VERIFICATION

Purpose: See which letters, digits and punctuation marks the supplied original font contains and how to draw them.

How it works: m_init prepares the display and font. m_text draws each row; m_put draws the double quote using character code 34.

Controls and expected result: Look for 26 uppercase letters, 26 lowercase letters, 10 digits and 30 punctuation marks. Check that every glyph is legible. No input is required.

Purpose: Learn the basic sequence for starting a ROM and drawing text and a number on the background.

How it works: After m_init, m_text draws the greeting and m_number formats 42. The final loop waits for frames while leaving the screen visible.

Controls and expected result: The screen shows HELLO WORLD and 042. The leading zero is three-digit decimal formatting.

Purpose: Learn to keep an intermediate result that does not fit in eight bits.

How it works: (u16)200 + 100 produces 300. The program divides it by 10, then converts the result to u8 for display. Notice that the widening cast precedes the addition.

Controls and expected result: 030 represents the calculated result, 30.

Purpose: Try for, continue, while, do/while and switch in a small calculation.

How it works: Adding 0 through 7 while skipping 3 gives 25. The while loop advances to 30, do/while advances to 32, and switch selects case 32 to assign 42.

Controls and expected result: 042 is the final result of these loops and branches.

Purpose: Learn to group values and access them through functions and pointers.

How it works: The program copies a Point containing (10,20), then writes 1 through 4 into an array through a pointer. It adds the function result 30 to array values 1, 2 and 4 and the constant 5.

Controls and expected result: The sum is displayed as 042. Follow the structure copy, the ptr[i] writes and the function return value.

Purpose: Pack flags into a byte and copy a buffer into separate storage.

How it works: __memset clears four bytes. The program sets bit 3, toggles bit 1, then copies all four bytes with __memcpy.

Controls and expected result: The first destination byte is displayed as 010: bit 3 contributes 8 and bit 1 contributes 2.

Purpose: Distinguish a newly pressed button from one that remains held.

How it works: Each frame calls input_update. The counter advances only when input_pressed(BTN_A) is true.

Controls and expected result: The initial count is 000. Press A to get 001; holding it does not add more. Release and press again for 002. The byte counter wraps from 255 to 000.

Purpose: Learn integer-to-Q8.8 conversion, multiplication and conversion back to an integer.

How it works: fix_from_int converts 3 and 4 to Q8.8. fix_mul multiplies them, and fix_to_int converts the product back.

Controls and expected result: 012 means 3 × 4 = 12. It is the converted integer, not the internal value scaled by 256.

Purpose: Create an object from a fixed set of slots without dynamic allocation.

How it works: entity_init resets the pool. entity_create creates type 1 at (20,30); the program checks for the failure ID 0xFF before setting vx to 2.

Controls and expected result: 001 is the active object count, not an ID or coordinate. This example does not update or draw the object, so no moving character appears.

Purpose: Keep a named game value in a diagnostic buffer separately from the screen display.

How it works: The program initializes debugging, sets frame tag 1 and records the value 42 under the name HP.

Controls and expected result: 001 is the number of trace entries. HP=42 is stored in the diagnostic buffer; the screen alone does not show or verify that payload.

Purpose: Learn how to store a trail of positions in a ring buffer.

How it works: chain_init attaches an array with room for four points. chain_push_head then records (20,30).

Controls and expected result: 042 is a fixed completion marker, not a coordinate or count. Inspect trail and points to check the stored history. This program does not draw a following body.

Purpose: See how counted frame waits affect the library frame counter.

How it works: After system_init, the program calls system_wait_vblank twice and displays system_get_frame8.

Controls and expected result: The result is 002. The idle loop uses the manual helper m_wait, so the displayed value does not keep increasing.

Purpose: Learn to select an ID that can distinguish scenes such as a title screen and gameplay.

How it works: The program registers two zero-initialized SceneDef entries and selects ID 1 with scene_change.

Controls and expected result: 001 is the current ID returned by scene_get_current. No scene callbacks or transition drawing are registered in this example.

Purpose: See which letters, digits and punctuation marks the supplied original font contains and how to draw them.

How it works: m_init prepares the display and font. m_text draws each row; m_put draws the double quote using character code 34.

Controls and expected result: Look for 26 uppercase letters, 26 lowercase letters, 10 digits and 30 punctuation marks. Check that every glyph is legible. No input is required.

Purpose: Learn the basic sequence for starting a ROM and drawing text and a number on the background.

How it works: After m_init, m_text draws the greeting and m_number formats 42. The final loop waits for frames while leaving the screen visible.

Controls and expected result: The screen shows HELLO WORLD and 042. The leading zero is three-digit decimal formatting.

Purpose: Learn to keep an intermediate result that does not fit in eight bits.

How it works: (u16)200 + 100 produces 300. The program divides it by 10, then converts the result to u8 for display. Notice that the widening cast precedes the addition.

Controls and expected result: 030 represents the calculated result, 30.

Purpose: Try for, continue, while and if/else in a small calculation.

How it works: The for loop skips 3 while adding 0 through 7, producing 25. The while loop advances to 32; the following if assigns 42 when that value matches.

Controls and expected result: 042 is the final result. This program uses an if/else branch.

Purpose: Learn to group values and access them through functions and pointers.

How it works: The program copies a Point containing (10,20), then writes 1 through 4 into an array through a pointer. It adds the function result 30 to array values 1, 2 and 4 and the constant 5.

Controls and expected result: The sum is displayed as 042. Follow the structure copy, the ptr[i] writes and the function return value.

Purpose: Pack flags into a byte and copy a buffer into separate storage.

How it works: __memset clears four bytes. The program sets bit 3, toggles bit 1, then copies all four bytes with __memcpy.

Controls and expected result: The first destination byte is displayed as 010: bit 3 contributes 8 and bit 1 contributes 2.

Purpose: Distinguish a newly pressed button from one that remains held.

How it works: Each frame calls input_update. The counter advances only when input_pressed(BTN_A) is true.

Controls and expected result: The initial count is 000. Press A to get 001; holding it does not add more. Release and press again for 002. The byte counter wraps from 255 to 000.

Purpose: Learn integer-to-Q8.8 conversion, multiplication and conversion back to an integer.

How it works: fix_from_int converts 3 and 4 to Q8.8. fix_mul multiplies them, and fix_to_int converts the product back.

Controls and expected result: 012 means 3 × 4 = 12. It is the converted integer, not the internal value scaled by 256.

Purpose: Create an object from a fixed set of slots without dynamic allocation.

How it works: entity_init resets the pool. entity_create creates type 1 at (20,30); the program checks for the failure ID 0xFF before setting vx to 2.

Controls and expected result: 001 is the active object count, not an ID or coordinate. This example does not update or draw the object, so no moving character appears.

Purpose: Keep a named game value in a diagnostic buffer separately from the screen display.

How it works: The program initializes debugging, sets frame tag 1 and records the value 42 under the name HP.

Controls and expected result: 001 is the number of trace entries. HP=42 is stored in the diagnostic buffer; the screen alone does not show or verify that payload.

Purpose: Learn how to store a trail of positions in a ring buffer.

How it works: chain_init attaches an array with room for four points. chain_push_head then records (20,30).

Controls and expected result: 042 is a fixed completion marker, not a coordinate or count. Inspect trail and points to check the stored history. This program does not draw a following body.

Purpose: See how counted frame waits affect the library frame counter.

How it works: After system_init, the program calls system_wait_vblank twice and displays system_get_frame8.

Controls and expected result: The result is 002. The idle loop uses the manual helper m_wait, so the displayed value does not keep increasing.

Purpose: Learn to select an ID that can distinguish scenes such as a title screen and gameplay.

How it works: The program registers two zero-initialized SceneDef entries and selects ID 1 with scene_change.

Controls and expected result: 001 is the current ID returned by scene_get_current. No scene callbacks or transition drawing are registered in this example.

Purpose: Subtract the camera position to find where a world position belongs on screen.

How it works: Camera_Set receives Q8.8 value 2560, or X=10 pixels. Camera_WorldToScreenX then converts world X=52.

Controls and expected result: 052 minus 010 gives the displayed 042. This is a coordinate calculation; it does not scroll a background.

Purpose: Try a compact count/value representation of repeated bytes.

How it works: The packed bytes {3,42,0} mean three copies of 42 followed by a zero-count terminator. rle_decode writes into a three-byte destination.

Controls and expected result: The last byte, out[2], is displayed as 042. All three decoded bytes are expected to contain 42.

Purpose: Learn how grid coordinates map to storage for a board game.

How it works: A 16-byte array backs a 4 × 4 board. The program clears it, writes 42 at cell (2,1), then reads the same cell.

Controls and expected result: 042 is the value read back. The program does not draw the 4 × 4 board itself.

Purpose: Initialize a world and box body, then update position from velocity.

How it works: The body starts at (40,40), with velocity (2,0) and zero gravity. The program calls kq2d_step once.

Controls and expected result: 042 is the resulting X coordinate, measured in integer pixels in this example. No box shape or continuous animation is drawn.

Purpose: Distinguish a completed transfer from one that does not finish within the wait limit.

How it works: The master sends 42 and waits with Link_WaitByte. Completion displays the received byte; timeout cancels the transfer and displays zero.

Controls and expected result: An unconnected transfer that completes can return 255. A timeout displays 000; with a connected peer, the display shows its received byte. The result is not always 042.

Purpose: Learn the arguments for copying ROM data into RAM.

How it works: far_data_read copies the two bytes 7 and 42 into copied, using bank argument 0 and a length of 2.

Controls and expected result: The second destination byte is displayed as 042. This example reads fixed ROM; it does not demonstrate transfer between different switchable banks.

Purpose: Register an asset location and length, then retrieve the bytes by ID.

How it works: Asset 0 has type RAW, bank 0, a pointer to {7,42} and length 2. asset_load_raw copies it into a two-byte RAM buffer.

Controls and expected result: The second byte is displayed as 042. This demonstrates asset lookup and copying, not image rendering.

Purpose: Initialize the bullet pool and inspect its occupancy after spawning.

How it works: After danmaku_reset, the program calls danmaku_spawn(40,40,16,0) and displays dm_count.

Controls and expected result: 001 is the number of allocated bullets. There is no bullet update loop or background compositor here, so no moving bullet is drawn.

Purpose: Keep subpixel motion as a remainder and carry whole pixels into the position.

How it works: Starting at X=40, the loop adds 2/8 pixel eight times. A right shift extracts whole pixels; a mask retains the remainder.

Controls and expected result: The total motion is two pixels, so the screen shows X=42 as 042. This manual integration example handles positive motion; negative motion needs a matching borrow path.

Purpose: Choose background and text colors using Game Boy Color RGB components.

How it works: The program disables the LCD during VBlank, sets palette 0 color 0 to white (31,31,31) and color 3 to purple (12,0,22), then enables the display.

Controls and expected result: Run in CGB mode to see purple text and 042 on white. DMG monochrome output cannot demonstrate these colors.

Purpose: Move the viewing position without redrawing the background contents.

How it works: Each frame increments phase and passes it to Scroll_SetBg. The eight-bit position wraps after 255.

Controls and expected result: The word SCROLL moves left. Observe its position over time; a single screenshot cannot show the motion.

Purpose: Separate a drawing request from the VRAM transfer that applies it.

How it works: vram_queue_bg_tile queues tile 52 at tile coordinate (3,8), and vram_flush transfers it. In the supplied font, tile 52 is the digit 4.

Controls and expected result: Look for a single 4 at background tile coordinate (3,8). It is a tile update, not a numeric counter.

Purpose: Allocate and display a sprite independently of the background.

How it works: The fresh pool supplies slot 0. The program selects tile 65, sets position (70,80), enables OBJ display and transfers shadow OAM each frame.

Controls and expected result: A stationary letter A appears at the specified sprite position. In a game, check allocation failure before using the returned ID.

Purpose: Use a seed to reproduce a pseudorandom sequence.

How it works: rng_seed(1234) initializes the generator, then rng_range(10) is called once. Its upper bound, 10, is excluded.

Controls and expected result: The screen shows a value from 000 to 009. Restarting the same program with the same seed reproduces it; the value does not change every frame.

Purpose: Represent a Boolean state, such as whether an event is complete, using a flag number.

How it works: The program clears flag 12, sets it and reads it back with flag_get.

Controls and expected result: 001 means flag 12 is true. This example operates on RAM flags and does not save them across power cycles.

Purpose: Set up a circular body and update its position from velocity.

How it works: The active circle has radius 4, position (40,40) and velocity (2,0). Gravity is zero and linear_damping_q8 is 255; kq2dc_step runs once.

Controls and expected result: 042 is the resulting integer X coordinate. This example does not draw a circle outline or collision animation.

Purpose: Move the background by updating the PPU scroll position.

How it works: Starting at __scroll_set(0,0), the program increments phase once per frame and uses it as the horizontal position.

Controls and expected result: The word SCROLL changes horizontal position. phase wraps from 255 to 0. This is not a wide-map example spanning multiple nametables.

Purpose: Submit a PPU update from the main program for the NMI path to apply.

How it works: __vramq_put queues tile 52 at nametable address 0x2103, and __vramq_commit submits it. That address corresponds to tile coordinate (3,8).

Controls and expected result: A single 4 appears at background coordinate (3,8). Tile 52 is the digit 4 in the supplied font.

Purpose: Prepare sprite colors and OAM data to draw an image independently of the background.

How it works: The program loads the sprite palette, sets slot 0 to position (70,80), tile 65 and attributes 0, enables rendering and repeats OAM DMA.

Controls and expected result: A stationary letter A appears as a sprite. The example demonstrates OAM setup and transfer, not animation.

Purpose: Set the built-in NES pulse channel control, timer and length values.

How it works: After nes_apu_init, the program calls nes_sfx_square1(0xBF,400,20). Control 0xBF selects constant volume and halts the length counter, so the tone sustains. The value 20 is a length-table index, not 20 frames.

Controls and expected result: A sustained pulse tone plays while 042 is displayed. Call nes_apu_silence_all to stop it. The displayed marker alone does not verify sound output.

Purpose: Start a sound-effect stream and advance it through regular frame updates.

How it works: After Audio_Init, Audio_PlaySFX starts tone on channel ID 1. The main loop calls Audio_Update once per frame.

Controls and expected result: A short pulse effect plays while 042 remains visible. That number is a fixed marker, not volume or playback position. Use audio output or a recording to assess the sound.