2155 lines
70 KiB
GDScript
2155 lines
70 KiB
GDScript
extends CharacterBody2D
|
||
|
||
@onready var pet_image: AnimatedSprite2D = $PetImage #这里展示宠物动画
|
||
@onready var pet_tool_image: Sprite2D = $PetImage/PetToolImage #这里展示宠物武器工具
|
||
@onready var pet_name_rich_text: RichTextLabel = $PetInformVBox/PetNameRichText #这里展示主人给宠物命名的名字
|
||
@onready var armor_bar: ProgressBar = $PetInformVBox/ArmorBar #宠物盔甲值进度条
|
||
@onready var armor_label: Label = $PetInformVBox/ArmorBar/ArmorLabel #宠物盔甲值
|
||
@onready var shield_bar: ProgressBar = $PetInformVBox/ShieldBar #宠物护盾值进度条
|
||
@onready var shield_label: Label = $PetInformVBox/ShieldBar/ShieldLabel #宠物护盾值
|
||
@onready var health_bar: ProgressBar = $PetInformVBox/HealthBar #宠物生命值进度条
|
||
@onready var health_label: Label = $PetInformVBox/HealthBar/HealthLabel #宠物生命值
|
||
@onready var volume_collision: CollisionShape2D = $VolumeCollision #宠物碰撞体积
|
||
|
||
|
||
#=====================宠物基本属性=====================
|
||
### 一、基础信息
|
||
#- 主人（主人名字）
|
||
#- 生日（年月日时分秒）
|
||
#- 年龄（从生日开始算
|
||
#- 性格（开朗，内向，活泼，安静，暴躁，温和，调皮，懒惰
|
||
#- 简介
|
||
#- 爱好
|
||
#- 宠物ID（唯一标识，从0000开始）
|
||
#- 宠物类型(宠物原本的名字，比如绿史莱姆，红史莱姆，迷你护卫，小绿人）
|
||
#- 宠物名称 （主人给宠物命名的名字）
|
||
#- 能否购买（true/false）
|
||
#- 购买价格（如果可以购买）
|
||
#- 出售价格（如果可以出售）
|
||
|
||
### 二、生存与防御
|
||
#- 生命值（可恢复，小于等于0则死亡）
|
||
#- 护盾值（不可恢复的生命值）
|
||
#- 护甲值（折扣伤害）
|
||
#- 生命恢复（恢复生命值,多少秒恢复多少生命值，如0.5秒恢复10点生命值）
|
||
#- 闪避率（免疫伤害概率）
|
||
#- 控制抗性（减免被控时长和概率）
|
||
#- 击退抗性（抵消击退力度）
|
||
#- 移动速度
|
||
|
||
### 三、攻击与效果
|
||
#- 普通攻击伤害
|
||
#- 普通攻击速度
|
||
#- 暴击率（暴击概率）
|
||
#- 暴击伤害
|
||
#- 护甲穿透（忽视敌人护甲）
|
||
#- 生命汲取（普攻回血%）
|
||
#- 击退（攻击使敌人后退）
|
||
|
||
### 四、其他属性
|
||
#- 元素属性（金木水火土，雷）
|
||
#- 等级（等级高属性强）
|
||
#- 经验值（满额升级）
|
||
#- 亲密度（额外加属性）
|
||
#- 品质（白/绿/蓝/橙/红/紫）
|
||
|
||
#近战
|
||
#近战攻击伤害
|
||
#近战攻击速度
|
||
|
||
#附录
|
||
#- 护甲公式示例：实际伤害 = 基础伤害 × (1 - 护甲值/(护甲值 + 100))，搭配"护甲穿透"可直接减少目标护甲值
|
||
#- 元素克制：火属性攻击对冰属性敌人造成150%伤害，同时被水属性克制（仅造成80%伤害）
|
||
#- 成长曲线：低级宠物升级快，高级宠物经验需求指数增长，避免养成周期过短
|
||
|
||
#特殊机制
|
||
#1.伤害反弹，无视防具穿透伤害，
|
||
#2.血量低于某个值进入狂暴模式，
|
||
#3.死亡后重生一次，
|
||
#4.毅力不倒、不死图腾(受到致命伤害抵挡并维持一滴血)
|
||
#5.援助 宠物血量低于某个值时，会自动召唤宠物仆从，宠物仆从会自动攻击敌人，唤数量（一次召唤多少个宠物仆从），唤间隔（多少秒召唤一次）
|
||
#=====================宠物基本属性=====================
|
||
|
||
|
||
# 宠物基本属性（从JSON配置文件加载）
|
||
var pet_owner: String = "树萌芽" # 宠物主人
|
||
var pet_name: String = "宠物名称" # 宠物名称
|
||
var pet_team: String = "team1" # 队伍标识：team1, team2, neutral
|
||
var pet_id: String = "0001" # 宠物唯一ID
|
||
var pet_type: String = "小绿人" # 宠物类型（原本名字）
|
||
var pet_birthday: String = "" # 生日（年月日时分秒）
|
||
var pet_age: int = 0 # 年龄（天数）
|
||
var pet_personality: String = "活泼" # 性格
|
||
var pet_introduction: String = "" # 简介
|
||
var pet_hobby: String = "" # 爱好
|
||
|
||
var pet_level: int = 1 # 宠物等级
|
||
var pet_experience: float = 0.0 # 当前经验值
|
||
var max_experience: float = 100.0 # 升级所需经验值
|
||
var pet_intimacy: float = 0.0 # 亲密度
|
||
var max_intimacy: float = 1000.0 # 最大亲密度
|
||
|
||
var can_buy: bool = true # 能否购买
|
||
var buy_price: int = 100 # 购买价格
|
||
var sell_price: int = 50 # 出售价格
|
||
|
||
# 生命与防御属性
|
||
var max_health: float = 100.0 # 最大生命值
|
||
var current_health: float = 100.0 # 当前生命值
|
||
var health_regen: float = 1.0 # 生命恢复速度（每秒）
|
||
var max_shield: float = 0.0 # 最大护盾值
|
||
var current_shield: float = 0.0 # 当前护盾值
|
||
var shield_regen: float = 0.0 # 护盾恢复速度（每秒）- 默认不恢复
|
||
var max_armor: float = 100.0 # 最大护甲值
|
||
var current_armor: float = 100.0 # 当前护甲值
|
||
|
||
# 攻击属性
|
||
var attack_type: AttackType = AttackType.RANGED # 攻击类型
|
||
var attack_damage: float = 20.0 # 基础攻击伤害
|
||
var attack_range: float = 400.0 # 攻击距离
|
||
var crit_rate: float = 0.1 # 暴击率（0.0-1.0）
|
||
var crit_damage: float = 1.5 # 暴击伤害倍数
|
||
var life_steal: float = 0.1 # 生命汲取（0.0-1.0）
|
||
var armor_penetration: float = 0.0 # 护甲穿透
|
||
|
||
var melee_damage_bonus: float = 0.0 # 近战额外伤害（在基础伤害上加成）
|
||
var melee_attack_speed: float = 1.0 # 近战攻击速度
|
||
|
||
var ranged_damage_bonus: float = 0.0 # 远程额外伤害（在基础伤害上加成）
|
||
var ranged_attack_speed: float = 1.0 # 远程攻击速度
|
||
var ranged_mode: RangedAttackMode = RangedAttackMode.SINGLE # 远程攻击模式
|
||
var projectile_speed: float = 300.0 # 子弹速度
|
||
|
||
var shotgun_bullets: int = 5 # 散弹数量
|
||
var shotgun_spread_angle: float = 45.0 # 散弹扩散角度(度)
|
||
|
||
var burst_rows: int = 2 # 多发射击行数
|
||
var burst_cols: int = 3 # 多发射击列数
|
||
var burst_spacing: float = 30.0 # 多发射击间距
|
||
|
||
var gatling_bullets: int = 8 # 加特林子弹数量
|
||
var gatling_interval: float = 0.1 # 加特林射击间隔
|
||
var gatling_cooldown: float = 2.0 # 加特林冷却时间
|
||
|
||
var pierce_count: int = 3 # 穿透数量
|
||
|
||
# 远程攻击类型枚举
|
||
enum AttackType {
|
||
MELEE, # 近战攻击
|
||
RANGED # 远程攻击
|
||
}
|
||
|
||
enum RangedAttackMode {
|
||
SINGLE, # 普通单发
|
||
SHOTGUN, # 散弹攻击
|
||
BURST, # 多发射击(平行)
|
||
GATLING, # 加特林式连射
|
||
PIERCING # 穿透攻击
|
||
}
|
||
|
||
|
||
var attack_speed: float = 1.0 # 当前攻击速度（根据攻击类型动态设置）
|
||
var gatling_firing: bool = false # 是否正在加特林射击
|
||
var gatling_current_bullet: int = 0 # 当前加特林子弹计数
|
||
var gatling_last_shot: float = 0.0 # 上次加特林射击时间
|
||
|
||
@export var projectile_scene: PackedScene = preload("res://Scene/Pet/Projectile.tscn") # 子弹场景
|
||
|
||
# 移动与闪避属性
|
||
var move_speed: float = 100.0 # 移动速度
|
||
var dodge_rate: float = 0.05 # 闪避率（0.0-1.0）
|
||
var knockback_force: float = 300.0 # 击退力度
|
||
var knockback_resist: float = 0.0 # 击退抗性（0.0-1.0）
|
||
|
||
# 元素属性
|
||
enum ElementType {
|
||
NONE, # 无属性
|
||
METAL, # 金
|
||
WOOD, # 木
|
||
WATER, # 水
|
||
FIRE, # 火
|
||
EARTH, # 土
|
||
THUNDER # 雷
|
||
}
|
||
var element_type: ElementType = ElementType.NONE# 宠物元素属性
|
||
var element_damage_bonus: float = 50.0 # 元素克制额外伤害
|
||
|
||
var control_resist: float = 0.0 # 控制抗性（减少眩晕等控制时间）
|
||
var damage_reflect: float = 0.0 # 伤害反弹（0.0-1.0）
|
||
var death_immunity: bool = false # 死亡免疫（一次性）
|
||
var berserker_threshold: float = 0.3 # 狂暴阈值（血量低于此值时触发狂暴）
|
||
var berserker_bonus: float = 1.5 # 狂暴状态伤害倍数
|
||
|
||
# 特殊机制开关（布尔值控制是否启用各种特殊机制）
|
||
var enable_damage_reflect: bool = false # 启用伤害反弹机制
|
||
var enable_berserker_mode: bool = false # 启用狂暴模式机制
|
||
var enable_death_immunity: bool = false # 启用死亡免疫机制
|
||
var enable_aid_system: bool = false # 启用援助召唤机制
|
||
var enable_resurrection: bool = false # 启用死亡重生机制
|
||
var resurrection_used: bool = false # 重生是否已使用
|
||
|
||
# 援助系统属性
|
||
var aid_threshold: float = 0.2 # 援助触发阈值（血量低于此值时召唤援助）
|
||
var aid_summon_count: int = 2 # 一次召唤的援助数量
|
||
var aid_summon_interval: float = 5.0 # 援助召唤间隔（秒）
|
||
var aid_last_summon_time: float = 0.0 # 上次召唤援助的时间
|
||
var aid_summoned: bool = false # 是否已经召唤过援助（防止重复召唤）
|
||
var aid_minions: Array[CharacterBody2D] = [] # 召唤的援助宠物列表
|
||
|
||
# 品质系统
|
||
enum PetQuality {
|
||
COMMON, # 普通（白）
|
||
UNCOMMON, # 不凡（绿）
|
||
RARE, # 稀有（蓝）
|
||
EPIC, # 史诗（紫）
|
||
LEGENDARY, # 传说（橙）
|
||
MYTHIC # 神话（红）
|
||
}
|
||
var pet_quality: PetQuality = PetQuality.COMMON # 宠物品质
|
||
|
||
# 战斗状态
|
||
var is_alive: bool = true # 是否存活
|
||
var is_dying: bool = false # 是否正在死亡过程中（防止重复调用die()）
|
||
var is_attacking: bool = false # 是否正在攻击
|
||
var is_berserker: bool = false # 是否处于狂暴状态
|
||
var is_stunned: bool = false # 是否被眩晕
|
||
var is_invulnerable: bool = false # 是否无敌
|
||
var current_target: CharacterBody2D = null # 当前目标
|
||
var last_attacker: CharacterBody2D = null # 最后攻击者（用于击杀奖励）
|
||
var last_attack_time: float = 0.0 # 上次攻击时间
|
||
var last_regen_time: float = 0.0 # 上次恢复时间
|
||
var last_target_check_time: float = 0.0 # 上次目标检查时间
|
||
|
||
# 受伤动画相关
|
||
var hurt_tween: Tween = null # 受伤动画缓动
|
||
var original_modulate: Color = Color.WHITE # 原始颜色
|
||
var last_hurt_time: float = 0.0 # 上次受伤时间（防止受伤动画过于频繁）
|
||
var hurt_animation_cooldown: float = 0.3 # 受伤动画冷却时间
|
||
|
||
# 攻击频率控制
|
||
var min_attack_interval: float = 0.5 # 最小攻击间隔（防止攻击过于频繁）
|
||
|
||
# 伤害反弹保护
|
||
var damage_reflect_depth: int = 0 # 伤害反弹递归深度
|
||
var max_reflect_depth: int = 3 # 最大反弹深度（防止无限递归）
|
||
|
||
# 性能保护
|
||
var performance_mode: bool = false # 性能模式（减少特效和计算）
|
||
var frame_skip_counter: int = 0 # 帧跳跃计数器
|
||
|
||
# 升级系统 - 基础属性列表（每次升级随机选择加点）
|
||
var base_upgrade_attributes: Array[String] = [
|
||
"max_health", # 最大生命值
|
||
"attack_damage", # 攻击伤害
|
||
"move_speed", # 移动速度
|
||
"max_shield", # 最大护盾值
|
||
"max_armor", # 最大护甲值
|
||
"crit_rate", # 暴击率
|
||
"health_regen", # 生命恢复
|
||
"attack_range" # 攻击距离
|
||
]
|
||
|
||
# 每次升级随机选择的属性数量
|
||
var attributes_per_level: int = 3
|
||
|
||
# 每5级额外属性奖励表
|
||
var level_milestone_bonuses: Dictionary = {
|
||
5: {"max_health": 20, "attack_damage": 5, "crit_rate": 0.02},
|
||
10: {"max_shield": 30, "armor_penetration": 5, "life_steal": 0.05},
|
||
15: {"max_armor": 25, "knockback_resist": 0.1, "dodge_rate": 0.03},
|
||
20: {"health_regen": 2, "move_speed": 15, "attack_range": 30},
|
||
25: {"max_health": 40, "attack_damage": 10, "enable_berserker_mode": true},
|
||
30: {"max_shield": 50, "shield_regen": 1, "enable_damage_reflect": true},
|
||
35: {"crit_damage": 0.3, "berserker_bonus": 0.2, "damage_reflect": 0.05},
|
||
40: {"max_armor": 40, "control_resist": 0.15, "enable_aid_system": true},
|
||
45: {"projectile_speed": 50, "pierce_count": 1, "enable_death_immunity": true},
|
||
50: {"max_health": 100, "attack_damage": 25, "enable_resurrection": true}
|
||
}
|
||
|
||
# 巡逻状态
|
||
var is_patrolling: bool = false # 是否正在巡逻
|
||
var patrol_path: PackedVector2Array = [] # 巡逻路径点
|
||
var patrol_speed: float = 80.0 # 巡逻移动速度
|
||
var current_patrol_index: int = 0 # 当前巡逻目标点索引
|
||
var patrol_wait_time: float = 0.0 # 在巡逻点等待的时间
|
||
var patrol_max_wait_time: float = 1.0 # 在巡逻点的最大等待时间
|
||
|
||
# 战斗控制
|
||
var combat_enabled: bool = true # 是否启用战斗行为
|
||
|
||
# AI状态
|
||
enum PetState {
|
||
IDLE, #站立空闲
|
||
MOVING_TO_TARGET, #移动到目标
|
||
ATTACKING, #攻击
|
||
PATROLLING, #巡逻
|
||
DEAD #死亡
|
||
}
|
||
var current_state: PetState = PetState.IDLE # 当前状态
|
||
|
||
# 队伍节点引用
|
||
var team_nodes: Dictionary = {}
|
||
|
||
# 从JSON配置文件加载宠物配置（强制要求）
|
||
func load_pet_config_from_json():
|
||
var file = FileAccess.open("res://Data/pet_data.json", FileAccess.READ)
|
||
if not file:
|
||
set_basic_default_values()
|
||
return
|
||
|
||
var json_string = file.get_as_text()
|
||
file.close()
|
||
|
||
var json = JSON.new()
|
||
var parse_result = json.parse(json_string)
|
||
if parse_result != OK:
|
||
set_basic_default_values()
|
||
return
|
||
|
||
var pet_configs = json.data
|
||
var pet_name_key = get_pet_name_key()
|
||
|
||
if not pet_configs.has(pet_name_key):
|
||
set_basic_default_values()
|
||
return
|
||
|
||
var config = pet_configs[pet_name_key]
|
||
apply_json_config(config)
|
||
|
||
# 设置基本默认值（当JSON加载失败时使用）
|
||
func set_basic_default_values():
|
||
# 基本信息
|
||
pet_owner = "未知主人"
|
||
pet_name = "未配置宠物"
|
||
pet_team = "team1"
|
||
pet_id = "0000"
|
||
pet_type = "未知类型"
|
||
pet_birthday = ""
|
||
pet_age = 0
|
||
pet_personality = "活泼"
|
||
pet_introduction = ""
|
||
pet_hobby = ""
|
||
|
||
# 等级经验
|
||
pet_level = 1
|
||
pet_experience = 0.0
|
||
max_experience = 100.0
|
||
pet_intimacy = 0.0
|
||
max_intimacy = 1000.0
|
||
|
||
# 购买信息
|
||
can_buy = true
|
||
buy_price = 100
|
||
sell_price = 50
|
||
|
||
# 生命与防御
|
||
max_health = 100.0
|
||
current_health = 100.0
|
||
health_regen = 1.0
|
||
max_shield = 0.0
|
||
current_shield = 0.0
|
||
shield_regen = 0.0
|
||
max_armor = 100.0
|
||
current_armor = 100.0
|
||
|
||
# 基础攻击属性
|
||
attack_type = AttackType.RANGED
|
||
attack_damage = 20.0
|
||
attack_range = 300.0
|
||
crit_rate = 0.1
|
||
crit_damage = 1.5
|
||
life_steal = 0.1
|
||
armor_penetration = 0.0
|
||
|
||
# 近战攻击
|
||
melee_damage_bonus = 0.0
|
||
melee_attack_speed = 1.0
|
||
|
||
# 远程攻击
|
||
ranged_damage_bonus = 0.0
|
||
ranged_attack_speed = 1.0
|
||
ranged_mode = RangedAttackMode.SINGLE
|
||
projectile_speed = 300.0
|
||
|
||
# 散弹攻击
|
||
shotgun_bullets = 5
|
||
shotgun_spread_angle = 45.0
|
||
|
||
# 多发射击
|
||
burst_rows = 2
|
||
burst_cols = 3
|
||
burst_spacing = 30.0
|
||
|
||
# 加特林属性
|
||
gatling_bullets = 8
|
||
gatling_interval = 0.1
|
||
gatling_cooldown = 2.0
|
||
|
||
# 穿透属性
|
||
pierce_count = 3
|
||
|
||
# 移动与闪避
|
||
move_speed = 100.0
|
||
dodge_rate = 0.05
|
||
knockback_force = 300.0
|
||
knockback_resist = 0.0
|
||
|
||
# 元素属性
|
||
element_type = ElementType.NONE
|
||
element_damage_bonus = 50.0
|
||
|
||
# 特殊属性
|
||
control_resist = 0.0
|
||
damage_reflect = 0.0
|
||
death_immunity = false
|
||
berserker_threshold = 0.3
|
||
berserker_bonus = 1.5
|
||
|
||
# 特殊机制开关
|
||
enable_damage_reflect = false
|
||
enable_berserker_mode = false
|
||
enable_death_immunity = false
|
||
enable_aid_system = false
|
||
enable_resurrection = false
|
||
|
||
# 援助系统
|
||
aid_threshold = 0.2
|
||
aid_summon_count = 2
|
||
aid_summon_interval = 5.0
|
||
|
||
# 品质系统
|
||
pet_quality = PetQuality.COMMON
|
||
|
||
# 获取宠物名称键（用于JSON配置查找）
|
||
func get_pet_name_key() -> String:
|
||
# 直接返回宠物类型作为JSON键
|
||
# 现在pet_type已经是正确的JSON键名了
|
||
return pet_type
|
||
|
||
# 应用JSON配置到宠物属性
|
||
func apply_json_config(config: Dictionary):
|
||
# 基本信息
|
||
if config.has("基本信息"):
|
||
var basic_info = config["基本信息"]
|
||
if basic_info.has("宠物主人"):
|
||
pet_owner = basic_info["宠物主人"]
|
||
if basic_info.has("宠物名称"):
|
||
pet_name = basic_info["宠物名称"]
|
||
if basic_info.has("队伍标识"):
|
||
pet_team = basic_info["队伍标识"]
|
||
if basic_info.has("宠物ID"):
|
||
pet_id = basic_info["宠物ID"]
|
||
if basic_info.has("宠物类型"):
|
||
pet_type = basic_info["宠物类型"]
|
||
if basic_info.has("生日"):
|
||
pet_birthday = basic_info["生日"]
|
||
if basic_info.has("年龄"):
|
||
pet_age = basic_info["年龄"]
|
||
if basic_info.has("性格"):
|
||
pet_personality = basic_info["性格"]
|
||
if basic_info.has("简介"):
|
||
pet_introduction = basic_info["简介"]
|
||
if basic_info.has("爱好"):
|
||
pet_hobby = basic_info["爱好"]
|
||
|
||
# 等级经验
|
||
if config.has("等级经验"):
|
||
var level_exp = config["等级经验"]
|
||
if level_exp.has("宠物等级"):
|
||
pet_level = level_exp["宠物等级"]
|
||
if level_exp.has("当前经验"):
|
||
pet_experience = level_exp["当前经验"]
|
||
if level_exp.has("最大经验"):
|
||
max_experience = level_exp["最大经验"]
|
||
if level_exp.has("亲密度"):
|
||
pet_intimacy = level_exp["亲密度"]
|
||
if level_exp.has("最大亲密度"):
|
||
max_intimacy = level_exp["最大亲密度"]
|
||
|
||
# 购买信息
|
||
if config.has("购买信息"):
|
||
var buy_info = config["购买信息"]
|
||
if buy_info.has("能否购买"):
|
||
can_buy = buy_info["能否购买"]
|
||
if buy_info.has("购买价格"):
|
||
buy_price = buy_info["购买价格"]
|
||
if buy_info.has("出售价格"):
|
||
sell_price = buy_info["出售价格"]
|
||
|
||
# 生命与防御
|
||
if config.has("生命与防御"):
|
||
var health_defense = config["生命与防御"]
|
||
if health_defense.has("最大生命值"):
|
||
max_health = health_defense["最大生命值"]
|
||
if health_defense.has("当前生命值"):
|
||
current_health = health_defense["当前生命值"]
|
||
if health_defense.has("生命恢复速度"):
|
||
health_regen = health_defense["生命恢复速度"]
|
||
if health_defense.has("最大护盾值"):
|
||
max_shield = health_defense["最大护盾值"]
|
||
if health_defense.has("当前护盾值"):
|
||
current_shield = health_defense["当前护盾值"]
|
||
if health_defense.has("护盾恢复速度"):
|
||
shield_regen = health_defense["护盾恢复速度"]
|
||
if health_defense.has("最大护甲值"):
|
||
max_armor = health_defense["最大护甲值"]
|
||
if health_defense.has("当前护甲值"):
|
||
current_armor = health_defense["当前护甲值"]
|
||
|
||
# 基础攻击属性
|
||
if config.has("基础攻击属性"):
|
||
var attack_attr = config["基础攻击属性"]
|
||
if attack_attr.has("攻击类型"):
|
||
var attack_type_str = attack_attr["攻击类型"]
|
||
if attack_type_str == "MELEE":
|
||
attack_type = AttackType.MELEE
|
||
elif attack_type_str == "RANGED":
|
||
attack_type = AttackType.RANGED
|
||
if attack_attr.has("基础攻击伤害"):
|
||
attack_damage = attack_attr["基础攻击伤害"]
|
||
if attack_attr.has("攻击距离"):
|
||
attack_range = attack_attr["攻击距离"]
|
||
if attack_attr.has("暴击率"):
|
||
crit_rate = attack_attr["暴击率"]
|
||
if attack_attr.has("暴击伤害倍数"):
|
||
crit_damage = attack_attr["暴击伤害倍数"]
|
||
if attack_attr.has("生命汲取"):
|
||
life_steal = attack_attr["生命汲取"]
|
||
if attack_attr.has("护甲穿透"):
|
||
armor_penetration = attack_attr["护甲穿透"]
|
||
|
||
# 近战攻击
|
||
if config.has("近战攻击"):
|
||
var melee_attack = config["近战攻击"]
|
||
if melee_attack.has("近战额外伤害"):
|
||
melee_damage_bonus = melee_attack["近战额外伤害"]
|
||
if melee_attack.has("近战攻击速度"):
|
||
melee_attack_speed = melee_attack["近战攻击速度"]
|
||
|
||
# 远程攻击
|
||
if config.has("远程攻击"):
|
||
var ranged_attack = config["远程攻击"]
|
||
if ranged_attack.has("远程额外伤害"):
|
||
ranged_damage_bonus = ranged_attack["远程额外伤害"]
|
||
if ranged_attack.has("远程攻击速度"):
|
||
ranged_attack_speed = ranged_attack["远程攻击速度"]
|
||
if ranged_attack.has("远程攻击模式"):
|
||
var ranged_mode_str = ranged_attack["远程攻击模式"]
|
||
match ranged_mode_str:
|
||
"SINGLE":
|
||
ranged_mode = RangedAttackMode.SINGLE
|
||
"SHOTGUN":
|
||
ranged_mode = RangedAttackMode.SHOTGUN
|
||
"BURST":
|
||
ranged_mode = RangedAttackMode.BURST
|
||
"GATLING":
|
||
ranged_mode = RangedAttackMode.GATLING
|
||
"PIERCING":
|
||
ranged_mode = RangedAttackMode.PIERCING
|
||
if ranged_attack.has("子弹速度"):
|
||
projectile_speed = ranged_attack["子弹速度"]
|
||
|
||
# 散弹攻击
|
||
if config.has("散弹攻击"):
|
||
var shotgun_attack = config["散弹攻击"]
|
||
if shotgun_attack.has("散弹数量"):
|
||
shotgun_bullets = shotgun_attack["散弹数量"]
|
||
if shotgun_attack.has("散弹扩散角度"):
|
||
shotgun_spread_angle = shotgun_attack["散弹扩散角度"]
|
||
|
||
# 多发射击
|
||
if config.has("多发射击"):
|
||
var burst_attack = config["多发射击"]
|
||
if burst_attack.has("多发射击行数"):
|
||
burst_rows = burst_attack["多发射击行数"]
|
||
if burst_attack.has("多发射击列数"):
|
||
burst_cols = burst_attack["多发射击列数"]
|
||
if burst_attack.has("多发射击间距"):
|
||
burst_spacing = burst_attack["多发射击间距"]
|
||
|
||
# 加特林属性
|
||
if config.has("加特林属性"):
|
||
var gatling_attr = config["加特林属性"]
|
||
if gatling_attr.has("加特林子弹数量"):
|
||
gatling_bullets = gatling_attr["加特林子弹数量"]
|
||
if gatling_attr.has("加特林射击间隔"):
|
||
gatling_interval = gatling_attr["加特林射击间隔"]
|
||
if gatling_attr.has("加特林冷却时间"):
|
||
gatling_cooldown = gatling_attr["加特林冷却时间"]
|
||
|
||
# 穿透属性
|
||
if config.has("穿透属性"):
|
||
var pierce_attr = config["穿透属性"]
|
||
if pierce_attr.has("穿透数量"):
|
||
pierce_count = pierce_attr["穿透数量"]
|
||
|
||
# 移动与闪避
|
||
if config.has("移动与闪避"):
|
||
var move_dodge = config["移动与闪避"]
|
||
if move_dodge.has("移动速度"):
|
||
move_speed = move_dodge["移动速度"]
|
||
if move_dodge.has("闪避率"):
|
||
dodge_rate = move_dodge["闪避率"]
|
||
if move_dodge.has("击退力度"):
|
||
knockback_force = move_dodge["击退力度"]
|
||
if move_dodge.has("击退抗性"):
|
||
knockback_resist = move_dodge["击退抗性"]
|
||
|
||
# 元素属性
|
||
if config.has("元素属性"):
|
||
var element_attr = config["元素属性"]
|
||
if element_attr.has("元素类型"):
|
||
var element_type_str = element_attr["元素类型"]
|
||
match element_type_str:
|
||
"NONE":
|
||
element_type = ElementType.NONE
|
||
"METAL":
|
||
element_type = ElementType.METAL
|
||
"WOOD":
|
||
element_type = ElementType.WOOD
|
||
"WATER":
|
||
element_type = ElementType.WATER
|
||
"FIRE":
|
||
element_type = ElementType.FIRE
|
||
"EARTH":
|
||
element_type = ElementType.EARTH
|
||
"THUNDER":
|
||
element_type = ElementType.THUNDER
|
||
if element_attr.has("元素克制额外伤害"):
|
||
element_damage_bonus = element_attr["元素克制额外伤害"]
|
||
|
||
# 特殊属性
|
||
if config.has("特殊属性"):
|
||
var special_attr = config["特殊属性"]
|
||
if special_attr.has("控制抗性"):
|
||
control_resist = special_attr["控制抗性"]
|
||
if special_attr.has("伤害反弹"):
|
||
damage_reflect = special_attr["伤害反弹"]
|
||
if special_attr.has("死亡免疫"):
|
||
death_immunity = special_attr["死亡免疫"]
|
||
if special_attr.has("狂暴阈值"):
|
||
berserker_threshold = special_attr["狂暴阈值"]
|
||
if special_attr.has("狂暴状态伤害倍数"):
|
||
berserker_bonus = special_attr["狂暴状态伤害倍数"]
|
||
|
||
# 特殊机制开关
|
||
if config.has("特殊机制开关"):
|
||
var special_toggle = config["特殊机制开关"]
|
||
if special_toggle.has("启用伤害反弹机制"):
|
||
enable_damage_reflect = special_toggle["启用伤害反弹机制"]
|
||
if special_toggle.has("启用狂暴模式机制"):
|
||
enable_berserker_mode = special_toggle["启用狂暴模式机制"]
|
||
if special_toggle.has("启用死亡免疫机制"):
|
||
enable_death_immunity = special_toggle["启用死亡免疫机制"]
|
||
if special_toggle.has("启用援助召唤机制"):
|
||
enable_aid_system = special_toggle["启用援助召唤机制"]
|
||
if special_toggle.has("启用死亡重生机制"):
|
||
enable_resurrection = special_toggle["启用死亡重生机制"]
|
||
|
||
# 援助系统
|
||
if config.has("援助系统"):
|
||
var aid_system = config["援助系统"]
|
||
if aid_system.has("援助触发阈值"):
|
||
aid_threshold = aid_system["援助触发阈值"]
|
||
if aid_system.has("援助召唤数量"):
|
||
aid_summon_count = aid_system["援助召唤数量"]
|
||
if aid_system.has("援助召唤间隔"):
|
||
aid_summon_interval = aid_system["援助召唤间隔"]
|
||
|
||
# 品质系统
|
||
if config.has("品质系统"):
|
||
var quality_system = config["品质系统"]
|
||
if quality_system.has("宠物品质"):
|
||
var quality_str = quality_system["宠物品质"]
|
||
match quality_str:
|
||
"COMMON":
|
||
pet_quality = PetQuality.COMMON
|
||
"UNCOMMON":
|
||
pet_quality = PetQuality.UNCOMMON
|
||
"RARE":
|
||
pet_quality = PetQuality.RARE
|
||
"EPIC":
|
||
pet_quality = PetQuality.EPIC
|
||
"LEGENDARY":
|
||
pet_quality = PetQuality.LEGENDARY
|
||
"MYTHIC":
|
||
pet_quality = PetQuality.MYTHIC
|
||
|
||
|
||
|
||
func _ready():
|
||
# 初始化生日
|
||
initialize_birthday()
|
||
|
||
# 保存原始颜色
|
||
if pet_image:
|
||
original_modulate = pet_image.modulate
|
||
|
||
# 延迟初始化UI显示，确保所有节点都已准备好
|
||
call_deferred("update_ui")
|
||
|
||
# 设置初始动画为空闲状态
|
||
if pet_image:
|
||
pet_image.animation = "idle"
|
||
|
||
# 获取队伍节点引用
|
||
call_deferred("setup_team_references")
|
||
|
||
# 延迟设置碰撞层，确保队伍信息已设置
|
||
call_deferred("setup_collision_layers")
|
||
|
||
# 设置宠物类型并加载对应配置
|
||
func set_pet_type_and_load_config(pet_type_name: String):
|
||
pet_type = pet_type_name
|
||
load_pet_config_from_json()
|
||
|
||
# 设置队伍节点引用
|
||
func setup_team_references():
|
||
var battle_panel = get_parent()
|
||
while battle_panel and not battle_panel.has_method("get_team_node"):
|
||
battle_panel = battle_panel.get_parent()
|
||
|
||
if battle_panel:
|
||
team_nodes["team1"] = battle_panel.get_node_or_null("team1")
|
||
team_nodes["team2"] = battle_panel.get_node_or_null("team2")
|
||
team_nodes["neutral"] = battle_panel.get_node_or_null("neutral")
|
||
|
||
# 设置碰撞层，让队友之间不碰撞
|
||
func setup_collision_layers():
|
||
# 简化的碰撞层设计：
|
||
# 第1位（值1）：team1宠物
|
||
# 第2位（值2）：team2宠物
|
||
# 第3位（值4）：中立宠物
|
||
|
||
match pet_team:
|
||
"team1":
|
||
collision_layer = 1 # 第1位
|
||
collision_mask = 2 # 只检测team2
|
||
"team2":
|
||
collision_layer = 2 # 第2位
|
||
collision_mask = 1 # 只检测team1
|
||
"neutral":
|
||
collision_layer = 4 # 第3位
|
||
collision_mask = 3 # 检测team1和team2
|
||
_:
|
||
# 默认设置为team1
|
||
collision_layer = 1
|
||
collision_mask = 2
|
||
|
||
#限制宠物在战斗区域内
|
||
func clamp_to_battle_area():
|
||
var battle_area_min = Vector2(0,0)
|
||
var battle_area_max = Vector2(1400, 720)
|
||
|
||
# 限制位置
|
||
global_position.x = clamp(global_position.x, battle_area_min.x, battle_area_max.x)
|
||
global_position.y = clamp(global_position.y, battle_area_min.y, battle_area_max.y)
|
||
|
||
#宠物物理更新（带性能保护）
|
||
func _physics_process(delta):
|
||
if not is_alive or is_dying:
|
||
return
|
||
|
||
# 性能保护：每3帧执行一次非关键逻辑
|
||
frame_skip_counter += 1
|
||
var should_skip_frame = performance_mode and (frame_skip_counter % 3 != 0)
|
||
|
||
# 检测性能问题（如果帧时间过长，自动启用性能模式）
|
||
if delta > 0.025: # 帧时间超过25ms（低于40FPS）
|
||
if not performance_mode:
|
||
performance_mode = true
|
||
print("⚡ " + pet_name + " 启用性能模式（帧时间: " + str("%.3f" % delta) + "s）")
|
||
|
||
# 巡逻宠物特殊处理
|
||
if is_patrolling:
|
||
handle_patrol(delta)
|
||
return
|
||
|
||
# 处理生命和护盾恢复
|
||
if not should_skip_frame:
|
||
handle_regeneration(delta)
|
||
|
||
# 更新年龄和亲密度（低优先级，可跳帧）
|
||
if not should_skip_frame:
|
||
update_age_and_intimacy(delta)
|
||
|
||
# 检查狂暴状态
|
||
if not should_skip_frame:
|
||
check_berserker_mode()
|
||
|
||
# 检查援助系统（低优先级，可跳帧）
|
||
if not should_skip_frame:
|
||
check_aid_system()
|
||
|
||
# 如果被眩晕则不能行动
|
||
if is_stunned:
|
||
return
|
||
|
||
# 定期检查目标状态（性能模式下降低检查频率）
|
||
var current_time = Time.get_ticks_msec() / 1000.0
|
||
var check_interval = 0.5 if not performance_mode else 1.0
|
||
if current_time - last_target_check_time >= check_interval:
|
||
check_target_validity()
|
||
last_target_check_time = current_time
|
||
|
||
# 更新AI状态机
|
||
update_ai_state(delta)
|
||
|
||
# 处理移动
|
||
handle_movement(delta)
|
||
|
||
# 处理攻击
|
||
handle_attack(delta)
|
||
|
||
# 应用移动
|
||
move_and_slide()
|
||
|
||
# 限制在战斗区域内
|
||
clamp_to_battle_area()
|
||
|
||
#宠物AI状态机
|
||
func update_ai_state(delta):
|
||
match current_state:
|
||
PetState.IDLE:
|
||
# 播放空闲动画
|
||
if pet_image.animation != "idle":
|
||
pet_image.animation = "idle"
|
||
|
||
# 只有启用战斗时才寻找敌人
|
||
if combat_enabled:
|
||
find_nearest_enemy()
|
||
if current_target and is_instance_valid(current_target):
|
||
current_state = PetState.MOVING_TO_TARGET
|
||
|
||
PetState.MOVING_TO_TARGET:
|
||
# 播放行走动画
|
||
if pet_image.animation != "walk":
|
||
pet_image.animation = "walk"
|
||
|
||
if not current_target or not is_instance_valid(current_target):
|
||
current_state = PetState.IDLE
|
||
else:
|
||
var distance_to_target = global_position.distance_to(current_target.global_position)
|
||
if distance_to_target <= attack_range:
|
||
# 进入攻击范围开始攻击
|
||
current_state = PetState.ATTACKING
|
||
|
||
PetState.ATTACKING:
|
||
# 攻击时播放空闲动画（或者你可以添加攻击动画）
|
||
if pet_image.animation != "idle":
|
||
pet_image.animation = "idle"
|
||
|
||
if not current_target or not is_instance_valid(current_target):
|
||
current_state = PetState.IDLE
|
||
else:
|
||
var distance_to_target = global_position.distance_to(current_target.global_position)
|
||
if distance_to_target > attack_range * 1.2:
|
||
# 目标超出射程，继续追击
|
||
current_state = PetState.MOVING_TO_TARGET
|
||
|
||
#宠物移动
|
||
func handle_movement(delta):
|
||
if current_state == PetState.MOVING_TO_TARGET and current_target:
|
||
var distance_to_target = global_position.distance_to(current_target.global_position)
|
||
var direction = (current_target.global_position - global_position).normalized()
|
||
|
||
# 根据攻击类型调整移动策略
|
||
if attack_type == AttackType.MELEE:
|
||
# 近战：直接冲向目标
|
||
velocity = direction * move_speed
|
||
else:
|
||
# 远程：保持适当距离
|
||
var optimal_distance = attack_range * 0.8 # 保持在80%射程距离
|
||
if distance_to_target > optimal_distance:
|
||
# 太远了，靠近一点
|
||
velocity = direction * move_speed
|
||
elif distance_to_target < optimal_distance * 0.6:
|
||
# 太近了，后退一点
|
||
velocity = -direction * move_speed * 0.5
|
||
else:
|
||
# 距离合适，停止移动
|
||
velocity = Vector2.ZERO
|
||
|
||
# 翻转精灵朝向
|
||
if direction.x < 0:
|
||
pet_image.flip_h = false
|
||
pet_tool_image.flip_h = true
|
||
pet_tool_image.position.x = -10
|
||
elif direction.x > 0:
|
||
pet_image.flip_h = true
|
||
pet_tool_image.flip_h = false
|
||
pet_tool_image.position.x = 10
|
||
else:
|
||
velocity = Vector2.ZERO
|
||
|
||
#宠物攻击（带频率保护）
|
||
func handle_attack(delta):
|
||
if current_state == PetState.ATTACKING and current_target:
|
||
var current_time = Time.get_ticks_msec() / 1000.0 # 转换为秒
|
||
|
||
# 处理加特林连射
|
||
if ranged_mode == RangedAttackMode.GATLING:
|
||
handle_gatling_attack(current_time, delta)
|
||
else:
|
||
# 普通攻击频率控制（确保最小攻击间隔）
|
||
var attack_interval = max(1.0 / attack_speed, min_attack_interval)
|
||
if current_time - last_attack_time >= attack_interval:
|
||
perform_attack(current_target)
|
||
last_attack_time = current_time
|
||
|
||
# 处理加特林攻击
|
||
func handle_gatling_attack(current_time: float, delta: float):
|
||
if gatling_firing:
|
||
# 正在连射
|
||
if current_time - gatling_last_shot >= gatling_interval:
|
||
fire_projectile_by_mode(current_target)
|
||
gatling_current_bullet += 1
|
||
gatling_last_shot = current_time
|
||
|
||
if gatling_current_bullet >= gatling_bullets:
|
||
# 连射完毕，进入冷却
|
||
gatling_firing = false
|
||
gatling_current_bullet = 0
|
||
last_attack_time = current_time + gatling_cooldown
|
||
print(pet_name + " 加特林连射完毕，进入冷却")
|
||
else:
|
||
# 检查是否可以开始新的连射
|
||
if current_time - last_attack_time >= 1.0 / attack_speed:
|
||
gatling_firing = true
|
||
gatling_current_bullet = 0
|
||
gatling_last_shot = current_time - gatling_interval # 立即开始第一发
|
||
print(pet_name + " 开始加特林连射!")
|
||
|
||
#寻找最近的敌人
|
||
func find_nearest_enemy():
|
||
var nearest_enemy: CharacterBody2D = null
|
||
var nearest_distance: float = INF
|
||
|
||
# 获取所有存活的敌方宠物
|
||
var all_enemies: Array[CharacterBody2D] = []
|
||
|
||
# 直接从pets组中查找敌人（更可靠的方法）
|
||
var all_pets = get_tree().get_nodes_in_group("pets")
|
||
for pet in all_pets:
|
||
if not is_instance_valid(pet) or pet == self or not pet.is_alive:
|
||
continue
|
||
|
||
# 检查是否为敌人
|
||
if pet.has_method("get_team") and pet.get_team() != pet_team:
|
||
all_enemies.append(pet)
|
||
|
||
# 如果没有敌人，清除目标
|
||
if all_enemies.is_empty():
|
||
if current_target:
|
||
current_target = null
|
||
return
|
||
|
||
# 寻找最近的敌人
|
||
for enemy in all_enemies:
|
||
var distance = global_position.distance_to(enemy.global_position)
|
||
if distance < nearest_distance:
|
||
nearest_distance = distance
|
||
nearest_enemy = enemy
|
||
|
||
# 更新目标（只有在没有目标或目标已死亡时才更换）
|
||
if not current_target or not is_instance_valid(current_target) or not current_target.is_alive:
|
||
if nearest_enemy != current_target:
|
||
current_target = nearest_enemy
|
||
|
||
# 检查目标有效性
|
||
func check_target_validity():
|
||
if current_target:
|
||
# 检查目标是否还存活且有效
|
||
if not is_instance_valid(current_target) or not current_target.is_alive:
|
||
current_target = null
|
||
current_state = PetState.IDLE
|
||
# 检查目标是否还是敌人（防止队伍变更等情况）
|
||
elif current_target.get_team() == pet_team:
|
||
current_target = null
|
||
current_state = PetState.IDLE
|
||
|
||
#宠物攻击
|
||
func perform_attack(target: CharacterBody2D):
|
||
if not target or not is_instance_valid(target) or not target.is_alive:
|
||
# 目标无效或已死亡，重新寻找目标
|
||
current_target = null
|
||
current_state = PetState.IDLE
|
||
return
|
||
|
||
# 根据攻击类型执行不同的攻击方式
|
||
if attack_type == AttackType.MELEE:
|
||
perform_melee_attack(target)
|
||
else:
|
||
fire_projectile_by_mode(target)
|
||
|
||
# 执行近战攻击
|
||
func perform_melee_attack(target: CharacterBody2D):
|
||
# 计算基础伤害 + 近战额外伤害
|
||
var damage = attack_damage + melee_damage_bonus
|
||
|
||
# 狂暴状态加成
|
||
if is_berserker:
|
||
damage *= berserker_bonus
|
||
|
||
# 护甲穿透计算
|
||
var final_armor_penetration = armor_penetration
|
||
|
||
# 暴击计算
|
||
var is_critical = randf() < crit_rate
|
||
if is_critical:
|
||
damage *= crit_damage
|
||
|
||
# 添加战斗细节
|
||
add_battle_detail_to_panel("⚔️ " + pet_name + " 对 " + target.pet_name + " 造成近战攻击 " + str(int(damage)) + " 点伤害" + ("（暴击）" if is_critical else ""))
|
||
|
||
# 对目标造成伤害
|
||
target.take_damage(damage, final_armor_penetration, element_type, self)
|
||
|
||
# 生命汲取
|
||
if life_steal > 0:
|
||
var heal_amount = damage * life_steal
|
||
heal(heal_amount)
|
||
|
||
# 击退效果已禁用
|
||
# if knockback_force > 0:
|
||
# apply_knockback_to_target(target)
|
||
|
||
# 根据攻击模式发射子弹
|
||
func fire_projectile_by_mode(target: CharacterBody2D):
|
||
# 计算基础伤害 + 远程额外伤害
|
||
var damage = attack_damage + ranged_damage_bonus
|
||
|
||
# 狂暴状态加成
|
||
if is_berserker:
|
||
damage *= berserker_bonus
|
||
|
||
# 护甲穿透计算
|
||
var final_armor_penetration = armor_penetration
|
||
|
||
# 暴击计算
|
||
var is_critical = randf() < crit_rate
|
||
if is_critical:
|
||
damage *= crit_damage
|
||
|
||
# 根据远程攻击模式执行不同的射击方式
|
||
match ranged_mode:
|
||
RangedAttackMode.SINGLE:
|
||
fire_single_projectile(target, damage, final_armor_penetration, is_critical)
|
||
RangedAttackMode.SHOTGUN:
|
||
fire_shotgun_projectiles(target, damage, final_armor_penetration, is_critical)
|
||
RangedAttackMode.BURST:
|
||
fire_burst_projectiles(target, damage, final_armor_penetration, is_critical)
|
||
RangedAttackMode.GATLING:
|
||
fire_single_projectile(target, damage, final_armor_penetration, is_critical) # 加特林也是单发，但频率高
|
||
RangedAttackMode.PIERCING:
|
||
fire_piercing_projectile(target, damage, final_armor_penetration, is_critical)
|
||
|
||
# 发射单发子弹
|
||
func fire_single_projectile(target: CharacterBody2D, damage: float, armor_pen: float, is_critical: bool):
|
||
add_battle_detail_to_panel("🏹 " + pet_name + " 向 " + target.pet_name + " 发射单发子弹 " + str(int(damage)) + " 点伤害" + ("（暴击）" if is_critical else ""))
|
||
create_and_fire_projectile(global_position, target.global_position, damage, armor_pen, is_critical, 1)
|
||
|
||
# 发射散弹
|
||
func fire_shotgun_projectiles(target: CharacterBody2D, damage: float, armor_pen: float, is_critical: bool):
|
||
var base_direction = (target.global_position - global_position).normalized()
|
||
var base_angle = atan2(base_direction.y, base_direction.x)
|
||
|
||
# 计算每发子弹的角度偏移
|
||
var angle_step = deg_to_rad(shotgun_spread_angle) / (shotgun_bullets - 1)
|
||
var start_angle = base_angle - deg_to_rad(shotgun_spread_angle) / 2
|
||
|
||
for i in range(shotgun_bullets):
|
||
var bullet_angle = start_angle + i * angle_step
|
||
var bullet_direction = Vector2(cos(bullet_angle), sin(bullet_angle))
|
||
var target_pos = global_position + bullet_direction * attack_range
|
||
|
||
create_and_fire_projectile(global_position, target_pos, damage * 0.7, armor_pen, is_critical, 1) # 散弹伤害降低
|
||
|
||
# 发射多发射击（平行）
|
||
func fire_burst_projectiles(target: CharacterBody2D, damage: float, armor_pen: float, is_critical: bool):
|
||
var base_direction = (target.global_position - global_position).normalized()
|
||
var perpendicular = Vector2(-base_direction.y, base_direction.x) # 垂直方向
|
||
|
||
# 计算起始位置偏移
|
||
var total_width = (burst_cols - 1) * burst_spacing
|
||
var total_height = (burst_rows - 1) * burst_spacing
|
||
|
||
for row in range(burst_rows):
|
||
for col in range(burst_cols):
|
||
var offset_x = (col - (burst_cols - 1) * 0.5) * burst_spacing
|
||
var offset_y = (row - (burst_rows - 1) * 0.5) * burst_spacing
|
||
|
||
var start_pos = global_position + perpendicular * offset_x + base_direction.rotated(PI/2) * offset_y
|
||
var target_pos = target.global_position + perpendicular * offset_x + base_direction.rotated(PI/2) * offset_y
|
||
|
||
create_and_fire_projectile(start_pos, target_pos, damage * 0.8, armor_pen, is_critical, 1) # 多发伤害稍微降低
|
||
|
||
# 发射穿透子弹
|
||
func fire_piercing_projectile(target: CharacterBody2D, damage: float, armor_pen: float, is_critical: bool):
|
||
create_and_fire_projectile(global_position, target.global_position, damage * 1.2, armor_pen, is_critical, pierce_count) # 穿透子弹伤害更高
|
||
|
||
# 创建并发射子弹的通用函数
|
||
func create_and_fire_projectile(start_pos: Vector2, target_pos: Vector2, damage: float, armor_pen: float, is_critical: bool, pierce: int = 1):
|
||
# 直接创建新子弹
|
||
if not projectile_scene:
|
||
print("错误：没有设置子弹场景!")
|
||
return
|
||
|
||
var projectile: Area2D = projectile_scene.instantiate()
|
||
if not projectile:
|
||
print("错误：无法创建子弹实例")
|
||
return
|
||
|
||
# 将子弹添加到战斗场景中
|
||
if get_tree():
|
||
var battle_scene = get_tree().current_scene
|
||
if battle_scene.has_node("PetFightPanel"):
|
||
battle_scene.get_node("PetFightPanel").add_child(projectile)
|
||
else:
|
||
get_tree().current_scene.add_child(projectile)
|
||
else:
|
||
# 如果场景树不存在，直接销毁子弹
|
||
projectile.queue_free()
|
||
return
|
||
|
||
# 设置子弹位置
|
||
projectile.global_position = start_pos
|
||
|
||
# 计算射击方向
|
||
var direction = (target_pos - start_pos).normalized()
|
||
|
||
# 设置子弹数据
|
||
projectile.set_projectile_data(damage, projectile_speed, direction, pet_team, element_type, armor_pen, pierce, self)
|
||
|
||
# 设置子弹颜色
|
||
if projectile.has_node("ProjectileSprite"):
|
||
if is_critical:
|
||
projectile.get_node("ProjectileSprite").modulate = Color.RED # 暴击红色
|
||
elif pierce > 1:
|
||
projectile.get_node("ProjectileSprite").modulate = Color.PURPLE # 穿透紫色
|
||
else:
|
||
# 根据攻击模式设置不同颜色
|
||
match ranged_mode:
|
||
RangedAttackMode.SINGLE:
|
||
projectile.get_node("ProjectileSprite").modulate = Color.YELLOW
|
||
RangedAttackMode.SHOTGUN:
|
||
projectile.get_node("ProjectileSprite").modulate = Color.ORANGE
|
||
RangedAttackMode.BURST:
|
||
projectile.get_node("ProjectileSprite").modulate = Color.CYAN
|
||
RangedAttackMode.GATLING:
|
||
projectile.get_node("ProjectileSprite").modulate = Color.GREEN
|
||
RangedAttackMode.PIERCING:
|
||
projectile.get_node("ProjectileSprite").modulate = Color.PURPLE
|
||
|
||
#宠物受到伤害（带死循环保护）
|
||
func take_damage(damage: float, armor_pen: float = 0.0, attacker_element: ElementType = ElementType.NONE, attacker: CharacterBody2D = null):
|
||
if not is_alive or is_invulnerable:
|
||
return
|
||
|
||
# 防止过于频繁的伤害处理（性能保护）
|
||
var current_time = Time.get_ticks_msec() / 1000.0
|
||
if current_time - last_attack_time < 0.05: # 50ms最小伤害间隔
|
||
return
|
||
|
||
# 增加伤害反弹递归深度
|
||
damage_reflect_depth += 1
|
||
|
||
# 递归深度保护（防止无限反弹）
|
||
if damage_reflect_depth > max_reflect_depth:
|
||
damage_reflect_depth = max(0, damage_reflect_depth - 1)
|
||
return
|
||
|
||
# 闪避检测
|
||
if randf() < dodge_rate:
|
||
if attacker and is_instance_valid(attacker):
|
||
add_battle_detail_to_panel("✨ " + pet_name + " 闪避了 " + attacker.pet_name + " 的攻击！", Color.CYAN)
|
||
damage_reflect_depth = max(0, damage_reflect_depth - 1)
|
||
return
|
||
|
||
var actual_damage = damage
|
||
|
||
# 元素克制计算 - 额外伤害
|
||
var element_extra_damage = get_element_multiplier(attacker_element, element_type)
|
||
actual_damage += element_extra_damage
|
||
|
||
# 护甲减伤计算（考虑护甲穿透）
|
||
var effective_armor = max(0, current_armor - armor_pen)
|
||
if effective_armor > 0:
|
||
var armor_reduction = effective_armor / (effective_armor + 100.0)
|
||
actual_damage = actual_damage * (1.0 - armor_reduction)
|
||
|
||
# 先扣护盾
|
||
if current_shield > 0:
|
||
var shield_damage = min(actual_damage, current_shield)
|
||
current_shield -= shield_damage
|
||
actual_damage -= shield_damage
|
||
|
||
# 再扣血量
|
||
if actual_damage > 0:
|
||
current_health -= actual_damage
|
||
|
||
# 播放受伤动画（带冷却保护）
|
||
play_hurt_animation()
|
||
|
||
# 添加受伤细节（性能模式下减少文本输出）
|
||
if not performance_mode and attacker and is_instance_valid(attacker):
|
||
var damage_text = "💔 " + pet_name + " 受到 " + str(int(actual_damage)) + " 点伤害"
|
||
if element_extra_damage > 0:
|
||
damage_text += " （元素克制 +" + str(int(element_extra_damage)) + "）"
|
||
add_battle_detail_to_panel(damage_text, Color.ORANGE)
|
||
|
||
# 记录最后攻击者
|
||
if attacker and is_instance_valid(attacker):
|
||
last_attacker = attacker
|
||
|
||
# 反击机制：立即将攻击者设为目标（只有启用战斗时才反击）
|
||
# 添加反击冷却，防止过于频繁的目标切换
|
||
if combat_enabled and attacker and is_instance_valid(attacker) and attacker.is_alive:
|
||
if attacker.get_team() != pet_team: # 确保不攻击队友
|
||
# 只有当前没有目标或当前目标已死亡时才切换目标
|
||
if not current_target or not is_instance_valid(current_target) or not current_target.is_alive:
|
||
current_target = attacker
|
||
current_state = PetState.MOVING_TO_TARGET
|
||
|
||
# 伤害反弹（带递归深度保护）
|
||
if enable_damage_reflect and damage_reflect > 0.0 and attacker and is_instance_valid(attacker) and damage_reflect_depth <= max_reflect_depth:
|
||
var reflect_damage = damage * damage_reflect * 0.5 # 反弹伤害减半，防止无限递归
|
||
# 延迟反弹，避免同帧内的递归调用
|
||
call_deferred("apply_reflect_damage", attacker, reflect_damage)
|
||
|
||
# 检查死亡
|
||
if current_health <= 0:
|
||
if enable_death_immunity and death_immunity:
|
||
current_health = 1.0
|
||
death_immunity = false
|
||
is_invulnerable = true
|
||
# 设置短暂无敌时间
|
||
if get_tree():
|
||
var timer = get_tree().create_timer(2.0)
|
||
timer.timeout.connect(func(): is_invulnerable = false)
|
||
else:
|
||
if not is_dying: # 防止重复调用die()
|
||
call_deferred("die")
|
||
|
||
# 减少伤害反弹递归深度
|
||
damage_reflect_depth = max(0, damage_reflect_depth - 1)
|
||
|
||
# 更新UI
|
||
call_deferred("update_ui")
|
||
|
||
# 延迟应用反弹伤害（防止递归调用）
|
||
func apply_reflect_damage(target: CharacterBody2D, reflect_damage: float):
|
||
if target and is_instance_valid(target) and target.is_alive:
|
||
target.take_damage(reflect_damage, 0.0, element_type, self)
|
||
|
||
#宠物死亡
|
||
func die():
|
||
if is_dying: # 如果已经在死亡过程中，直接返回
|
||
return
|
||
|
||
# 检查重生机制
|
||
if enable_resurrection and not resurrection_used:
|
||
resurrection_used = true
|
||
add_battle_detail_to_panel("💀 " + pet_name + " 死亡，但触发重生机制！", Color.GOLD)
|
||
resurrect()
|
||
return
|
||
|
||
is_dying = true # 设置死亡标志
|
||
is_alive = false
|
||
current_state = PetState.DEAD
|
||
|
||
# 添加死亡细节
|
||
var death_message = "💀 " + pet_name + " 死亡了！"
|
||
if last_attacker and is_instance_valid(last_attacker):
|
||
death_message += " （被 " + last_attacker.pet_name + " 击杀）"
|
||
add_battle_detail_to_panel(death_message, Color.RED)
|
||
|
||
# 给击杀者奖励
|
||
if last_attacker and is_instance_valid(last_attacker) and last_attacker.has_method("on_kill_enemy"):
|
||
last_attacker.on_kill_enemy(self)
|
||
|
||
# 通知其他宠物这个目标已死亡，让它们重新寻找目标
|
||
if get_tree(): # 确保场景树存在
|
||
var all_pets = get_tree().get_nodes_in_group("pets")
|
||
for pet in all_pets:
|
||
if pet != self and is_instance_valid(pet) and pet.has_method("on_enemy_died"):
|
||
pet.on_enemy_died(self)
|
||
|
||
# 立即通知战斗面板检查战斗结束
|
||
var battle_panel = get_parent()
|
||
while battle_panel and not battle_panel.has_method("check_battle_end"):
|
||
battle_panel = battle_panel.get_parent()
|
||
|
||
if battle_panel:
|
||
battle_panel.call_deferred("check_battle_end")
|
||
|
||
# 延迟0.5秒后移除自己，避免在物理回调中操作
|
||
if get_tree():
|
||
await get_tree().create_timer(0.5).timeout
|
||
if get_parent():
|
||
get_parent().remove_child(self)
|
||
queue_free()
|
||
else:
|
||
# 如果场景树不存在，直接销毁
|
||
queue_free()
|
||
|
||
# 重生机制
|
||
func resurrect():
|
||
# 恢复生命值到50%
|
||
current_health = max_health * 0.5
|
||
current_shield = max_shield * 0.5
|
||
current_armor = max_armor * 0.5
|
||
|
||
# 设置短暂无敌状态
|
||
is_invulnerable = true
|
||
is_dying = false
|
||
is_alive = true
|
||
current_state = PetState.IDLE
|
||
|
||
# 清除目标，重新开始
|
||
current_target = null
|
||
|
||
# 重生特效（变为金色闪烁）
|
||
var original_modulate = pet_image.modulate
|
||
pet_image.modulate = Color.GOLD
|
||
|
||
# 3秒后恢复正常状态
|
||
if get_tree():
|
||
var timer = get_tree().create_timer(3.0)
|
||
timer.timeout.connect(func():
|
||
is_invulnerable = false
|
||
pet_image.modulate = original_modulate
|
||
)
|
||
|
||
call_deferred("update_ui")
|
||
|
||
# 显示启用的特殊机制
|
||
func show_enabled_special_abilities():
|
||
var abilities: Array[String] = []
|
||
|
||
if enable_damage_reflect:
|
||
abilities.append("伤害反弹(" + str(int(damage_reflect * 100)) + "%)")
|
||
if enable_berserker_mode:
|
||
abilities.append("狂暴模式(" + str(int(berserker_threshold * 100)) + "%血量触发)")
|
||
if enable_death_immunity:
|
||
abilities.append("死亡免疫")
|
||
if enable_aid_system:
|
||
abilities.append("援助召唤(x" + str(aid_summon_count) + ")")
|
||
if enable_resurrection:
|
||
abilities.append("死亡重生")
|
||
|
||
# 可以在这里添加UI显示特殊能力的逻辑，暂时注释掉print
|
||
# if abilities.size() > 0:
|
||
# print(pet_name + " 启用特殊机制: " + ", ".join(abilities))
|
||
# else:
|
||
# print(pet_name + " 无特殊机制")
|
||
|
||
#更新宠物状态UI
|
||
func update_ui():
|
||
# 检查UI节点是否存在，防止援助宠物或未完全初始化的宠物出错
|
||
if not health_bar or not shield_bar or not armor_bar or not health_label or not shield_label or not armor_label or not pet_name_rich_text:
|
||
return
|
||
|
||
# 更新血量条
|
||
health_bar.max_value = max_health
|
||
health_bar.value = current_health
|
||
health_label.text = "生命值:" + str(int(current_health)) + "/" + str(int(max_health))
|
||
|
||
# 更新护盾条
|
||
shield_bar.max_value = max_shield
|
||
shield_bar.value = current_shield
|
||
shield_label.text = "护盾值:" + str(int(current_shield)) + "/" + str(int(max_shield))
|
||
|
||
# 更新护甲条
|
||
armor_bar.max_value = max_armor
|
||
armor_bar.value = current_armor
|
||
armor_label.text = "护甲值:" + str(int(current_armor)) + "/" + str(int(max_armor))
|
||
|
||
# 更新名称（包含等级、经验、亲密度信息）
|
||
var display_name = pet_name + " [Lv." + str(pet_level) + "]"
|
||
display_name += "\n经验:" + str(int(pet_experience)) + "/" + str(int(max_experience))
|
||
display_name += "\n亲密度:" + str(int(pet_intimacy)) + "/" + str(int(max_intimacy))
|
||
if pet_age > 0:
|
||
display_name += "\n年龄:" + get_age_display()
|
||
pet_name_rich_text.text = display_name
|
||
|
||
# 获取友好的年龄显示
|
||
func get_age_display() -> String:
|
||
if pet_age == 0:
|
||
return "新生"
|
||
elif pet_age < 7:
|
||
return str(pet_age) + "天"
|
||
elif pet_age < 30:
|
||
var weeks = pet_age / 7
|
||
return str(weeks) + "周"
|
||
elif pet_age < 365:
|
||
var months = pet_age / 30
|
||
return str(months) + "个月"
|
||
else:
|
||
var years = pet_age / 365
|
||
var remaining_days = pet_age % 365
|
||
if remaining_days > 0:
|
||
return str(years) + "年" + str(remaining_days) + "天"
|
||
else:
|
||
return str(years) + "年"
|
||
|
||
# 添加战斗细节到对战面板
|
||
func add_battle_detail_to_panel(text: String, color: Color = Color.WHITE):
|
||
# 查找战斗面板
|
||
var battle_panel = find_battle_panel()
|
||
if battle_panel and battle_panel.has_method("add_battle_detail"):
|
||
battle_panel.add_battle_detail(text, color)
|
||
|
||
# 查找战斗面板
|
||
func find_battle_panel():
|
||
var current_scene = get_tree().current_scene
|
||
if current_scene.has_node("PetFightPanel"):
|
||
return current_scene.get_node("PetFightPanel")
|
||
else:
|
||
# 遍历所有子节点查找
|
||
var queue = [current_scene]
|
||
while queue.size() > 0:
|
||
var node = queue.pop_front()
|
||
if node.name == "PetFightPanel":
|
||
return node
|
||
for child in node.get_children():
|
||
queue.append(child)
|
||
return null
|
||
|
||
#设置宠物数据
|
||
func set_pet_data(name: String, team: String, health: float = 100.0, attack: float = 20.0, speed: float = 100.0, quality: PetQuality = PetQuality.COMMON, element: ElementType = ElementType.NONE):
|
||
pet_name = name
|
||
pet_team = team
|
||
max_health = health
|
||
current_health = health
|
||
attack_damage = attack
|
||
move_speed = speed
|
||
pet_quality = quality
|
||
element_type = element
|
||
|
||
# 根据品质调整属性
|
||
apply_quality_bonuses()
|
||
|
||
# 更新攻击速度
|
||
update_attack_speed()
|
||
|
||
# 设置碰撞层（现在team信息已确定）
|
||
setup_collision_layers()
|
||
|
||
# 显示启用的特殊机制
|
||
call_deferred("show_enabled_special_abilities")
|
||
|
||
call_deferred("update_ui")
|
||
|
||
# 更新攻击速度（根据当前攻击类型）
|
||
func update_attack_speed():
|
||
if attack_type == AttackType.MELEE:
|
||
attack_speed = melee_attack_speed
|
||
else:
|
||
attack_speed = ranged_attack_speed
|
||
|
||
# 根据品质应用属性加成
|
||
func apply_quality_bonuses():
|
||
var quality_multiplier = 1.0
|
||
match pet_quality:
|
||
PetQuality.COMMON:
|
||
quality_multiplier = 1.0
|
||
PetQuality.UNCOMMON:
|
||
quality_multiplier = 1.1
|
||
PetQuality.RARE:
|
||
quality_multiplier = 1.25
|
||
PetQuality.EPIC:
|
||
quality_multiplier = 1.5
|
||
PetQuality.LEGENDARY:
|
||
quality_multiplier = 1.75
|
||
PetQuality.MYTHIC:
|
||
quality_multiplier = 2.0
|
||
|
||
# 应用品质加成到基础属性
|
||
max_health *= quality_multiplier
|
||
current_health = max_health
|
||
max_shield *= quality_multiplier
|
||
current_shield = max_shield
|
||
max_armor *= quality_multiplier
|
||
current_armor = max_armor
|
||
attack_damage *= quality_multiplier
|
||
|
||
# 高品质宠物获得额外属性
|
||
if pet_quality >= PetQuality.RARE:
|
||
crit_rate += 0.05
|
||
life_steal += 0.05
|
||
enable_berserker_mode = true # 稀有品质启用狂暴模式
|
||
if pet_quality >= PetQuality.EPIC:
|
||
armor_penetration += 10.0
|
||
health_regen += 1.0
|
||
enable_damage_reflect = true # 史诗品质启用伤害反弹
|
||
damage_reflect += 0.1
|
||
if pet_quality >= PetQuality.LEGENDARY:
|
||
knockback_resist += 0.2
|
||
enable_aid_system = true # 传说品质启用援助系统
|
||
enable_death_immunity = true # 传说品质启用死亡免疫
|
||
death_immunity = true
|
||
if pet_quality >= PetQuality.MYTHIC:
|
||
berserker_bonus += 0.5
|
||
enable_resurrection = true # 神话品质启用重生机制
|
||
|
||
func get_team() -> String:
|
||
return pet_team
|
||
|
||
# 获取攻击类型（调试用）
|
||
func get_attack_type() -> AttackType:
|
||
return attack_type
|
||
|
||
# 处理生命和护盾恢复
|
||
func handle_regeneration(delta: float):
|
||
var current_time = Time.get_ticks_msec() / 1000.0
|
||
if current_time - last_regen_time >= 1.0: # 每秒恢复一次
|
||
# 生命恢复
|
||
if current_health < max_health and health_regen > 0:
|
||
current_health = min(max_health, current_health + health_regen)
|
||
|
||
# 护盾恢复
|
||
if current_shield < max_shield and shield_regen > 0:
|
||
current_shield = min(max_shield, current_shield + shield_regen)
|
||
|
||
last_regen_time = current_time
|
||
call_deferred("update_ui")
|
||
|
||
# 更新亲密度
|
||
var intimacy_timer: float = 0.0
|
||
|
||
func update_age_and_intimacy(delta: float):
|
||
# 更新年龄（基于出生日期和现实时间）
|
||
update_pet_age()
|
||
|
||
# 每10秒增加1点亲密度（战斗中会增加更多）
|
||
intimacy_timer += delta
|
||
if intimacy_timer >= 10.0:
|
||
gain_intimacy(1.0)
|
||
intimacy_timer = 0.0
|
||
|
||
# 根据出生日期计算宠物年龄
|
||
func update_pet_age():
|
||
if pet_birthday == "":
|
||
return
|
||
|
||
# 解析出生日期
|
||
var birth_parts = pet_birthday.split(" ")
|
||
if birth_parts.size() != 2:
|
||
return
|
||
|
||
var date_parts = birth_parts[0].split("-")
|
||
var time_parts = birth_parts[1].split(":")
|
||
|
||
if date_parts.size() != 3 or time_parts.size() != 3:
|
||
return
|
||
|
||
# 获取当前时间
|
||
var current_time = Time.get_datetime_dict_from_system()
|
||
|
||
# 计算出生时间
|
||
var birth_year = int(date_parts[0])
|
||
var birth_month = int(date_parts[1])
|
||
var birth_day = int(date_parts[2])
|
||
var birth_hour = int(time_parts[0])
|
||
var birth_minute = int(time_parts[1])
|
||
var birth_second = int(time_parts[2])
|
||
|
||
# 创建出生时间的Unix时间戳
|
||
var birth_dict = {
|
||
"year": birth_year,
|
||
"month": birth_month,
|
||
"day": birth_day,
|
||
"hour": birth_hour,
|
||
"minute": birth_minute,
|
||
"second": birth_second
|
||
}
|
||
|
||
var birth_unix = Time.get_unix_time_from_datetime_dict(birth_dict)
|
||
var current_unix = Time.get_unix_time_from_system()
|
||
|
||
# 计算年龄（秒差转换为天数）
|
||
var age_seconds = current_unix - birth_unix
|
||
pet_age = int(age_seconds / 86400) # 86400秒 = 1天
|
||
|
||
if pet_age < 0:
|
||
pet_age = 0 # 防止负数年龄
|
||
|
||
# 增加亲密度
|
||
func gain_intimacy(amount: float):
|
||
if pet_intimacy < max_intimacy:
|
||
pet_intimacy = min(max_intimacy, pet_intimacy + amount)
|
||
|
||
# 每100点亲密度提供属性加成
|
||
var intimacy_level = int(pet_intimacy / 100.0)
|
||
if intimacy_level > 0:
|
||
# 亲密度加成：每100点提供5%属性加成
|
||
var intimacy_bonus = 1.0 + (intimacy_level * 0.05)
|
||
# 这里可以应用到各种属性上，暂时先输出提示
|
||
if int(pet_intimacy) % 100 == 0:
|
||
pass
|
||
|
||
# 增加经验值
|
||
func gain_experience(amount: float):
|
||
if pet_level >= 50: # 等级上限
|
||
return
|
||
|
||
pet_experience += amount
|
||
|
||
# 检查是否升级
|
||
while pet_experience >= max_experience and pet_level < 50:
|
||
level_up()
|
||
|
||
# 升级（新的随机属性系统）
|
||
func level_up():
|
||
pet_experience -= max_experience
|
||
pet_level += 1
|
||
|
||
# 计算新的升级经验需求（指数增长）
|
||
max_experience = 100.0 * pow(1.2, pet_level - 1)
|
||
|
||
# 随机选择属性进行升级
|
||
var upgraded_attributes = apply_random_attribute_upgrade()
|
||
|
||
# 检查是否有里程碑奖励（每5级）
|
||
var milestone_rewards = apply_milestone_bonus()
|
||
|
||
# 升级回血和护盾护甲
|
||
current_health = max_health
|
||
current_shield = max_shield
|
||
current_armor = max_armor
|
||
|
||
# 升级特效
|
||
show_level_up_effect()
|
||
|
||
# 添加升级细节
|
||
var upgrade_text = "🎉 " + pet_name + " 升级到 " + str(pet_level) + " 级！"
|
||
upgrade_text += "\n📈 随机提升：" + ", ".join(upgraded_attributes)
|
||
if milestone_rewards.size() > 0:
|
||
upgrade_text += "\n🏆 里程碑奖励：" + ", ".join(milestone_rewards)
|
||
|
||
add_battle_detail_to_panel(upgrade_text, Color.GOLD)
|
||
|
||
call_deferred("update_ui")
|
||
|
||
# 应用随机属性升级
|
||
func apply_random_attribute_upgrade() -> Array[String]:
|
||
var upgraded_attributes: Array[String] = []
|
||
var available_attributes = base_upgrade_attributes.duplicate()
|
||
|
||
# 随机选择几个属性进行升级
|
||
for i in range(min(attributes_per_level, available_attributes.size())):
|
||
var random_index = randi() % available_attributes.size()
|
||
var selected_attribute = available_attributes[random_index]
|
||
available_attributes.remove_at(random_index)
|
||
|
||
# 应用属性升级
|
||
var upgrade_applied = apply_single_attribute_upgrade(selected_attribute)
|
||
if upgrade_applied:
|
||
upgraded_attributes.append(upgrade_applied)
|
||
|
||
return upgraded_attributes
|
||
|
||
# 应用单个属性升级
|
||
func apply_single_attribute_upgrade(attribute_name: String) -> String:
|
||
match attribute_name:
|
||
"max_health":
|
||
var bonus = randf_range(8.0, 15.0) # 随机8-15点生命值
|
||
max_health += bonus
|
||
return "生命值 +" + str(int(bonus))
|
||
"attack_damage":
|
||
var bonus = randf_range(2.0, 5.0) # 随机2-5点攻击力
|
||
attack_damage += bonus
|
||
return "攻击力 +" + str(int(bonus))
|
||
"move_speed":
|
||
var bonus = randf_range(3.0, 8.0) # 随机3-8点移动速度
|
||
move_speed += bonus
|
||
return "移动速度 +" + str(int(bonus))
|
||
"max_shield":
|
||
var bonus = randf_range(5.0, 12.0) # 随机5-12点护盾值
|
||
max_shield += bonus
|
||
return "护盾值 +" + str(int(bonus))
|
||
"max_armor":
|
||
var bonus = randf_range(4.0, 10.0) # 随机4-10点护甲值
|
||
max_armor += bonus
|
||
return "护甲值 +" + str(int(bonus))
|
||
"crit_rate":
|
||
var bonus = randf_range(0.01, 0.03) # 随机1-3%暴击率
|
||
crit_rate = min(1.0, crit_rate + bonus) # 暴击率上限100%
|
||
return "暴击率 +" + str(int(bonus * 100)) + "%"
|
||
"health_regen":
|
||
var bonus = randf_range(0.3, 0.8) # 随机0.3-0.8点生命恢复
|
||
health_regen += bonus
|
||
return "生命恢复 +" + str("%.1f" % bonus)
|
||
"attack_range":
|
||
var bonus = randf_range(8.0, 20.0) # 随机8-20点攻击距离
|
||
attack_range += bonus
|
||
return "攻击距离 +" + str(int(bonus))
|
||
_:
|
||
return ""
|
||
|
||
# 应用里程碑奖励
|
||
func apply_milestone_bonus() -> Array[String]:
|
||
var milestone_rewards: Array[String] = []
|
||
|
||
if not level_milestone_bonuses.has(pet_level):
|
||
return milestone_rewards
|
||
|
||
var bonuses = level_milestone_bonuses[pet_level]
|
||
|
||
for bonus_key in bonuses.keys():
|
||
var bonus_value = bonuses[bonus_key]
|
||
var reward_text = apply_milestone_bonus_single(bonus_key, bonus_value)
|
||
if reward_text != "":
|
||
milestone_rewards.append(reward_text)
|
||
|
||
return milestone_rewards
|
||
|
||
# 应用单个里程碑奖励
|
||
func apply_milestone_bonus_single(bonus_key: String, bonus_value) -> String:
|
||
match bonus_key:
|
||
"max_health":
|
||
max_health += bonus_value
|
||
return "生命值 +" + str(bonus_value)
|
||
"attack_damage":
|
||
attack_damage += bonus_value
|
||
return "攻击力 +" + str(bonus_value)
|
||
"max_shield":
|
||
max_shield += bonus_value
|
||
return "护盾值 +" + str(bonus_value)
|
||
"max_armor":
|
||
max_armor += bonus_value
|
||
return "护甲值 +" + str(bonus_value)
|
||
"crit_rate":
|
||
crit_rate = min(1.0, crit_rate + bonus_value)
|
||
return "暴击率 +" + str(int(bonus_value * 100)) + "%"
|
||
"armor_penetration":
|
||
armor_penetration += bonus_value
|
||
return "护甲穿透 +" + str(bonus_value)
|
||
"life_steal":
|
||
life_steal = min(1.0, life_steal + bonus_value)
|
||
return "生命汲取 +" + str(int(bonus_value * 100)) + "%"
|
||
"knockback_resist":
|
||
knockback_resist = min(1.0, knockback_resist + bonus_value)
|
||
return "击退抗性 +" + str(int(bonus_value * 100)) + "%"
|
||
"dodge_rate":
|
||
dodge_rate = min(1.0, dodge_rate + bonus_value)
|
||
return "闪避率 +" + str(int(bonus_value * 100)) + "%"
|
||
"health_regen":
|
||
health_regen += bonus_value
|
||
return "生命恢复 +" + str(bonus_value)
|
||
"move_speed":
|
||
move_speed += bonus_value
|
||
return "移动速度 +" + str(bonus_value)
|
||
"attack_range":
|
||
attack_range += bonus_value
|
||
return "攻击距离 +" + str(bonus_value)
|
||
"shield_regen":
|
||
shield_regen += bonus_value
|
||
return "护盾恢复 +" + str(bonus_value)
|
||
"crit_damage":
|
||
crit_damage += bonus_value
|
||
return "暴击伤害 +" + str(int(bonus_value * 100)) + "%"
|
||
"berserker_bonus":
|
||
berserker_bonus += bonus_value
|
||
return "狂暴加成 +" + str(int(bonus_value * 100)) + "%"
|
||
"damage_reflect":
|
||
damage_reflect = min(1.0, damage_reflect + bonus_value)
|
||
return "伤害反弹 +" + str(int(bonus_value * 100)) + "%"
|
||
"control_resist":
|
||
control_resist = min(1.0, control_resist + bonus_value)
|
||
return "控制抗性 +" + str(int(bonus_value * 100)) + "%"
|
||
"projectile_speed":
|
||
projectile_speed += bonus_value
|
||
return "子弹速度 +" + str(bonus_value)
|
||
"pierce_count":
|
||
pierce_count += bonus_value
|
||
return "穿透数量 +" + str(bonus_value)
|
||
"enable_berserker_mode":
|
||
if bonus_value:
|
||
enable_berserker_mode = true
|
||
return "解锁狂暴模式"
|
||
else:
|
||
return ""
|
||
"enable_damage_reflect":
|
||
if bonus_value:
|
||
enable_damage_reflect = true
|
||
return "解锁伤害反弹"
|
||
else:
|
||
return ""
|
||
"enable_aid_system":
|
||
if bonus_value:
|
||
enable_aid_system = true
|
||
return "解锁援助召唤"
|
||
else:
|
||
return ""
|
||
"enable_death_immunity":
|
||
if bonus_value:
|
||
enable_death_immunity = true
|
||
death_immunity = true
|
||
return "解锁死亡免疫"
|
||
else:
|
||
return ""
|
||
"enable_resurrection":
|
||
if bonus_value:
|
||
enable_resurrection = true
|
||
return "解锁死亡重生"
|
||
else:
|
||
return ""
|
||
_:
|
||
return ""
|
||
|
||
# 显示升级特效
|
||
func show_level_up_effect():
|
||
if not pet_image:
|
||
return
|
||
|
||
# 保存原始颜色
|
||
var original_color = pet_image.modulate
|
||
|
||
# 创建升级特效（金色闪烁）
|
||
var tween = create_tween()
|
||
tween.set_loops(3) # 闪烁3次
|
||
|
||
# 闪烁效果
|
||
tween.tween_method(func(color): pet_image.modulate = color, original_color, Color.GOLD, 0.2)
|
||
tween.tween_method(func(color): pet_image.modulate = color, Color.GOLD, original_color, 0.2)
|
||
|
||
# 恢复原始颜色
|
||
tween.tween_callback(func(): pet_image.modulate = original_color)
|
||
|
||
# 击杀敌人时获得额外经验
|
||
func on_kill_enemy(enemy: CharacterBody2D):
|
||
var kill_exp = enemy.pet_level * 20.0 # 根据敌人等级获得经验
|
||
gain_experience(kill_exp)
|
||
gain_intimacy(10.0) # 击杀获得更多亲密度
|
||
|
||
# 初始化生日
|
||
func initialize_birthday():
|
||
if pet_birthday == "":
|
||
var time_dict = Time.get_datetime_dict_from_system()
|
||
pet_birthday = str(time_dict.year) + "-" + str(time_dict.month).pad_zeros(2) + "-" + str(time_dict.day).pad_zeros(2) + " " + str(time_dict.hour).pad_zeros(2) + ":" + str(time_dict.minute).pad_zeros(2) + ":" + str(time_dict.second).pad_zeros(2)
|
||
|
||
# 检查狂暴模式
|
||
func check_berserker_mode():
|
||
if not enable_berserker_mode:
|
||
return
|
||
|
||
var health_ratio = current_health / max_health
|
||
if health_ratio <= berserker_threshold and not is_berserker:
|
||
is_berserker = true
|
||
pet_image.modulate = Color.RED # 狂暴状态变红色
|
||
add_battle_detail_to_panel("🔥 " + pet_name + " 血量过低，进入狂暴模式！", Color.RED)
|
||
elif health_ratio > berserker_threshold and is_berserker:
|
||
is_berserker = false
|
||
add_battle_detail_to_panel("😌 " + pet_name + " 脱离狂暴模式", Color.GREEN)
|
||
# 恢复原来的队伍颜色
|
||
if pet_team == "team1":
|
||
pet_image.modulate = Color.CYAN
|
||
else:
|
||
pet_image.modulate = Color.ORANGE
|
||
|
||
# 检查援助系统
|
||
func check_aid_system():
|
||
if not enable_aid_system:
|
||
return
|
||
|
||
var health_ratio = current_health / max_health
|
||
var current_time = Time.get_ticks_msec() / 1000.0
|
||
|
||
# 如果血量低于阈值且还没召唤过援助，或者距离上次召唤已经超过间隔时间
|
||
if health_ratio <= aid_threshold:
|
||
if not aid_summoned or (current_time - aid_last_summon_time >= aid_summon_interval):
|
||
summon_aid()
|
||
aid_last_summon_time = current_time
|
||
aid_summoned = true
|
||
|
||
# 召唤援助
|
||
func summon_aid():
|
||
# 获取战斗面板引用
|
||
var battle_panel = get_parent()
|
||
while battle_panel and not battle_panel.has_method("get_team_node"):
|
||
battle_panel = battle_panel.get_parent()
|
||
|
||
if not battle_panel:
|
||
return
|
||
|
||
var team_node = battle_panel.get_team_node(pet_team)
|
||
if not team_node:
|
||
return
|
||
|
||
# 召唤多个援助宠物
|
||
for i in range(aid_summon_count):
|
||
var aid_pet = create_aid_minion()
|
||
if aid_pet:
|
||
team_node.add_child(aid_pet)
|
||
aid_minions.append(aid_pet)
|
||
|
||
# 设置援助宠物位置（在主宠物周围）
|
||
var offset_angle = (PI * 2 / aid_summon_count) * i
|
||
var offset_distance = 80.0
|
||
var offset = Vector2(cos(offset_angle), sin(offset_angle)) * offset_distance
|
||
aid_pet.global_position = global_position + offset
|
||
|
||
# 添加到宠物组
|
||
aid_pet.add_to_group("pets")
|
||
aid_pet.add_to_group(pet_team)
|
||
aid_pet.add_to_group("aid_minions")
|
||
|
||
# 创建援助宠物
|
||
func create_aid_minion() -> CharacterBody2D:
|
||
# 使用相同的宠物场景
|
||
var pet_scene = preload("res://Scene/Pet/PetBase.tscn")
|
||
var aid_pet = pet_scene.instantiate()
|
||
|
||
# 设置援助宠物属性（比主宠物弱一些）
|
||
var aid_name = pet_name + "的援助"
|
||
var aid_health = max_health * 0.3 # 30%血量
|
||
var aid_attack = attack_damage * 0.5 # 50%攻击力
|
||
var aid_speed = move_speed * 1.2 # 120%移动速度
|
||
|
||
aid_pet.set_pet_data(aid_name, pet_team, aid_health, aid_attack, aid_speed, PetQuality.COMMON, element_type)
|
||
|
||
# 援助宠物使用简单的远程攻击
|
||
aid_pet.attack_type = AttackType.RANGED
|
||
aid_pet.ranged_mode = RangedAttackMode.SINGLE
|
||
aid_pet.attack_range = 250.0
|
||
|
||
# 设置援助宠物的特殊标识（小一点，颜色稍微不同）
|
||
aid_pet.scale = Vector2(0.7, 0.7) # 缩小到70%
|
||
if aid_pet.pet_image:
|
||
aid_pet.pet_image.modulate = aid_pet.pet_image.modulate * Color(1.0, 1.0, 1.0, 0.8) # 半透明
|
||
|
||
# 隐藏援助宠物的UI面板，减少性能开销
|
||
if aid_pet.has_node("PetInformVBox"):
|
||
aid_pet.get_node("PetInformVBox").visible = false
|
||
|
||
return aid_pet
|
||
|
||
# 治疗函数
|
||
func heal(amount: float):
|
||
if not is_alive:
|
||
return
|
||
current_health = min(max_health, current_health + amount)
|
||
call_deferred("update_ui")
|
||
|
||
# 击退效果已禁用
|
||
func apply_knockback_to_target(target: CharacterBody2D):
|
||
# 击退功能暂时禁用
|
||
pass
|
||
|
||
# 击退效果已禁用
|
||
func apply_knockback(direction: Vector2, force: float):
|
||
# 击退功能暂时禁用
|
||
pass
|
||
|
||
# 将位置限制在战斗区域内
|
||
func clamp_position_to_battle_area(pos: Vector2) -> Vector2:
|
||
var battle_area_min = Vector2(50, 50)
|
||
var battle_area_max = Vector2(1350, 670)
|
||
|
||
pos.x = clamp(pos.x, battle_area_min.x, battle_area_max.x)
|
||
pos.y = clamp(pos.y, battle_area_min.y, battle_area_max.y)
|
||
return pos
|
||
|
||
# 元素克制计算
|
||
func get_element_multiplier(attacker_element: ElementType, defender_element: ElementType) -> float:
|
||
# 如果攻击者无属性，返回正常伤害
|
||
if attacker_element == ElementType.NONE:
|
||
return 0.0 # 无额外伤害
|
||
|
||
# 雷属性克制所有其他属性
|
||
if attacker_element == ElementType.THUNDER and defender_element != ElementType.NONE:
|
||
return element_damage_bonus # 雷克制所有
|
||
|
||
# 如果防御者无属性，无克制关系
|
||
if defender_element == ElementType.NONE:
|
||
return 0.0
|
||
|
||
# 五行克制：金克木，木克水，水克火，火克土，土克金
|
||
match attacker_element:
|
||
ElementType.METAL:
|
||
if defender_element == ElementType.WOOD:
|
||
return element_damage_bonus # 金克木
|
||
ElementType.WOOD:
|
||
if defender_element == ElementType.WATER:
|
||
return element_damage_bonus # 木克水
|
||
ElementType.WATER:
|
||
if defender_element == ElementType.FIRE:
|
||
return element_damage_bonus # 水克火
|
||
ElementType.FIRE:
|
||
if defender_element == ElementType.EARTH:
|
||
return element_damage_bonus # 火克土
|
||
ElementType.EARTH:
|
||
if defender_element == ElementType.METAL:
|
||
return element_damage_bonus # 土克金
|
||
|
||
return 0.0 # 无克制关系，无额外伤害
|
||
|
||
# 当敌人死亡时被调用
|
||
func on_enemy_died(dead_enemy: CharacterBody2D):
|
||
if current_target == dead_enemy:
|
||
current_target = null
|
||
current_state = PetState.IDLE
|
||
|
||
# 处理巡逻逻辑
|
||
func handle_patrol(delta: float):
|
||
if patrol_path.size() == 0:
|
||
return
|
||
|
||
# 确保当前巡逻索引有效
|
||
if current_patrol_index >= patrol_path.size():
|
||
current_patrol_index = 0
|
||
|
||
var target_point = patrol_path[current_patrol_index]
|
||
# 使用本地坐标进行计算（因为宠物现在在巡逻线节点下）
|
||
var distance_to_target = position.distance_to(target_point)
|
||
|
||
# 如果距离目标点很近，移动到下一个点
|
||
if distance_to_target < 30.0: # 增加检测距离，避免抖动
|
||
patrol_wait_time += delta
|
||
if patrol_wait_time >= patrol_max_wait_time:
|
||
current_patrol_index = (current_patrol_index + 1) % patrol_path.size()
|
||
patrol_wait_time = 0.0
|
||
|
||
# 在等待期间播放空闲动画
|
||
if pet_image and pet_image.animation != "idle":
|
||
pet_image.animation = "idle"
|
||
velocity = Vector2.ZERO
|
||
else:
|
||
# 移动到目标点
|
||
var direction = (target_point - position).normalized()
|
||
velocity = direction * patrol_speed
|
||
|
||
# 播放移动动画
|
||
if pet_image and pet_image.animation != "walk":
|
||
pet_image.animation = "walk"
|
||
|
||
# 根据移动方向翻转精灵
|
||
if direction.x < 0:
|
||
pet_image.flip_h = false
|
||
elif direction.x > 0:
|
||
pet_image.flip_h = true
|
||
|
||
patrol_wait_time = 0.0
|
||
|
||
# 应用移动
|
||
move_and_slide()
|
||
|
||
# 限制在巡逻区域内（使用本地坐标）
|
||
clamp_to_patrol_area()
|
||
|
||
# 设置战斗启用状态
|
||
func set_combat_enabled(enabled: bool):
|
||
combat_enabled = enabled
|
||
if not enabled:
|
||
# 禁用战斗时，清除当前目标
|
||
current_target = null
|
||
current_state = PetState.IDLE
|
||
|
||
# 限制巡逻宠物在合理的坐标范围内
|
||
func clamp_to_patrol_area():
|
||
# 基于巡逻路径计算合理的边界
|
||
if patrol_path.size() > 0:
|
||
var min_x = patrol_path[0].x
|
||
var max_x = patrol_path[0].x
|
||
var min_y = patrol_path[0].y
|
||
var max_y = patrol_path[0].y
|
||
|
||
# 找到路径的边界
|
||
for point in patrol_path:
|
||
min_x = min(min_x, point.x)
|
||
max_x = max(max_x, point.x)
|
||
min_y = min(min_y, point.y)
|
||
max_y = max(max_y, point.y)
|
||
|
||
# 添加一些缓冲区域
|
||
var buffer = 100.0
|
||
min_x -= buffer
|
||
max_x += buffer
|
||
min_y -= buffer
|
||
max_y += buffer
|
||
|
||
# 限制位置
|
||
position.x = clamp(position.x, min_x, max_x)
|
||
position.y = clamp(position.y, min_y, max_y)
|
||
|
||
# 播放受伤动画（带冷却保护）
|
||
func play_hurt_animation():
|
||
if not pet_image:
|
||
return
|
||
|
||
# 检查受伤动画冷却时间
|
||
var current_time = Time.get_ticks_msec() / 1000.0
|
||
if current_time - last_hurt_time < hurt_animation_cooldown:
|
||
return # 冷却中，不播放动画
|
||
|
||
last_hurt_time = current_time
|
||
|
||
# 如果已经有受伤动画在播放，停止之前的
|
||
if hurt_tween:
|
||
hurt_tween.kill()
|
||
hurt_tween = null
|
||
|
||
# 性能模式下简化动画
|
||
if performance_mode:
|
||
# 简单的颜色变化，无需Tween
|
||
pet_image.modulate = Color.RED
|
||
# 使用计时器恢复颜色（更轻量）
|
||
await get_tree().create_timer(0.1).timeout
|
||
if pet_image: # 确保宠物还存在
|
||
pet_image.modulate = original_modulate
|
||
return
|
||
|
||
# 创建受伤动画（闪红效果）
|
||
hurt_tween = create_tween()
|
||
|
||
# 立即变红
|
||
pet_image.modulate = Color.RED
|
||
|
||
# 0.2秒后恢复原色
|
||
hurt_tween.tween_property(pet_image, "modulate", original_modulate, 0.2)
|
||
|
||
# 动画结束后清理
|
||
hurt_tween.tween_callback(func():
|
||
hurt_tween = null
|
||
)
|
||
|
||
# 切换性能模式
|
||
func toggle_performance_mode():
|
||
performance_mode = !performance_mode
|
||
var mode_text = "性能模式" if performance_mode else "正常模式"
|
||
add_battle_detail_to_panel("⚡ " + pet_name + " 切换到 " + mode_text, Color.YELLOW)
|
||
print("⚡ " + pet_name + " 切换到 " + mode_text)
|
||
|
||
# 输出宠物性能状态
|
||
func debug_performance_status():
|
||
print("=== " + pet_name + " 性能状态调试 ===")
|
||
print("性能模式: " + str(performance_mode))
|
||
print("伤害反弹深度: " + str(damage_reflect_depth))
|
||
print("帧跳跃计数: " + str(frame_skip_counter))
|
||
print("上次受伤时间: " + str(last_hurt_time))
|
||
print("上次攻击时间: " + str(last_attack_time))
|
||
print("当前状态: " + str(current_state))
|
||
print("是否存活: " + str(is_alive))
|
||
print("是否正在死亡: " + str(is_dying))
|
||
print("============================")
|
||
|
||
# 重置性能状态（紧急恢复）
|
||
func reset_performance_state():
|
||
performance_mode = false
|
||
damage_reflect_depth = 0
|
||
frame_skip_counter = 0
|
||
|
||
# 清理可能卡住的动画
|
||
if hurt_tween:
|
||
hurt_tween.kill()
|
||
hurt_tween = null
|
||
|
||
# 恢复正常颜色
|
||
if pet_image:
|
||
pet_image.modulate = original_modulate
|
||
|
||
print("🔄 " + pet_name + " 性能状态已重置")
|
||
add_battle_detail_to_panel("🔄 " + pet_name + " 性能状态已重置", Color.GREEN)
|