Godot Spawn System

# 僵尸类型枚举
enum Type {
    Zombie,      # 普通僵尸
    AglieZombie, # 敏捷僵尸
    ZombieKing   # 僵尸王
}

# 战斗地图类，管理生成点
class_name FightMap
extends Node2D

@export_group("Zombie Generater Enable")
@export var up_enable: bool = false
@export var left_enable: bool = false
@export var right_enable: bool = false
@export var down_enable: bool = false

@export_group("Zombie Generater Markers")
@export var up_markers_container: Node2D
@export var left_markers_container: Node2D
@export var right_markers_container: Node2D
@export var down_markers_container: Node2D

func get_zombie_generater_markers() -> Array[Marker2D]:
    var result: Array[Marker2D] = []
    if up_enable:
        result.append_array(up_markers_container.get_children())
    if left_enable:
        result.append_array(left_markers_container.get_children())
    if right_enable:
        result.append_array(right_markers_container.get_children())
    if down_enable:
        result.append_array(down_markers_container.get_children())
    return result

FightMap
├── UpMarkers (Node2D)
│   └── Marker2D × N
├── LeftMarkers (Node2D)
│   └── Marker2D × N
├── RightMarkers (Node2D)
│   └── Marker2D × N
└── DownMarkers (Node2D)
    └── Marker2D × N

var generate_zombie_with_level = [
    {"zombie": 0.75, "king": 0.5, "king_time": 16},
    {"zombie": 0.30, "king": 1, "king_time": 5},  # 25级：僵尸王必出
]

func _on_generate_zombie_timer_timeout():
    if not zombie_generate_enable:
        return

    var zombie_markers = current_fight_map.get_zombie_generater_markers()
    var rand_zombie: float = randf()

    if can_generate_zombie_king and rand_zombie < GameData.generate_zombie_with_level[GameData.level].king:
        can_generate_zombie_king = false
        generate_zombie_king_timer.wait_time = GameData.generate_zombie_with_level[GameData.level].king_time
        generate_zombie_king_timer.start()
        zombie_packed_scene = ZOMBIE_KING
        fight_ui.warn_zombie_king()
    else:
        rand_zombie = randf()
        if rand_zombie < GameData.generate_zombie_with_level[GameData.level].zombie:
            zombie_packed_scene = ZOMBIE
        else:
            zombie_packed_scene = AGILE_ZOMBIE

    var zombie: Zombie = zombie_packed_scene.instantiate()
    zombie.global_position = zombie_markers.pick_random().global_position + random_pos
    zombie.died.connect(on_zombie_died)
    enermies.add_child(zombie)

func _physics_process(_delta):
    if not is_died and not is_stun:
        var player := get_tree().get_first_node_in_group("Player") as Player
        navigation_agent_2d.target_position = player.global_position
        var next_pos = navigation_agent_2d.get_next_path_position()
        var new_velocity = global_position.direction_to(next_pos) * SPEED
        navigation_agent_2d.set_velocity(new_velocity)
        await navigation_agent_2d.velocity_computed
        move_and_slide()

enum State {
    Walk,   # 行走
    Stun,   # 眩晕
    Die     # 死亡
}

func die():
    animation_tree_state_machine.travel("Die")
    state_machine.change_state("Die")
    died.emit(type, global_position)

var zombie_drop_bullet_gift = {
    "zombie": 0.05,        # 普通僵尸：5% 掉落
    "aglie_zombie": 0.2,   # 敏捷僵尸：20% 掉落
    "zombie_king": 1       # 僵尸王：100% 掉落
}