tas/major_tom
1
0
Fork 1
Code Issues 3 Pull Requests Actions Packages Projects Releases Wiki Activity
Files
79e9d0e2adf6775c6384010e93be7edbce6005c1
major_tom/src/game/editor.c

1621 lines
64 KiB
C
Raw Blame History

#include "game/editor.h"
#include "game/entity_registry.h"
#include "game/transition.h"
#include "engine/core.h"
#include "engine/input.h"
#include "engine/renderer.h"
#include "engine/assets.h"
#include "engine/camera.h"
#include "engine/font.h"
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#ifdef __EMSCRIPTEN__
#include <emscripten.h>
/* ═══════════════════════════════════════════════════
* Browser file I/O helpers (Emscripten only)
*
* Save: write .lvl to virtual FS, then trigger
* browser download via Blob URL.
* Load: open an <input type="file"> dialog, read
* the file contents, write to virtual FS,
* and set a flag for the editor to pick up.
* ═══════════════════════════════════════════════════ */
/* Download a file from the Emscripten virtual FS to the user's machine */
EM_JS(void, browser_download_file, (const char *vfs_path, const char *download_name), {
var path = UTF8ToString(vfs_path);
var name = UTF8ToString(download_name);
try {
var data = FS.readFile(path);
var blob = new Blob([data], { type: 'text/plain' });
var url = URL.createObjectURL(blob);
var a = document.createElement('a');
a.href = url;
a.download = name;
document.body.appendChild(a);
a.click();
setTimeout(function() {
document.body.removeChild(a);
URL.revokeObjectURL(url);
}, 100);
} catch (e) {
console.error('Download failed:', e);
}
});
/* Path where uploaded file will be written in virtual FS */
#define UPLOAD_VFS_PATH "/tmp/_upload.lvl"
/* Flags polled by editor_update — set by JS */
static volatile int s_upload_ready = 0; /* file upload completed */
static volatile int s_save_request = 0; /* Ctrl+S or Save button */
static volatile int s_load_request = 0; /* Ctrl+O or Load button */
/* Path to load when s_load_request is 2 (load a specific VFS file) */
static char s_load_vfs_path[256] = {0};
/* Open a browser file picker; on selection, write contents to virtual FS */
EM_JS(void, browser_open_file_picker, (), {
var input = document.createElement('input');
input.type = 'file';
input.accept = '.lvl,.txt';
input.onchange = function(e) {
var file = e.target.files[0];
if (!file) return;
var reader = new FileReader();
reader.onload = function(ev) {
var data = new Uint8Array(ev.target.result);
try { FS.unlink('/tmp/_upload.lvl'); } catch(x) {}
FS.writeFile('/tmp/_upload.lvl', data);
/* Set the C flag via direct heap access */
var ptr = _editor_upload_flag_ptr();
HEAP32[ptr >> 2] = 1;
};
reader.readAsArrayBuffer(file);
};
input.click();
});
/* Export addresses so JS can set flags and paths */
EMSCRIPTEN_KEEPALIVE
int *editor_upload_flag_ptr(void) {
return (int *)&s_upload_ready;
}
EMSCRIPTEN_KEEPALIVE
int *editor_save_flag_ptr(void) {
return (int *)&s_save_request;
}
EMSCRIPTEN_KEEPALIVE
int *editor_load_flag_ptr(void) {
return (int *)&s_load_request;
}
/* Called from JS to load an existing level file from the virtual FS */
EMSCRIPTEN_KEEPALIVE
void editor_load_vfs_file(const char *path) {
snprintf(s_load_vfs_path, sizeof(s_load_vfs_path), "%s", path);
s_load_request = 2; /* 2 = load from specific VFS path */
}
#endif /* __EMSCRIPTEN__ */
/* Bitmap font provided by engine/font.h (included above). */
/* ═══════════════════════════════════════════════════
* 8x8 pixel mini-icons for the entity palette
*
* Each icon is 8 pixels wide, 8 pixels tall.
* Stored as 8 rows of 8 bits packed in a uint64_t.
* Row 0 is the top row, stored in bits 56-63.
* Bit 7 of each byte = leftmost pixel.
* ═══════════════════════════════════════════════════ */
#define ICON_SIZE 8
static const uint64_t s_icon_bitmaps[ICON_COUNT] = {
/* ICON_GRUNT: spiky creature */
0x5A3C7EDB7E3C5A00ULL,
/* ICON_FLYER: bat with wings */
0x0018187E7E241800ULL,
/* ICON_TURRET: mounted cannon */
0x0010107C7C381000ULL,
/* ICON_PLATFORM: horizontal bar */
0x000000007E7E0000ULL,
/* ICON_PLATFORM_V: vertical bar */
0x0018181818180000ULL,
/* ICON_FLAME: fire */
0x0010385454381000ULL,
/* ICON_FORCEFIELD: electric bars */
0x2424FF2424FF2424ULL,
/* ICON_HEART: classic heart shape */
0x006C7E7E3E1C0800ULL,
/* ICON_BOLT: lightning bolt */
0x0C1C18387060C000ULL,
/* ICON_FUEL: fuel canister */
0x003C4242423C1800ULL,
/* ICON_DRONE: quad-rotor */
0x00427E3C3C7E4200ULL,
/* ICON_GUN: pistol shape */
0x00007C7C10100000ULL,
/* ICON_ASTEROID: jagged rock */
0x001C3E7F7F3E1C00ULL,
/* ICON_SPACECRAFT: ship */
0x0018183C7E7E2400ULL,
/* ICON_LASER: laser turret (box with beam line) */
0x003C3C18187E0000ULL,
/* ICON_LASER_TRACK: tracking laser (box with rotating beam) */
0x003C3C1818660000ULL,
/* ICON_CHARGER: arrow/charging creature */
0x0018187E7E181800ULL,
/* ICON_SPAWNER: pulsing core with dots */
0x24003C3C3C002400ULL,
};
static void draw_icon(SDL_Renderer *r, EditorIcon icon,
int x, int y, SDL_Color col) {
if (icon < 0 || icon >= ICON_COUNT) return;
uint64_t bits = s_icon_bitmaps[icon];
SDL_SetRenderDrawColor(r, col.r, col.g, col.b, col.a);
for (int row = 0; row < ICON_SIZE; row++) {
int byte = (int)((bits >> (56 - row * 8)) & 0xFF);
for (int col_bit = 0; col_bit < ICON_SIZE; col_bit++) {
if (byte & (1 << (7 - col_bit))) {
SDL_RenderDrawPoint(r, x + col_bit, y + row);
}
}
}
}
/* ═══════════════════════════════════════════════════
* Constants
* ═══════════════════════════════════════════════════ */
#define CAM_PAN_SPEED 200.0f
#define ZOOM_MIN 0.25f
#define ZOOM_MAX 2.0f
#define ZOOM_STEP 0.25f
/* ═══════════════════════════════════════════════════
* Available tilesets (cycle with T key)
* ═══════════════════════════════════════════════════ */
static const char *s_tilesets[] = {
"assets/tiles/tileset.png",
"assets/tiles/moon_tileset.png",
};
#define TILESET_COUNT ((int)(sizeof(s_tilesets) / sizeof(s_tilesets[0])))
static const SDL_Color COL_BG = {30, 30, 46, 255};
static const SDL_Color COL_PANEL = {20, 20, 35, 255};
static const SDL_Color COL_PANEL_LT = {40, 40, 60, 255};
static const SDL_Color COL_TEXT = {200, 200, 220, 255};
static const SDL_Color COL_TEXT_DIM = {120, 120, 140, 255};
static const SDL_Color COL_HIGHLIGHT= {255, 200, 60, 255};
static const SDL_Color COL_GRID = {60, 60, 80, 80};
static const SDL_Color COL_SPAWN = {60, 255, 60, 255};
static const SDL_Color COL_ENTITY = {255, 100, 100, 255};
static const SDL_Color COL_SELECT = {255, 255, 100, 255};
static const SDL_Color COL_EXIT = {50, 230, 180, 255};
/* Tool names */
static const char *s_tool_names[TOOL_COUNT] = {
"PENCIL", "ERASER", "FILL", "ENTITY", "SPAWN", "EXIT"
};
/* Layer names */
static const char *s_layer_names[EDITOR_LAYER_COUNT] = {
"COL", "BG", "FG"
};
/* ═══════════════════════════════════════════════════
* Layer access helpers
* ═══════════════════════════════════════════════════ */
static uint16_t *get_layer(Tilemap *map, EditorLayer layer) {
switch (layer) {
case EDITOR_LAYER_COLLISION: return map->collision_layer;
case EDITOR_LAYER_BG: return map->bg_layer;
case EDITOR_LAYER_FG: return map->fg_layer;
default: return map->collision_layer;
}
}
static uint16_t get_tile(const Tilemap *map, const uint16_t *layer, int tx, int ty) {
if (tx < 0 || tx >= map->width || ty < 0 || ty >= map->height) return 0;
return layer[ty * map->width + tx];
}
static void set_tile(Tilemap *map, uint16_t *layer, int tx, int ty, uint16_t id) {
if (tx < 0 || tx >= map->width || ty < 0 || ty >= map->height) return;
layer[ty * map->width + tx] = id;
}
/* ═══════════════════════════════════════════════════
* Flood fill (scanline algorithm)
*
* Processes entire horizontal spans at once, then
* pushes only the boundary seeds above and below.
* Much more memory-efficient than naive 4-neighbor
* fill on large maps (O(height) stack vs O(area)).
* ═══════════════════════════════════════════════════ */
typedef struct FillSpan { int x_left, x_right, y, dir; } FillSpan;
static void flood_fill(Tilemap *map, uint16_t *layer, int sx, int sy, uint16_t new_id) {
uint16_t old_id = get_tile(map, layer, sx, sy);
if (old_id == new_id) return;
int capacity = 1024;
FillSpan *stack = malloc(capacity * sizeof(FillSpan));
if (!stack) return;
int top = 0;
/* Fill the initial span containing (sx, sy). */
int xl = sx, xr = sx;
while (xl > 0 && get_tile(map, layer, xl - 1, sy) == old_id) xl--;
while (xr < map->width - 1 && get_tile(map, layer, xr + 1, sy) == old_id) xr++;
for (int x = xl; x <= xr; x++) set_tile(map, layer, x, sy, new_id);
/* Seed rows above and below. */
stack[top++] = (FillSpan){xl, xr, sy, -1};
stack[top++] = (FillSpan){xl, xr, sy, 1};
while (top > 0) {
FillSpan s = stack[--top];
int ny = s.y + s.dir;
if (ny < 0 || ny >= map->height) continue;
/* Scan the row for sub-spans that match old_id and are seeded
* by the parent span [x_left, x_right]. */
int x = s.x_left;
while (x <= s.x_right) {
/* Skip non-matching tiles. */
if (get_tile(map, layer, x, ny) != old_id) { x++; continue; }
/* Found a matching run; expand it fully. */
int run_l = x;
while (run_l > 0 && get_tile(map, layer, run_l - 1, ny) == old_id) run_l--;
int run_r = x;
while (run_r < map->width - 1 && get_tile(map, layer, run_r + 1, ny) == old_id) run_r++;
/* Fill this run. */
for (int fx = run_l; fx <= run_r; fx++) set_tile(map, layer, fx, ny, new_id);
/* Grow stack if needed. */
if (top + 2 >= capacity) {
capacity *= 2;
FillSpan *tmp = realloc(stack, capacity * sizeof(FillSpan));
if (!tmp) { fprintf(stderr, "Warning: flood fill out of memory\n"); free(stack); return; }
stack = tmp;
}
/* Continue in the same direction. */
stack[top++] = (FillSpan){run_l, run_r, ny, s.dir};
/* Also seed the opposite direction for portions that extend
* beyond the parent span (leak-around fills). */
if (run_l < s.x_left)
stack[top++] = (FillSpan){run_l, s.x_left - 1, ny, -s.dir};
if (run_r > s.x_right) {
if (top + 1 >= capacity) {
capacity *= 2;
FillSpan *tmp = realloc(stack, capacity * sizeof(FillSpan));
if (!tmp) { fprintf(stderr, "Warning: flood fill out of memory\n"); free(stack); return; }
stack = tmp;
}
stack[top++] = (FillSpan){s.x_right + 1, run_r, ny, -s.dir};
}
x = run_r + 1;
}
}
free(stack);
}
/* ═══════════════════════════════════════════════════
* Tilemap save (reuses .lvl format)
* ═══════════════════════════════════════════════════ */
static bool save_tilemap(const Tilemap *map, const char *path) {
FILE *f = fopen(path, "w");
if (!f) {
fprintf(stderr, "editor: failed to write %s\n", path);
return false;
}
fprintf(f, "# Level created with in-game editor\n\n");
/* Write the tileset path stored in the map, falling back to default */
fprintf(f, "TILESET %s\n",
map->tileset_path[0] ? map->tileset_path : "assets/tiles/tileset.png");
fprintf(f, "SIZE %d %d\n", map->width, map->height);
/* Player spawn in tile coords */
int stx = (int)(map->player_spawn.x / TILE_SIZE);
int sty = (int)(map->player_spawn.y / TILE_SIZE);
fprintf(f, "SPAWN %d %d\n", stx, sty);
if (map->gravity > 0)
fprintf(f, "GRAVITY %.0f\n", map->gravity);
if (map->wind != 0.0f)
fprintf(f, "WIND %.0f\n", map->wind);
if (map->has_bg_color)
fprintf(f, "BG_COLOR %d %d %d\n", map->bg_color.r, map->bg_color.g, map->bg_color.b);
if (map->music_path[0])
fprintf(f, "MUSIC %s\n", map->music_path);
if (map->parallax_far_path[0])
fprintf(f, "PARALLAX_FAR %s\n", map->parallax_far_path);
if (map->parallax_near_path[0])
fprintf(f, "PARALLAX_NEAR %s\n", map->parallax_near_path);
if (map->parallax_style > 0)
fprintf(f, "PARALLAX_STYLE %d\n", map->parallax_style);
if (map->player_unarmed)
fprintf(f, "PLAYER_UNARMED\n");
/* Transition styles */
if (map->transition_in != TRANS_NONE) {
fprintf(f, "TRANSITION_IN %s\n",
transition_style_name(map->transition_in));
}
if (map->transition_out != TRANS_NONE) {
fprintf(f, "TRANSITION_OUT %s\n",
transition_style_name(map->transition_out));
}
fprintf(f, "\n");
/* Entity spawns */
for (int i = 0; i < map->entity_spawn_count; i++) {
const EntitySpawn *es = &map->entity_spawns[i];
int tx = (int)(es->x / TILE_SIZE);
int ty = (int)(es->y / TILE_SIZE);
fprintf(f, "ENTITY %s %d %d\n", es->type_name, tx, ty);
}
fprintf(f, "\n");
/* Exit zones */
for (int i = 0; i < map->exit_zone_count; i++) {
const ExitZone *ez = &map->exit_zones[i];
int tx = (int)(ez->x / TILE_SIZE);
int ty = (int)(ez->y / TILE_SIZE);
int tw = (int)(ez->w / TILE_SIZE);
int th = (int)(ez->h / TILE_SIZE);
if (ez->target[0]) {
fprintf(f, "EXIT %d %d %d %d %s\n", tx, ty, tw, th, ez->target);
} else {
fprintf(f, "EXIT %d %d %d %d\n", tx, ty, tw, th);
}
}
if (map->exit_zone_count > 0) fprintf(f, "\n");
/* Tile definitions — save all entries so flags and tex coords survive
* round-trips, including tiles at position (0,0) with no flags. */
for (int id = 1; id < map->tile_def_count; id++) {
const TileDef *td = &map->tile_defs[id];
fprintf(f, "TILEDEF %d %d %d %u\n", id, td->tex_x, td->tex_y, td->flags);
}
fprintf(f, "\n");
/* Write each layer */
const char *layer_names[] = {"collision", "bg", "fg"};
const uint16_t *layers[] = {map->collision_layer, map->bg_layer, map->fg_layer};
for (int l = 0; l < 3; l++) {
/* Skip empty layers */
bool has_data = false;
for (int i = 0; i < map->width * map->height; i++) {
if (layers[l][i]) { has_data = true; break; }
}
if (!has_data && l != 0) continue; /* always write collision */
fprintf(f, "LAYER %s\n", layer_names[l]);
for (int y = 0; y < map->height; y++) {
for (int x = 0; x < map->width; x++) {
if (x > 0) fprintf(f, " ");
fprintf(f, "%d", layers[l][y * map->width + x]);
}
fprintf(f, "\n");
}
fprintf(f, "\n");
}
fclose(f);
printf("editor: saved to %s\n", path);
return true;
}
/* ═══════════════════════════════════════════════════
* Editor resize
* ═══════════════════════════════════════════════════ */
static void resize_layer(uint16_t **layer, int old_w, int old_h, int new_w, int new_h) {
uint16_t *new_data = calloc(new_w * new_h, sizeof(uint16_t));
int copy_w = old_w < new_w ? old_w : new_w;
int copy_h = old_h < new_h ? old_h : new_h;
for (int y = 0; y < copy_h; y++) {
for (int x = 0; x < copy_w; x++) {
new_data[y * new_w + x] = (*layer)[y * old_w + x];
}
}
free(*layer);
*layer = new_data;
}
static void editor_resize(Editor *ed, int new_w, int new_h) {
if (new_w < 10) new_w = 10;
if (new_h < 10) new_h = 10;
if (new_w > MAX_MAP_SIZE) new_w = MAX_MAP_SIZE;
if (new_h > MAX_MAP_SIZE) new_h = MAX_MAP_SIZE;
int old_w = ed->map.width;
int old_h = ed->map.height;
resize_layer(&ed->map.collision_layer, old_w, old_h, new_w, new_h);
resize_layer(&ed->map.bg_layer, old_w, old_h, new_w, new_h);
resize_layer(&ed->map.fg_layer, old_w, old_h, new_w, new_h);
ed->map.width = new_w;
ed->map.height = new_h;
ed->dirty = true;
camera_set_bounds(&ed->camera,
(float)(new_w * TILE_SIZE),
(float)(new_h * TILE_SIZE));
}
/* ═══════════════════════════════════════════════════
* Discover tileset dimensions
* ═══════════════════════════════════════════════════ */
static void discover_tileset(Editor *ed) {
if (!ed->map.tileset) {
ed->tileset_cols = 0;
ed->tileset_rows = 0;
ed->tileset_total = 0;
return;
}
int tex_w, tex_h;
SDL_QueryTexture(ed->map.tileset, NULL, NULL, &tex_w, &tex_h);
ed->tileset_cols = tex_w / TILE_SIZE;
ed->tileset_rows = tex_h / TILE_SIZE;
ed->tileset_total = ed->tileset_cols * ed->tileset_rows;
}
/* ═══════════════════════════════════════════════════
* Tileset switching
* ═══════════════════════════════════════════════════ */
/* Find current tileset index in the table, or -1 */
static int find_tileset_index(const char *path) {
for (int i = 0; i < TILESET_COUNT; i++) {
if (strcmp(path, s_tilesets[i]) == 0) return i;
}
return -1;
}
/* Switch the editor to a different tileset by path */
static void editor_switch_tileset(Editor *ed, const char *path) {
SDL_Texture *tex = assets_get_texture(path);
if (!tex) {
fprintf(stderr, "editor: cannot load tileset %s\n", path);
return;
}
snprintf(ed->map.tileset_path, sizeof(ed->map.tileset_path), "%s", path);
ed->map.tileset = tex;
int tex_w;
SDL_QueryTexture(tex, NULL, NULL, &tex_w, NULL);
ed->map.tileset_cols = tex_w / TILE_SIZE;
discover_tileset(ed);
ed->tile_palette_scroll = 0;
ed->dirty = true;
}
/* Cycle to the next tileset in the table.
* If the current tileset is not in the list, cycle to the first entry. */
static void editor_cycle_tileset(Editor *ed) {
int idx = find_tileset_index(ed->map.tileset_path);
int next = (idx < 0) ? 0 : (idx + 1) % TILESET_COUNT;
editor_switch_tileset(ed, s_tilesets[next]);
printf("editor: tileset -> %s\n", s_tilesets[next]);
}
/* ── Tile flag helpers ───────────────────────────── */
/* Ensure a tile ID has a TileDef entry. Creates one if missing. */
static void ensure_tile_def(Tilemap *map, uint16_t tile_id) {
if (tile_id == 0 || tile_id >= MAX_TILE_DEFS) return;
if (tile_id < map->tile_def_count) return;
/* Fill gaps with default entries (tex pos from grid, no flags) */
int cols = map->tileset_cols > 0 ? map->tileset_cols : 16;
for (int id = map->tile_def_count; id <= tile_id; id++) {
map->tile_defs[id].tex_x = (uint16_t)((id - 1) % cols);
map->tile_defs[id].tex_y = (uint16_t)((id - 1) / cols);
map->tile_defs[id].flags = 0;
}
map->tile_def_count = tile_id + 1;
}
/* Cycle the flag on the currently selected tile: none -> solid -> platform -> hazard -> none */
static void editor_cycle_tile_flag(Editor *ed) {
uint16_t id = ed->selected_tile;
if (id == 0 || id >= MAX_TILE_DEFS) return;
ensure_tile_def(&ed->map, id);
uint32_t cur = ed->map.tile_defs[id].flags;
/* Cycle: 0 -> SOLID -> PLATFORM -> HAZARD -> 0 */
if (cur & TILE_HAZARD) ed->map.tile_defs[id].flags = 0;
else if (cur & TILE_PLATFORM) ed->map.tile_defs[id].flags = TILE_HAZARD;
else if (cur & TILE_SOLID) ed->map.tile_defs[id].flags = TILE_PLATFORM;
else ed->map.tile_defs[id].flags = TILE_SOLID;
ed->dirty = true;
}
/* Get display name for the flags of the selected tile */
static const char *tile_flag_name(uint32_t flags) {
if (flags & TILE_HAZARD) return "HAZARD";
if (flags & TILE_PLATFORM) return "PLATFORM";
if (flags & TILE_SOLID) return "SOLID";
return "NONE";
}
/* ═══════════════════════════════════════════════════
* Lifecycle
* ═══════════════════════════════════════════════════ */
void editor_init(Editor *ed) {
memset(ed, 0, sizeof(Editor));
ed->tool = TOOL_PENCIL;
ed->active_layer = EDITOR_LAYER_COLLISION;
ed->selected_tile = 1;
ed->selected_entity = 0;
ed->show_grid = true;
ed->show_all_layers = true;
ed->dragging_entity = -1;
ed->active = true;
camera_init(&ed->camera, SCREEN_WIDTH, SCREEN_HEIGHT);
/* Ensure entity registry is populated for the palette.
* If we came from gameplay it is already initialized;
* if the editor was launched directly it will be empty. */
if (g_entity_registry.count == 0) {
entity_registry_populate();
}
}
void editor_new_level(Editor *ed, int width, int height) {
/* Free any existing map */
tilemap_free(&ed->map);
memset(&ed->map, 0, sizeof(Tilemap));
ed->map.width = width;
ed->map.height = height;
int total = width * height;
ed->map.collision_layer = calloc(total, sizeof(uint16_t));
ed->map.bg_layer = calloc(total, sizeof(uint16_t));
ed->map.fg_layer = calloc(total, sizeof(uint16_t));
/* Default tile defs (same as levelgen) */
ed->map.tile_defs[1] = (TileDef){0, 0, TILE_SOLID};
ed->map.tile_defs[2] = (TileDef){1, 0, TILE_SOLID};
ed->map.tile_defs[3] = (TileDef){2, 0, TILE_SOLID};
ed->map.tile_defs[4] = (TileDef){0, 1, TILE_PLATFORM};
ed->map.tile_def_count = 5;
/* Default spawn */
ed->map.player_spawn = vec2(3.0f * TILE_SIZE, (height - 4) * TILE_SIZE);
ed->map.gravity = DEFAULT_GRAVITY;
/* Load tileset */
snprintf(ed->map.tileset_path, sizeof(ed->map.tileset_path),
"%s", "assets/tiles/tileset.png");
ed->map.tileset = assets_get_texture(ed->map.tileset_path);
if (ed->map.tileset) {
int tex_w;
SDL_QueryTexture(ed->map.tileset, NULL, NULL, &tex_w, NULL);
ed->map.tileset_cols = tex_w / TILE_SIZE;
}
discover_tileset(ed);
camera_init(&ed->camera, SCREEN_WIDTH, SCREEN_HEIGHT);
camera_set_bounds(&ed->camera,
(float)(width * TILE_SIZE),
(float)(height * TILE_SIZE));
ed->has_file = false;
ed->dirty = false;
ed->file_path[0] = '\0';
printf("editor: new level %dx%d\n", width, height);
}
bool editor_load(Editor *ed, const char *path) {
tilemap_free(&ed->map);
memset(&ed->map, 0, sizeof(Tilemap));
if (!tilemap_load(&ed->map, path, g_engine.renderer)) {
return false;
}
discover_tileset(ed);
camera_init(&ed->camera, SCREEN_WIDTH, SCREEN_HEIGHT);
camera_set_bounds(&ed->camera,
(float)(ed->map.width * TILE_SIZE),
(float)(ed->map.height * TILE_SIZE));
strncpy(ed->file_path, path, sizeof(ed->file_path) - 1);
ed->has_file = true;
ed->dirty = false;
printf("editor: loaded %s\n", path);
return true;
}
bool editor_save(Editor *ed) {
if (!ed->has_file) {
/* Default path */
strncpy(ed->file_path, "assets/levels/edited.lvl",
sizeof(ed->file_path) - 1);
ed->has_file = true;
}
if (save_tilemap(&ed->map, ed->file_path)) {
ed->dirty = false;
#ifdef __EMSCRIPTEN__
/* Trigger a browser download of the saved file */
{
/* Extract just the filename from the path for the download name */
const char *name = strrchr(ed->file_path, '/');
name = name ? name + 1 : ed->file_path;
browser_download_file(ed->file_path, name);
}
#endif
return true;
}
return false;
}
bool editor_save_as(Editor *ed, const char *path) {
strncpy(ed->file_path, path, sizeof(ed->file_path) - 1);
ed->has_file = true;
return editor_save(ed);
}
void editor_free(Editor *ed) {
tilemap_free(&ed->map);
ed->active = false;
}
/* ═══════════════════════════════════════════════════
* Coordinate helpers
* ═══════════════════════════════════════════════════ */
/* Is the screen position inside the canvas area (not on UI panels)? */
static bool in_canvas(int sx, int sy) {
return sx < (SCREEN_WIDTH - EDITOR_PALETTE_W) &&
sy >= EDITOR_TOOLBAR_H &&
sy < (SCREEN_HEIGHT - EDITOR_STATUS_H);
}
/* Screen position to world tile coordinates */
static void screen_to_tile(const Editor *ed, int sx, int sy, int *tx, int *ty) {
Vec2 world = camera_screen_to_world(&ed->camera, vec2((float)sx, (float)sy));
*tx = world_to_tile(world.x);
*ty = world_to_tile(world.y);
}
/* ═══════════════════════════════════════════════════
* Entity helpers
* ═══════════════════════════════════════════════════ */
/* Find entity spawn at a tile position, return index or -1 */
static int find_entity_at(const Tilemap *map, float wx, float wy) {
for (int i = 0; i < map->entity_spawn_count; i++) {
const EntitySpawn *es = &map->entity_spawns[i];
const EntityRegEntry *reg = entity_registry_find(es->type_name);
float ew = reg ? (float)reg->width : TILE_SIZE;
float eh = reg ? (float)reg->height : TILE_SIZE;
if (wx >= es->x && wx < es->x + ew &&
wy >= es->y && wy < es->y + eh) {
return i;
}
}
return -1;
}
static void add_entity_spawn(Tilemap *map, const char *name, float wx, float wy) {
if (map->entity_spawn_count >= MAX_ENTITY_SPAWNS) return;
EntitySpawn *es = &map->entity_spawns[map->entity_spawn_count];
strncpy(es->type_name, name, 31);
es->type_name[31] = '\0';
/* Snap to tile grid */
es->x = floorf(wx / TILE_SIZE) * TILE_SIZE;
es->y = floorf(wy / TILE_SIZE) * TILE_SIZE;
map->entity_spawn_count++;
}
static void remove_entity_spawn(Tilemap *map, int index) {
if (index < 0 || index >= map->entity_spawn_count) return;
/* Shift remaining entries */
for (int i = index; i < map->entity_spawn_count - 1; i++) {
map->entity_spawns[i] = map->entity_spawns[i + 1];
}
map->entity_spawn_count--;
}
/* ── Exit zone helpers ─────────────────────────────── */
#define EXIT_DEFAULT_W 2 /* default exit zone width in tiles */
#define EXIT_DEFAULT_H 3 /* default exit zone height in tiles */
static int find_exit_at(const Tilemap *map, float wx, float wy) {
for (int i = 0; i < map->exit_zone_count; i++) {
const ExitZone *ez = &map->exit_zones[i];
if (wx >= ez->x && wx < ez->x + ez->w &&
wy >= ez->y && wy < ez->y + ez->h) {
return i;
}
}
return -1;
}
static void add_exit_zone(Tilemap *map, float wx, float wy) {
if (map->exit_zone_count >= MAX_EXIT_ZONES) return;
ExitZone *ez = &map->exit_zones[map->exit_zone_count];
/* Snap to tile grid */
ez->x = floorf(wx / TILE_SIZE) * TILE_SIZE;
ez->y = floorf(wy / TILE_SIZE) * TILE_SIZE;
ez->w = EXIT_DEFAULT_W * TILE_SIZE;
ez->h = EXIT_DEFAULT_H * TILE_SIZE;
ez->target[0] = '\0'; /* empty = victory / end of level */
map->exit_zone_count++;
}
static void remove_exit_zone(Tilemap *map, int index) {
if (index < 0 || index >= map->exit_zone_count) return;
for (int i = index; i < map->exit_zone_count - 1; i++) {
map->exit_zones[i] = map->exit_zones[i + 1];
}
map->exit_zone_count--;
}
/* ═══════════════════════════════════════════════════
* Internal state for test-play / quit requests
* ═══════════════════════════════════════════════════ */
static bool s_wants_test_play = false;
static bool s_wants_quit = false;
bool editor_wants_test_play(Editor *ed) {
(void)ed;
bool v = s_wants_test_play;
s_wants_test_play = false;
return v;
}
bool editor_wants_quit(Editor *ed) {
(void)ed;
bool v = s_wants_quit;
s_wants_quit = false;
return v;
}
/* ═══════════════════════════════════════════════════
* Update — input handling
* ═══════════════════════════════════════════════════ */
void editor_update(Editor *ed, float dt) {
int mx, my;
input_mouse_pos(&mx, &my);
/* ── Keyboard shortcuts ────────────────── */
/* Tool selection: 1-5 */
if (input_key_pressed(SDL_SCANCODE_1)) ed->tool = TOOL_PENCIL;
if (input_key_pressed(SDL_SCANCODE_2)) ed->tool = TOOL_ERASER;
if (input_key_pressed(SDL_SCANCODE_3)) ed->tool = TOOL_FILL;
if (input_key_pressed(SDL_SCANCODE_4)) ed->tool = TOOL_ENTITY;
if (input_key_pressed(SDL_SCANCODE_5)) ed->tool = TOOL_SPAWN;
if (input_key_pressed(SDL_SCANCODE_6)) ed->tool = TOOL_EXIT;
/* Layer selection: Q/W/E */
if (input_key_pressed(SDL_SCANCODE_Q)) ed->active_layer = EDITOR_LAYER_COLLISION;
if (input_key_pressed(SDL_SCANCODE_W)) ed->active_layer = EDITOR_LAYER_BG;
if (input_key_pressed(SDL_SCANCODE_E) && !input_key_held(SDL_SCANCODE_LCTRL))
ed->active_layer = EDITOR_LAYER_FG;
/* Grid toggle: G */
if (input_key_pressed(SDL_SCANCODE_G)) ed->show_grid = !ed->show_grid;
/* Layer visibility toggle: V */
if (input_key_pressed(SDL_SCANCODE_V)) ed->show_all_layers = !ed->show_all_layers;
/* Tileset cycle: T */
if (input_key_pressed(SDL_SCANCODE_T) && !input_key_held(SDL_SCANCODE_LCTRL))
editor_cycle_tileset(ed);
/* Tile flag cycle: F (solid/platform/hazard/none) */
if (input_key_pressed(SDL_SCANCODE_F) && !input_key_held(SDL_SCANCODE_LCTRL))
editor_cycle_tile_flag(ed);
/* Save: Ctrl+S */
if (input_key_pressed(SDL_SCANCODE_S) && input_key_held(SDL_SCANCODE_LCTRL)) {
editor_save(ed);
}
/* Open / Load: Ctrl+O */
if (input_key_pressed(SDL_SCANCODE_O) && input_key_held(SDL_SCANCODE_LCTRL)) {
#ifdef __EMSCRIPTEN__
browser_open_file_picker();
#else
/* Desktop: reload from current file (no native file dialog) */
if (ed->has_file) {
editor_load(ed, ed->file_path);
}
#endif
}
#ifdef __EMSCRIPTEN__
/* Poll for save request from JS (Ctrl+S or Save button) */
if (s_save_request) {
s_save_request = 0;
editor_save(ed);
}
/* Poll for load request from JS */
if (s_load_request == 1) {
/* 1 = open file picker (Ctrl+O or Load button) */
s_load_request = 0;
browser_open_file_picker();
} else if (s_load_request == 2) {
/* 2 = load a specific VFS file (level picker dropdown) */
s_load_request = 0;
if (s_load_vfs_path[0]) {
if (editor_load(ed, s_load_vfs_path)) {
printf("editor: loaded %s\n", s_load_vfs_path);
}
s_load_vfs_path[0] = '\0';
}
}
/* Poll for completed file upload from browser */
if (s_upload_ready) {
s_upload_ready = 0;
if (editor_load(ed, UPLOAD_VFS_PATH)) {
/* Clear the stored path so saves go to default,
* not the tmp upload path */
strncpy(ed->file_path, "assets/levels/edited.lvl",
sizeof(ed->file_path) - 1);
ed->has_file = true;
printf("editor: loaded from browser upload\n");
}
}
#endif
/* Test play: P */
if (input_key_pressed(SDL_SCANCODE_P)) {
s_wants_test_play = true;
}
/* Quit editor: Escape */
if (input_key_pressed(SDL_SCANCODE_ESCAPE)) {
s_wants_quit = true;
}
/* Resize: Ctrl+Shift+Plus/Minus for height, Ctrl+Plus/Minus for width */
if (input_key_held(SDL_SCANCODE_LCTRL)) {
if (input_key_held(SDL_SCANCODE_LSHIFT)) {
/* Height resize takes priority when Shift is also held */
if (input_key_pressed(SDL_SCANCODE_EQUALS))
editor_resize(ed, ed->map.width, ed->map.height + 5);
if (input_key_pressed(SDL_SCANCODE_MINUS))
editor_resize(ed, ed->map.width, ed->map.height - 5);
} else {
/* Width resize only when Shift is NOT held */
if (input_key_pressed(SDL_SCANCODE_EQUALS))
editor_resize(ed, ed->map.width + 10, ed->map.height);
if (input_key_pressed(SDL_SCANCODE_MINUS))
editor_resize(ed, ed->map.width - 10, ed->map.height);
}
}
/* ── Camera panning (arrow keys or WASD with no ctrl) ── */
if (!input_key_held(SDL_SCANCODE_LCTRL)) {
float pan_speed = CAM_PAN_SPEED * dt;
/* Faster when zoomed out */
if (ed->camera.zoom > 0.0f)
pan_speed /= ed->camera.zoom;
if (input_key_held(SDL_SCANCODE_LEFT) || input_key_held(SDL_SCANCODE_A))
ed->camera.pos.x -= pan_speed;
if (input_key_held(SDL_SCANCODE_RIGHT) || input_key_held(SDL_SCANCODE_D))
ed->camera.pos.x += pan_speed;
if (input_key_held(SDL_SCANCODE_UP))
ed->camera.pos.y -= pan_speed;
if (input_key_held(SDL_SCANCODE_DOWN) || input_key_held(SDL_SCANCODE_S))
ed->camera.pos.y += pan_speed;
}
/* Middle mouse drag panning */
{
static int last_mx = 0, last_my = 0;
static bool dragging_cam = false;
if (input_mouse_held(MOUSE_MIDDLE)) {
if (!dragging_cam) {
dragging_cam = true;
last_mx = mx;
last_my = my;
} else {
float inv_zoom = (ed->camera.zoom > 0.0f) ? (1.0f / ed->camera.zoom) : 1.0f;
ed->camera.pos.x -= (float)(mx - last_mx) * inv_zoom;
ed->camera.pos.y -= (float)(my - last_my) * inv_zoom;
last_mx = mx;
last_my = my;
}
} else {
dragging_cam = false;
}
}
/* ── Zoom (scroll wheel) — only when mouse is over the canvas ── */
int scroll = input_mouse_scroll();
if (scroll != 0 && in_canvas(mx, my)) {
/* Compute world pos under mouse at CURRENT zoom, before changing it */
Vec2 mouse_world = camera_screen_to_world(&ed->camera, vec2((float)mx, (float)my));
float old_zoom = ed->camera.zoom;
ed->camera.zoom += (float)scroll * ZOOM_STEP;
if (ed->camera.zoom < ZOOM_MIN) ed->camera.zoom = ZOOM_MIN;
if (ed->camera.zoom > ZOOM_MAX) ed->camera.zoom = ZOOM_MAX;
/* Zoom toward mouse position: keep the world point under the
* mouse cursor in the same screen position after the zoom. */
if (ed->camera.zoom != old_zoom) {
float new_zoom = ed->camera.zoom;
ed->camera.pos.x = mouse_world.x - (float)mx / new_zoom;
ed->camera.pos.y = mouse_world.y - (float)my / new_zoom;
}
}
/* Clamp camera */
float vp_w = ed->camera.viewport.x;
float vp_h = ed->camera.viewport.y;
if (ed->camera.zoom > 0.0f) {
vp_w /= ed->camera.zoom;
vp_h /= ed->camera.zoom;
}
float max_x = ed->camera.bounds_max.x - vp_w;
float max_y = ed->camera.bounds_max.y - vp_h;
if (ed->camera.pos.x < ed->camera.bounds_min.x - vp_w * 0.5f)
ed->camera.pos.x = ed->camera.bounds_min.x - vp_w * 0.5f;
if (ed->camera.pos.y < ed->camera.bounds_min.y - vp_h * 0.5f)
ed->camera.pos.y = ed->camera.bounds_min.y - vp_h * 0.5f;
if (max_x > 0 && ed->camera.pos.x > max_x + vp_w * 0.5f)
ed->camera.pos.x = max_x + vp_w * 0.5f;
if (max_y > 0 && ed->camera.pos.y > max_y + vp_h * 0.5f)
ed->camera.pos.y = max_y + vp_h * 0.5f;
/* ── Right palette click ── */
if (mx >= SCREEN_WIDTH - EDITOR_PALETTE_W && my >= EDITOR_TOOLBAR_H &&
my < SCREEN_HEIGHT - EDITOR_STATUS_H) {
int px = SCREEN_WIDTH - EDITOR_PALETTE_W;
int py = EDITOR_TOOLBAR_H;
int ph = SCREEN_HEIGHT - EDITOR_TOOLBAR_H - EDITOR_STATUS_H;
/* Split point: tiles take ~55%, entities take ~45% */
int tile_section_h = (ph * 55) / 100;
int ent_section_y = py + tile_section_h;
if (my < ent_section_y) {
/* Tile palette area */
if (input_mouse_pressed(MOUSE_LEFT)) {
int pal_x = mx - px - 2;
int pal_label_h = FONT_H + 6;
int pal_y = my - py - pal_label_h
+ ed->tile_palette_scroll * (TILE_SIZE + 1);
if (pal_x >= 0 && pal_y >= 0) {
int max_cols = (EDITOR_PALETTE_W - 4) / (TILE_SIZE + 1);
if (max_cols < 1) max_cols = 1;
int tile_col = pal_x / (TILE_SIZE + 1);
int tile_row = pal_y / (TILE_SIZE + 1);
int tile_id = tile_row * max_cols + tile_col + 1;
if (tile_id >= 1 && tile_id <= ed->tileset_total) {
ed->selected_tile = (uint16_t)tile_id;
/* Auto-switch to pencil tool when selecting a tile */
if (ed->tool == TOOL_ENTITY) ed->tool = TOOL_PENCIL;
}
}
}
if (scroll != 0) {
ed->tile_palette_scroll -= scroll;
if (ed->tile_palette_scroll < 0) ed->tile_palette_scroll = 0;
}
} else {
/* Entity palette area */
if (input_mouse_pressed(MOUSE_LEFT)) {
int pal_label_h = FONT_H + 6;
int pal_y = my - ent_section_y - pal_label_h
+ ed->entity_palette_scroll * 12;
int entry_idx = pal_y / 12;
if (entry_idx >= 0 && entry_idx < g_entity_registry.count) {
ed->selected_entity = entry_idx;
/* Auto-switch to entity tool when selecting an entity */
ed->tool = TOOL_ENTITY;
}
}
if (scroll != 0) {
ed->entity_palette_scroll -= scroll;
if (ed->entity_palette_scroll < 0) ed->entity_palette_scroll = 0;
}
}
return; /* Don't process canvas clicks when on palette */
}
/* ── Toolbar click ── */
if (my < EDITOR_TOOLBAR_H) {
if (input_mouse_pressed(MOUSE_LEFT)) {
/* Tool buttons: each 35px wide starting at x=2 */
int btn = (mx - 2) / 35;
if (btn >= 0 && btn < TOOL_COUNT) {
ed->tool = (EditorTool)btn;
}
/* Layer buttons after separator */
int sep_x = TOOL_COUNT * 35 + 8;
int lx = mx - sep_x;
if (lx >= 0) {
int lbtn = lx / 25;
if (lbtn >= 0 && lbtn < EDITOR_LAYER_COUNT) {
ed->active_layer = (EditorLayer)lbtn;
}
}
}
return;
}
/* ── Canvas interaction ── */
if (!in_canvas(mx, my)) return;
int tile_x, tile_y;
screen_to_tile(ed, mx, my, &tile_x, &tile_y);
Vec2 world_pos = camera_screen_to_world(&ed->camera, vec2((float)mx, (float)my));
switch (ed->tool) {
case TOOL_PENCIL:
if (input_mouse_held(MOUSE_LEFT)) {
uint16_t *layer = get_layer(&ed->map, ed->active_layer);
/* Ensure tile has an explicit TileDef so it does not fall
* through to the "unknown tile = solid" default. */
ensure_tile_def(&ed->map, ed->selected_tile);
set_tile(&ed->map, layer, tile_x, tile_y, ed->selected_tile);
ed->dirty = true;
}
if (input_mouse_held(MOUSE_RIGHT)) {
/* Pick tile under cursor */
uint16_t *layer = get_layer(&ed->map, ed->active_layer);
uint16_t t = get_tile(&ed->map, layer, tile_x, tile_y);
if (t != 0) ed->selected_tile = t;
}
break;
case TOOL_ERASER:
if (input_mouse_held(MOUSE_LEFT)) {
uint16_t *layer = get_layer(&ed->map, ed->active_layer);
set_tile(&ed->map, layer, tile_x, tile_y, 0);
ed->dirty = true;
}
break;
case TOOL_FILL:
if (input_mouse_pressed(MOUSE_LEFT)) {
uint16_t *layer = get_layer(&ed->map, ed->active_layer);
ensure_tile_def(&ed->map, ed->selected_tile);
flood_fill(&ed->map, layer, tile_x, tile_y, ed->selected_tile);
ed->dirty = true;
}
if (input_mouse_pressed(MOUSE_RIGHT)) {
uint16_t *layer = get_layer(&ed->map, ed->active_layer);
flood_fill(&ed->map, layer, tile_x, tile_y, 0);
ed->dirty = true;
}
break;
case TOOL_ENTITY:
if (input_mouse_pressed(MOUSE_LEFT)) {
/* Check if clicking an existing entity */
int eidx = find_entity_at(&ed->map, world_pos.x, world_pos.y);
if (eidx >= 0) {
/* Start dragging */
ed->dragging_entity = eidx;
ed->drag_offset_x = ed->map.entity_spawns[eidx].x - world_pos.x;
ed->drag_offset_y = ed->map.entity_spawns[eidx].y - world_pos.y;
} else {
/* Place new entity */
if (ed->selected_entity >= 0 && ed->selected_entity < g_entity_registry.count) {
add_entity_spawn(&ed->map,
g_entity_registry.entries[ed->selected_entity].name,
world_pos.x, world_pos.y);
ed->dirty = true;
}
}
}
if (input_mouse_held(MOUSE_LEFT) && ed->dragging_entity >= 0) {
/* Drag entity — snap to grid */
float nx = floorf((world_pos.x + ed->drag_offset_x) / TILE_SIZE) * TILE_SIZE;
float ny = floorf((world_pos.y + ed->drag_offset_y) / TILE_SIZE) * TILE_SIZE;
ed->map.entity_spawns[ed->dragging_entity].x = nx;
ed->map.entity_spawns[ed->dragging_entity].y = ny;
ed->dirty = true;
}
if (input_mouse_released(MOUSE_LEFT)) {
ed->dragging_entity = -1;
}
/* Right-click to delete entity */
if (input_mouse_pressed(MOUSE_RIGHT)) {
int eidx = find_entity_at(&ed->map, world_pos.x, world_pos.y);
if (eidx >= 0) {
remove_entity_spawn(&ed->map, eidx);
ed->dirty = true;
}
}
break;
case TOOL_SPAWN:
if (input_mouse_pressed(MOUSE_LEFT)) {
ed->map.player_spawn = vec2(
floorf(world_pos.x / TILE_SIZE) * TILE_SIZE,
floorf(world_pos.y / TILE_SIZE) * TILE_SIZE
);
ed->dirty = true;
}
break;
case TOOL_EXIT:
if (input_mouse_pressed(MOUSE_LEFT)) {
/* Place a new exit zone (if not clicking an existing one) */
int eidx = find_exit_at(&ed->map, world_pos.x, world_pos.y);
if (eidx < 0) {
add_exit_zone(&ed->map, world_pos.x, world_pos.y);
ed->dirty = true;
}
}
/* Right-click to delete exit zone */
if (input_mouse_pressed(MOUSE_RIGHT)) {
int eidx = find_exit_at(&ed->map, world_pos.x, world_pos.y);
if (eidx >= 0) {
remove_exit_zone(&ed->map, eidx);
ed->dirty = true;
}
}
break;
default:
break;
}
}
/* ═══════════════════════════════════════════════════
* Render
* ═══════════════════════════════════════════════════ */
void editor_render(Editor *ed, float interpolation) {
(void)interpolation;
SDL_Renderer *r = g_engine.renderer;
Camera *cam = &ed->camera;
/* ── Clear background ── */
SDL_SetRenderDrawColor(r, COL_BG.r, COL_BG.g, COL_BG.b, 255);
SDL_RenderClear(r);
/* ── Render tile layers ── */
if (ed->show_all_layers) {
/* Draw all layers, dim inactive ones */
for (int l = 0; l < EDITOR_LAYER_COUNT; l++) {
uint16_t *layer = get_layer(&ed->map, (EditorLayer)l);
if (l != (int)ed->active_layer) {
SDL_SetTextureAlphaMod(ed->map.tileset, 80);
} else {
SDL_SetTextureAlphaMod(ed->map.tileset, 255);
}
tilemap_render_layer(&ed->map, layer, cam, r);
}
SDL_SetTextureAlphaMod(ed->map.tileset, 255);
} else {
/* Only active layer */
uint16_t *layer = get_layer(&ed->map, ed->active_layer);
tilemap_render_layer(&ed->map, layer, cam, r);
}
/* ── Grid ── */
if (ed->show_grid) {
SDL_SetRenderDrawBlendMode(r, SDL_BLENDMODE_BLEND);
SDL_SetRenderDrawColor(r, COL_GRID.r, COL_GRID.g, COL_GRID.b, COL_GRID.a);
float inv_zoom = (cam->zoom > 0.0f) ? (1.0f / cam->zoom) : 1.0f;
int start_tx = (int)floorf(cam->pos.x / TILE_SIZE);
int start_ty = (int)floorf(cam->pos.y / TILE_SIZE);
int end_tx = start_tx + (int)(cam->viewport.x * inv_zoom / TILE_SIZE) + 2;
int end_ty = start_ty + (int)(cam->viewport.y * inv_zoom / TILE_SIZE) + 2;
if (start_tx < 0) start_tx = 0;
if (start_ty < 0) start_ty = 0;
if (end_tx > ed->map.width) end_tx = ed->map.width;
if (end_ty > ed->map.height) end_ty = ed->map.height;
/* Vertical lines */
for (int x = start_tx; x <= end_tx; x++) {
Vec2 top = camera_world_to_screen(cam, vec2(tile_to_world(x), tile_to_world(start_ty)));
Vec2 bot = camera_world_to_screen(cam, vec2(tile_to_world(x), tile_to_world(end_ty)));
SDL_RenderDrawLine(r, (int)top.x, (int)top.y, (int)bot.x, (int)bot.y);
}
/* Horizontal lines */
for (int y = start_ty; y <= end_ty; y++) {
Vec2 left = camera_world_to_screen(cam, vec2(tile_to_world(start_tx), tile_to_world(y)));
Vec2 right_pt = camera_world_to_screen(cam, vec2(tile_to_world(end_tx), tile_to_world(y)));
SDL_RenderDrawLine(r, (int)left.x, (int)left.y, (int)right_pt.x, (int)right_pt.y);
}
SDL_SetRenderDrawBlendMode(r, SDL_BLENDMODE_NONE);
}
/* ── Hazard tile overlay (collision layer) ── */
if (ed->map.collision_layer) {
float inv_zoom = (cam->zoom > 0.0f) ? (1.0f / cam->zoom) : 1.0f;
int hs_tx = (int)floorf(cam->pos.x / TILE_SIZE) - 1;
int hs_ty = (int)floorf(cam->pos.y / TILE_SIZE) - 1;
int he_tx = hs_tx + (int)(cam->viewport.x * inv_zoom / TILE_SIZE) + 3;
int he_ty = hs_ty + (int)(cam->viewport.y * inv_zoom / TILE_SIZE) + 3;
if (hs_tx < 0) hs_tx = 0;
if (hs_ty < 0) hs_ty = 0;
if (he_tx > ed->map.width) he_tx = ed->map.width;
if (he_ty > ed->map.height) he_ty = ed->map.height;
SDL_SetRenderDrawBlendMode(r, SDL_BLENDMODE_BLEND);
for (int y = hs_ty; y < he_ty; y++) {
for (int x = hs_tx; x < he_tx; x++) {
uint16_t tid = ed->map.collision_layer[y * ed->map.width + x];
if (tid == 0 || tid >= ed->map.tile_def_count) continue;
if (!(ed->map.tile_defs[tid].flags & TILE_HAZARD)) continue;
Vec2 sp = camera_world_to_screen(cam,
vec2(tile_to_world(x), tile_to_world(y)));
float zs = TILE_SIZE * cam->zoom;
SDL_SetRenderDrawColor(r, 255, 60, 30, 60);
SDL_Rect hr = {(int)sp.x, (int)sp.y,
(int)(zs + 0.5f), (int)(zs + 0.5f)};
SDL_RenderFillRect(r, &hr);
}
}
SDL_SetRenderDrawBlendMode(r, SDL_BLENDMODE_NONE);
}
/* ── Level boundary ── */
{
SDL_SetRenderDrawColor(r, 200, 200, 255, 120);
SDL_SetRenderDrawBlendMode(r, SDL_BLENDMODE_BLEND);
Vec2 tl = camera_world_to_screen(cam, vec2(0, 0));
Vec2 br = camera_world_to_screen(cam,
vec2((float)(ed->map.width * TILE_SIZE), (float)(ed->map.height * TILE_SIZE)));
SDL_Rect border = {(int)tl.x, (int)tl.y, (int)(br.x - tl.x), (int)(br.y - tl.y)};
SDL_RenderDrawRect(r, &border);
SDL_SetRenderDrawBlendMode(r, SDL_BLENDMODE_NONE);
}
/* ── Entity spawn markers ── */
for (int i = 0; i < ed->map.entity_spawn_count; i++) {
const EntitySpawn *es = &ed->map.entity_spawns[i];
const EntityRegEntry *reg = entity_registry_find(es->type_name);
SDL_Color col = reg ? reg->color : COL_ENTITY;
float ew = reg ? (float)reg->width : TILE_SIZE;
float eh = reg ? (float)reg->height : TILE_SIZE;
Vec2 sp = camera_world_to_screen(cam, vec2(es->x, es->y));
float zw = ew * cam->zoom;
float zh = eh * cam->zoom;
SDL_SetRenderDrawColor(r, col.r, col.g, col.b, 180);
SDL_SetRenderDrawBlendMode(r, SDL_BLENDMODE_BLEND);
SDL_Rect er = {(int)sp.x, (int)sp.y, (int)(zw + 0.5f), (int)(zh + 0.5f)};
SDL_RenderFillRect(r, &er);
SDL_SetRenderDrawColor(r, 255, 255, 255, 200);
SDL_RenderDrawRect(r, &er);
SDL_SetRenderDrawBlendMode(r, SDL_BLENDMODE_NONE);
/* Draw icon or first letter of entity name */
if (reg && zw >= ICON_SIZE + 2 && reg->icon >= 0 && reg->icon < ICON_COUNT) {
draw_icon(r, (EditorIcon)reg->icon,
(int)sp.x + 1, (int)sp.y + 1, COL_TEXT);
} else if (reg && reg->display[0] && zw >= 6) {
font_draw_char(r, reg->display[0], (int)sp.x + 1, (int)sp.y + 1, COL_TEXT);
}
}
/* ── Player spawn marker ── */
{
Vec2 sp = camera_world_to_screen(cam, ed->map.player_spawn);
float zs = TILE_SIZE * cam->zoom;
SDL_SetRenderDrawColor(r, COL_SPAWN.r, COL_SPAWN.g, COL_SPAWN.b, 200);
SDL_SetRenderDrawBlendMode(r, SDL_BLENDMODE_BLEND);
SDL_Rect sr = {(int)sp.x, (int)sp.y, (int)(zs + 0.5f), (int)(zs + 0.5f)};
SDL_RenderDrawRect(r, &sr);
font_draw_text(r, "SP", (int)sp.x + 1, (int)sp.y + 1, COL_SPAWN);
SDL_SetRenderDrawBlendMode(r, SDL_BLENDMODE_NONE);
}
/* ── Exit zone markers ── */
for (int i = 0; i < ed->map.exit_zone_count; i++) {
const ExitZone *ez = &ed->map.exit_zones[i];
Vec2 sp = camera_world_to_screen(cam, vec2(ez->x, ez->y));
float zw = ez->w * cam->zoom;
float zh = ez->h * cam->zoom;
SDL_SetRenderDrawColor(r, COL_EXIT.r, COL_EXIT.g, COL_EXIT.b, 80);
SDL_SetRenderDrawBlendMode(r, SDL_BLENDMODE_BLEND);
SDL_Rect er = {(int)sp.x, (int)sp.y, (int)(zw + 0.5f), (int)(zh + 0.5f)};
SDL_RenderFillRect(r, &er);
SDL_SetRenderDrawColor(r, COL_EXIT.r, COL_EXIT.g, COL_EXIT.b, 220);
SDL_RenderDrawRect(r, &er);
font_draw_text(r, "EXIT", (int)sp.x + 1, (int)sp.y + 1, COL_EXIT);
if (ez->target[0]) {
font_draw_text(r, ez->target, (int)sp.x + 1, (int)sp.y + 8, COL_EXIT);
}
SDL_SetRenderDrawBlendMode(r, SDL_BLENDMODE_NONE);
}
/* ── Cursor highlight ── */
{
int mx_c, my_c;
input_mouse_pos(&mx_c, &my_c);
if (in_canvas(mx_c, my_c)) {
int tx, ty;
screen_to_tile(ed, mx_c, my_c, &tx, &ty);
if (tx >= 0 && tx < ed->map.width && ty >= 0 && ty < ed->map.height) {
Vec2 cpos = camera_world_to_screen(cam,
vec2(tile_to_world(tx), tile_to_world(ty)));
float zs = TILE_SIZE * cam->zoom;
/* Exit tool: show 2x3 preview */
int cw = 1, ch = 1;
if (ed->tool == TOOL_EXIT) {
cw = EXIT_DEFAULT_W;
ch = EXIT_DEFAULT_H;
}
SDL_SetRenderDrawColor(r,
ed->tool == TOOL_EXIT ? COL_EXIT.r : COL_SELECT.r,
ed->tool == TOOL_EXIT ? COL_EXIT.g : COL_SELECT.g,
ed->tool == TOOL_EXIT ? COL_EXIT.b : COL_SELECT.b, 120);
SDL_SetRenderDrawBlendMode(r, SDL_BLENDMODE_BLEND);
SDL_Rect cr = {(int)cpos.x, (int)cpos.y,
(int)(zs * cw + 0.5f), (int)(zs * ch + 0.5f)};
SDL_RenderDrawRect(r, &cr);
SDL_SetRenderDrawBlendMode(r, SDL_BLENDMODE_NONE);
}
}
}
/* ═════════════════════════════════════════
* UI Panels (drawn in screen space)
* ═════════════════════════════════════════ */
/* ── Top toolbar ── */
{
SDL_SetRenderDrawColor(r, COL_PANEL.r, COL_PANEL.g, COL_PANEL.b, COL_PANEL.a);
SDL_Rect tb = {0, 0, SCREEN_WIDTH, EDITOR_TOOLBAR_H};
SDL_RenderFillRect(r, &tb);
/* Vertically center text: (EDITOR_TOOLBAR_H - FONT_H) / 2 */
int text_y = (EDITOR_TOOLBAR_H - FONT_H) / 2;
/* Tool buttons */
for (int i = 0; i < TOOL_COUNT; i++) {
int bx = i * 35 + 2;
SDL_Color tc = (i == (int)ed->tool) ? COL_HIGHLIGHT : COL_TEXT_DIM;
font_draw_text(r, s_tool_names[i], bx, text_y, tc);
}
/* Separator */
int sep_x = TOOL_COUNT * 35 + 4;
SDL_SetRenderDrawColor(r, COL_PANEL_LT.r, COL_PANEL_LT.g, COL_PANEL_LT.b, 255);
SDL_RenderDrawLine(r, sep_x, 3, sep_x, EDITOR_TOOLBAR_H - 3);
/* Layer buttons */
int layer_start = sep_x + 4;
for (int i = 0; i < EDITOR_LAYER_COUNT; i++) {
int bx = layer_start + i * 25;
SDL_Color lc = (i == (int)ed->active_layer) ? COL_HIGHLIGHT : COL_TEXT_DIM;
font_draw_text(r, s_layer_names[i], bx, text_y, lc);
}
/* Grid & Layers indicators */
int grid_x = layer_start + EDITOR_LAYER_COUNT * 25 + 4;
font_draw_text(r, ed->show_grid ? "[G]RID" : "[G]rid", grid_x, text_y,
ed->show_grid ? COL_TEXT : COL_TEXT_DIM);
/* Tileset switch hint */
int ts_x = grid_x + 7 * (FONT_W + 1) + 4;
font_draw_text(r, "[T]SET", ts_x, text_y, COL_TEXT_DIM);
}
/* ── Right palette panel ── */
{
int px = SCREEN_WIDTH - EDITOR_PALETTE_W;
int py = EDITOR_TOOLBAR_H;
int ph = SCREEN_HEIGHT - EDITOR_TOOLBAR_H - EDITOR_STATUS_H;
SDL_SetRenderDrawColor(r, COL_PANEL.r, COL_PANEL.g, COL_PANEL.b, COL_PANEL.a);
SDL_Rect panel = {px, py, EDITOR_PALETTE_W, ph};
SDL_RenderFillRect(r, &panel);
/* Left separator line */
SDL_SetRenderDrawColor(r, COL_PANEL_LT.r, COL_PANEL_LT.g, COL_PANEL_LT.b, 255);
SDL_RenderDrawLine(r, px, py, px, py + ph);
/* Split: tiles top ~55%, entities bottom ~45% */
int tile_section_h = (ph * 55) / 100;
int ent_section_y = py + tile_section_h;
/* ── Tile palette (top section) ── */
{
int label_h = FONT_H + 6; /* label area: font + padding */
/* Show tileset filename (strip directory) */
{
const char *ts_name = strrchr(ed->map.tileset_path, '/');
ts_name = ts_name ? ts_name + 1 : ed->map.tileset_path;
font_draw_text(r, ts_name[0] ? ts_name : "TILES",
px + 2, py + (label_h - FONT_H) / 2, COL_TEXT);
}
int pal_y_start = py + label_h;
int max_cols = (EDITOR_PALETTE_W - 4) / (TILE_SIZE + 1);
if (max_cols < 1) max_cols = 1;
if (ed->map.tileset && ed->tileset_total > 0) {
SDL_Rect clip = {px, pal_y_start, EDITOR_PALETTE_W,
tile_section_h - label_h};
SDL_RenderSetClipRect(r, &clip);
for (int id = 1; id <= ed->tileset_total; id++) {
int col_idx = (id - 1) % max_cols;
int row_idx = (id - 1) / max_cols;
int draw_x = px + 2 + col_idx * (TILE_SIZE + 1);
int draw_y = pal_y_start + row_idx * (TILE_SIZE + 1)
- ed->tile_palette_scroll * (TILE_SIZE + 1);
if (draw_y + TILE_SIZE < pal_y_start ||
draw_y > ent_section_y) continue;
/* Use TileDef tex coords when available, else grid position */
int src_col, src_row;
if (id < ed->map.tile_def_count) {
src_col = ed->map.tile_defs[id].tex_x;
src_row = ed->map.tile_defs[id].tex_y;
} else {
src_col = (id - 1) % ed->tileset_cols;
src_row = (id - 1) / ed->tileset_cols;
}
SDL_Rect src = {
src_col * TILE_SIZE, src_row * TILE_SIZE,
TILE_SIZE, TILE_SIZE
};
SDL_Rect dst = {draw_x, draw_y, TILE_SIZE, TILE_SIZE};
SDL_RenderCopy(r, ed->map.tileset, &src, &dst);
/* Flag indicator: colored dot for solid/platform/hazard */
if (id < ed->map.tile_def_count) {
uint32_t fl = ed->map.tile_defs[id].flags;
if (fl & TILE_HAZARD) {
SDL_SetRenderDrawColor(r, 255, 80, 40, 255);
SDL_Rect dot = {draw_x + TILE_SIZE - 3, draw_y, 3, 3};
SDL_RenderFillRect(r, &dot);
} else if (fl & TILE_PLATFORM) {
SDL_SetRenderDrawColor(r, 80, 200, 255, 255);
SDL_Rect dot = {draw_x + TILE_SIZE - 3, draw_y, 3, 3};
SDL_RenderFillRect(r, &dot);
} else if (fl & TILE_SOLID) {
SDL_SetRenderDrawColor(r, 200, 200, 200, 180);
SDL_Rect dot = {draw_x + TILE_SIZE - 3, draw_y, 3, 3};
SDL_RenderFillRect(r, &dot);
}
}
/* Highlight selected */
if (id == (int)ed->selected_tile) {
SDL_SetRenderDrawColor(r, COL_HIGHLIGHT.r, COL_HIGHLIGHT.g,
COL_HIGHLIGHT.b, 255);
SDL_Rect sel = {draw_x - 1, draw_y - 1,
TILE_SIZE + 2, TILE_SIZE + 2};
SDL_RenderDrawRect(r, &sel);
}
}
SDL_RenderSetClipRect(r, NULL);
}
/* Show selected tile's flag below palette */
if (ed->selected_tile > 0 && ed->selected_tile < MAX_TILE_DEFS) {
uint32_t flags = 0;
if (ed->selected_tile < ed->map.tile_def_count)
flags = ed->map.tile_defs[ed->selected_tile].flags;
const char *fname = tile_flag_name(flags);
SDL_Color fc = (flags & TILE_HAZARD) ? (SDL_Color){255, 80, 40, 255} :
(flags & TILE_PLATFORM) ? (SDL_Color){80, 200, 255, 255} :
(flags & TILE_SOLID) ? COL_TEXT : COL_TEXT_DIM;
font_draw_text(r, fname, px + 2, ent_section_y - FONT_H - 2, fc);
/* Show [F] hint */
int fw = (int)strlen(fname) * (FONT_W + 1);
font_draw_text(r, "[F]", px + 2 + fw + 2, ent_section_y - FONT_H - 2, COL_TEXT_DIM);
}
}
/* ── Divider line between tiles and entities ── */
SDL_SetRenderDrawColor(r, COL_PANEL_LT.r, COL_PANEL_LT.g, COL_PANEL_LT.b, 255);
SDL_RenderDrawLine(r, px + 2, ent_section_y, px + EDITOR_PALETTE_W - 2, ent_section_y);
/* ── Entity palette (bottom section) ── */
{
int label_h = FONT_H + 6;
font_draw_text(r, "ENTITIES", px + 2, ent_section_y + (label_h - FONT_H) / 2, COL_TEXT);
int pal_y_start = ent_section_y + label_h;
int ent_area_h = py + ph - pal_y_start;
SDL_Rect clip = {px, pal_y_start, EDITOR_PALETTE_W, ent_area_h};
SDL_RenderSetClipRect(r, &clip);
for (int i = 0; i < g_entity_registry.count; i++) {
const EntityRegEntry *ent = &g_entity_registry.entries[i];
int ey = pal_y_start + i * 12 - ed->entity_palette_scroll * 12;
if (ey + 10 < pal_y_start || ey > py + ph) continue;
/* Mini-icon (or color swatch fallback) */
if (ent->icon >= 0 && ent->icon < ICON_COUNT) {
draw_icon(r, (EditorIcon)ent->icon,
px + 2, ey + 1, ent->color);
} else {
SDL_SetRenderDrawColor(r, ent->color.r, ent->color.g,
ent->color.b, 255);
SDL_Rect swatch = {px + 2, ey + 1, 8, 8};
SDL_RenderFillRect(r, &swatch);
}
/* Name */
SDL_Color nc = (i == ed->selected_entity) ? COL_HIGHLIGHT : COL_TEXT;
font_draw_text(r, ent->display, px + 13, ey + 2, nc);
}
SDL_RenderSetClipRect(r, NULL);
}
}
/* ── Bottom status bar ── */
{
int sy = SCREEN_HEIGHT - EDITOR_STATUS_H;
SDL_SetRenderDrawColor(r, COL_PANEL.r, COL_PANEL.g, COL_PANEL.b, COL_PANEL.a);
SDL_Rect sb = {0, sy, SCREEN_WIDTH, EDITOR_STATUS_H};
SDL_RenderFillRect(r, &sb);
/* Cursor position */
int mx_s, my_s;
input_mouse_pos(&mx_s, &my_s);
int tx = 0, ty = 0;
screen_to_tile(ed, mx_s, my_s, &tx, &ty);
char status[512];
snprintf(status, sizeof(status), "%dx%d (%d,%d) Z:%.0f%% %s%s",
ed->map.width, ed->map.height,
tx, ty,
ed->camera.zoom * 100.0f,
ed->has_file ? ed->file_path : "new level",
ed->dirty ? " *" : "");
font_draw_text(r, status, 2, sy + (EDITOR_STATUS_H - FONT_H) / 2, COL_TEXT);
}
}
Reference in New Issue View Git Blame Copy Permalink