odin-space-invaders/game.odin

package space_invaders

import "core:c"
import "core:log"
import glm "core:math/linalg/glsl"

import rl "vendor:raylib"

GLOBAL_SPRITE_SCALE :: 2
SPRITE_CELL :: 16

ALIEN_ROWS :: 5
ALIENS_PER_ROW :: 11
ALIENS :: ALIEN_ROWS * ALIENS_PER_ROW
ALIEN_SIDE_STEP :: 20 * GLOBAL_SPRITE_SCALE
ALIEN_RECT :: glm.vec2{SPRITE_CELL * GLOBAL_SPRITE_SCALE, SPRITE_CELL * GLOBAL_SPRITE_SCALE}

MAX_BULLETS :: 100
BULLET_SPEED :: 240
BULLET_RECT :: glm.vec2{SPRITE_CELL * GLOBAL_SPRITE_SCALE, SPRITE_CELL * GLOBAL_SPRITE_SCALE}

MAX_PLAYER_HEALTH :: 3
PLAYER_SPEED :: 120
PLAYER_RECT :: glm.vec2{SPRITE_CELL * GLOBAL_SPRITE_SCALE, SPRITE_CELL * GLOBAL_SPRITE_SCALE}

// texture offset for ship
SHIP_TO :: glm.vec2{0, 112}
BULLET_TO :: glm.vec2{32, 112}

AlienKind :: enum {
	ORANGE,
	GREEN,
	YELLOW,
	RED,
}

// texture atlas offset for aliens
ALIENS_TO := [AlienKind]glm.vec2 {
	.ORANGE = {0, 128 - (SPRITE_CELL * 2)},
	.GREEN = {SPRITE_CELL * 1, 128 - (SPRITE_CELL * 2)},
	.YELLOW = {SPRITE_CELL * 2, 128 - (SPRITE_CELL * 2)},
	.RED = {SPRITE_CELL * 3, 128 - (SPRITE_CELL * 2)},
}

Alien :: struct {
	alive:    bool,
	position: glm.vec2,
	id:       AlienKind,
}

Bullet :: struct {
	alive:    bool,
	position: glm.vec2,
}

collideAABB :: proc(
	a_rect: glm.vec2,
	a_pos: ^glm.vec2,
	b_rect: glm.vec2,
	b_pos: ^glm.vec2,
) -> bool {
	return(
		a_pos.x < b_pos.x + f32(b_rect.x / 2) &&
		a_pos.x + f32(a_rect.x / 2) > b_pos.x &&
		a_pos.y < b_pos.y + f32(b_rect.y / 2) &&
		a_pos.y + f32(a_rect.y / 2) > b_pos.y \
	)
}

setup_game :: proc(state: ^GameState) {
	using state
	player_pos = glm.vec2{f32(screen_width / 2), f32(screen_height) - PLAYER_RECT.x}

	// setup the initial positions of the aliens
	for row in 0 ..< ALIEN_ROWS {
		for alien in 0 ..< ALIENS_PER_ROW {
			alien_ptr := &aliens[(row * ALIENS_PER_ROW) + alien]
			alien_ptr.position = glm.vec2 {
				f32((alien + 1) * int(ALIEN_RECT.x + 10)),
				f32((row + 1) * int(ALIEN_RECT.x + 10)),
			}
			alien_ptr.alive = true
		}
	}
	// aliens[ALIENS - 1].alive = true

	if player_score > player_high_score {
		player_high_score = player_score
	}
	player_score = 0

	reset_game = false
}

update_game :: proc(state: ^GameState) {
	using state

	// If we're entering the game screen then we need to setup initial state of the game variables
	if last_frame_screen != .GAMEPLAY || reset_game {
		setup_game(state)
		log.info("Done setting up game")
	}

	// Press enter to change to ENDING screen
	if (rl.IsKeyPressed(rl.KeyboardKey.ENTER)) {
		state.screen = .ENDING
		log.info("Updated screen enum", state.screen)
	}

	// Press space to change to fire
	if (rl.IsKeyPressed(rl.KeyboardKey.SPACE)) {
		log.info("FIRE!")
		bullet := &bullets[bullet_index];bullet_index = (bullet_index + 1) % MAX_BULLETS
		bullet.alive = true
		bullet.position = player_pos
		bullet.position.y = bullet.position.y - ((PLAYER_RECT.y / 2) + BULLET_RECT.y / 2.0)
	}

	if (rl.IsKeyDown(rl.KeyboardKey.RIGHT)) {
		player_pos.x = player_pos.x + f32(PLAYER_SPEED * delta_time)
	}
	if (rl.IsKeyDown(rl.KeyboardKey.LEFT)) {
		player_pos.x = player_pos.x - f32(PLAYER_SPEED * delta_time)
	}

	all_aliens_dead := true
	for &alien in aliens {
		if !alien.alive {continue}
		all_aliens_dead = false
	}

	if all_aliens_dead {
		screen = .ENDING
	}

	// movement update
	for &bullet in bullets {
		if !bullet.alive {continue}

		bullet.position.y = bullet.position.y - f32(BULLET_SPEED * delta_time)
	}

	for &bullet in bullets {
		if !bullet.alive {continue}
		for &alien in aliens {
			if !alien.alive {continue}
			if collideAABB(ALIEN_RECT, &alien.position, BULLET_RECT, &bullet.position) {
				bullet.alive = false
				alien.alive = false
				player_score += 10
				log.info("HIT 'EM HARD")
			}
		}
	}


}

ship_sprite_cell_offset := rl.Rectangle{SHIP_TO.x, SHIP_TO.y, SPRITE_CELL, SPRITE_CELL}
bullet_sprite_cell_offset := rl.Rectangle{BULLET_TO.x, BULLET_TO.y, SPRITE_CELL, SPRITE_CELL}

draw_game :: proc(state: ^GameState) {
	using state

	rl.DrawRectangle(0, 0, state.screen_width, state.screen_height, rl.BLACK)

	rl.DrawTexturePro(
		texture_atlas,
		ship_sprite_cell_offset,
		{player_pos.x, player_pos.y, f32(PLAYER_RECT.x), f32(PLAYER_RECT.y)},
		{SPRITE_CELL, SPRITE_CELL},
		0,
		rl.WHITE,
	)

	for alien in aliens {
		if !alien.alive {continue}
		rl.DrawTexturePro(
			texture_atlas,
			{ALIENS_TO[alien.id].x, ALIENS_TO[alien.id].y, SPRITE_CELL, SPRITE_CELL},
			{alien.position.x, alien.position.y, SPRITE_CELL, SPRITE_CELL},
			{SPRITE_CELL, SPRITE_CELL},
			0,
			rl.WHITE,
		)
		// rl.DrawCircle(
		// 	c.int(alien.position.x),
		// 	c.int(alien.position.y),
		// 	f32(ALIEN_RECT.x / 2),
		// 	rl.YELLOW,
		// )
	}

	for &bullet in bullets {
		if !bullet.alive {continue}
		rl.DrawCircle(
			c.int(bullet.position.x),
			c.int(bullet.position.y),
			f32(BULLET_RECT.x / 2),
			rl.WHITE,
		)
	}

	if DEBUG_MODE {
		for &bullet in bullets {
			if !bullet.alive {continue}
			rl.DrawRectangleLines(
				c.int(bullet.position.x - (BULLET_RECT.x / 2)),
				c.int(bullet.position.y - (BULLET_RECT.y / 2)),
				c.int(BULLET_RECT.x),
				c.int(BULLET_RECT.y),
				rl.YELLOW,
			)
		}
		for &alien in aliens {
			if !alien.alive {continue}
			rl.DrawRectangleLines(
				c.int(alien.position.x - (ALIEN_RECT.x / 2)),
				c.int(alien.position.y - (ALIEN_RECT.y / 2)),
				c.int(ALIEN_RECT.x),
				c.int(ALIEN_RECT.y),
				rl.YELLOW,
			)
		}

		rl.DrawRectangleLines(
			c.int(player_pos.x - (PLAYER_RECT.x / 2)),
			c.int(player_pos.y - (PLAYER_RECT.y / 2)),
			c.int(PLAYER_RECT.x),
			c.int(PLAYER_RECT.y),
			rl.YELLOW,
		)
	}

	rl.DrawText(rl.TextFormat("Score: %d", player_score), 130, 220, 20, rl.MAROON)
	// rl.DrawText("GAMEPLAY SCREEN", 20, 20, 40, rl.MAROON)
}