The Complete Guide to Tilemaps, Fonts, and Asset Management

Feb 25, 2026 · by 0xKiireguidegraphicscsdlrenderingdata orientedimmediate modegame development

---

Table of Contents

1. Introduction to Asset-Driven Game Development
2. SDL_ttf Font Rendering Fundamentals
3. Advanced Text Rendering Techniques
4. Tilemap Architecture and Design
5. Building a Tile Engine
6. TMX and Tiled Map Editor Integration
7. Layered Tilemap Rendering
8. Tile-Based Collision Detection
9. Animated Tiles and Auto-Tiling
10. Isometric and Hexagonal Tilemaps
11. Asset Manager Architecture
12. Texture Atlas and Sprite Sheet Management
13. Audio Asset Management
14. Music System and Streaming
15. Sound Effects and Mixing
16. Resource Loading and Streaming
17. Asset Bundling and Packaging
18. Performance Optimization for Assets
19. Complete Game Examples
20. Production Asset Pipeline

---

Chapter 1: Introduction to Asset-Driven Game Development

1.1 Why Asset Management Matters

Modern games are data-driven. Instead of hardcoding everything, we load content from files:

• Flexibility - Change content without recompiling
• Scalability - Add new levels/characters easily
• Team Workflow - Designers can work independently
• Memory Efficiency - Load/unload assets as needed
• Localization - Support multiple languages

1.2 The Asset Pipeline

Creation → Export → Import → Process → Cache → Load → Use → Unload

Creation: Artists create content in tools (Photoshop, Tiled, Audacity)
Export: Save in game-friendly formats (PNG, TMX, WAV)
Import: Load into game engine
Process: Convert to optimized runtime format
Cache: Store processed data for fast loading
Load: Bring into memory when needed
Use: Render/play the asset
Unload: Free memory when done

1.3 File Organization

game/
├── assets/
│   ├── fonts/
│   │   ├── ui.ttf
│   │   ├── title.ttf
│   │   └── monospace.ttf
│   ├── maps/
│   │   ├── level1.tmx
│   │   ├── level2.tmx
│   │   └── tilesets/
│   │       ├── dungeon.png
│   │       └── dungeon.tsx
│   ├── sprites/
│   │   ├── player.png
│   │   ├── enemies.png
│   │   └── items.png
│   ├── ui/
│   │   ├── buttons.png
│   │   ├── panels.png
│   │   └── icons.png
│   ├── music/
│   │   ├── menu.ogg
│   │   ├── level1.ogg
│   │   └── boss.ogg
│   └── sfx/
│       ├── jump.wav
│       ├── shoot.wav
│       └── explosion.wav
├── src/
└── build/

1.4 Asset Types Overview

// asset_types.h

typedef enum {
    ASSET_TEXTURE,
    ASSET_FONT,
    ASSET_SOUND,
    ASSET_MUSIC,
    ASSET_MAP,
    ASSET_DATA
} AssetType;

typedef struct {
    char name[64];
    AssetType type;
    void* data;
    size_t size;
    int refCount;
    bool loaded;
} Asset;

---

Chapter 2: SDL_ttf Font Rendering Fundamentals

2.1 Setting Up SDL_ttf

// font_system.h
#include <SDL2/SDL.h>
#include <SDL2/SDL_ttf.h>
#include <stdbool.h>

// Initialize SDL_ttf
bool initFontSystem() {
    if (TTF_Init() < 0) {
        printf("SDL_ttf initialization failed: %s\n", TTF_GetError());
        return false;
    }
    return true;
}

void cleanupFontSystem() {
    TTF_Quit();
}

2.2 Loading and Managing Fonts

// font_manager.c

typedef struct {
    TTF_Font* font;
    char name[64];
    int size;
    int refCount;
} FontData;

typedef struct {
    FontData fonts[64];
    int count;
} FontManager;

void initFontManager(FontManager* fm) {
    fm->count = 0;
    memset(fm->fonts, 0, sizeof(fm->fonts));
}

TTF_Font* loadFont(FontManager* fm, const char* path, int size, const char* name) {
    // Check if already loaded
    for (int i = 0; i < fm->count; i++) {
        if (strcmp(fm->fonts[i].name, name) == 0 && fm->fonts[i].size == size) {
            fm->fonts[i].refCount++;
            return fm->fonts[i].font;
        }
    }
    
    // Load new font
    TTF_Font* font = TTF_OpenFont(path, size);
    if (!font) {
        printf("Failed to load font %s: %s\n", path, TTF_GetError());
        return NULL;
    }
    
    // Store in manager
    if (fm->count < 64) {
        FontData* fd = &fm->fonts[fm->count++];
        fd->font = font;
        strncpy(fd->name, name, sizeof(fd->name) - 1);
        fd->size = size;
        fd->refCount = 1;
    }
    
    return font;
}

void unloadFont(FontManager* fm, const char* name, int size) {
    for (int i = 0; i < fm->count; i++) {
        if (strcmp(fm->fonts[i].name, name) == 0 && fm->fonts[i].size == size) {
            fm->fonts[i].refCount--;
            
            if (fm->fonts[i].refCount <= 0) {
                TTF_CloseFont(fm->fonts[i].font);
                
                // Shift remaining fonts
                for (int j = i; j < fm->count - 1; j++) {
                    fm->fonts[j] = fm->fonts[j + 1];
                }
                fm->count--;
            }
            return;
        }
    }
}

void destroyFontManager(FontManager* fm) {
    for (int i = 0; i < fm->count; i++) {
        TTF_CloseFont(fm->fonts[i].font);
    }
    fm->count = 0;
}

2.3 Basic Text Rendering

// text_rendering.c

// Render text with solid color (fastest)
SDL_Texture* renderTextSolid(SDL_Renderer* renderer, TTF_Font* font,
                             const char* text, SDL_Color color) {
    SDL_Surface* surface = TTF_RenderText_Solid(font, text, color);
    if (!surface) {
        printf("Text rendering failed: %s\n", TTF_GetError());
        return NULL;
    }
    
    SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surface);
    SDL_FreeSurface(surface);
    
    return texture;
}

// Render text with background color (slower, but smooth)
SDL_Texture* renderTextShaded(SDL_Renderer* renderer, TTF_Font* font,
                              const char* text, SDL_Color fg, SDL_Color bg) {
    SDL_Surface* surface = TTF_RenderText_Shaded(font, text, fg, bg);
    if (!surface) return NULL;
    
    SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surface);
    SDL_FreeSurface(surface);
    
    return texture;
}

// Render text with alpha blending (slowest, best quality)
SDL_Texture* renderTextBlended(SDL_Renderer* renderer, TTF_Font* font,
                               const char* text, SDL_Color color) {
    SDL_Surface* surface = TTF_RenderText_Blended(font, text, color);
    if (!surface) return NULL;
    
    SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surface);
    SDL_FreeSurface(surface);
    
    return texture;
}

// Draw text at position
void drawText(SDL_Renderer* renderer, TTF_Font* font, const char* text,
             int x, int y, SDL_Color color) {
    SDL_Texture* textTexture = renderTextBlended(renderer, font, text, color);
    if (!textTexture) return;
    
    int w, h;
    SDL_QueryTexture(textTexture, NULL, NULL, &w, &h);
    
    SDL_Rect dest = {x, y, w, h};
    SDL_RenderCopy(renderer, textTexture, NULL, &dest);
    
    SDL_DestroyTexture(textTexture);
}

2.4 Font Styles and Attributes

// font_styles.c

// Set font style
void setFontStyle(TTF_Font* font, int style) {
    TTF_SetFontStyle(font, style);
    // Styles: TTF_STYLE_NORMAL, TTF_STYLE_BOLD, TTF_STYLE_ITALIC, 
    //         TTF_STYLE_UNDERLINE, TTF_STYLE_STRIKETHROUGH
}

// Set font outline
void setFontOutline(TTF_Font* font, int outline) {
    TTF_SetFontOutline(font, outline);
}

// Get font metrics
void getFontMetrics(TTF_Font* font) {
    int height = TTF_FontHeight(font);
    int ascent = TTF_FontAscent(font);
    int descent = TTF_FontDescent(font);
    int lineSkip = TTF_FontLineSkip(font);
    
    printf("Font metrics:\n");
    printf("  Height: %d\n", height);
    printf("  Ascent: %d\n", ascent);
    printf("  Descent: %d\n", descent);
    printf("  Line skip: %d\n", lineSkip);
}

// Measure text dimensions
void measureText(TTF_Font* font, const char* text, int* w, int* h) {
    TTF_SizeText(font, text, w, h);
}

// Example: Render text with outline
SDL_Texture* renderTextWithOutline(SDL_Renderer* renderer, TTF_Font* font,
                                   const char* text, SDL_Color color,
                                   SDL_Color outlineColor, int outlineSize) {
    // Save original outline
    int originalOutline = TTF_GetFontOutline(font);
    
    // Render outline
    TTF_SetFontOutline(font, outlineSize);
    SDL_Surface* outlineSurface = TTF_RenderText_Blended(font, text, outlineColor);
    
    // Render text
    TTF_SetFontOutline(font, 0);
    SDL_Surface* textSurface = TTF_RenderText_Blended(font, text, color);
    
    // Combine surfaces
    SDL_Rect destRect = {outlineSize, outlineSize, textSurface->w, textSurface->h};
    SDL_BlitSurface(textSurface, NULL, outlineSurface, &destRect);
    
    // Create texture
    SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, outlineSurface);
    
    // Cleanup
    SDL_FreeSurface(textSurface);
    SDL_FreeSurface(outlineSurface);
    TTF_SetFontOutline(font, originalOutline);
    
    return texture;
}

2.5 UTF-8 and Unicode Support

// unicode_text.c

// Render UTF-8 text (supports international characters)
SDL_Texture* renderUTF8Text(SDL_Renderer* renderer, TTF_Font* font,
                            const char* utf8Text, SDL_Color color) {
    SDL_Surface* surface = TTF_RenderUTF8_Blended(font, utf8Text, color);
    if (!surface) return NULL;
    
    SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surface);
    SDL_FreeSurface(surface);
    
    return texture;
}

// Render single Unicode character
SDL_Texture* renderUnicodeGlyph(SDL_Renderer* renderer, TTF_Font* font,
                               Uint16 unicode, SDL_Color color) {
    SDL_Surface* surface = TTF_RenderGlyph_Blended(font, unicode, color);
    if (!surface) return NULL;
    
    SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surface);
    SDL_FreeSurface(surface);
    
    return texture;
}

// Example usage with international text
void demonstrateUnicode(SDL_Renderer* renderer, TTF_Font* font) {
    SDL_Color white = {255, 255, 255, 255};
    
    // English
    drawText(renderer, font, "Hello World", 10, 10, white);
    
    // Spanish
    drawText(renderer, font, "Hola Mundo", 10, 40, white);
    
    // Japanese
    drawText(renderer, font, "こんにちは世界", 10, 70, white);
    
    // Arabic (RTL support may need additional handling)
    drawText(renderer, font, "مرحبا بالعالم", 10, 100, white);
    
    // Emoji (if font supports)
    drawText(renderer, font, "🎮🕹️👾", 10, 130, white);
}

---

Chapter 3: Advanced Text Rendering Techniques

3.1 Text Caching System

// text_cache.h

typedef struct {
    char text[256];
    SDL_Texture* texture;
    int width;
    int height;
    Uint32 lastUsed;
} CachedText;

typedef struct {
    CachedText cache[256];
    int count;
    int maxCacheSize;
} TextCache;

void initTextCache(TextCache* tc, int maxSize) {
    tc->count = 0;
    tc->maxCacheSize = maxSize;
    memset(tc->cache, 0, sizeof(tc->cache));
}

SDL_Texture* getCachedText(TextCache* tc, SDL_Renderer* renderer,
                          TTF_Font* font, const char* text, SDL_Color color) {
    // Check cache
    for (int i = 0; i < tc->count; i++) {
        if (strcmp(tc->cache[i].text, text) == 0) {
            tc->cache[i].lastUsed = SDL_GetTicks();
            return tc->cache[i].texture;
        }
    }
    
    // Not in cache - render new
    SDL_Texture* texture = renderTextBlended(renderer, font, text, color);
    if (!texture) return NULL;
    
    int w, h;
    SDL_QueryTexture(texture, NULL, NULL, &w, &h);
    
    // Add to cache
    if (tc->count < tc->maxCacheSize) {
        CachedText* ct = &tc->cache[tc->count++];
        strncpy(ct->text, text, sizeof(ct->text) - 1);
        ct->texture = texture;
        ct->width = w;
        ct->height = h;
        ct->lastUsed = SDL_GetTicks();
    } else {
        // Cache full - replace oldest
        int oldestIndex = 0;
        Uint32 oldestTime = tc->cache[0].lastUsed;
        
        for (int i = 1; i < tc->count; i++) {
            if (tc->cache[i].lastUsed < oldestTime) {
                oldestTime = tc->cache[i].lastUsed;
                oldestIndex = i;
            }
        }
        
        // Replace oldest
        SDL_DestroyTexture(tc->cache[oldestIndex].texture);
        strncpy(tc->cache[oldestIndex].text, text, sizeof(tc->cache[oldestIndex].text) - 1);
        tc->cache[oldestIndex].texture = texture;
        tc->cache[oldestIndex].width = w;
        tc->cache[oldestIndex].height = h;
        tc->cache[oldestIndex].lastUsed = SDL_GetTicks();
    }
    
    return texture;
}

void clearTextCache(TextCache* tc) {
    for (int i = 0; i < tc->count; i++) {
        SDL_DestroyTexture(tc->cache[i].texture);
    }
    tc->count = 0;
}

3.2 Text Layout and Word Wrapping

// text_layout.c

typedef struct {
    char* lines[64];
    int lineCount;
    int lineWidths[64];
    int totalHeight;
} TextLayout;

TextLayout* createTextLayout(TTF_Font* font, const char* text, int maxWidth) {
    TextLayout* layout = calloc(1, sizeof(TextLayout));
    
    char buffer[1024];
    strncpy(buffer, text, sizeof(buffer) - 1);
    
    char* start = buffer;
    char* end;
    int lineHeight = TTF_FontLineSkip(font);
    
    while (*start) {
        // Find word boundaries
        end = start;
        char* lastSpace = NULL;
        int currentWidth = 0;
        
        while (*end) {
            // Measure current segment
            char temp = *end;
            *end = '\0';
            
            int w;
            TTF_SizeText(font, start, &w, NULL);
            
            *end = temp;
            
            if (w > maxWidth && lastSpace) {
                // Line too long, break at last space
                end = lastSpace;
                break;
            }
            
            currentWidth = w;
            
            if (*end == ' ') lastSpace = end;
            if (*end == '\n') break;
            
            end++;
        }
        
        if (*end == '\0' && currentWidth <= maxWidth) {
            // Last line
            layout->lines[layout->lineCount] = strdup(start);
            layout->lineWidths[layout->lineCount] = currentWidth;
            layout->lineCount++;
            break;
        }
        
        // Store line
        char savedChar = *end;
        *end = '\0';
        layout->lines[layout->lineCount] = strdup(start);
        TTF_SizeText(font, start, &layout->lineWidths[layout->lineCount], NULL);
        layout->lineCount++;
        *end = savedChar;
        
        // Move to next line
        if (*end == '\n' || *end == ' ') end++;
        start = end;
    }
    
    layout->totalHeight = layout->lineCount * lineHeight;
    
    return layout;
}

void renderTextLayout(SDL_Renderer* renderer, TTF_Font* font,
                     TextLayout* layout, int x, int y, SDL_Color color) {
    int lineHeight = TTF_FontLineSkip(font);
    
    for (int i = 0; i < layout->lineCount; i++) {
        drawText(renderer, font, layout->lines[i], x, y + i * lineHeight, color);
    }
}

void destroyTextLayout(TextLayout* layout) {
    for (int i = 0; i < layout->lineCount; i++) {
        free(layout->lines[i]);
    }
    free(layout);
}

3.3 Text Alignment and Justification

// text_alignment.c

typedef enum {
    ALIGN_LEFT,
    ALIGN_CENTER,
    ALIGN_RIGHT,
    ALIGN_JUSTIFY
} TextAlign;

void drawAlignedText(SDL_Renderer* renderer, TTF_Font* font,
                    const char* text, int x, int y, int width,
                    TextAlign align, SDL_Color color) {
    int textWidth, textHeight;
    TTF_SizeText(font, text, &textWidth, &textHeight);
    
    int drawX = x;
    
    switch (align) {
        case ALIGN_LEFT:
            drawX = x;
            break;
            
        case ALIGN_CENTER:
            drawX = x + (width - textWidth) / 2;
            break;
            
        case ALIGN_RIGHT:
            drawX = x + width - textWidth;
            break;
            
        case ALIGN_JUSTIFY:
            // Justify is complex, handled separately
            drawX = x;
            break;
    }
    
    drawText(renderer, font, text, drawX, y, color);
}

void drawMultilineText(SDL_Renderer* renderer, TTF_Font* font,
                      TextLayout* layout, int x, int y, int width,
                      TextAlign align, SDL_Color color) {
    int lineHeight = TTF_FontLineSkip(font);
    
    for (int i = 0; i < layout->lineCount; i++) {
        int drawX = x;
        
        switch (align) {
            case ALIGN_LEFT:
                drawX = x;
                break;
                
            case ALIGN_CENTER:
                drawX = x + (width - layout->lineWidths[i]) / 2;
                break;
                
            case ALIGN_RIGHT:
                drawX = x + width - layout->lineWidths[i];
                break;
                
            case ALIGN_JUSTIFY:
                // Implement justify logic for middle lines
                if (i < layout->lineCount - 1) {
                    // Distribute space between words
                    // (complex implementation omitted for brevity)
                    drawX = x;
                } else {
                    // Last line: left-align
                    drawX = x;
                }
                break;
        }
        
        drawText(renderer, font, layout->lines[i], drawX, y + i * lineHeight, color);
    }
}

3.4 Bitmap Font System

// bitmap_font.h - For faster rendering of fixed character sets

typedef struct {
    SDL_Texture* texture;
    SDL_Rect glyphs[256];  // Character positions
    int glyphWidths[256];
    int glyphHeight;
    int spacing;
} BitmapFont;

BitmapFont* loadBitmapFont(SDL_Renderer* renderer, const char* imagePath,
                           int glyphWidth, int glyphHeight, const char* charset) {
    BitmapFont* font = calloc(1, sizeof(BitmapFont));
    
    SDL_Surface* surface = IMG_Load(imagePath);
    if (!surface) return NULL;
    
    font->texture = SDL_CreateTextureFromSurface(renderer, surface);
    font->glyphHeight = glyphHeight;
    font->spacing = 1;
    
    int charsPerRow = surface->w / glyphWidth;
    int charsetLen = strlen(charset);
    
    for (int i = 0; i < charsetLen; i++) {
        unsigned char c = charset[i];
        int row = i / charsPerRow;
        int col = i % charsPerRow;
        
        font->glyphs[c].x = col * glyphWidth;
        font->glyphs[c].y = row * glyphHeight;
        font->glyphs[c].w = glyphWidth;
        font->glyphs[c].h = glyphHeight;
        font->glyphWidths[c] = glyphWidth;
    }
    
    SDL_FreeSurface(surface);
    
    return font;
}

void drawBitmapText(SDL_Renderer* renderer, BitmapFont* font,
                   const char* text, int x, int y) {
    int cursorX = x;
    
    for (int i = 0; text[i] != '\0'; i++) {
        unsigned char c = text[i];
        
        if (c == ' ') {
            cursorX += font->glyphWidths[c] + font->spacing;
            continue;
        }
        
        if (c == '\n') {
            cursorX = x;
            y += font->glyphHeight;
            continue;
        }
        
        SDL_Rect dest = {
            cursorX,
            y,
            font->glyphs[c].w,
            font->glyphs[c].h
        };
        
        SDL_RenderCopy(renderer, font->texture, &font->glyphs[c], &dest);
        
        cursorX += font->glyphWidths[c] + font->spacing;
    }
}

void destroyBitmapFont(BitmapFont* font) {
    SDL_DestroyTexture(font->texture);
    free(font);
}

3.5 Text Effects

// text_effects.c

// Wavy text effect
void drawWavyText(SDL_Renderer* renderer, TTF_Font* font,
                 const char* text, int x, int y, SDL_Color color, float time) {
    int cursorX = x;
    
    for (int i = 0; text[i] != '\0'; i++) {
        char charStr[2] = {text[i], '\0'};
        
        int w, h;
        TTF_SizeText(font, charStr, &w, &h);
        
        float wave = sinf(time * 3.0f + i * 0.5f) * 5.0f;
        int drawY = y + (int)wave;
        
        drawText(renderer, font, charStr, cursorX, drawY, color);
        
        cursorX += w;
    }
}

// Rainbow text effect
void drawRainbowText(SDL_Renderer* renderer, TTF_Font* font,
                    const char* text, int x, int y, float time) {
    int cursorX = x;
    
    for (int i = 0; text[i] != '\0'; i++) {
        char charStr[2] = {text[i], '\0'};
        
        int w, h;
        TTF_SizeText(font, charStr, &w, &h);
        
        // Calculate rainbow color
        float hue = fmodf(time + i * 0.1f, 1.0f);
        SDL_Color color = hsvToRgb(hue, 1.0f, 1.0f);
        
        drawText(renderer, font, charStr, cursorX, y, color);
        
        cursorX += w;
    }
}

// Typewriter effect (gradually reveal text)
void drawTypewriterText(SDL_Renderer* renderer, TTF_Font* font,
                       const char* text, int x, int y, SDL_Color color,
                       float progress) {
    int visibleChars = (int)(strlen(text) * progress);
    
    char buffer[256];
    strncpy(buffer, text, visibleChars);
    buffer[visibleChars] = '\0';
    
    drawText(renderer, font, buffer, x, y, color);
}

// Shadow text
void drawTextWithShadow(SDL_Renderer* renderer, TTF_Font* font,
                       const char* text, int x, int y, SDL_Color color,
                       int shadowOffsetX, int shadowOffsetY) {
    SDL_Color shadowColor = {0, 0, 0, 128};
    
    // Draw shadow
    drawText(renderer, font, text, x + shadowOffsetX, y + shadowOffsetY, shadowColor);
    
    // Draw text
    drawText(renderer, font, text, x, y, color);
}

// Helper: HSV to RGB conversion
SDL_Color hsvToRgb(float h, float s, float v) {
    SDL_Color rgb;
    
    int i = (int)(h * 6.0f);
    float f = h * 6.0f - i;
    float p = v * (1.0f - s);
    float q = v * (1.0f - f * s);
    float t = v * (1.0f - (1.0f - f) * s);
    
    switch (i % 6) {
        case 0: rgb.r = v * 255; rgb.g = t * 255; rgb.b = p * 255; break;
        case 1: rgb.r = q * 255; rgb.g = v * 255; rgb.b = p * 255; break;
        case 2: rgb.r = p * 255; rgb.g = v * 255; rgb.b = t * 255; break;
        case 3: rgb.r = p * 255; rgb.g = q * 255; rgb.b = v * 255; break;
        case 4: rgb.r = t * 255; rgb.g = p * 255; rgb.b = v * 255; break;
        case 5: rgb.r = v * 255; rgb.g = p * 255; rgb.b = q * 255; break;
    }
    
    rgb.a = 255;
    return rgb;
}

---

Chapter 4: Tilemap Architecture and Design

4.1 Tilemap Fundamentals

A tilemap is a grid of tiles that forms a game level:

Tile Grid (8x6):
┌───┬───┬───┬───┬───┬───┬───┬───┐
│ 0 │ 1 │ 1 │ 1 │ 1 │ 1 │ 1 │ 2 │  Row 0
├───┼───┼───┼───┼───┼───┼───┼───┤
│ 3 │ 4 │ 4 │ 4 │ 4 │ 4 │ 4 │ 5 │  Row 1
├───┼───┼───┼───┼───┼───┼───┼───┤
│ 3 │ 4 │ 4 │ 4 │ 4 │ 4 │ 4 │ 5 │  Row 2
└───┴───┴───┴───┴───┴───┴───┴───┘

Each number is a tile ID that references a tile in the tileset.

Benefits:

• Memory efficient (store integers, not textures)
• Fast rendering (batch same tiles)
• Easy level editing
• Simple collision detection

4.2 Core Tilemap Data Structures

// tilemap.h

#define MAX_TILES 256
#define MAX_LAYERS 8

typedef struct {
    int tileID;
    bool walkable;
    bool destructible;
    int userData;  // Custom data per tile
} TileProperties;

typedef struct {
    int* tiles;          // 2D array of tile IDs (stored as 1D)
    int width;           // Width in tiles
    int height;          // Height in tiles
    int tileWidth;       // Width of each tile in pixels
    int tileHeight;      // Height of each tile in pixels
} TileLayer;

typedef struct {
    SDL_Texture* tileset;     // Tileset image
    int tileWidth;
    int tileHeight;
    int tilesPerRow;
    int tileCount;
    TileProperties properties[MAX_TILES];
} Tileset;

typedef struct {
    Tileset tileset;
    TileLayer layers[MAX_LAYERS];
    int layerCount;
    int width;            // Total width in pixels
    int height;           // Total height in pixels
} Tilemap;

4.3 Creating Tilemaps

// tilemap_creation.c

Tilemap* createTilemap(int mapWidth, int mapHeight, int tileWidth, int tileHeight) {
    Tilemap* map = calloc(1, sizeof(Tilemap));
    
    map->tileset.tileWidth = tileWidth;
    map->tileset.tileHeight = tileHeight;
    map->width = mapWidth * tileWidth;
    map->height = mapHeight * tileHeight;
    map->layerCount = 0;
    
    return map;
}

TileLayer* addLayer(Tilemap* map, int width, int height) {
    if (map->layerCount >= MAX_LAYERS) return NULL;
    
    TileLayer* layer = &map->layers[map->layerCount++];
    layer->width = width;
    layer->height = height;
    layer->tileWidth = map->tileset.tileWidth;
    layer->tileHeight = map->tileset.tileHeight;
    layer->tiles = calloc(width * height, sizeof(int));
    
    return layer;
}

void setTile(TileLayer* layer, int x, int y, int tileID) {
    if (x < 0 || x >= layer->width || y < 0 || y >= layer->height) return;
    
    layer->tiles[y * layer->width + x] = tileID;
}

int getTile(TileLayer* layer, int x, int y) {
    if (x < 0 || x >= layer->width || y < 0 || y >= layer->height) return -1;
    
    return layer->tiles[y * layer->width + x];
}

void destroyTilemap(Tilemap* map) {
    for (int i = 0; i < map->layerCount; i++) {
        free(map->layers[i].tiles);
    }
    
    if (map->tileset.tileset) {
        SDL_DestroyTexture(map->tileset.tileset);
    }
    
    free(map);
}

4.4 Loading Tileset

// tileset_loading.c

bool loadTileset(Tilemap* map, SDL_Renderer* renderer, const char* imageFile) {
    SDL_Surface* surface = IMG_Load(imageFile);
    if (!surface) {
        printf("Failed to load tileset: %s\n", IMG_GetError());
        return false;
    }
    
    map->tileset.tileset = SDL_CreateTextureFromSurface(renderer, surface);
    map->tileset.tilesPerRow = surface->w / map->tileset.tileWidth;
    map->tileset.tileCount = (surface->w / map->tileset.tileWidth) *
                             (surface->h / map->tileset.tileHeight);
    
    SDL_FreeSurface(surface);
    
    printf("Loaded tileset: %d tiles, %d per row\n",
           map->tileset.tileCount, map->tileset.tilesPerRow);
    
    return true;
}

// Get source rectangle for a tile ID
SDL_Rect getTileSourceRect(Tileset* tileset, int tileID) {
    int row = tileID / tileset->tilesPerRow;
    int col = tileID % tileset->tilesPerRow;
    
    SDL_Rect src = {
        col * tileset->tileWidth,
        row * tileset->tileHeight,
        tileset->tileWidth,
        tileset->tileHeight
    };
    
    return src;
}

---

Chapter 5: Building a Tile Engine

5.1 Basic Tilemap Rendering

// tilemap_rendering.c

void renderTileLayer(SDL_Renderer* renderer, Tilemap* map, TileLayer* layer,
                    int cameraX, int cameraY) {
    // Calculate visible tile range (culling)
    int startCol = cameraX / layer->tileWidth;
    int startRow = cameraY / layer->tileHeight;
    int endCol = (cameraX + 800) / layer->tileWidth + 1;  // Assuming 800px viewport
    int endRow = (cameraY + 600) / layer->tileHeight + 1;  // Assuming 600px viewport
    
    // Clamp to map bounds
    if (startCol < 0) startCol = 0;
    if (startRow < 0) startRow = 0;
    if (endCol > layer->width) endCol = layer->width;
    if (endRow > layer->height) endRow = layer->height;
    
    // Render visible tiles
    for (int row = startRow; row < endRow; row++) {
        for (int col = startCol; col < endCol; col++) {
            int tileID = getTile(layer, col, row);
            
            if (tileID < 0) continue;  // Empty tile
            
            SDL_Rect src = getTileSourceRect(&map->tileset, tileID);
            
            SDL_Rect dest = {
                col * layer->tileWidth - cameraX,
                row * layer->tileHeight - cameraY,
                layer->tileWidth,
                layer->tileHeight
            };
            
            SDL_RenderCopy(renderer, map->tileset.tileset, &src, &dest);
        }
    }
}

void renderTilemap(SDL_Renderer* renderer, Tilemap* map, int cameraX, int cameraY) {
    for (int i = 0; i < map->layerCount; i++) {
        renderTileLayer(renderer, map, &map->layers[i], cameraX, cameraY);
    }
}

5.2 Optimized Rendering with Batching

// tilemap_batch.c

typedef struct {
    SDL_Rect src;
    SDL_Rect dest;
} TileBatch;

typedef struct {
    TileBatch* batches;
    int count;
    int capacity;
} TileRenderQueue;

TileRenderQueue* createRenderQueue(int capacity) {
    TileRenderQueue* queue = malloc(sizeof(TileRenderQueue));
    queue->batches = malloc(sizeof(TileBatch) * capacity);
    queue->count = 0;
    queue->capacity = capacity;
    return queue;
}

void addTileToQueue(TileRenderQueue* queue, SDL_Rect src, SDL_Rect dest) {
    if (queue->count >= queue->capacity) return;
    
    queue->batches[queue->count].src = src;
    queue->batches[queue->count].dest = dest;
    queue->count++;
}

void renderBatchedTiles(SDL_Renderer* renderer, SDL_Texture* tileset,
                       TileRenderQueue* queue) {
    for (int i = 0; i < queue->count; i++) {
        SDL_RenderCopy(renderer, tileset,
                      &queue->batches[i].src,
                      &queue->batches[i].dest);
    }
    
    queue->count = 0;  // Reset for next frame
}

void renderTilemapBatched(SDL_Renderer* renderer, Tilemap* map,
                         int cameraX, int cameraY) {
    TileRenderQueue* queue = createRenderQueue(10000);
    
    for (int layerIdx = 0; layerIdx < map->layerCount; layerIdx++) {
        TileLayer* layer = &map->layers[layerIdx];
        
        int startCol = cameraX / layer->tileWidth;
        int startRow = cameraY / layer->tileHeight;
        int endCol = (cameraX + 800) / layer->tileWidth + 1;
        int endRow = (cameraY + 600) / layer->tileHeight + 1;
        
        if (startCol < 0) startCol = 0;
        if (startRow < 0) startRow = 0;
        if (endCol > layer->width) endCol = layer->width;
        if (endRow > layer->height) endRow = layer->height;
        
        for (int row = startRow; row < endRow; row++) {
            for (int col = startCol; col < endCol; col++) {
                int tileID = getTile(layer, col, row);
                if (tileID < 0) continue;
                
                SDL_Rect src = getTileSourceRect(&map->tileset, tileID);
                SDL_Rect dest = {
                    col * layer->tileWidth - cameraX,
                    row * layer->tileHeight - cameraY,
                    layer->tileWidth,
                    layer->tileHeight
                };
                
                addTileToQueue(queue, src, dest);
            }
        }
    }
    
    renderBatchedTiles(renderer, map->tileset.tileset, queue);
    
    free(queue->batches);
    free(queue);
}

5.3 Coordinate Conversion

// tilemap_coords.c

// World position to tile coordinates
void worldToTile(Tilemap* map, float worldX, float worldY, int* tileX, int* tileY) {
    *tileX = (int)(worldX / map->tileset.tileWidth);
    *tileY = (int)(worldY / map->tileset.tileHeight);
}

// Tile coordinates to world position (center of tile)
void tileToWorld(Tilemap* map, int tileX, int tileY, float* worldX, float* worldY) {
    *worldX = tileX * map->tileset.tileWidth + map->tileset.tileWidth / 2.0f;
    *worldY = tileY * map->tileset.tileHeight + map->tileset.tileHeight / 2.0f;
}

// Get tile at world position
int getTileAtPosition(Tilemap* map, int layerIndex, float worldX, float worldY) {
    int tileX, tileY;
    worldToTile(map, worldX, worldY, &tileX, &tileY);
    
    if (layerIndex < 0 || layerIndex >= map->layerCount) return -1;
    
    return getTile(&map->layers[layerIndex], tileX, tileY);
}

// Set tile at world position
void setTileAtPosition(Tilemap* map, int layerIndex, float worldX, float worldY, int tileID) {
    int tileX, tileY;
    worldToTile(map, worldX, worldY, &tileX, &tileY);
    
    if (layerIndex < 0 || layerIndex >= map->layerCount) return;
    
    setTile(&map->layers[layerIndex], tileX, tileY, tileID);
}

---

Chapter 10: Isometric and Hexagonal Tilemaps

10.1 Isometric Coordinate Conversion

// isometric.h

// Screen to isometric tile coordinates
void screenToIso(int screenX, int screenY, int tileWidth, int tileHeight,
                 int* isoX, int* isoY) {
    *isoX = (screenX / (tileWidth / 2) + screenY / (tileHeight / 2)) / 2;
    *isoY = (screenY / (tileHeight / 2) - screenX / (tileWidth / 2)) / 2;
}

// Isometric tile to screen coordinates
void isoToScreen(int isoX, int isoY, int tileWidth, int tileHeight,
                int* screenX, int* screenY) {
    *screenX = (isoX - isoY) * (tileWidth / 2);
    *screenY = (isoX + isoY) * (tileHeight / 2);
}

// Render isometric tilemap
void renderIsometric TileLayer(SDL_Renderer* renderer, Tileset* tileset,
                              TileLayer* layer, int cameraX, int cameraY) {
    for (int y = 0; y < layer->height; y++) {
        for (int x = 0; x < layer->width; x++) {
            int tileID = getTile(layer, x, y);
            if (tileID < 0) continue;
            
            int screenX, screenY;
            isoToScreen(x, y, layer->tileWidth, layer->tileHeight,
                       &screenX, &screenY);
            
            screenX -= cameraX;
            screenY -= cameraY;
            
            SDL_Rect src = getTileSourceRect(tileset, tileID);
            SDL_Rect dest = {screenX, screenY, layer->tileWidth, layer->tileHeight};
            
            SDL_RenderCopy(renderer, tileset->tileset, &src, &dest);
        }
    }
}

10.2 Hexagonal Tilemaps

// hexagonal.h

typedef enum {
    HEX_POINTY_TOP,  // ⬡
    HEX_FLAT_TOP     // ⬢
} HexOrientation;

typedef struct {
    float x, y;
} HexCoord;

// Hex grid conversion
HexCoord hexToPixel(int q, int r, float hexSize, HexOrientation orientation) {
    HexCoord pixel;
    
    if (orientation == HEX_POINTY_TOP) {
        pixel.x = hexSize * (sqrt(3.0f) * q + sqrt(3.0f) / 2.0f * r);
        pixel.y = hexSize * (3.0f / 2.0f * r);
    } else {  // FLAT_TOP
        pixel.x = hexSize * (3.0f / 2.0f * q);
        pixel.y = hexSize * (sqrt(3.0f) / 2.0f * q + sqrt(3.0f) * r);
    }
    
    return pixel;
}

void pixelToHex(float x, float y, float hexSize, HexOrientation orientation,
               int* q, int* r) {
    float q_frac, r_frac;
    
    if (orientation == HEX_POINTY_TOP) {
        q_frac = (sqrt(3.0f) / 3.0f * x - 1.0f / 3.0f * y) / hexSize;
        r_frac = (2.0f / 3.0f * y) / hexSize;
    } else {  // FLAT_TOP
        q_frac = (2.0f / 3.0f * x) / hexSize;
        r_frac = (-1.0f / 3.0f * x + sqrt(3.0f) / 3.0f * y) / hexSize;
    }
    
    // Cube rounding
    float s_frac = -q_frac - r_frac;
    
    int q_int = roundf(q_frac);
    int r_int = roundf(r_frac);
    int s_int = roundf(s_frac);
    
    float q_diff = fabsf(q_int - q_frac);
    float r_diff = fabsf(r_int - r_frac);
    float s_diff = fabsf(s_int - s_frac);
    
    if (q_diff > r_diff && q_diff > s_diff) {
        q_int = -r_int - s_int;
    } else if (r_diff > s_diff) {
        r_int = -q_int - s_int;
    }
    
    *q = q_int;
    *r = r_int;
}

---

Chapter 11: Asset Manager Architecture

11.1 Universal Asset Manager

// asset_manager.h

#define MAX_ASSETS 1024

typedef struct {
    char path[256];
    char name[64];
    AssetType type;
    void* data;
    size_t size;
    int refCount;
    bool loaded;
    Uint32 lastAccessed;
} Asset;

typedef struct {
    Asset assets[MAX_ASSETS];
    int assetCount;
    
    // Cache limits
    size_t maxCacheSize;
    size_t currentCacheSize;
    
    // Paths
    char basePath[256];
} AssetManager;

AssetManager* createAssetManager(const char* basePath, size_t maxCacheSize) {
    AssetManager* am = calloc(1, sizeof(AssetManager));
    strncpy(am->basePath, basePath, sizeof(am->basePath) - 1);
    am->maxCacheSize = maxCacheSize;
    am->currentCacheSize = 0;
    am->assetCount = 0;
    return am;
}

// Register asset (doesn't load yet)
int registerAsset(AssetManager* am, const char* path, const char* name,
                 AssetType type) {
    if (am->assetCount >= MAX_ASSETS) return -1;
    
    Asset* asset = &am->assets[am->assetCount];
    
    // Build full path
    snprintf(asset->path, sizeof(asset->path), "%s/%s", am->basePath, path);
    strncpy(asset->name, name, sizeof(asset->name) - 1);
    asset->type = type;
    asset->data = NULL;
    asset->refCount = 0;
    asset->loaded = false;
    asset->lastAccessed = 0;
    
    return am->assetCount++;
}

// Find asset by name
Asset* findAsset(AssetManager* am, const char* name) {
    for (int i = 0; i < am->assetCount; i++) {
        if (strcmp(am->assets[i].name, name) == 0) {
            return &am->assets[i];
        }
    }
    return NULL;
}

11.2 Asset Loading and Unloading

// asset_loading.c

void* loadAsset(AssetManager* am, SDL_Renderer* renderer, const char* name) {
    Asset* asset = findAsset(am, name);
    if (!asset) {
        printf("Asset not found: %s\n", name);
        return NULL;
    }
    
    // Already loaded - increment ref count
    if (asset->loaded) {
        asset->refCount++;
        asset->lastAccessed = SDL_GetTicks();
        return asset->data;
    }
    
    // Load based on type
    switch (asset->type) {
        case ASSET_TEXTURE: {
            SDL_Surface* surface = IMG_Load(asset->path);
            if (surface) {
                asset->data = SDL_CreateTextureFromSurface(renderer, surface);
                asset->size = surface->w * surface->h * 4;  // Estimate
                SDL_FreeSurface(surface);
            }
            break;
        }
        
        case ASSET_FONT: {
            int fontSize = 24;  // Default, should be configurable
            asset->data = TTF_OpenFont(asset->path, fontSize);
            asset->size = 50000;  // Estimate
            break;
        }
        
        case ASSET_SOUND: {
            asset->data = Mix_LoadWAV(asset->path);
            if (asset->data) {
                Mix_Chunk* chunk = (Mix_Chunk*)asset->data;
                asset->size = chunk->alen;
            }
            break;
        }
        
        case ASSET_MUSIC: {
            asset->data = Mix_LoadMUS(asset->path);
            asset->size = 1000000;  // Estimate
            break;
        }
        
        case ASSET_MAP: {
            asset->data = loadTMX(renderer, asset->path);
            asset->size = 100000;  // Estimate
            break;
        }
        
        default:
            printf("Unknown asset type\n");
            return NULL;
    }
    
    if (asset->data) {
        asset->loaded = true;
        asset->refCount = 1;
        asset->lastAccessed = SDL_GetTicks();
        am->currentCacheSize += asset->size;
        
        printf("Loaded asset: %s (%zu bytes)\n", asset->name, asset->size);
        
        // Check if we need to free some assets
        while (am->currentCacheSize > am->maxCacheSize) {
            unloadLeastRecentlyUsed(am);
        }
    } else {
        printf("Failed to load asset: %s\n", asset->path);
    }
    
    return asset->data;
}

void unloadAsset(AssetManager* am, const char* name) {
    Asset* asset = findAsset(am, name);
    if (!asset || !asset->loaded) return;
    
    asset->refCount--;
    
    if (asset->refCount <= 0) {
        // Free the asset
        switch (asset->type) {
            case ASSET_TEXTURE:
                SDL_DestroyTexture((SDL_Texture*)asset->data);
                break;
            case ASSET_FONT:
                TTF_CloseFont((TTF_Font*)asset->data);
                break;
            case ASSET_SOUND:
                Mix_FreeChunk((Mix_Chunk*)asset->data);
                break;
            case ASSET_MUSIC:
                Mix_FreeMusic((Mix_Music*)asset->data);
                break;
            case ASSET_MAP:
                destroyTilemap((Tilemap*)asset->data);
                break;
        }
        
        am->currentCacheSize -= asset->size;
        asset->data = NULL;
        asset->loaded = false;
        asset->refCount = 0;
        
        printf("Unloaded asset: %s\n", asset->name);
    }
}

void unloadLeastRecentlyUsed(AssetManager* am) {
    Asset* oldest = NULL;
    Uint32 oldestTime = UINT32_MAX;
    
    for (int i = 0; i < am->assetCount; i++) {
        Asset* asset = &am->assets[i];
        
        if (asset->loaded && asset->refCount == 0 && 
            asset->lastAccessed < oldestTime) {
            oldest = asset;
            oldestTime = asset->lastAccessed;
        }
    }
    
    if (oldest) {
        unloadAsset(am, oldest->name);
    }
}

void destroyAssetManager(AssetManager* am) {
    for (int i = 0; i < am->assetCount; i++) {
        if (am->assets[i].loaded) {
            unloadAsset(am, am->assets[i].name);
        }
    }
    free(am);
}

11.3 Asset Preloading and Streaming

// asset_streaming.c

#include <pthread.h>

typedef struct {
    AssetManager* am;
    SDL_Renderer* renderer;
    char** assetNames;
    int assetCount;
    int loadedCount;
    bool complete;
    pthread_t thread;
} AssetLoader;

void* assetLoadThread(void* arg) {
    AssetLoader* loader = (AssetLoader*)arg;
    
    for (int i = 0; i < loader->assetCount; i++) {
        loadAsset(loader->am, loader->renderer, loader->assetNames[i]);
        loader->loadedCount++;
        
        // Small delay to prevent thrashing
        SDL_Delay(10);
    }
    
    loader->complete = true;
    return NULL;
}

AssetLoader* startAssetLoading(AssetManager* am, SDL_Renderer* renderer,
                               char** assetNames, int count) {
    AssetLoader* loader = malloc(sizeof(AssetLoader));
    loader->am = am;
    loader->renderer = renderer;
    loader->assetNames = assetNames;
    loader->assetCount = count;
    loader->loadedCount = 0;
    loader->complete = false;
    
    pthread_create(&loader->thread, NULL, assetLoadThread, loader);
    
    return loader;
}

float getLoadingProgress(AssetLoader* loader) {
    if (loader->assetCount == 0) return 1.0f;
    return (float)loader->loadedCount / loader->assetCount;
}

void waitForAssetLoading(AssetLoader* loader) {
    pthread_join(loader->thread, NULL);
    free(loader);
}

---

Chapter 12: Texture Atlas and Sprite Sheet Management

12.1 Sprite Sheet Packing

// sprite_sheet.h

typedef struct {
    char name[64];
    int x, y, width, height;
    int offsetX, offsetY;  // Trim offset
    int sourceWidth, sourceHeight;  // Original size before trim
} SpriteFrame;

typedef struct {
    SDL_Texture* texture;
    SpriteFrame* frames;
    int frameCount;
    int textureWidth;
    int textureHeight;
} SpriteSheet;

SpriteSheet* createSpriteSheet(SDL_Renderer* renderer, const char* imagePath) {
    SpriteSheet* sheet = calloc(1, sizeof(SpriteSheet));
    
    SDL_Surface* surface = IMG_Load(imagePath);
    if (!surface) return NULL;
    
    sheet->texture = SDL_CreateTextureFromSurface(renderer, surface);
    sheet->textureWidth = surface->w;
    sheet->textureHeight = surface->h;
    
    SDL_FreeSurface(surface);
    
    return sheet;
}

void addSpriteFrame(SpriteSheet* sheet, const char* name,
                   int x, int y, int w, int h) {
    if (!sheet->frames) {
        sheet->frames = malloc(sizeof(SpriteFrame) * 256);
        sheet->frameCount = 0;
    }
    
    SpriteFrame* frame = &sheet->frames[sheet->frameCount++];
    strncpy(frame->name, name, sizeof(frame->name) - 1);
    frame->x = x;
    frame->y = y;
    frame->width = w;
    frame->height = h;
    frame->offsetX = 0;
    frame->offsetY = 0;
    frame->sourceWidth = w;
    frame->sourceHeight = h;
}

SpriteFrame* findFrame(SpriteSheet* sheet, const char* name) {
    for (int i = 0; i < sheet->frameCount; i++) {
        if (strcmp(sheet->frames[i].name, name) == 0) {
            return &sheet->frames[i];
        }
    }
    return NULL;
}

void drawSprite(SDL_Renderer* renderer, SpriteSheet* sheet,
               const char* frameName, int x, int y) {
    SpriteFrame* frame = findFrame(sheet, frameName);
    if (!frame) return;
    
    SDL_Rect src = {frame->x, frame->y, frame->width, frame->height};
    SDL_Rect dest = {
        x - frame->offsetX,
        y - frame->offsetY,
        frame->width,
        frame->height
    };
    
    SDL_RenderCopy(renderer, sheet->texture, &src, &dest);
}

12.2 Loading TexturePacker JSON

// texturepacker_loader.c

// Parse TexturePacker JSON format
SpriteSheet* loadTexturePackerJSON(SDL_Renderer* renderer,
                                   const char* jsonPath,
                                   const char* imagePath) {
    // Read JSON file
    FILE* file = fopen(jsonPath, "r");
    if (!file) return NULL;
    
    fseek(file, 0, SEEK_END);
    long fileSize = ftell(file);
    fseek(file, 0, SEEK_SET);
    
    char* jsonData = malloc(fileSize + 1);
    fread(jsonData, 1, fileSize, file);
    jsonData[fileSize] = '\0';
    fclose(file);
    
    // Create sprite sheet
    SpriteSheet* sheet = createSpriteSheet(renderer, imagePath);
    if (!sheet) {
        free(jsonData);
        return NULL;
    }
    
    // Parse JSON (simplified - use cJSON or similar in production)
    char* ptr = strstr(jsonData, "\"frames\"");
    if (!ptr) {
        free(jsonData);
        return sheet;
    }
    
    // Extract frames
    // (Full JSON parsing implementation omitted for brevity)
    // In production, use a proper JSON library like cJSON
    
    free(jsonData);
    return sheet;
}

12.3 Nine-Slice Scaling

// nine_slice.h

typedef struct {
    SDL_Texture* texture;
    int left, right, top, bottom;  // Border sizes
    int sourceWidth, sourceHeight;
} NineSlice;

NineSlice* createNineSlice(SDL_Renderer* renderer, const char* imagePath,
                          int left, int right, int top, int bottom) {
    NineSlice* slice = malloc(sizeof(NineSlice));
    
    SDL_Surface* surface = IMG_Load(imagePath);
    if (!surface) {
        free(slice);
        return NULL;
    }
    
    slice->texture = SDL_CreateTextureFromSurface(renderer, surface);
    slice->sourceWidth = surface->w;
    slice->sourceHeight = surface->h;
    slice->left = left;
    slice->right = right;
    slice->top = top;
    slice->bottom = bottom;
    
    SDL_FreeSurface(surface);
    return slice;
}

void drawNineSlice(SDL_Renderer* renderer, NineSlice* slice,
                  int x, int y, int width, int height) {
    int sw = slice->sourceWidth;
    int sh = slice->sourceHeight;
    int l = slice->left;
    int r = slice->right;
    int t = slice->top;
    int b = slice->bottom;
    
    // Calculate dimensions
    int centerW = sw - l - r;
    int centerH = sh - t - b;
    int scaledCenterW = width - l - r;
    int scaledCenterH = height - t - b;
    
    // Top-left corner
    SDL_Rect src = {0, 0, l, t};
    SDL_Rect dest = {x, y, l, t};
    SDL_RenderCopy(renderer, slice->texture, &src, &dest);
    
    // Top edge
    src = (SDL_Rect){l, 0, centerW, t};
    dest = (SDL_Rect){x + l, y, scaledCenterW, t};
    SDL_RenderCopy(renderer, slice->texture, &src, &dest);
    
    // Top-right corner
    src = (SDL_Rect){sw - r, 0, r, t};
    dest = (SDL_Rect){x + width - r, y, r, t};
    SDL_RenderCopy(renderer, slice->texture, &src, &dest);
    
    // Left edge
    src = (SDL_Rect){0, t, l, centerH};
    dest = (SDL_Rect){x, y + t, l, scaledCenterH};
    SDL_RenderCopy(renderer, slice->texture, &src, &dest);
    
    // Center
    src = (SDL_Rect){l, t, centerW, centerH};
    dest = (SDL_Rect){x + l, y + t, scaledCenterW, scaledCenterH};
    SDL_RenderCopy(renderer, slice->texture, &src, &dest);
    
    // Right edge
    src = (SDL_Rect){sw - r, t, r, centerH};
    dest = (SDL_Rect){x + width - r, y + t, r, scaledCenterH};
    SDL_RenderCopy(renderer, slice->texture, &src, &dest);
    
    // Bottom-left corner
    src = (SDL_Rect){0, sh - b, l, b};
    dest = (SDL_Rect){x, y + height - b, l, b};
    SDL_RenderCopy(renderer, slice->texture, &src, &dest);
    
    // Bottom edge
    src = (SDL_Rect){l, sh - b, centerW, b};
    dest = (SDL_Rect){x + l, y + height - b, scaledCenterW, b};
    SDL_RenderCopy(renderer, slice->texture, &src, &dest);
    
    // Bottom-right corner
    src = (SDL_Rect){sw - r, sh - b, r, b};
    dest = (SDL_Rect){x + width - r, y + height - b, r, b};
    SDL_RenderCopy(renderer, slice->texture, &src, &dest);
}

---

Chapter 13: Audio Asset Management

13.1 SDL_mixer Initialization

// audio_system.h

#include <SDL2/SDL_mixer.h>

#define MAX_SOUNDS 256
#define MAX_MUSIC_TRACKS 32

typedef struct {
    Mix_Chunk* chunks[MAX_SOUNDS];
    int chunkCount;
    
    Mix_Music* musicTracks[MAX_MUSIC_TRACKS];
    int musicCount;
    
    int masterVolume;
    int musicVolume;
    int sfxVolume;
    
    int currentMusicTrack;
    bool musicPlaying;
} AudioManager;

bool initAudioSystem(int frequency, Uint16 format, int channels, int chunksize) {
    if (Mix_OpenAudio(frequency, format, channels, chunksize) < 0) {
        printf("SDL_mixer initialization failed: %s\n", Mix_GetError());
        return false;
    }
    
    // Allocate mixing channels
    Mix_AllocateChannels(32);
    
    printf("Audio system initialized:\n");
    printf("  Frequency: %d Hz\n", frequency);
    printf("  Channels: %d\n", channels);
    printf("  Chunk size: %d\n", chunksize);
    
    return true;
}

AudioManager* createAudioManager() {
    AudioManager* am = calloc(1, sizeof(AudioManager));
    
    am->masterVolume = MIX_MAX_VOLUME;
    am->musicVolume = MIX_MAX_VOLUME;
    am->sfxVolume = MIX_MAX_VOLUME;
    am->currentMusicTrack = -1;
    am->musicPlaying = false;
    
    return am;
}

13.2 Sound Effect Management

// sound_manager.c

int loadSound(AudioManager* am, const char* path, const char* name) {
    if (am->chunkCount >= MAX_SOUNDS) {
        printf("Max sounds reached\n");
        return -1;
    }
    
    Mix_Chunk* chunk = Mix_LoadWAV(path);
    if (!chunk) {
        printf("Failed to load sound %s: %s\n", path, Mix_GetError());
        return -1;
    }
    
    int id = am->chunkCount;
    am->chunks[id] = chunk;
    am->chunkCount++;
    
    printf("Loaded sound: %s (ID: %d)\n", name, id);
    
    return id;
}

int playSound(AudioManager* am, int soundID, int loops) {
    if (soundID < 0 || soundID >= am->chunkCount) return -1;
    
    int channel = Mix_PlayChannel(-1, am->chunks[soundID], loops);
    
    if (channel >= 0) {
        int volume = (am->sfxVolume * am->masterVolume) / MIX_MAX_VOLUME;
        Mix_Volume(channel, volume);
    }
    
    return channel;
}

void setSoundVolume(AudioManager* am, int channel, float volume) {
    int vol = (int)(volume * MIX_MAX_VOLUME);
    vol = (vol * am->sfxVolume * am->masterVolume) / 
          (MIX_MAX_VOLUME * MIX_MAX_VOLUME);
    Mix_Volume(channel, vol);
}

void stopSound(int channel) {
    Mix_HaltChannel(channel);
}

void stopAllSounds() {
    Mix_HaltChannel(-1);
}

13.3 Sound Groups and Categories

// sound_groups.h

typedef struct {
    int* channels;
    int channelCount;
    int channelCapacity;
    float volume;
    bool muted;
} SoundGroup;

typedef struct {
    SoundGroup groups[16];
    int groupCount;
} SoundGroupManager;

SoundGroup* createSoundGroup(SoundGroupManager* sgm) {
    if (sgm->groupCount >= 16) return NULL;
    
    SoundGroup* group = &sgm->groups[sgm->groupCount++];
    group->channels = malloc(sizeof(int) * 32);
    group->channelCount = 0;
    group->channelCapacity = 32;
    group->volume = 1.0f;
    group->muted = false;
    
    return group;
}

void addChannelToGroup(SoundGroup* group, int channel) {
    if (group->channelCount >= group->channelCapacity) {
        group->channelCapacity *= 2;
        group->channels = realloc(group->channels,
                                 sizeof(int) * group->channelCapacity);
    }
    
    group->channels[group->channelCount++] = channel;
}

void setGroupVolume(SoundGroup* group, float volume) {
    group->volume = volume;
    
    if (!group->muted) {
        for (int i = 0; i < group->channelCount; i++) {
            Mix_Volume(group->channels[i], (int)(volume * MIX_MAX_VOLUME));
        }
    }
}

void muteGroup(SoundGroup* group, bool mute) {
    group->muted = mute;
    
    int volume = mute ? 0 : (int)(group->volume * MIX_MAX_VOLUME);
    
    for (int i = 0; i < group->channelCount; i++) {
        Mix_Volume(group->channels[i], volume);
    }
}

---

Chapter 14: Music System and Streaming

14.1 Music Loading and Playback

// music_manager.c

int loadMusic(AudioManager* am, const char* path, const char* name) {
    if (am->musicCount >= MAX_MUSIC_TRACKS) {
        printf("Max music tracks reached\n");
        return -1;
    }
    
    Mix_Music* music = Mix_LoadMUS(path);
    if (!music) {
        printf("Failed to load music %s: %s\n", path, Mix_GetError());
        return -1;
    }
    
    int id = am->musicCount;
    am->musicTracks[id] = music;
    am->musicCount++;
    
    printf("Loaded music: %s (ID: %d)\n", name, id);
    
    return id;
}

void playMusic(AudioManager* am, int musicID, int loops) {
    if (musicID < 0 || musicID >= am->musicCount) return;
    
    // Stop current music
    if (am->musicPlaying) {
        Mix_HaltMusic();
    }
    
    int volume = (am->musicVolume * am->masterVolume) / MIX_MAX_VOLUME;
    Mix_VolumeMusic(volume);
    
    if (Mix_PlayMusic(am->musicTracks[musicID], loops) == 0) {
        am->currentMusicTrack = musicID;
        am->musicPlaying = true;
    }
}

void pauseMusic(AudioManager* am) {
    if (am->musicPlaying) {
        Mix_PauseMusic();
    }
}

void resumeMusic(AudioManager* am) {
    if (am->musicPlaying) {
        Mix_ResumeMusic();
    }
}

void stopMusic(AudioManager* am) {
    Mix_HaltMusic();
    am->musicPlaying = false;
    am->currentMusicTrack = -1;
}

void setMusicVolume(AudioManager* am, float volume) {
    am->musicVolume = (int)(volume * MIX_MAX_VOLUME);
    
    int vol = (am->musicVolume * am->masterVolume) / MIX_MAX_VOLUME;
    Mix_VolumeMusic(vol);
}

14.2 Music Crossfading

// music_crossfade.c

typedef struct {
    AudioManager* am;
    int fromTrack;
    int toTrack;
    float duration;
    float elapsed;
    bool active;
} MusicCrossfade;

void startMusicCrossfade(MusicCrossfade* cf, AudioManager* am,
                        int toTrack, float duration) {
    cf->am = am;
    cf->fromTrack = am->currentMusicTrack;
    cf->toTrack = toTrack;
    cf->duration = duration;
    cf->elapsed = 0;
    cf->active = true;
    
    // Start new track at volume 0
    playMusic(am, toTrack, -1);
    Mix_VolumeMusic(0);
}

void updateMusicCrossfade(MusicCrossfade* cf, float dt) {
    if (!cf->active) return;
    
    cf->elapsed += dt;
    float t = cf->elapsed / cf->duration;
    
    if (t >= 1.0f) {
        // Crossfade complete
        t = 1.0f;
        cf->active = false;
    }
    
    int newVolume = (int)(t * cf->am->musicVolume);
    newVolume = (newVolume * cf->am->masterVolume) / MIX_MAX_VOLUME;
    Mix_VolumeMusic(newVolume);
}

// Music callback for seamless looping
void musicFinishedCallback() {
    // Restart music or start next track
}

void setupMusicCallbacks() {
    Mix_HookMusicFinished(musicFinishedCallback);
}

14.3 Adaptive Music System

// adaptive_music.h

typedef struct {
    int introTrack;
    int loopTrack;
    int* layerTracks;  // Different instrument layers
    int layerCount;
    bool* layersActive;
    float* layerVolumes;
} AdaptiveMusic;

AdaptiveMusic* createAdaptiveMusic(int layers) {
    AdaptiveMusic* am = calloc(1, sizeof(AdaptiveMusic));
    am->layerCount = layers;
    am->layerTracks = malloc(sizeof(int) * layers);
    am->layersActive = malloc(sizeof(bool) * layers);
    am->layerVolumes = malloc(sizeof(float) * layers);
    
    // Initialize all layers
    for (int i = 0; i < layers; i++) {
        am->layersActive[i] = false;
        am->layerVolumes[i] = 1.0f;
    }
    
    return am;
}

void playAdaptiveMusic(AdaptiveMusic* am, AudioManager* audio) {
    // Play intro
    if (am->introTrack >= 0) {
        playMusic(audio, am->introTrack, 1);
    }
    
    // Start all layers (muted initially)
    for (int i = 0; i < am->layerCount; i++) {
        // Layers would need separate Mix_Music instances
        // In practice, might use separate channels or mix externally
    }
}

void setMusicIntensity(AdaptiveMusic* am, float intensity) {
    // Activate layers based on intensity
    int activeLayerCount = (int)(intensity * am->layerCount);
    
    for (int i = 0; i < am->layerCount; i++) {
        am->layersActive[i] = (i < activeLayerCount);
        // Fade layer volume
    }
}

---

Chapter 15: Sound Effects and Mixing

15.1 3D Positional Audio

// positional_audio.c

typedef struct {
    float x, y, z;
} AudioListener;

void setListenerPosition(AudioListener* listener, float x, float y, float z) {
    listener->x = x;
    listener->y = y;
    listener->z = z;
}

void play3DSound(AudioManager* am, int soundID, float x, float y, float z,
                AudioListener* listener, float maxDistance) {
    if (soundID < 0 || soundID >= am->chunkCount) return;
    
    // Calculate distance
    float dx = x - listener->x;
    float dy = y - listener->y;
    float dz = z - listener->z;
    float distance = sqrtf(dx*dx + dy*dy + dz*dz);
    
    // Distance attenuation
    float attenuation = 1.0f;
    if (distance > maxDistance) {
        return;  // Too far, don't play
    } else if (distance > 0) {
        attenuation = 1.0f - (distance / maxDistance);
    }
    
    // Play sound
    int channel = Mix_PlayChannel(-1, am->chunks[soundID], 0);
    if (channel < 0) return;
    
    // Set volume based on distance
    int volume = (int)(attenuation * am->sfxVolume);
    Mix_Volume(channel, volume);
    
    // Set panning based on left-right position
    float angle = atan2f(dx, dz);
    Uint8 left = (Uint8)(127.0f * (1.0f + sinf(angle)));
    Uint8 right = 255 - left;
    Mix_SetPanning(channel, left, right);
}

15.2 Sound Effects Processing

// audio_effects.c

// Fade in/out
void fadeInSound(int channel, int ms) {
    Mix_FadeInChannel(channel, NULL, 0, ms);
}

void fadeOutSound(int channel, int ms) {
    Mix_FadeOutChannel(channel, ms);
}

// Echo effect
void addEcho(Mix_Chunk* chunk, int delay_ms, float decay) {
    int sampleRate = 44100;
    int delaySamples = (sampleRate * delay_ms) / 1000;
    
    Uint32 newLen = chunk->alen + delaySamples * 2;  // 16-bit audio
    Uint8* newBuffer = malloc(newLen);
    
    // Copy original
    memcpy(newBuffer, chunk->abuf, chunk->alen);
    
    // Add echo
    Sint16* original = (Sint16*)chunk->abuf;
    Sint16* output = (Sint16*)newBuffer;
    int samples = chunk->alen / 2;
    
    for (int i = delaySamples; i < samples + delaySamples; i++) {
        float sample = output[i] + original[i - delaySamples] * decay;
        
        // Clamp
        if (sample > 32767) sample = 32767;
        if (sample < -32768) sample = -32768;
        
        output[i] = (Sint16)sample;
    }
    
    // Replace chunk data
    free(chunk->abuf);
    chunk->abuf = newBuffer;
    chunk->alen = newLen;
}

// Pitch shifting (simple speed-based)
void changePitch(int channel, float pitch) {
    // SDL_mixer doesn't support pitch shifting directly
    // Would need external library like SoLoud or PortAudio
}

15.3 Dynamic Sound Mixing

// dynamic_mixing.c

typedef struct {
    int priority;
    float volume;
    int channel;
    Uint32 startTime;
    bool oneShot;
} PlayingSound;

typedef struct {
    PlayingSound sounds[32];
    int soundCount;
} SoundMixer;

int playPrioritizedSound(SoundMixer* mixer, AudioManager* am, int soundID,
                        int priority, float volume, bool oneShot) {
    // Find available channel or lowest priority sound
    int channel = -1;
    int lowestPriority = INT_MAX;
    int lowestPriorityIdx = -1;
    
    for (int i = 0; i < 32; i++) {
        if (!Mix_Playing(i)) {
            channel = i;
            break;
        }
        
        // Find lowest priority channel
        if (mixer->sounds[i].priority < lowestPriority) {
            lowestPriority = mixer->sounds[i].priority;
            lowestPriorityIdx = i;
        }
    }
    
    // If no free channel and this sound is higher priority
    if (channel < 0 && priority > lowestPriority) {
        channel = lowestPriorityIdx;
        Mix_HaltChannel(channel);
    }
    
    if (channel < 0) return -1;  // Couldn't play
    
    // Play sound
    Mix_PlayChannel(channel, am->chunks[soundID], 0);
    Mix_Volume(channel, (int)(volume * MIX_MAX_VOLUME));
    
    // Record in mixer
    if (channel < 32) {
        mixer->sounds[channel].priority = priority;
        mixer->sounds[channel].volume = volume;
        mixer->sounds[channel].channel = channel;
        mixer->sounds[channel].startTime = SDL_GetTicks();
        mixer->sounds[channel].oneShot = oneShot;
    }
    
    return channel;
}

---

I'll continue with the remaining chapters. Let me complete the guide:

Chapter 16: Resource Loading and Streaming

16.1 Asynchronous Asset Loading

// async_loader.h

typedef struct {
    char path[256];
    AssetType type;
    void* result;
    bool complete;
    bool success;
} LoadRequest;

typedef struct {
    LoadRequest requests[64];
    int requestCount;
    pthread_t workerThread;
    bool running;
    pthread_mutex_t mutex;
} AsyncLoader;

AsyncLoader* createAsyncLoader() {
    AsyncLoader* loader = malloc(sizeof(AsyncLoader));
    loader->requestCount = 0;
    loader->running = true;
    pthread_mutex_init(&loader->mutex, NULL);
    pthread_create(&loader->workerThread, NULL, loaderWorkerFunc, loader);
    return loader;
}

void* loaderWorkerFunc(void* arg) {
    AsyncLoader* loader = (AsyncLoader*)arg;
    
    while (loader->running) {
        pthread_mutex_lock(&loader->mutex);
        
        for (int i = 0; i < loader->requestCount; i++) {
            LoadRequest* req = &loader->requests[i];
            
            if (!req->complete) {
                // Load asset based on type
                switch (req->type) {
                    case ASSET_TEXTURE: {
                        SDL_Surface* surface = IMG_Load(req->path);
                        req->result = surface;  // Convert to texture on main thread
                        req->success = (surface != NULL);
                        break;
                    }
                    // Other types...
                }
                
                req->complete = true;
            }
        }
        
        pthread_mutex_unlock(&loader->mutex);
        SDL_Delay(16);  // ~60fps check rate
    }
    
    return NULL;
}

int queueAssetLoad(AsyncLoader* loader, const char* path, AssetType type) {
    pthread_mutex_lock(&loader->mutex);
    
    if (loader->requestCount >= 64) {
        pthread_mutex_unlock(&loader->mutex);
        return -1;
    }
    
    LoadRequest* req = &loader->requests[loader->requestCount];
    strncpy(req->path, path, sizeof(req->path) - 1);
    req->type = type;
    req->complete = false;
    req->success = false;
    req->result = NULL;
    
    int id = loader->requestCount++;
    
    pthread_mutex_unlock(&loader->mutex);
    
    return id;
}

bool checkLoadComplete(AsyncLoader* loader, int requestID) {
    if (requestID < 0 || requestID >= loader->requestCount) return false;
    return loader->requests[requestID].complete;
}

16.2 Streaming Textures

// texture_streaming.c

typedef struct {
    SDL_Texture* lowRes;   // Low resolution version loaded immediately
    SDL_Texture* highRes;  // High resolution streamed in
    bool highResLoaded;
    int width, height;
} StreamedTexture;

StreamedTexture* createStreamedTexture(SDL_Renderer* renderer,
                                      const char* lowResPath,
                                      const char* highResPath) {
    StreamedTexture* tex = calloc(1, sizeof(StreamedTexture));
    
    // Load low-res immediately
    tex->lowRes = IMG_LoadTexture(renderer, lowResPath);
    if (tex->lowRes) {
        SDL_QueryTexture(tex->lowRes, NULL, NULL, &tex->width, &tex->height);
    }
    
    tex->highResLoaded = false;
    tex->highRes = NULL;
    
    // Queue high-res for loading
    // (Use async loader from previous section)
    
    return tex;
}

SDL_Texture* getStreamedTexture(StreamedTexture* tex) {
    return tex->highResLoaded ? tex->highRes : tex->lowRes;
}

void updateStreamedTexture(StreamedTexture* tex, SDL_Renderer* renderer) {
    if (!tex->highResLoaded && tex->highRes) {
        // High res finished loading
        tex->highResLoaded = true;
        
        // Can optionally free low-res now
        if (tex->lowRes) {
            SDL_DestroyTexture(tex->lowRes);
            tex->lowRes = NULL;
        }
    }
}

16.3 Level Streaming

// level_streaming.h

typedef struct {
    Tilemap* map;
    bool loaded;
    char path[256];
} Level;

typedef struct {
    Level levels[16];
    int levelCount;
    int currentLevel;
    int loadingLevel;
    AsyncLoader* loader;
} LevelManager;

void startLevelLoad(LevelManager* lm, int levelIndex) {
    if (levelIndex < 0 || levelIndex >= lm->levelCount) return;
    
    lm->loadingLevel = levelIndex;
    
    // Queue for async loading
    queueAssetLoad(lm->loader, lm->levels[levelIndex].path, ASSET_MAP);
}

void updateLevelStreaming(LevelManager* lm, SDL_Renderer* renderer) {
    if (lm->loadingLevel >= 0) {
        // Check if loading complete
        Level* level = &lm->levels[lm->loadingLevel];
        
        if (!level->loaded /* check async loader */) {
            // Load complete!
            level->loaded = true;
            
            // Unload old level
            if (lm->currentLevel >= 0 && lm->currentLevel != lm->loadingLevel) {
                destroyTilemap(lm->levels[lm->currentLevel].map);
                lm->levels[lm->currentLevel].loaded = false;
            }
            
            lm->currentLevel = lm->loadingLevel;
            lm->loadingLevel = -1;
        }
    }
}

---

Chapter 17: Asset Bundling and Packaging

17.1 Custom Asset Archive Format

// asset_archive.h

#define ARCHIVE_MAGIC 0x41535354  // "ASST"
#define ARCHIVE_VERSION 1

typedef struct {
    uint32_t magic;
    uint32_t version;
    uint32_t fileCount;
    uint32_t indexOffset;
} ArchiveHeader;

typedef struct {
    char name[64];
    uint32_t offset;
    uint32_t size;
    uint32_t compressedSize;
    bool compressed;
} FileEntry;

typedef struct {
    FILE* file;
    ArchiveHeader header;
    FileEntry* entries;
} Archive;

Archive* openArchive(const char* path) {
    Archive* archive = calloc(1, sizeof(Archive));
    
    archive->file = fopen(path, "rb");
    if (!archive->file) {
        free(archive);
        return NULL;
    }
    
    // Read header
    fread(&archive->header, sizeof(ArchiveHeader), 1, archive->file);
    
    if (archive->header.magic != ARCHIVE_MAGIC) {
        printf("Invalid archive format\n");
        fclose(archive->file);
        free(archive);
        return NULL;
    }
    
    // Read file entries
    fseek(archive->file, archive->header.indexOffset, SEEK_SET);
    archive->entries = malloc(sizeof(FileEntry) * archive->header.fileCount);
    fread(archive->entries, sizeof(FileEntry), archive->header.fileCount, archive->file);
    
    printf("Opened archive with %d files\n", archive->header.fileCount);
    
    return archive;
}

void* readFileFromArchive(Archive* archive, const char* filename, size_t* outSize) {
    // Find file entry
    FileEntry* entry = NULL;
    for (uint32_t i = 0; i < archive->header.fileCount; i++) {
        if (strcmp(archive->entries[i].name, filename) == 0) {
            entry = &archive->entries[i];
            break;
        }
    }
    
    if (!entry) {
        printf("File not found in archive: %s\n", filename);
        return NULL;
    }
    
    // Read file data
    fseek(archive->file, entry->offset, SEEK_SET);
    
    void* data = malloc(entry->size);
    
    if (entry->compressed) {
        // Read compressed data
        void* compressed = malloc(entry->compressedSize);
        fread(compressed, 1, entry->compressedSize, archive->file);
        
        // Decompress (using zlib or similar)
        // uncompress(data, &entry->size, compressed, entry->compressedSize);
        
        free(compressed);
    } else {
        // Read uncompressed
        fread(data, 1, entry->size, archive->file);
    }
    
    if (outSize) *outSize = entry->size;
    
    return data;
}

void closeArchive(Archive* archive) {
    if (archive->file) fclose(archive->file);
    free(archive->entries);
    free(archive);
}

17.2 Creating Archives

// archive_builder.c

typedef struct {
    FILE* output;
    FileEntry* entries;
    int entryCount;
    int entryCapacity;
    uint32_t currentOffset;
} ArchiveBuilder;

ArchiveBuilder* createArchiveBuilder(const char* outputPath) {
    ArchiveBuilder* builder = calloc(1, sizeof(ArchiveBuilder));
    
    builder->output = fopen(outputPath, "wb");
    if (!builder->output) {
        free(builder);
        return NULL;
    }
    
    builder->entryCapacity = 256;
    builder->entries = malloc(sizeof(FileEntry) * builder->entryCapacity);
    builder->entryCount = 0;
    
    // Reserve space for header (write at end)
    builder->currentOffset = sizeof(ArchiveHeader);
    fseek(builder->output, builder->currentOffset, SEEK_SET);
    
    return builder;
}

void addFileToArchive(ArchiveBuilder* builder, const char* name, const char* path,
                     bool compress) {
    if (builder->entryCount >= builder->entryCapacity) {
        builder->entryCapacity *= 2;
        builder->entries = realloc(builder->entries,
                                  sizeof(FileEntry) * builder->entryCapacity);
    }
    
    FileEntry* entry = &builder->entries[builder->entryCount++];
    strncpy(entry->name, name, sizeof(entry->name) - 1);
    entry->offset = builder->currentOffset;
    
    // Read file
    FILE* input = fopen(path, "rb");
    if (!input) {
        printf("Failed to open file: %s\n", path);
        builder->entryCount--;
        return;
    }
    
    fseek(input, 0, SEEK_END);
    entry->size = ftell(input);
    fseek(input, 0, SEEK_SET);
    
    void* data = malloc(entry->size);
    fread(data, 1, entry->size, input);
    fclose(input);
    
    // Optionally compress
    if (compress) {
        // Use zlib to compress
        // uLongf compressedSize = compressBound(entry->size);
        // void* compressed = malloc(compressedSize);
        // compress(compressed, &compressedSize, data, entry->size);
        
        // For now, just store uncompressed
        entry->compressed = false;
        entry->compressedSize = entry->size;
    } else {
        entry->compressed = false;
        entry->compressedSize = entry->size;
    }
    
    // Write to archive
    fwrite(data, 1, entry->size, builder->output);
    builder->currentOffset += entry->size;
    
    free(data);
    
    printf("Added to archive: %s (%u bytes)\n", name, entry->size);
}

void finalizeArchive(ArchiveBuilder* builder) {
    // Write file index
    uint32_t indexOffset = builder->currentOffset;
    fwrite(builder->entries, sizeof(FileEntry), builder->entryCount, builder->output);
    
    // Write header
    ArchiveHeader header;
    header.magic = ARCHIVE_MAGIC;
    header.version = ARCHIVE_VERSION;
    header.fileCount = builder->entryCount;
    header.indexOffset = indexOffset;
    
    fseek(builder->output, 0, SEEK_SET);
    fwrite(&header, sizeof(ArchiveHeader), 1, builder->output);
    
    fclose(builder->output);
    free(builder->entries);
    free(builder);
    
    printf("Archive created with %d files\n", builder->entryCount);
}

---

Chapter 18: Performance Optimization for Assets

18.1 Texture Compression

// texture_optimization.c

// Convert texture to optimal format
SDL_Texture* createOptimizedTexture(SDL_Renderer* renderer, SDL_Surface* surface) {
    // Convert to 32-bit RGBA if not already
    SDL_Surface* optimized = SDL_ConvertSurfaceFormat(surface,
                                                      SDL_PIXELFORMAT_RGBA32,
                                                      0);
    
    SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, optimized);
    SDL_FreeSurface(optimized);
    
    // Set texture filtering
    SDL_SetTextureScaleMode(texture, SDL_ScaleModeLinear);
    
    return texture;
}

// Mipmap generation (for scaling)
void generateMipmaps(SDL_Surface* surface, SDL_Surface** mipmaps, int levels) {
    mipmaps[0] = surface;
    
    for (int i = 1; i < levels; i++) {
        int w = mipmaps[i-1]->w / 2;
        int h = mipmaps[i-1]->h / 2;
        
        if (w < 1 || h < 1) break;
        
        mipmaps[i] = SDL_CreateRGBSurfaceWithFormat(0, w, h, 32,
                                                    SDL_PIXELFORMAT_RGBA32);
        
        // Downsample (simple box filter)
        Uint32* src = (Uint32*)mipmaps[i-1]->pixels;
        Uint32* dst = (Uint32*)mipmaps[i]->pixels;
        
        for (int y = 0; y < h; y++) {
            for (int x = 0; x < w; x++) {
                // Average 2x2 pixels
                Uint32 p0 = src[(y*2) * mipmaps[i-1]->w + (x*2)];
                Uint32 p1 = src[(y*2) * mipmaps[i-1]->w + (x*2+1)];
                Uint32 p2 = src[(y*2+1) * mipmaps[i-1]->w + (x*2)];
                Uint32 p3 = src[(y*2+1) * mipmaps[i-1]->w + (x*2+1)];
                
                // Simple average (not gamma-correct, but fast)
                Uint8 r = ((p0 >> 24) + (p1 >> 24) + (p2 >> 24) + (p3 >> 24)) / 4;
                Uint8 g = (((p0 >> 16) & 0xFF) + ((p1 >> 16) & 0xFF) + 
                          ((p2 >> 16) & 0xFF) + ((p3 >> 16) & 0xFF)) / 4;
                Uint8 b = (((p0 >> 8) & 0xFF) + ((p1 >> 8) & 0xFF) +
                          ((p2 >> 8) & 0xFF) + ((p3 >> 8) & 0xFF)) / 4;
                Uint8 a = ((p0 & 0xFF) + (p1 & 0xFF) + (p2 & 0xFF) + (p3 & 0xFF)) / 4;
                
                dst[y * w + x] = (r << 24) | (g << 16) | (b << 8) | a;
            }
        }
    }
}

18.2 Audio Optimization

// audio_optimization.c

// Convert audio to optimal format
Mix_Chunk* optimizeSound(const char* path, int targetQuality) {
    Mix_Chunk* chunk = Mix_LoadWAV(path);
    if (!chunk) return NULL;
    
    // For lossy compression, would need external library
    // SDL_mixer loads WAV, FLAC, MP3, OGG natively
    
    // Set volume normalization
    float peak = 0;
    Sint16* samples = (Sint16*)chunk->abuf;
    int sampleCount = chunk->alen / 2;
    
    for (int i = 0; i < sampleCount; i++) {
        float sample = fabsf(samples[i] / 32768.0f);
        if (sample > peak) peak = sample;
    }
    
    if (peak > 0 && peak < 1.0f) {
        float gain = 1.0f / peak;
        for (int i = 0; i < sampleCount; i++) {
            float sample = samples[i] * gain;
            if (sample > 32767) sample = 32767;
            if (sample < -32768) sample = -32768;
            samples[i] = (Sint16)sample;
        }
    }
    
    return chunk;
}

// Trim silence from audio
Mix_Chunk* trimSilence(Mix_Chunk* chunk, float threshold) {
    Sint16* samples = (Sint16*)chunk->abuf;
    int sampleCount = chunk->alen / 2;
    
    // Find start of audio
    int start = 0;
    for (int i = 0; i < sampleCount; i++) {
        if (fabsf(samples[i] / 32768.0f) > threshold) {
            start = i;
            break;
        }
    }
    
    // Find end of audio
    int end = sampleCount - 1;
    for (int i = sampleCount - 1; i >= 0; i--) {
        if (fabsf(samples[i] / 32768.0f) > threshold) {
            end = i;
            break;
        }
    }
    
    // Create trimmed chunk
    int newLen = (end - start + 1) * 2;
    Mix_Chunk* trimmed = malloc(sizeof(Mix_Chunk));
    trimmed->allocated = 1;
    trimmed->abuf = malloc(newLen);
    trimmed->alen = newLen;
    trimmed->volume = chunk->volume;
    
    memcpy(trimmed->abuf, &samples[start], newLen);
    
    return trimmed;
}

18.3 Memory Profiling

// memory_profiler.c

typedef struct {
    const char* category;
    size_t bytesAllocated;
    int allocationCount;
} MemoryCategory;

typedef struct {
    MemoryCategory categories[32];
    int categoryCount;
    size_t totalAllocated;
    size_t peakAllocated;
} MemoryProfiler;

static MemoryProfiler globalProfiler = {0};

void trackAllocation(const char* category, size_t size) {
    // Find or create category
    int catIndex = -1;
    for (int i = 0; i < globalProfiler.categoryCount; i++) {
        if (strcmp(globalProfiler.categories[i].category, category) == 0) {
            catIndex = i;
            break;
        }
    }
    
    if (catIndex < 0 && globalProfiler.categoryCount < 32) {
        catIndex = globalProfiler.categoryCount++;
        globalProfiler.categories[catIndex].category = category;
        globalProfiler.categories[catIndex].bytesAllocated = 0;
        globalProfiler.categories[catIndex].allocationCount = 0;
    }
    
    if (catIndex >= 0) {
        globalProfiler.categories[catIndex].bytesAllocated += size;
        globalProfiler.categories[catIndex].allocationCount++;
    }
    
    globalProfiler.totalAllocated += size;
    if (globalProfiler.totalAllocated > globalProfiler.peakAllocated) {
        globalProfiler.peakAllocated = globalProfiler.totalAllocated;
    }
}

void printMemoryReport() {
    printf("\n=== Memory Profile ===\n");
    printf("Total: %.2f MB (Peak: %.2f MB)\n",
           globalProfiler.totalAllocated / 1024.0f / 1024.0f,
           globalProfiler.peakAllocated / 1024.0f / 1024.0f);
    printf("\nBy Category:\n");
    
    for (int i = 0; i < globalProfiler.categoryCount; i++) {
        MemoryCategory* cat = &globalProfiler.categories[i];
        printf("  %-20s: %.2f MB (%d allocations)\n",
               cat->category,
               cat->bytesAllocated / 1024.0f / 1024.0f,
               cat->allocationCount);
    }
}

---

Chapter 19: Complete Game Examples

19.1 Platformer with Tilemap

// platformer_game.c

typedef struct {
    SDL_Window* window;
    SDL_Renderer* renderer;
    FontManager* fontMgr;
    AssetManager* assetMgr;
    AudioManager* audioMgr;
    
    Tilemap* currentLevel;
    Entity player;
    
    float cameraX, cameraY;
    int score;
    int lives;
    bool running;
} PlatformerGame;

PlatformerGame* createPlatformerGame() {
    PlatformerGame* game = calloc(1, sizeof(PlatformerGame));
    
    SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO);
    TTF_Init();
    
    game->window = SDL_CreateWindow("Platformer",
        SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
        800, 600, SDL_WINDOW_SHOWN);
    
    game->renderer = SDL_CreateRenderer(game->window, -1,
        SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
    
    initAudioSystem(44100, MIX_DEFAULT_FORMAT, 2, 2048);
    
    game->fontMgr = initFontManager();
    game->assetMgr = createAssetManager("assets", 100 * 1024 * 1024);
    game->audioMgr = createAudioManager();
    
    // Register assets
    registerAsset(game->assetMgr, "maps/level1.tmx", "level1", ASSET_MAP);
    registerAsset(game->assetMgr, "sprites/player.png", "player", ASSET_TEXTURE);
    registerAsset(game->assetMgr, "fonts/game.ttf", "gameFont", ASSET_FONT);
    registerAsset(game->assetMgr, "music/level.ogg", "levelMusic", ASSET_MUSIC);
    registerAsset(game->assetMgr, "sfx/jump.wav", "jumpSound", ASSET_SOUND);
    registerAsset(game->assetMgr, "sfx/coin.wav", "coinSound", ASSET_SOUND);
    
    game->score = 0;
    game->lives = 3;
    game->running = true;
    
    return game;
}

void loadLevel(PlatformerGame* game, const char* levelName) {
    game->currentLevel = loadAsset(game->assetMgr, game->renderer, levelName);
    
    // Find player spawn point from object layer
    // (Implementation depends on TMX object handling)
    
    game->cameraX = 0;
    game->cameraY = 0;
    
    // Start level music
    int musicID = loadMusic(game->audioMgr,
        "assets/music/level.ogg", "levelMusic");
    playMusic(game->audioMgr, musicID, -1);
}

void updatePlatformerGame(PlatformerGame* game, float dt) {
    // Handle input
    const Uint8* keys = SDL_GetKeyboardState(NULL);
    
    float moveSpeed = 200.0f;
    float jumpSpeed = 400.0f;
    
    // Player movement
    float velX = 0;
    if (keys[SDL_SCANCODE_LEFT]) velX = -moveSpeed;
    if (keys[SDL_SCANCODE_RIGHT]) velX = moveSpeed;
    
    // Jump
    static bool onGround = false;
    if (keys[SDL_SCANCODE_SPACE] && onGround) {
        // Apply jump
        // Play jump sound
        playSound(game->audioMgr, /* jump sound ID */, 0);
    }
    
    // Update player physics
    // Check tile collisions
    // Update camera
    
    game->cameraX = game->player.x - 400;
    game->cameraY = game->player.y - 300;
    
    // Clamp camera to level bounds
    if (game->cameraX < 0) game->cameraX = 0;
    if (game->cameraY < 0) game->cameraY = 0;
}

void renderPlatformerGame(PlatformerGame* game) {
    SDL_SetRenderDrawColor(game->renderer, 135, 206, 235, 255);  // Sky blue
    SDL_RenderClear(game->renderer);
    
    // Render tilemap
    renderTilemap(game->renderer, game->currentLevel,
                 (int)game->cameraX, (int)game->cameraY);
    
    // Render player
    // Render UI
    
    SDL_Color white = {255, 255, 255, 255};
    char scoreText[32];
    snprintf(scoreText, sizeof(scoreText), "Score: %d", game->score);
    
    TTF_Font* font = loadFont(game->fontMgr, "assets/fonts/game.ttf", 24, "gameFont");
    drawText(game->renderer, font, scoreText, 10, 10, white);
    
    SDL_RenderPresent(game->renderer);
}

int main() {
    PlatformerGame* game = createPlatformerGame();
    loadLevel(game, "level1");
    
    Uint64 lastTime = SDL_GetPerformanceCounter();
    
    while (game->running) {
        Uint64 currentTime = SDL_GetPerformanceCounter();
        float dt = (float)(currentTime - lastTime) / SDL_GetPerformanceFrequency();
        lastTime = currentTime;
        
        if (dt > 0.05f) dt = 0.05f;
        
        SDL_Event event;
        while (SDL_PollEvent(&event)) {
            if (event.type == SDL_QUIT) {
                game->running = false;
            }
        }
        
        updatePlatformerGame(game, dt);
        renderPlatformerGame(game);
    }
    
    // Cleanup
    return 0;
}

19.2 Top-Down RPG with Tilemaps

// rpg_game.c - Simpler example showing key concepts

void renderTopDownRPG(SDL_Renderer* renderer, Tilemap* map,
                     Entity* player, float cameraX, float cameraY) {
    // Render ground layers
    for (int i = 0; i < map->layerCount; i++) {
        if (map->layers[i].zOrder < player->z) {
            renderTileLayer(renderer, map, &map->layers[i], cameraX, cameraY);
        }
    }
    
    // Render player
    renderPlayer(renderer, player, cameraX, cameraY);
    
    // Render layers above player
    for (int i = 0; i < map->layerCount; i++) {
        if (map->layers[i].zOrder >= player->z) {
            renderTileLayer(renderer, map, &map->layers[i], cameraX, cameraY);
        }
    }
}

---

Chapter 20: Production Asset Pipeline

20.1 Asset Management Workflow

┌──────────────┐
│   Artists    │ Create content in tools (Photoshop, Tiled, etc.)
└──────┬───────┘
       │
       ↓
┌──────────────┐
│   Export     │ Save to source formats (PSD → PNG, etc.)
└──────┬───────┘
       │
       ↓
┌──────────────┐
│   Process    │ Optimize, compress, generate mipmaps
└──────┬───────┘
       │
       ↓
┌──────────────┐
│   Package    │ Bundle into archives
└──────┬───────┘
       │
       ↓
┌──────────────┐
│     Game     │ Load and use assets
└──────────────┘

20.2 Build Script Example

#!/bin/bash
# build_assets.sh

echo "Building game assets..."

# Create output directories
mkdir -p build/assets/textures
mkdir -p build/assets/maps
mkdir -p build/assets/audio

# Optimize textures
for file in assets/textures/*.png; do
    echo "Optimizing $file..."
    pngcrush -reduce "$file" "build/$file"
done

# Process tilemaps
for file in assets/maps/*.tmx; do
    echo "Processing $file..."
    cp "$file" "build/$file"
done

# Convert audio to OGG
for file in assets/music/*.wav; do
    echo "Converting $file to OGG..."
    oggenc -q 6 "$file" -o "build/${file%.wav}.ogg"
done

# Normalize sound effects
for file in assets/sfx/*.wav; do
    echo "Normalizing $file..."
    sox "$file" "build/$file" norm
done

# Create asset archive
echo "Creating asset archive..."
./archive_builder build/assets build/game.pak

echo "Asset build complete!"

20.3 Hot Reloading System

// hot_reload.h

typedef struct {
    char path[256];
    time_t lastModified;
    void* asset;
    AssetType type;
    void (*reloadCallback)(void* asset);
} WatchedAsset;

typedef struct {
    WatchedAsset assets[256];
    int assetCount;
} AssetWatcher;

void watchAsset(AssetWatcher* watcher, const char* path, AssetType type,
               void* asset, void (*callback)(void*)) {
    if (watcher->assetCount >= 256) return;
    
    WatchedAsset* wa = &watcher->assets[watcher->assetCount++];
    strncpy(wa->path, path, sizeof(wa->path) - 1);
    wa->type = type;
    wa->asset = asset;
    wa->reloadCallback = callback;
    
    struct stat fileStat;
    stat(path, &fileStat);
    wa->lastModified = fileStat.st_mtime;
}

void checkForChanges(AssetWatcher* watcher) {
    for (int i = 0; i < watcher->assetCount; i++) {
        WatchedAsset* wa = &watcher->assets[i];
        
        struct stat fileStat;
        if (stat(wa->path, &fileStat) == 0) {
            if (fileStat.st_mtime > wa->lastModified) {
                printf("Asset changed: %s - Reloading...\n", wa->path);
                
                // Reload asset
                if (wa->reloadCallback) {
                    wa->reloadCallback(wa->asset);
                }
                
                wa->lastModified = fileStat.st_mtime;
            }
        }
    }
}

---

Conclusion

You've completed a comprehensive journey through tilemaps, fonts, and asset management!

What You've Learned:

Fonts (Chapters 1-3):

• SDL_ttf fundamentals and initialization
• Text rendering techniques (solid, shaded, blended)
• Font styles, outlines, and Unicode support
• Text caching and layout systems
• Word wrapping and alignment
• Bitmap fonts for performance
• Text effects (wavy, rainbow, typewriter, shadows)

Tilemaps (Chapters 4-10):

• Tilemap architecture and data structures
• Tileset loading and management
• Efficient rendering with culling and batching
• TMX file format and Tiled integration
• Layered rendering and parallax scrolling
• Tile-based collision detection and response
• Slopes and one-way platforms
• Animated tiles and auto-tiling
• Isometric and hexagonal tile systems

Asset Management (Chapters 11-18):

• Universal asset manager architecture
• Loading, unloading, and reference counting
• Texture atlas and sprite sheet systems
• Nine-slice scaling
• SDL_mixer audio initialization
• Sound effect management and 3D positioning
• Music playback and crossfading
• Asynchronous loading and streaming
• Asset bundling and archives
• Optimization techniques
• Memory profiling

Production (Chapters 19-20):

• Complete game examples
• Production asset pipeline
• Build automation
• Hot reloading for development

Next Steps:

1. Build a Complete Game - Use these systems together
2. Optimize - Profile and improve performance
3. Extend - Add particle systems, dialogue, cutscenes
4. Polish - Juice, screen shake, effects
5. Ship - Package and distribute your game!

Resources:

• SDL2: https://www.libsdl.org/
• SDL_ttf: https://www.libsdl.org/projects/SDL_ttf/
• SDL_mixer: https://www.libsdl.org/projects/SDL_mixer/
• SDL_image: https://www.libsdl.org/projects/SDL_image/
• Tiled Map Editor: https://www.mapeditor.org/
• TexturePacker: https://www.codeandweb.com/texturepacker

The asset pipeline is crucial for professional game development. Master these concepts and you'll be able to build scalable, maintainable games with rich content!

Happy coding, and may your textures load fast and your sounds play smooth! 🎮🎨🎵