文章目录
- 奇美拉类
- 摸鱼仔，负能量，真老实，小坏蛋，压力怪
- 治愈师
- 小团体
- 画饼王
- 平凡王
- 坏脾气
- 抗压包
- 请假狂
- 请假王
- 内卷王
- 受气包
- 跑路侠
- 看乐子
- 背锅侠
- 抢功劳
- 急先锋
- 说怪话
- 帮倒忙
- 小夸夸
- 工作狂
- 职业经理
- 严酷恶魔
- 职场清流
- 开始工作吧小奇美拉
- 没想到吧，我还在！（优化）
本博文是奇美拉项目的完结篇章
前两个篇连接如下：
游戏开发实战（一）：Python复刻「崩坏星穹铁道」嗷呜嗷呜事务所—源码级解析该小游戏背后的算法与设计模式【纯原创】-CSDN博客
游戏开发实战（二）：Python复刻「崩坏星穹铁道」嗷呜嗷呜事务所—源码级解析该小游戏背后的算法与设计模式【纯原创】-CSDN博客
项目Github: https://github.com/Hanachirusat/Chimeras
奇美拉类
摸鱼仔，负能量，真老实，小坏蛋，压力怪
这些奇美拉并没有技能，平平无奇。我们对所有奇美拉的攻击力快照设置了property（只读）。我们不希望可以随意更改奇美拉快照，而只有每回合开始时调用相应的方法来固定攻击力快照。
#**摸鱼仔【3,2】**：平平无奇
class Myz(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=3
self.__hp=2
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否登场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=0 #观察模式，2观察所有1观察自身外的所有0只观察自身
self.__skill=False
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
pass
#**负能量【7，3】：**平平无奇
class Fnl(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=7
self.__hp=3
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否登场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=0
self.__skill=False
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
pass
#**真老实【1，16】：**平平无奇
class Zls(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=1
self.__hp=16
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否登场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=0
self.__skill=False
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
pass
#**小坏蛋【3，5】：**平平无奇
class Xhd(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=3
self.__hp=5
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否登场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=0
self.__skill=False
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
pass
##**压力怪【5，3】**：平平无奇
class Ylg(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=5
self.__hp=3
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否登场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=0
self.__skill=False
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
pass
治愈师
每回合开始，使前一格同伴体力+1
治愈师进观察自身，如果变化的属性不是自己则直接返回。代码中的new_value-old_value)==1是防御性编程。用于辅助发现episode相关的逻辑错误（每回合episode只能+1）
#**治愈师【温暖，2，5】：**==每回合开始==，使前一格同伴`体力+1`
class Zys(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=2
self.__hp=5
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否登场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=0 #只监控自身的属性变化从而保证每回合只触发一次被动技能
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self!=changed_obj):
return
if changed_attr=="episode" and (new_value-old_value)==1 and self.__on:
position=self.queue.members_list.index(self)+1
#如果前面一格有队友
if position<=len(self.queue.members_list-1):
self.queue.members_list[position].hp+=1
小团体
每回合开始时，使前两格同伴效率+1，其余同伴体力-1
小团体的实际技能生效情况和自身位置相关。我们先对它前面两格（直到队头奇美拉）的同伴效率+1。其余体力同伴-1可能会触发其他奇美拉的被动技能，因此我们先记住其余奇美拉对象，然后再对这些奇美拉对象的hp-1。
class Xtt(ChimerasEntity):
#
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=3
self.__hp=3
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否登场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=0 #只监控自身的属性变化从而保证每回合只触发一次被动技能
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self!=changed_obj):
return
if changed_attr=="episode" and (new_value-old_value)==1 and self.__on:
position=self.queue.members_list.index(self)
l=len(self.queue.members_list)
#前两格同伴效率+1
for i in range(position+1,min(position+3,l)):
self.queue.members_list[i].atk += 1
# 其余同伴体力-1，体力-1可能触发其他同伴的技能导致位置发生变化
# w我们先记录需要-1的同伴
chi_hp_decrease=[]
for i in range(position):
chi_hp_decrease.append(self.queue.members_list[i])
for chi in chi_hp_decrease:
chi.hp -= 1
画饼王
登场技判断需要保证旧值为False。回合技能需要保证再第二回合触发。
# **画饼王【话术，2，7】：**==登场后==所有同伴`效率+8 `,==若自身在场，每回合==使所有同伴`效率-2`
class Hbw(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=2
self.__hp=7
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=0 #只监控自身的属性变化从而保证每回合只触发一次被动技能
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self!=changed_obj):
return
#登场后，所有同伴效率+8
if changed_attr=="on" and old_value==False and self.__on:
for i in self.queue.members_list:
if i!=self:
i.atk+=8
# 若自身在场，每回合所有同伴效率-2，这个应该从第二回合开始算,第二回合的时候1-》2.old_value应该为1
if changed_attr=="episode" and (new_value-old_value)==1 and old_value>0 and self.__on:
for i in self.queue.members_list:
if i!=self:
i.atk-=2
平凡王
先记录场上所有无特性同伴的效率和体力，之后进行截断（上限为25）。注意：这里单词的实际意思可能是单个奇美拉的意思，因为登场技能只会发动一次，因此不存在技能发动单次的含义）
# **平凡王【联合，7，7】：**==登场后==，获得场上`所有无特性同伴100%的效率和体力`（单次上限均为25）
class Pfw(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=7
self.__hp=7
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=0 #只监控自身的属性变化从而保证每回合只触发一次被动技能
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self!=changed_obj):
return
#登场后，获得场上所有无特性同伴100%的效率和体力
if changed_attr=="on" and old_value==False and self.__on:
a,h=0,0
for i in self.queue.members_list:
if i!=self:
a+=min(i.atk,25)
h+=min(i.hp,25)
#单次上限均为25
self.__atk+=a
self.__hp+=h
坏脾气
只有当前奇美拉不是最后一个奇美拉时才会发动技能
# **坏脾气【发作，AT:2，HP:9】：**==自身工作时==：使`后一格`同伴`体力-1`
class Hpq(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=2
self.__hp=9
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=0 #只监控自身的属性变化从而保证每回合只触发一次被动技能
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self!=changed_obj):
return
#自身工作时
if changed_attr=="work_num" and new_value>old_value and self.__on:
#获得当前位置
position=self.queue.members_list.index(self)
#如果后面有同伴，则使后面同伴hp-1
if position>0:
self.queue.members_list[position-1].hp-=1
抗压包
使得同伴效率降增加并不会实际触发技能，因此可以直接操作，并不需要先记录需要加buff的奇美拉对象
#**抗压包【熟练，2，5】：**==自身体力降低时==使`前后一格`同伴`效率+1`
class Kyb(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=2
self.__hp=5
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=0 #只监控自身的属性变化从而保证每回合只触发一次被动技能
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self!=changed_obj):
return
#自身体力降低时
if changed_attr=="hp" and new_value<old_value and self.__on:
#获得当前位置
position=self.queue.members_list.index(self)
l=len(self.queue.members_list.index(self))
position_before=position+1
position_after=position-1
if position_before>=0 and position_before<l:
self.queue.members_list[position_before].atk+=1
if position_after >= 0 and position_after < l:
self.queue.members_list[position_after].atk += 1
请假狂
# **请假狂【装病，2，7】：**==自身体力降低后==，与`后一格`同伴`交换位置`，并使自身`效率+2`
class Qjk(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=2
self.__hp=7
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=0 #只监控自身的属性变化从而保证每回合只触发一次被动技能
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self!=changed_obj):
return
#自身体力降低时
if changed_attr=="hp" and new_value<old_value and self.__on:
#获得当前位置
position=self.queue.members_list.index(self)
#如果不在队列最后，则与后一格同伴交换位置，并使自身体力+2
if position>0:
self.queue.members_list[position-1],self.queue.members_list[position]=self.queue.members_list[position],self.queue.members_list[position-1]
self.atk += 2
请假王
# **请假王【开摆，6，3】**：==自身体力降低后==，与`后一格`同伴`交换位置`，并使自身`体力+3`
class Qjw(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=6
self.__hp=3
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=0 #只监控自身的属性变化从而保证每回合只触发一次被动技能
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self!=changed_obj):
return
#自身体力降低时
if changed_attr == "hp" and new_value < old_value and self.__on:
# 获得当前位置
position = self.queue.members_list.index(self)
# 如果不在队列最后，则与后一格同伴交换位置
if position > 0:
self.queue.members_list[position - 1], self.queue.members_list[position] = self.queue.members_list[position], self.queue.members_list[position - 1]
self.hp += 3
内卷王
# **内卷王【激励，3，8】：**==自身完成工作时==：获得`效率+2`，`体力+3`
class Njw(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=3
self.__hp=8
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=0 #只监控自身的属性变化从而保证每回合只触发一次被动技能
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self!=changed_obj):
return
#自身完成工作时，
if changed_attr=="complete_work_num" and new_value>old_value and self.__on:
self.atk+=2
self.hp+=3
受气包
# **受气包【道歉，2，5】：** ==自身体力降低时==，使全局同伴`效率+1`
class Sqb(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=2
self.__hp=5
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=0 #只监控自身的属性变化从而保证每回合只触发一次被动技能
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self!=changed_obj):
return
#自身体力降低时
if changed_attr == "hp" and new_value < old_value and self.__on:
for i in self.queue.members_list:
if i!=self:
i.atk+=1
跑路侠
跑路侠累到后和后一个同伴一起逃离工作，根据前面提到的“规则”，我们不直接修改后一个同伴的生命，而是修改on属性为False，在每回合结束后，会把所有on属性为False的奇美拉清理出队列。此外，为了确保跑路侠hp小于0后一定离场（后续其他奇美拉对他加hp也不起作用），我们增加了一个hp-100的语句，为了防止这个语句继续调用跑路侠的技能，跑路下的技能判断条件为，旧的hp>0，新的hp<1(<=0)。(如果你还记得我们之前提到过的，在eval中用下划线修改私有属性并不会通知观察者，那么这里你就可以优雅的用self.__hp+=100)
# **跑路侠【怂恿，1，1】**：==自身累倒时==，和后一格同伴一起`逃离工作`，并使其他同伴`体力+8`
class Plx(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=1
self.__hp=1
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=0 #只监控自身的属性变化从而保证每回合只触发一次被动技能
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self!=changed_obj):
return
#自身累倒时
if changed_attr == "hp" and new_value < 1 and old_vale>0 and self.__on:
slef.__hp-=100
position=self.queue.members_list.index(self)
# 使得后一格同伴离场，不修改后一格同伴的生命值
if position>0:
self.queue.members_list[position-1].on=False
# 使得其他同伴体力+8
for i in range(len(self.queue.members_list)):
if i<(position-1) or (i> position):
self.queue.members_list[i].hp+=8
看乐子
正如上文提到的，对于同一个奇美拉，看乐子可能触发两次被动。这也是有道理的，奇美拉生命值小于0表示累倒了。但是同伴可以给他加buff，使她的hp>0，此时又充满活力了，所以可以再次工作累倒。
# **看乐子【围观，3，3】**：==同伴累到后==，自身`效率+2`，`体力+2`
class Klz(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=3
self.__hp=3
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=1 #监控自己以外的所有同伴
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self==changed_obj):
return
#同伴累倒后
if changed_attr == "hp" and new_value < 1 and old_vale>0 and self.__on:
self.atk+=2
self.hp+=2
背锅侠
# **背锅侠【接锅，3 ，6：**==同伴累倒时==，使该同伴`体力+10`，自身逃离工作
class Bgx(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=3
self.__hp=6
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=1 #监控自己以外的所有同伴
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self==changed_obj):
return
#同伴累倒后
if changed_attr == "hp" and new_value < 1 and old_vale>0 and self.__on:
#同伴累到后体力为hp，不会出现负体力，但这里不要用等于10
#可能会出现其他奇美拉也给他加血，并且先于该奇美拉。
print(f"\t给{changed_obj.name}加buff，hp+10!")
changed_obj.hp+=10
#注意此时不能修改self.queue.remove_member，因为我们无法保证此时弱引用集合已经遍历完毕。
#如果直接修改，可能会会导致集合在遍历过程中被修改了，因此我们需要保证所有的技能都执行完，才移除on属性为False的奇美拉。也就是在每回合最后才移除奇美拉。
self.on=False
抢功劳
这里需要保证work的hp>0，道理也很简单，如果工作已经被完成了，尘埃落定，如何抢功劳呢？由于追加工作可能触发其他奇美拉的被动，因此我们先判断是否完成工作，然后再修改complete_work_num属性。
# **抢功劳【独占，15，2：** ==同伴工作时==：若自身效率》=剩余工作进度，则进行`追加工作`完成该任务
class Qgl(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=15
self.__hp=2
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=1 #监控自己以外的所有同伴
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self==changed_obj):
return
#同伴工作时，进行追加工作不算
if changed_attr == "work_num" and (new_value-old_value)==1 and self.__on:
#如果回合开始时的效率足以完成任务
if self.__fixed_atk>=self.queue.work.hp and self.queue.work.hp>0:
#进行一次追加攻击
self.queue.work.hp-=self.__fixed_atk
if self.queue.work.hp < 1:
#完成工作也可能触发其他同伴的技能，因此需要最后执行
self.complete_work_num += 1
#追加攻击可能触发其他同伴的技能，导致继续工作一次，因此需要最后执行
self.append_work_num+=1
急先锋
# **急先锋【带头，2，5】：**==同伴工作或追加工作时==，自身与前一格同伴`交换位置`，并且`体力+6`
class Jxf(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=2
self.__hp=5
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=1 #监控自己以外的所有同伴
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self==changed_obj):
return
#同伴工作或追加工作时，
if (changed_attr =="work_num" or changed_attr=="append_work_num") and (new_value-old_value)==1:
position=self.queue.members_list.index(self)
#如果当前奇美拉不是第一个奇美拉
if position<len(self.queue.members_list)-1:
print(f"\t{self.name}与前一格奇美拉交换位置")
#与前一格同伴交换位置
self.queue.members_list[position],self.queue.members_list[position+1]=\
self.queue.members_list[position+1],self.queue.members_list[position]
self.hp+=6
说怪话
# **说怪话【暗讽，14，1】：**==同伴完成工作时==，使该同伴`效率+4 `并发表自己的意见
class Sgh(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=14
self.__hp=1
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=1 #监控自己以外的所有同伴
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self==changed_obj):
return
#同伴完成工作时
if changed_attr == "complete_work_num" and (new_value-old_value)==1 and self.__on:
#使该同伴效率+4
changed_obj.atk+=4
#发表锐评
print(f"{self.name}对{changed_obj.name}发表了锐评")
帮倒忙
# **帮倒忙【捣乱，-1，5】：**==同伴工作时==，自身进行一次`追加工作`
class Bdm(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=-1
self.__hp=5
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=1 #监控自己以外的所有同伴
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self==changed_obj):
return
#同伴工作时候
if changed_attr =="work_num" and (new_value-old_value)==1 and self.__on:
#自身进行追加攻击,工作小于0的时候也可以继续追加攻击获得buff
self.queue.work.hp-=self.__fixed_atk
print(f"\t{self.name}进行一次追加攻击！")
#追加攻击后立刻判断是否完成工作
if self.queue.work.hp < 1:
self.complete_work_num += 1
self.append_work_num+=1
小夸夸
# **小夸夸【鼓励，3，3】：**==同伴工作或追加工作时==，若同伴效率》5使其`效率+2 `
class Xkk(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=3
self.__hp=3
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=1 #监控自己以外的所有同伴
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self==changed_obj):
return
#同伴工作或追加工作时
if (changed_attr == "work_num" or changed_attr== "append_work_num") and (new_value-old_value)==1 and self.__on:
#如果同伴效率>5，使效率+2
if changed_obj.atk>5:
#小夸夸监控所有队友的所有属性，因此修改atk也会进入小夸夸的eval但是不会执行任何语句。
print(f"\t给{changed_obj.name}加buff，atk+2!")
changed_obj.atk+=2
工作狂
# **工作狂【争先 6，10】：**==同伴工作或追加工作时==，进行一次等于自身50%效率的`追加工作`
class Gzk(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=6
self.__hp=10
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=1 #监控自己以外的所有同伴
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self==changed_obj):
return
#同伴工作或追加工作时
if (changed_attr == "work_num" or changed_attr== "append_work_num") and (new_value-old_value)==1 and self.__on:
#进行一次相当于自身50%效率的追加攻击
self.queue.work.hp-=(self.__fixed_atk/2)
print(f"\t{self.name}进行一次追加攻击！")
if self.queue.work.hp<1:
self.complete_work_num+=1
self.append_work_num+=1
职业经理
# **职业经理【自我驱动】：**==登场后==：使全体奇美拉`效率+3`，`体力+3`
class Zyjl(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=6
self.__hp=10
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=0 #监控自己以外的所有同伴
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self!=changed_obj):
return
#同伴工作或追加工作时
if changed_attr == "on" and old_value==False and self.__on:
#使所有成员效率和体力都+3
for i in self.queue.members_list:
i.hp+=3
i.atk+=3
严酷恶魔
# **严酷恶魔【不准停！】：**奇美拉==完成工作后==，使其`效率+5`
class Ykem(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=6
self.__hp=10
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=1 #监控自己以外的所有同伴
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
if(self==changed_obj):
return
#同伴完成工作后
if changed_attr == "complete_work_num" and (new_value-old_value)==1 and self.__on:
#使其效率+5
changed_obj.atk+=5
职场清流
# **职场清流【抚慰之心】：**==登场后==：全体奇美拉`效率+2`。奇美==拉追加工作==后：使其`效率+1`
class Zcql(ChimerasEntity):
__observed_attrs__ = ('atk', 'hp','episode','on','work_num','append_work_num','mode','skill','complete_work_num')
def __init__(self, name):
super().__init__(name)
self.name=name
self.__atk=6
self.__hp=10
self.__episode=0 #每回合开始都会先增加回合数
self.__on=False #是否在场，True为登场，刚开始的时候为False
self.__work_num=0 #工作次数
self.__append_work_num=0 #追加攻击次数
self.__mode=2 #监控自己及其所有奇美拉
self.__skill=True
self.__complete_work_num = 0
self.__fixed_atk=0
@property
def fixed_atk(self):
return self.__fixed_atk
def set_fix_atk(self):
self.__fixed_atk=self.__atk
def eval(self, changed_obj, changed_attr, old_value, new_value):
#登场后，全体奇美拉效率+2
if changed_attr == "on" and old_value==False and changed_obj==self and self.__on:
for i in self.queue.members_list:
print(f"\t给{i.name}加buff，atk+2!")
i.atk+=2
#同伴追加攻击后，使其效率+1
if changed_attr == "append_work_num" and (new_value-old_value)==1 and changed_obj!=self and self.__on:
print(f"\t给{changed_obj.name}加buff，{changed_attr} atk+1!")
changed_obj.atk+=1
开始工作吧小奇美拉
我们把工作也定义成一个类，该类中仅有攻击力和生命值属性，同时设置这两个属性的property描述符。我们把所有的工作逻辑都集成在奇美拉队列类中，我们在该类中新增三个方法
- work_once，选定第一个在场并且hp>0的奇美拉，使其进行一次工作
- work_episode，执行一个工作回合，在该函数中处理每回合工作前和工作后的一些信息。例如工作前增加回合数，固定攻击力。工作后判断奇美拉是否应该离场
- begin_work，该方法接受一个工作对象，然后循环调用work_episode直到完成工作或者所有奇美拉都累到了
Task类
class Task():
def __init__(self,atk=5,hp=150):
self._atk = atk
self._hp = hp
@property
def atk(self):
return self._atk
@atk.setter
def atk(self,value):
self._atk=value
@property
def hp(self):
return self._hp
@hp.setter
def hp(self,value):
self._hp=value
begin_work：
class InteractionQueue:
"""管理相互观察的队列"""
#......此处参见本系列的上一篇博文
def begin_work(self,work):
self.work=work
print("开始工作...")
#奇美拉登场
for i in self.members_list:
i.on=True
self.leader.on=True
#1 更新回合数，固定攻击力
#2 第一个奇美拉攻击（立即判断工作是否被完成）
#3 其他奇美拉发动技能）
#4 判断奇美拉是否离场（循环内判断），或者工作是否被完成（循环条件判断）
while(work.hp>0):
live=self.work_episode()
if not live and work.hp>0:
print("工作未完成，奇美拉都累坏了~")
print("工作已全部完成~")
work_episode
class InteractionQueue:
"""管理相互观察的队列"""
#......此处参见本系列的上一篇博文
def work_episode(self):
self.episode += 1
print(f"===开始第{self.episode}回合的工作===")
#先处理episode+1的逻辑，这时可能会触发被动，这个被动可能加攻击力
for chi in self.members_list:
chi.episode+=1
#开始工作前的最后时刻固定攻击力
for chi in self.members_list:
# 固定奇美拉攻击力
chi.set_fix_atk()
print("\t工作前：")
print("\t", end="")
for chi in self.members_list:
print(f"{chi.name}[atk:{chi.atk},hp:{chi.hp}]", end="")
print("\n",end="")
print(f"\tWork[atk:{self.work.atk},hp:{self.work.hp}]")
# 奇美拉开始工作
self.work_once()
print("\t请脑部工作画面呀QwQ")
# 根据奇美拉的生命值判断是否应该离场，并触发离场被动
for chi in self.members_list:
if chi.hp<1:
chi.on=False
self.remove_member(chi)
#防御性编程
if chi.on==False:
self.remove_member(chi)
print("\t工作后：")
print("\t", end="")
for chi in self.members_list:
print(f"{chi.name}[atk:{chi.atk},hp:{chi.hp}]", end="")
print("\n",end="")
print(f"\tWork[atk:{self.work.atk},hp:{self.work.hp}]")
#如果本回合结束后奇美拉都离场了
if len(self.members_list)==0:
return False
else:
return True
work_once
class InteractionQueue:
"""管理相互观察的队列"""
#......此处参见本系列的上一篇博文
def work_once(self):
before_work_hp=self.work.hp
work_chi=None
for chi in reversed(self.members_list):
if chi.hp>0 and chi.on:
work_chi=chi
break
#开始工作，这时进触发自己hp降低的被动
self.work.hp-=work_chi.atk
after_work_hp=self.work.hp
#开始触发技能，自身 体力降低,或同伴累倒后
work_chi.hp-=self.work.atk
#触发工作时和完成工作时的被动
work_chi.work_num+=1
if before_work_hp>0 and after_work_hp<1:
work_chi.complete_work_num+=1
最后，给出我们非常简单的main函数，完结撒花，★,°:.☆(￣▽￣)/$:.°★ 。🌸🌸🌸
import time
import unittest
from observer import InteractionQueue, Task
from chimeras import *
if __name__=="__main__":
queue=InteractionQueue()
jxf=Jxf("急先锋")
queue.add_member(jxf)
gzk=Gzk("工作狂")
queue.add_member(gzk)
bdm=Bdm("帮倒忙")
queue.add_member(bdm)
xkk=Xkk("小夸夸")
queue.add_member(xkk)
bgx=Bgx("背锅侠")
queue.add_member(bgx)
zcql=Zcql("职场清流")
queue.add_leader(zcql)
work=Task(atk=5,hp=80)
queue.begin_work(work)
没想到吧，我还在！（优化）
**不同的奇美拉应该监控特定属性：**回忆一下我们的元类和基类的实现，__observed_attrs__存放的更像是subject的主题，也就是其他奇美拉关注的属性。那么对于同一个奇美拉，不同的奇美拉可能观察该奇美拉的不同属性，这就需要属性分类。
我们可以把属性进行分类（或者说分级），相应的我们把observer也进行分类（和前面属性的分类是一一对应的）。在属性变化的时候，根据属性的级别，遍历不同的observer集合，调用被动技能和该属性有关的奇美拉的eval方法，而不是调用所有奇美的eval方法。
有序弱引用：我们在queue中保存所有对象的强引用（list保存）,此时我们必须手动调用queue的remove函数。如果我们打算在成员的析构函数中调用queue的remove函数就会出现一个奇怪的循环。如果我们忘记调用queue的remove_member函数，我们del成员，但是由于queue中保留着成员的引用，所以不会执行成员的析构函数。由于不会执行析构函数，所以queue中一直保留着成员的引用。解决办法可以采用有序弱引用。
我们需要自己基于weakref来实现一个有序弱引用类。这里给出基于有序字典来实现的思路：我们创建一个key为id（递增，）value为弱引用对象的有序字典。每次我们手动递增id。添加弱引用的时候需要判断该弱引用对象是否已经存在地点内。
