def d_shift_end(self, t):
if self.action_timer is not None:
self.action_timer.off()
self.action_timer = None
duration = now() - self.shift_start_time
log(
self.name, '{:.2f}dmg / {:.2f}s, {:.2f} dps'.format(
self.shift_damage_sum, duration,
self.shift_damage_sum / duration), ' '.join(self.act_sum))
self.act_sum = []
self.act_list = []
self.dracolith_mod.off()
if self.off_ele_mod is not None:
self.off_ele_mod.off()
self.ds_reset()
if not self.is_dragondrive:
self.shift_silence = True
Timer(self.end_silence).on(10)
self.dragon_gauge_pause_timer = Timer(self.resume_auto_gauge).on(
self.dragon_gauge_timer_diff)
self.status = -2
self._setprev() # turn self from doing to prev
self._static.doing = self.nop
self.end_event()
self.idle_event()
def oninit(self, adv):
super().oninit(adv)
charge_timer = Timer(
lambda _: adv.charge_p('ds', 0.091, no_autocharge=True), 0.9, True)
ds_buff = EffectBuff('ds_sp_regen_zone', 10, lambda: charge_timer.on(),
lambda: charge_timer.off())
adv.Event('ds').listener(lambda _: ds_buff.on())
def d_shift_end(self, t):
if self.action_timer is not None:
self.action_timer.off()
self.action_timer = None
duration = now()-self.shift_start_time
shift_dmg = g_logs.shift_dmg
g_logs.log_shift_dmg(False)
count = self.clear_delayed()
if count > 0:
log('cancel', self.c_act_name, f'by shift end', f'lost {count} hit{"s" if count > 1 else ""}')
log(self.name, '{:.2f}dmg / {:.2f}s, {:.2f} dps'.format(shift_dmg, duration, shift_dmg/duration), ' '.join(self.act_sum))
self.act_sum = []
self.act_list = []
if self.off_ele_mod is not None:
self.off_ele_mod.off()
if self.shift_spd_mod is not None:
self.shift_spd_mod.off()
self.ds_reset()
if not self.is_dragondrive:
self.shift_silence = True
Timer(self.end_silence).on(10)
self.dragon_gauge_pause_timer = Timer(self.resume_auto_gauge).on(self.dragon_gauge_timer_diff)
self.status = Action.OFF
self._setprev() # turn self from doing to prev
self._static.doing = self.nop
self.end_event()
self.idle_event()
def act_timer(self, act, time, next_action=None):
if self.c_act_name == 'dodge':
self.action_timer = Timer(act, time)
else:
self.action_timer = Timer(act, time / self.speed())
self.action_timer.next_action = next_action
return self.action_timer.on()
def effect_on(self):
value = self.get()
if self.mod_type == "defense" and value > 0:
db = Event("defchain")
db.source = self.source
db.on()
if self.bufftype == "team":
log("buff", "doublebuff", 15 * self.bufftime())
if self.bufftime == self._bufftime:
self._static.adv.slots.c.set_need_bufftime()
elif self.mod_type == "maxhp":
if self._static.adv.sub_mod("maxhp", "buff") < Buff.MAXHP_BUFF_CAP:
self.modifier.on()
percent = value * 100
log("heal", self.name, self._static.adv.max_hp * value,
"team" if self.bufftype == "team" else "self")
self._static.adv.add_hp(percent)
# FIXME: heal formula 1day twust
elif self.mod_type == "regen" and value != 0:
self.set_hp_event = Event("set_hp")
self.set_hp_event.delta = value
self.regen_timer = Timer(self.hp_regen, 3.9, True).on()
elif self.mod_type == "heal" and value != 0:
self.set_hp_event = Event("heal_make")
self.set_hp_event.name = self.name
self.set_hp_event.delta = self._static.adv.heal_formula(
self.source, value)
self.set_hp_event.target = "team" if self.bufftype == "team" else "self"
self.regen_timer = Timer(self.hp_regen, 2.9, True).on()
else:
return self.modifier and self.modifier.on()
def __init__(self, name='<buff_noname>', value=0, duration=0, mtype='att', morder=None, modifier=None, hidden=False):
self.name = name
self.__value = value
self.duration = duration
self.mod_type = mtype
self.mod_order = morder or ('chance' if self.mod_type == 'crit' else 'buff')
self.bufftype = 'misc' if hidden else 'self'
self.bufftime = self._bufftime if self.duration > 0 else self._no_bufftime
self.buff_end_timer = Timer(self.buff_end_proc)
if modifier:
self.modifier = modifier
self.get = self.modifier.get
elif mtype != 'effect':
self.modifier = Modifier('mod_' + self.name, self.mod_type, self.mod_order, 0)
self.modifier.get = self.get
else:
self.modifier = None
self.dmg_test_event = Event('dmg_formula')
self.dmg_test_event.dmg_coef = 1
self.dmg_test_event.dname = 'test'
self.hidden = hidden
self.__stored = 0
self.__active = 0
def __init__(self, name, conf, adv):
self.name = name
self.conf = conf
self.adv = adv
self.cancel_by = []
self.interrupt_by = []
self.disabled = False
self.shift_event = Event('dragon')
self.act_event = Event('dact')
self.end_event = Event('dragon_end')
self.delayed = set()
self.ds_reset()
self.act_list = []
self.act_sum = []
self.repeat_act = False
self.dx_list = [dx for dx, _ in self.conf.find(r'^dx\d+$')]
self.ds_event = Event('ds')
self.ds_event.name = 'ds'
self.dx_event = Event('dx')
self.action_timer = None
self.shift_start_time = 0
self.shift_end_timer = Timer(self.d_shift_end)
self.idle_event = Event('idle')
self.c_act_name = None
self.c_act_conf = None
self.dracolith_mod = self.adv.Modifier('dracolith', 'att', 'dragon', 0)
self.dracolith_mod.get = self.ddamage
self.dracolith_mod.off()
self.shift_mods = [self.dracolith_mod]
self.shift_spd_mod = None
self.off_ele_mod = None
if self.adv.slots.c.ele != self.adv.slots.d.ele:
self.off_ele_mod = self.adv.Modifier('off_ele', 'att', 'dragon',
-1 / 3)
self.off_ele_mod.off()
self.dragon_gauge = 0
self.dragon_gauge_val = self.conf.gauge_val
self.conf.gauge_iv = min(int(self.adv.duration / 12), 15)
self.dragon_gauge_timer = Timer(self.auto_gauge,
timeout=max(1, self.conf.gauge_iv),
repeat=1).on()
self.dragon_gauge_pause_timer = None
self.dragon_gauge_timer_diff = 0
self.max_gauge = 1000
self.shift_cost = 500
self.shift_count = 0
self.shift_silence = False
self.is_dragondrive = False
self.can_end = True
def oninit(self, adv):
super().oninit(adv)
sp_regen_timer = Timer(
lambda _: adv.charge_p('ds_sp', 0.0075, target=['s1', 's2']), 0.99,
True)
sp_regen_buff = EffectBuff('ds_sp', 90, lambda: sp_regen_timer.on(),
lambda: sp_regen_timer.off())
adv.Event('ds').listener(lambda _: sp_regen_buff.on())
def set_dragondrive(self, dd_buff):
self.is_dragondrive = True
self.shift_event = Event('dragondrive')
self.dragondrive_end_event = Event('dragondrive_end')
self.max_gauge = 3000
self.shift_cost = 1200 # does not deduct, but need to have this much pt to shift
self.dragondrive_buff = dd_buff
self.dragondrive_timer = Timer(self.d_dragondrive_end)
def oninit(self, adv):
super().oninit(adv)
self.sp_regen_timer = Timer(
lambda _: adv.charge_p("ds_sp", 0.0075, target=["s1", "s2"]), 0.99,
True)
self.sp_regen_buff = EffectBuff("ds_sp", 90,
lambda: self.sp_regen_timer.on(),
lambda: self.sp_regen_timer.off())
def reset_allow_end(self):
if self.is_dragondrive:
self.allow_end = True
else:
log('allow_end', self.allow_end_cd)
self.allow_end = False
self.allow_force_end_timer = Timer(self.set_allow_end, timeout=self.allow_end_cd)
self.allow_force_end_timer.on()
self.allow_end_cd += self.conf.allow_end_step
def on(self, duration=None):
if self.mod_type == 'maxhp':
max_hp = self._static.adv.mod('maxhp')
if max_hp >= Buff.MAXHP_CAP:
return self
value = self.__value
mod_val = min(value, max(Buff.MAXHP_CAP - max_hp, 0))
self._static.adv.set_hp(
(self._static.adv.hp * max_hp + value * 100) /
(max_hp + mod_val))
d = max(-1, (duration or self.duration) * self.bufftime())
if self.__active == 0:
self.__active = 1
if self.__stored == 0:
self._static.all_buffs.append(self)
self.__stored = 1
if d >= 0:
self.buff_end_timer.on(d)
proc_type = 'start'
else:
if d >= 0:
if self.buff_end_timer.online:
self.buff_end_timer.add(d)
else:
self.refresh_time = d
proc_type = 'refresh'
self.logwrapper(
self.name,
f'{self.mod_type}({self.mod_order}): {self.value():.02f}',
f'buff {proc_type} <{d:.02f}s>')
value, stack = self.valuestack()
if stack > 1:
log('buff', self.name,
f'{self.mod_type}({self.mod_order}): {value:.02f}',
f'buff stack <{stack}>')
if self.mod_type == 'defense' and value > 0:
db = Event('defchain')
db.source = self.source
db.on()
if self.bufftype == 'team':
log('buff', 'doublebuff', 15 * self.bufftime())
if self.mod_type == 'regen':
# may need to make this part global since game always regen all stacks at same ticks
self.set_hp_event = Event('set_hp')
self.set_hp_event.delta = self.get()
self.regen_timer = Timer(self.hp_regen, 3.9, True).on()
else:
self.effect_on()
self.buffevent.buff = self
self.buffevent.on()
return self
def oninit(self, adv):
if not super().oninit(adv):
self.adv.blood_moon = 0
self.adv.moonlit_rage = 0
self.blood_moon_timer = Timer(self.d_moon_repeat, 3.5, True)
self.dragon_strike_timer = Timer(self.add_rage, 1.0, True)
Event("dfs_start").listener(self.dfs_start)
Event("dfs_charged").listener(self.dfs_charged)
def __init__(self, name, conf, adv, ds_proc):
self.name = name
self.conf = conf
self.adv = adv
self.cancel_by = []
self.interrupt_by = []
self.disabled = False
self.shift_event = Event('dragon')
self.end_event = Event('dragon_end')
self.ds_proc = ds_proc
self.ds_reset()
self.act_list = []
self.act_sum = []
self.dx_list = [
'dx{}'.format(i) for i in range(1, 6)
if 'dmg' in self.conf['dx{}'.format(i)]
]
self.ds_event = Event('s')
self.ds_event.name = 'ds'
self.action_timer = None
self.shift_start_time = 0
self.shift_damage_sum = 0
self.shift_end_timer = Timer(self.d_shift_end)
self.idle_event = Event('idle')
self.c_act_name = None
self.c_act_conf = None
self.dracolith_mod = self.adv.Modifier('dracolith', 'att', 'dragon', 0)
self.dracolith_mod.off()
self.off_ele_mod = None
if self.adv.slots.c.ele != self.adv.slots.d.ele:
self.off_ele_mod = self.adv.Modifier('off_ele', 'att', 'dragon',
-1 / 3)
self.off_ele_mod.off()
self.dragon_gauge = 0
self.dragon_gauge_val = self.conf.gauge_val
self.dragon_gauge_timer = Timer(self.auto_gauge,
timeout=max(1, self.conf.gauge_iv),
repeat=1).on()
self.dragon_gauge_pause_timer = None
self.dragon_gauge_timer_diff = 0
self.max_gauge = 1000
self.shift_cost = 500
self.shift_count = 0
self.shift_silence = False
self.is_dragondrive = False
self.can_end = True
def reset_allow_end(self):
if self.is_dragondrive:
self.allow_end = True
else:
log("allow_end", self.allow_end_cd)
self.allow_end = False
self.allow_force_end_timer = Timer(self.set_allow_end,
timeout=self.allow_end_cd)
self.allow_force_end_timer.on()
self.allow_end_cd = min(
self.allow_end_cd + self.conf.allow_end_step, self.dtime())
class Ramiel(DragonBase):
def ds1_proc(self, e):
self.sp_regen_buff.on()
def oninit(self, adv):
super().oninit(adv)
self.sp_regen_timer = Timer(
lambda _: adv.charge_p("ds_sp", 0.0075, target=["s1", "s2"]), 0.99,
True)
self.sp_regen_buff = EffectBuff("ds_sp", 90,
lambda: self.sp_regen_timer.on(),
lambda: self.sp_regen_timer.off())
def oninit(self, adv):
super().oninit(adv)
if not adv.nihilism:
charge_timer = Timer(
lambda _: adv.charge_p("ds", 0.091, no_autocharge=False), 0.9,
True)
ds_buff = EffectBuff(
"ds_sp_regen_zone",
10,
lambda: charge_timer.on(),
lambda: charge_timer.off(),
)
Event("ds").listener(lambda _: ds_buff.on())
def ds_proc(self):
from core.timeline import Timer
def autocharge(t):
self.adv.charge_p('ds', 0.091)
charge = Timer(autocharge, 0.9, True).on()
def autocharge_off(t):
charge.off()
Timer(autocharge_off, 10, True).on()
return 0
def set_dragondrive(self, dd_buff, max_gauge=3000, shift_cost=1200, drain=150):
self.disabled = False
self.is_dragondrive = True
self.shift_event = Event('dragondrive')
self.dragondrive_end_event = Event('dragondrive_end')
ratio = max_gauge / self.max_gauge
self.dragon_gauge *= ratio
self.dragon_gauge_val *= ratio
self.max_gauge = max_gauge
self.shift_cost = shift_cost # does not deduct, but need to have this much pt to shift
self.drain = drain
self.dragondrive_buff = dd_buff
self.dragondrive_timer = Timer(self.d_dragondrive_end)
return self.dragondrive_buff
def oninit(self, adv):
super().oninit(adv)
adv.styx_spirit = 0
adv.csd_buff = SingleActionBuff("d_compounding_sd", 0.0, -1, "s",
"buff")
def add_csd(e):
if not adv.csd_buff.get():
adv.csd_buff.set(min(2.00, adv.csd_buff.get() + 0.50))
adv.csd_buff.on()
else:
adv.csd_buff.value(min(2.00, adv.csd_buff.get() + 0.50))
csd_timer = Timer(add_csd, 15, True).on()
def add_spirit(e):
if e.index == 3:
adv.styx_spirit = min(3, adv.styx_spirit + 1)
log("dx_spirit", adv.styx_spirit)
Event("dx").listener(add_spirit)
def reset_spirit(e):
adv.styx_spirit = 0
Event("ds").listener(reset_spirit)
Event("dragon_end").listener(reset_spirit)
def d_shift_end(self, e=None, reason="timeout"):
if not self.status or self.is_dragonbattle:
return False
doing = self.d_shift.getdoing()
if self.ds_final and not (isinstance(doing, S) and doing.base in self.shift_skills) and not self.l_s_final_end.get():
ds_final = self.adv.a_s_dict[self.ds_final]
if ds_final.ac.conf.final and ds_final.ac.enabled:
self.shift_end_reason = reason
self.l_s_final_end.on()
ds_final.reset_uses()
ds_final.charged = ds_final.sp
ds_final()
self.set_dacts_enabled(False)
return False
if self.off_ele:
self.adv.element = self.adv.slots.c.ele
if self.shift_spd_mod is not None:
self.shift_spd_mod.off()
self.shift_silence_timer.on()
if self.dragon_gauge_timer_diff > 0:
self.dragon_gauge_pause_timer = Timer(self.resume_auto_gauge).on(self.dragon_gauge_timer_diff)
self.l_s.off()
self.l_s_end.off()
self.l_s_final_end.off()
self.set_dacts_enabled(False)
self.adv.set_dacl(False)
self.end_event()
self.d_end()
self.status = False
g_logs.set_log_shift(end_reason=self.shift_end_reason or reason)
self.shift_end_reason = None
if self.shift_end_proc:
self.shift_end_proc()
return True
def oninit(self, adv):
super().oninit(adv)
joyful_radiance_buff = adv.Selfbuff('joyful_radiance', 0.8, -1, 'att',
'passive').on()
adv.joyful_radiance = 4
def add_joyful_radiance(e):
if e.buff.mod_type != 'effect' and e.buff.bufftype in (
'self', 'team'
) and e.buff.name[0] == 's' and e.buff.name[1].isdigit():
if adv.joyful_radiance == 0:
joyful_radiance_buff.on()
adv.joyful_radiance = min(4, adv.joyful_radiance + 1)
joyful_radiance_buff.value(adv.joyful_radiance * 0.2)
adv.Event('buff').listener(add_joyful_radiance)
def expire_joyful_radiance(t):
adv.joyful_radiance = max(0, adv.joyful_radiance - 1)
if adv.joyful_radiance == 0:
joyful_radiance_buff.off()
else:
joyful_radiance_buff.value(adv.joyful_radiance * 0.2)
Timer(expire_joyful_radiance, 20, True).on()
def oninit(self, adv):
super().oninit(adv)
from core.advbase import Selfbuff, Event, Timer
self.csd_buff = Selfbuff('d_compounding_sd', 0.0, -1, 's', 'buff').on()
self.csd_stack = 0
self.csd_timer = Timer(self.add_csd, 15, True).on()
Event('s').listener(self.reset_csd)
def oninit(self, adv):
super().oninit(adv)
adv.styx_spirit = 0
adv.csd_buff = SingleActionBuff('d_compounding_sd', 0.0, -1, 's',
'buff')
def add_csd(e):
if not adv.csd_buff.get():
adv.csd_buff.set(min(2.00, adv.csd_buff.get() + 0.50))
adv.csd_buff.on()
else:
adv.csd_buff.value(min(2.00, adv.csd_buff.get() + 0.50))
csd_timer = Timer(add_csd, 15, True).on()
def add_spirit(e):
if e.index == 3:
adv.styx_spirit = min(3, adv.styx_spirit + 1)
log('dx_spirit', adv.styx_spirit)
adv.Event('dx').listener(add_spirit)
def reset_spirit(e):
adv.styx_spirit = 0
adv.Event('ds').listener(reset_spirit)
adv.Event('dragon_end').listener(reset_spirit)
def oninit(self, adv):
super().oninit(adv)
adv.summer_sakuya_flowers = 0
self.flower_buffs = Summer_Konohana_Sakuya.FLOWER_BUFFS
if adv.nihilism:
self.flower_buffs = dict(self.flower_buffs)
del self.flower_buffs[1]
del self.flower_buffs[2]
del self.flower_buffs[3]
def add_flower(t=None):
if adv.summer_sakuya_flowers >= 6:
return
adv.summer_sakuya_flowers += 1
try:
adv.Selfbuff(
f"d_sakuya_flower_{adv.summer_sakuya_flowers}",
*self.flower_buffs[adv.summer_sakuya_flowers],
).on()
except KeyError:
pass
add_flower()
Timer(add_flower, 60, True).on()
Event("ds").listener(add_flower)
def l_selfaff_proc(e):
if not self.is_cd:
self.deranged_thrill.on()
# confirm which mod is used
# adv.dmg_make("#menoetius_aura", 27.53)
adv.dmg_make("#menoetius_aura", 24.57)
self.is_cd = True
Timer(cd_end, 20).on()
def oninit(self, adv):
super().oninit(adv)
def chariot_energy(t):
adv.energy.add(1)
Timer(chariot_energy, 5, True).on()
def shift_end_energy(e):
adv.energy.add(5, team=True)
adv.Event('dragon_end').listener(shift_end_energy)
def __init__(
self,
name="<buff_noname>",
value=0,
duration=0,
mtype="att",
morder=None,
modifier=None,
hidden=False,
source=None,
):
self.name = name
self.__value = value
self.duration = duration
self.mod_type = mtype
self.mod_order = morder or ("chance"
if self.mod_type == "crit" else "buff")
self.bufftype = "misc" if hidden else "self"
self.source = source
if self.source is not None and source[0] != "s" and source[0:2] != "ds":
self.bufftime = self._ex_bufftime
else:
self.bufftime = self._bufftime
self.buff_end_timer = Timer(self.buff_end_proc)
if modifier:
self.modifier = modifier
self.get = self.modifier.get
elif mtype != "effect":
self.modifier = Modifier("mod_" + self.name, self.mod_type,
self.mod_order, 0)
self.modifier.get = self.get
else:
self.modifier = None
self.dmg_test_event = Event("dmg_formula")
self.dmg_test_event.dmg_coef = 1
self.dmg_test_event.dname = "test"
self.hidden = hidden
self.__stored = 0
self.__active = 0
self.buffevent = Event("buff")
self.pause_time = -1
self.refresh_time = -1
def d_shift_end(self, t):
if self.action_timer is not None:
self.action_timer.off()
self.action_timer = None
if not self.is_dragondrive and self.prev_act != "ds" and self.skill_use_final > 0:
self.skill_use_final -= 1
self.d_act_start("ds_final")
self.act_list = ["end"]
return False
duration = now() - self.shift_start_time
shift_dmg = g_logs.shift_dmg
g_logs.log_shift_dmg(False)
count = self.clear_delayed()
if count > 0:
log(
"cancel",
self.c_act_name,
f"by shift end",
f'lost {count} hit{"s" if count > 1 else ""}',
)
log(
self.name,
"{:.2f}dmg / {:.2f}s, {:.2f} dps".format(shift_dmg, duration,
shift_dmg / duration),
" ".join(self.act_sum),
)
self.act_sum = []
self.act_list = []
if self.off_ele:
self.adv.element = self.adv.slots.c.ele
if self.shift_spd_mod is not None:
self.shift_spd_mod.off()
self.ds_reset()
if not self.is_dragondrive:
self.shift_silence = True
Timer(self.end_silence).on(10)
self.dragon_gauge_pause_timer = Timer(self.resume_auto_gauge).on(
self.dragon_gauge_timer_diff)
self.status = Action.OFF
self._setprev() # turn self from doing to prev
self._static.doing = self.nop
if not self.is_dragondrive:
self.end_event()
self.idle_event()
return True
def d_dragondrive_end(self, t):
log('dragondrive', 'end')
self.dragondrive_buff.off()
Timer(self.end_silence).on(10)
self.status = -2
self._setprev() # turn self from doing to prev
self._static.doing = self.nop
self.dragondrive_end_event()
self.idle_event()
