Exemplo n.º 1
0
class Su_Fang(Adv):
    a3 = ('s',0.35)
    conf = {}
    conf['slots.a'] = Twinfold_Bonds()+The_Fires_of_Hate()
    conf['acl'] = """
        `dragon.act("c3 s end")
        `s3, not self.s3_buff
        `s2, fsc
        `s4, fsc
        `s1
        `fs, x=4
        """
    coab = ['Blade','Dragonyule_Xainfried','Lin_You']
    share = ['Curran']

    def fs_proc_alt(self, e):
        self.afflics.poison('fs', 120, 0.582)

    def prerun(self):
        conf_fs_alt = {'fs.dmg': 0.174, 'fs.hit': 6}
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt), self.fs_proc_alt)
        self.s2_buff = Selfbuff('s2', 0.30, 15)

    def s1_proc(self, e):
        with KillerModifier('skiller', 'hit', 0.50, ['poison']):
            self.dmg_make(e.name, 5.58)
            if self.s2_buff.get():
                self.dmg_make(e.name, 2.60)
                self.hits += 2

    def s2_proc(self, e):
        self.fs_alt.on(1)
        self.s2_buff = Selfbuff(e.name, 0.30, 15).on()
Exemplo n.º 2
0
class Vice(Adv):
    a1 = ('bk',0.35)
    conf = {}
    conf['slot.a'] = Twinfold_Bonds()+The_Plaguebringer()
    conf['slot.d'] = Shinobi()
    conf['acl'] = """
        `s3, not self.s3_buff
        `s1
        `s2
        `fs, x=5
        """
    conf['afflict_res.poison'] = 0

    def fs_proc_alt(self, e):
        self.afflics.poison('fs', 120, 0.582)

    def prerun(self):
        conf_fs_alt = {'fs.dmg': 0.174, 'fs.hit': 6}
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt), self.fs_proc_alt)

    def s1_proc(self, e):
        with KillerModifier('s1_killer', 'hit', 0.5, ['poison']):
            self.dmg_make("s1", 15.84)

    def s2_proc(self, e):
        self.fs_alt.on(1)
        with KillerModifier('s2_killer', 'hit', 0.5, ['poison']):
            self.dmg_make("s2", 16.77)
Exemplo n.º 3
0
Arquivo: melody.py Projeto: Zeiin/dl
class Melody(Adv):
    a1 = ('cc', 0.15, 'hp100')

    conf = {}
    conf['slots.a'] = A_Dogs_Day() + From_Whence_He_Comes()
    conf['slots.d'] = Ariel()
    conf['acl'] = """
        `s3, not self.s3_buff
        `s1
        `fs, x=5
    """
    coab = ['Bow', 'Tobias', 'Tiki']

    def prerun(self):
        conf_fs_alt = {
            'fs.dmg': 3.40,
            'fs.recovery': 72 / 60.0,  # needs confirm
        }
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt))

    def s1_proc(self, e):
        self.fs_alt.on(1)

    def s2_proc(self, e):
        self.afflics.poison(e.name, 120, 0.582)
Exemplo n.º 4
0
class Radiant_Xuan_Zang(Adv):
    a1 = ('prep', 100)
    a3 = ('dbt', 0.20)

    conf = staff_fs_conf.copy()
    conf['slots.a'] = Candy_Couriers() + Spirit_of_the_Season()
    conf['acl'] = """
        `dragon, x=1
        `s2
        `s1
        `s4
        `s3, x=5
        `fs, self.fs_alt.uses>0 and cancel
    """
    coab = ['Sharena', 'Blade', 'Peony']
    share = ['Curran']
    conf['afflict_res.paralysis'] = 0

    def fs_proc_alt(self, e):
        self.afflics.paralysis.res_modifier = 0.20
        Timer(self.paralysis_rate_reset).on(20)

    def paralysis_rate_reset(self, t):
        self.afflics.paralysis.res_modifier = 0

    def prerun(self):
        conf_fs_alt = {'fs.dmg': 8.88}
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt), self.fs_proc_alt)
        self.xihe_gauge = 0
        self.xihe = {'s1': False, 's2': False}
        if self.condition('buff all team'):
            self.xihe_gauge_gain = 50
            self.buff_class = Teambuff
        else:
            self.xihe_gauge_gain = 20
            self.buff_class = Selfbuff

    def s1_proc(self, e):
        if self.xihe[e.name]:
            self.xihe[e.name] = False
            with KillerModifier('s1_killer', 'hit', 0.5, ['paralysis']):
                self.dmg_make(e.name, 18.80)
            Debuff(e.name, 0.25, 10, 1, 'attack').on()
        else:
            self.dmg_make(e.name, 16.1)
            Debuff(e.name, 0.10, 10, 0.70, 'attack').on()
            self.afflics.paralysis(e.name, 120, 0.97)

    def s2_proc(self, e):
        if self.xihe[e.name]:
            self.xihe[e.name] = False
            self.buff_class(e.name, 0.20, 15).on()
            self.inspiration.add(5, team=True)
        else:
            self.xihe_gauge += self.xihe_gauge_gain
            log('debug', 'xihe', self.xihe_gauge)
            if self.xihe_gauge >= 100:
                self.xihe_gauge = 0
                self.fs_alt.on(1)
                self.xihe = {'s1': True, 's2': True}
Exemplo n.º 5
0
Arquivo: albert.py Projeto: pfleg/dl
class Albert(Adv):
    a1 = ('fs', 0.5)
    conf = {}
    conf['acl'] = """
        `dragon, fsc
        `s2, s1.charged>=s1.sp-330
        `fs, s=2 and not self.afflics.paralysis.get()
        `s1, fsc
        `s3, fsc
        `s4
        `fs, seq=2
        """
    coab = ['Blade', 'Dagger', 'Peony']
    share = ['Ranzal']
    conf['afflict_res.paralysis'] = 0

    def fs_proc_alt(self, e):
        self.afflics.paralysis('fs', 100, 0.803)

    def prerun(self):
        conf_fs_alt = {
            'fs.dmg': 1.02,
            'fs.sp': 330,
            'fs.recovery': 26 / 60.0,
        }
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt), self.fs_proc_alt)
        self.s2.autocharge_init(self.s2autocharge).on()
        self.s2buff = Selfbuff("s2_shapshift", 1, 20, 'ss', 'ss')
        self.a3 = Selfbuff('a2_str_passive', 0.25, 20, 'att', 'passive')

        self.fs_alt_timer = Timer(self.fs_alt_end)
        self.s1_hits = 6 if self.condition('big hitbox') else 4

    @staticmethod
    def prerun_skillshare(adv, dst):
        adv.s2buff = Dummy()

    def fs_alt_end(self, t):
        self.fs_alt.off()

    def s2autocharge(self, t):
        if not self.s2buff.get():
            self.s2.charge(160000.0 / 40)
            log('sp', 's2autocharge')

    def s1_proc(self, e):
        if self.s2buff.get():
            name = f'o_{e.name}_boost'
            self.dmg_make(name, 12.38 - 0.825)
            for _ in range(2, self.s1_hits + 1):
                self.dmg_make(name, 0.83)
                self.add_hits(1)
            self.s2buff.buff_end_timer.timing += 2.6
            self.a3.buff_end_timer.timing += 2.6

    def s2_proc(self, e):
        self.s2buff.on()
        self.a3.on()
        self.fs_alt.on(-1)
        self.fs_alt_timer(20)
Exemplo n.º 6
0
Arquivo: vice.py Projeto: zzonnee/dl
class Vice(Adv):
    a1 = ('bk', 0.35)
    conf = {}
    conf['slots.a'] = Twinfold_Bonds() + The_Fires_of_Hate()
    conf['acl'] = """
        `dragon.act("c3 s end")
        `s3, not self.s3_buff
        `s4
        `s1
        `s2
        `fs, x=5
        """
    coab = ['Wand', 'Gala_Alex', 'Heinwald']
    conf['afflict_res.poison'] = 0
    share = ['Curran']

    def fs_proc_alt(self, e):
        self.afflics.poison('fs', 120, 0.582)

    def prerun(self):
        conf_fs_alt = {'fs.dmg': 0.174, 'fs.hit': 6}
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt), self.fs_proc_alt)

    def s1_proc(self, e):
        with KillerModifier('s1_killer', 'hit', 0.5, ['poison']):
            self.dmg_make(e.name, 15.84)

    def s2_proc(self, e):
        self.fs_alt.on(1)
        with KillerModifier('s2_killer', 'hit', 0.5, ['poison']):
            self.dmg_make(e.name, 16.77)
Exemplo n.º 7
0
class Lin_You(Adv):
    a1 = [('cc',0.10,'hp70'), ('cc',0.20,'hit25'), ('cc',0.20,'hit50')]
    a3 = ('sp',0.08)
    conf = {}
    conf['slots.a'] = The_Wyrmclan_Duo()+Primal_Crisis()
    conf['acl'] = """
        `dragon.act("c3 s end")
        `s3, not self.s3_buff
        `s2, s1.check()
        `s1
        `fs, self.hits <= 44 and self.fs_alt.uses > 0 and x=4
        """
    coab = ['Blade','Dragonyule_Xainfried','Axe2']

    def prerun(self):
        conf_fs_alt = {'fs.dmg': 2.59, 'fs.hit': 6}
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt))
        self.s2_buff = Spdbuff('s2_spd',0.20, 15)

    def s1_proc(self, e):
        if self.s2_buff.get():
            self.dmg_make(f'{e.name}_powerup', 1.86*3)
            self.s2_buff.buff_end_timer.add(self.s1.ac.getstartup()+self.s1.ac.getrecovery())
            self.hits += 3
            self.afflics.sleep(e.name, 150)
        self.fs_alt.on(3)

    def s2_proc(self, e):
        self.s2_buff.on()
Exemplo n.º 8
0
Arquivo: hawk.py Projeto: pfleg/dl
class Hawk(Adv):
    a1 = [('edge_stun', 50), ('edge_poison', 50)]
    a3 = [('k_stun', 0.4), ('k_poison', 0.3)]

    conf = {}
    conf['slots.a'] = Resounding_Rendition() + The_Fires_of_Hate()
    conf['acl'] = """
        # queue self.duration<=60 and prep and self.afflics.stun.resist
        # s2; s3; fs; s1, fsc; fs; s1, fsc; s1, cancel; s2, cancel
        # end
        `s3, not self.s3_buff
        `dragon.act('c3 s end'), s and self.duration >= 120
        `s2, self.fs_alt.uses=0 or (self.s2_mode=1)
        `fs, (s1.check() and self.fs_alt.uses>1) or (x=4 and self.s2_mode=0 and self.fs_alt.uses>0)
        `s1, fsc or s=1
        `s4, s or x=5
    """

    coab = ['Blade', 'Dragonyule_Xainfried', 'Sylas']
    share = ['Curran']
    conf['afflict_res.stun'] = 80
    conf['afflict_res.poison'] = 0

    def fs_proc_alt(self, e):
        self.afflics.stun('fs', 110)
        self.afflics.poison('fs', 120, 0.582)

    def prerun(self):
        conf_fs_alt = {
            'fs.dmg': 4.94,
            'fs.hit': 19,
            'fs.sp': 2400,
            'missile_iv.fs': 0.5
        }
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt), self.fs_proc_alt)
        self.s2_mode = 0
        self.a_s2 = self.s2.ac
        self.a_s2a = S('s2', Conf({'startup': 0.10, 'recovery': 2.5}))

    def s1_proc(self, e):
        with KillerModifier('s1_stun_killer', 'hit', 3.3, ['stun']):
            self.dmg_make(e.name, 4.74)
        with KillerModifier('s1_poison_killer', 'hit', 2, ['poison']):
            self.dmg_make(e.name, 4.74)

    def s2_proc(self, e):
        if self.s2_mode == 0:
            self.fs_alt.on(2)
            self.s2.ac = self.a_s2a
        else:
            with KillerModifier('s2_killer', 'hit', 0.5, ['poison']):
                self.dmg_make(e.name, 9.48)
            self.conf.s2.startup = 0.25
            self.conf.s2.recovery = 0.9
            self.s2.ac = self.a_s2
            self.add_hits(3)
        self.s2_mode = (self.s2_mode + 1) % 2
Exemplo n.º 9
0
Arquivo: nefaria.py Projeto: qwewqa/dl
class Nefaria(Adv):
    comment = 's2 fs(precharge) s1 s1'
    a1 = ('k_poison', 0.3)
    a3 = ('k_blind', 0.4)
    conf = {}
    conf['slot.d'] = Shinobi()
    conf['slot.a'] = Resounding_Rendition() + The_Fires_of_Hate()
    conf['acl'] = """
        `fs, self.fs_alt.uses > 0 and s1.check()
        `s2, s1.check()
        `s1
        `s3, x=4 or x=5
        """
    # conf['acl'] = """
    #     `fs, self.fs_alt.uses > 0 and x=4
    #     `s1, fsc or x=1 or not self.s3_buff
    #     `s2
    #     `s3, not self.s3_buff
    #     """

    conf['afflict_res.blind'] = 80
    conf['afflict_res.poison'] = 0

    def fs_proc_alt(self, e):
        self.afflics.blind('s2_fs', 110 + self.fullhp * 60)

    def prerun(self):
        conf_fs_alt = {
            'fs.dmg': 8.09,
            'fs.hit': 19,
            'fs.sp': 2400,
        }
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt), self.fs_proc_alt)

        if self.condition('hp100'):
            self.fullhp = 1
        else:
            self.fullhp = 0

    def s1_proc(self, e):
        with KillerModifier('s1killer', 'hit', 0.74, ['blind', 'poison']):
            self.dmg_make('s1', 1.06)
            self.hits += 1
            self.afflics.poison('s1', 70 + self.fullhp * 60, 0.582)
            self.dmg_make('s1', 7 * 1.06)
            self.hits += 7

    def s2_proc(self, e):
        self.fsacharge = 1
        self.fs_alt.on(1)
Exemplo n.º 10
0
class Vida(Adv):
    a1 = ('fs',0.30)
    conf = {}
    conf['acl'] = """
        `s3, not self.s3_buff
        `s1
        `fs, x=5
        """

    def prerun(self):
        conf_fs_alt = {'fs.dmg': 0.110, 'fs.hit': 6}
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt))

    def s2_proc(self, e):
        self.fs_alt.on(3)
Exemplo n.º 11
0
class Hawk(Adv):
    a1 = [('edge_stun', 50), ('edge_poison', 50)]
    a3 = [('k_stun', 0.4), ('k_poison', 0.3)]
    conf = {}
    conf['slot.a'] = Resounding_Rendition() + The_Fires_of_Hate()
    conf['acl'] = """
        `dragon.act("c3 s end")
        `fs, s=2
        `s2, s1.check()
        `s1, cancel
    """
    coab = ['Blade', 'Dragonyule_Xainfried', 'Sylas']
    conf['afflict_res.stun'] = 80
    conf['afflict_res.poison'] = 0

    def fs_proc_alt(self, e):
        self.afflics.stun('fs', 110)
        self.afflics.poison('fs', 120, 0.582)

    def prerun(self):
        conf_fs_alt = {
            'fs.dmg': 4.94,
            'fs.hit': 19,
            'fs.sp': 2400,
        }
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt), self.fs_proc_alt)
        self.s2_mode = 0
        self.a_s2 = self.s2.ac
        self.a_s2a = S('s2', Conf({'startup': 0.10, 'recovery': 2.5}))

    def s1_proc(self, e):
        with KillerModifier('s1_stun_killer', 'hit', 3.3, ['stun']):
            self.dmg_make('s1', 4.74)
        with KillerModifier('s1_poison_killer', 'hit', 2, ['poison']):
            self.dmg_make('s1', 4.74)

    def s2_proc(self, e):
        if self.s2_mode == 0:
            self.fs_alt.on(2)
            self.s2.ac = self.a_s2a
        else:
            with KillerModifier('s2_killer', 'hit', 0.5, ['poison']):
                self.dmg_make('s2', 9.48)
            self.conf.s2.startup = 0.25
            self.conf.s2.recovery = 0.9
            self.s2.ac = self.a_s2
            self.hits += 3
        self.s2_mode = (self.s2_mode + 1) % 2
Exemplo n.º 12
0
Arquivo: ku_hai.py Projeto: zzonnee/dl
class Ku_Hai(Adv):
    comment = 'c2+fs during s2'
    a1 = ('cd', 0.15)
    a3 = ('cd', 0.15, 'hp70')
    conf = {}
    # c1+fs_alt has higher dps and sp rate than c2+fs_alt with or without stellar show  (x)
    # c2+fs_alt fs can init quicker than c1+fs_alt
    conf['slots.a'] = The_Lurker_in_the_Woods() + The_Shining_Overlord()
    conf['slots.d'] = AC011_Garland()
    conf['acl'] = '''
        `dragon.act("c3 s c1 end")
        `s3, not self.s3_buff
        `s1, fsc
        `s2
        `s4
        `fs, seq=2 and self.fs_alt.get()
        `fs, seq=3
        '''
    coab = ['Blade', 'Dragonyule_Xainfried', 'Akasha']
    share = ['Curran']

    def prerun(self):
        self.fshit = 2
        self.alttimer = Timer(self.altend)
        conf_fs_alt = {
            'fs.dmg': 0.83 * 2,
            'fs.sp': 330,
            'fs.charge': 2 / 60.0,  # needs confirm
            'fs.startup': 31 / 60.0,
            'fs.recovery': 33 / 60.0,
            'fs.hit': 2,
            'x2fs.startup': 16 / 60.0,
            'x2fs.recovery': 33 / 60.0,
            'x3fs.startup': 16 / 60.0,
            'x3fs.recovery': 33 / 60.0,
        }
        if self.condition('big hitbox'):
            conf_fs_alt['fs.dmg'] += 0.83
            conf_fs_alt['fs.hit'] += 1
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt))

    def altend(self, t):
        self.fs_alt.off()

    def s2_proc(self, e):
        self.fs_alt.on(-1)
        self.alttimer.on(10)
Exemplo n.º 13
0
Arquivo: vida.py Projeto: zzysan/dl
class Vida(Adv):
    a1 = ('fs', 0.30)
    conf = {}
    conf['acl'] = """
        `dragon
        `s3, not self.s3_buff
        `s1
        `fs, x=5
        """
    coab = ['Ieyasu', 'Wand', 'Tiki']

    def prerun(self):
        conf_fs_alt = {'fs.dmg': 0.110, 'fs.hit': 6}
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt))

    def s2_proc(self, e):
        self.fs_alt.on(3)
Exemplo n.º 14
0
class Nefaria(Adv):
    comment = 's2 fs(precharge) s1 s1'

    a1 = [('edge_blind', 60, 'hp100'), ('edge_poison', 60, 'hp100')]
    a3 = [('k_blind', 0.4), ('k_poison', 0.3)]

    conf = {}
    conf['slots.a'] = Resounding_Rendition() + The_Fires_of_Hate()
    conf['acl'] = """
        `dragon.act("c3 s end")
        `s3, not self.s3_buff
        `fs, self.fs_alt.uses > 0 and x=4
        `s1, fsc or x=1 or not self.s3_buff
        `s4
        `s2
        """
    coab = ['Wand', 'Gala_Alex', 'Heinwald']
    share = ['Curran']

    conf['afflict_res.blind'] = 80
    conf['afflict_res.poison'] = 0

    def fs_proc_alt(self, e):
        self.afflics.blind('s2_fs', 110)

    def prerun(self):
        conf_fs_alt = {
            'fs.dmg': 7.90,
            'fs.hit': 19,
            'fs.sp': 2400,
            'missile_iv.fs': 0.5
        }
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt), self.fs_proc_alt)

    def s1_proc(self, e):
        with KillerModifier('s1killer', 'hit', 0.74, ['blind', 'poison']):
            self.dmg_make(e.name, 1.06)
            self.hits += 1
            self.afflics.poison(e.name, 70, 0.582)
            self.dmg_make(e.name, 7 * 1.06)
            self.hits += 7

    def s2_proc(self, e):
        self.fsacharge = 1
        self.fs_alt.on(1)
Exemplo n.º 15
0
class Vida(Adv):
    a1 = ('fs', 0.30)
    conf = {}
    conf['acl'] = """
        `dragon, x=5
        `s3, not self.s3_buff
        `s4
        `s1
        `fs, x=5
        """
    coab = ['Ieyasu', 'Wand', 'Axe2']
    share = ['Curran']

    def prerun(self):
        conf_fs_alt = {'fs.dmg': 2.04, 'fs.hit': 6}
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt))

    def s2_proc(self, e):
        self.fs_alt.on(3)
Exemplo n.º 16
0
class Fritz(Adv):
    conf = {}
    conf['acl'] = """
        `dragon
        `s1, x=5 and cancel or fsc
        `s2
        `s3
        `fs, x=5
        """
    coab = ['Blade', 'Halloween_Elisanne', 'Peony']

    def fs_proc_alt(self, e):
        self.afflics.stun('fs', 100)

    def prerun(self):
        conf_fs_alt = {'fs.dmg': 4.03, 'fs.hit': 11}
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt), self.fs_proc_alt)

    def s2_proc(self, e):
        self.fs_alt.on(3)
Exemplo n.º 17
0
class Nefaria(Adv):
    comment = 's2 fs(precharge) s1 s1'
    a1 = [('edge_blind', 60, 'hp100'), ('edge_poison', 60, 'hp100')]
    a3 = [('k_blind', 0.4), ('k_poison', 0.3)]
    conf = {}
    conf['slot.d'] = Shinobi()
    conf['slot.a'] = Resounding_Rendition() + The_Fires_of_Hate()
    conf['acl'] = """
        `s3, not self.s3_buff
        `fs, self.fs_alt.uses > 0 and x=4
        `s1, fsc or x=1 or not self.s3_buff
        `s2
        """

    conf['afflict_res.blind'] = 80
    conf['afflict_res.poison'] = 0

    def fs_proc_alt(self, e):
        self.afflics.blind('s2_fs', 110)

    def prerun(self):
        conf_fs_alt = {
            'fs.dmg': 7.90,
            'fs.hit': 19,
            'fs.sp': 2400,
        }
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt), self.fs_proc_alt)

    def s1_proc(self, e):
        with KillerModifier('s1killer', 'hit', 0.74, ['blind', 'poison']):
            self.dmg_make('s1', 1.06)
            self.hits += 1
            self.afflics.poison('s1', 70, 0.582)
            self.dmg_make('s1', 7 * 1.06)
            self.hits += 7

    def s2_proc(self, e):
        self.fsacharge = 1
        self.fs_alt.on(1)
Exemplo n.º 18
0
Arquivo: xander.py Projeto: zzonnee/dl
class Xander(Adv):
    comment = 'c2+fs'

    a3 = ('fs', 0.55)

    conf = {}
    conf['slots.a'] = The_Shining_Overlord() + His_Clever_Brother()
    conf['slots.d'] = Gaibhne_and_Creidhne()
    conf['acl'] = """
        if self.born_ruler_1.get() and not self.born_ruler_2.get()
        `s3 
        `s4
        `s2
        `s1
        else
        `dragon.act('c3 s end'), fsc
        `s3, fsc or s
        `s2, fsc or s
        `s1, fsc or s
        `fs, x=2
        end
    """
    coab = ['Blade', 'Yurius', 'Hunter_Sarisse']
    share = ['Gala_Elisanne', 'Hunter_Sarisse']

    def fs_proc_alt(self, e):
        if self.born_ruler_2.get():
            with KillerModifier('fs_killer', 'hit', 0.30, ['frostbite']):
                self.dmg_make('fs', 6.66)
        else:
            self.dmg_make('fs', 3.26)
        self.conf['s1'].dmg = 8.32
        self.born_ruler.off()
        self.born_ruler_1.off()
        self.born_ruler_2.off()

    def prerun(self):
        # identical to granzal FS in frames
        conf_fs_alt = {
            'fs.dmg': 0.0,
            'fs.sp': 330,
            'fs.hit': 3,
            'fs.charge': 2 / 60.0,  # needs confirm
            'fs.startup': 66 / 60.0,
            'x1fs.startup': 75 / 60.0,
            'x2fs.startup': 60 / 60.0,
            'x3fs.startup': 60 / 60.0,
            'fs.recovery': 13 / 60.0,
            'x1fs.recovery': 13 / 60.0,
            'x2fs.recovery': 13 / 60.0,
            'x3fs.recovery': 13 / 60.0,
        }
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt), self.fs_proc_alt)
        self.born_ruler = Selfbuff('born_ruler', 0.05, -1, 'att', 'buff')
        self.born_ruler_1 = Selfbuff('born_ruler_1', 1, -1, 'xunder', 'buff')
        self.born_ruler_2 = Selfbuff('born_ruler_2', 1, -1, 'xunder', 'buff')

    def s1_proc(self, e):
        boost = 0.05 * self.buffcount
        self.afflics.frostbite(e.name, 120, 0.41 * (1 + boost))
        try:
            if self.born_ruler_2.get():
                # phase 3
                self.dmg_make(f'o_{e.name}_boost',
                              self.conf[e.name].dmg * boost)
                self.conf[e.name].dmg = 8.32
                self.fs_alt.off()
                self.born_ruler.off()
                self.born_ruler_1.off()
                self.born_ruler_2.off()
            elif self.born_ruler_1.get():
                # phase 2
                self.dmg_make(f'o_{e.name}_boost',
                              self.conf[e.name].dmg * boost)
                self.conf[e.name].dmg = 8.40
                self.born_ruler_2.on()
            else:
                self.fs_alt.on()
                self.born_ruler.on()
                self.born_ruler_1.on()
                # phase 1
                self.dmg_make(f'o_{e.name}_boost',
                              self.conf[e.name].dmg * boost)
                self.conf[e.name].dmg = 8.37
        except:
            self.dmg_make(f'o_{e.name}_boost', self.conf[e.name].dmg * boost)
        log('debug', 'xander_s1_boost',
            f'x{self.buffcount} = {self.conf[e.name].dmg*(1+boost):.2%}')

    def s2_proc(self, e):
        boost = 0.05 * self.buffcount
        self.dmg_make(f'o_{e.name}_boost', self.conf[e.name].dmg * boost)
        log('debug', 'xander_s2_boost',
            f'x{self.buffcount} = {self.conf[e.name].dmg*(1+boost):.2%}')
Exemplo n.º 19
0
class Albert(Adv):
    a1 = ('fs',0.5)
    conf = {}
    conf['acl'] = """
        `s2, s1.charged>=s1.sp-330
        `fs, s=2 and not self.afflics.paralysis.get()
        `s1, fsc
        `s3, fsc
        `fs, seq=2
        """
    conf['slot.a'] = TSO()+SDO()
    conf['slot.d'] = C_Phoenix()
    conf['afflict_res.paralysis'] = 0

    def init(self):
        if self.condition('big hitbox'):
            self.s1_proc = self.c_s1_proc

    def fs_proc_alt(self, e):
        self.afflics.paralysis('fs',100,0.803)

    def prerun(self):
        conf_fs_alt = {
            'fs.dmg':1.02,
            'fs.sp':330,
            'fs.recovery':26/60.0,
        }
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt), self.fs_proc_alt)


        self.s2timer = Timer(self.s2autocharge,1,1).on()
        self.s2buff = Selfbuff("s2_shapshift",1, 20,'ss','ss')
        self.a3 = Selfbuff('a2_str_passive',0.25,20,'att','passive')

        self.fs_alt_timer = Timer(self.fs_alt_end)

    def fs_alt_end(self,t):
        self.fs_alt.off()

    def s2autocharge(self, t):
        if not self.s2buff.get():
            self.s2.charge(160000.0/40)
            log('sp','s2autocharge')

    def c_s1_proc(self, e):
        if self.s2buff.get():
            self.dmg_make("o_s1_s2boost",12.38-0.825)
            self.dmg_make("o_s1_hit2", 0.83)
            self.dmg_make("o_s1_hit3", 0.83)
            self.dmg_make("o_s1_hit4", 0.83)
            self.dmg_make("o_s1_hit5", 0.83)
            self.dmg_make("o_s1_hit6", 0.83)
            self.s2buff.buff_end_timer.timing += 2.6
            self.a3.buff_end_timer.timing += 2.6
            self.s2timer.timing += 2.6


    def s1_proc(self, e):
        if self.s2buff.get():
            self.dmg_make("o_s1_s2boost",12.38-0.825)
            self.dmg_make("o_s1_hit2", 0.83)
            self.dmg_make("o_s1_hit3", 0.83)
            self.dmg_make("o_s1_hit4", 0.83)
            self.s2buff.buff_end_timer.timing += 2.6
            self.a3.buff_end_timer.timing += 2.6
            self.s2timer.timing += 2.6

    def s2_proc(self, e):
        self.s2timer.on()
        self.s2buff.on()
        self.a3.on()
        self.fs_alt.on(-1)
        self.fs_alt_timer(20)
Exemplo n.º 20
0
class Bellina(Adv):
    conf = {}
    conf['slot.a'] = Twinfold_Bonds()+Howling_to_the_Heavens()
    conf['slot.d'] = Fatalis()
    conf['acl'] = """
        `s2, sim_duration-now()<1.5
        `s3, not self.s3_buff
        if self.dragondrive_buff.get()
        `s1, self.dragonform.dragon_gauge>850 and x=3
        `fsf, x=3
        else
        `s2
        `dragon
        `fs, x=4
        end
    """

    def fs_proc_alt(self, e):
        with CrisisModifier('s1', 1.00, self.hp):
            self.dmg_make('fs', 5.65)
        self.dragonform.charge_gauge(self.conf.fs.utp, percent=False)

    def l_dragondrive_x(self, e):
        xalt = self.dragondrive_x
        xseq = e.name
        dmg_coef = xalt.conf[xseq].dmg
        sp = xalt.conf[xseq].sp
        hit = xalt.conf[xseq].hit
        utp = xalt.conf[xseq].utp
        log('x', xseq, 'dragondrive')
        self.hits += hit
        with CrisisModifier('x', 1.00, self.hp):
            self.dmg_make(xseq, dmg_coef)
        self.charge(xseq, sp)
        self.dragonform.charge_gauge(utp, percent=False)

    def prerun(self):
        self.dragondrive_buff = Selfbuff('dragondrive', 0.35, -1, 's', 'passive')
        self.dragonform.set_dragondrive(self.dragondrive_buff)
        Event('dragon_end').listener(self.dragondrive_on) # cursed
        Event('dragondrive_end').listener(self.dragondrive_off)

        self.dragondrive_x = X_alt(self, 'dragondrive', dragondrive_auto_conf, x_proc=self.l_dragondrive_x)
        self.fs_alt = Fs_alt(self, Conf(dragondrive_fs_conf), self.fs_proc_alt)

        self.a3_str = Modifier('a3', 'att', 'passive', 0.20)
        self.a3_spd = Spdbuff('a3',0.10,-1)
        
        self.hp = 100

        self.a_s1 = self.s1.ac
        self.a_s1a = S('s1', Conf({'startup': 0.10, 'recovery': 1.10}))

        self.a_s2 = self.s2.ac
        self.a_s2a = S('s2', Conf({'startup': 0.10, 'recovery': 2.70}))

        self.fsf_a = Fs('fsf', self.conf.fsf)

    def dragondrive_on(self, e):
        self.s1.ac = self.a_s1a
        self.s2.ac = self.a_s2a
        self.fs_alt.on(-1)
        self.dragondrive_x.on()
        self.a_fsf = Fs('fsf', self.conf.fsf)

    def dragondrive_off(self, e):
        self.s1.ac = self.a_s1
        self.s2.ac = self.a_s2
        self.fs_alt.off()
        self.dragondrive_x.off()

    def s1_proc(self, e):
        if self.dragondrive_buff.get():
            with CrisisModifier('s1', 0.50, self.hp):
                self.dmg_make('s1', 2.02 * 5)
                self.hits += 5
            self.s1.charge(self.conf.s1.sp)
            self.dragonform.charge_gauge(-750, percent=False)
            # 2.02 mod 1.5x crisis
            # 0.2666666805744171 + 0.18000000715255737 * 5
            # 1.1666666269302368 (?)
            # -750 gauge
            # +100% skill
        else:
            with CrisisModifier('s1', 0.50, self.hp):
                self.dmg_make('s1', 8.40)
                self.hits += 1
            # 840 mod, 1.5x crisis
            # 1.399999976158142 (?)

    def s2_proc(self, e):
        if self.dragondrive_buff.get():
            with CrisisModifier('s2', 2.00, self.hp):
                self.dmg_make('s2', 12.12)
                self.hits += 1
            self.dragonform.charge_gauge(-3000, percent=False)
            # -3000 gauge
            # 2.7666666507720947 (?)
            # 1212 mod, 3x crisis
        else:
            self.dragonform.charge_gauge(1200, percent=False)
            # 1 hp loss = 1 gauge gain, will assume 3000 max hp here
            if self.hp > 30:
                self.dragonform.charge_gauge(3000 * (self.hp-30)/100, percent=False)
                self.hp = 30
                self.a3_str.on()
                self.a3_spd.on()
Exemplo n.º 21
0
class Gala_Ranzal(Adv):
    comment = 'no s2'

    conf = {}
    conf['slots.a'] = The_Shining_Overlord()+United_by_One_Vision()
    conf['slot.d'] = AC011_Garland()
    conf['acl'] = '''
        `dragon.act("c3 s end")
        `s1, fsc
        `s3, fsc
        `fs, seq=2 and self.gauges['x'] <= 500
        `fs, seq=3
    '''
    coab = ['Blade','Dragonyule_Xainfried','Lin_You']
    
    def d_slots(self):
        if self.slots.c.has_ex('bow'):
            self.conf.slot.a = TSO()+BN()

    a3 = ('s',0.3)

    #c3 770
    #fs1 802
    #fs3 832
    #fsend 854-9
    #c1 854

    def prerun(self):
        self.ifs1ins2 = 0
        self.gauges = {
                'x':0,
                'fs':0,
                }
        self.conf.fs.gauge = 150
        conf_fs_alt = {
            'fs.dmg':0.83*2+0.92,
            'fs.sp' :330,
            'fs.gauge': 350,
            'fs.charge': 2/60.0, # needs confirm
            'fs.startup':66/60.0,
            'x1fs.startup':75/60.0,
            'x2fs.startup':60/60.0,
            'x3fs.startup':60/60.0,

            'fs.recovery':13/60.0,
            'x1fs.recovery':13/60.0,
            'x2fs.recovery':13/60.0,
            'x3fs.recovery':13/60.0,
        }
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt))

    def dmg_proc(self, name, amount):
        if name == 'x1':
            self.gauges['x'] += 77
        elif name == 'x2':
            self.gauges['x'] += 77
        elif name == 'x3':
            self.gauges['x'] += 100
        elif name == 'x4':
            self.gauges['x'] += 136
        elif name == 'x5':
            self.gauges['x'] += 200
        elif name == 'fs':
            self.gauges['fs'] += self.conf.fs.gauge
        log('gauges', name, self.gauges['x'], self.gauges['fs'])

    def s1_proc(self, e):
        boost = 0
        if self.gauges['x'] >= 1000:
            boost += 1
            self.gauges['x'] = 0
        if self.gauges['fs'] >= 1000:
            boost += 1
            self.gauges['fs'] = 0
        if boost == 1:
            self.dmg_make('o_s1_boost',self.conf['s1.dmg']*0.2)
        if boost == 2:
            self.dmg_make('o_s1_boost',self.conf['s1.dmg']*0.8)
        self.ifs1ins2 = 1


    def s2_proc(self, e):
        self.fs_alt.on(3)
        self.ifs1ins2 = 0
        Event('defchain')()
Exemplo n.º 22
0
class Ku_Hai(Adv):
    comment = 'c2+fs during s2'
    a1 = ('cd', 0.15)
    a3 = ('cd', 0.15, 'hp70')
    conf = {}
    # c1+fs_alt has higher dps and sp rate than c2+fs_alt with or without stellar show  (x)
    # c2+fs_alt fs can init quicker than c1+fs_alt
    conf['slots.a'] = The_Lurker_in_the_Woods() + The_Shining_Overlord()
    conf['slot.d'] = AC011_Garland()
    conf['acl'] = '''
        `dragon.act("c3 s c1 end")
        `s1, fsc
        `s2
        `s3, fsc
        `fs, seq=2 and self.fs_alt.get()
        `fs, seq=3
        '''
    coab = ['Blade', 'Dragonyule_Xainfried', 'Akasha']

    def init(self):
        if self.condition('huge hitbox eneny'):
            self.o_prerun = self.prerun
            self.prerun = self.c_prerun
        else:
            self.missc1 = self.c_missc1
            self.backc1 = self.c_backc1

    def pre2(self):
        pass

    def c_prerun(self):
        self.o_prerun()
        self.fshit = 3
        self.fs_alt.conf_alt['fs.dmg'] = 0

    def missc1(self):
        pass

    def backc1(self):
        pass

    def c_missc1(self):
        self.x1dmgb = self.conf['x1.dmg']
        self.x1spb = self.conf['x1.sp']
        self.conf['x1.dmg'] = 0
        self.conf['x1.sp'] = 0

    def c_backc1(self):
        self.conf['x1.dmg'] = self.x1dmgb
        self.conf['x1.sp'] = self.x1spb

    def fs_proc_alt(self, e):
        self.dmg_make('o_fs_alt_hit1', 0.83)
        if self.fshit >= 2:
            self.dmg_make('o_fs_alt_hit2', 0.83)
        if self.fshit >= 3:
            self.dmg_make('o_fs_alt_hit3', 0.83)

    def prerun(self):
        self.fshit = 2
        self.alttimer = Timer(self.altend)
        conf_fs_alt = {
            'fs.dmg': 0,
            'fs.sp': 330,
            'fs.charge': 2 / 60.0,  # needs confirm
            'fs.startup': 31 / 60.0,
            'fs.recovery': 33 / 60.0,
            'x2fs.startup': 16 / 60.0,
            'x2fs.recovery': 33 / 60.0,
            'x3fs.startup': 16 / 60.0,
            'x3fs.recovery': 33 / 60.0,
        }
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt), self.fs_proc_alt)

    def altend(self, t):
        self.fs_alt.off()
        self.backc1()

    def s2_proc(self, e):
        self.fs_alt.on(-1)
        self.alttimer.on(10)
        self.missc1()
Exemplo n.º 23
0
class Gala_Cleo(Adv):
    comment = '(the true cleo is here)'
    a3 = ('prep','100%')
    conf = {}
    conf['slots.a'] = Candy_Couriers()+Primal_Crisis()  # wand c2*1.08 = 217
    conf['acl'] = """
        `s3, not self.s3_buff
        `fs, s1.charged>=s1.sp and self.fs_alt.uses > 0
        if x=5 or x=4 or fsc or s
        `s4
        `s2
        end
        `s1, s or fsc

        # Buffbot Gleo with Azazel & Memory_of_a_Friend
        # `s3, not self.s3_buff
        # `fs, (s1.check() or s2.check()) and self.fs_alt.uses > 0
        # `s4, cancel
        # `s2, cancel
        # `s1, cancel
        """
    coab = ['Blade','Bow','Dagger']
    share = ['Curran']

    def fs_proc_alt(self, e):
        if self.a1_buffed:
            Teambuff('a1_str',0.25,10).no_bufftime().on()

    def prerun(self):
        self.a1_buffed = self.condition('a1 buff for 10s')
        self.phase['s1'] = 0

        conf_fs_alt = {
            'fs.dmg':0,
            'fs.sp' :0,
            'fs.charge': 30/60.0,
            'fs.startup': 20/60.0,
            'fs.recovery': 60/60.0,
        }
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt), self.fs_proc_alt)

    @staticmethod
    def prerun_skillshare(adv, dst):
        adv.phase[dst] = 0
        adv.fs_alt = Dummy()
        adv.rebind_function(Gala_Cleo, 's1_dmg')

    def s1_dmg(self, t):
        self.dmg_make(t.name,0.88)
        self.hits += 1
        self.dmg_make(t.name,2.65)
        self.hits += 1

    def s1_proc(self, e):
        self.phase[e.name] += 1
        for i in range(0, 3 + self.phase[e.name]):
            s1_timer = Timer(self.s1_dmg)
            s1_timer.name = e.name
            s1_timer.on((42.0 + 12*i )/60)
        self.fs_alt.on()
        self.phase[e.name] %= 3

    def s2_proc(self, e):
        Debuff(e.name, 0.10, 20).on()
        Debuff(e.name, 0.05, 20, 1, 'attack').on()
Exemplo n.º 24
0
class Gala_Ranzal(Adv):
    comment = 'no s2'

    conf = {}
    conf['acl'] = '''
        `s1, fsc
        `s3, fsc
        `fs, seq=2 and self.gauges['x'] <= 500
        `fs, seq=3
    '''
    conf['slots.a'] = JotS() + TSO()
    def d_slots(self):
        if 'bow' in self.ex:
            self.conf.slot.a = TSO()+BN()

    a3 = ('s',0.3)

    #c3 770
    #fs1 802
    #fs3 832
    #fsend 854-9
    #c1 854

    def prerun(self):
        self.ifs1ins2 = 0
        self.gauges = {
                'x':0,
                'fs':0,
                }
        self.conf.fs.gauge = 150
        conf_fs_alt = {
            'fs.dmg':0.83*2+0.92,
            'fs.sp' :330,
            'fs.gauge': 350,
            'fs.charge': 2/60.0, # needs confirm
            'fs.startup':66/60.0,
            'x1fs.startup':75/60.0,
            'x2fs.startup':60/60.0,
            'x3fs.startup':60/60.0,

            'fs.recovery':13/60.0,
            'x1fs.recovery':13/60.0,
            'x2fs.recovery':13/60.0,
            'x3fs.recovery':13/60.0,
        }
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt))

    def dmg_proc(self, name, amount):
        if name == 'x1':
            self.gauges['x'] += 77
        elif name == 'x2':
            self.gauges['x'] += 77
        elif name == 'x3':
            self.gauges['x'] += 100
        elif name == 'x4':
            self.gauges['x'] += 136
        elif name == 'x5':
            self.gauges['x'] += 200
        elif name == 'fs':
            self.gauges['fs'] += self.conf.fs.gauge
        log('gauges', name, self.gauges['x'], self.gauges['fs'])

    def s1_proc(self, e):
        boost = 0
        if self.gauges['x'] >= 1000:
            boost += 1
            self.gauges['x'] = 0
        if self.gauges['fs'] >= 1000:
            boost += 1
            self.gauges['fs'] = 0
        if boost == 1:
            self.dmg_make('o_s1_boost',self.conf['s1.dmg']*0.2)
        if boost == 2:
            self.dmg_make('o_s1_boost',self.conf['s1.dmg']*0.8)
        self.ifs1ins2 = 1


    def s2_proc(self, e):
        self.fs_alt.on(3)
        self.ifs1ins2 = 0
        Event('defchain')()
Exemplo n.º 25
0
class Bellina(Adv):
    a3 = ('crisisattspd', 3)

    conf = {}
    conf['slots.a'] = Twinfold_Bonds() + Howling_to_the_Heavens()
    conf['slots.poison.a'] = Twinfold_Bonds() + The_Plaguebringer()
    conf['acl'] = """
        `s2, sim_duration-now()<1.5
        `s3, not self.s3_buff
        if self.dragondrive_buff.get()
        `s1, self.dragonform.dragon_gauge>1000 and x=3
        `s4, x=3
        `fsf, x=3
        else
        `s2
        `dragon
        `fs, x=4
        end
    """
    coab = ['Ieyasu', 'Curran', 'Berserker']
    share = ['Veronica']

    def fs_proc_alt(self, e):
        with CrisisModifier(e.name, 1.00, self.hp):
            self.dmg_make('fs', 5.65)
        self.dragonform.charge_gauge(self.conf.fs.utp, utp=True)

    def l_dragondrive_x(self, e):
        xalt = self.dragondrive_x
        xseq = e.name
        dmg_coef = xalt.conf[xseq].dmg
        sp = xalt.conf[xseq].sp
        hit = xalt.conf[xseq].hit
        utp = xalt.conf[xseq].utp
        log('x', xseq, 'dragondrive')
        self.hits += hit
        with CrisisModifier('x', 1.00, self.hp):
            self.dmg_make(xseq, dmg_coef)
        self.charge(xseq, sp)
        self.dragonform.charge_gauge(utp, utp=True)

    def prerun(self):
        self.dragondrive_buff = Selfbuff('dragondrive', 0.35, -1, 's',
                                         'passive')
        self.dragonform.set_dragondrive(self.dragondrive_buff)
        Event('dragon_end').listener(self.dragondrive_on)  # cursed
        Event('dragondrive_end').listener(self.dragondrive_off)

        self.dragondrive_x = X_alt(self,
                                   'dragondrive',
                                   dragondrive_auto_conf,
                                   x_proc=self.l_dragondrive_x)
        self.fs_alt = Fs_alt(self, Conf(dragondrive_fs_conf), self.fs_proc_alt)

        self.a_s1 = self.s1.ac
        self.a_s1a = S('s1', Conf({'startup': 0.10, 'recovery': 1.10}))

        self.a_s2 = self.s2.ac
        self.a_s2a = S('s2', Conf({'startup': 0.10, 'recovery': 2.26}))

        self.fsf_a = Fs('fsf', self.conf.fsf)

    def dragondrive_on(self, e):
        self.s1.ac = self.a_s1a
        self.s2.ac = self.a_s2a
        self.fs_alt.on(-1)
        self.dragondrive_x.on()
        self.a_fsf = Fs('fsf', self.conf.fsf)

    def dragondrive_off(self, e):
        self.s1.ac = self.a_s1
        self.s2.ac = self.a_s2
        self.fs_alt.off()
        self.dragondrive_x.off()

    def s1_proc(self, e):
        if self.dragondrive_buff.get():
            with CrisisModifier(e.name, 0.50, self.hp):
                self.dmg_make(e.name, 2.02 * 5)
                self.hits += 5
            self.s1.charge(self.conf.s1.sp)
            self.dragonform.charge_gauge(-750, utp=True)
        else:
            with CrisisModifier(e.name, 0.50, self.hp):
                self.dmg_make(e.name, 8.40)
                self.hits += 1

    def s2_proc(self, e):
        if self.dragondrive_buff.get():
            with CrisisModifier(e.name, 2.00, self.hp):
                self.dmg_make(e.name, 12.12)
                self.hits += 1
            self.dragonform.charge_gauge(-3000, utp=True)
            # -3000 gauge
            # 2.7666666507720947 (?)
            # 1212 mod, 3x crisis
        else:
            self.dragonform.charge_gauge(1200, utp=True)
            # 1 hp loss = 1 gauge gain, will assume 3000 max hp here
            if self.hp > 30:
                self.dragonform.charge_gauge(3000 * (self.hp - 30) / 100,
                                             utp=True)
                self.set_hp(30)
            # regular buff duration (?)

    def s_proc(self, e):
        if self.dragondrive_buff.get():
            s = getattr(self, e.name)
            self.dragonform.add_drive_gauge_time(s.ac.getstartup() +
                                                 s.ac.getrecovery(),
                                                 skill_pause=True)
Exemplo n.º 26
0
Arquivo: peony.py Projeto: zzysan/dl
class Peony(Adv):
    comment = 'team skill prep not considered'
    a3 = ('k_paralysis', 0.30)

    conf = peony_conf.copy()
    conf['slots.a'] = Valiant_Crown() + Spirit_of_the_Season()
    conf['acl'] = """
        `dragon, fsc
        `fs, s2.charged>=s2.sp and self.fs_alt.uses > 0
        `s1, x=5
        `s2, cancel
        `s3, cancel
    """
    coab = ['Blade', 'Sharena', 'Malora']
    conf['afflict_res.paralysis'] = 0

    def d_coabs(self):
        if self.duration <= 60:
            self.coab = ['Tiki', 'Sharena', 'Malora']

    def fs_proc_alt(self, e):
        self.fs_str.on()
        self.fs_spd.on()
        Event('defchain')()
        self.a1_is_cd = True
        self.a1_cd_timer.on(20)

    def a1_cd(self, t):
        self.a1_is_cd = False
        if self.a1_charge_defer:
            self.fs_alt.on(1)
            self.a1_charge_defer = False

    def prerun(self):
        self.s1_shift = 0
        conf_fs_alt = {
            'fs.dmg': 0,
            'fs.sp': 0,
            'fs.charge': 30 / 60.0,
            'fs.startup': 20 / 60.0,
            'fs.recovery': 60 / 60.0,
        }
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt), self.fs_proc_alt)
        self.fs_str = Teambuff('fs_str', 0.10, 10, 'att', 'buff')
        self.fs_spd = Spdbuff('fs_spd', 0.10, 10, wide='team')

        self.a1_is_cd = False
        self.a1_charge_defer = False
        self.a1_cd_timer = Timer(self.a1_cd)

    def s1_proc(self, e):
        self.afflics.paralysis('s1', 120, 0.97)
        if self.s1_shift > 0:
            Event('defchain')()
        if self.s1_shift > 1:
            Teambuff('s1_str', 0.10, 10, 'att', 'buff').on()
        self.s1_shift = (self.s1_shift + 1) % 3

    def s2_proc(self, e):
        with KillerModifier('s2_killer', 'hit', 0.2, ['paralysis']):
            self.dmg_make('s2', 9.64)
        Spdbuff('s2_spd', 0.10, 10, wide='team').on()
        Teambuff('s2_str', 0.10, 10, 'att', 'buff').on()

        if self.a1_is_cd:
            self.a1_charge_defer = True
        else:
            self.fs_alt.on(1)
Exemplo n.º 27
0
class Gala_Cleo(Adv):
    comment = '(the true cleo is here)'
    a3 = ('prep', '100%')
    conf = {}
    conf['slot.a'] = CC() + JotS()  # wand c2*1.08 = 217
    conf['slot.d'] = Shinobi()
    conf['acl'] = """
        `s3, pin='prep'
        `fs, s1.charged>=s1.sp and self.fs_alt.uses > 0
        `s2, x=5 or x=4 or fsc or s=3
        `s1, s=2 or fsc
        """

    def d_slots(self):
        if self.slots.c.has_ex('bow'):
            self.slots.a = CC() + Primal_Crisis()

    def fs_proc_alt(self, e):
        if self.a1_buffed:
            buff = Teambuff('a1_str', 0.25, 10)
            buff.bufftime = buff.nobufftime
            buff.on()

    def prerun(self):
        self.a1_buffed = self.condition('always in a1')
        self.s1p = 0

        conf_fs_alt = {
            'fs.dmg': 0,
            'fs.sp': 0,
            'fs.charge': 30 / 60.0,
            'fs.startup': 20 / 60.0,
            'fs.recovery': 60 / 60.0,
        }
        self.fs_alt = Fs_alt(self, Conf(conf_fs_alt), self.fs_proc_alt)

    def s1_dmg(self, t):
        self.dmg_make('s1', 0.88)
        self.hits += 1
        self.dmg_make('s1', 2.65)
        self.hits += 1

    def s1_proc(self, e):
        self.s1p += 1
        if self.s1p > 3:
            self.s1p = 1
        if self.s1p == 1:
            Timer(self.s1_dmg).on((42.0 + 12 * 0) / 60)
            Timer(self.s1_dmg).on((42.0 + 12 * 1) / 60)
            Timer(self.s1_dmg).on((42.0 + 12 * 2) / 60)
        elif self.s1p == 2:
            Timer(self.s1_dmg).on((42.0 + 12 * 0) / 60)
            Timer(self.s1_dmg).on((42.0 + 12 * 1) / 60)
            Timer(self.s1_dmg).on((42.0 + 12 * 2) / 60)
            Timer(self.s1_dmg).on((42.0 + 12 * 3) / 60)
        elif self.s1p == 3:
            Timer(self.s1_dmg).on((42.0 + 12 * 0) / 60)
            Timer(self.s1_dmg).on((42.0 + 12 * 1) / 60)
            Timer(self.s1_dmg).on((42.0 + 12 * 2) / 60)
            Timer(self.s1_dmg).on((42.0 + 12 * 3) / 60)
            Timer(self.s1_dmg).on((42.0 + 12 * 4) / 60)

        self.fs_alt.on()

    def s2_proc(self, e):
        Debuff('s2', 0.10, 20).on()