### Initialize Audio System and Load Sounds (C)

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Initializes the audio subsystem and loads all sound effects from the game's embedded filesystem into memory. This setup is required before any sounds can be played, ensuring that audio assets are ready for playback. It configures the sample rate and number of audio buffers.

```c
#include "sound.h"

// Initialize audio subsystem (called once at startup)
audio_init(44100, 4); // 44.1kHz sample rate, 4 audio buffers

// Load sound files from embedded filesystem
sound_init();

// Internally loads:
// /sfx/A.raw     - Sound for A button (SOUND_A)
// /sfx/B.raw     - Sound for B button (SOUND_B)
// /sfx/C.raw     - Sound for C button (SOUND_C)
// /sfx/start.raw - Sound for Start button (SOUND_START)

// All sounds are 16-bit signed PCM at 44.1kHz
// Allocates audio buffer for mixing

```

--------------------------------

### Render Title Screen with Logo and Animation (C)

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Renders the game's title screen, displaying a logo and an animated 'press start' prompt. It initializes the filesystem, loads the logo sprite, sets up a timer for the animation, and handles player input to transition to the game. Dependencies include 'screens.h' and 'dfs.h'.

```c
#include "screens.h"
#include "dfs.h"

// Initialize filesystem and load logo sprite
dfs_init(DFS_DEFAULT_LOCATION);
sprite_t *logo = dfs_load("/gfx/logo.sprite");

// Create timer for press start animation
timer_link_t *timer_press_start = new_timer(TIMER_TICKS(500000), TF_CONTINUOUS, screen_timer_title);

display_context_t disp;
control_t keys = controls_get_keys();

while (!(disp = display_lock()));

// Render title screen
screen_title(disp, logo);

// Handle start button press
if (IS_DOWN(keys.start)) {
    delete_timer(timer_press_start);
    free(logo);
    game_set_level(1);
    screen = game;
}

display_show(disp);
```

--------------------------------

### Build Project from Source (Makefile)

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

This section details how to compile the Memory64 N64 project from source using the libdragon toolchain via Makefiles. It covers building the ROM file, using Docker for compilation if libdragon is not installed locally, running the ROM on the CEN64 emulator, and cleaning build artifacts.

```bash
# Build ROM file from source
make

# Output: Memory64.z64 (N64 ROM file)
# Compiles all .c files in src/ directory
# Links with libdragon library
# Processes sprites and sounds
# Packages filesystem into ROM
# Applies checksum for N64 bootloader

# Build using Docker (if libdragon not installed locally)
make docker

# Run on CEN64 emulator
export CEN64_DIR=/path/to/cen64
make cen64

# Clean build artifacts
make clean
# Removes: *.z64, *.elf, src/*.o, *.bin, *.dfs
```

--------------------------------

### Display Game Over Screen with Restart Option (C)

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Handles the display of the game over screen and provides an option for the player to restart the game. It renders a 'GAME OVER' message and waits for the start button input to reset the game state and return to the main game screen. Dependencies include 'screens.h'.

```c
#include "screens.h"

display_context_t disp;
screen_t screen = gameover;

while (true) {
    control_t keys = controls_get_keys();
    while (!(disp = display_lock()));

    switch (screen) {
        case gameover:
            screen_gameover(disp);

            // Wait for start button to restart
            if (IS_DOWN(keys.start)) {
                game_set_level(1);
                screen = game;
            }
            break;
    }

    display_show(disp);
}

// Renders dark gray background with "GAME OVER" text centered
```

--------------------------------

### Poll N64 Controller Input (C)

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Polls the Nintendo 64 controller to get the current state of all buttons. It provides macros to check button states like 'DOWN', 'HELD', 'UP', and 'PRESSED', enabling responsive game control and actions. This function is fundamental for player interaction.

```c
#include "controls.h"

// Main game loop input handling
control_t keys = controls_get_keys();

// Check button states using provided macros:
if (IS_DOWN(keys.Z)) {
    // Z button just pressed (single frame)
    show_fps = !show_fps;
    sound_play(SOUND_A);
}

if (IS_HELD(keys.start)) {
    // Start button is being held down
    // Useful for continuous actions
}

if (IS_UP(keys.start)) {
    // Start button was just released
    gameover = game_play_player(BUTTON_START);
}

if (IS_PRESSED(keys.A)) {
    // A button is down (either held or just pressed)
    // Visual feedback: highlight the button
    rdp_draw_filled_octagon_with_border(400, 220, 24, 24, colors[BGREEN], colors[BLACK]);
}

// Available buttons: keys.Z, keys.A, keys.B, keys.C, keys.start
// Button states: HELD (1), DOWN (2), UP (3)

```

--------------------------------

### Process Game Assets (Makefile)

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Instructions for processing and packaging audio and graphics assets for the Memory64 N64 project using Makefiles. This includes commands to convert sprite graphics (e.g., PNG to .sprite format) and audio files (e.g., AIFF to raw PCM), as well as how all assets are automatically packaged into the ROM filesystem.

```bash
# Process sprite graphics
make sprites
# Converts resources/gfx/logo.png to filesystem/gfx/logo.sprite
# Format: 16-bit, 1-bit alpha, 9 frames for animation

# Process audio files
make sounds
# Converts AIFF audio to raw PCM:
# resources/sfx/A.aiff → filesystem/sfx/A.raw
# resources/sfx/B.aiff → filesystem/sfx/B.raw
# resources/sfx/C.aiff → filesystem/sfx/C.raw
# resources/sfx/start.aiff → filesystem/sfx/start.raw
# Format: 16-bit signed integer, big-endian, 44.1kHz, mono

# All assets automatically packaged by main build:
make Memory64.dfs
# Creates filesystem bundle with sprites and sounds
# Embedded in ROM at 1MB offset
```

--------------------------------

### Render Gameplay Screen and Handle Game Logic (C)

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Manages the main gameplay loop, rendering the game screen, visualizing controller input, and processing game logic. It continuously checks for controller input, updates the display, and handles game state transitions, including a game over condition. Dependencies include 'screens.h'.

```c
#include "screens.h"

display_context_t disp;
screen_t screen = game;
bool gameover = false;

while (true) {
    control_t keys = controls_get_keys();
    while (!(disp = display_lock()));

    if (screen == game) {
        // Render game screen and process input
        gameover = screen_game(disp, keys);

        if (gameover) {
            screen = gameover;
        }
    }

    display_show(disp);
    sound_frame();
}

// screen_game handles:
// - Drawing controller representation
// - Highlighting buttons during AI sequence
// - Processing player button presses
// - Validating against expected sequence
// - Triggering rumble pak
// - Displaying score and turn indicator
// Returns true if player made mistake (game over)
```

--------------------------------

### Initialize Game Color Palette (C)

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Initializes the global color palette used throughout the game. It sets up display parameters and populates a color array with 12 predefined colors for UI elements, buttons, and highlights. This function should be called once during initialization. Dependencies include 'colors.h'.

```c
#include "colors.h"

// Called once during initialization (before rendering)
init_interrupts();
display_init(RESOLUTION_640x480, DEPTH_16_BPP, 2, GAMMA_NONE, ANTIALIAS_RESAMPLE);
colors_init();

// Initializes global color array with 12 predefined colors:
// BLACK, DGRAY, LGRAY - Grayscale UI colors
// RED, BRED - Start button colors (normal/bright)
// GREEN, BGREEN - B button colors
// BLUE, BBLUE - A button colors
// YELLOW, BYELLOW - C button colors
// WHITE - Highlights and borders

// Access colors via global array:
extern uint32_t colors[NUM_COLORS];
rdp_draw_filled_rectangle(0, 0, 640, 480, colors[DGRAY]);
```

--------------------------------

### Mix and Output Audio Samples - C

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Mixes and outputs audio samples to the hardware. This function must be called every frame within the main game loop to handle audio buffer readiness, sound mixing, playback cursor advancement, and hardware output.

```c
#include "sound.h"

// Main game loop structure
while (true) {
    // ... game logic and rendering ...

    display_show(disp);

    // Must call every frame to output audio
    sound_frame();

    // Handles:
    // - Checking if audio buffer is ready for new samples
    // - Mixing all active sounds into stereo output
    // - Advancing sound playback cursors
    // - Writing final samples to hardware
}
```

--------------------------------

### Display No Controller Warning Screen (C)

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Checks for controller presence on port 1 and displays a warning message if no controller is detected. The game cannot proceed without a controller, so this screen prevents further execution until a controller is inserted. Dependencies include 'screens.h'.

```c
#include "screens.h"

display_context_t disp;

while (true) {
    while (!(disp = display_lock()));

    // Check if controller is inserted
    if (!(get_controllers_present() & CONTROLLER_1_INSERTED)) {
        screen_no_controller(disp);
    } else {
        // Normal game logic
        control_t keys = controls_get_keys();
        // ... handle input ...
    }

    display_show(disp);
}

// Displays: "NO CONTROLLER INSERTED ON PORT #1"
// Game cannot proceed without controller
```

--------------------------------

### Sound Playback API

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Functions for playing sound effects and processing audio frames.

```APIDOC
## POST /sound_play

### Description
Triggers a sound effect to begin playing. This function is used to play various sound effects at different points in the game logic, such as button presses or sequence demonstrations. Sounds play asynchronously.

### Method
POST

### Endpoint
/sound_play

### Parameters
#### Query Parameters
- **sound_id** (SOUND_TYPE) - Required - Identifier for the sound effect to play.

### Request Body
None

### Response
#### Success Response (200)
- **status** (string) - Indicates success.

#### Response Example
```json
{
  "status": "success"
}
```

## POST /sound_frame

### Description
Mixes and outputs audio samples to the hardware. This function must be called every frame in the main loop to ensure audio is processed and played correctly. It handles buffer readiness, sound mixing, playback cursor advancement, and writing samples to hardware.

### Method
POST

### Endpoint
/sound_frame

### Parameters
None

### Request Body
None

### Response
#### Success Response (200)
- **status** (string) - Indicates success.

#### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### Play Sound Effect - C

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Triggers a sound effect to play. Supports playing sounds on button presses or during specific game events like AI sequence demonstrations. Sounds are mixed and output asynchronously in `sound_frame()`.

```c
#include "sound.h"

// Play sound when player presses button
if (IS_UP(keys.A)) {
    sound_play(SOUND_A);
    gameover = game_play_player(BUTTON_A);
}

// Play sound during AI sequence demonstration
switch (game.notes[game.current]) {
    case BUTTON_START:
        sound_play(SOUND_START);
        break;
    case BUTTON_A:
        sound_play(SOUND_A);
        break;
    case BUTTON_B:
        sound_play(SOUND_B);
        break;
    case BUTTON_C:
        sound_play(SOUND_C);
        break;
}

// Sounds play asynchronously, mixed in sound_frame()
```

--------------------------------

### Initialize or Advance Game Level (C)

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Initializes or advances the game to a new level by increasing the sequence length. It sets up a timer for sequence playback and handles score updates and advancement to the next level upon successful completion. This function is crucial for managing game difficulty progression.

```c
#include "game.h"

// Start a new game at level 1
game_set_level(1);

// The function initializes a random sequence of 256 notes
// Sets the sequence size to the specified level
// Creates a timer that plays back the sequence at 500ms intervals
// Example: Level 1 = 1 button to remember, Level 5 = 5 buttons to remember

// After player successfully completes a level, advance to next:
if (game.current == game.size) {
    game.score++;
    if (game.score > game.best) {
        game.best = game.score;
    }
    game_set_level(game.size + 1); // Increment difficulty
}
```

--------------------------------

### Graphics Rendering API

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Functions for drawing various shapes and text elements to the display buffer.

```APIDOC
## POST /graphics_draw_circle

### Description
Draws a circle or a filled circle at a specified position with a given color and fill status.

### Method
POST

### Endpoint
/graphics_draw_circle

### Parameters
#### Request Body
- **disp** (display_context_t) - Required - The display context.
- **x** (int) - Required - The X-coordinate of the circle's center.
- **y** (int) - Required - The Y-coordinate of the circle's center.
- **radius** (int) - Required - The radius of the circle in pixels.
- **color** (Color) - Required - The color of the circle.
- **filled** (bool) - Required - Whether to fill the circle.

### Request Example
```json
{
  "disp": "display_context_data",
  "x": 320,
  "y": 240,
  "radius": 50,
  "color": "RED",
  "filled": true
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates success.

#### Response Example
```json
{
  "status": "success"
}
```

## POST /graphics_draw_circle_with_border

### Description
Draws a filled circle with a contrasting border for improved visibility, often used for buttons or UI elements to create a 3D effect.

### Method
POST

### Endpoint
/graphics_draw_circle_with_border

### Parameters
#### Request Body
- **disp** (display_context_t) - Required - The display context.
- **x** (int) - Required - The X-coordinate of the circle's center.
- **y** (int) - Required - The Y-coordinate of the circle's center.
- **radius** (int) - Required - The radius of the circle in pixels.
- **fill_color** (Color) - Required - The fill color of the circle.
- **border_color** (Color) - Required - The color of the border.

### Request Example
```json
{
  "disp": "display_context_data",
  "x": 400,
  "y": 220,
  "radius": 24,
  "fill_color": "GREEN",
  "border_color": "BLACK"
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates success.

#### Response Example
```json
{
  "status": "success"
}
```

## POST /graphics_draw_box_with_border

### Description
Draws a filled rectangle with a border, suitable for UI elements like score displays or panels.

### Method
POST

### Endpoint
/graphics_draw_box_with_border

### Parameters
#### Request Body
- **disp** (display_context_t) - Required - The display context.
- **x** (int) - Required - The X-coordinate of the top-left corner of the box.
- **y** (int) - Required - The Y-coordinate of the top-left corner of the box.
- **width** (int) - Required - The width of the box in pixels.
- **height** (int) - Required - The height of the box in pixels.
- **fill_color** (Color) - Required - The fill color of the box.
- **border_color** (Color) - Required - The color of the border.

### Request Example
```json
{
  "disp": "display_context_data",
  "x": 20,
  "y": 20,
  "width": 600,
  "height": 18,
  "fill_color": "DGRAY",
  "border_color": "BLACK"
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates success.

#### Response Example
```json
{
  "status": "success"
}
```

## POST /graphics_draw_textf

### Description
Draws formatted text to the display buffer using printf-style formatting. This allows for dynamic text rendering with various data types.

### Method
POST

### Endpoint
/graphics_draw_textf

### Parameters
#### Request Body
- **disp** (display_context_t) - Required - The display context.
- **x** (int) - Required - The X-coordinate for the text's starting position.
- **y** (int) - Required - The Y-coordinate for the text's starting position.
- **format** (string) - Required - The format string (e.g., "SCORE: %04d").
- **args** (list) - Optional - Arguments to be formatted into the string.

### Request Example
```json
{
  "disp": "display_context_data",
  "x": 25,
  "y": 26,
  "format": "SCORE: %04d",
  "args": [1234]
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates success.

#### Response Example
```json
{
  "status": "success"
}
```

## POST /graphics_draw_text_center

### Description
Draws text centered horizontally at a specified X coordinate. This is useful for titles, game over messages, or other centrally aligned text elements.

### Method
POST

### Endpoint
/graphics_draw_text_center

### Parameters
#### Request Body
- **disp** (display_context_t) - Required - The display context.
- **x** (int) - Required - The X-coordinate at which to center the text.
- **y** (int) - Required - The Y-coordinate for the text's position.
- **text** (string) - Required - The text string to draw.

### Request Example
```json
{
  "disp": "display_context_data",
  "x": 320,
  "y": 230,
  "text": "GAME OVER"
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates success.

#### Response Example
```json
{
  "status": "success"
}
```
```

--------------------------------

### Retrieve Current Game State (C)

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Retrieves the current game state structure, which holds all relevant game data including the button sequence, current position, score, and timer status. This function allows access to game variables for display or logic checks. It's essential for rendering UI elements and managing game flow.

```c
#include "game.h"

game_t game = game_get();

// Access game state fields:
// game.notes[256]  - The sequence of buttons (0=START, 1=A, 2=B, 3=C)
// game.current     - Current position in the sequence
// game.size        - Length of current sequence to play
// game.score       - Current score (successful levels completed)
// game.best        - Best score achieved in session
// game.pause       - Whether AI is paused between button displays
// game.timer_IA    - Timer handle for AI playback (NULL when player's turn)

// Example: Display score
graphics_draw_textf(disp, 25, 26, "SCORE: %04d", game.score);
graphics_draw_textf(disp, 536, 26, "BEST: %04d", game.best);

// Check if it's player's turn
if (game.timer_IA == NULL) {
    // Player can input buttons
    rumble_stop(0);
} else {
    // AI is showing sequence
}
```

--------------------------------

### Validate Player Input and Handle Scoring (C)

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Validates a player's button press against the game's expected sequence and manages scoring. It returns true if the input is incorrect, triggering a game over, or false if correct, advancing the player's position in the sequence. This function is central to the core gameplay loop.

```c
#include "game.h"

// When player presses a button, validate it:
bool gameover = false;

if (IS_UP(keys.start)) {
    gameover = game_play_player(BUTTON_START);
}
else if (IS_UP(keys.A)) {
    gameover = game_play_player(BUTTON_A);
}
else if (IS_UP(keys.B)) {
    gameover = game_play_player(BUTTON_B);
}
else if (IS_UP(keys.C)) {
    gameover = game_play_player(BUTTON_C);
}

// Function returns true if wrong button pressed (game over)
// Returns false if correct, advances position in sequence
// Automatically advances to next level when sequence completed
// Resets score to 0 on wrong input

if (gameover) {
    screen = gameover;
    // Display game over screen
}
```

--------------------------------

### Retrieve FPS Value (C)

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

This C code snippet demonstrates how to retrieve the current frames per second (FPS) value in the Memory64 N64 project. It includes logic to toggle the FPS display using the Z button and draws the FPS text on the screen if enabled. The expected FPS on real N64 hardware is around 60, with lower values indicating performance issues.

```c
#include "fps.h"

bool show_fps = false;
display_context_t disp;

while (true) {
    control_t keys = controls_get_keys();

    // Toggle FPS display with Z button
    if (IS_DOWN(keys.Z)) {
        show_fps = !show_fps;
        sound_play(SOUND_A);
    }

    while (!(disp = display_lock()));

    // ... render game ...

    fps_frame();

    if (show_fps) {
        uint8_t current_fps = fps_get();
        graphics_draw_textf(disp, 5, 5, "FPS: %d", current_fps);

        // Expected: ~60 FPS on real N64 hardware
        // Lower values indicate performance issues
    }

    display_show(disp);
}
```

--------------------------------

### Draw Formatted Text - C

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Draws formatted text to the display buffer using printf-style formatting. This function allows for dynamic text rendering, including numbers with specific padding, strings, and hexadecimal values. It is essential for displaying scores, messages, and other dynamic information on the screen.

```c
#include "graphics.h"

display_context_t disp;
while (!(disp = display_lock()));
game_t game = game_get();

// Draw score with formatting
graphics_draw_textf(disp, 25, 26, "SCORE: %04d", game.score);
// Position: (25, 26), Format: Zero-padded 4-digit score

// Draw best score
graphics_draw_textf(disp, 536, 26, "BEST: %04d", game.best);

// Show FPS counter
if (show_fps) {
    graphics_draw_textf(disp, 5, 5, "FPS: %d", fps_get());
}

// Supports standard printf format specifiers:
// %d (int), %04d (zero-padded), %s (string), %x (hex)
display_show(disp);
```

--------------------------------

### Retrieve Color Value from Palette (C)

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Provides a function to retrieve a color value from the initialized color palette by its index. This offers an alternative to direct array access for accessing predefined colors. It's used in drawing operations for various graphical elements. Dependencies include 'colors.h'.

```c
#include "colors.h"

// Alternative to direct array access
uint32_t bg_color = colors_get(DGRAY);
uint32_t button_color = colors_get(RED);

// Equivalent to:
uint32_t bg_color = colors[DGRAY];
uint32_t button_color = colors[RED];

// Use for drawing operations:
rdp_draw_filled_rectangle_size(0, 0, 640, 480, colors_get(LGRAY));
graphics_draw_circle(disp, 320, 240, 50, colors_get(BLUE), true);

// Available color constants:
// BLACK (0), DGRAY (1), LGRAY (2)
// RED (3), BRED (4), GREEN (5), BGREEN (6)
// BLUE (7), BBLUE (8), YELLOW (9), BYELLOW (10), WHITE (11)
```

--------------------------------

### Draw Circle or Filled Circle - C

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Draws a circle or a filled circle on the display buffer at a specified position with a given color. It can be used for various visual elements like buttons, indicators, or joystick representations. The `filled` parameter determines if the circle is solid or an outline.

```c
#include "graphics.h"

display_context_t disp;
while (!(disp = display_lock()));

// Draw filled circle (for buttons, visual elements)
graphics_draw_circle(disp, 320, 240, 50, colors[RED], true);
// Position: (320, 240), Radius: 50px, Color: RED, Filled: true

// Draw circle outline only
graphics_draw_circle(disp, 400, 300, 30, colors[BLUE], false);
// Creates hollow circle useful for selection indicators

// Example: Draw joystick visual representation
graphics_draw_circle(disp, 320, 340, 60, colors[DGRAY], true);
graphics_draw_circle(disp, 320, 340, 26, colors[WHITE], true);
graphics_draw_circle(disp, 320, 340, 18, colors[WHITE], true);

display_show(disp);
```

--------------------------------

### Update Frame Counter for FPS Calculation (C)

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Updates the internal frame counter used for calculating Frames Per Second (FPS). This function is intended to be called every frame within the main game loop. A separate timer callback resets the counter periodically to provide accurate FPS readings. Dependencies include 'fps.h'.

```c
#include "fps.h"

// Initialize FPS timer during startup
timer_init();
new_timer(TIMER_TICKS(1000000), TF_CONTINUOUS, fps_timer);
// Timer fires every 1 second to calculate FPS

// Main game loop
while (true) {
    control_t keys = controls_get_keys();
    while (!(disp = display_lock()));

    // ... render game ...

    fps_frame(); // Increment frame counter

    // Optionally display FPS
    if (show_fps) {
        graphics_draw_textf(disp, 5, 5, "FPS: %d", fps_get());
    }

    display_show(disp);
}

// fps_frame() increments internal counter
// fps_timer() callback resets counter every second
// fps_get() returns calculated frames per second
```

--------------------------------

### Draw Circle with Border - C

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Draws a filled circle with a contrasting border, enhancing visibility and creating a 3D effect for UI elements like buttons. The border is always 2 pixels thick and drawn on the outside of the specified radius. This function is useful for interactive elements that change color when pressed.

```c
#include "graphics.h"

display_context_t disp;
while (!(disp = display_lock()));

// Draw button with border (creates 3D effect)
graphics_draw_circle_with_border(disp, 400, 220, 24, colors[GREEN], colors[BLACK]);
// Draws filled green circle with 2px black border

// When button is pressed, use bright color:
if (IS_PRESSED(keys.A)) {
    graphics_draw_circle_with_border(disp, 400, 220, 24, colors[BGREEN], colors[BLACK]);
} else {
    graphics_draw_circle_with_border(disp, 400, 220, 24, colors[GREEN], colors[BLACK]);
}

// Border is always 2px thick, drawn on outside of specified radius
display_show(disp);
```

--------------------------------

### Draw Box with Border - C

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Draws a filled rectangle with a border, suitable for UI elements such as score displays or panels. The border is 2 pixels thick and drawn inside the specified dimensions. It allows for distinct visual separation of UI components.

```c
#include "graphics.h"

display_context_t disp;
while (!(disp = display_lock()));

// Draw score display box
graphics_draw_box_with_border(disp, 20, 20, 600, 18, colors[DGRAY], colors[BLACK]);
// Position: (20, 20), Size: 600x18px, Fill: Dark gray, Border: Black

// Draw UI panel
graphics_draw_box_with_border(disp, 100, 100, 440, 280, colors[LGRAY], colors[WHITE]);

// Border is 2px thick on all sides, drawn inside the specified dimensions
display_show(disp);
```

--------------------------------

### Draw Centered Text - C

Source: https://context7.com/vrgl117-games/memory64-n64/llms.txt

Draws text centered horizontally at a specified X coordinate. This is useful for titles, messages, or indicators that need to be precisely positioned in the middle of the screen or other designated areas. The centering is based on character width (6 pixels per character).

```c
#include "graphics.h"

display_context_t disp;
while (!(disp = display_lock()));

// Center text at screen center (640x480 resolution)
graphics_draw_text_center(disp, 320, 230, "GAME OVER");
// X: 320 (horizontal center), Y: 230, Text: "GAME OVER"

// Show player turn indicator
game_t game = game_get();
if (game.timer_IA == NULL) {
    graphics_draw_text_center(disp, 320, 26, "< PLAYER >");
} else {
    graphics_draw_text_center(disp, 320, 26, "<<< IA >>>");
}

// Blinking "press start" message
if (tick % 2) {
    graphics_draw_text_center(disp, 320, 436, "PRESS START");
}

// Text is automatically centered based on character width (6px per char)
display_show(disp);
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.