/godot-weapon-system

name: godot-weapon-system
description: Godot 4武器切换系统，支持武器类型枚举、武器基类设计、多种切换逻辑、输入绑定和锁定机制。

Godot 4 武器切换系统

完整的武器管理系统，支持多类型武器、快速切换、冷却锁定、输入绑定。

何时使用此技能

• 实现玩家武器切换
• 近战/远程武器系统
• 武器冷却与锁定
• 武器类型分类管理

武器类型枚举

# weapon_type.gd
class_name WeaponType
extends RefCounted

## 武器类型枚举
enum Type {
    NONE = -1,
    SWORD = 0,      # 近战 - 剑
    AXE = 1,        # 近战 - 斧
    HAMMER = 2,     # 近战 - 锤
    BOW = 3,        # 远程 - 弓
    CROSSBOW = 4,   # 远程 - 弩
    STAFF = 5,      # 法杖
    SHIELD = 6,     # 盾牌
    THROWING = 7,   # 投掷武器
}

## 类型名称映射
const TYPE_NAMES: Dictionary = {
    Type.SWORD: "剑",
    Type.AXE: "斧",
    Type.HAMMER: "锤",
    Type.BOW: "弓",
    Type.CROSSBOW: "弩",
    Type.STAFF: "法杖",
    Type.SHIELD: "盾牌",
    Type.THROWING: "投掷武器"
}

## 获取类型名称
static func get_name(type: Type) -> String:
    return TYPE_NAMES.get(type, "未知")

## 是否是近战武器
static func is_melee(type: Type) -> bool:
    return type in [Type.SWORD, Type.AXE, Type.HAMMER, Type.SHIELD]

## 是否是远程武器
static func is_ranged(type: Type) -> bool:
    return type in [Type.BOW, Type.CROSSBOW, Type.STAFF, Type.THROWING]

武器基类设计

WeaponData 武器数据资源

# weapon_data.gd
class_name WeaponData
extends Resource

## 武器唯一标识符
@export var id: StringName

## 武器名称
@export var weapon_name: String

## 武器类型
@export var weapon_type: WeaponType.Type = WeaponType.Type.SWORD

## 武器 Prefab 场景
@export var weapon_scene: PackedScene

## 武器图标（用于UI）
@export var icon: Texture2D

## 基础属性
@export var base_damage: int = 10
@export var attack_speed: float = 1.0
@export var attack_range: float = 1.0

## 冷却时间
@export var cooldown: float = 0.5

## 是否需要弹药
@export var needs_ammo: bool = false
@export var max_ammo: int = 0
@export var ammo_type: StringName = &""

## 特殊属性
@export var can_block: bool = false
@export var block_ratio: float = 0.5

## 动画
@export var attack_animation: StringName = &"attack"
@export var idle_animation: StringName = &"idle"

## 获取武器类型名称
func get_type_name() -> String:
    return WeaponType.get_name(weapon_type)

## 是否是近战武器
func is_melee() -> bool:
    return WeaponType.is_melee(weapon_type)

## 是否是远程武器
func is_ranged() -> bool:
    return WeaponType.is_ranged(weapon_type)

Weapon 基类

# weapon.gd
class_name Weapon
extends Node2D

## 信号：攻击开始
signal attack_started

## 信号：攻击结束
signal attack_finished

## 信号：攻击命中
signal attack_hit(target: Node)

## 信号：弹药变化
signal ammo_changed(current: int, max: int)

@export var weapon_data: WeaponData

var _owner: CharacterBody2D
var _current_ammo: int
var _cooldown_timer: float = 0.0
var _is_attacking: bool = false

func _ready() -> void:
    _owner = get_owner() as CharacterBody2D
    if weapon_data and weapon_data.needs_ammo:
        _current_ammo = weapon_data.max_ammo
        ammo_changed.emit(_current_ammo, weapon_data.max_ammo)

func _process(delta: float) -> void:
    if _cooldown_timer > 0:
        _cooldown_timer -= delta

func _physics_process(delta: float) -> void:
    pass

## 使用武器攻击
func attack() -> bool:
    if not can_attack():
        return false
    
    if weapon_data.needs_ammo and _current_ammo <= 0:
        return false
    
    _is_attacking = true
    _start_attack()
    attack_started.emit()
    
    if weapon_data.needs_ammo:
        _current_ammo -= 1
        ammo_changed.emit(_current_ammo, weapon_data.max_ammo)
    
    # 重置冷却
    _cooldown_timer = weapon_data.cooldown
    
    return true

func _start_attack() -> void:
    # 播放攻击动画
    if _owner.has_method("play_animation"):
        _owner.play_animation(weapon_data.attack_animation)

func _end_attack() -> void:
    _is_attacking = false
    attack_finished.emit()

## 停止攻击
func stop_attack() -> void:
    _is_attacking = false
    _end_attack()

## 是否可以攻击
func can_attack() -> bool:
    if _is_attacking:
        return false
    if _cooldown_timer > 0:
        return false
    return true

## 获取剩余冷却时间
func get_cooldown_remaining() -> float:
    return maxf(_cooldown_timer, 0.0)

## 装填弹药
func reload(amount: int = 0) -> void:
    if not weapon_data.needs_ammo:
        return
    
    if amount <= 0:
        _current_ammo = weapon_data.max_ammo
    else:
        _current_ammo = mini(_current_ammo + amount, weapon_data.max_ammo)
    
    ammo_changed.emit(_current_ammo, weapon_data.max_ammo)

## 命中处理（供Hitbox调用）
func on_hit(target: Node) -> void:
    attack_hit.emit(target)

具体武器实现

# sword.gd
class_name Sword
extends Weapon

@export var slash_effect_scene: PackedScene

func _start_attack() -> void:
    super._start_attack()
    
    # 生成斩击特效
    if slash_effect_scene:
        var effect := slash_effect_scene.instantiate()
        get_tree().current_scene.add_child(effect)
        effect.global_position = global_position
        effect.rotation = _owner.rotation

func on_hit(target: Node) -> void:
    if target.has_method("take_damage"):
        target.take_damage(weapon_data.base_damage)
    
    # 击退效果
    if target.has_method("apply_knockback"):
        var direction := (target.global_position - _owner.global_position).normalized()
        target.apply_knockback(direction, 200.0)

# bow.gd
class_name Bow
extends Weapon

@export var arrow_scene: PackedScene
@export var arrow_spawn_offset: Vector2 = Vector2(30, 0)

func _start_attack() -> void:
    super._start_attack()
    
    # 发射箭矢
    if arrow_scene:
        var arrow := arrow_scene.instantiate()
        get_tree().current_scene.add_child(arrow)
        
        var spawn_pos := global_position + arrow_spawn_offset.rotated(global_rotation)
        arrow.initialize(spawn_pos, _owner.rotation, weapon_data.base_damage)

切换逻辑

WeaponSwitcher 武器切换器

# weapon_switcher.gd
class_name WeaponSwitcher
extends Node

## 信号：武器切换
signal weapon_switched(from_weapon: Weapon, to_weapon: Weapon)

## 信号：武器被锁定
signal weapon_locked(weapon_type: WeaponType.Type, unlock_time: float)

## 信号：切换冷却开始
signal switch_cooldown_started(duration: float)

@export var weapon_slots: Array[WeaponData] =