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()