async def check_win(self):
embeds = []
side1_dead = True
for char in self.side1:
side1_dead = side1_dead and (char.health < 1)
if char.health < 1 and char.alive == True:
embeds.append(bembed.dead(char))
char.alive = False
char.effects = []
side2_dead = True
for char in self.side2:
side2_dead = side2_dead and (char.health < 1)
if char.health < 1 and char.alive == True:
embeds.append(bembed.dead(char))
char.alive = False
char.effects = []
if len(embeds) > 0:
self.message.append(bembed.deadcomp(embeds))
# await self.channel.send(embed=bembed.abicomp(embeds))
if side2_dead == True:
self.end = True
await self.win()
return
if side1_dead == True:
self.end = True
await self.lose()
return
async def player_turn(self, par, msg, player):
if self.end:
return
playeringame = [ing for ing in self.side1 if player.id == ing.id][0]
if self.turn % 2 != 1:
cha = msg.channel
await cha.send('It\'s not your turn')
return
if playeringame.health < 1:
return
if par[0] == 'info':
pass
if par[0] == 'use':
self.message.append('---**Ally Turn**---')
embed = await playeringame.use_ability(self, 1, par, msg)
if embed != None:
self.message.append(bembed.abifinish(embed))
else:
return
# await msg.channel.send(embed=bembed.show(self.side1, self.side2))
self.turn += 1
await self.check_win()
await self.enemy_turn()
if par[0] in ['concede', 'leave', 'l']:
self.message.append('{} gave up.'.format(player.user.mention))
await self.channel.send(embed=bembed.link(self.message))
self.remove_self()
async def win(self):
winners = [char for char in self.side1 if char.isplayer == True]
for winner in winners:
player = core.GET.player(winner.id)
loot = await player.give_item_bulk(self.data['loot'])
self.message.append(bembed.win(self, winners, loot))
await self.channel.send(embed=bembed.link(self.message))
self.remove_self()
def cast_ability(ability, target, attacker):
if isinstance(target, (list,)):
if len(target) > 1:
return '\n'.join([cast_ability(ability, targ, attacker) for targ in target])
else:
target = target[0]
print('{} used {} on {}'.format(attacker.name, ability[0], target.name))
if len([effect for effect, duration in attacker.effects if effect in ef.cripef]) > 0:
return '{0.name} missed their turn.'.format(attacker)
hbefore = target.health
damage = ability[1]['damage'][0] + attacker.stats['strength'] * ability[1]['damage'][1] + attacker.stats['precision'] * ability[1]['damage'][2]
if damage > 0:
damage = round(damage * (100 / (100 + target.stats['defense'])))
else:
damage = round(damage)
magic_damage = ability[1]['magic_damage'][0] + attacker.stats['intelligence'] * ability[1]['magic_damage'][1] + attacker.stats['precision'] * ability[1]['magic_damage'][2]
if magic_damage > 0:
magic_damage = round(magic_damage * (100 / (100 + target.stats['magic_defense'])))
else:
magic_damage = round(magic_damage)
total_damage = damage + magic_damage
if 'random_multiplier' in ability[1]:
total_damage = total_damage * randint(ability[1]['random_multiplier'][0] * 100, ability[1]['random_multiplier'][1] * 100) / 100
if 'crit_chance' in ability[1]:
if randint(1, 100) <= ability[1]['crit_chance'][0] * 100:
total_damage = total_damage * ability[1]['crit_chance'][1]
total_damage = round(total_damage)
target.health -= total_damage
if len(ability[1]['effects']) > 0:
for full_effect in ability[1]['effects']:
effect = full_effect[0]
duration = full_effect[1]
if len(full_effect) > 2:
if randint(1, 100) > full_effect[2] * 100:
continue
print('added {} {} for to {}'.format(effect, duration, target.name))
if not ef.has_effect(effect, target):
target.effects.append([effect, duration])
ef.start(effect, target)
else:
to_longer = ef.get_effect(effect, target)
effect_index = target.effects.index(to_longer)
print('original dur: {} new dur: {}'.format(to_longer[1], duration))
to_longer[1] = max(to_longer[1], int(duration))
print('new dur {}'.format(to_longer[1]))
target.effects[effect_index][1] = to_longer[1]
print(target.effects)
return bembed.abipart(ability, target, attacker, total_damage, hbefore)
async def wait_for_player(self, cha):
if self.end:
return
await cha.send(embed=bembed.player_turn(self.side1[0], self.side1,
self.side2, self.message))
turn = self.turn
await asyncio.sleep(120)
if turn == self.turn:
await cha.send('timed out')
self.remove_self()
async def enemy_turn(self):
self.message.append('---**Enemy Turn**---')
if self.end:
return
embeds = []
for enemy in self.side2:
if enemy.alive:
text = await enemy.turn(self)
embeds.append(text)
asyncio.wait(1)
self.message.append(bembed.abicomp(embeds))
self.turn += 1
self.update_effects(self.side1)
self.update_effects(self.side2)
await self.check_win()
self.update()
await self.wait_for_player(self.channel)
async def lose(self):
self.message.append(bembed.lose(self))
await self.channel.send(embed=bembed.link(self.message))
self.remove_self()