      src/main.odin
      1430 lines
    

package main import "base:intrinsics"import "core:fmt"import "core:log"import "core:math"import "core:math/linalg"import "core:os"import "core:slice"import "core:strings"import "core:time" import rl "vendor:raylib" Vec2 :: rl.Vector2Vec4 :: rl.Vector4Rect :: rl.RectangleVec2i :: [2]i32 Entity_Flags :: enum {	Grounded,	Dead,	Kinematic,	Debug_Draw,	Left,	Immortal,	Frozen,	Flying,} Entity_Behaviors :: enum {	Walk,	Flip_At_Wall,	Flip_At_Edge,	Wander,	Hop,	Charge_At_Player,	Fly,} Entity :: struct {	using collider:             Rect,	vel:                        Vec2,	move_speed:                 f32,	jump_force:                 f32,	on_enter, on_stay, on_exit: proc(self_id, other_id: Entity_Id),	on_update:                  proc(_: ^Entity, _: ^Game_State, dt: f32),	on_hit_static:              proc(_: ^Entity, _: ^Game_State, pos: Vec2, dt: f32),	on_death:                   proc(entity: ^Entity, gs: ^Game_State),	entity_ids:                 map[Entity_Id]time.Time,	flags:                      bit_set[Entity_Flags],	behaviors:                  bit_set[Entity_Behaviors],	health:                     int,	max_health:                 int,	on_hit_damage:              int,	debug_color:                rl.Color,	texture:                    ^rl.Texture,	animations:                 map[string]Animation,	current_anim_name:          string,	current_anim_frame:         int,	animation_timer:            f32,	hit_timer:                  f32,	hit_duration:               f32,	hit_response:               Entity_Hit_Response,	destination:                Maybe(Vec2),	charge_dir:                 Maybe(Vec2),	wander_timer:               f32,	hop_timer:                  f32,	charge_timer:               f32,	charge_cooldown_timer:      f32,	definition:                 ^Enemy_Def,} Entity_Hit_Response :: enum {	None,	Stop,	Knockback,} Entity_Id :: distinct int Enemy_Def :: struct {	collider_size:       Vec2,	move_speed:          f32,	behaviors:           bit_set[Entity_Behaviors],	debug_color:         Maybe(rl.Color),	health:              int,	on_hit_damage:       int,	texture:             rl.Texture2D,	animations:          map[string]Animation,	initial_animation:   string,	hit_response:        Entity_Hit_Response,	hit_duration:        f32,	hit_knockback_force: f32,	drops:               [dynamic]Drop,	flags:               bit_set[Entity_Flags],	on_update:           proc(_: ^Entity, _: ^Game_State, dt: f32),} Drop :: struct {	type:   Item_Type,	chance: f32,	range:  [2]int,} Animation :: struct {	size:           Vec2,	offset:         Vec2,	offset_flipped: Vec2,	start:          int,	end:            int,	row:            int,	time:           f32,	flags:          bit_set[Animation_Flags],	on_finish:      proc(gs: ^Game_State, entity: ^Entity),	timed_events:   [dynamic]Animation_Event,	texture:        ^rl.Texture2D,	tint:           rl.Color,} Animation_Flags :: enum {	// Default is to play once then stop	Loop,	Ping_Pong, // Loop + Ping_Pong will play forwards, then backwards, then forwards...} Animation_Event :: struct {	timer:    f32,	duration: f32,	callback: proc(gs: ^Game_State, entity: ^Entity),} Game_State :: struct {	scene:                     Scene_Type,	main_menu_state:           Main_Menu_State,	editor_enabled:            bool,	last_update_time:          time.Time,	this_frame_time:           time.Time,	font_18:                   rl.Font,	font_48:                   rl.Font,	font_64:                   rl.Font,	camera:                    rl.Camera2D,	ui_camera:                 rl.Camera2D,	player_texture:            rl.Texture,	tileset_texture:           rl.Texture,	levels:                    [dynamic]Level,	level:                     ^Level,	checkpoint_level_id:       u32,	checkpoint_id:             u32,	colliders:                 [dynamic]Rect,	entities:                  [dynamic]Entity,	falling_logs:              [dynamic]Falling_Log,	debug_shapes:              [dynamic]Debug_Shape,	safe_position:             Vec2,	safe_reset_timer:          f32,	player_movement_state:     Player_Movement_State,	player_id:                 Entity_Id,	jump_timer:                f32,	coyote_timer:              f32,	enemy_definitions:         map[string]Enemy_Def,	debug_draw_enabled:        bool,	attack_cooldown_timer:     f32,	attack_recovery_timer:     f32,	sword_swoosh_sound:        rl.Sound,	sword_swoosh_sound_2:      rl.Sound,	sword_hit_soft_sound:      rl.Sound,	sword_hit_medium_sound:    rl.Sound,	sword_hit_stone_sound:     rl.Sound,	player_jump_sound:         rl.Sound,	original_spawn_point:      Vec2,	dash_timer:                f32,	dash_cooldown_timer:       f32,	bgm:                       rl.Music,	save_data:                 Save_Data,	game_menu_state:           Game_Menu_State,	items:                     [dynamic]Item,	item_texture:              rl.Texture,	inventory:                 [dynamic]Inventory_Slot,	demon_boss_attack_texture: rl.Texture,	particle_systems:          [dynamic]Particle_System,	particles:                 #soa[dynamic]Particle,	delta_time:                f32,} Game_Menu_State :: struct {	menu_type: Game_Menu_Type,} Game_Menu_Type :: enum {	None,	Inventory,	Map,	Count,} Inventory_Slot :: struct {	item_type: Item_Type,	src:       Vec2,	count:     int,} // This is in the worldItem :: struct {	type: Item_Type,	src:  Vec2,	pos:  Vec2,} Item_Type :: enum {	Dummy0,	Dummy1,	Dummy2,	Dummy3,	Dummy4,	Dummy5,	Dummy6,	Dummy7,	Dummy8,	Dummy9,	DummyA,	DummyB,	DummyC,	DummyD,	DummyE,	DummyF,	Necrotic_Tail,	Strange_Bacon,	Lucky_Foot,} Main_Menu_State :: struct {	menu_type:               Main_Menu_Type,	save_texture:            rl.RenderTexture2D,	save_slots:              [SAVE_SLOTS]Save_Data,	save_list_scroll_offset: f32,} Main_Menu_Type :: enum {	Default,	Select_Save_Slot,} Save_Data :: struct {	slot:                int,	version:             struct {		major, minor, patch: int,	},	level_id:            u32,	checkpoint_id:       u32,	seconds_played:      f64,	location:            string, // Most recent level name, not checkpoint level	visited_level_ids:   [dynamic]u32,	collected_power_ups: bit_set[Power_Up_Type],} Scene_Type :: enum {	Main_Menu,	Game,} Level :: struct {	id:                 u32,	pos:                Vec2,	size:               Vec2,	player_spawn:       Maybe(Vec2),	name:               string,	enemy_spawns:       [dynamic]Enemy_Spawn,	doors:              [dynamic]Door,	spikes:             [dynamic]Spike,	falling_log_spawns: [dynamic]Falling_Log_Spawn,	checkpoints:        [dynamic]Checkpoint,	power_up_spawns:    [dynamic]Power_Up_Spawn,	tiles:              [dynamic]Tile,	on_enter:           proc(gs: ^Game_State),} Enemy_Type :: enum {	Walker,	Jumper,	Charger,	Orb,} Enemy_Spawn :: struct {	type: Enemy_Type,	pos:  Vec2,} Falling_Log_Spawn :: struct {	rect: Rect,} Checkpoint :: struct {	id:  u32,	pos: Vec2,} Power_Up_Spawn :: struct {	type: Power_Up_Type,	pos:  Vec2,} Power_Up_Type :: enum {	Dash,} Door :: struct {	rect: Rect,} Spike :: struct {	collider: Rect,	facing:   Direction,} Falling_Log :: struct {	collider:    Rect,	rope_height: f32,	state:       enum {		Default,		Falling,		Settled,	},} Tile :: struct {	pos:       Vec2,	src:       Vec2,	neighbors: Tile_Neighbors,	f:         u8,} Direction :: enum {	Up,	Right,	Down,	Left,} Directions := [Direction]Vec2i {	.Up    = Vec2i{0, -1},	.Right = Vec2i{1, 0},	.Down  = Vec2i{0, 1},	.Left  = Vec2i{-1, 0},} level_on_enter_map: map[cstring]proc(gs: ^Game_State) some_other_init :: proc(_: ^Game_State) {}yet_other_init :: proc(_: ^Game_State) {}and_other_init :: proc(_: ^Game_State) {} TARGET_FPS :: 60 UP :: Vec2{0, -1}RIGHT :: Vec2{1, 0}DOWN :: Vec2{0, 1}LEFT :: Vec2{-1, 0} WINDOW_WIDTH :: 1280WINDOW_HEIGHT :: 720RENDER_WIDTH :: 640RENDER_HEIGHT :: 360TILE_SIZE :: 16ZOOM :: WINDOW_WIDTH / RENDER_WIDTHBG_COLOR :: rl.Color{50, 44, 67, 255}BG_COLOR_MAIN_MENU :: rl.Color{0, 0, 28, 255} INGAME_UI_BG_RECT :: Rect{16, 16, RENDER_WIDTH - 32, RENDER_HEIGHT - 32}INGAME_UI_BG_COLOR :: rl.Color{0, 0, 0, 120} MAP_SCALE :: 16MAP_COLOR_CURRENT_LEVEL :: rl.Color{10, 10, 50, 255}MAP_COLOR_OTHER_LEVEL :: BG_COLOR_MAIN_MENUMAP_COLOR_SOLID :: rl.LIGHTGRAYMAP_COLOR_SOLID_OTHER :: rl.GRAYMAP_COLOR_LEVEL_BORDER :: rl.DARKGRAYMAP_COLOR_PLAYER :: rl.RED PHYSICS_ITERATIONS :: 8GRAVITY :: 5TERMINAL_VELOCITY :: 1200 SPIKE_BREADTH :: 16SPIKE_DEPTH :: 12SPIKE_DIFF :: TILE_SIZE - SPIKE_DEPTH PLAYER_SAFE_RESET_TIME :: 1 JUMP_TIME :: 0.2COYOTE_TIME :: 0.15ATTACK_COOLDOWN_DURATION :: 0.3ATTACK_RECOVERY_DURATION :: 0.2 DASH_DURATION :: 0.3DASH_COOLDOWN :: 1DASH_VELOCITY :: 500 FIRST_LEVEL_ID :: 1 SAVE_ITEM_HEIGHT :: 60SAVE_SLOTS :: 10SAVE_PANEL_WIDTH :: WINDOW_WIDTH / 2SAVE_PANEL_HEIGHT :: WINDOW_HEIGHT / 3SCROLL_SPEED :: 20 VERSION_MAJOR :: 0VERSION_MINOR :: 1VERSION_PATCH :: 0 // TODO: Move this into the main proc, not a global// Anywhere gs is used as an argument, reduce the parameters to only requried fields// ATM gs is used in a few procs without being passed in - this makes debugging harder// as we can't tell from the proc type which procs alter the state if they use the globalgs: ^Game_State recreate_colliders :: proc(world_pos: Vec2, colliders: ^[dynamic]Rect, falling_logs: []Falling_Log, tiles: []Tile) {	clear(colliders) 	slice.sort_by(tiles, proc(a, b: Tile) -> bool {		if a.pos.y != b.pos.y do return a.pos.y < b.pos.y		return a.pos.x < b.pos.x	}) 	solid_tiles := make([dynamic]Rect, context.temp_allocator)	for t in tiles {		append(&solid_tiles, Rect{t.pos.x - world_pos.x, t.pos.y - world_pos.y, TILE_SIZE, TILE_SIZE})	} 	if len(solid_tiles) > 0 {		combine_colliders(world_pos, solid_tiles[:], &gs.colliders)	} 	for falling_log in gs.falling_logs {		if falling_log.state == .Settled {			append(colliders, falling_log.collider)		}	}} combine_colliders :: proc(world_pos: Vec2, solid_tiles: []Rect, colliders: ^[dynamic]Rect) {	wide_rect := solid_tiles[0]	wide_rects := make([dynamic]Rect, context.temp_allocator) 	for i in 1 ..< len(solid_tiles) {		rect := solid_tiles[i] 		if rect.x == wide_rect.x + wide_rect.width && rect.y == wide_rect.y {			wide_rect.width += TILE_SIZE		} else {			append(&wide_rects, wide_rect)			wide_rect = rect		}	} 	append(&wide_rects, wide_rect) 	slice.sort_by(wide_rects[:], proc(a, b: Rect) -> bool {		if a.x != b.x do return a.x < b.x		return a.y < b.y	}) 	big_rect := wide_rects[0] 	for i in 1 ..< len(wide_rects) {		rect := wide_rects[i] 		if rect.x == big_rect.x && big_rect.width == rect.width && big_rect.y + big_rect.height == rect.y {			big_rect.height += TILE_SIZE		} else {			big_rect.x += world_pos.x			big_rect.y += world_pos.y			append(colliders, big_rect)			big_rect = rect		}	} 	big_rect.x += world_pos.x	big_rect.y += world_pos.y	append(colliders, big_rect)} level_from_id :: proc(levels: []Level, id: u32) -> ^Level {	for &l in levels {		if l.id == id {			return &l		}	}	return nil} // Returns -1 on failurelevel_index_from_id :: proc(levels: []Level, id: u32) -> int {	for l, i in levels {		if l.id == id {			return i		}	}	return -1} level_load :: proc(gs: ^Game_State, id: u32, player_spawn: Vec2) {	level := level_from_id(gs.levels[:], id)	if level == nil {		log.fatalf("Level with id `%d` could not be found.", id)	}	gs.level = level 	player := entity_get(gs.player_id)	player_anim_name: string	player_health: int	player_vel: Vec2 	if player != nil {		player_anim_name = strings.clone(player.current_anim_name, context.temp_allocator)		player_health = player.health		player_vel = player.vel	} 	clear(&gs.entities) 	spawn_player(gs, player_spawn) 	// NOTE: Player will always have animation after first spawn	// This will be skipped on first load	if player_anim_name != "" {		player = entity_get(gs.player_id)		player.health = player_health		for k in player.animations {			if k == player_anim_name {				player.current_anim_name = k			}		}		player.vel = player_vel	} 	recreate_colliders(level.pos, &gs.colliders, gs.falling_logs[:], level.tiles[:])	autotile_run(level) 	save_data_update(gs)	savefile_save(gs.save_data) 	if level.on_enter != nil {		level.on_enter(gs)	}} spawn_player :: proc(gs: ^Game_State, player_spawn: Vec2) {	gs.player_id = entity_create(		{			x = player_spawn.x,			y = player_spawn.y,			width = 16,			height = 38,			move_speed = 220,			jump_force = 650,			on_enter = player_on_enter,			health = 7,			max_health = 7,			debug_color = rl.GREEN,			texture = &gs.player_texture,			current_anim_name = "idle",			on_death = player_on_death,		},	) 	player := entity_get(gs.player_id) 	player.animations["idle"] = Animation {		size           = {120, 80},		offset         = {52, 42},		offset_flipped = {52, 42},		start          = 0,		end            = 9,		row            = 0,		time           = 0.075,		flags          = {.Loop},	} 	player.animations["jump"] = Animation {		size           = {120, 80},		offset         = {52, 42},		offset_flipped = {52, 42},		start          = 0,		end            = 2,		row            = 1,		time           = 0.075,	} 	player.animations["jump_fall_inbetween"] = Animation {		size           = {120, 80},		offset         = {52, 42},		offset_flipped = {52, 42},		start          = 3,		end            = 4,		row            = 1,		time           = 0.075,	} 	player.animations["fall"] = Animation {		size           = {120, 80},		offset         = {52, 42},		offset_flipped = {52, 42},		start          = 5,		end            = 7,		row            = 1,		time           = 0.075,		flags          = {.Loop},	} 	player.animations["run"] = Animation {		size           = {120, 80},		offset         = {52, 42},		offset_flipped = {52, 42},		start          = 0,		end            = 9,		row            = 2,		time           = 0.075,		flags          = {.Loop},	} 	player.animations["attack"] = Animation {		size           = {120, 80},		offset         = {52, 42},		offset_flipped = {52, 42},		start          = 0,		end            = 3,		row            = 3,		time           = 0.05,		on_finish      = player_on_finish_attack,	} 	if attack_anim, attack_anim_ok := &player.animations["attack"]; attack_anim_ok {		append(&attack_anim.timed_events, Animation_Event{timer = 0.01, duration = 0.01, callback = player_attack_sfx})		append(			&attack_anim.timed_events,			Animation_Event{timer = 0.05, duration = 0.05, callback = player_attack_callback},		)	} 	player.animations["dash"] = Animation {		size           = {120, 80},		offset         = {52, 42},		offset_flipped = {52, 42},		start          = 4,		end            = 5,		row            = 3,		time           = 0.075,	} } main_menu_update :: proc(gs: ^Game_State) {	for !rl.WindowShouldClose() {		center := Vec2{WINDOW_WIDTH, WINDOW_HEIGHT} / 2		title_text: cstring = "METROIDVANIA"		title_text_size := rl.MeasureTextEx(gs.font_64, title_text, 64, 4) 		rl.BeginDrawing()		rl.ClearBackground(BG_COLOR_MAIN_MENU) 		// Draw Title		rl.DrawTextEx(gs.font_64, title_text, {center.x - title_text_size.x / 2, center.y / 2}, 64, 4, rl.WHITE) 		switch gs.main_menu_state.menu_type {		case .Default:			if main_menu_item_draw("Play", center) {				gs.main_menu_state.menu_type = .Select_Save_Slot			} 			if main_menu_item_draw("Settings", center + {0, 60}) {				// TODO				// return			} 			if main_menu_item_draw("Quit", center + {0, 120}) {				rl.CloseWindow()				return			}		case .Select_Save_Slot:			// To simulate a scrolling box, we are rendering to a different texture			target := gs.main_menu_state.save_texture 			// This is the position of the scrolling box			panel_pos := Vec2{(WINDOW_WIDTH - SAVE_PANEL_WIDTH) / 2, WINDOW_HEIGHT / 2} 			mouse_wheel_move := rl.GetMouseWheelMove() 			// This offset is used to draw the correct part of the texture into the box			gs.main_menu_state.save_list_scroll_offset = clamp(				gs.main_menu_state.save_list_scroll_offset + mouse_wheel_move * SCROLL_SPEED,				SAVE_PANEL_HEIGHT - SAVE_ITEM_HEIGHT * SAVE_SLOTS,				0,			) 			// Start drawing to the texture			rl.BeginTextureMode(target)			rl.ClearBackground(BG_COLOR_MAIN_MENU) 			for save_data, i in gs.main_menu_state.save_slots {				// We always have SAVE_SLOTS amount of save slots				// So we check if the seconds_played is > 0 to determine if the slot is taken				if save_data.seconds_played > 0 { 					// Save file exists, pass in location and seconds_played					if load_game_item_draw(						i,						panel_pos,						gs.main_menu_state.save_list_scroll_offset,						save_data.location,						save_data.seconds_played,					) {						gs.save_data = save_data						game_init(gs) 						// If level doesn't exist, replace it with FIRST_LEVEL_ID						// NOTE: Else break save games during development 						level := level_from_id(gs.levels[:], gs.save_data.level_id)						if level == nil {							gs.save_data.level_id = FIRST_LEVEL_ID						} 						level_load(gs, gs.save_data.level_id, 0) 					}				} else {					// We are starting a new game					if load_game_item_draw(i, panel_pos, gs.main_menu_state.save_list_scroll_offset) {						game_init(gs) 						gs.save_data.slot = i						gs.save_data.version.major = VERSION_MAJOR						gs.save_data.version.minor = VERSION_MINOR						gs.save_data.version.patch = VERSION_PATCH 						level_load(gs, FIRST_LEVEL_ID, 0)					}				}			} 			rl.EndTextureMode() 			// We finished drawing to the scrolling box			// Now we draw the box onto the screen at the correct location 			rl.DrawTextureRec(				gs.main_menu_state.save_texture.texture,				Rect {					0,					gs.main_menu_state.save_list_scroll_offset - SAVE_PANEL_HEIGHT,					SAVE_PANEL_WIDTH,					-SAVE_PANEL_HEIGHT,				},				panel_pos,				rl.WHITE,			) 			{				text :: "Back"				size := rl.MeasureTextEx(gs.font_48, text, 48, 0)				if main_menu_item_draw(text, {32 + size.x / 2, WINDOW_HEIGHT - 60}) {					gs.main_menu_state.menu_type = .Default				}			}		} 		rl.EndDrawing() 		// gs.scene is set when we load_level		// We need to make sure we end texture and drawing modes		// Then we can return to change scene 		if gs.scene != .Main_Menu {			return		}	}} load_game_item_draw :: proc(	slot: int,	panel_pos: Vec2,	offset: f32,	location: string = "",	time_played: f64 = 0,) -> (	pressed: bool,) {	text: cstring	if time_played == 0 {		text = "New Game"	} else {		dur := time.Duration(i64(time_played * 1000 * 1000 * 1000))		buf: [time.MIN_HMS_LEN]u8		time_played_str := time.to_string_hms(dur, buf[:])		text = fmt.ctprintf("%d - %s, %s", slot + 1, location, time_played_str)	} 	pos := Vec2{0, f32(slot) * SAVE_ITEM_HEIGHT}	mouse_pos := rl.GetMousePosition() 	screen_pos := panel_pos + {0, pos.y + offset} 	if rl.CheckCollisionPointRec(mouse_pos, {screen_pos.x, screen_pos.y, SAVE_PANEL_WIDTH, SAVE_ITEM_HEIGHT}) {		rl.DrawTextEx(gs.font_48, text, pos, 48, 0, rl.YELLOW)		if rl.IsMouseButtonPressed(.LEFT) {			pressed = true		}	} else {		rl.DrawTextEx(gs.font_48, text, pos, 48, 0, rl.WHITE)	} 	return} main_menu_item_draw :: proc(text: cstring, pos: Vec2, color := rl.WHITE, hover_color := rl.YELLOW) -> (pressed: bool) {	pos := pos	text_size := rl.MeasureTextEx(gs.font_48, text, 48, 0)	pos.x -= text_size.x / 2	rect := Rect{pos.x, pos.y, text_size.x, text_size.y} 	if rl.CheckCollisionPointRec(rl.GetMousePosition(), rect) {		rl.DrawTextEx(gs.font_48, text, pos, 48, 0, hover_color)		if rl.IsMouseButtonPressed(.LEFT) {			pressed = true		}	} else {		rl.DrawTextEx(gs.font_48, text, pos, 48, 0, color)	} 	return} game_init :: proc(gs: ^Game_State) {	gs.last_update_time = time.now() 	// Load player texture	gs.player_texture = rl.LoadTexture("assets/textures/player_120x80.png")	gs.item_texture = rl.LoadTexture("assets/textures/items_16x16.png") 	gs.sword_swoosh_sound = rl.LoadSound("assets/sounds/player_sword_swing.wav")	gs.sword_swoosh_sound_2 = rl.LoadSound("assets/sounds/player_sword_swing_2.wav")	gs.sword_hit_soft_sound = rl.LoadSound("assets/sounds/sword_hit_soft.wav")	gs.sword_hit_medium_sound = rl.LoadSound("assets/sounds/sword_hit_medium.wav")	gs.sword_hit_stone_sound = rl.LoadSound("assets/sounds/sword_hit_stone.wav")	gs.player_jump_sound = rl.LoadSound("assets/sounds/player_jump.wav") 	gs.bgm = rl.LoadMusicStream("assets/music/bgm.ogg")	rl.PlayMusicStream(gs.bgm) 	gs.enemy_definitions["Walker"] = Enemy_Def {		collider_size     = {36, 18},		move_speed        = 35,		health            = 3,		behaviors         = {.Walk, .Flip_At_Wall, .Flip_At_Edge},		on_hit_damage     = 1,		texture           = rl.LoadTexture("assets/textures/opossum_36x28.png"),		initial_animation = "walk",		hit_response      = .Stop,		hit_duration      = 0.25,	} 	if walker, walker_ok := &gs.enemy_definitions["Walker"]; walker_ok {		walker.animations["walk"] = Animation {			size           = {36, 28},			offset         = {0, 10},			offset_flipped = {0, 10},			start          = 0,			end            = 5,			time           = 0.15,			flags          = {.Loop},		} 		append(&walker.drops, Drop{type = .Necrotic_Tail, chance = 1, range = 1})	} 	gs.enemy_definitions["Jumper"] = Enemy_Def {		collider_size     = {50, 48},		health            = 2,		behaviors         = {.Wander, .Hop},		on_hit_damage     = 1,		texture           = rl.LoadTexture("assets/textures/bunny_50x48.png"),		initial_animation = "idle",		hit_response      = .Knockback,		hit_duration      = 0.25,	} 	if jumper, jumper_ok := &gs.enemy_definitions["Jumper"]; jumper_ok {		jumper.animations["idle"] = Animation {			size = {50, 48},		}		jumper.animations["hop"] = Animation {			size   = {50, 48},			offset = {},			start  = 0,			end    = 2,			time   = 0.075,			flags  = {},		} 		append(&jumper.drops, Drop{type = .Lucky_Foot, chance = 1, range = {1, 2}})	} 	gs.enemy_definitions["Charger"] = Enemy_Def {		collider_size     = {64, 35},		health            = 3,		move_speed        = 25,		behaviors         = {.Walk, .Flip_At_Wall, .Flip_At_Edge, .Charge_At_Player},		on_hit_damage     = 2,		texture           = rl.LoadTexture("assets/textures/pig_64x35.png"),		initial_animation = "walk",		hit_response      = .Stop,		hit_duration      = 0.25,	} 	if charger, charger_ok := &gs.enemy_definitions["Charger"]; charger_ok {		charger.animations["walk"] = Animation {			size  = {64, 35},			end   = 3,			time  = 0.125,			flags = {.Loop},		}		charger.animations["charge"] = Animation {			size = {64, 35},			end  = 3,			time = 0.075,		} 		append(&charger.drops, Drop{type = .Strange_Bacon, chance = 0.5, range = {1, 3}})		append(&charger.drops, Drop{type = .Dummy4, chance = 1, range = {1, 5000}})	} 	gs.demon_boss_attack_texture = rl.LoadTexture("assets/textures/demon_boss_240x192.png")	gs.enemy_definitions["Demon_Boss"] = Enemy_Def {		collider_size     = {32, 64},		move_speed        = 35,		health            = 30,		debug_color       = rl.Color{255, 255, 0, 255},		texture           = rl.LoadTexture("assets/textures/demon_boss_160x144.png"),		initial_animation = "fly",		on_update         = demon_boss_on_update,		flags             = {.Flying, .Kinematic},	} 	if demon_boss, demon_boss_ok := &gs.enemy_definitions["Demon_Boss"]; demon_boss_ok {		demon_boss.animations["fly"] = Animation {			size           = {160, 144},			offset         = {80, 48},			offset_flipped = {48, 48},			start          = 0,			end            = 5,			time           = 0.075,			flags          = {.Loop},		} 		demon_boss.animations["attack"] = Animation {			size           = {240, 192},			offset         = {80, 96},			offset_flipped = {120, 96},			start          = 0,			end            = 10,			time           = 0.075,			flags          = {},			on_finish      = demon_boss_on_finish_attack,			texture        = &gs.demon_boss_attack_texture,		} 		if attack_anim, attack_anim_ok := &demon_boss.animations["attack"]; attack_anim_ok {			append(&attack_anim.timed_events, Animation_Event{duration = 0.600, callback = demon_boss_breath_cb})			append(&attack_anim.timed_events, Animation_Event{duration = 0.675, callback = demon_boss_breath_cb})			append(&attack_anim.timed_events, Animation_Event{duration = 0.750, callback = demon_boss_breath_cb})		} 	} 	gs.enemy_definitions["Orb"] = Enemy_Def {		collider_size     = {16, 16},		health            = 30,		on_hit_damage     = 2,		texture           = rl.LoadTexture("assets/textures/orb_32x32.png"),		initial_animation = "idle",		flags             = {.Flying, .Kinematic},	} 	if orb, orb_ok := gs.enemy_definitions["Orb"]; orb_ok {		orb.animations["idle"] = Animation {			size           = {32, 32},			offset         = {8, 8},			offset_flipped = {8, 8},			start          = 0,			end            = 1,			time           = 1,			flags          = {.Loop},			tint           = {0, 255, 255, 255},		}	} 	// TODO: Remove this. Just to test inventory layout	{		append(&gs.inventory, Inventory_Slot{item_type = .Dummy0, count = 1})		append(&gs.inventory, Inventory_Slot{item_type = .Dummy1, count = 1})		append(&gs.inventory, Inventory_Slot{item_type = .Dummy2, count = 1})		append(&gs.inventory, Inventory_Slot{item_type = .Dummy3, count = 1})		append(&gs.inventory, Inventory_Slot{item_type = .Dummy4, count = 1})		append(&gs.inventory, Inventory_Slot{item_type = .Dummy5, count = 1})		append(&gs.inventory, Inventory_Slot{item_type = .Dummy6, count = 1})		append(&gs.inventory, Inventory_Slot{item_type = .Dummy7, count = 1})		append(&gs.inventory, Inventory_Slot{item_type = .Dummy8, count = 1})		append(&gs.inventory, Inventory_Slot{item_type = .Dummy9, count = 1})		append(&gs.inventory, Inventory_Slot{item_type = .DummyA, count = 1})		append(&gs.inventory, Inventory_Slot{item_type = .DummyB, count = 1})		append(&gs.inventory, Inventory_Slot{item_type = .DummyC, count = 1})		append(&gs.inventory, Inventory_Slot{item_type = .DummyD, count = 1})		append(&gs.inventory, Inventory_Slot{item_type = .DummyE, count = 1})		append(&gs.inventory, Inventory_Slot{item_type = .DummyF, count = 1})	} 	gs.scene = .Game} game_update :: proc(gs: ^Game_State) {	for !rl.WindowShouldClose() {		rl.UpdateMusicStream(gs.bgm) 		gs.this_frame_time = time.now() 		dt := rl.GetFrameTime()		gs.delta_time = rl.GetFrameTime() 		if rl.IsKeyPressed(.F5) {			gs.editor_enabled = !gs.editor_enabled			gs.camera.zoom = ZOOM		} 		// Make sure to get a new pointer every frame in case the entities		// array is moved in memory		player := entity_get(gs.player_id) 		if gs.editor_enabled {			editor_update(gs, dt)		} else {			if rl.IsKeyPressed(.TAB) {				gs.game_menu_state.menu_type += cast(Game_Menu_Type)1				if gs.game_menu_state.menu_type == .Count {					gs.game_menu_state.menu_type = .None				}			} 			player_update(gs, dt)			entity_update(gs, dt)			physics_update(gs.entities[:], gs.colliders[:], gs.falling_logs[:], dt)			behavior_update(gs.entities[:], gs.colliders[:], dt)			particle_systems_update(gs) 			for &falling_log in gs.falling_logs {				if falling_log.state == .Falling {					falling_log.collider.y += dt * 600 					for collider in gs.colliders {						if rl.CheckCollisionRecs(collider, falling_log.collider) {							if collider.y <= falling_log.collider.y + falling_log.collider.height {								falling_log.state = .Settled								recreate_colliders(gs.level.pos, &gs.colliders, gs.falling_logs[:], gs.level.tiles[:])								break							}						}					} 					for entity, i in gs.entities {						if rl.CheckCollisionRecs(entity.collider, falling_log.collider) {							entity_damage(Entity_Id(i), 999)						}					}				}			} 			// Update Camera			{				render_half_size := Vec2{RENDER_WIDTH, RENDER_HEIGHT} / 2 				gs.camera.target = {player.x, player.y} - render_half_size 				if gs.camera.target.x < gs.level.pos.x {					gs.camera.target.x = gs.level.pos.x				} 				if gs.camera.target.y < gs.level.pos.y {					gs.camera.target.y = gs.level.pos.y				} 				if gs.camera.target.x + RENDER_WIDTH > gs.level.pos.x + gs.level.size.x {					gs.camera.target.x = gs.level.pos.x + gs.level.size.x - RENDER_WIDTH				} 				if gs.camera.target.y + RENDER_HEIGHT > gs.level.pos.y + gs.level.size.y {					gs.camera.target.y = gs.level.pos.y + gs.level.size.y - RENDER_HEIGHT				}			} 			if .Grounded in player.flags {				pos := Vec2{player.x, player.y}				size := Vec2{player.width, player.height} 				targets := make([dynamic]Rect, context.temp_allocator)				for e, i in gs.entities {					if Entity_Id(i) == gs.player_id do continue					if .Dead not_in e.flags {						append(&targets, e.collider)					}				} 				safety_check: {					for spike in gs.level.spikes {						if rl.CheckCollisionRecs(rect_pos_add(spike.collider, gs.level.pos), player.collider) {							break safety_check						}					} 					_, hit_ground_left := raycast(pos + {0, size.y}, DOWN * 2, gs.colliders[:])					if !hit_ground_left do break safety_check 					_, hit_ground_right := raycast(pos + size, DOWN * 2, gs.colliders[:])					if !hit_ground_right do break safety_check 					_, hit_entity_left := raycast(pos, LEFT * TILE_SIZE, targets[:])					if hit_entity_left do break safety_check 					_, hit_entity_right := raycast(pos + {size.x, 0}, RIGHT * TILE_SIZE, targets[:])					if hit_entity_right do break safety_check 					gs.safe_position = pos				}			}		} 		rl.BeginDrawing()		rl.BeginMode2D(gs.camera)		rl.ClearBackground(BG_COLOR) 		for rect in gs.colliders {			rl.DrawRectangleLinesEx(rect, 1, rl.ORANGE)		} 		for rect in gs.colliders {			rl.DrawRectangleRec(rect, {255, 255, 255, 40})		} 		for tile in gs.level.tiles {			width: f32 = TILE_SIZE			height: f32 = TILE_SIZE 			if tile.f == 1 || tile.f == 3 {				width = -TILE_SIZE			} else if tile.f == 2 || tile.f == 3 {				height = -TILE_SIZE			}			rl.DrawTextureRec(gs.tileset_texture, {tile.src.x, tile.src.y, width, height}, tile.pos, rl.WHITE)		} 		for e in gs.entities {			if .Dead in e.flags do continue 			if e.texture != nil {				anim := e.animations[e.current_anim_name]				source := Rect {					f32(e.current_anim_frame) * anim.size.x,					f32(anim.row) * anim.size.y,					anim.size.x,					anim.size.y,				} 				if .Left in e.flags {					source.width = -source.width				}				offset := .Left in e.flags ? anim.offset_flipped : anim.offset				texture := anim.texture == nil ? e.texture : anim.texture				tint := anim.tint == 0 ? rl.WHITE : anim.tint				rl.DrawTextureRec(texture^, source, {e.x, e.y} - offset, tint)			}			if .Debug_Draw in e.flags && .Dead not_in e.flags {				rl.DrawRectangleLinesEx(e.collider, 1, e.debug_color)			}		} 		for spike in gs.level.spikes {			rl.DrawRectangleLinesEx(rect_pos_add(spike.collider, gs.level.pos), 1, rl.YELLOW)		} 		for falling_log in gs.falling_logs {			center := rect_center(falling_log.collider)			if falling_log.state == .Default {				rope_pos := Vec2{center.x, center.y - falling_log.collider.height / 2}				rl.DrawLineEx(rope_pos, rope_pos - {0, falling_log.rope_height}, 1, rl.BROWN)			}			rl.DrawRectangleLinesEx(falling_log.collider, 1, rl.BROWN)		} 		rl.DrawRectangleLinesEx({gs.safe_position.x, gs.safe_position.y, 16, 16}, 1, rl.BLUE) 		for door in gs.level.doors {			rl.DrawRectangleLinesEx(door.rect, 1, rl.BLUE)		} 		for checkpoint in gs.level.checkpoints {			rl.DrawRectangleLinesEx({checkpoint.pos.x, checkpoint.pos.y, 32, 32}, 1, rl.ORANGE)		} 		for power_up in gs.level.power_up_spawns {			if power_up.type not_in gs.save_data.collected_power_ups {				rl.DrawRectangleLinesEx({power_up.pos.x, power_up.pos.y, 16, 16}, 1, rl.GOLD)			}		} 		for item in gs.items {			src := Rect{item.src.x, item.src.y, 16, 16}			rl.DrawTextureRec(gs.item_texture, src, item.pos, rl.WHITE)		} 		if gs.debug_draw_enabled {			for s in gs.debug_shapes {				switch v in s {				case Debug_Line:					rl.DrawLineEx(v.start, v.end, v.thickness, v.color)				case Debug_Rect:					rl.DrawRectangleLinesEx({v.pos.x, v.pos.y, v.size.x, v.size.y}, v.thickness, v.color)				case Debug_Circle:					rl.DrawCircleLinesV(v.pos, v.radius, v.color)				}			}		} 		for p in gs.particles {			pos := linalg.round(p.pos)			color := p.color			color.a = u8(f32(p.color.a) * (1 - p.transparency))			rl.DrawRectangleV(pos, p.size, color)		} 		rl.EndMode2D() 		rl.BeginMode2D(gs.ui_camera) 		// Player health		{			full_hearts := player.health / 2			has_half_heart := f32(player.health) / 2 > f32(full_hearts)			// Integer division truncates towards zero.			// 5 / 2 = 2			// -5 / 2 = -2			empty_hearts := math.ceil(f32(player.max_health - player.health) / 2) 			x := f32(16) 			for _ in 0 ..< full_hearts {				rl.DrawTextureRec(gs.tileset_texture, {336, 176, 16, 16}, {x, 16}, rl.WHITE)				x += 16			} 			if has_half_heart {				rl.DrawTextureRec(gs.tileset_texture, {336, 144, 16, 16}, {x, 16}, rl.WHITE)				x += 16			} 			for _ in 0 ..< empty_hearts {				rl.DrawTextureRec(gs.tileset_texture, {336, 112, 16, 16}, {x, 16}, rl.WHITE)				x += 16			}		} 		// Inventory		switch gs.game_menu_state.menu_type {		case .None, .Count:		case .Inventory:			// Background			rect := INGAME_UI_BG_RECT			rl.DrawRectangleRec(rect, INGAME_UI_BG_COLOR) 			pos := Vec2{40, 40} 			text: cstring = "Inventory"			font_size := f32(14)			text_size := rl.MeasureTextEx(gs.font_48, text, font_size, 0) 			rl.DrawTextEx(gs.font_48, text, {pos.x + 24 * 4 - text_size.x / 2 - 4, 20}, font_size, 0, rl.WHITE) 			// Items			for slot, i in gs.inventory {				src := Rect{slot.src.x, slot.src.y, 16, 16}				rl.DrawTextureRec(gs.item_texture, src, pos, rl.WHITE) 				if slot.count > 1 {					rl.DrawTextEx(gs.font_48, fmt.ctprintf("%d", slot.count), pos + 12, 10, 0, rl.WHITE)				}				if (i + 1) % 8 == 0 {					pos.y += 24					pos.x = 16				} 				pos.x += 24			}		case .Map:			// Background			rect := INGAME_UI_BG_RECT			rl.DrawRectangleRec(rect, INGAME_UI_BG_COLOR) 			player_tile_pos_x := (int(player.x) / MAP_SCALE) * MAP_SCALE			player_tile_pos_y := (int(player.y) / MAP_SCALE) * MAP_SCALE 			map_offset := Vec2{f32(player_tile_pos_x), f32(player_tile_pos_y)} 			for id in gs.save_data.visited_level_ids {				level := level_from_id(gs.levels[:], id)				if level == nil {					continue				} 				base_pos := level.pos				base_pos -= map_offset				base_pos = linalg.floor(base_pos / 16)				base_pos += Vec2{RENDER_WIDTH, RENDER_HEIGHT} / 2 				size := level.size / 16 				bg_color := id == gs.level.id ? MAP_COLOR_CURRENT_LEVEL : MAP_COLOR_OTHER_LEVEL 				rl.DrawRectangleV(base_pos, size, bg_color) 				rl.DrawRectangleLinesEx({base_pos.x, base_pos.y, size.x, size.y}, 1, MAP_COLOR_LEVEL_BORDER) 				for tile in level.tiles {					rel_tile_pos := Vec2{(tile.pos.x - level.pos.x) / 16, (tile.pos.y - level.pos.y) / 16}					tile_pos := linalg.round(base_pos + rel_tile_pos)					tile_size :: f32(TILE_SIZE) / 16					color := id == gs.level.id ? MAP_COLOR_SOLID : MAP_COLOR_SOLID_OTHER					rl.DrawRectangleV(tile_pos, tile_size, color)				}			} 			player_pos := Vec2{RENDER_WIDTH, RENDER_HEIGHT} / 2			player_size :: 4			rl.DrawRectangleV(player_pos, player_size, MAP_COLOR_PLAYER)		} 		rl.EndMode2D() 		if gs.editor_enabled {			editor_draw(gs)		} 		rl.EndDrawing() 		clear(&gs.debug_shapes)		free_all(context.temp_allocator)	}} main :: proc() {	level_on_enter_map["demon_boss_init"] = demon_boss_init	level_on_enter_map["some_other_init"] = some_other_init	level_on_enter_map["yet_other_init"] = yet_other_init	level_on_enter_map["and_other_init"] = and_other_init 	gs = new(Game_State)	gs.debug_draw_enabled = true 	rl.InitWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "Program Video Games!")	rl.SetTargetFPS(TARGET_FPS)	rl.InitAudioDevice() 	world_data_load() 	gs.font_18 = rl.LoadFontEx("assets/fonts/Gogh-ExtraBold.ttf", 18, nil, 256)	gs.font_48 = rl.LoadFontEx("assets/fonts/Gogh-ExtraBold.ttf", 48, nil, 256)	gs.font_64 = rl.LoadFontEx("assets/fonts/Gogh-ExtraBold.ttf", 64, nil, 256) 	gs.tileset_texture = rl.LoadTexture("assets/textures/tileset.png") 	editor_init() 	gs.camera = rl.Camera2D {		zoom = ZOOM,	}	gs.ui_camera = rl.Camera2D {		zoom = ZOOM,	} 	// Check for savefiles	{		curr_path := os.get_current_directory(context.temp_allocator)		save_dir_path := fmt.tprintf("%s/saves", curr_path)		save_dir, err := os.open(save_dir_path)		if err == .Not_Exist {			make_err := os.make_directory(save_dir_path)			save_dir, err = os.open(save_dir_path) 			if make_err != nil || err != nil {				panic("Could not create save directory")			}		} 		files, read_dir_err := os.read_dir(save_dir, 0, context.temp_allocator)		if read_dir_err != nil {			panic("Failed to read saves directory")		} 		for file in files {			save_data, ok := savefile_load(file.fullpath)			if ok {				gs.main_menu_state.save_slots[save_data.slot] = save_data			}		}	} 	// Setup Main Menu Texture	{		width :: SAVE_PANEL_WIDTH		height :: SAVE_SLOTS * SAVE_ITEM_HEIGHT		gs.main_menu_state.save_texture = rl.LoadRenderTexture(width, height)	} 	for !rl.WindowShouldClose() {		switch gs.scene {		case .Main_Menu:			main_menu_update(gs)		case .Game:			game_update(gs)		}	}}

45. Particle System

What are you stuck on?