async def use(self):
"""
`coroutine`
Add a stack to all active acid debuff on the enemy team.
--
Return : str
"""
# init
move = Move_displayer()
effect_checker = Effect_checker(self.caster)
has_unity = False
acid_ref = await effect_checker.get_effect(1, self.client, self.ctx,
self.caster, self.team_a,
self.team_b)
unity_ref = await effect_checker.get_effect(2, self.client, self.ctx,
self.caster, self.team_a,
self.team_b)
# check if there is a unity buff in the team a
for ally in self.team_a:
await asyncio.sleep(0)
unity_checker = Effect_checker(ally)
unity = await unity_checker.get_buff(unity_ref)
if (unity != None):
has_unity = True
break
# now increase the stack of acids
for enemy in self.team_b:
await asyncio.sleep(0)
acid_checker = Effect_checker(enemy)
acid = await acid_checker.get_debuff(acid_ref)
if (acid != None):
await acid.add_stack()
# set up the move display
_move = await move.get_new_move()
_move["name"] = self.name
_move["icon"] = self.icon
_move["ki"] = True
_move = await move.effect_move(_move)
return (_move)
async def apply(self):
"""
`coroutine`
Add the two stacks to the carrier.
--
Return : None
"""
# init
if not self.triggered:
effect_checker = Effect_checker(self.carrier)
triple_ref = await effect_checker.get_effect(
6, self.client, self.ctx, self.carrier, self.team_a,
self.team_b)
# check if the target already has the buff
has_triple = await effect_checker.get_buff(triple_ref)
if (has_triple != None):
# add 2 stacks
has_triple.stack += 2
else: # doesn't have triple
triple_ref.stack = 2
self.carrier.bonus.append(triple_ref)
self.triggered = True
return
async def apply(self):
"""
`coroutine`
Applies a buff that makes the carrier gain 5 % of its allied Saibaiman ki power.
--
Return : None
"""
# init
effect_checker = Effect_checker(self.carrier)
gather_ref = await effect_checker.get_effect(
7,
self.client,
self.ctx,
self.carrier,
self.team_a,
self.team_b
)
# check if the target has the buff
has_gather = await effect_checker.get_buff(gather_ref)
if(has_gather != None): # pass, don't re add the buff
pass
else: # add the buff
self.carrier.bonus.append(gather_ref)
return
async def on_remove(self):
"""
Reset all the acid effects. (Duration and max stacks)
"""
# now retrieve all the acid effects
# team b because we reset the effect in the enemy team
for character in self.team_b:
await asyncio.sleep(0)
# init the checker
checker = Effect_checker(character)
acid_ref = await checker.get_effect(1, self.client, self.ctx,
character, self.team_a,
self.team_b)
acid_active = await checker.get_debuff(acid_ref)
# now reset
if (acid_active != None):
# duration
acid_active.initial_duration = acid_ref.initial_duration
if (acid_active.duration > acid_ref.initial_duration):
acid_active.duration = acid_ref.initial_duration
# stack
acid_active.max_stack = acid_ref.max_stack
if (acid_active.stack > acid_ref.max_stack):
acid_active.stack = acid_ref.max_stack
return
async def apply(self):
"""
Applies 2 stacks of acid on the enemy team.
"""
for enemy in self.team_b:
await asyncio.sleep(0)
effect_checker = Effect_checker(enemy)
acid_ref = await effect_checker.get_effect(1, self.client,
self.ctx, enemy,
self.team_a,
self.team_b)
# check if the target has acid
has_acid = await effect_checker.get_debuff(acid_ref)
if (has_acid !=
None): # add 2 stack of acid to the current acid effect
await has_acid.add_stack()
await has_acid.add_stack()
else:
await acid_ref.add_stack()
await acid_ref.add_stack()
return
async def apply(self):
"""
`coroutine`
Reduces the carrier's spirit amount by 2 %.
--
Return : None
"""
# init
effect_checker = Effect_checker(self.carrier)
reduction = int(0.02 * self.carrier.defense.spirit) # get 2 % of the carrier's spirit
acid_ref = await effect_checker.get_effect(
1,
self.client,
self.ctx,
self.carrier,
self.team_a,
self.team_b
)
carrier_acid = await effect_checker.get_debuff(acid_ref)
if(carrier_acid != None):
reduction = int(reduction * carrier_acid.stack)
# reduce the spirit of the carrier
self.carrier.defense.spirit -= reduction
return
async def apply(self):
"""
`coroutine`
Add the Red Saibaiman's passive to all the allied Saibaiman.
--
Return : None
"""
# init
effect_checker = Effect_checker(self.carrier)
passive_ref = await effect_checker.get_effect(
10,
self.client,
self.ctx,
self.carrier,
self.team_a,
self.team_b
)
# add the passive to all the allied saibaiman
for ally in self.team_a:
await asyncio.sleep(0)
if ally.info.id in self.saibaiman_list:
effect_checker = Effect_checker(ally)
has_power = await effect_checker.get_buff(passive_ref)
if(has_power == None):
new_power = await effect_checker.get_effect(
10,
self.client,
self.ctx,
ally,
self.team_a,
self.team_b
)
ally.bonus.append(new_power)
return
async def apply(self):
"""
`coroutine`
Heals up the carrier for each acid stacks active on the enemy team.
--
Return : None
"""
# init
checker = Effect_checker(None)
acid_stacks = 0
# we don't need to pass the target as we just want to get the acid.id (None)
acid = await checker.get_effect(1, self.client, self.ctx, self.carrier,
self.team_a, self.team_b)
# check the enemy team
for character in self.team_b:
await asyncio.sleep(0)
# check if the target has the acid effect on it
checker = Effect_checker(character)
_acid = await checker.get_debuff(acid)
if (_acid != None):
# count the stacks
acid_stacks += _acid.stack
# improve the debuff
_acid.max_stack = 5
_acid.initial_duration = 5
# now heal the carrier
if (acid_stacks > 0):
heal = int(acid_stacks * (0.1 * self.carrier.damage.ki_max))
self.carrier.health.current += heal
await self.carrier.health.health_limit()
return
async def use(self):
"""
`coroutine`
Inflicts damage and applies a dot to the target.
--
Return : str
"""
# init
await self.caster.posture.change_posture("attacking")
move = Move_displayer()
calculator = Damage_calculator(self.caster, self.target)
checker = Effect_checker(self.target)
# get the damage
damage = randint(self.caster.damage.ki_min, self.caster.damage.ki_max)
damage = int(damage *
0.25) # the ability inflicts only 25 % of the ki damage
damage = await calculator.ki_damage(damage,
critable=True,
dodgable=True)
# define move info
_move = await move.get_new_move()
_move["name"] = self.name
_move["icon"] = self.icon
_move["damage"] = damage["calculated"]
_move["critical"] = damage["critical"]
_move["dodge"] = damage["dodge"]
_move["ki"] = True
_move = await move.offensive_move(_move)
# inflict damage
await self.target.receive_damage(damage["calculated"])
# add a stack of acid on the target
_acid = Dot_acid(self.client, self.ctx, self.target, self.team_a,
self.team_b)
await _acid.add_stack()
return (_move)
async def use(self):
"""
`coroutine`
Applies the Unity is strenght buff on all the allied Saibaimen.
--
Return : str
"""
# init
await self.caster.posture.change_posture("attacking")
move = Move_displayer()
# applies the buff on the team
for character in self.team_a:
await asyncio.sleep(0)
# init
checker = Effect_checker(character)
unity_buff = await checker.get_effect(2, self.client, self.ctx,
character, self.team_a,
self.team_b)
ally_buff = None # check if the ally already has the Unity is strenght active
character.bonus.append(unity_buff)
if character.info.id in self.saibaimen:
# if the ally is a saibaimen
# applies the buff
ally_buff = await checker.get_buff(unity_buff)
if (ally_buff !=
None): # if the ally has the buff, reset duration
ally_buff.duration = unity_buff.initial_duration
else: # otherwise, add the buff
character.bonus.append(unity_buff)
# setup the move display
display = await move.get_new_move()
display["name"] = self.name
display["icon"] = self.icon
display["ki"] = True
display = await move.effect_move(display)
return (display)
async def use(self):
"""
`coroutine`
Applies the Pilaf Barrier buff on the caster.
--
Return : str
"""
# init
# change the posture
move = Move_displayer()
_move = await move.get_new_move()
effect_checker = Effect_checker(self.caster)
barrier_ref = await effect_checker.get_effect(
5,
self.client,
self.ctx,
self.caster,
self.team_a,
self.team_b
)
await self.caster.posture.change_posture("defending")
# first check if the target (caster) already have the buff active
has_barrier = await effect_checker.get_buff(barrier_ref)
if(has_barrier != None):
# just reset the duration
has_barrier.duration = has_barrier.initial_duration
else: # if the target doesn't have the buff
self.caster.bonus.append(barrier_ref)
# set cooldown
self.cooldown = 3
# define the move
_move["name"] = self.name
_move["icon"] = self.icon
_move = await move.effect_move(_move)
return(_move)
async def use(self):
"""
`coroutine`
Consums one stack of Triple pilots to recover health
--
Return : str
"""
# init
move = Move_displayer()
heal = 0
effect_checker = Effect_checker(self.caster)
triple_ref = await effect_checker.get_effect(6, self.client, self.ctx,
self.caster, self.team_a,
self.team_b)
# check if the caster has the triple pilots buff
has_triple = await effect_checker.get_buff(triple_ref)
if (has_triple != None):
if (has_triple.stack > 0):
# consum a stack
has_triple.stack -= 1
# restore health
heal = int((30 * self.caster.health.maximum) / 100)
self.caster.health.current += heal
await self.caster.health.health_limit()
if (has_triple.stack <=
0): # the caster doesn't have triple pilots stacks anymore
self.caster.bonus.remove(has_triple)
# set up the move
_move = await move.get_new_move()
_move["name"], _move["icon"] = self.name, self.icon
_move = await move.effect_move(_move)
if (heal > 0):
_move += f"__Heal__ : **+{heal:,}** :hearts:"
return (_move)
async def apply(self):
"""
Applies the Power charge bonus to the carrier
"""
# init
effect_checker = Effect_checker(self.carrier)
power_ref = await effect_checker.get_effect(10, self.client, self.ctx,
self.carrier, self.team_a,
self.team_b)
# check if the target already has the bonus
has_power = await effect_checker.get_buff(power_ref)
if (has_power == None): # doesn't has the buff, add it
self.carrier.bonus.append(power_ref)
return
async def use(self):
"""
`coroutine`
Performs a sequence attack against any enemy
--
Return : str
"""
# init
await self.caster.posture.change_posture("attacking")
move = Move_displayer()
calculator = Damage_calculator(self.caster, self.target)
checker = Effect_checker(self.target)
# get the damage
damage = randint(self.caster.damage.physical_min, self.caster.damage.physical_max)
damage = await calculator.physical_damage(
damage,
critable = True,
dodgable = True
)
# define move info
_move = await move.get_new_move()
_move["name"] = self.name
_move["icon"] = self.icon
_move["damage"] = damage["calculated"]
_move["critical"] = damage["critical"]
_move["dodge"] = damage["dodge"]
_move["physical"] = True
_move = await move.offensive_move(_move)
# inflict damage
await self.target.receive_damage(damage["calculated"])
return(_move)
async def apply(self):
"""
Add on_death bonus.
"""
effect_checker = Effect_checker(self.carrier)
last_will_ref = await effect_checker.get_effect(
8, self.client, self.ctx, self.carrier, self.team_a, self.team_b)
# check if the carrier has the buff or not
has_last_will = False
for on_death in self.carrier.on_death:
await asyncio.sleep(0)
if (on_death.id == last_will_ref.id):
has_last_will = True
if not has_last_will: # if the target doesn't have last will
self.carrier.on_death.append(last_will_ref)
self.triggered = True
return
async def use(self):
"""
`coroutine`
See class description.
--
Return : str
"""
# init
move = Move_displayer()
effect_checker = Effect_checker(self.target)
damager = Damage_calculator(self.caster, self.target)
missing_health = self.target.health.maximum - self.target.health.current
roll_damage = randint(self.caster.damage.ki_min, self.caster.damage.ki_max)
damage_done = await damager.ki_damage(
roll_damage,
dodgable = True,
critable = True
)
# init the damage done
damage_done["calculated"] = int(damage_done["calculated"] * 0.1)
# special effect
if not damage_done["dodge"]: # if the damage has not been dodged
# check if the target has acid stack active on it
acid = await effect_checker.get_effect(
1,
self.client,
self.ctx,
self.target,
self.team_a,
self.team_b
)
has_acid = await effect_checker.get_debuff(acid)
if(has_acid != None):
damage_done["calculated"] += int(((2 * missing_health)/100) * has_acid.stack)
# remove the acid debuff to the target
# consums it
self.target.malus.remove(has_acid)
else: # doesn't have acid active on it
pass
# deal damage to the target
await self.target.receive_damage(damage_done["calculated"])
# heal the caster
# of 50 % of damage done
healing = int(damage_done["calculated"] / 2)
self.caster.health.current += healing
await self.caster.health.health_limit()
# setting up the move
_move = await move.get_new_move()
_move["name"] = self.name
_move["icon"] = self.icon
_move["damage"] = damage_done["calculated"]
_move["critical"] = damage_done["critical"]
_move["dodge"] = damage_done["dodge"]
_move["ki"] = True
_move = await move.offensive_move(_move)
# healing display
if(healing > 0):
_move += f"__Heal__ : +**{healing}** :hearts:\n"
return(_move)
async def use(self):
"""
`coroutine`
Applies the Paralyzing debuff on the target.
If the target already has the debuff : reset the duration
--
Return : str
"""
# init
effect_checker = Effect_checker(self.target)
move = Move_displayer()
_move = ""
has_paralyzing = None
has_acid = None
# effect reference
acid_ref = await effect_checker.get_effect(1, self.client, self.ctx,
self.target, self.team_a,
self.team_b)
paralyzing_ref = await effect_checker.get_effect(
4, self.client, self.ctx, self.target, self.team_a, self.team_b)
# set up the move
_move = await move.get_new_move()
_move["name"] = self.name
_move["icon"] = self.icon
_move["ki"] = True
_move = await move.effect_move(_move)
# check if the target has acid stack active
has_acid = await effect_checker.get_debuff(acid_ref)
if (has_acid != None):
# get the amount of acid's stack the target has
acid_stack = has_acid.stack
# check if the target has 3 or more active stacks
if (acid_stack >= 3):
# check if the target has an active paralyzing burns
has_paralyzing = await effect_checker.get_debuff(paralyzing_ref
)
if (has_paralyzing != None):
# reset the duration
if (acid_stack == 3):
has_paralyzing.initial_duration = 2
has_paralyzing.duration = has_paralyzing.initial_duration
elif (acid_stack > 3):
has_paralyzing.initial_duration = 4
has_paralyzing.duration = has_paralyzing.initial_duration
else: # the target doesn't have paralyzing burns active on it
# set the duration of the stun
if (acid_stack == 3):
paralyzing_ref.initial_duration = 2
paralyzing_ref.duration = paralyzing_ref.initial_duration
elif (acid_stack > 3):
paralyzing_ref.initial_duration = 4
paralyzing_ref.duration = paralyzing_ref.initial_duration
# apply the debuff on the target
self.target.malus.append(paralyzing_ref)
# consums all the acid stacks
self.target.malus.remove(has_acid)
else: # the target has less that 3 acid stacks
pass
else:
# the target doesn't have acid stack, don't do nothing
pass
return (_move)
async def add_stack(self):
# init
checker = Effect_checker(self.target)
unity = False
_acid = await checker.get_effect(1, self.client, self.ctx, self.target,
self.team_a, self.team_b)
# check if the target already has acid on it
has_acid = await checker.get_debuff(self)
# look for someone in the team_a who has the unity is strength buff
for ally in self.team_a:
await asyncio.sleep(0)
# get the character
checker = Effect_checker(ally)
unity_buff = await checker.get_effect(2, self.client, self.ctx,
ally, self.team_a,
self.team_b)
if (ally != None):
if ally.info.id in self.saibaiman_id:
_unity = await checker.get_buff(unity_buff)
if (_unity != None): # if someone has the buff active
unity = True
break
# increase acid stack
# get existing acid stack
if (has_acid != None): # if the target already has the effect on it
_acid = has_acid
self.target.malus.remove(_acid)
# increase only if the max stack hasn't been reached
if (_acid.stack < _acid.max_stack):
if (unity): # if an ally has the unity buff
_acid.stack += 2
if (_acid.stack > _acid.max_stack):
_acid.stack = _acid.max_stack
_acid.duration = _acid.initial_duration
else: # if no unity in the team
_acid.stack += 1
_acid.duration = _acid.initial_duration
_acid.duration = _acid.initial_duration
# add or re-add the malus
self.target.malus.append(_acid)
else: # if the target doesn't have acid on it
if (unity):
_acid.stack = 2
_acid.initial_duration = 5
await _acid.set_damage()
else:
_acid.stack = 1
await _acid.set_damage()
# add or re-add the malus
self.target.malus.append(_acid)
return
async def use(self):
"""
`coroutine`
Inflicts 50 % of the caster's ki damage to the target.
If the target has at least 3 stacks of acid, splashes it onto all of the target's team members.
Applies the Acid explosion debuff that increases the ki damages that they take by 2 %.
--
Return : str
"""
# init
move = Move_displayer()
effect_checker = Effect_checker(self.target)
damage_calculator = Damage_calculator(self.caster, self.target)
# debuff
acid_ref = await effect_checker.get_effect(1, self.client, self.ctx,
self.target, self.team_a,
self.team_b)
explosion_ref = await effect_checker.get_effect(
3, self.client, self.ctx, self.target, self.team_a, self.team_b)
# set the damage
damage = randint(self.caster.damage.ki_min, self.caster.damage.ki_max)
damage /= 2 # 50 % of the ki damage
damage = await damage_calculator.ki_damage(damage, critable=True)
# check if the target has acid
has_acid = await effect_checker.get_debuff(acid_ref)
if (has_acid != None): # the target has an acid dot active on it
# now check if the target has at least 3 stacks of acid
if (has_acid.stack >= 3):
# spread the dot onto the enemy members
for unit in self.team_b:
await asyncio.sleep(0)
# init
effect_checker = Effect_checker(unit)
# check if the unit has acid stack
unit_has_acid = await effect_checker.get_debuff(acid_ref)
if (unit_has_acid != None):
await unit_has_acid.add_stack()
unit_has_acid.duration = unit_has_acid.initial_duration
else: # the unit doesn't have acid active on it
# create a new acid instance for the target
unit_acid = await effect_checker.get_effect(
1, self.client, self.ctx, unit, self.team_a,
self.team_b)
# applies the new acid instance
await unit_acid.add_stack()
# now check if the target already have explosion debuff active
has_explosion = await effect_checker.get_debuff(explosion_ref)
if (has_explosion != None):
# reset the duration
has_explosion.duration = has_explosion.initial_duration
else:
self.target.malus.append(explosion_ref)
# setting up the move display
_move = await move.get_new_move()
_move["name"] = self.name
_move["icon"] = self.icon
_move["damage"] = damage["calculated"]
_move["critical"] = damage["critical"]
_move["dodge"] = damage["dodge"]
_move["ki"] = True
_move = await move.offensive_move(_move)
return (_move)
