tower-defense-prototype/game/tower.odin

package game

import "core:fmt"
import rl "vendor:raylib"

Tower :: struct {
	upgrade_level: int,
	position:      Vec2,
	kind:          Tower_Kind,
	cooldown:      f32,
	anchor_gx:     int,
	anchor_gy:     int,
}

Tower_Kind :: enum {
	Archer,
	Cannon,
	Ice,
}

Tower_Archetype :: struct {
	kind:             Tower_Kind,
	range:            f32,
	damage:           int,
	fire_rate:        f32,
	cost:             int,
	footprint_w:      int, // 1 column wide
	footprint_h:      int, // two rows tall
	max_upgrade:      int,
	upgrade_cost:     int,
	damage_per_level: int,
	range_per_level:  f32,
	splash_radius:    f32,
}

TOWER_ARCHETYPES: [Tower_Kind]Tower_Archetype = {
	.Archer = {
		kind = .Archer,
		range = 100,
		damage = 12,
		fire_rate = 0.45,
		cost = TOWER_COST,
		footprint_w = 1,
		footprint_h = 2,
		max_upgrade = 1,
		upgrade_cost = 40,
		damage_per_level = 3,
		range_per_level = 8,
		splash_radius = 0,
	},
	.Cannon = {
		kind = .Cannon,
		range = 110,
		damage = 35,
		fire_rate = 1.2,
		cost = 80,
		footprint_w = 2,
		footprint_h = 2,
		max_upgrade = 1,
		upgrade_cost = 40,
		damage_per_level = 3,
		range_per_level = 8,
		splash_radius = 60,
	},
	.Ice = {
		kind = .Ice,
		range = 85,
		damage = 6,
		fire_rate = 0.55,
		cost = 65,
		footprint_w = 1,
		footprint_h = 1,
		max_upgrade = 1,
		upgrade_cost = 40,
		damage_per_level = 3,
		range_per_level = 8,
		splash_radius = 0,
	},
}

tower_stats_at_level :: proc(tower: Tower) -> (damage: int, range: f32) {
	arch := TOWER_ARCHETYPES[tower.kind]
	damage = arch.damage + tower.upgrade_level * arch.damage_per_level
	range = arch.range + f32(tower.upgrade_level) * arch.range_per_level
	return
}

find_target_slot :: proc(tower: Tower, world: ^World) -> int {
	best_slot: int = -1
	best_dist: f32 = 999999

	for i in 0 ..< MAX_ENEMIES {
		e := &world.enemies[i]
		if !e.active do continue
		if e.path_index >= len(world.path) do continue

		d := distance(tower.position, e.position)
		_, range := tower_stats_at_level(tower)
		if d <= range && d < best_dist {
			best_slot = i
			best_dist = d
		}
	}
	return best_slot
}

update_towers :: proc(world: ^World, dt: f32) {
	for i in 0 ..< len(world.towers) {
		t := &world.towers[i]
		t.cooldown -= dt

		if t.cooldown > 0 do continue

		slot := find_target_slot(t^, world)
		if slot < 0 do continue

		arch := TOWER_ARCHETYPES[t.kind]

		damage, _ := tower_stats_at_level(t^)
		switch t.kind {
		case .Archer:
			spawn_projectile(world, t.position, slot, damage)
		case .Cannon:
			if target := enemy_at_slot(world, slot); target != nil {
				len := distance(t.position, target.position)
				if (len > 0.001) {
					dir := Vec2 {
						(target.position.x - t.position.x) / len,
						(target.position.y - t.position.y) / len,
					}
					spawn_ballistic(world, t.position, dir, damage, arch.splash_radius)
				}
			}
		case .Ice:
			if target := enemy_at_slot(world, slot); target != nil {
				apply_ice_hit(world, target, damage)
			}
		}
		t.cooldown = arch.fire_rate
	}
}

apply_tower_hit :: proc(world: ^World, target: ^Enemy, damage: int) {
	target.health -= damage
	if target.health <= 0 {
		target.active = false
		push_event(world, .Enemy_Killed, gold_reward = 5)
	}
}

apply_ice_hit :: proc(world: ^World, target: ^Enemy, damage: int) {
	apply_tower_hit(world, target, damage)
	if target.active do target.slow_timer = ICE_SLOW_DURATION
}

enemy_at_slot :: proc(world: ^World, slot: int) -> ^Enemy {
	if slot < 0 || slot >= MAX_ENEMIES do return nil

	e := &world.enemies[slot]
	if !e.active do return nil
	return e
}

render_towers :: proc(world: ^World) {
	for t in world.towers {
		archetype := TOWER_ARCHETYPES[t.kind]
		pixel_width := f32(archetype.footprint_w * TILE_SIZE)
		pixel_height := f32(archetype.footprint_h * TILE_SIZE)
		color := rl.Color{255, 203, 0, 255}
		if t.kind == .Cannon do color = rl.DARKGRAY
		rl.DrawRectangle(
			i32(t.position.x - pixel_width * 0.5),
			i32(t.position.y - pixel_height * 0.5),
			i32(pixel_width),
			i32(pixel_height),
			color,
		)
		if t.upgrade_level > 0 {
			label := fmt.ctprintf("Lv%d", t.upgrade_level + 1) // or just t.upgrade_level
			rl.DrawText(label, i32(t.position.x), i32(t.position.y), 14, rl.WHITE)
		}
	}
}