《英雄联盟》（League of Legends，简称LOL）是由美国拳头游戏（Riot Games）开发、中国内地由腾讯游戏代理运营的英雄对战MOBA竞技网游。游戏里拥有数百个个性英雄，并拥有排位系统、符文系统等特色系统。下面用python写代码。
一.英雄：
1.刀锋舞者·艾瑞莉娅，定位为战士。艾瑞莉娅原称号为“刀锋意志”，8.7版本更新后更名为“刀锋舞者”。
时而似平静的海面，时而似汹涌的风暴。艾瑞莉娅是艾欧尼亚勇猛的捍卫者，她接受过祖辈传承的舞蹈训练，并将舞艺化为战斗的技法。伴随着她优雅的动作，锋利的刀刃在空中组成夺命的阵列翩翩起舞，这位刀锋舞者将斩除任何想要扮演征服者的蠢货。
技能一 ：
被动技能
艾欧尼亚热诚：
艾瑞莉娅在用一个技能命中一名敌人时，会获得可一层持续6秒的效果（最大4层）。每层效果为她提升7.5/13.75/20% 攻击速度，并在满层时她的攻击会造成额外的10-61(1-18级 每级+3)（+20%*AD）魔法伤害。 攻击一名英雄或大型野怪，会刷新效果的持续时间。艾瑞莉娅每命中一名英雄都会获得一层效果，命中多个小兵时仍获得一层效果。
class lonianFervor:
def_init_(self):
self.stacks = 0
self.max_stacks = 4
self.level = 1
self.last_refresh_time = 0
self.duration = 6 # 持续时间6秒
# 攻速加成 per stack:[7.5%，13.75%，20%]for levels[1-6,7-12,13-18]
self.attack_speed_bonus = [0.075,0.1275,0.20]
# 额外魔法伤害 base:10-61(1-18级 每级 + 3）
self.base_magic_damage = 10 + (self.level - 1)*3
self.ad_ratio = 0.20 # 20% AD加成
def get_attack_speed_bonus(self):
"""获取当前攻速加成百分比"""
if self.level <= 6:
bonus_per_stack = self.attack_speed_bonus[0]
elif self.level <= 12:
bonus_per_stack = self.attack_speed_bonus[1]
else:
bonus per stack = self.attack speed bonus[2]
return self.stacks*bonus_per_stack
def get_extra_magic_damage(self,ad):
"""计算满层时的额外魔法伤害"""
return 0
self.base magic damage = 10 + (self.level - 1) * 3
return self.base_magic_damage + (ad * self_ratio)
def on_ability_hit(self,target_type,current_time):
"""
当技能命中敌人时调用
：param target_type:'chamion'(英雄)，
'large_monster'（大型野怪）,'minion'(小兵)
：param current_time:当前游戏时间
"""
if target_type =='champion':
# 命中英雄获得一层并刷新持续时间
self.stacks = min(self.stacks + 1,self.max_stacks)
self.last_refresh_time = current_time
elif target_type == 'large_monster':
# 命中大型野怪获得一层并刷新持续时间
self.stacks = min(self.stacks + 1,self.max_stacks)
self.last_refresh_time = current_time
elif target_type =='minion':
#命中小兵只获得一层（无论命中多少个小兵）
if self.stacks == 0:
self.stacks = 1
self.last_refresh_time = current_time
def on_attack(self,target_type,current_time):
"""
当普攻命中时调用
：param target_type:'champion' or 'large_monster'
: param current_time:当前游戏时间
"""
if target_type in ['chamion','large_monster']:
# 攻击英雄或大型野怪刷新持续时间
if self.stacks > 0 and current_time
self.last_refresh_time = current_time -
self.last refresh time > self.duration:
self.stacks = 0
def level_up(self):
"""升级时调用"""
self.level = min(self.level + 1,18)
#创建被动技能实例
irelia_passive = lonianFervor()
# 设置等级
irelia_passive.level = 9
#技能命中英雄
irelia_passive.on_ability_hit('champion'，
current_time=0)
# 检查攻速加成
attack_speed_bonus =
irelia_passive.get_attack_speed_bonus()
#攻击英雄刷新持续时间
irelia_passive.on_attack('champion',current_time=1)
#计算满层时的额外魔法伤害(假设AD为100)
extra_damage=
irelia_passive.get_extra_magic_damage(ad=100)
# 游戏时间更新
irelia_passive.update(current_time=8) # 在第8秒检查，
此时效果会消失(因为最后一次刷新在第1秒)
这段代码实现了艾瑞莉娅被动技能的主要逻辑，包括：
技能命中不同目标时的层数积累
攻击英雄/大型野怪刷新持续时间
根据等级计算攻速加成和额外魔法伤害
效果持续时间管理
技能二：
Q技能
利刃冲击：
触发:Q
艾瑞莉娅冲向目标，造成55/75/95/115/135物理伤害，附带命中特效并回复相当于9/10/11/12/13%攻击力的生命值。
如果目标被标记，或者被利刃冲击杀死，则刷新冷却时间。
class Irelia:
def_init_(self,attack_damage):
self.attack_damage = attack_damage:
self.attack_damage = attack_damage
self.q_cooldown = 0 # 初始冷却时间为0，表示技能可用
self.q_level = 1 # 初始化技能等级为1
def level_up_q(self)：
"""升级Q技能"""
if self.q_level < 5:
self.q_level += 1
def get_q_damage(self):
"""获取当前Q技能伤害"""
damage_values = [55,75,95,115,135)
return damage_values[self.q_level - 1]
def get_q_heal(self):
"""获取当前Q技能伤害"""
damage_values = [55,75,95,115,135]
return damage_values[self.q_level - 1]
def get_q_heal(self):
"""获取当前Q技能治疗比例"""
heal_percent = [0.09.0.10,0.11,0.12,0.13]
return heal_percent[self.q_level - 1]
def cast_q(self,target,is_marked = False)：
"""
施放Q技能
：parant target:目标对象，需要有is_alive()h和take_damage()方法
：param is_marked:目标是否被标记
：return:是否刷新了冷却时间
"""
if self.q_cooldown > 0:
print("技能冷却中！"）
return False
# 计算伤害和治疗
damage = self.get_q_damage()
heal_amount = self.attack_damage*
self.get_q_heal()
#对目标造成伤害
target.take_damage(damage)
#艾瑞莉娅回复生命值
print（f"艾瑞莉娅施放利刃冲击，造成（damage）点伤害，回复（heal_amount:1f）点生命值）
#检查是否刷新冷却
target killed = not target.alive()
if is_marked or target_killed:
print("利刃冲击冷却时间刷新！"
self.q_cooldown = 0 # 刷新冷却
return True
else:
self.q_cooldown = 6 # 假设基础冷却时间为6秒
return False
def cooldown_tick(self):
"""冷却时间减少1秒"""
if self.q_cooldown > 0:
self.q_cooldown -= 1
#使用示例
if_name_ =="_main_":
#创建一个攻击力为100的艾瑞莉娅
irelia = Irelia(attack_damage=100）
#创建一个生命值为80的目标
target = Target( health =80)
#施放Q技能（目标未被标记）
print("第一次施放Q技能（目标未被标记）:")
irelia.cast_q(target)
#升级Q技能
irelia.level_up_q()
print("\nQ技能升级到2级")
#创建一个新目标（标记状态）
marked target = Target(health=50)
print("\n第二次施放Q技能（目标被标记）：")
irelia.cast_q（marked_target,is_marked=True）
#创建一个低生命值目标
weak_target = Target(health=30
print("\n第三次施放Q技能（击杀目标）：")
irelia.cast_q(weak_target)
这段代码实现了刀锋舞者·艾瑞莉娅的Q技能"利刃冲击"的核心机制：
根据技能等级造成不同伤害
根据攻击力百分比回复生命值
如果目标被标记或被击杀，则刷新冷却时间
包含简单的目标类和技能升级功能
技能三：
W技能
距破之舞：
触发:w
第一次施放：艾瑞莉娅为刀锋蓄力，过程中无法移动或攻击，但短时间内获得50(+10%每100AP)%物理伤害减免。这一引导过程无法被打断。
第二次施放：艾瑞莉娅甩出刀锋，对敌人造成至少10/25/40/55/70(+0.5AD)(+0.4AP)伤害。艾瑞莉娅蓄力的时间每增加0.075秒伤害便提高10%，最高提升100%(0.75秒)。
class Irelia:
def_init_(self,level=1,ad=0,ap=0):
self.w_level = level
self.ad = ad
self.ap = ap
self.is_charging = False
self.charge_start_time = curren_0
self.charge_duration = 0
def first_cast_w(self,curren_time):
"""第一次施放W：开始蓄力"""
self.is_charging = True
self.charge_start_time = current_time
print("艾瑞莉娅开始为刀锋蓄力，获得物理伤害减免！")
#计算物理伤害减免百分比
damage_reduction = 50 + 0.1*(self.ap//100)
print(f"获得{damage_reduction}%物理伤害减免")
def second_cast_w(self,current_time):
"""第二次施放W：施放蓄力后的伤害"""
if not self.is_charging:
print("错误：尚未开始蓄力！"）
retrun 0
self.charge_duration = current_time - self.charge_start_time
self.is_charging = False
#基础伤害
base_damage = [10,25,40,55,70][self.w_level - 1] + 0.5*self.ad + 0.4*self.ap
#计算蓄力加成(每0.075秒则增加10%,最高100%)
charge_bonus = min(self.charge_duration/0.075 * 0.1,1.0)#最高1.0（100%）
total_damage = base_damage*(1+charge_bonus)
print(f"艾瑞莉娅释放蓄力后的刀锋！蓄力时间：{self.charge_duration:.3f}秒")
print(f"造成{total_damage:1f}点伤害（基础：{base_damage:.1f}，蓄力加成：）
{charge_bounus*100:.0f}%)")
return total_damage
#使用示例
if_name_=="_main_":
#创建一个5级W，AD100，AP 300的艾瑞莉娅
irelia = Irelia(level=5,ad=100,ap=300)
#第一次施放W开始蓄力（假设游戏时间0秒）
irelia.first_cast_w(current_time=0)
#模拟蓄力0.6秒后第二次施放W
damage = irelia.second_cast_w(current_time=0.6)
#输出结果
print(f"实际造成伤害：{damage:1f}")
这段代码实现了艾瑞莉娅W技能的主要功能：
first_cast_w()方法处理第一次施放，开始蓄力并计算物理伤害减免
second_cast_w()方法处理第二次施放，根据蓄力时间计算伤害
伤害计算包括：
基础伤害随技能等级提升
AD和AP加成
蓄力时间加成（每0.075秒增加10%伤害，最高100%）
物理伤害减免根据AP计算（50% + 每100AP增加10%）
技能四：
E技能
比翼双刃:
艾瑞莉娅将一片刀锋投向一个地点，随后再次施放比翼双刀，将第二片刀锋投向另一个地点。两片刀锋将互相飞向彼此的位置，交错过程中对敌人造成80/125/170/215/260(+0.8AP)魔法伤害并使其晕眩0.75秒。比翼双刀也将对英雄和大型野怪进行标记，持续5秒。
class Irelia:
def_init_(self,level=1,ap=0):
self.level= level
self.ap = ap
self.e_damage = [80,125,170,215,260]
self.stun_duration = 0.75
self.mark_duration = 5
self.first_blade = None
self.second_blade = None
self.marked_targets = {} # 存储被标记的目标及其剩余时间
def cast_first_blade(self,position):
"""施放第一片刀锋"""
self.first_blade = position
print(f"第一片刀锋已放置在位置：{position}")
def cast_second_blade(self,position):
"""施放第二片刀锋并触发效果"""
if self.first_blade is None:
print("错误：需要先施放第一片刀锋！"）
return
self.second_blade = position
print(f"第二片刀锋以放置在位置：{position}")
self._trigger_blades()
def -trigger_blades(self):
"""触发两片刀锋的效果"""
print("两片刀锋开始向彼此飞行！"）
#模拟刀锋飞行过程中检测到的敌人
enemies_in_path = self._detect_enemies_between_blades()
if enemies_in_path:
print(f"刀锋命中了{len(enemies_in_path)}个敌人！"）
#计算伤害
damage = self.e_damage[self.level - 1] + 0.8 * self.ap
print(f"每个敌人收到{damage}点魔法伤害并眩晕{self.stun_duration}秒"}
#标记英雄和大型野怪
for enemy in enemies_in_path:
if enemy['type']in['hero','large_monster']:
self._apply_mark(enemy['id'])
#重置刀锋位置
self.first_blade = None
self.second_blade = None
def _detect_enemies_between_blades（self）:
"""模拟检测两片刀锋之间的敌人（简化版）"""
# 在实际游戏中，这会使用碰撞检测算法
# 这里我们返回一些模拟的敌人数据
return[
{'id':1,'type':'hero','name':'敌方英雄1'},
{'id':2,'type':'minion','name':'小兵1'},
{'id':3，'type':'large_monster'，'name':'大型野怪'}
]
def _apply_mark(self, target_id):
"""应用标记效果"""
self.marked_targets[target_id] = self.mark_duration
print(f"目标 {target_id} 被标记，持续 {self.mark_duration} 秒")
def update_marked_targets(self, delta_time):
"""更新标记剩余时间"""
for target_id in list(self.marked_targets.keys()):
self.marked_targets[target_id] -= delta_time
if self.marked_targets[target_id] <= 0:
del self.marked_targets[target_id]
print(f"目标 {target_id} 的标记已消失")
# 使用示例
if __name__ == "__main__":
# 创建一个5级，有100AP的艾瑞莉娅
irelia = Irelia(level=5, ap=100)
# 施放第一片刀锋
irelia.cast_first_blade((100, 200))
# 施放第二片刀锋
irelia.cast_second_blade((150, 250))
# 更新标记状态(例如游戏每帧调用)
irelia.update_marked_targets(1.0) # 假设过了1秒
这个代码模拟了技能的基本逻辑，包括刀锋的放置、伤害计算、眩晕效果和标记功能。这是一个简化的模拟实现，实际的游戏实现会涉及更复杂的物理碰撞检测、网络同步和游戏引擎集成等。这个代码主要用于演示技能的基本逻辑。
这段代码实现了以下功能：
可以分别施放两片刀锋
当两片刀锋都施放后，会触发伤害和眩晕效果
对英雄和大型野怪施加标记
标记有持续时间，并会随时间更新
技能五：
R技能
先锋之刃:
艾瑞莉娅沿直线方向释放全部刀锋之力。如果先锋之刃命中敌方英雄，则会向外圈散射，对敌方英雄和大型野怪造成125/250/375(+0.7AP)魔法伤害并标记5秒，同时在2.5秒内形成一道刀锋铁幕。穿过铁幕的敌人将受到125/250/375(+0.7AP)魔法伤害和90%减速效果。
class Irelia:
def __init__(self, ap=0, skill_level=1):
"""
初始化艾瑞莉娅的R技能
:param ap: 法术强度
:param skill_level: R技能等级 (1, 2, 3)
"""
self.ap = ap
self.skill_level = skill_level
self.damage_values = {1: 125, 2: 250, 3: 375} # 各级基础伤害
self.scaling = 0.7 # AP加成系数
self.mark_duration = 5 # 标记持续时间(秒)
self.barrier_duration = 2.5 # 刀锋铁幕持续时间(秒)
self.slow_percent = 0.9 # 减速百分比
def cast_r_ability(self, target_hit, target_position):
"""
施放R技能
:param target_hit: 是否命中敌方英雄
:param target_position: 目标位置
:return: 伤害效果和减速效果
"""
result = {
'initial_hit': False,
'initial_damage': 0,
'barrier_created': False,
'barrier_damage': 0,
'slow_applied': False
}
if target_hit:
# 计算初始伤害
base_damage = self.damage_values[self.skill_level]
total_damage = base_damage + (self.ap * self.scaling)
result['initial_hit'] = True
result['initial_damage'] = total_damage
# 创建刀锋铁幕
result['barrier_created'] = True
print(f"刀锋铁幕在位置 {target_position} 形成，持续 {self.barrier_duration} 秒")
return result
def barrier_effect(self, enemy_passed):
"""
刀锋铁幕效果
:param enemy_passed: 是否有敌人穿过铁幕
:return: 伤害和减速效果
"""
result = {
'damage': 0,
'slow_applied': False
}
if enemy_passed:
# 计算铁幕伤害(与初始伤害相同)
base_damage = self.damage_values[self.skill_level]
total_damage = base_damage + (self.ap * self.scaling)
result['damage'] = total_damage
result['slow_applied'] = True
print(f"敌人穿过刀锋铁幕，受到 {total_damage} 魔法伤害并被减速 {self.slow_percent*100}%")
return result
# 使用示例
if __name__ == "__main__":
# 创建一个AP为100，R技能等级3的艾瑞莉娅
irelia = Irelia(ap=100, skill_level=3)
# 施放R技能并命中敌方英雄
cast_result = irelia.cast_r_ability(target_hit=True, target_position=(100, 200))
# 敌人穿过刀锋铁幕
barrier_result = irelia.barrier_effect(enemy_passed=True)
这个代码包含了技能命中逻辑、伤害计算和减速效果：
这段代码实现了：
艾瑞莉娅R技能的基本逻辑，包括：
初始命中敌方英雄时的伤害计算
刀锋铁幕的形成
敌人穿过铁幕时的伤害和减速效果
伤害计算考虑了：
技能等级基础伤害
法术强度(AP)加成
效果包括：
初始命中伤害
铁幕伤害(与初始伤害相同)
90%的减速效果
你可以根据需要扩展这个代码，比如添加更多敌人目标、更复杂的位置计算或与其他技能的交互逻辑
2.光辉女郎·拉克丝，是盖伦的妹妹，擅长使用光魔法，不仅出身显赫、身份尊贵，并且长得好看，穿的好看。
技能一：
被动技能
光芒四射：
拉克丝的伤害型技能会标记目标6秒。拉克丝的攻击会消耗该标记，以造成20~190(1-18级 每级+10) （+20％AP）魔法伤害。 终极闪光在命中敌人时将先消耗标记然后刷新标记。
class LuxPassive:
def_init_(self):
self.marked_targets = {} # 存储被标记的目标及其剩余时间
self.level = 1
self.ability_power = 0
def update_stats(self,level,ability_power):
"""更新拉克丝的等级和法术强度"""
self.level = level
self.ability_power = ability_power
def calculate_passive_damage(self):
"""计算被动技能的伤害"""
base_damage = 10 + (self.level - 1)*10 # 1级20，每级 + 10,18级190
scaling_damage = 0.2*self.ability_power # 20%AP加成
return base_damage + scaling_damage
def apply_mark(self,target_id,duration=6):
"""施加标记到目标"""
self.marked_targets[target_id] = duration
def consume_mark(self,target_id,is_ultimate=False):
"""消耗目标的标记并返回伤害值"""
if target_id not in self.marked_targets:
return 0
damage = self.calculate_passive_damage()
#如果是终极闪光，先消耗标记然后刷新
if is_ultimate:
self.marked_targets[target_id] = 6 # 刷新标记持续时间
else:
del self.marked_targets[target_id] #移除标记
return damage
def update_marks(self,delta_time):
"""更新所有标记的剩余时间"""
expired_targets = []
for target_id,duration in self.marked_targets.items():
self.marked_targets[target_id]
def has_mark9(self,target_id):
"""检查目标是否有标记"""
return target_id in self.marked_targets
#使用示例
if_name_=="_main_":
Lux_passive = LusPassive()
#更新拉克丝属性（等级18,200AP）
lux_passive.update_stats(18,200)
#拉克丝用技能命中敌人（假设敌人ID为1）
lux_passive.apply_mark(1)
#检查敌人是否有标记
print(f"敌人是否有标记：{lux_passive.has_mark(1)}"}
#拉克丝普通攻击触发被动
damage = lux_passive.consume_mark(1)
print(f"被动触发造成伤害：{damage}")
print(f"触发后敌人1是否有标记：{lux_passive.has_mark(1)}")
#终极闪光特殊处理
lux_passive.apply_mark(1)#再次标记
ultimate_damage = lux_passive.cosume_mark(1,is_ultimate=True)
print（f"终极闪光触发被动造成伤害：{ultimate_damage}"）
print(f"终极闪光后敌人1是否有标记：{lux_passive.has_mark(1}}")
这段代码实现了拉克丝被动技能的主要功能：
根据等级和AP计算被动伤害
管理被标记的目标及其持续时间
处理普通攻击和终极闪光对标记的不同消耗方式
提供方法来更新标记持续时间
你可以根据需要将这个类集成到更大的游戏系统中，或者调整数值计算方式来匹配实际的游戏机制。
技能二：
Q技能
光之束缚：
拉克丝朝目标地点发射一团光球，束缚前2名敌人2秒并对每个敌人造成80/125/170/215/260（+60％AP）魔法伤害。
class Lux:
def __init__(self, ap=0, skill_level=1):
"""
初始化拉克丝的光之束缚技能
:param ap: 法术强度
:param skill_level: 技能等级 (1-5)
"""
self.ap = ap
self.skill_level = skill_level
def light_binding(self):
"""
释放光之束缚技能
返回：造成的伤害值和束缚时间
"""
#基础伤害随技能等级变化
base_damage = [80,125,170,215,260][self.skill_level - 1]
#计算总伤害（基础伤害+AP加成）
total_damage = base_damage + 0.6*self.ap
#束缚时间固定2秒
snare_duration = 2.0
return{
"damage"：total_damage,
"snare_duration":snare_duration,
"max_targets":2,
"message":f"拉克丝释放光之束缚，造成{total_damage:.1f}点魔法伤害，并束缚敌人{snare_duration}秒"
}
#使用示例
if_name_=="_mian_":
#创建一个拉克丝实例，AP为100，Q技能等级3
lux = Lux(ap=100,skill_level=3)
#释放Q技能
result = lux.light_binding()
print(result["message"])
print(f"详细信息：伤害{result['damage']},束缚时间{result['snare_duratio']}秒，最终影响{result['max_targets']}个目标")
这段代码实现了：
创建一个拉克丝类，可以设置AP(法术强度)和Q技能等级
light_binding()方法计算Q技能的伤害和效果
伤害计算包括基础伤害(随技能等级变化)和AP加成(60%AP)
束缚时间固定为2秒
最多影响2个目标(虽然代码中没体现目标选择逻辑，但用max_targets标明了)
返回包含伤害值、束缚时间和描述信息的字典
你可以根据需要扩展这个类，比如添加目标选择逻辑、冷却时间等其他游戏机制。
技能三：
W技能
曲光屏障 ：
拉克丝扔出她的魔杖，为它途经的友军提供40/55/70/85/100 (+35% 法术强度) 护盾。随后它会折返，为它途经的友军提供等额的护盾。 两段护盾可以叠加。
class Lux:
def_init_(self,ap):
self.ap = ap # 法术强度
self.w_level = 1 # W技能等级，默认为1
def set w_level(self,level):
"""设置W技能等级（1-5）"""
if 1 <=level <=5：
self.w_level = level
else:
print("W技能等级应在1-5之间")
def get_shield_amount(self):
"""计算基础护盾值"""
base_shield = [40,55,70,85,100][self.w_level - 1]
return base_shield + 0.35 * self.ap
def cast_w(self,allies_hit_first_pass，allies_hit_second_pass):
"""
施放W技能
：papram allies_hit_first_pass:第一段路径命中的友军列表
：param allies_hit_second_pass:第二段路径命中的友军列
：return:每个友军获得的总护盾值字典
"""
shield_amount = self.get_shield_amount()
shield_dict = {}
#第一段护盾
for ally in allies_hit_first_pass:
shield_dict[ally] = shield_dict.get(ally,0) + shield_amount
#第二段护盾
for ally in allies_hit_first_pass；
shield_dict[ally] = shield_dict.get(ally,0) + shield_amount
return shield_dict
#使用示例
if_name_=="_main_":
#创建一个拥有100法术强度的拉克丝
lux = Lux(ap=100)
lux.set_w_level(3) #设置W等级为3
#假设第一段命中了友军A和B，第二段命中了友军B和C
allies_first_pass = ["Ally A","Ally B"]
allies_second_pass = ["Ally B","Ally C"]
#施放W技能
shields = lux.cast_w(allies_first_pass,allies_second_pass)
#显示结果
print(" 护盾效果：")
for ally,amount in shields.items():
print(f"{ally}:{amount:.1f}护盾值"）
#计算示例验证
expected_shield = 70 + 0.35 * 100 # 70 +35 = 105
print(f\n验证(等级3,100AP):单段护盾应为{expected_shield}")
print("Ally B应获得双倍护盾：",expected_shield * 2)
这段代码实现了：
Lux类包含法术强度(AP)和W技能等级属性
根据技能等级和AP计算护盾值
cast_w方法模拟施放技能，接受两段路径命中的友军列表
护盾可以叠加（同一友军被两段命中则护盾值加倍）
护盾效果:
Ally A: 105.0 护盾值
Ally B: 210.0 护盾值
Ally C: 105.0 护盾值
验证(等级3, 100AP): 单段护盾应为105.0
Ally B应获得双倍护盾: 210.0
技能四：
E技能
透光奇点：
拉克丝创造一个光明地带，显形该区域并使区域中的敌人减速25/30/35/40/45%。在5秒后或再次施放这个技能后，它会爆炸，造成70/120/170/220/270 (+70%法术强度)魔法伤害并减速额外的1秒。
class Lux:
def_init_(self,ap)：
self.ap = ap # 法术强度
self.e_level = 1 # E技能等级，默认为1
self.e_zones = {} #存储活跃的光明地带{zone_id:{"position":(x,y),"timer":5}}
def set_e_level(self,level):
"""设置E技能等级（1-5）"""
if 1 <= level <= 5：
self.e_level = level
else:
print("E技能应在1-5之间")
def get_slow_percent(self):
"""获取减速百分比"""
return[25,30,35,40,45][self.e_level - 1]
def get_damage_amount(self):
"""计算爆炸伤害"""
base_damage =[70,120,170,220,270][self.e_level - 1]
return base_damage + 0.7 * self.ap
def cast_e(self,position,enemies_in_zone):
"""
施放E技能-创建光明地带
：param position:技能施放位置（x,y）
:param enemies_in_zone:区域内的敌人列表
：return:减速效果应用结果
"""
zone_id = len(self.e_zones) + 1
self.e_zones[zone_id] = {
"position":position,
"timer"：5，#5秒后自动爆炸
"enemies_affected":enemies_in_zone
}
slow_percent = self.get_slow_percent()
result = {
"action":"zone_created",
"zone_id":zone_id,
"position":position,
"enemies_slowed"：[(enemy,slow_percent)for enemy in enemies_in_zone]
}
return result
def detonate_e(self,zone_id):
"""
引爆光明地带（手动引爆或超时自动引爆）
：param zone_id:要引爆的区域ID
：return:被自动引爆的列表
"""
detonated_zones = []
for zone_id in list(self.e_zones.keys()):
self.e_zones[zone_id]["timer"] -= delta_time
if self.e_zones[zone_id]["timer"] <= 0：
detonated_zones.append(self.detonate_e(zone_id))
return detonated_zones
#使用示例
if_name_=="_main_":
#创建一个拥有150法术强度的拉克丝
lux = Lux(ap=150)
lux,set_e_level(2) # 设置E等级为2
#施放E技能在位置（100,200），命中敌人A和B
cast_result = lux.cast_e(position=(100,200),
enemies_in_zone=["Enemy A","Enemy B"])
print("施放E技能结果:")
print(f"在位置{cast_result['position']}创建光明地带"）
for enemy,slow in cast_result["enemies_slowed"]:
print(f"{enemy}被减速{slow}%")
#模拟3秒后
print("\n手动引爆E技能："
detonate_result = lux.detonate_e(1)
for enemy, damage in detonate_result["damage_dealt"]:
print(f"{enemy} 受到 {damage:.1f} 伤害")
for enemy, slow in detonate_result["enemies_slowed"]:
print(f"{enemy} 被额外减速 {slow}% 持续1秒")
# 计算示例验证
expected_damage = 120 + 0.7 * 150 # 120 + 105 = 225
print(f"\n验证(等级2, 150AP): 爆炸伤害应为{expected_damage}")
这段代码实现了：
Lux类包含法术强度(AP)和E技能等级属性
跟踪多个活跃的光明地带及其计时器
根据技能等级和AP计算减速百分比和爆炸伤害
两种引爆方式：手动引爆或5秒后自动引爆
爆炸后造成伤害并施加额外1秒减速
示例输出：
施放E技能结果:
在位置 (100, 200) 创建光明地带
Enemy A 被减速 30%
Enemy B 被减速 30%
3秒后...
剩余时间: 2.0秒
手动引爆E技能:
Enemy A 受到 225.0 伤害
Enemy B 受到 225.0 伤害
Enemy A 被额外减速 30% 持续1秒
Enemy B 被额外减速 30% 持续1秒
验证(等级2, 150AP): 爆炸伤害应为225.0
技能五：
R技能
终极闪光：
拉克丝发射一束耀目的光能射线，对一条直线上的所有敌人造成300/400/500（+100％AP）魔法伤害。
class Lux:
def __init__(self, ap=0, skill_level=1):
"""
初始化拉克丝属性
:param ap: 当前法术强度
:param skill_level: 大招等级 (1/2/3)
"""
self.ap = ap
self.skill_level = skill_level
self.base_damage = {1: 300, 2: 400, 3: 500} # 各等级基础伤害
def final_spark_damage(self):
"""计算终极闪光的理论伤害"""
return self.base_damage[self.skill_level] + self.ap * 1.0 # 100% AP加成
def hit_enemies(self, enemies_in_line):
"""
模拟命中直线上的敌人
:param enemies_in_line: 直线上的敌人列表 (假设每个敌人是一个字典，包含魔抗等信息)
:return: 每个敌人实际受到的伤害列表
"""
damage = self.final_spark_damage()
results = []
for enemy in enemies_in_line:
# 简单模拟魔抗减免 (假设魔抗公式为 100/(100+MR))
magic_resist = enemy.get('magic_resist', 0)
damage_reduction = 100 / (100 + magic_resist)
actual_damage = damage * damage_reduction
results.append({
'name': enemy.get('name', 'Unknown'),
'damage_dealt': actual_damage,
'is_killed': actual_damage >= enemy.get('hp', 0)
})
return results
# 示例使用
if __name__ == "__main__":
# 创建一个AP=300、大招等级3的拉克丝
lux = Lux(ap=300, skill_level=3)
# 直线上的3个敌人 (假设有不同魔抗和血量)
enemies = [
{'name': 'Ashe', 'hp': 800, 'magic_resist': 30},
{'name': 'Zed', 'hp': 1200, 'magic_resist': 50},
{'name': 'Soraka', 'hp': 600, 'magic_resist': 20}
]
# 计算伤害结果
damage_results = lux.hit_enemies(enemies)
# 打印输出
print(f"拉克丝大招伤害 (AP加成后): {lux.final_spark_damage()}")
for result in damage_results:
status = "击杀!" if result['is_killed'] else "未击杀"
print(f"{result['name']} 受到伤害: {result['damage_dealt']:.1f} → {status}")
输出示例：
拉克丝大招伤害 (AP加成后): 800.0
Ashe 受到伤害: 615.4 → 未击杀
Zed 受到伤害: 533.3 → 未击杀
Soraka 受到伤害: 666.7 → 击杀!
功能说明：
基础伤害计算：根据技能等级和AP值计算理论伤害。
魔抗减免：使用简化的魔抗公式 (100/(100+MR)) 计算实际伤害。
命中判断：支持多个敌人同时被命中，并反馈是否击杀。
二.野怪：
1.暗影狼：
暗影狼属于非史诗级野怪，暗影狼是一个快速的近战野怪。同大型暗影狼生活在一起，击杀获得少量金钱及经验。
class ShadowWolf:
"""模拟暗影狼野怪（非史诗级野怪）"""
def __init__(self, is_large=False):
"""
初始化暗影狼属性
:param is_large: 是否为大型暗影狼（默认为小型）
"""
self.is_large = is_large
self.health = 1200 if is_large else 450 # 大型狼血量较高
self.attack_damage = 35 if is_large else 16
self.attack_range = "近战"
self.movement_speed = 443 # 游戏内实际移速（单位：游戏单位/秒）
self.gold_reward = 55 if is_large else 10 # 击杀金钱奖励
self.exp_reward = 120 if is_large else 30 # 击杀经验奖励
self.respawn_time = 150 # 重生时间（秒）
def attack(self, target):
"""模拟攻击目标（简化版）"""
damage_dealt = self.attack_damage
print(f"暗影狼{'（大型）' if self.is_large else ''} 对 {target} 造成 {damage_dealt} 点物理伤害！")
return damage_dealt
def die(self, killer):
"""被击杀时的奖励逻辑"""
print(f"{killer} 击杀了暗影狼{'（大型）' if self.is_large else ''}！")
print(f"获得 {self.gold_reward} 金币 和 {self.exp_reward} 经验值")
return {
'gold': self.gold_reward,
'exp': self.exp_reward,
'respawn_timer': self.respawn_time
}
# 示例使用
if __name__ == "__main__":
# 创建1只大型暗影狼和2只小型暗影狼
large_wolf = ShadowWolf(is_large=True)
small_wolf1 = ShadowWolf()
small_wolf2 = ShadowWolf()
# 模拟攻击玩家
large_wolf.attack("玩家-赵信")
small_wolf1.attack("玩家-拉克丝")
# 模拟被击杀
rewards = large_wolf.die("玩家-李青")
print(f"击杀奖励详情: {rewards}")
# 输出野怪基础信息
print(f"\n大型暗影狼属性: 血量={large_wolf.health} 攻击力={large_wolf.attack_damage}")
print(f"小型暗影狼属性: 血量={small_wolf1.health} 攻击力={small_wolf1.attack_damage}")
输出示例：
暗影狼（大型） 对 玩家-赵信 造成 35 点物理伤害！
暗影狼 对 玩家-拉克丝 造成 16 点物理伤害！
玩家-李青 击杀了暗影狼（大型）！
获得 55 金币 和 120 经验值
击杀奖励详情: {'gold': 55, 'exp': 120, 'respawn_timer': 150}
大型暗影狼属性: 血量=1200 攻击力=35
小型暗影狼属性: 血量=450 攻击力=16
关键设计说明：
双类型区分：通过 is_large 参数区分大型/小型暗影狼，属性不同
战斗模拟：
近战攻击逻辑（可扩展为真实战斗循环）
击杀后返回金币、经验和重生时间
数据真实性：基于游戏实际数据设定属性（血量/伤害/奖励等）
扩展建议：
添加野怪刷新机制（基于 respawn_time 计时）
实现野怪仇恨系统（追击/返回逻辑）
结合地图坐标模拟野怪营地位置
2.峡谷迅捷蟹:
峡谷迅捷蟹，属于非史诗级野怪，一个难以捉摸的巡逻野怪，无攻击性。击杀这个野怪会在这条河中提供一个速度圣坛，为经过的友军提供速度加成，并且会被动的提供视野。这个新的中立怪，是为了增加河道控制力，作为大龙或是小龙的据点，或是在前期提供保护或是阻止河道gank。非敌意，看到敌方英雄会跑走。
import time
class RiftScuttler:
"""模拟峡谷迅捷蟹（河道蟹）"""
def __init__(self):
self.health = 1200 # 血量
self.movement_speed = 500 # 基础移速（逃跑时加速）
self.gold_reward = 70 # 击杀金币
self.exp_reward = 115 # 击杀经验
self.respawn_time = 150 # 重生时间（秒）
self.is_alive = True
self.speed_shrine_active = False # 速度圣坛状态
self.vision_radius = 1000 # 提供的视野范围（游戏单位）
self.flee_speed_multiplier = 1.5 # 逃跑时移速加成
def detect_enemy(self, enemy_team):
"""检测到敌方英雄时逃跑"""
if self.is_alive and enemy_team:
print(f"峡谷迅捷蟹发现了敌方英雄 {enemy_team}，开始逃跑！")
self.movement_speed *= self.flee_speed_multiplier
return True
return False
def die(self, killer_team):
"""被击杀时生成速度圣坛"""
if self.is_alive:
self.is_alive = False
self.speed_shrine_active = True
print(f"{killer_team} 击杀了峡谷迅捷蟹！")
print(f"生成速度圣坛，为友军提供加速效果和视野（半径={self.vision_radius}）")
return {
'gold': self.gold_reward,
'exp': self.exp_reward,
'shrine_active': True,
'respawn_timer': self.respawn_time
}
return None
def respawn(self):
"""重生逻辑"""
time.sleep(self.respawn_time) # 模拟重生等待
self.is_alive = True
self.speed_shrine_active = False
self.movement_speed = 500 # 重置移速
print("峡谷迅捷蟹已重生！")
return True
# 示例使用
if __name__ == "__main__":
scuttler = RiftScuttler()
# 模拟敌方英雄接近
scuttler.detect_enemy(["敌方-劫"])
# 模拟被击杀
rewards = scuttler.die("友方-赵信")
print(f"击杀奖励: {rewards}")
# 模拟圣坛效果（简化版）
if rewards['shrine_active']:
print(">>> 友军经过圣坛将获得速度加成和视野")
# 模拟重生（实际游戏中由服务器计时控制）
# scuttler.respawn() # 需异步执行
输出示例：
峡谷迅捷蟹发现了敌方英雄 ['敌方-劫']，开始逃跑！
友方-赵信 击杀了峡谷迅捷蟹！
生成速度圣坛，为友军提供加速效果和视野（半径=1000）
击杀奖励: {'gold': 70, 'exp': 115, 'shrine_active': True, 'respawn_timer': 150}
>>> 友军经过圣坛将获得速度加成和视野
核心机制实现：
逃跑行为：
检测到敌方英雄时触发移速加成（flee_speed_multiplier）
战略资源：
击杀后生成速度圣坛（speed_shrine_active）和视野（vision_radius）
无攻击性：
省略战斗逻辑，专注移动和交互
扩展建议：
动态路径计算：实现蟹的逃跑路径（通常向相反方向移动）
团队归属判定：圣坛仅对击杀方团队生效
战争迷雾集成：与游戏视野系统联动
3.苍蓝雕纹魔像（蓝BUFF）：
属于非史诗级野怪。原身为远古魔像。苍蓝雕纹魔像是一个强大且耐揍的近战野怪，生命值为2000，攻击力73，攻击速度0.49，护甲10，魔抗-15，移动速度150，随等级成长的生命值100-170%，随等级成长的护甲100-300%，在击杀时会提供洞悉之冠能够极大的恢复法力值和能量恢复。
class BlueSentinel:
"""模拟苍蓝雕纹魔像（蓝BUFF野怪）"""
def __init__(self, game_time=0):
"""
:param game_time: 游戏时间（分钟），用于属性成长计算
"""
self.base_health = 2000
self.base_attack = 73
self.attack_speed = 0.49
self.base_armor = 10
self.base_magic_resist = -15 # 负魔抗意味着承受更多魔法伤害
self.movement_speed = 150
self.is_alive = True
self.gold_reward = 80
self.exp_reward = 180
self.respawn_time = 300 # 5分钟重生
self.game_time = game_time
# 动态计算成长属性
self._calculate_scaling_stats()
def _calculate_scaling_stats(self):
"""根据游戏时间计算成长属性（简化版）"""
# 成长比例：随时间线性增长（0-30分钟）
time_scale = min(self.game_time / 30, 1.0) # 30分钟后停止成长
# 生命值成长：100%-170%
self.health = self.base_health * (1 + 0.7 * time_scale)
# 护甲成长：100%-300%
self.armor = self.base_armor * (1 + 2 * time_scale)
# 魔抗固定为-15（不成长）
self.magic_resist = self.base_magic_resist
def attack(self, target):
"""近战攻击目标"""
damage = self.base_attack
print(f"苍蓝雕纹魔像 对 {target} 造成 {damage} 点物理伤害！")
return damage
def take_damage(self, damage, damage_type="physical"):
"""承受伤害（区分物理/魔法伤害）"""
if damage_type == "physical":
actual_damage = damage * (100 / (100 + self.armor))
elif damage_type == "magic":
actual_damage = damage * (100 / (100 + self.magic_resist)) # 负魔抗会放大伤害
else:
actual_damage = damage
self.health -= actual_damage
print(f"苍蓝雕纹魔像 受到 {actual_damage:.1f} 点{damage_type}伤害，剩余血量：{self.health:.1f}")
if self.health <= 0:
self.die()
return actual_damage
def die(self, killer=""):
"""被击杀时提供蓝BUFF"""
self.is_alive = False
print(f"{killer} 击杀了苍蓝雕纹魔像！")
print(">>> 获得【洞悉之冠】效果：持续回复法力/能量，并减少技能冷却！")
return {
'gold': self.gold_reward,
'exp': self.exp_reward,
'buff': {
'name': '洞悉之冠',
'effect': "每秒回复1%最大法力/能量，+10%冷却缩减",
'duration': 120 # BUFF持续时间（秒）
}
}
def respawn(self):
"""重生逻辑（需游戏引擎计时触发）"""
self.is_alive = True
self._calculate_scaling_stats() # 重生后重新计算属性
print("苍蓝雕纹魔像已重生！")
# 示例使用
if __name__ == "__main__":
# 创建蓝BUFF（假设游戏时间15分钟）
blue_buff = BlueSentinel(game_time=15)
# 显示属性（受成长影响）
print(f"苍蓝雕纹魔像属性（15分钟）:")
print(f"生命值: {blue_buff.health:.1f}（基础2000，成长+70%）")
print(f"护甲: {blue_buff.armor:.1f}（基础10，成长+200%）")
print(f"魔抗: {blue_buff.magic_resist}（固定负值）")
# 模拟战斗
blue_buff.attack("玩家-盲僧")
blue_buff.take_damage(350, "physical") # 物理伤害
blue_buff.take_damage(500, "magic") # 魔法伤害（负魔抗承受更多）
# 击杀奖励
if not blue_buff.is_alive:
rewards = blue_buff.die("玩家-卡牌大师")
print(f"击杀奖励详情: {rewards}")
输出示例：
苍蓝雕纹魔像属性（15分钟）:
生命值: 2700.0（基础2000，成长+70%）
护甲: 20.0（基础10，成长+200%）
魔抗: -15（固定负值）
苍蓝雕纹魔像 对 玩家-盲僧 造成 73 点物理伤害！
苍蓝雕纹魔像 受到 291.7 点physical伤害，剩余血量：2408.3
苍蓝雕纹魔像 受到 588.2 点magic伤害，剩余血量：1820.1
玩家-卡牌大师 击杀了苍蓝雕纹魔像！
>>> 获得【洞悉之冠】效果：持续回复法力/能量，并减少技能冷却！
击杀奖励详情: {'gold': 80, 'exp': 180, 'buff': {'name': '洞悉之冠', 'effect': '每秒回复1%最大法力/能量，+10%冷却缩减', 'duration': 120}}
关键设计：
属性成长系统：
生命值和护甲随游戏时间成长（15分钟时生命+35%，护甲+100%）
负魔抗始终放大魔法伤害
蓝BUFF效果：
击杀后提供持续120秒的回复+冷却缩减效果
战斗模拟：
区分物理/魔法伤害计算
近战攻击逻辑
扩展方向：
添加BUFF持有者状态管理
实现野怪仇恨系统（追击/返回逻辑）
与打野装备/符文互动（如惩戒伤害计算）
4.纳什男爵：
刷新时间：20分钟
【男爵之手】
大幅增加攻击力和法术强度，回程时间从8秒降低到4秒。附近小兵获得你90%的移动速度以及一个额外效果。
近战小兵：降低所有受到伤害80%。
远程小兵：射程提高以及伤害小幅提升的。
炮车：射程大幅提高，能超过防御塔。攻击速度会放慢，造成AoE效果，并且对于防御塔造成四倍伤害。
超级兵：在敌人附近时，获得75%的移动速度以及25%的攻击速度。
class BaronNashor:
"""模拟纳什男爵（史诗级野怪）"""
def __init__(self):
self.health = 9000 # 高额血量
self.attack_damage = 240 # 高攻击力
self.respawn_time = 420 # 7分钟重生（首次刷新在20分钟）
self.is_alive = False
self.initial_spawn_time = 20 * 60 # 首次刷新时间（秒）
self.buff_duration = 210 # 男爵之手BUFF持续时间（3分30秒）
def spawn(self, current_game_time):
"""首次刷新或重生"""
if current_game_time >= self.initial_spawn_time and not self.is_alive:
self.is_alive = True
print(f"纳什男爵已在河道出生！当前游戏时间：{current_game_time//60}分{current_game_time%60}秒")
return True
return False
def die(self, killer_team):
"""被击杀时赋予男爵之手BUFF"""
if self.is_alive:
self.is_alive = False
print(f"{killer_team} 击杀了纳什男爵！获得【男爵之手】强化效果：")
print(">>> 攻击力+40 | 法术强度+40 | 回城时间缩短至4秒")
print(">>> 附近小兵获得强化效果：")
self._apply_minion_buffs(killer_team)
return {
'buff': {
'name': 'Baron\'s Hand',
'ad_bonus': 40,
'ap_bonus': 40,
'recall_time_reduction': 4, # 秒
'duration': self.buff_duration
},
'respawn_timer': self.respawn_time
}
return None
def _apply_minion_buffs(self, team):
"""对小兵施加强化效果（简化版）"""
minion_types = ['Melee', 'Ranged', 'Cannon', 'Super']
buffs = {
'Melee': "减伤80%",
'Ranged': "射程+50 | 伤害+30",
'Cannon': "射程+200 | 对塔4倍伤害 | 攻击附带AOE",
'Super': "附近有敌人时：移速+75% | 攻速+25%"
}
for m_type in minion_types:
print(f" - {m_type}小兵: {buffs[m_type]}")
def respawn(self, current_game_time):
"""重生逻辑（需游戏引擎调用）"""
if not self.is_alive and current_game_time >= self.initial_spawn_time:
self.is_alive = True
print(f"纳什男爵已重生！当前游戏时间：{current_game_time//60}分{current_game_time%60}秒")
return True
return False
# 示例使用
if __name__ == "__main__":
baron = BaronNashor()
# 模拟游戏时间推进（20分钟时首次刷新）
game_time = 20 * 60 # 20分钟（秒）
if baron.spawn(game_time):
print("\n--- 纳什男爵战斗开始 ---")
# 模拟击杀
rewards = baron.die("蓝色方团队")
print(f"\nBUFF详情: {rewards['buff']}")
print(f"下次重生时间: {rewards['respawn_timer']//60}分钟后")
# 模拟重生（27分钟时）
game_time += rewards['respawn_timer']
baron.respawn(game_time)
输出示例：
纳什男爵已在河道出生！当前游戏时间：20分0秒
--- 纳什男爵战斗开始 ---
蓝色方团队 击杀了纳什男爵！获得【男爵之手】强化效果：
>>> 攻击力+40 | 法术强度+40 | 回城时间缩短至4秒
>>> 附近小兵获得强化效果：
- Melee小兵: 减伤80%
- Ranged小兵: 射程+50 | 伤害+30
- Cannon小兵: 射程+200 | 对塔4倍伤害 | 攻击附带AOE
- Super小兵: 附近有敌人时：移速+75% | 攻速+25%
BUFF详情: {'name': "Baron's Hand", 'ad_bonus': 40, 'ap_bonus': 40, 'recall_time_reduction': 4, 'duration': 210}
下次重生时间: 7分钟后
纳什男爵已重生！当前游戏时间：27分0秒
核心机制实现：
刷新控制：
首次在20分钟刷新，之后每7分钟重生
男爵之手BUFF：
直接增益：AD/AP提升 + 回城加速
小兵强化：根据兵种类型提供不同效果
战略决策点：
BUFF持续3分30秒，影响推进/防守节奏
扩展建议：
动态小兵生成：将BUFF效果绑定到实际小兵对象
团队状态同步：仅对击杀方团队生效
战斗模拟：添加纳什男爵技能（如击飞、酸液池）
三.出装装备：
1.狂战士胫甲：
物品属性
攻击速度：25%
移动速度：45
说明：限购1个鞋类装备。
合成信息
总价：1100金币
合成路线：鞋子（300金币）+ 短剑（250金币）+ 短剑（250金币） + 300金币；有点神奇之靴 + 短剑（250金币）+ 短剑（250金币）+ 300金币
可合成物品：灵风（3100金币）
class BerserkersGreaves:
"""模拟狂战士胫甲（攻速鞋）"""
def __init__(self):
self.name = "狂战士胫甲"
self.attack_speed = 0.25 # 25%攻速
self.movement_speed = 45 # 固定移速
self.price = 1100
self.unique_passive = "限购1个鞋类装备"
self.build_path = {
'components': [('鞋子', 300), ('短剑', 250), ('短剑', 250)],
'additional_cost': 300 # 合成费用
}
self.can_upgrade_to = ["灵风"] # 可升级选项
def can_purchase(self, player):
"""检查玩家是否可购买（鞋类唯一性检查）"""
if any(item.lower().endswith('鞋') for item in player.items):
print(f"购买失败：{player.name} 已拥有其他鞋类装备")
return False
return True
def build(self, player):
"""合成逻辑"""
required_items = ['鞋子', '短剑', '短剑']
if not all(item in player.inventory for item in required_items):
missing = [item for item in required_items if item not in player.inventory]
print(f"合成失败：缺少组件 {missing}")
return False
if player.gold < self.build_path['additional_cost']:
print(f"合成失败：需要额外 {self.build_path['additional_cost']} 金币")
return False
# 扣除组件和金币
for item in required_items:
player.inventory.remove(item)
player.gold -= self.build_path['additional_cost']
# 添加成品
player.items.append(self.name)
print(f"{player.name} 合成了 {self.name}！")
return True
class Player:
"""模拟玩家角色"""
def __init__(self, name):
self.name = name
self.gold = 0
self.items = []
self.inventory = [] # 背包中的组件
def add_gold(self, amount):
self.gold += amount
def buy_component(self, component_name, component_price):
if self.gold >= component_price:
self.gold -= component_price
self.inventory.append(component_name)
print(f"{self.name} 购买了 {component_name}（-{component_price}金）")
return True
print(f"金币不足（当前：{self.gold}，需要：{component_price}）")
return False
# 示例使用
if __name__ == "__main__":
# 创建玩家和装备
player = Player("测试玩家")
greaves = BerserkersGreaves()
# 模拟购买组件
player.add_gold(1100)
player.buy_component('鞋子', 300)
player.buy_component('短剑', 250)
player.buy_component('短剑', 250)
# 尝试合成
if greaves.can_purchase(player):
greaves.build(player)
# 检查结果
print(f"\n玩家最终装备：{player.items}")
print(f"剩余金币：{player.gold}")
print(f"背包剩余组件：{player.inventory}")
# 尝试重复购买鞋类
print("\n尝试购买第二双鞋：")
player.add_gold(1100)
greaves.can_purchase(player) # 应触发唯一性检查
输出示例：
测试玩家 购买了 鞋子（-300金）
测试玩家 购买了 短剑（-250金）
测试玩家 购买了 短剑（-250金）
测试玩家 合成了 狂战士胫甲！
玩家最终装备：['狂战士胫甲']
剩余金币：300
背包剩余组件：[]
尝试购买第二双鞋：
购买失败：测试玩家 已拥有其他鞋类装备
关键设计：
唯一性检查：通过 can_purchase() 方法确保鞋类装备唯一
合成系统：
必须拥有全部组件（鞋子+2短剑）
需要额外支付300金币合成费
经济管理：实时扣除金币和组件
扩展建议：
添加 MagicFootwear（神奇之靴）特殊合成路径
实现升级逻辑（如合成灵风）
绑定角色属性（实际提升攻速/移速）
2.饮血剑：
饮血剑，提供攻击力、生命偷取。饮血剑，在Kaladoun沼泽发现，携带着灵魂偷窃者FraxVanltt之力，其持有者将永被绑定，渴求鲜血。缩写为“KBSS-FV剑”。
物品属性
攻击力：80
生命偷取：15%
灵液护盾：将来自你的生命偷取的溢出你最大生命值的那部分治疗效果转化为至多165 - 315（基于角色等级）护盾值。
合成信息
总花费：3400金币
合成路线：暴风之剑（1300金币）+十字镐（875金币）+吸血鬼节杖（900金币）+325金币
出售价格：2380金币
适用英雄
技能AD加成较高的ADC，如荣耀行刑官、复仇之矛、暴走萝莉等。
class Bloodthirster:
"""模拟饮血剑（高AD吸血装备）"""
def __init__(self):
self.name = "饮血剑"
self.attack_damage = 80
self.life_steal = 0.15 # 15%生命偷取
self.shield_capacity = (165, 315) # 护盾值范围（基于等级）
self.price = 3400
self.sell_price = 2380
self.build_path = {
'components': [
('暴风之剑', 1300),
('十字镐', 875),
('吸血鬼节杖', 900)
],
'additional_cost': 325 # 合成费用
}
self.recommended_champs = [
'荣耀行刑官', '复仇之矛', '暴走萝莉',
'圣枪游侠', '戏命师'
]
def calculate_shield(self, champion_level):
"""计算当前等级下的护盾最大值"""
min_shield, max_shield = self.shield_capacity
return min_shield + (max_shield - min_shield) * (champion_level - 1) / 17 # 1-18级线性增长
def apply_lifesteal(self, damage_dealt, current_hp, max_hp, champion_level):
"""
模拟生命偷取和护盾生成
:param damage_dealt: 造成的物理伤害
:param current_hp: 当前生命值
:param max_hp: 最大生命值
:param champion_level: 英雄等级
:return: (实际治疗量, 新增护盾值)
"""
heal_amount = damage_dealt * self.life_steal
overflow = (current_hp + heal_amount) - max_hp
if overflow > 0:
shield_cap = self.calculate_shield(champion_level)
new_shield = min(overflow, shield_cap)
actual_heal = heal_amount - new_shield
return actual_heal, new_shield
return heal_amount, 0
def is_recommended_for(self, champion_name):
"""检查是否推荐给特定英雄"""
return champion_name in self.recommended_champs
class Champion:
"""模拟英雄角色"""
def __init__(self, name, level=1):
self.name = name
self.level = level
self.items = []
self.gold = 0
self.inventory = []
self.max_hp = 500 + (level * 80) # 示例血量公式
self.current_hp = self.max_hp * 0.6 # 假设当前60%血量
def buy_component(self, component_name, component_price):
if self.gold >= component_price:
self.gold -= component_price
self.inventory.append(component_name)
print(f"{self.name} 购买了 {component_name}（-{component_price}金）")
return True
print(f"金币不足（当前：{self.gold}，需要：{component_price}）")
return False
def build_bloodthirster(self):
"""尝试合成饮血剑"""
bt = Bloodthirster()
required = [item[0] for item in bt.build_path['components']]
if not all(item in self.inventory for item in required):
missing = [item for item in required if item not in self.inventory]
print(f"合成失败：缺少组件 {missing}")
return None
if self.gold < bt.build_path['additional_cost']:
print(f"需要额外 {bt.build_path['additional_cost']} 金币合成")
return None
# 扣除组件和金币
for item in required:
self.inventory.remove(item)
self.gold -= bt.build_path['additional_cost']
self.items.append(bt.name)
print(f"{self.name} 合成了 {bt.name}！")
print(f"当前攻击力：+{bt.attack_damage} | 生命偷取：{bt.life_steal*100}%")
return bt
# 示例使用
if __name__ == "__main__":
# 创建ADC英雄
draven = Champion("荣耀行刑官", level=11)
draven.add_gold(4000)
# 购买组件
draven.buy_component("暴风之剑", 1300)
draven.buy_component("十字镐", 875)
draven.buy_component("吸血鬼节杖", 900)
# 合成饮血剑
bloodthirster = draven.build_bloodthirster()
# 测试生命偷取效果
if bloodthirster:
print("\n--- 战斗测试 ---")
damage = 800 # 假设一次普攻伤害
heal, shield = bloodthirster.apply_lifesteal(
damage, draven.current_hp, draven.max_hp, draven.level
)
print(f"造成 {damage} 伤害 → 治疗 {heal:.1f} | 生成护盾 {shield:.1f}")
print(f"护盾上限（{draven.level}级）: {bloodthirster.calculate_shield(draven.level):.1f}")
# 检查装备推荐
print("\n推荐英雄检查：")
for champ in ["荣耀行刑官", "疾风剑豪"]:
is_rec = bloodthirster.is_recommended_for(champ)
print(f"{champ}: {'✓' if is_rec else '✗'} 推荐")
输出示例：
荣耀行刑官 购买了 暴风之剑（-1300金）
荣耀行刑官 购买了 十字镐（-875金）
荣耀行刑官 购买了 吸血鬼节杖（-900金）
荣耀行刑官 合成了 饮血剑！
当前攻击力：+80 | 生命偷取：15.0%
--- 战斗测试 ---
造成 800 伤害 → 治疗 72.0 | 生成护盾 48.0
护盾上限（11级）: 243.5
推荐英雄检查：
荣耀行刑官: ✓ 推荐
疾风剑豪: ✗ 推荐
核心机制实现：
灵液护盾系统：
溢出治疗量按等级转换为护盾（calculate_shield()）
动态计算实际治疗和护盾值（apply_lifesteal()）
合成路径验证：
必须拥有暴风之剑+十字镐+吸血鬼节杖
额外支付325金币合成费
英雄适配检查：
预设推荐AD射手列表（recommended_champs）
扩展建议：
添加护盾衰减机制（随时间减少）
实现与其他吸血装备的交互（如死亡之舞）
绑定到角色属性系统（实际提升AD/吸血效果）
3.无尽之刃:
物品属性
攻击力：65
暴击几率：25%
暴击伤害：40%
合成信息
总花费：3450金币
合成路线：暴风之剑（1300金币）+ 十字镐（875金币）+ 灵巧披风（600金币）+ 675金币
装备说明
使用技巧
无尽之刃适合依赖于普通攻击的物理输出英雄，该装备配合增加攻速暴击的装备（幻影之舞、疾射火炮等）效果更佳。
class InfinityEdge:
"""模拟无尽之刃（暴击核心装备）"""
def __init__(self):
self.name = "无尽之刃"
self.attack_damage = 65
self.crit_chance = 0.25 # 25%暴击率
self.crit_damage = 0.40 # 暴击伤害+40%
self.price = 3450
self.build_path = {
'components': [
('暴风之剑', 1300),
('十字镐', 875),
('灵巧披风', 600)
],
'additional_cost': 675 # 合成费用
}
self.synergy_items = [
'幻影之舞', '疾射火炮', '斯塔缇克电刃'
]
def calculate_crit(self, base_damage, has_synergy=False):
"""
计算暴击伤害
:param base_damage: 基础攻击力（含其他装备加成）
:param has_synergy: 是否装备了协同暴击装
:return: (实际伤害, 是否暴击)
"""
import random
is_crit = random.random() <= self.crit_chance
if is_crit:
damage_multiplier = 1.75 + self.crit_damage # 基础暴击150% + 无尽40%
if has_synergy:
damage_multiplier += 0.10 # 假设协同装备额外提升10%暴伤
return base_damage * damage_multiplier, True
return base_damage, False
def build(self, player):
"""合成逻辑"""
required = [item[0] for item in self.build_path['components']]
if not all(item in player.inventory for item in required):
missing = [item for item in required if item not in player.inventory]
print(f"合成失败：缺少组件 {missing}")
return False
if player.gold < self.build_path['additional_cost']:
print(f"需要额外 {self.build_path['additional_cost']} 金币")
return False
# 扣除组件和金币
for item in required:
player.inventory.remove(item)
player.gold -= self.build_path['additional_cost']
player.items.append(self.name)
print(f"{player.name} 合成了 {self.name}！")
print(f"当前暴击率：{self.crit_chance*100}% | 暴击伤害：{175+self.crit_damage*100}%")
return True
class Player:
"""模拟玩家角色（含装备系统）"""
def __init__(self, name):
self.name = name
self.gold = 0
self.items = []
self.inventory = []
self.base_ad = 100 # 基础攻击力
def add_gold(self, amount):
self.gold += amount
def buy_component(self, component_name, component_price):
if self.gold >= component_price:
self.gold -= component_price
self.inventory.append(component_name)
print(f"{self.name} 购买了 {component_name}（-{component_price}金）")
return True
print(f"金币不足（当前：{self.gold}，需要：{component_price}）")
return False
def total_attack_damage(self):
"""计算总攻击力（基础+装备）"""
ad_bonus = 0
if "无尽之刃" in self.items:
ad_bonus += 65
# 可添加其他装备加成...
return self.base_ad + ad_bonus
def has_synergy(self):
"""检查是否有暴击协同装备"""
return any(item in self.items for item in [
'幻影之舞', '疾射火炮', '斯塔缇克电刃'
])
# 示例使用
if __name__ == "__main__":
# 创建ADC玩家
jinx = Player("暴走萝莉")
jinx.add_gold(4000)
# 购买组件
components = [
("暴风之剑", 1300),
("十字镐", 875),
("灵巧披风", 600)
]
for name, price in components:
jinx.buy_component(name, price)
# 合成无尽之刃
ie = InfinityEdge()
if ie.build(jinx):
# 模拟攻击（带协同装备）
jinx.items.append("幻影之舞") # 添加协同装备
total_ad = jinx.total_attack_damage()
print("\n--- 暴击测试（10次攻击）---")
for i in range(1, 11):
damage, is_crit = ie.calculate_crit(
total_ad,
has_synergy=jinx.has_synergy()
)
crit_mark = "💥暴击!" if is_crit else ""
print(f"攻击{i}: {damage:.1f}伤害 {crit_mark}")
print("\n装备协同效果：")
print("✓ 幻影之舞：提升暴击率和生存能力")
print("✓ 疾射火炮：增加暴击距离")
# 输出装备说明
print("\n*无尽之刃使用技巧*")
print("1. 优先搭配攻速暴击装（如幻影之舞）形成核心输出组合")
print("2. 适合依赖普攻的ADC（如亚索、烬、金克丝）")
print("3. 暴击率叠加到75%以上时收益最大化")
输出示例：
暴走萝莉 购买了 暴风之剑（-1300金）
暴走萝莉 购买了 十字镐（-875金）
暴走萝莉 购买了 灵巧披风（-600金）
暴走萝莉 合成了 无尽之刃！
当前暴击率：25.0% | 暴击伤害：215.0%
--- 暴击测试（10次攻击）---
攻击1: 165.0伤害
攻击2: 165.0伤害
攻击3: 354.8伤害 💥暴击!
攻击4: 165.0伤害
攻击5: 165.0伤害
攻击6: 354.8伤害 💥暴击!
攻击7: 165.0伤害
攻击8: 165.0伤害
攻击9: 354.8伤害 💥暴击!
攻击10: 165.0伤害
装备协同效果：
✓ 幻影之舞：提升暴击率和生存能力
✓ 疾射火炮：增加暴击距离
*无尽之刃使用技巧*
1. 优先搭配攻速暴击装（如幻影之舞）形成核心输出组合
2. 适合依赖普攻的ADC（如亚索、烬、金克丝）
3. 暴击率叠加到75%以上时收益最大化
核心机制实现：
暴击系统：
基础暴击伤害175%（含无尽额外40%）
协同装备可进一步提升暴击效果
动态伤害计算：
每次攻击独立判定暴击
总攻击力 = 基础AD + 装备加成
装备协同：
检测幻影之舞/疾射火炮等联动装备
扩展建议：
添加暴击率软上限（如超过100%时转换属性）
实现真实伤害暴击（如亚索被动）
绑定到英雄类（如ADC/战士的不同收益）
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
