### Draw inventory weight overlay in C

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Example implementation showing how to draw a colored weight indicator above the inventory panel. Uses dotx/doty to position the overlay and calculates weight based on character strength.

```c
void amod_frame(void) {
    int inv_x = dotx(DOT_INV);
    int inv_y = doty(DOT_INV);

    if (inv_x > 0 && inv_y > 0) {
        // Draw weight indicator above inventory
        int current_weight = calculate_inventory_weight();
        int max_weight = value[0][V_STR] * 100;

        unsigned short color;
        if (current_weight > max_weight * 0.9) {
            color = IRGB(31, 0, 0);  // Red - overweight
        } else if (current_weight > max_weight * 0.7) {
            color = IRGB(31, 31, 0);  // Yellow - heavy
        } else {
            color = IRGB(0, 31, 0);  // Green - OK
        }

        dd_drawtext_fmt(inv_x, inv_y - 20, color, DD_LEFT | DD_SHADE,
                       "Weight: %d/%d", current_weight, max_weight);
    }
}

int calculate_inventory_weight(void) {
    int total = 0;
    for (int i = 0; i < INVENTORYSIZE; i++) {
        if (item[i]) {
            // Request item info if needed, or use cached data
            total += 10;  // Simplified weight
        }
    }
    return total;
}
```

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

### Draw minimap markers in C

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Example showing how to draw dynamic markers on the game minimap. Calculates scaled positions from map coordinates and renders pulsing quest objective indicators.

```c
void draw_minimap_overlay(void) {
    int map_tl_x = dotx(DOT_MTL);
    int map_tl_y = doty(DOT_MTL);
    int map_br_x = dotx(DOT_MBR);
    int map_br_y = doty(DOT_MBR);

    if (map_tl_x > 0 && map_br_x > 0) {
        int map_width = map_br_x - map_tl_x;
        int map_height = map_br_y - map_tl_y;

        // Draw quest objective marker
        int objective_x = 35;  // Map coordinates
        int objective_y = 40;

        // Scale to minimap
        int marker_x = map_tl_x + (objective_x * map_width / MAPDX);
        int marker_y = map_tl_y + (objective_y * map_height / MAPDY);

        // Draw pulsing marker
        int pulse = (current_time / 100) % 20;
        unsigned short marker_color = IRGB(31, pulse, 0);

        dd_rect(marker_x - 2, marker_y - 2, marker_x + 2, marker_y + 2,
                marker_color);
        dd_drawtext(marker_x + 5, marker_y - 5, marker_color, DD_LEFT | DD_SMALL,
                   "Quest");
    }
}
```

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

### Draw Sprites - Basic Parameters (C)

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Renders sprites to screen using basic parameters including screen coordinates, lighting level, and alignment mode. The function provides three alignment options (offset, center, normal) and 32 lighting levels from brightest to darkest. Dependencies include the game.h header and display driver functions. Example demonstrates drawing a player character with an equipped item and shadow effect.

```c
// Draw sprite with simple parameters
void dd_copysprite(int sprite, int scrx, int scry, int light, int align);

// Alignment constants
#define DD_OFFSET 0    // Draw from top-left
#define DD_CENTER 1    // Draw centered
#define DD_NORMAL 2    // Draw from sprite origin

// Lighting constants
#define DDFX_NLIGHT 15     // Normal lighting
#define DDFX_BRIGHT 0      // Brightest
#define DDFX_DARK 31       // Darkest

// Example: Draw character sprite and item
#include "game.h"

void draw_player_and_item(void) {
    int player_sprite = 52000;  // Player sprite ID
    int sword_sprite = 10450;   // Sword item sprite
    int x = 400, y = 300;       // Screen position

    // Draw centered player with normal lighting
    dd_copysprite(player_sprite, x, y, DDFX_NLIGHT, DD_CENTER);

    // Draw sword above player, slightly offset
    dd_copysprite(sword_sprite, x + 20, y - 40, DDFX_NLIGHT, DD_CENTER);

    // Draw shadow beneath (darker, offset sprite)
    dd_copysprite(player_sprite, x + 5, y + 5, 25, DD_CENTER);
}
```

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

### Draw UI elements and shapes using primitive functions

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Provides C functions for drawing basic UI elements including filled and semi-transparent rectangles, lines, and pixels. Includes examples for rendering health/mana bars with gradient effects and text overlays, plus a minimap grid drawing function. Requires game.h header for text rendering functions.

```c
// Draw filled rectangle
void dd_rect(int sx, int sy, int ex, int ey, unsigned short color);

// Draw semi-transparent rectangle
void dd_shaded_rect(int sx, int sy, int ex, int ey, unsigned short color,
                    unsigned short alpha);

// Draw line
void dd_line(int fx, int fy, int tx, int ty, unsigned short col);

// Draw single pixel
void dd_pixel(int x, int y, unsigned short col);

// Example: Draw health/mana bars
#include "game.h"

void draw_stat_bars(int x, int y, int hp, int max_hp, int mana, int max_mana) {
    unsigned short red = IRGB(25, 0, 0);
    unsigned short bright_red = IRGB(31, 5, 5);
    unsigned short blue = IRGB(0, 0, 25);
    unsigned short bright_blue = IRGB(5, 5, 31);
    unsigned short gray = IRGB(10, 10, 10);

    int bar_width = 150;
    int bar_height = 12;

    // HP bar background
    dd_rect(x, y, x + bar_width, y + bar_height, gray);

    // HP bar fill
    int hp_width = (hp * bar_width) / max_hp;
    dd_rect(x, y, x + hp_width, y + bar_height, red);

    // HP bar highlight (top half)
    dd_rect(x, y, x + hp_width, y + bar_height/2, bright_red);

    // HP text
    dd_drawtext_fmt(x + bar_width/2, y + 2, IRGB(31,31,31), DD_CENTER | DD_SMALL,
                    "%d/%d", hp, max_hp);

    // Mana bar (offset below HP)
    y += bar_height + 5;
    dd_rect(x, y, x + bar_width, y + bar_height, gray);

    int mana_width = (mana * bar_width) / max_mana;
    dd_rect(x, y, x + mana_width, y + bar_height, blue);
    dd_rect(x, y, x + mana_width, y + bar_height/2, bright_blue);

    dd_drawtext_fmt(x + bar_width/2, y + 2, IRGB(31,31,31), DD_CENTER | DD_SMALL,
                    "%d/%d", mana, max_mana);
}

// Example: Draw minimap grid
void draw_minimap_grid(int map_x, int map_y, int map_size) {
    unsigned short grid_color = IRGB(8, 8, 8);

    for (int i = 0; i <= map_size; i++) {
        int offset = i * 5;
        // Vertical lines
        dd_line(map_x + offset, map_y, map_x + offset, map_y + map_size * 5,
                grid_color);
        // Horizontal lines
        dd_line(map_x, map_y + offset, map_x + map_size * 5, map_y + offset,
                grid_color);
    }
}
```

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

### Draw Text in C

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

This snippet demonstrates drawing text strings, formatted text, and word-wrapped text using the dd_drawtext, dd_drawtext_fmt, and dd_drawtext_break functions. The example includes color, shadows, alignment, and formatting options, with text length calculation.

```C
// Draw text string
int dd_drawtext(int sx, int sy, unsigned short color, int flags, const char *text);

// Draw formatted text (printf-style)
int dd_drawtext_fmt(int sx, int sy, unsigned short color, int flags,
                    const char *format, ...);

// Draw text with word wrapping
int dd_drawtext_break(int x, int y, int breakx, unsigned short color,
                      int flags, const char *ptr);

// Get text width in pixels
int dd_textlength(int flags, const char *text);

// Text flags
#define DD_LEFT 0       // Left-aligned
#define DD_CENTER 1     // Centered
#define DD_RIGHT 2      // Right-aligned
#define DD_SHADE 4      // Drop shadow
#define DD_SMALL 8      // Small font
#define DD_FRAME 16     // Framed background
#define DD_BIG 32       // Large font

// Color macros (15-bit RGB, 5-5-5 format)
#define IRGB(r,g,b) (((r)<<10)|((g)<<5)|((b)<<0))
#define IGET_R(c) ((((unsigned short)(c))>>10)&0x1F)
#define IGET_G(c) ((((unsigned short)(c))>>5)&0x1F)
#define IGET_B(c) ((((unsigned short)(c))>>0)&0x1F)

// Example: Draw UI text with various styles
#include "game.h"

void draw_character_stats(int hp, int max_hp, int mana, int max_mana, int gold) {
    unsigned short white = IRGB(31, 31, 31);
    unsigned short red = IRGB(31, 0, 0);
    unsigned short blue = IRGB(0, 15, 31);
    unsigned short yellow = IRGB(31, 31, 0);

    int x = 50, y = 50;

    // Title with shadow
    dd_drawtext(x, y, white, DD_LEFT | DD_SHADE | DD_BIG, "Character Stats");

    // HP bar with color based on health percentage
    int hp_percent = (hp * 100) / max_hp;
    unsigned short hp_color = (hp_percent > 50) ? white : red;
    dd_drawtext_fmt(x, y + 30, hp_color, DD_LEFT | DD_SHADE, "HP: %d/%d (%d%%)", hp, max_hp, hp_percent);

    // Mana in blue
    dd_drawtext_fmt(x, y + 50, blue, DD_LEFT | DD_SHADE, "Mana: %d/%d", mana, max_mana);

    // Gold in yellow
    dd_drawtext_fmt(x, y + 70, yellow, DD_LEFT | DD_SHADE, "Gold: %d", gold);

    // Small footer text
    dd_drawtext(x, y + 100, white, DD_LEFT | DD_SMALL, "Press TAB for inventory");
}

// Example: Word-wrapped dialog box
void draw_dialog(const char *message) {
    int box_x = 200, box_y = 400;
    int box_width = 400;
    unsigned short box_color = IRGB(8, 8, 12);
    unsigned short text_color = IRGB(28, 28, 28);

    // Draw semi-transparent background box
    dd_shaded_rect(box_x, box_y, box_x + box_width, box_y + 100, box_color, 200);

    // Draw text with word wrap at box boundary
    dd_drawtext_break(box_x + 10, box_y + 10, box_x + box_width - 10, text_color, DD_LEFT | DD_SHADE, message);
}
```

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

### Create loadable mod hooks for game events in C

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

This snippet provides the basic hook functions required to create a loadable DLL mod for the ASTONIA client. It defines lifecycle callbacks, input event hooks, and example implementations such as an FPS counter overlay. The mod interacts with the engine via amod_* functions and uses utilities like dd_drawtext_fmt, requiring the amod.h header.

```C
// Mod lifecycle functions
void amod_init(void);           // Called when mod loads
void amod_exit(void);           // Called when mod unloads
void amod_gamestart(void);      // Called when entering game
void amod_frame(void);          // Called each render frame
void amod_tick(void);           // Called each game tick (24/sec)

// Input hooks (return 1 to consume event, 0 to pass through)
int amod_mouse_click(int x, int y, int what);
int amod_keydown(int key);
int amod_keyup(int key);

// Mouse event constants
#define SDL_MOUM_LUP 1      // Left button up
#define SDL_MOUM_LDOWN 2    // Left button down
#define SDL_MOUM_RUP 3      // Right button up
#define SDL_MOUM_RDOWN 4    // Right button down
#define SDL_MOUM_WHEEL 7    // Mouse wheel

// Example: Basic mod with FPS counter
#include "amod.h"

static int frame_count = 0;
static int last_second = 0;
static int fps = 0;

void amod_init(void) {
    note("FPS Counter Mod v.0 loaded!");
}

void amod_exit(void) {
    note("FPS Counter Mod unloaded.");
}

void amod_frame(void) {
    frame_count++;

    // Calculate FPS every second
    if (current_time > last_second + 1000) {
        fps = frame_count;
        frame_count = 0;
        last_second current_time;
    }

    // Draw FPS counter in top-right corner
    int x = XRES - 100;
    int y = 10;
    dd_drawtext_fmt(x, y, IRGB(31, 31, 0), DD_LEFT | DD_SHADE,
                    "FPS: %d", fps);
}

int amod_mouse_click(int x, int y, int what) {
    if (what == SDL_MOUM_RDOWN) {
        // Log right-clicks
        addline("Right-clicked at (%d, %d)", x, y);
    }
    return 0;  // Don't consume event
}

int amod_keydown(int) {
    if (key == 'F') {
        addline("Current FPS: %d", fps);
        return 1;  // Consume 'F' key
    }
    return 0;
}
```

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

### Get UI element positions in C

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Functions dotx() and doty() return screen coordinates for UI elements by index. Includes predefined indices for common panels like inventory, map, and chat. Used for aligning custom overlays with game UI.

```c
// Get UI element position
int dotx(int didx);  // X coordinate
int doty(int didx);  // Y coordinate

// Get button position
int butx(int bidx);  // X coordinate
int buty(int bidx);  // Y coordinate

// UI element indices
#define DOT_WEA 2       // Worn equipment panel
#define DOT_INV 3       // Inventory panel
#define DOT_CON 4       // Container panel
#define DOT_TXT 9       // Chat/text window
#define DOT_MTL 10      // Map top-left corner
#define DOT_MBR 11      // Map bottom-right corner
#define DOT_SKL 12      // Skill list panel
```

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

### C - Sprite Override Functions

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Defines functions for checking sprite properties (cut, door, movement) and manipulating character sprites. Includes examples of custom armor rendering, weapon rendering, and sprite height adjustments based on sprite ID.

```C
// Check if sprite should be cut at ground level
int is_cut_sprite(int sprite);

// Check if sprite is a door
int is_door_sprite(int sprite);

// Check if sprite should move smoothly
int is_mov_sprite(int sprite, int itemhint);

// Get character sprite based on state
int get_player_sprite(int nr, int zdir, int action, int step,
                      int duration, int attick);

// Transform character sprite properties
void trans_csprite(int mn, struct map *cmap, int attick);

// Get sprite height for rendering
int get_chr_height(int csprite);

// Example: Custom character appearance system
#include "amod.h"

#define CUSTOM_ARMOR_OFFSET 100000
#define CUSTOM_WEAPON_OFFSET 110000

// Override character sprite rendering
void trans_csprite(int mn, struct map *cmap, int attick) {
    if (!cmap->cn) return;

    struct player *p = &player[cmap->cn];

    // Check for custom armor equipped
    int chest_item = item[WEAR_BODY];  // Body armor slot
    if (chest_item > 0) {
        // Apply custom armor sprite
        int armor_sprite = CUSTOM_ARMOR_OFFSET + (chest_item % 1000);

        // Add armor layer to display list
        DL *dl = dl_next_set(GME_LAY, armor_sprite,
                           cmap->x * 32, cmap->y * 32,
                           cmap->light);
        dl->h = 60;  // Render above character base

        // Match character animation state
        dl->ddfx.sprite += (attick % 8);  // Animation frame
    }

    // Custom weapon rendering
    int weapon_item = item[WEAR_RHAND];
    if (weapon_item > 0) {
        int weapon_sprite = CUSTOM_WEAPON_OFFSET + (weapon_item % 1000);

        DL *dl = dl_next_set(GME_LAY, weapon_sprite,
                           cmap->x * 32 + 10, cmap->y * 32 - 20,
                           cmap->light);
        dl->h = 65;  // Render above armor

        // Rotate weapon based on character direction
        if (cmap->dir == DX_RIGHT) {
            dl->ddfx.scale = 100;
        } else if (cmap->dir == DX_LEFT) {
            dl->ddfx.scale = -100;  // Flip horizontally
        }
    }
}

// Custom sprite height for collision detection
int get_chr_height(int csprite) {
    // Custom tall sprites
    if (csprite >= 60000 && csprite < 61000) {
        return 80;  // Giant creatures
    }    // Custom small sprites
    if (csprite >= 61000 && csprite < 62000) {
        return 30;  // Small creatures
    }

    // Default height
    return 60;
}

```

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

### Manage rendering bounds with clipping regions

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Provides functions for controlling rendering bounds through clipping region management. Includes saving/restoring clip regions and narrowing clip areas. The scrollable list example demonstrates how to constrain text rendering within boundaries while allowing border elements to remain unclipped. Requires game.h header for text rendering functions.

```c
// Save current clip region
void dd_push_clip(void);

// Restore saved clip region
void dd_pop_clip(void);

// Narrow clip region (intersection with current)
void dd_more_clip(int sx, int sy, int ex, int ey);

// Example: Draw text in bounded area without overflow
#include "game.h"

void draw_scrollable_list(char **items, int item_count, int scroll_offset) {
    int list_x = 100;
    int list_y = 200;
    int list_width = 300;
    int list_height = 400;
    int line_height = 20;

    // Draw list background
    dd_rect(list_x, list_y, list_x + list_width, list_y + list_height,
            IRGB(5, 5, 5);

    // Save current clip state
    dd_push_clip();

    // Restrict rendering to list bounds
    dd_more_clip(list_x, list_y, list_x + list_width, list_y + list_height);

    // Draw items (clipped automatically)
    int y = list_y - (scroll_offset * line_height);
    for (int i = 0; i < item_count; i++) {
        dd_drawtext(list_x + 10, y, IRGB(28, 28, 28), DD_LEFT, items[i]);
        y += line_height;
    }

    // Restore previous clip region
    dd_pop_clip();

    // Draw border (not clipped)
    unsigned short border = IRGB(15, 15, 15);
    dd_line(list_x, list_y, list_x + list_width, list_y, border);
    dd_line(list_x, list_y + list_height, list_x + list_width,
            list_y + list_height, border);
    dd_line(list_x, list_y, list_x, list_y + list_height, border);
    dd_line(list_x + list_width, list_y, list_x + list_width,
            list_y + list_height, border);
}
```

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

### Render display list sprites with depth sorting in C

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

This snippet demonstrates how to build and populate a display list for deferred sprite rendering with automatic depth sorting and layering in ASTONIA client. It defines the DL structure, constants, and helper functions dl_next and dl_next_set, and shows example usage for adding ground tiles, characters, text, and UI elements. The code assumes the presence of the game.h header and DDFX sprite effect definitions.

```C
// Get next display list entry
DL* dl_next(void);

// Get display list entry with initialization
DL* dl_next_set(int layer, int sprite, int scrx, int scry, int light);

// Display list structure
struct dl {
    int layer;              // Rendering layer (controls draw order)
    int x, y, h;           // Position (scry = y - h for depth sort)
    DDFX ddfx;             // Sprite effects
    char call;             // Special rendering callback
};

// Layer constants
#define GND_LAY 100        // Ground layer
#define GND2_LAY 101       // Ground layer 2
#define GME_LAY 110        // Game objects (items, characters)
#define TOP_LAY 1000       // UI overlay layer

// Example: Add sprites to display list
#include "game.h"

void render_scene(void) {
    // Add ground tile
    DL *dl = dl_next_set(GND_LAY, 5000, 400, 300, DDFX_NLIGHT);

    // Add character sprite with height for depth sorting
    dl = dl_next_set(GME_LAY, 52000, 400, 350, DDFX_NLIGHT);
    dl->h = 50;  // Character is 50 pixels tall

    // Add floating name text above character
    dl = dl_next_set(GME_LAY, 0, 400, 320, DDFX_NLIGHT);
    dl->h = 80;  // Sort above character
    dl->call = 1;  // Custom text rendering callback

    // Add UI element on top layer
    dl = dl_next_set(TOP_LAY, 1000, 50, 50, DDFX_NLIGHT);
}

// Example: Advanced display list with effects
void render_magical_projectile(int x, int y, int z, int frame) {
    DL *dl = dl_next();

    dl->layer = GME_LAY;
    dl->x = x;
    dl->y = y;
    dl->h = z;  // Height for depth sorting

    // Configure sprite effects
    dl->ddfx.sprite = 15500 + (frame % 8);  // Animated sprite
    dl->ddfx.scale = 80 + (frame % 20);     // Pulsing scale
    dl->ddfx.cr = 20;
    dl->ddfx.cg = 10;
    dl->ddfx.cb = 50;  // Blue tint
    dl->ddfx.alpha = 220;  // Semi-transparent
    dl->ddfx.light = 5;    // Bright
    dl->ddfx.align = DD_CENTER;
    dl->ddfx.ml = dl->ddfx.ll = dl->ddfx.rl = dl->ddfx.ul = dl->ddfx.dl = 5;
}
```

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

### Draw Sprites - Advanced Visual Effects (C)

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Provides comprehensive sprite rendering with full effect control including scaling, color tinting, transparency, and multi-directional lighting. The DDFX structure controls all visual aspects with RGB color balance, scale percentage, alpha transparency, and directional light sources. Requires memset for initialization and screen resolution constants (XRES/YRES). Example functions demonstrate creating magical glowing effects and pulsing damage indicators.

```c
// Draw sprite with full effect control
int dd_copysprite_fx(DDFX *ddfx, int scrx, int scry);

// Effect structure
struct ddfx {
    int sprite;                  // Sprite ID
    signed char sink;            // Vertical offset
    unsigned char scale;         // Scale (100 = normal, 50 = half, 200 = double)
    char cr, cg, cb;            // Color balance RGB (-64 to +63)
    char clight, sat;           // Lightness, saturation
    unsigned short c1, c2, c3;  // Color replacement (0 = no replace)
    unsigned short shine;        // Shine color
    char light;                  // Lighting (0 = bright, 15 = normal, 31 = dark)
    char freeze;                 // Animation freeze frame
    char ml, ll, rl, ul, dl;    // Multi-light (middle, left, right, up, down)
    char align;                  // Alignment mode
    short clipsx, clipex;        // Clip rectangle start/end X
    short clipsy, clipey;        // Clip rectangle start/end Y
    unsigned char alpha;         // Transparency (0 = invisible, 255 = opaque)
};

// Example: Draw glowing, scaled, semi-transparent sprite
#include "game.h"
#include <string.h>

void draw_magical_effect(int x, int y) {
    DDFX ddfx;
    memset(&ddfx, 0, sizeof(DDFX));

    // Magical orb sprite
    ddfx.sprite = 15000;
    ddfx.scale = 150;              // 150% size
    ddfx.cr = 0;                   // Normal red
    ddfx.cg = 30;                  // Boost green
    ddfx.cb = 50;                  // Boost blue (cyan tint)
    ddfx.alpha = 180;              // 70% opacity
    ddfx.light = 8;                // Brighter than normal
    ddfx.align = DD_CENTER;
    ddfx.sink = 0;

    // Set multi-directional lighting (all bright)
    ddfx.ml = ddfx.ll = ddfx.rl = ddfx.ul = ddfx.dl = 8;

    // No clipping
    ddfx.clipsx = ddfx.clipsy = 0;
    ddfx.clipex = XRES;
    ddfx.clipey = YRES;

    dd_copysprite_fx(&ddfx, x, y);
}

// Example: Pulsing red damage effect
void draw_damage_flash(int sprite_id, int x, int y, int frame) {
    DDFX ddfx;
    memset(&ddfx, 0, sizeof(DDFX));

    ddfx.sprite = sprite_id;
    ddfx.cr = 63;                           // Maximum red tint
    ddfx.cg = ddfx.cb = -30;               // Reduce green/blue
    ddfx.scale = 100 + (frame % 10);       // Slight pulse
    ddfx.alpha = 255 - (frame * 10);       // Fade out
    ddfx.light = DDFX_NLIGHT;
    ddfx.align = DD_CENTER;
    ddfx.ml = ddfx.ll = ddfx.rl = ddfx.ul = ddfx.dl = DDFX_NLIGHT;

    dd_copysprite_fx(&ddfx, x, y);
}
```

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

### C Configuration File Loading with Logging

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Demonstrates loading a configuration file with robust error handling using logging functions. Includes error messages for file opening and invalid syntax, as well as informational messages for successful loading and options.

```c
#include "astonia.h"
#include <errno.h>

int load_config_file(const char *path) {
    note("Loading configuration from %s", path);

    FILE *f = fopen(path, "r");
    if (!f) {
        warn("Could not open config file %s: %s", path, strerror(errno));
        return 0;
    }

    char line[256];
    int line_num = 0;
    int options_loaded = 0;

    while (fgets(line, sizeof(line), f)) {
        line_num++;

        // Parse configuration line
        if (line[0] == '#' || line[0] == '\n') {
            continue;  // Skip comments and empty lines
        }

        char key[64], value[64];
        if (sscanf(line, "%63s = %63s", key, value) != 2) {
            warn("Invalid config syntax at line %d: %s", line_num, line);
            continue;
        }

        // Process option
        note("Config: %s = %s", key, value);
        options_loaded++;
    }

    fclose(f);

    if (options_loaded == 0) {
        fail("No valid options loaded from %s", path);
        return 0;
    }

    note("Successfully loaded %d configuration options", options_loaded);
    addline("Configuration loaded: %d options", options_loaded);
    return 1;
}
```

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

### Module Initialization and Cleanup with Memory Tracking in C

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Demonstrates allocating and freeing an array of structures during module init and exit phases. Depends on amod.h and xcalloc/xfree; assumes MAXCHARS is defined. Inputs: Loop over MAXCHARS; outputs: Populated player_data array. Limitations: Manual null checks required; fails module init on allocation error.

```c
// Example: Proper memory management in mod
#include "amod.h"
#include <string.h>

struct custom_data {
    char name[64];
    int value;
    float coords[3];
};

static struct custom_data *player_data[MAXCHARS];

void amod_init(void) {
    // Allocate player data array
    for (int i = 0; i < MAXCHARS; i++) {
        player_data[i] = xcalloc(sizeof(struct custom_data), MEM_GAME);
        if (!player_data[i]) {
            fail("Failed to allocate player data");
            return;
        }
    }

    note("Allocated %d player data structures", MAXCHARS);
}

void amod_exit(void) {
    // Clean up all allocations
    for (int i = 0; i < MAXCHARS; i++) {
        if (player_data[i]) {
            xfree(player_data[i]);
            player_data[i] = NULL;
        }
    }

    note("Freed all player data");
}
```

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

### Accessing Game State Variables and Map Scanning in C

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Provides global variables for game state like map, stats, inventory, and resources, along with a map structure for tile data. Includes functions to display character info and scan nearby items/characters. Depends on client.h for addline and other utilities; inputs are coordinates or indices, outputs via addline prints. Limitations: Assumes 51x51 visible map and fixed inventory size of 110 slots.

```c
// Global game state variables
extern struct map map[MAPDX*MAPDY];     // 51x51 visible map
extern int value[2][V_MAX];             // [0]=current, [1]=base stats
extern int item[INVENTORYSIZE];         // 110 inventory slots
extern int hp, mana, rage, endurance;   // Current resource values
extern int gold, experience;            // Currency and XP
extern struct player player[MAXCHARS];  // Visible characters

// Map structure (simplified)
struct map {
    unsigned short gsprite, gsprite2;   // Ground sprites
    unsigned short fsprite, fsprite2;   // Foreground sprites
    unsigned int isprite;               // Item sprite
    unsigned int csprite;               // Character sprite
    unsigned int cn;                    // Character number
    unsigned char action, dir;          // Character state
    unsigned char health, mana;         // Resource bars (0-16)
    unsigned int flags;                 // Tile flags
};

// Stat indices
#define V_HP 0          // Hit points
#define V_MANA 2        // Mana points
#define V_WIS 3         // Wisdom
#define V_INT 4         // Intelligence
#define V_AGI 5         // Agility
#define V_STR 6         // Strength
#define V_ARMOR 18      // Armor value
#define V_WEAPON 19     // Weapon skill

// Map coordinate conversion
int mapmn(int x, int y);  // Convert (x,y) to array index

// Example: Display character statistics
#include "client.h"

void show_character_info(void) {
    // Current vs base stats
    int cur_str = value[0][V_STR];
    int base_str = value[1][V_STR];
    int cur_hp = value[0][V_HP];

    // Display stats
    addline("Strength: %d (base: %d)", cur_str, base_str);
    addline("Max HP: %d, Current HP: %d", cur_hp, hp);
    addline("Gold: %d, Experience: %d", gold, experience);

    // Check for buffs/debuffs
    if (cur_str > base_str) {
        addline("You are buffed! (+%d STR)", cur_str - base_str);
    }
}

// Example: Scan nearby map tiles
void scan_nearby_items(int player_x, int player_y) {
    int found_items = 0;

    for (int dy = -5; dy <= 5; dy++) {
        for (int dx = -5; dx <= 5; dx++) {
            int check_x = player_x + dx;
            int check_y = player_y + dy;

            // Bounds check
            if (check_x < 0 || check_x >= MAPDX ||
                check_y < 0 || check_y >= MAPDY) {
                continue;
            }

            int mn = mapmn(check_x, check_y);

            // Check for items on ground
            if (map[mn].isprite) {
                addline("Item at (%d, %d)", check_x, check_y);
                found_items++;
            }

            // Check for characters
            if (map[mn].cn) {
                struct player *p = &player[map[mn].cn];
                addline("Character '%s' at (%d, %d)", p->name, check_x, check_y);
            }
        }
    }

    if (found_items == 0) {
        addline("No items nearby");
    }
}
```

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

### Dynamic String Creation and Management in C

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Creates formatted strings using snprintf and tracked duplication for temporary use. Depends on stdio.h for snprintf and xstrdup/xfree. Inputs: Player name and score; outputs: Allocated string pointer. Limitations: Fixed buffer size risks truncation; manual free required to avoid leaks.

```c
// Example: Dynamic string management
char* create_formatted_message(const char *player_name, int score) {
    char buffer[256];
    snprintf(buffer, sizeof(buffer),
             "Player %s scored %d points!", player_name, score);

    // Allocate and return duplicated string
    return xstrdup(buffer, MEM_TEMP);
}

void process_message(void) {
    char *msg = create_formatted_message("Hero", 1000);

    // Use message
    addline("%s", msg);

    // Free when done
    xfree(msg);
}
```

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

### Send Client Commands to Server

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Functions to send player actions and requests to the game server using the client command API. Commands are transmitted as binary packets over TCP sockets. Includes movement, combat, spell casting and chat functionality.

```c
// Move player to map coordinates
void cmd_move(int x, int y);

// Attack character by character number
void cmd_kill(int cn);

// Use object at map location
void cmd_use(int x, int y);

// Send chat message
void cmd_text(char *text);

// Cast spell at location or character
void cmd_some_spell(int spell, int x, int y, int chr);

// Example: Walk to location, attack, and cast fireball
#include "client.h"

void combat_sequence(void) {
    // Move to position (25, 30)
    cmd_move(25, 30);

    // Attack character 5
    cmd_kill(5);

    // Cast fireball at map position (28, 32)
    cmd_some_spell(CL_FIREBALL, 28, 32, 0);

    // Send chat message
    cmd_text("Victory!");

    // Request look at map tile
    cmd_look_map(28, 32);
}

// Spell command constants
#define CL_BLESS 10         // Cast bless buff
#define CL_FIREBALL 11      // Cast fireball attack
#define CL_HEAL 12          // Cast heal spell
#define CL_MAGICSHIELD 13   // Cast magic shield
#define CL_FREEZE 14        // Cast freeze
#define CL_FLASH 17         // Cast flash
#define CL_BALL 18          // Cast lightning ball
#define CL_WARCRY 19        // Cast warcry
#define CL_PULSE 38         // Cast pulse
```

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

### C Performance Profiling - Rendering Frame Times

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Provides a function to profile rendering performance by tracking frame times. It calculates and displays the average frame time and frames per second (FPS) every 60 frames.

```c
void profile_rendering(void) {
    static int frame_times[60];
    static int frame_index = 0;
    static unsigned long last_time = 0;

    unsigned long current = get_current_time_ms();
    int frame_time = (int)(current - last_time);
    last_time = current;

    frame_times[frame_index] = frame_time;
    frame_index = (frame_index + 1) % 60;

    // Calculate average every 60 frames
    if (frame_index == 0) {
        int total = 0;
        int min = 999999, max = 0;

        for (int i = 0; i < 60; i++) {
            total += frame_times[i];
            if (frame_times[i] < min) min = frame_times[i];
            if (frame_times[i] > max) max = frame_times[i];
        }

        float avg = total / 60.0f;
        float fps = 1000.0f / avg;

        note("Frame stats: avg=%.2fms (%.1f fps), min=%dms, max=%dms",
             avg, fps, min, max);
    }
}
```

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

### Memory Usage Debugging in C

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Calls list_mem to print a breakdown of memory usage by category for leak detection. No dependencies beyond list_mem declaration. Inputs: None; outputs: Console printout of category stats. Limitations: Debug-only; does not free memory or provide interactive tools.

```c
// Example: Check memory usage
void debug_memory_usage(void) {
    list_mem();  // Prints breakdown by category
}
```

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

### Convert screen to map coordinates in C

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Converts screen coordinates to map coordinates using the stom function. Returns non-zero if the conversion is valid. Requires screen x/y coordinates and output pointers for map x/y coordinates.

```c
// Convert screen to map coordinates
int stom(int scrx, int scry, int *mapx, int *mapy);
```

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

### Find nearest enemy with pathfinding in C

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Finds the nearest enemy character by calculating squared distances to all characters on the map. Uses a helper function to compute squared distances for efficiency.

```c
int get_distance(int x1, int y1, int x2, int y2) {
    int dx = x2 - x1;
    int dy = y2 - y1;
    return (dx * dx + dy * dy);  // Squared distance (faster)
}

void find_nearest_enemy(int player_x, int player_y) {
    int nearest_cn = 0;
    int nearest_dist = 999999;

    for (int y = 0; y < MAPDY; y++) {
        for (int x = 0; x < MAPDX; x++) {
            int mn = mapmn(x, y);

            if (map[mn].cn) {
                int dist = get_distance(player_x, player_y, x, y);

                if (dist < nearest_dist) {
                    nearest_dist = dist;
                    nearest_cn = map[mn].cn;
                }
            }
        }
    }

    if (nearest_cn > 0) {
        addline("Nearest enemy: %s (distance: %d)",
                player[nearest_cn].name, nearest_dist);
    }
}
```

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

### Convert map to screen coordinates in C

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Converts map coordinates to screen coordinates using the mtos function. Takes map x/y coordinates and outputs screen x/y coordinates through pointers.

```c
// Convert map to screen coordinates
void mtos(int mapx, int mapy, int *scrx, int *scry);
```

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

### Custom Memory Allocation Functions in C

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Implements tracked allocation, deallocation, and duplication with category IDs for debugging leaks. Depends on internal implementation; uses standard C types like void*. Inputs: allocation size and category ID; outputs: pointers to allocated memory. Limitations: Non-standard API, requires matching xfree for cleanup; no automatic error handling beyond null checks.

```c
// Allocate memory with category tracking
void* xmalloc(int size, int ID);
void* xcalloc(int size, int ID);  // Zero-initialized
void* xrealloc(void *ptr, int size, int ID);
void xfree(void *ptr);
char* xstrdup(const char *src, int ID);

// Memory category IDs
#define MEM_GLOB 1          // Global data
#define MEM_TEMP 2          // Temporary allocations
#define MEM_DL 4            // Display lists
#define MEM_GUI 9           // GUI data
#define MEM_GAME 10         // Game state
#define MEM_SDL_BASE 15     // SDL structures
#define MEM_SDL_PIXEL 16    // SDL pixel buffers
#define MEM_SDL_PNG 17      // PNG image data

// Debug function
void list_mem(void);        // Print memory usage by category
```

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

### C Logging Functions

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Provides C functions for logging messages with different severity levels. These functions output messages to the console, chat window, and log files. Severity levels include info, warning, error, and chat message.

```c
int note(const char *format, ...);   // Info message (console only)
int warn(const char *format, ...);   // Warning (console + log)
int fail(const char *format, ...);   // Error (console + log)
void addline(const char *format, ...); // Chat window message
```

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

### Handle map clicks with coordinate conversion in C

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Processes mouse clicks on the map by converting screen coordinates to map coordinates. Detects characters, items, or empty tiles at the clicked location and performs appropriate actions.

```c
void handle_map_click(int screen_x, int screen_y) {
    int map_x, map_y;

    // Convert screen click to map coordinates
    if (stom(screen_x, screen_y, &map_x, &map_y)) {
        // Click was on valid map tile
        int mn = mapmn(map_x, map_y);

        // Check what's at this location
        if (map[mn].cn) {
            // Character present
            addline("Character at tile (%d, %d)", map_x, map_y);
            cmd_look_map(map_x, map_y);
        }
        else if (map[mn].isprite) {
            // Item on ground
            addline("Item at tile (%d, %d)", map_x, map_y);
            cmd_take(map_x, map_y);
        }
        else {
            // Empty tile - move there
            cmd_move(map_x, map_y);
        }
    }
}
```

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

### Send Achievement Request (C)

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

This function sends a request to the server to retrieve a list of achievements. It constructs a packet with a custom client command and sends it using the client_send function. It demonstrates how to initiate communication with the server for specific mod-related information.

```C
void request_achievement_list(void) {
    unsigned char packet[2];
    packet[0] = CL_USER;  // Custom client command
    packet[1] = 1;        // Request achievement list

    client_send(packet, 2);
}

```

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

### C Debug Visualization - Collision Boxes

Source: https://context7.com/danielbrockhaus/astonia_client/llms.txt

Provides a function to draw collision boxes for map tiles. It iterates over the map and draws magenta outlines for tiles marked as blocked, converting map coordinates to screen coordinates.

```c
void debug_draw_collision_boxes(void) {
    unsigned short debug_color = IRGB(31, 0, 31);  // Magenta

    for (int y = 0; y < MAPDY; y++) {
        for (int x = 0; x < MAPDX; x++) {
            int mn = mapmn(x, y);

            // Check if tile is blocked
            if (map[mn].flags & 1) {
                int scr_x, scr_y;
                mtos(x, y, &scr_x, &scr_y);

                // Draw collision box outline
                dd_line(scr_x, scr_y, scr_x + 32, scr_y, debug_color);
                dd_line(scr_x + 32, scr_y, scr_x + 32, scr_y + 32, debug_color);
                dd_line(scr_x + 32, scr_y + 32, scr_x, scr_y + 32, debug_color);
                dd_line(scr_x, scr_y + 32, scr_x, scr_y, debug_color);
            }
        }
    }
}
```