Documented bigmap.c

#include <tonc.h>
#include "map.h"
#include "maps/bigmap.h"
#include "assets/pokemonMap.h"
#include "assets/Pal0.h"
#include "assets/Pal1.h"
#include "assets/Pal2.h"
#include "assets/Pal3.h"
#include "assets/Pal4.h"
#include "assets/Pal5.h"
#include "assets/Pal6.h"

static void append_map_column(int src_tile_x, int src_tile_y);
static void append_map_row(int src_tile_x, int src_tile_y);

Viewport g_viewport;
TMap g_map;

void init_map(POINT16 start_pos) {
    g_map.bgNum = 0;
    g_map.srcMap = (SCR_ENTRY*) BG_0;
    g_map.dstMap = se_mem[31]; // One 256x256p map takes up a single screenblock
    g_map.srcMapWidth = BIGMAP_WIDTH;
    g_map.srcMapHeight = BIGMAP_HEIGHT;

    // Copy base tiles to charblock 0
    GRIT_CPY(tile_mem[0], pokemonMapTiles);

    centre_viewport(start_pos);
    g_viewport.prevOffset = g_viewport.offset;

    // Tile coordinates (in 128x128t srcMap space) of the top left corner of the viewport
    int src_y = g_viewport.offset.y / 8;
    int src_x = g_viewport.offset.x / 8;

    // Copy first 32x32 tiles around the start pos. from srcMap into dstMap (se_mem)
    for (int y = 0; y < 32; y++) {
        append_map_row(src_x, src_y);
        src_y++;
    }

    // Copy palettes to correct banks in BG pallete memory
    GRIT_CPY(pal_bg_bank[0], Pal0Pal);
    GRIT_CPY(pal_bg_bank[1], Pal1Pal);
    GRIT_CPY(pal_bg_bank[2], Pal2Pal);
    GRIT_CPY(pal_bg_bank[3], Pal3Pal);
    GRIT_CPY(pal_bg_bank[4], Pal4Pal);
    GRIT_CPY(pal_bg_bank[5], Pal5Pal);
    GRIT_CPY(pal_bg_bank[6], Pal6Pal);

    REG_BGCNT[g_map.bgNum] = BG_CBB(0) | BG_SBB(31) | BG_4BPP | BG_REG_32x32;
}

void centre_viewport(POINT16 pt) {
    g_viewport.offset.x = clamp(pt.x - (SCREEN_WIDTH / 2), 0, 1024 - SCREEN_WIDTH);
    g_viewport.offset.y = clamp(pt.y - (SCREEN_HEIGHT / 2), 0, 1024 - SCREEN_HEIGHT);
}

/*
    Check whether the viewport has shifted to another tile (up/down/left/right) this frame.
    If it has, copy one 32t row/column of srcMap over to dstMap to give the appearance of a
    larger continuously scrolling map.

    Since regular backgrounds wrap around by default, REG_BG_OFS (the viewport offset) is modulo
    256x256p (dimensions of dstMap). We can thus write the newly exposed row/column from srcMap
    to the row/column in 32x32t dstMap space that is just outside the dimensions of the
    viewport (in the direction of the shift).

    The result is that the viewport will always show a 240x160p slice of dstMap that corresponds
    to the "camera's position" in srcMap (centred around the player's position).
*/
void update_map() {
    // Tile coordinates of the viewport in srcMap
    int prev_tile_x = g_viewport.prevOffset.x / 8;
    int prev_tile_y = g_viewport.prevOffset.y / 8;
    int curr_tile_x = g_viewport.offset.x / 8;
    int curr_tile_y = g_viewport.offset.y / 8;

    if (curr_tile_x < prev_tile_x) {
        append_map_column(curr_tile_x, curr_tile_y); // Append from left side of srcMap
    } else if (curr_tile_x > prev_tile_x) {
        append_map_column(curr_tile_x + 31, curr_tile_y); // Append from right side of srcMap
    }

    if (curr_tile_y < prev_tile_y) {
        append_map_row(curr_tile_x, curr_tile_y); // Append from top row of srcMap
    } else if (curr_tile_y > prev_tile_y) {
        append_map_row(curr_tile_x, curr_tile_y + 31); // Append from bottom row of srcMap
    }

    g_viewport.prevOffset = g_viewport.offset;
    REG_BG_OFS[g_map.bgNum] = g_viewport.offset;
}

/*
    Write one 32t column of SCR_ENTRIES from srcMap to dstMap.
    Called when the viewport has moved to a new tile coordinate
    towards the left or right this frame.

    Parameters: The tile coordinates (in range [srcWidth, srcHeight]) of either
        a) the top left corner, or
        b) the top right corner
    of the viewport window.

    The column is retrieved from srcMap tile coords
    (x = src_tile_x, y in [src_tile_y, src_tile_y + 31]).

    It's copied over to
    (x = dst_tile_x, y in [0, 31]).
*/
static void append_map_column(int src_tile_x, int src_tile_y) {
    // Find a corresponding column in the 32x32t space of dstMap
    int dst_tile_x = src_tile_x % 32;
    int dst_tile_y = src_tile_y % 32;

    // SCR_ENTRY of the newly exposed tile (top left/right of viewport) in srcMap
    SCR_ENTRY* src_entry = &g_map.srcMap[src_tile_y * g_map.srcMapWidth + src_tile_x];

    // SCR_ENTRY in dstMap (left/rightmost edge of the viewport offset) to write the new tile to
    SCR_ENTRY* dst_entry = &g_map.dstMap[dst_tile_y * 32 + dst_tile_x];

    // Copy over every tile to dstMap for y range [dst_tile_y, dst_tile_y + 31]
    for(int y = dst_tile_y; y < 32; y++) {
        // Write a single tile
        *dst_entry= *src_entry;

        // Move dst_entry pointer down one tile (dst_tile_y++)
        dst_entry += 32;
        // Move src_entry pointer down one tile (src_tile_y++)
        src_entry += g_map.srcMapWidth;
    }

    // Move dst_entry pointer up to y = 0
    dst_entry -= 1024;

    // Copy over every tile to dstMap for y range [0, dst_tile_y - 1]
    for(int y = 0; y < dst_tile_y; y++) {
        *dst_entry= *src_entry;

        dst_entry += 32;
        src_entry += g_map.srcMapWidth;
    }
}

/*
    Write one 32t row of SCR_ENTRIES from srcMap to dstMap.
    Called when the viewport has moved up or down one tile coordinate
    this frame.

    Parameters: The tile coordinates (in range [srcWidth, srcHeight]) of either
        a) the top left corner, or
        b) the bottom left corner
    of the viewport window.

    The row is retrieved from srcMap tile coords
    (x in [src_tile_x, src_tile_x + 31], y = src_tile_y).

    It's copied over to
    (x in [0, 31], y = dst_tile_y).
*/
static void append_map_row(int src_tile_x, int src_tile_y) {
    // Find a corresponding row in the 32x32t space of dstMap
    int dst_tile_x = src_tile_x % 32;
    int dst_tile_y = src_tile_y % 32;

    // SCR_ENTRY of the newly exposed tile (top/bottom left of viewport) in srcMap
    SCR_ENTRY* src_entry = &g_map.srcMap[src_tile_y * g_map.srcMapWidth + src_tile_x];

    // SCR_ENTRY in dstMap (top/bottom edge of the viewport offset) to write the new tile to
    SCR_ENTRY* dst_entry = &g_map.dstMap[dst_tile_y * 32 + dst_tile_x];

    // Write every tile to dstMap from x in [dst_tile_x, 31]
    for(int x = dst_tile_x; x < 32; x++) {
        *dst_entry = *src_entry;

        dst_entry++;
        src_entry++;
    }

    // Move dst_entry back to x = 0
    dst_entry -= 32;

    // Write every tile to dstMap from x in [0, dst_tile_x - 1]
    for(int x = 0; x < dst_tile_x; x++) {
        *dst_entry = *src_entry;

        dst_entry++;
        src_entry++;
    }
}