      src/editor.odin
      2124 lines
    

package main import "core:fmt"import "core:log"import "core:math"import "core:math/linalg"import "core:math/rand"import "core:mem"import "core:mem/virtual"import "core:slice"import "core:strings"import rl "vendor:raylib" Editor_Tool :: enum {	None,	Tile,	Spike,	Level,	Level_Resize,	Entity,	Checkpoint,	Powerup,} // Ordered this way so looping gives priority to cornersDir8 :: enum {	NE,	SE,	SW,	NW,	N,	E,	S,	W,} Dir8_Coords := [Dir8]Vec2i {	.NE = Vec2i{1, -1},	.SE = Vec2i{1, 1},	.SW = Vec2i{-1, 1},	.NW = Vec2i{-1, -1},	.N  = Vec2i{0, -1},	.E  = Vec2i{1, 0},	.S  = Vec2i{0, 1},	.W  = Vec2i{-1, 0},} Tile_Neighbors :: bit_set[Dir8]TILE_NEIGHBORS_ALL: Tile_Neighbors : {.N, .E, .S, .W, .NE, .SE, .SW, .NW} Tile_Flip :: enum {	None,	X,	Y,	Both,} Rule_Flags :: enum {	Match_Exact,	Terminate,} Tileset_Rule :: struct {	src:                         Vec2,	layer:                       Tileset_Layer,	flip:                        Tile_Flip,	flags:                       bit_set[Rule_Flags],	grid:                        [9][9]Tileset_Rule_Cell_Type,	alignment:                   Tileset_Rule_Alignment,	sources:                     []Rect,	random_distribution:         f32,	x_modulo, x_modulo_offset:   i32,	y_modulo, y_modulo_offset:   i32,	check_before_apply:          proc(coords: Vec2i, level: ^Level) -> bool,} Tileset_Layer :: enum {	Collisions,	Background,} Tileset_Rule_Alignment :: enum {	None,	Left,	Right,} Tileset_Rule_Cell_Type :: enum {	Unset              = '.',	Is_Solid_Tile      = '#',	Is_Background_Tile = '~',	Has_No_Value       = '0',	Has_Any_Value      = '?',	Is_Out_Of_Bounds   = 'X',	Is_Spike           = '^',} Tileset :: struct {	texture: int,	rules:   []Tileset_Rule,	layer: Tileset_Layer,} PANEL_WIDTH :: 260 make_main_tileset :: proc() -> Tileset {	tileset: Tileset 	rules := make([dynamic]Tileset_Rule) 	ascii: []string	rule: Tileset_Rule	sources: []Rect	sources_flipped_x: []Rect	sources_flipped_y: []Rect	_ = sources_flipped_x	_ = sources_flipped_y 	ascii = []string{		`.........`,		`.........`,		`.........`,		`....^....`,		`....#....`,		`.........`,		`.........`,		`.........`,		`.........`,	}	rule = rule_from_ascii(ascii)	sources = make([]Rect, 1)	sources[0] = {112, 16, 16, 16}	rule.sources = sources[:]	rule.flags = {.Terminate}	rule_append(&rules, rule) 	ascii = []string{		`.........`,		`.........`,		`.........`,		`.........`,		`....#....`,		`....X....`,		`.........`,		`.........`,		`.........`,	}	rule = rule_from_ascii(ascii)	rule.flip = .Y	sources = make([]Rect, 1)	sources[0] = {48, 48, 16, 16}	rule.sources = sources[:]	rule.flags = {.Terminate}	sources_flipped_y = make([]Rect, 1)	sources_flipped_y[0] = {48, 48, 16, 16}	rule_append(&rules, rule, nil, sources_flipped_y) 	ascii = []string{		`.........`,		`.........`,		`.........`,		`....#....`,		`...X#....`,		`....#....`,		`.........`,		`.........`,		`.........`,	}	rule = rule_from_ascii(ascii)	rule.flip = .X	sources = make([]Rect, 1)	sources[0] = {48, 48, 16, 16}	rule.sources = sources[:]	rule.flags = {.Terminate}	sources_flipped_x = make([]Rect, 1)	sources_flipped_x[0] = {48, 48, 16, 16}	rule_append(&rules, rule, sources_flipped_x) 	ascii = []string{		`.........`,		`.........`,		`.........`,		`....#....`,		`...###...`,		`....#....`,		`.........`,		`.........`,		`.........`,	}	rule = rule_from_ascii(ascii)	sources = make([]Rect, 1)	sources[0] = {48, 48, 16, 16}	rule.sources = sources[:]	rule.flags = {.Terminate}	rule_append(&rules, rule) 	ascii = []string{		`.........`,		`.........`,		`.........`,		`.........`,		`...0#....`,		`.........`,		`.........`,		`.........`,		`.........`,	}	rule = rule_from_ascii(ascii)	rule.flip = .X	sources = make([]Rect, 1)	sources[0] = {16, 48, 16, 16}	rule.sources = sources[:]	sources_flipped_x = make([]Rect, 1)	sources_flipped_x[0] = {80, 48, 16, 16}	rule_append(&rules, rule, sources_flipped_x) 	ascii = []string{		`.........`,		`.........`,		`.........`,		`....#....`,		`...^#....`,		`.........`,		`.........`,		`.........`,		`.........`,	}	rule = rule_from_ascii(ascii)	rule.flip = .X	sources = make([]Rect, 1)	sources[0] = {16, 48, 16, 16}	rule.sources = sources[:]	rule.flags = {.Terminate}	sources_flipped_x = make([]Rect, 1)	sources_flipped_x[0] = {80, 48, 16, 16}	rule_append(&rules, rule, sources_flipped_x) 	ascii = []string{		`.........`,		`.........`,		`.........`,		`.........`,		`....#....`,		`....0....`,		`.........`,		`.........`,		`.........`,	}	rule = rule_from_ascii(ascii)	rule.flip = .Y	sources = make([]Rect, 1)	sources[0] = {48, 80, 16, 16}	rule.sources = sources[:]	sources_flipped_y = make([]Rect, 1)	sources_flipped_y[0] = {48, 16, 16, 16}	rule_append(&rules, rule, nil, sources_flipped_y) 	ascii = []string{		`.........`,		`.........`,		`.........`,		`...##....`,		`...##0...`,		`....0....`,		`.........`,		`.........`,		`.........`,	}	rule = rule_from_ascii(ascii)	rule.flip = .X	sources = make([]Rect, 1)	sources[0] = {80, 80, 16, 16}	rule.sources = sources[:]	rule.flags = {.Terminate}	sources_flipped_x = make([]Rect, 1)	sources_flipped_x[0] = {16, 80, 16, 16}	rule_append(&rules, rule, sources_flipped_x) 	ascii = []string{		`.........`,		`.........`,		`.........`,		`....0....`,		`....#....`,		`....0....`,		`.........`,		`.........`,		`.........`,	}	rule = rule_from_ascii(ascii)	sources = make([]Rect, 1)	sources[0] = {16, 320, 16, 16}	rule.sources = sources[:]	rule.flags = {.Terminate}	rule_append(&rules, rule) 	tileset.texture = gs.tileset_texture	tileset.rules = rules[:] 	return tileset} rule_from_ascii :: proc(rows: []string) -> Tileset_Rule {	rule: Tileset_Rule 	for row, y in rows {		for char, x in row {			rule.grid[y][x] = Tileset_Rule_Cell_Type(char)		}	} 	return rule} make_bg_tileset :: proc() -> Tileset {	tileset: Tileset	tileset.layer = .Background 	rules := make([dynamic]Tileset_Rule) 	ascii: []string	rule: Tileset_Rule	sources: []Rect	sources_flipped_x: []Rect	sources_flipped_y: []Rect	_ = sources_flipped_x	_ = sources_flipped_y 	ascii = []string{		`.........`,		`.........`,		`.........`,		`.0000000.`,		`.00~~~00.`,		`.0000000.`,		`..00000..`,		`...000...`,		`.........`	}	rule = rule_from_ascii(ascii)	sources = make([]Rect, 1)	sources[0] = {272, 256, 48, 16}	rule.sources = sources[:]	rule.random_distribution = 0.10	rule.y_modulo = 2	rule.x_modulo = 3	rule.flags = {.Terminate}	rule_append(&rules, rule) 	ascii = []string{		`.........`,		`.........`,		`....00...`,		`....00...`,		`....00...`,		`....##...`,		`.........`,		`.........`,		`.........`	}	rule = rule_from_ascii(ascii)	sources = make([]Rect, 1)	sources[0] = {224, 256, 32, 48}	rule.sources = sources[:]	rule.x_modulo = 7	rule.random_distribution = 0.5	rule.flags = {.Terminate}	rule_append(&rules, rule) 	ascii = []string{		`.........`,		`.........`,		`.........`,		`..000#...`,		`..000#...`,		`..####...`,		`.........`,		`.........`,		`.........`	}	rule = rule_from_ascii(ascii)	sources = make([]Rect, 1)	sources[0] = {144, 320, 48, 32}	rule.sources = sources[:]	rule.random_distribution = 0.5	rule.alignment = .Right	rule.flags = {.Terminate}	rule_append(&rules, rule) 	ascii = []string{		`.........`,		`.........`,		`.........`,		`..#000...`,		`..#000...`,		`..####...`,		`.........`,		`.........`,		`.........`	}	rule = rule_from_ascii(ascii)	sources = make([]Rect, 1)	sources[0] = {208, 320, 48, 32}	rule.sources = sources[:]	rule.random_distribution = 0.5	rule.alignment = .Left	rule.flags = {.Terminate}	rule_append(&rules, rule) 	ascii = []string{		`.........`,		`.........`,		`.........`,		`.........`,		`....0....`,		`....#....`,		`....#....`,		`.........`,		`.........`	}	rule = rule_from_ascii(ascii)	sources = make([]Rect, 2)	sources[0] = {16, 112, 16, 16}	sources[1] = {48, 112, 16, 16}	rule.sources = sources[:]	rule.random_distribution = 0.5	rule.check_before_apply = proc(coords: Vec2i, level: ^Level) -> bool {		if is_spike_at(coords, level) {			return false		}		return true	}	rule_append(&rules, rule) 	tileset.texture = gs.tileset_texture	tileset.rules = rules[:] 	return tileset} tiles_reset :: proc(tiles: []Tile) {	for &tile in tiles {		tile.src = 0		tile.done = false	}} autotile_run_bg :: proc(data: rawptr) {	level := cast(^Level)data	autotile_run(gs.main_tileset, level)	autotile_run(gs.bg_tileset, level)} autotile_run :: proc(tileset: Tileset, level: ^Level) {	tiles := tileset.layer == .Collisions ? level.tiles[:] : level.bg_tiles[:] 	outer: for &tile in tiles {		for rule in tileset.rules {			tile_coords := coords_from_pos(tile.pos)			tile_seed := u64(tile_coords.x * 1337 + tile_coords.y * 5084) 			rand.reset(tile_seed) 			if rule.random_distribution > 0 && rand.float32() > rule.random_distribution {				continue			} 			if rule.x_modulo > 0 {				if tile_coords.x % rule.x_modulo != rule.x_modulo_offset {					continue				}			} 			if rule.y_modulo > 0 {				if tile_coords.y % rule.y_modulo != rule.y_modulo_offset {					continue				}			} 			success := rule_check(rule, tile_coords, level) 			if success {				should_apply := true 				if rule.check_before_apply != nil {					should_apply = rule.check_before_apply(tile_coords, level)				} 				if should_apply {					rule_apply(rule, &tile, tiles)				} 				if .Terminate in rule.flags {					continue outer				}			}		}	} 	level.flags += {.Autotile_Has_Run}} rule_append :: proc(	rules: ^[dynamic]Tileset_Rule,	rule: Tileset_Rule,	sources_flipped_x: []Rect = nil,	sources_flipped_y: []Rect = nil) {	append(rules, rule) 	switch rule.flip {	case .None:	case .X:		rule_flipped_x := rule		rule_flipped_x.sources = sources_flipped_x		for y in 0..< 9 {			slice.reverse(rule_flipped_x.grid[y][:])		}		append(rules, rule_flipped_x)	case .Y:		rule_flipped_y := rule		rule_flipped_y.sources = sources_flipped_y		slice.reverse(rule_flipped_y.grid[:])		append(rules, rule_flipped_y)	case .Both:		rule_flipped_x := rule		for y in 0..< 9 {			slice.reverse(rule_flipped_x.grid[y][:])		}		append(rules, rule_flipped_x) 		rule_flipped_y := rule		rule_flipped_y.sources = sources_flipped_y		slice.reverse(rule_flipped_y.grid[:])		append(rules, rule_flipped_y)	}} rule_print_ascii :: proc(rule: Tileset_Rule) {	for y in 0..< 9 {		for x in 0..< 9 {			fmt.printf("%c ", u8(rule.grid[y][x]))		}		fmt.print("\n")	}	fmt.println("---------")} rule_check :: proc(rule: Tileset_Rule, tile_coords: Vec2i, level: ^Level) -> bool {	for y in 0..< 9 {		for x in 0..< 9 {			cell := rule.grid[y][x]			cell_coords := tile_coords + Vec2i{i32(x) - 4, i32(y) - 4} 			switch cell {			case .Unset:			case .Is_Solid_Tile:				if !is_tile_at(cell_coords, level.tiles[:]) {					return false				}			case .Is_Background_Tile:				if !is_tile_at(cell_coords, level.bg_tiles[:]) {					return false				}			case .Has_No_Value:				if is_tile_at(cell_coords, level.tiles[:]) {					return false				}			case .Has_Any_Value:				if !is_tile_at(cell_coords, level.tiles[:]) && !is_tile_at(cell_coords, level.bg_tiles[:]) {					return false				}			case .Is_Out_Of_Bounds:				if !is_tile_oob(cell_coords, level) {					return false				}			case .Is_Spike:				if !is_spike_at(cell_coords, level) {					return false				}			} 		}	} 	return true} rule_apply :: proc(rule: Tileset_Rule, tile: ^Tile, tiles: []Tile) {	source: Rect 	if len(rule.sources) > 1 {		index := rand.int31_max(i32(len(rule.sources)))		source = rule.sources[index]	} else {		source = rule.sources[0]	} 	w := int(source.width / TILE_SIZE)	h := int(source.height / TILE_SIZE) 	for x in 0..< w {		for y in 0..< h {			tile_x := tile.pos.x + f32(x) * TILE_SIZE			tile_y := tile.pos.y - f32(h - y - 1) * TILE_SIZE 			switch rule.alignment {			case .None:			case .Left:				tile_x -= TILE_SIZE * math.floor(f32(w / 2))			case .Right:				tile_x -= TILE_SIZE * f32(w - 1)			} 			t, t_ok := tile_get({tile_x, tile_y}, tiles[:])			if t_ok && !t.done {				t.src.x = source.x + f32(x) * TILE_SIZE				t.src.y = source.y + f32(y) * TILE_SIZE				t.flip = rule.flip				if .Terminate in rule.flags {					t.done = true				}			}		}	}} tile_get :: proc(pos: Vec2, tiles: []Tile) -> (tile: ^Tile, ok: bool) {	for &tile in tiles {		if tile.pos == pos {			return &tile, true		}	}	return nil, false} Resize_Cursor := [Dir8]rl.MouseCursor {	.N  = .RESIZE_NS,	.NE = .RESIZE_NESW,	.E  = .RESIZE_EW,	.SE = .RESIZE_NWSE,	.S  = .RESIZE_NS,	.SW = .RESIZE_NESW,	.W  = .RESIZE_EW,	.NW = .RESIZE_NWSE,} Editor_State :: struct {	cmd_arena:         virtual.Arena,	cmd_allocator:     mem.Allocator,	tool:              Editor_Tool,	previous_tool:     Editor_Tool,	area_begin:        Vec2i,	area_end:          Vec2i,	resize_level_dir:  Dir8,	resize_rect:       Rect,	resize_start_pos:  Vec2,	command_history:   [dynamic]Cmd_Entry,	undo_count:        int,	spike_facing:      Direction,	tileset:           Tileset,	is_dragging:       bool,	drag_start:        Vec2,	drag_end:          Vec2,	deleted_levels:    [dynamic]Level,	entity_type_key:   string,	powerup_type:      Power_Up_Type,} Cmd :: union {	Cmd_Tiles_Insert,	Cmd_Tiles_Remove,	Cmd_Spikes_Insert,	Cmd_Spikes_Remove,	Cmd_Level_Move,	Cmd_Level_New,	Cmd_Level_Delete,	Cmd_Level_Restore,	Cmd_Level_Resize,	Cmd_Entity_Insert,	Cmd_Entity_Remove,	Cmd_Checkpoint_Insert,	Cmd_Checkpoint_Remove,	Cmd_Powerup_Insert,	Cmd_Powerup_Remove,} Cmd_Tiles_Insert :: struct {	coords:         []Vec2i,	spikes_removed: []Spike,} Cmd_Tiles_Remove :: struct {	coords:         []Vec2i,	spikes_removed: []Spike,} Cmd_Spikes_Insert :: struct {	spikes:        []Spike,	tiles_removed: []Vec2i,} Cmd_Spikes_Remove :: struct {	spikes:        []Spike,	tiles_removed: []Vec2i,} Cmd_Level_Move :: struct {	level_id: u32,	old_pos:  Vec2,	new_pos:  Vec2,} Cmd_Level_New :: struct {	pos:      Vec2,	size:     Vec2,	level_id: u32,} Cmd_Level_Delete :: struct {	level_id: u32,} Cmd_Level_Restore :: struct {	level_id: u32,} Cmd_Level_Resize :: struct {	level_id:       u32,	old_pos:        Vec2,	old_size:       Vec2,	new_pos:        Vec2,	new_size:       Vec2,	removed_tiles:  []Tile,	removed_spikes: []Spike,} Cmd_Entity_Insert :: struct {	coords: Vec2i,	type:   string,} Cmd_Entity_Remove :: struct {	coords: Vec2i,	type:   string,} Cmd_Checkpoint_Insert :: struct {	coords: Vec2i,} Cmd_Checkpoint_Remove :: struct {	coords: Vec2i,} Cmd_Powerup_Insert :: struct {	coords: Vec2i,	type: Power_Up_Type,} Cmd_Powerup_Remove :: struct {	coords: Vec2i,	type: Power_Up_Type,} Cmd_Entry :: struct {	forward: Cmd,	inverse: Cmd,} editor_command_execute :: proc(cmd: Cmd) {	switch v in cmd {	case Cmd_Tiles_Insert:		for coords in v.coords {			editor_tile_insert(coords, gs.level)		} 		for spike in v.spikes_removed {			editor_spike_remove(spike, gs.level)		}	case Cmd_Tiles_Remove:		for coords in v.coords {			editor_tile_remove(coords, gs.level)		} 		for spike in v.spikes_removed {			editor_spike_insert(spike, gs.level)		}	case Cmd_Spikes_Insert:		for spike in v.spikes {			editor_spike_insert(spike, gs.level)		} 		for coords in v.tiles_removed {			editor_tile_remove(coords, gs.level)		}	case Cmd_Spikes_Remove:		for spike in v.spikes {			editor_spike_remove(spike, gs.level)		} 		for coords in v.tiles_removed {			editor_tile_insert(coords, gs.level)		}	case Cmd_Level_Move:		level_load(gs, v.level_id) 		delta := v.new_pos - v.old_pos 		gs.level.pos = gs.level.pos + delta 		for &tile in gs.level.tiles {			tile.pos += delta		} 		for &spike in gs.level.spikes {			spike.collider.x += delta.x			spike.collider.y += delta.y		} 		for &spawner in gs.level.spawners {			spawner.pos += delta		} 		for &entity, i in gs.entities {			if Entity_Id(i) != gs.player_id {				entity.x += delta.x				entity.y += delta.y			}		} 		for &checkpoint in gs.level.checkpoints {			checkpoint.pos += delta		} 		for &powerup in gs.level.power_up_spawns {			powerup.pos += delta		}	case Cmd_Level_New:		level: Level		level.id = v.level_id		level.name = strings.clone(fmt.tprintf("level_%d", level.id))		level.pos = v.pos		level.player_spawn = level.pos		level.size = v.size		append(&gs.levels, level) 		level_load(gs, level.id)	case Cmd_Level_Delete:		append(&es.deleted_levels, level_from_id(gs.levels[:], v.level_id)^)		deleted_level_index := level_index_from_id(gs.levels[:], v.level_id)		// Since we don't clear the dynamic memory, it still exists even after this		unordered_remove(&gs.levels, deleted_level_index) 		// Load first non-deleted level		// Prevents artifacts from level data sticking around		for l in gs.levels {			if l.id != v.level_id {				level_load(gs, l.id)			}		}	case Cmd_Level_Restore:		append(&gs.levels, level_from_id(es.deleted_levels[:], v.level_id)^)		restored_level_index := level_index_from_id(es.deleted_levels[:], v.level_id)		unordered_remove(&es.deleted_levels, restored_level_index) 		level_load(gs, v.level_id)	case Cmd_Level_Resize:		level_load(gs, v.level_id) 		// We are reducing the size, therefore we may need to remove some tiles/spikes/(TODO)entities		// NOTE: I am comparing coords in case *somehow* there are floating point precision issues		// Even though we set values to absolute numbers, we may do something in the future		// that means we break == comparison		if gs.level.size.x > v.new_size.x || gs.level.size.y > v.new_size.y {			for tile in v.removed_tiles {				tile_coords := coords_from_pos(tile.pos)				#reverse for level_tile, i in gs.level.tiles {					level_tile_coords := coords_from_pos(level_tile.pos)					if tile_coords == level_tile_coords {						ordered_remove(&gs.level.tiles, i)					}				}			} 			for spike in v.removed_spikes {				spike_coords := coords_from_pos({spike.collider.x, spike.collider.y})				#reverse for level_spike, i in gs.level.spikes {					level_spike_coords := coords_from_pos(						{level_spike.collider.x, level_spike.collider.y},					)					if spike_coords == level_spike_coords {						ordered_remove(&gs.level.spikes, i)					}				}			}		} else {			// NOTE: This is an "Undo"			for tile in v.removed_tiles {				append(&gs.level.tiles, tile)			} 			for spike in v.removed_spikes {				append(&gs.level.spikes, spike)			}		} 		gs.level.pos = v.new_pos		gs.level.size = v.new_size	case Cmd_Entity_Insert:		pos := pos_from_coords(v.coords)		found := false		for spawner in gs.level.spawners {			if spawner.pos == pos {				found = true				break			}		} 		if !found {			append(&gs.level.spawners, Spawner {pos = pos, type = v.type})		}	case Cmd_Entity_Remove:		pos := pos_from_coords(v.coords)		for spawner, i in gs.level.spawners {			if spawner.pos == pos {				unordered_remove(&gs.level.spawners, i)				break			}		}	case Cmd_Checkpoint_Insert:		pos := pos_from_coords(v.coords)		found := false		for checkpoint in gs.level.checkpoints {			if checkpoint.pos == pos {				found = true				break			}		} 		if !found {			append(&gs.level.checkpoints, Checkpoint {pos = pos})		}	case Cmd_Checkpoint_Remove:		pos := pos_from_coords(v.coords)		for checkpoint, i in gs.level.checkpoints {			if checkpoint.pos == pos {				unordered_remove(&gs.level.checkpoints, i)				break			}		}	case Cmd_Powerup_Insert:		pos := pos_from_coords(v.coords)		found := false		for power_up_spawn in gs.level.power_up_spawns {			if power_up_spawn.pos == pos {				found = true				break			}		} 		if !found {			append(&gs.level.power_up_spawns, Power_Up_Spawn {pos = pos})		}	case Cmd_Powerup_Remove:		pos := pos_from_coords(v.coords)		for powerup, i in gs.level.power_up_spawns {			if powerup.pos == pos {				unordered_remove(&gs.level.power_up_spawns, i)				break			}		}	} 	recreate_colliders(gs.level.pos, &gs.colliders, gs.falling_logs[:], gs.level.tiles[:]) 	world_data_save()} editor_command_record :: proc(cmd: Cmd_Entry) {	next_index := len(es.command_history) - es.undo_count	resize(&es.command_history, next_index + 1) 	es.command_history[next_index] = cmd	es.undo_count = 0} editor_command_construct :: proc(cmd_type: typeid) -> (cmd: Cmd_Entry, ok: bool) {	switch cmd_type {	case Cmd_Tiles_Insert:		area_coords := coords_from_area(es.area_begin, es.area_end) 		// No tiles inside level bounds		if len(area_coords) == 0 {			return		} 		spikes := spikes_from_area(es.area_begin, es.area_end, gs.level) 		forward := Cmd_Tiles_Insert {			coords         = area_coords,			spikes_removed = spikes,		} 		air := make([dynamic]Vec2i) 		for coords in area_coords {			if !is_tile_at(coords, gs.level.tiles[:]) {				append(&air, coords)			}		} 		inverse := Cmd_Tiles_Remove {			coords         = air[:],			spikes_removed = spikes,		} 		return {forward, inverse}, true	case Cmd_Tiles_Remove:		area_coords := coords_from_area(es.area_begin, es.area_end) 		forward := Cmd_Tiles_Remove {			coords = area_coords,		} 		solid := make([dynamic]Vec2i) 		for coords in area_coords {			if is_tile_at(coords, gs.level.tiles[:]) {				append(&solid, coords)			}		} 		// No tiles removed		if len(solid) == 0 {			return		} 		spikes := spikes_from_area(es.area_begin, es.area_end, gs.level) 		inverse := Cmd_Tiles_Insert {			coords         = solid[:],			spikes_removed = spikes,		} 		return {forward, inverse}, true	case Cmd_Spikes_Insert:		area_begin, area_end := es.area_begin, es.area_end		area_coords := coords_from_area(area_begin, area_end) 		if len(area_coords) == 0 {			return		} 		tiles := tiles_from_area(area_begin, area_end) 		spikes := make([dynamic]Spike) 		for coords in area_coords {				spike := spike_init(coords, es.spike_facing)				append(&spikes, spike)		} 		forward := Cmd_Spikes_Insert {			spikes        = spikes[:],			tiles_removed = tiles,		} 		inverse := Cmd_Spikes_Remove {			spikes        = spikes[:],			tiles_removed = tiles,		} 		return {forward, inverse}, true	case Cmd_Spikes_Remove:		spikes := spikes_from_area(es.area_begin, es.area_end, gs.level) 		if len(spikes) == 0 do return 		forward := Cmd_Spikes_Remove {			spikes = spikes,		} 		inverse := Cmd_Spikes_Insert {			spikes = spikes,		} 		return {forward, inverse}, true	case Cmd_Level_Move:		forward := Cmd_Level_Move {			level_id = gs.level.id,			old_pos  = es.drag_start,			new_pos  = es.drag_end,		} 		inverse := Cmd_Level_Move {			level_id = forward.level_id,			old_pos  = forward.new_pos,			new_pos  = forward.old_pos,		} 		return {forward, inverse}, true	case Cmd_Level_New:		mouse_pos := rl.GetMousePosition()		world_pos := rl.GetScreenToWorld2D(mouse_pos, gs.camera)		// Round to tile corner		coords := coords_from_pos(world_pos)		pos := pos_from_coords(coords) 		// Default level size is one "screen"		size := linalg.ceil(Vec2{RENDER_WIDTH, RENDER_HEIGHT} / TILE_SIZE) * TILE_SIZE		rect := rect_from_pos_size(pos, size) 		for l in gs.levels {			def_rect := rect_from_pos_size(l.pos, l.size)			if rl.CheckCollisionRecs(rect, def_rect) {				// Invalid position				return {}, false			}		} 		level_id := get_next_level_id() 		forward := Cmd_Level_New {			level_id = level_id,			pos      = pos,			size     = size,		} 		inverse := Cmd_Level_Delete {			level_id = level_id,		} 		return {forward, inverse}, true	case Cmd_Level_Delete:		forward := Cmd_Level_Delete {			level_id = gs.level.id,		} 		inverse := Cmd_Level_Restore {			level_id = gs.level.id,		} 		return {forward, inverse}, true	case Cmd_Level_Restore:		forward := Cmd_Level_Restore {			level_id = gs.level.id,		} 		inverse := Cmd_Level_Delete {			level_id = gs.level.id,		} 		return {forward, inverse}, true	case Cmd_Level_Resize:		mouse_pos := rl.GetMousePosition()		world_pos := rl.GetScreenToWorld2D(mouse_pos, gs.camera)		new_pos, new_size := calculate_resize(			gs.level,			world_pos,			es.resize_start_pos,			es.resize_level_dir,		) 		removed_tiles := make([dynamic]Tile)		removed_spikes := make([dynamic]Spike) 		new_rect := rect_from_pos_size(new_pos, new_size) 		for tile in gs.level.tiles {			// Shrink slightly to account for flaoting point precision			rect := Rect{tile.pos.x + 1, tile.pos.y + 1, TILE_SIZE - 2, TILE_SIZE - 2}			if !rl.CheckCollisionRecs(new_rect, rect) {				append(&removed_tiles, tile)			}		} 		for spike in gs.level.spikes {			// Shrink slightly to account for flaoting point precision			rect := rect_pos_add(spike.collider, 1)			rect.width -= 2			rect.height -= 2			if !rl.CheckCollisionRecs(new_rect, rect) {				append(&removed_spikes, spike)			}		} 		forward := Cmd_Level_Resize {			level_id       = gs.level.id,			old_pos        = gs.level.pos,			old_size       = gs.level.size,			new_pos        = new_pos,			new_size       = new_size,			removed_tiles  = removed_tiles[:],			removed_spikes = removed_spikes[:],		} 		inverse := Cmd_Level_Resize {			level_id       = forward.level_id,			old_pos        = forward.new_pos,			old_size       = forward.new_size,			new_pos        = forward.old_pos,			new_size       = forward.old_size,			removed_tiles  = removed_tiles[:],			removed_spikes = removed_spikes[:],		} 		return {forward, inverse}, true	case Cmd_Entity_Insert:		mouse_pos := rl.GetMousePosition()		world_pos := rl.GetScreenToWorld2D(mouse_pos, gs.camera)		coords := coords_from_pos(world_pos) 		if is_tile_at(coords, gs.level.tiles[:]) || is_spawner_at(coords, gs.level) || is_spike_at(coords, gs.level) {			return {}, {}		} 		forward := Cmd_Entity_Insert {			coords = coords,			type   = es.entity_type_key,		} 		inverse := Cmd_Entity_Remove {			coords = coords,			type   = es.entity_type_key,		} 		return {forward, inverse}, true	case Cmd_Entity_Remove:		mouse_pos := rl.GetMousePosition()		world_pos := rl.GetScreenToWorld2D(mouse_pos, gs.camera)		coords := coords_from_pos(world_pos) 		if !is_spawner_at(coords, gs.level) {			return {}, {}		} 		forward := Cmd_Entity_Remove {			coords = coords,			type   = es.entity_type_key,		} 		inverse := Cmd_Entity_Insert {			coords = coords,			type   = es.entity_type_key,		} 		return {forward, inverse}, true	case Cmd_Checkpoint_Insert:		mouse_pos := rl.GetMousePosition()		world_pos := rl.GetScreenToWorld2D(mouse_pos, gs.camera)		coords := coords_from_pos(world_pos) 		if is_tile_at(coords, gs.level.tiles[:]) || is_spike_at(coords, gs.level) {			return {}, {}		} 		forward := Cmd_Checkpoint_Insert {			coords = coords,		} 		inverse := Cmd_Checkpoint_Remove {			coords = coords,		} 		return {forward, inverse}, true	case Cmd_Checkpoint_Remove:		mouse_pos := rl.GetMousePosition()		world_pos := rl.GetScreenToWorld2D(mouse_pos, gs.camera)		coords := coords_from_pos(world_pos) 		if !is_checkpoint_at(coords, gs.level) {			return {}, {}		} 		forward := Cmd_Checkpoint_Remove {			coords = coords,		} 		inverse := Cmd_Checkpoint_Insert {			coords = coords,		} 		return {forward, inverse}, true	case Cmd_Powerup_Insert:		mouse_pos := rl.GetMousePosition()		world_pos := rl.GetScreenToWorld2D(mouse_pos, gs.camera)		coords := coords_from_pos(world_pos) 		if is_tile_at(coords, gs.level.tiles[:]) || is_spike_at(coords, gs.level) || is_powerup_at(coords, gs.level) {			return {}, {}		} 		forward := Cmd_Powerup_Insert {			coords = coords,			type = es.powerup_type		} 		inverse := Cmd_Powerup_Remove {			coords = coords,			type = es.powerup_type		} 		return {forward, inverse}, true	case Cmd_Powerup_Remove:		mouse_pos := rl.GetMousePosition()		world_pos := rl.GetScreenToWorld2D(mouse_pos, gs.camera)		coords := coords_from_pos(world_pos) 		if !is_powerup_at(coords, gs.level) {			return {}, {}		} 		forward := Cmd_Powerup_Remove {			coords = coords,			type = es.powerup_type		} 		inverse := Cmd_Powerup_Insert {			coords = coords,			type = es.powerup_type		} 		return {forward, inverse}, true	} 	panic("Should not reach this location, check switch statement")} editor_command_dispatch :: proc(cmd_type: typeid) {	if cmd, ok := editor_command_construct(cmd_type); ok {		editor_command_execute(cmd.forward)		editor_command_record(cmd)	}} editor_undo :: proc() {	commands_exist := len(es.command_history) > 0	can_undo_more := len(es.command_history) != es.undo_count 	if commands_exist && can_undo_more {		es.undo_count += 1		undo_cmd := es.command_history[len(es.command_history) - es.undo_count]		editor_command_execute(undo_cmd.inverse)	}} editor_redo :: proc() {	did_undo := es.undo_count > 0	can_redo_more := len(es.command_history) - es.undo_count >= 0 	if did_undo && can_redo_more {		redo_cmd := es.command_history[len(es.command_history) - es.undo_count]		es.undo_count -= 1		editor_command_execute(redo_cmd.forward)	}} @(private = "file")es: Editor_State calculate_resize :: proc(	level: ^Level,	world_pos: Vec2,	start_pos: Vec2,	dir: Dir8,) -> (	new_pos: Vec2,	new_size: Vec2,) {	min_width := math.ceil(f32(RENDER_WIDTH) / TILE_SIZE) * TILE_SIZE	min_height := math.ceil(f32(RENDER_HEIGHT) / TILE_SIZE) * TILE_SIZE 	new_pos = level.pos	new_size = level.size 	delta := world_pos - start_pos	snapped_delta := linalg.round(delta / TILE_SIZE) * TILE_SIZE 	switch dir {	case .N:		height_delta := -snapped_delta.y		new_size.y = max(level.size.y + height_delta, min_height)		new_pos.y = level.pos.y - (new_size.y - level.size.y)	case .S:		new_size.y = max(level.size.y + snapped_delta.y, min_height)	case .E:		new_size.x = max(level.size.x + snapped_delta.x, min_width)	case .W:		width_delta := -snapped_delta.x		new_size.x = max(level.size.x + width_delta, min_width)		new_pos.x = level.pos.x - (new_size.x - level.size.x)	case .NE:		height_delta := -snapped_delta.y		new_size = {			max(level.size.x + snapped_delta.x, min_width),			max(level.size.y + height_delta, min_height),		}		new_pos.y = level.pos.y - (new_size.y - level.size.y)	case .NW:		height_delta := -snapped_delta.y		width_delta := -snapped_delta.x		new_size = {			max(level.size.x + width_delta, min_width),			max(level.size.y + height_delta, min_height),		}		new_pos = {			level.pos.x - (new_size.x - level.size.x),			level.pos.y - (new_size.y - level.size.y),		}	case .SE:		new_size = {			max(level.size.x + snapped_delta.x, min_width),			max(level.size.y + snapped_delta.y, min_height),		}	case .SW:		width_delta := -snapped_delta.x		new_size = {			max(level.size.x + width_delta, min_width),			max(level.size.y + snapped_delta.y, min_height),		}		new_pos.x = level.pos.x - (new_size.x - level.size.x)	} 	return new_pos, new_size} calculate_resize_rect :: proc(level_rect: Rect, dir: Dir8) -> Rect {	result: Rect	thickness :: 12	half_t :: thickness / 2 	switch dir {	case .N:		result = {level_rect.x, level_rect.y - half_t, level_rect.width, thickness}	case .S:		result = {			level_rect.x,			level_rect.y + level_rect.height - half_t,			level_rect.width,			thickness,		}	case .E:		result = {			level_rect.x + level_rect.width - half_t,			level_rect.y,			thickness,			level_rect.height,		}	case .W:		result = {level_rect.x - half_t, level_rect.y, thickness, level_rect.height}	case .NW:		result = {level_rect.x - half_t, level_rect.y - half_t, thickness, thickness}	case .NE:		result = {			level_rect.x + level_rect.width - half_t,			level_rect.y - half_t,			thickness,			thickness,		}	case .SE:		result = {			level_rect.x + level_rect.width - half_t,			level_rect.y + level_rect.height - half_t,			thickness,			thickness,		}	case .SW:		result = {			level_rect.x - half_t,			level_rect.y + level_rect.height - half_t,			thickness,			thickness,		}	} 	return result} editor_init :: proc() {	if err := virtual.arena_init_growing(&es.cmd_arena); err != nil {		log.panicf("Failed to init editor arena: %s\n", err)	}	es.cmd_allocator = virtual.arena_allocator(&es.cmd_arena)	es.command_history = make([dynamic]Cmd_Entry, es.cmd_allocator) 	es.entity_type_key = map_next_key(&gs.entity_definitions, nil)	es.tileset = gs.main_tileset} editor_update :: proc(gs: ^Game_State, dt: f32) {	context.allocator = es.cmd_allocator 	mouse_pos := rl.GetMousePosition() 	if mouse_pos.x < PANEL_WIDTH {		return	} 	rl.SetMouseCursor(.DEFAULT) 	scroll := rl.GetMouseWheelMove()	if scroll != 0 && es.tool != .Level_Resize {		mouse_world_pos := rl.GetScreenToWorld2D(mouse_pos, gs.camera) 		gs.camera.zoom = clamp(gs.camera.zoom + scroll * 0.25, 0.25, 8) 		mouse_world_pos_new := rl.GetScreenToWorld2D(mouse_pos, gs.camera) 		gs.camera.target += (mouse_world_pos - mouse_world_pos_new) 		es.resize_rect = {}	} 	// Pan Camera	{		mouse_delta: Vec2 		if rl.IsKeyDown(.LEFT) {			mouse_delta.x += 300 * dt		} 		if rl.IsKeyDown(.RIGHT) {			mouse_delta.x -= 300 * dt		} 		if rl.IsKeyDown(.UP) {			mouse_delta.y += 300 * dt		} 		if rl.IsKeyDown(.DOWN) {			mouse_delta.y -= 300 * dt		} 		if rl.IsMouseButtonDown(.MIDDLE) {			mouse_delta = rl.GetMouseDelta()		} 		gs.camera.target -= mouse_delta / gs.camera.zoom	} 	if es.tool == .Level || es.tool == .Level_Resize {		if gs.camera.zoom >= 1 {			es.tool = es.previous_tool		}	} else {		if rl.IsKeyPressed(.T) {			es.tool = .Tile		} 		if rl.IsKeyPressed(.S) {			es.tool = .Spike		} 		if rl.IsKeyPressed(.E) {			es.tool = .Entity		} 		if rl.IsKeyPressed(.C) {			es.tool = .Checkpoint		} 		if rl.IsKeyPressed(.P) {			es.tool = .Powerup		} 		es.previous_tool = es.tool		if gs.camera.zoom < 1 {			es.tool = .Level		} 		if rl.IsKeyPressed(.F) {			es.spike_facing += Direction(1)			if int(es.spike_facing) > 3 {				es.spike_facing = Direction(0)			}		}	} 	if rl.IsKeyPressed(.Z) && (rl.IsKeyDown(.LEFT_CONTROL) || rl.IsKeyDown(.RIGHT_CONTROL)) {		editor_undo()	} 	if rl.IsKeyPressed(.Y) && (rl.IsKeyDown(.LEFT_CONTROL) || rl.IsKeyDown(.RIGHT_CONTROL)) {		editor_redo()	} 	rel_pos := rl.GetMousePosition() + gs.camera.target * gs.camera.zoom	rel_pos /= gs.camera.zoom	coords := coords_from_pos(rel_pos) 	switch es.tool {	case .None:	case .Tile:		if rl.IsMouseButtonPressed(.LEFT) || rl.IsMouseButtonPressed(.RIGHT) {			es.area_begin = coords		} 		if rl.IsMouseButtonDown(.LEFT) || rl.IsMouseButtonDown(.RIGHT) {			es.area_end = coords		} 		place := rl.IsMouseButtonReleased(.LEFT)		remove := rl.IsMouseButtonReleased(.RIGHT) 		if place {			editor_command_dispatch(Cmd_Tiles_Insert)		} else if remove {			editor_command_dispatch(Cmd_Tiles_Remove)		}	case .Spike:		if rl.IsMouseButtonPressed(.LEFT) || rl.IsMouseButtonPressed(.RIGHT) {			es.area_begin = coords			es.area_end = coords		} 		if rl.IsMouseButtonDown(.LEFT) {			switch es.spike_facing {			case .Up, .Down:				es.area_end.x = coords.x			case .Left, .Right:				es.area_end.y = coords.y			}		} else if rl.IsMouseButtonDown(.RIGHT) {			es.area_end = coords		} 		if rl.IsMouseButtonReleased(.LEFT) {			editor_command_dispatch(Cmd_Spikes_Insert)		} 		if rl.IsMouseButtonReleased(.RIGHT) {			editor_command_dispatch(Cmd_Spikes_Remove)		}	case .Level:		if es.is_dragging {			es.drag_end = rl.GetScreenToWorld2D(mouse_pos, gs.camera)			es.drag_end = linalg.round(es.drag_end / TILE_SIZE) * TILE_SIZE 			if rl.IsMouseButtonReleased(.LEFT) {				es.is_dragging = false 				start_coords := coords_from_pos(es.drag_start)				end_coords := coords_from_pos(es.drag_end) 				if start_coords != end_coords {					editor_command_dispatch(Cmd_Level_Move)				}			}		} else {			for level in gs.levels {				level_rect := rect_from_pos_size(level.pos - gs.camera.target, level.size)				level_rect = rect_scale_all(level_rect, gs.camera.zoom)				if rl.CheckCollisionPointRec(mouse_pos, level_rect) {					if rl.IsMouseButtonPressed(.LEFT) {						level_load(gs, level.id)					} else if rl.IsMouseButtonDown(.LEFT) {						es.is_dragging = true						es.drag_start = rl.GetScreenToWorld2D(mouse_pos, gs.camera)						es.drag_start = linalg.round(es.drag_start / TILE_SIZE) * TILE_SIZE					}				}			}		} 		if rl.IsMouseButtonPressed(.LEFT) || rl.IsMouseButtonPressed(.RIGHT) {			es.area_begin = coords		} 		if rl.IsMouseButtonDown(.LEFT) || rl.IsMouseButtonDown(.RIGHT) {			es.area_end = coords		} 		if rl.IsMouseButtonReleased(.LEFT) {			editor_command_dispatch(Cmd_Level_New)		} 		if rl.IsKeyPressed(.DELETE) {			if len(gs.levels) > 1 {				editor_command_dispatch(Cmd_Level_Delete)			}		} 		es.resize_rect = {} 		level_rect := rect_from_pos_size(gs.level.pos - gs.camera.target, gs.level.size)		level_rect = rect_scale_all(level_rect, gs.camera.zoom) 		for dir in Dir8 {			resize_rect := calculate_resize_rect(level_rect, dir)			if rl.CheckCollisionPointRec(mouse_pos, resize_rect) {				rl.SetMouseCursor(Resize_Cursor[dir])				es.resize_rect = resize_rect 				if rl.IsMouseButtonPressed(.LEFT) {					es.resize_level_dir = dir					es.tool = .Level_Resize					es.area_begin = coords_from_pos(gs.level.pos)					es.resize_start_pos = rl.GetScreenToWorld2D(mouse_pos, gs.camera)				} 				break			}		}	case .Level_Resize:		if rl.IsMouseButtonReleased(.LEFT) {			editor_command_dispatch(Cmd_Level_Resize)			es.tool = .Level		}	case .Entity:		if rl.IsKeyPressed(.E) {			es.entity_type_key = map_next_key(&gs.entity_definitions, es.entity_type_key)		} 		if rl.IsMouseButtonPressed(.LEFT) {			editor_command_dispatch(Cmd_Entity_Insert)		} 		if rl.IsMouseButtonPressed(.RIGHT) {			editor_command_dispatch(Cmd_Entity_Remove)		}	case .Checkpoint:		if rl.IsMouseButtonPressed(.LEFT) {			editor_command_dispatch(Cmd_Checkpoint_Insert)		} 		if rl.IsMouseButtonPressed(.RIGHT) {			editor_command_dispatch(Cmd_Checkpoint_Remove)		}	case .Powerup:		if rl.IsKeyPressed(.P) {			index := (int(es.powerup_type) + 1) % len(Power_Up_Type)			es.powerup_type = Power_Up_Type(index)		} 		if rl.IsMouseButtonPressed(.LEFT) {			editor_command_dispatch(Cmd_Powerup_Insert)		} 		if rl.IsMouseButtonPressed(.RIGHT) {			editor_command_dispatch(Cmd_Powerup_Remove)		}	}} editor_draw :: proc(gs: ^Game_State) {	place := rl.IsMouseButtonDown(.LEFT)	remove := rl.IsMouseButtonDown(.RIGHT) 	if (place || remove) {		rect := rect_from_coords_any_facing(es.area_begin, es.area_end)		rect = rect_pos_add(rect, -gs.camera.target) 		rect = rect_scale_all(rect, gs.camera.zoom) 		if es.tool == .Level || es.tool == .Level_Resize {			if !es.is_dragging {				one_screen_rect := rect				one_screen_rect.width =					math.ceil(f32(RENDER_WIDTH) / TILE_SIZE) * TILE_SIZE * gs.camera.zoom				one_screen_rect.height =					math.ceil(f32(RENDER_HEIGHT) / TILE_SIZE) * TILE_SIZE * gs.camera.zoom				rl.DrawRectangleLinesEx(one_screen_rect, 1, rl.DARKGRAY)			}		} else {			rl.DrawRectangleLinesEx(rect, 4, place ? rl.WHITE : rl.RED)		}	} 	// Draw Tiles from other levels, too	rl.BeginMode2D(gs.camera) 	for l in gs.levels {		if l.id == gs.level.id do continue 		for tile in l.tiles {			rl.DrawRectangleV(tile.pos, TILE_SIZE, rl.BROWN)		}	} 	if es.is_dragging {		delta := es.drag_end - es.drag_start		rl.DrawRectangleLinesEx(			rect_from_pos_size(gs.level.pos + delta, gs.level.size),			2,			rl.GRAY,		)	} 	rl.EndMode2D() 	for l in gs.levels {		level_rect := Rect{l.pos.x, l.pos.y, l.size.x, l.size.y}		level_rect = rect_pos_add(level_rect, -gs.camera.target)		level_rect = rect_scale_all(level_rect, gs.camera.zoom) 		color := l.id == gs.level.id ? rl.WHITE : rl.GRAY		thickness := f32(1) 		if es.tool == .Level {			thickness = 4			text := l.name == "" ? fmt.ctprintf("level_%d", l.id) : fmt.ctprintf("%s", l.name)			text_size := rl.MeasureTextEx(gs.font_48, text, 48, 0)			text_pos :=				Vec2{level_rect.x, level_rect.y} +				({level_rect.width, level_rect.height} - text_size) / 2			rl.DrawTextEx(gs.font_48, text, text_pos, 48, 0, {255, 255, 255, 128})		} 		rl.DrawRectangleLinesEx(level_rect, thickness, color)	} 	if es.tool == .Level_Resize {		world_pos := rl.GetScreenToWorld2D(rl.GetMousePosition(), gs.camera) 		preview_pos, preview_size := calculate_resize(			gs.level,			world_pos,			es.resize_start_pos,			es.resize_level_dir,		) 		preview_rect := rect_from_pos_size(preview_pos - gs.camera.target, preview_size)		preview_rect = rect_scale_all(preview_rect, gs.camera.zoom) 		rl.DrawRectangleLinesEx(preview_rect, 2, rl.WHITE)	} 	rl.DrawRectangleRec(es.resize_rect, rl.YELLOW) 	// Spawners 	for spawner in gs.level.spawners {		pos := rl.GetWorldToScreen2D(spawner.pos, gs.camera)		rl.DrawRectangleLinesEx({pos.x, pos.y, 16 * gs.camera.zoom, 16 * gs.camera.zoom}, 1, rl.ORANGE)		rl.DrawTextEx(gs.font_18, fmt.ctprintf(spawner.type), pos, 18, 0, rl.WHITE)	} 	editor_panel(PANEL_WIDTH) 	editor_panel_text(fmt.ctprintf("Level ID: %d", gs.level.id))	editor_panel_text(fmt.ctprintf("Tool: %s", es.tool))	editor_panel_text(		fmt.ctprintf(			"History: %d/%d",			len(es.command_history) - es.undo_count,			len(es.command_history),		),	)	editor_panel_text(fmt.ctprintf("Facing: %v", es.spike_facing))	editor_panel_text(fmt.ctprintf("Camera Zoom: %v", gs.camera.zoom)) 	world_pos := rl.GetScreenToWorld2D(rl.GetMousePosition(), gs.camera)	editor_panel_text(fmt.ctprintf("Pos: %v", world_pos))	editor_panel_text(fmt.ctprintf("Coords: %v", coords_from_pos(world_pos))) 	level_pos_tiles := coords_from_pos(gs.level.pos)	editor_panel_text(fmt.ctprintf("Level Pos: %d, %d", level_pos_tiles.x, level_pos_tiles.y)) 	level_size_tiles := coords_from_pos(gs.level.size)	editor_panel_text(fmt.ctprintf("Level Size: %d, %d", level_size_tiles.x, level_size_tiles.y)) 	editor_panel_text(fmt.ctprintf("Entity: %s", es.entity_type_key))	editor_panel_text(fmt.ctprintf("Powerup: %s", es.powerup_type)) 	editor_panel_text("---")	editor_panel_text("Level On Enter:") 	for k, v in level_on_enter_map {		if gs.level.on_enter == v {			if editor_panel_button(k, rl.ORANGE) {				gs.level.on_enter = nil			}		} else if editor_panel_button(k) {			gs.level.on_enter = v		}	}} is_tile_at_pos :: proc(pos: Vec2, tiles: []Tile) -> bool {	for tile in tiles {		rect := Rect{tile.pos.x, tile.pos.y, TILE_SIZE, TILE_SIZE}		if rl.CheckCollisionPointRec(pos, rect) {			return true		}	}	return false} is_tile_at_coords :: proc(coords: Vec2i, tiles: []Tile) -> bool {	return is_tile_at(pos_from_coords(coords), tiles)} is_spike_at_pos :: proc(pos: Vec2, l: ^Level) -> bool {	for spike in l.spikes {		if rl.CheckCollisionPointRec(pos, spike.collider) {			return true		}	}	return false} is_spike_at_coords :: proc(coords: Vec2i, l: ^Level) -> bool {	return is_spike_at(pos_from_coords(coords) + 0.5 * TILE_SIZE, l)} is_spawner_at :: proc(coords: Vec2i, l: ^Level = gs.level) -> bool {	for spawner in l.spawners {		spawner_coords := coords_from_pos(spawner.pos)		if spawner_coords == coords {			return true		}	}	return false} is_checkpoint_at :: proc(coords: Vec2i, l: ^Level = gs.level) -> bool {	for checkpoint in l.checkpoints {		checkpoint_coords := coords_from_pos(checkpoint.pos)		if checkpoint_coords == coords {			return true		}	}	return false} get_spike_at :: proc(coords: Vec2i, l: ^Level = gs.level) -> (Spike, bool) {	pos := pos_from_coords(coords) 	for spike in l.spikes {		if rl.CheckCollisionPointRec(pos, spike.collider) {			return spike, true		}	} 	return {}, false} is_tile_at :: proc {	is_tile_at_pos,	is_tile_at_coords,} is_spike_at :: proc {	is_spike_at_pos,	is_spike_at_coords,} is_tile_oob :: proc(coords: Vec2i, l: ^Level = gs.level) -> bool {	pos := pos_from_coords(coords) + TILE_SIZE * 0.5 	level_rect := rect_from_pos_size(l.pos, l.size) 	if rl.CheckCollisionPointRec(pos, level_rect) {		return false	} 	return true} is_powerup_at :: proc(coords: Vec2i, l: ^Level = gs.level) -> bool {	pos := pos_from_coords(coords) + TILE_SIZE * 0.5	for powerup in l.power_up_spawns {		rect := rect_from_pos_size(powerup.pos, TILE_SIZE)		if rl.CheckCollisionPointRec(pos, rect) {			return true		}	}	return false} editor_tile_insert :: proc(coords: Vec2i, l: ^Level) {	if !is_tile_at(coords, l.tiles[:]) {		append(&l.tiles, Tile{pos = pos_from_coords(coords)})	}	// We also have to remove the background tile from this location	for tile, i in l.bg_tiles {		if coords_from_pos(tile.pos) == coords {			ordered_remove(&l.bg_tiles, i)			break		}	}} editor_tile_index :: proc(coords: Vec2i, l: ^Level) -> (index: int, ok: bool) {	for tile, i in l.tiles {		if coords_from_pos(tile.pos) == coords {			return i, true		}	}	return -1, false} editor_tile_remove :: proc(coords: Vec2i, l: ^Level) {	if index, ok := editor_tile_index(coords, l); ok {		ordered_remove(&l.tiles, index)	}	// We also have to place a background tile at this location	append(&l.bg_tiles, Tile {pos = pos_from_coords(coords)})} spike_init :: proc(coords: Vec2i, facing: Direction) -> Spike {	pos := pos_from_coords(coords) 	spike: Spike	spike.collider.x = pos.x	spike.collider.y = pos.y	spike.collider.width = TILE_SIZE	spike.collider.height = TILE_SIZE	spike.facing = facing 	switch spike.facing {	case .Up:		spike.collider.y += SPIKE_DIFF		spike.collider.height = SPIKE_DEPTH	case .Right:		spike.collider.width = SPIKE_DEPTH	case .Down:		spike.collider.height = SPIKE_DEPTH	case .Left:		spike.collider.width = SPIKE_DEPTH		spike.collider.x += SPIKE_DIFF	} 	return spike} editor_spike_insert :: proc(spike: Spike, l: ^Level) {	append(&l.spikes, spike)} editor_spike_index :: proc(coords: Vec2i, l: ^Level) -> (index: int, ok: bool) {	for spike, i in l.spikes {		pos := Vec2{spike.collider.x, spike.collider.y}		if coords_from_pos(pos) == coords {			return i, true		}	}	return -1, false} editor_spike_remove :: proc(spike: Spike, l: ^Level) {	if index, ok := slice.linear_search(l.spikes[:], spike); ok {		unordered_remove(&l.spikes, index)	}} rect_from_coords_any_facing :: proc(a, b: Vec2i) -> Rect {	top := f32(min(a.y, b.y)) * TILE_SIZE	left := f32(min(a.x, b.x)) * TILE_SIZE	bottom := f32(max(a.y, b.y)) * TILE_SIZE	right := f32(max(a.x, b.x)) * TILE_SIZE 	return Rect{left, top, right - left + TILE_SIZE, bottom - top + TILE_SIZE}} get_next_level_id :: proc() -> u32 {	id := u32(1)	for l in es.deleted_levels {		if l.id > id {			id = l.id		}	} 	for l in gs.levels {		if l.id > id {			id = l.id		}	} 	return id + 1} coords_from_area :: proc(begin, end: Vec2i) -> []Vec2i {	coords := make([dynamic]Vec2i) 	area_min := Vec2i{min(begin.x, end.x), min(begin.y, end.y)}	area_max := Vec2i{max(begin.x, end.x), max(begin.y, end.y)} 	level_min := coords_from_pos(gs.level.pos)	level_max := coords_from_pos(gs.level.pos + gs.level.size) 	area_min.x = max(area_min.x, level_min.x)	area_min.y = max(area_min.y, level_min.y)	area_max.x = min(area_max.x, level_max.x - 1)	area_max.y = min(area_max.y, level_max.y - 1) 	for y := area_min.y; y <= area_max.y; y += 1 {		for x := area_min.x; x <= area_max.x; x += 1 {			append(&coords, Vec2i{i32(x), i32(y)})		}	} 	return coords[:]} spikes_from_area :: proc(p, q: Vec2i, l: ^Level) -> []Spike {	rect := rect_from_coords_any_facing(p, q) 	spikes := make([dynamic]Spike) 	for spike in l.spikes {		if rl.CheckCollisionRecs(rect, spike.collider) {			append(&spikes, spike)		}	} 	return spikes[:]} tiles_from_area :: proc(p, q: Vec2i, l: ^Level = gs.level) -> []Vec2i {	rect := rect_from_coords_any_facing(p, q) 	tiles := make([dynamic]Vec2i) 	for tile in l.tiles {		if rl.CheckCollisionRecs(rect, rect_from_pos_size(tile.pos, TILE_SIZE)) {			append(&tiles, coords_from_pos(tile.pos))		}	} 	return tiles[:]}

51. Threaded Cached Autotile, Juice

What are you stuck on?