def base(self, message):
"""
Base state
Adventure starts from here
Inventory, status, shop
"""
if message not in self.get_state_input(): # standard check for right input
self.enqueue_message('Please input correct command',
self._chat_id, self._player_id)
self.enqueue_message(DialogMessage(
'base').get_message(), self._chat_id, self._player_id)
else:
if message == 'S':
self.send_stats(self.playerchar)
self.enqueue_message(DialogMessage(
'base').get_message(), self._chat_id, self._player_id)
elif message == 'I':
self.send_inventory(self.playerchar)
self.enqueue_message(DialogMessage(
'base').get_message(), self._chat_id, self._player_id)
elif message == 'Y':
self.create_battle()
self.set_state('Battle Choice')
elif message == 'B':
self.enqueue_message(StatusMessage(
self.playerchar).shop_message(), self._chat_id, self._player_id)
self.set_state('Shop')
def check_enemy(self, enemy):
"""
Sending message about the enemy
"""
enemy_char = enemy['Enemy']
enemy_type = enemy['Type']
message_list = {
'Normal':
DialogMessage('see_enemy_C', {
'char': enemy_char.get_class()
}).get_message(),
'Boss':
'You approach the boss of this act:'
}
self.enqueue_message(message_list[enemy_type], self._chat_id,
self._player_id, self._keyboard)
self.send_stats(enemy_char)
if enemy_char.get_summons():
self.enqueue_message("Enemy summons:", self._chat_id,
self._player_id, self._keyboard)
for summon in enemy_char.get_summons():
self.send_stats(summon)
self.enqueue_message(
DialogMessage('attack_enemy').get_message(), self._chat_id,
self._player_id, self._keyboard) # prompting to attack
def battle_choice(self, message=None):
"""
Battle battle_choice part
Fight or flight, battle() or base()
"""
if message is None: # Creating the enemy list first time
self.enemies = self.create_enemy_list(
self.playerchar.get_lvl()) # creating enemy
for target in self.enemies: # sending info for all enemies
self.enqueue_message(DialogMessage(
'see_enemy_C', target).get_message(), self._chat_id, self._player_id)
self.send_stats(target)
self.enqueue_message(DialogMessage('attack_enemy').get_message(
), self._chat_id, self._player_id) # prompting to attack
elif message not in ['Y', 'N']: # standard check for right input
self.enqueue_message('Please input correct command',
self._chat_id, self._player_id)
self.enqueue_message(DialogMessage(
'attack_enemy').get_message(), self._chat_id, self._player_id)
else:
if message == 'Y':
self.set_state('Battle')
self.battle()
elif message == 'N':
self.set_state('Base')
self.enqueue_message("You've lost half of your gold, while running away", self._chat_id, self._player_id)
self.playerchar.set_gold(self.playerchar.get_gold()/2)
self.enqueue_message(DialogMessage('base').get_message(), self._chat_id, self._player_id)
def use_skill(self, damage, attacker):
"""
Takes other character's attack and reduces self es or/and hp by it
Prints message about that attack
"""
if damage < self.get_es():
self._es -= damage
return DialogMessage(
'attack_es_CAT', {
'char': attacker,
'amount': damage,
'target': self.get_owner_stats()['CLS']
}).get_message() + "\n"
else:
if self.get_es() == damage:
self._es = 0
return DialogMessage('attack_es_CAT', {'char': attacker, 'amount': damage,
'target': self.get_owner_stats()['CLS']}).get_message() + "\n" + \
DialogMessage('broke_es_C', {'char': self.get_owner_stats()['CLS']}).get_message() + "\n"
else:
self._leftoverdamage = damage - self.get_es()
es_damage = self.get_es()
self._es = 0
return DialogMessage('attack_es_CAT', {'char': attacker, 'amount': es_damage,
'target': self.get_owner_stats()['CLS']}).get_message() + "\n" + \
DialogMessage('broke_es_C', {'char': self.get_owner_stats()['CLS']}).get_message() + "\n"
def item_choice(self, message):
"""
Player enemy_choice of equipping the item
None is a dirty hack and I am not proud
"""
if message not in self.get_state_input():
self.enqueue_message('Please input correct command', self._chat_id,
self._player_id)
self.enqueue_message(
self.item.get_stats() + "\n" +
DialogMessage('equip_item').get_message(), self._chat_id,
self._player_id, self._keyboard)
else:
if message == 'Equip': # adds item to playerchar inventory
self.playerchar.add_item(self.item)
self.item = None
self.send_inventory(self.playerchar)
self.send_stats(self.playerchar)
if self.item_drop != []:
self.process_drop()
else:
self.set_state('Base')
self.enqueue_message(
DialogMessage('base').get_message(), self._chat_id,
self._player_id, self._keyboard)
def enemy_choice(self, message):
"""
Battle enemy_choice part
Fight or flight, battle() or base()
"""
if message not in self.get_state_input(
): # standard check for right input
self.enqueue_message('Please input correct command', self._chat_id,
self._player_id)
self.enqueue_message(
DialogMessage('attack_enemy').get_message(), self._chat_id,
self._player_id, self._keyboard)
else:
if message == 'Attack':
self.set_state('Battle')
self.battle(self._enemy)
elif message == 'Retreat':
self.set_state('Base')
self.enqueue_message(
"You've lost half of your gold, while running away",
self._chat_id, self._player_id, self._keyboard)
self.playerchar.set_gold(self.playerchar.get_gold() / 2)
self.enqueue_message(
DialogMessage('base').get_message(), self._chat_id,
self._player_id, self._keyboard)
def create_battle(self):
"""Creating the enemy list first time"""
self.enemies = self.create_enemy_list(self.playerchar.get_lvl()) # creating enemy
for target in self.enemies: # sending info for all enemies
self.enqueue_message(DialogMessage(
'see_enemy_C', target).get_message(), self._chat_id, self._player_id)
self.send_stats(target)
self.enqueue_message(DialogMessage('attack_enemy').get_message(
), self._chat_id, self._player_id) # prompting to attack
def battle(self, enemy):
"""
Battle part
If character is not dead, leads to won_battle()
"""
battle_log = "" # creating battle log
enemy_char = enemy['Enemy']
player_chars = [self.playerchar] + self.playerchar.get_summons()
enemies = [enemy_char] + enemy_char.get_summons()
while self.playerchar.is_alive():
for char in player_chars:
if char.is_alive():
battle_log += char.attack(enemy_char)
if not enemy_char.is_alive():
battle_log += DialogMessage('won_C', {
'char': self.playerchar.get_class()
}).get_message()
self.enqueue_message(battle_log, self._chat_id,
self._player_id, self._keyboard)
for skill in self.playerchar.get_attack_skills():
skill.set_current_cd(0)
self.won_battle(enemy)
if enemy['Type'] == 'Boss':
self._act += 1
self._boss = None
elif enemy['Type'] == 'Normal':
self._enemy = None
break
for char in enemies:
if char.is_alive():
battle_log += char.attack(self.playerchar)
if not self.playerchar.is_alive():
battle_log += DialogMessage('won_C', {
'char': enemy_char.get_class()
}).get_message() + '\n'
battle_log += DialogMessage('dead').get_message() + '\n'
battle_log += DialogMessage('end_game').get_message() + '\n'
self.enqueue_message(battle_log, self._chat_id,
self._player_id, self._keyboard)
# user_list.pop(self._player_id['id']) # deleting user character
self._enemy = self._boss = None
self._act = 1
print(
f"Game ended for {self._chat_id, self._player_id} by {enemy_char.get_class(), self.playerchar.get_lvl()}"
)
# this needs to be reworked
self.set_state('Game Start')
self.enqueue_message('Ready Player One', self._chat_id,
self._player_id, self._keyboard)
self.enqueue_message(
DialogMessage('start_game').get_message(), self._chat_id,
self._player_id, self._keyboard)
break
def battle(self):
"""
Battle part
If character is not dead, leads to won_battle()
"""
battle_log = "" # creating battle log
while self.playerchar.is_alive():
for skill in self.playerchar.get_skills():
skill.set_current_cd(skill.get_current_cd() - 1)
if self.playerchar.is_skill_available():
skill = self.playerchar.first_available_skill()
battle_log += self.playerchar.use_attack_skill(
skill, next(enemy for enemy in self.enemies if enemy.is_alive()))
skill.set_current_cd(skill.get_cooldown_timer())
else:
battle_log += self.playerchar.attack(
next(enemy for enemy in self.enemies if enemy.is_alive()))
for enemy in self.enemies:
if enemy.is_alive():
battle_log += enemy.attack(self.playerchar)
if not self.playerchar.is_alive():
battle_log += DialogMessage('won_C',
enemy).get_message()
self.enqueue_message(
battle_log, self._chat_id, self._player_id)
self.enqueue_message(DialogMessage(
'dead').get_message(), self._chat_id, self._player_id)
# user_list.pop(self._player_id['id']) # deleting user character
self.enqueue_message(DialogMessage(
'end_game').get_message(), self._chat_id, self._player_id)
# this needs to be reworked
self.enqueue_message(
'Ready Player One', self._chat_id, self._player_id)
self.enqueue_message(DialogMessage(
'start_game').get_message(), self._chat_id, self._player_id)
self.set_state('Game Start')
# this needs to be reworked
break
if all(not enemy.is_alive() for enemy in self.enemies):
battle_log += DialogMessage('won_C',
self.playerchar).get_message()
self.enqueue_message(
battle_log, self._chat_id, self._player_id)
self.set_state('Battle Won')
self.won_battle(self.enemies)
for skill in self.playerchar.get_skills():
skill.set_current_cd(0)
self.enemies = [] # deleting enemies
break
def base(self, message):
"""
Base state
Adventure starts from here
Inventory, status, shop
"""
# 1 act -- GreaterMonster (Monster)
# 2 act -- ChampionMonster (Monster, GreaterMonster)
# 3 act -- Summoner (GreaterMonster, ChampionMonster)
# 4 act -- DarkShadow (ChampionMonster, Summoner)
if self._boss is None:
self.create_boss(self._act)
if self._enemy is None:
self.create_enemy(self._act)
if message not in self.get_state_input(
): # standard check for right input
self.enqueue_message('Please input correct command', self._chat_id,
self._player_id, self._keyboard)
self.enqueue_message(
DialogMessage('base').get_message(), self._chat_id,
self._player_id, self._keyboard)
else:
if message == 'Stats':
self.send_stats(self.playerchar)
self.enqueue_message(
DialogMessage('base').get_message(), self._chat_id,
self._player_id, self._keyboard)
elif message == 'Inventory':
self.send_inventory(self.playerchar)
self.enqueue_message(
DialogMessage('base').get_message(), self._chat_id,
self._player_id, self._keyboard)
elif message == 'Skills':
self.send_skills(self.playerchar)
self.enqueue_message(
DialogMessage('base').get_message(), self._chat_id,
self._player_id, self._keyboard)
elif message == 'Check Boss':
self.set_state('Boss Choice')
self.check_enemy(self._boss)
elif message == 'Find Monsters':
self.set_state('Enemy Choice')
self.check_enemy(self._enemy)
elif message == 'Shop':
self.set_state('Shop')
self.enqueue_message(
StatusMessage(self.playerchar).shop_message(),
self._chat_id, self._player_id, self._keyboard)
def take_damage_pure(self, damage, other):
"""
Takes pure damage from skills
"""
self._hp -= damage
return DialogMessage('attack_pure_CAT', other, damage,
self).get_message() + "\n"
def start_new_game(self, chat_id, player_id):
"""Starts a new game, and returns appropriate messages"""
self.user_list[player_id] = Game(chat_id, player_id)
return [OutMessage(
'Ready Player One', chat_id, player_id),
OutMessage(DialogMessage(
'start_game').get_message(), chat_id, player_id)]
def process_drop(self):
"""
Processing all the drops, and prompting to choose equip item or not
"""
self.item = self.item_drop[0]
self.enqueue_message(DialogMessage('found_item_I', self.item).get_message(
) + "\n" + self.item.get_stats(), self._chat_id, self._player_id)
if self.playerchar.get_inventory()[self.item.get_type()]:
playeritem = self.playerchar.get_inventory()[self.item.get_type()]
self.enqueue_message(
f"Comparing to your *{playeritem.get_full_name()}*:", self._chat_id, self._player_id)
self.enqueue_message(self.item.get_compare_stats(
playeritem), self._chat_id, self._player_id)
self.enqueue_message(DialogMessage(
'equip_item').get_message(), self._chat_id, self._player_id)
self.item_drop.pop(0) # deleting first available item
def shop(self, message=None):
"""
Shop part
"""
if message not in self.get_state_input(): # standard check for right input
self.enqueue_message('Please input correct command', self._chat_id, self._player_id)
self.enqueue_message(StatusMessage(self.playerchar).shop_message(), self._chat_id, self._player_id)
elif message != 'E':
if message == 'HP':
hp = int(self.playerchar.get_maxhp() -
self.playerchar.get_current_hp())
if self.playerchar.get_gold() >= hp:
self.playerchar.set_gold(self.playerchar.get_gold() - hp)
self.playerchar.set_hp(self.playerchar.get_maxhp())
self.enqueue_message(
'HP restored', self._chat_id, self._player_id)
self.send_stats(self.playerchar)
else:
self.enqueue_message('Not enough gold', self._chat_id, self._player_id)
if message == 'SP':
if self.playerchar.get_gold() >= 10:
self.playerchar.set_gold(self.playerchar.get_gold() - 10)
self.playerchar.set_hp(self.playerchar.get_current_hp() + 10)
self.enqueue_message(
'HP restored', self._chat_id, self._player_id)
self.send_stats(self.playerchar)
else:
self.enqueue_message('Not enough gold', self._chat_id, self._player_id)
if message == 'MP':
if self.playerchar.get_gold() >= 100:
self.playerchar.set_gold(self.playerchar.get_gold() - 100)
self.playerchar.set_hp(self.playerchar.get_current_hp() + 100)
self.enqueue_message(
'HP restored', self._chat_id, self._player_id)
self.send_stats(self.playerchar)
else:
self.enqueue_message('Not enough gold', self._chat_id, self._player_id)
if message == 'A':
if self.playerchar.get_gold() >= 1000:
self.playerchar.set_gold(self.playerchar.get_gold() - 1000)
self.playerchar.set_attack(self.playerchar._attack + 10)
self.enqueue_message(
'Attack Boosted', self._chat_id, self._player_id)
self.send_stats(self.playerchar)
else:
self.enqueue_message(
'Not enough gold', self._chat_id, self._player_id)
if message == 'M':
if self.playerchar.get_gold() >= 1000:
self.playerchar.set_gold(self.playerchar.get_gold() - 1000)
self.enqueue_message(
'MP Boosted', self._chat_id, self._player_id)
self.send_stats(self.playerchar)
else:
self.enqueue_message(
'Not enough gold', self._chat_id, self._player_id)
self.enqueue_message(StatusMessage(self.playerchar).shop_message(), self._chat_id, self._player_id)
else:
self.set_state('Base')
self.enqueue_message(DialogMessage('base').get_message(), self._chat_id, self._player_id)
def game_start(self, message):
"""
Character selection state
Intended for single use
"""
if message not in self.get_state_input(): # standard check for right input
self.enqueue_message(
'Please input correct class name', self._chat_id, self._player_id)
self.enqueue_message(DialogMessage(
'start_game').get_message(), self._chat_id, self._player_id)
else:
# creating player character
self.playerchar = eval("{}()".format(message))
self.send_stats(self.playerchar)
self.set_state('Base')
self.enqueue_message(DialogMessage(
'base').get_message(), self._chat_id, self._player_id)
def take_damage_from(self, damage, other):
"""
Takes damage from other character
Prints message about that attack
"""
self._hp -= damage * self.get_defence_modifier()
return DialogMessage('attack_CAT', other,
damage * self.get_defence_modifier(),
self).get_message() + "\n"
def generate_replays(self, update):
messages_to_send = []
try:
for msg in update:
new_message = Message(msg['message'])
if new_message.get_type() != 'text':
pass
else:
player_game = None
player_id = new_message.get_user_id()
chat_id = new_message.get_chat_id()
content = new_message.get_content()
if player_id['id'] not in self.user_list.keys() and content == '/start':
print(
f"Player: {player_id}, Chat: {chat_id}, Content: {content}")
messages_to_send.append(OutMessage(
'Ready Player One', chat_id, player_id))
messages_to_send.append(OutMessage(DialogMessage(
'start_game').get_message(), chat_id, player_id))
player_game = Game(chat_id, player_id)
self.user_list[player_id['id']] = player_game
elif player_id['id'] in self.user_list:
if new_message.get_content() == '/restart':
print(
f"Player: {player_id}, Chat: {chat_id}, Content: {content}")
self.user_list.pop(player_id['id'])
messages_to_send.append(OutMessage(
'Game reset', chat_id, player_id))
else:
player_game = self.user_list[player_id['id']]
game_state = player_game.check_state()
print(
f"Player: {player_id}, Chat: {chat_id}, Content: {content}, Game State: {game_state}")
if game_state == 'Game Start':
player_game.game_start(content)
elif game_state == 'Base':
player_game.base(content)
elif game_state == 'Battle Choice':
player_game.battle_choice(content)
elif game_state == 'Item Choice':
player_game.item_choice(
content)
elif game_state == 'Shop':
player_game.shop(content)
messages_to_send += player_game.send_all_messages()
else:
messages_to_send.append(OutMessage(
'Type /start to enter the game', chat_id, player_id))
# if player_game:
# self.redis.save_game(chat_id, player_game)
return self.merge_messages(messages_to_send)
except:
print("Some went wrong")
print("*"*50)
traceback.print_exc()
print("*"*50)
def use_skill(self, damage, attacker):
"""
Evades attack
Prints message about that attack
"""
super().use_skill(damage, attacker)
return DialogMessage('evaded_CA', {
'char': self.get_owner_stats()['CLS'],
'amount': damage
}).get_message() + "\n"
def take_damage_from(self, damage, other):
"""
Takes damage from other character
Prints message about that attack
"""
if self.get_dodge():
return DialogMessage('evaded_CA', self,
damage).get_message() + "\n"
else:
return super().take_damage_from(damage, other)
def use_skill(self):
"""
Used AttackSkill
Returns message about it
"""
self.set_current_cd(self.get_cooldown_timer())
output = DialogMessage('used_skill_C', {
'char': self.get_owner_stats()['CLS'],
'skill': self.get_name()
}).get_message() + "\n"
return output
def attack(self, other):
"""
Reduces other character's hp by self's attack
"""
if self.get_crit():
attack = self.get_attack() * self.get_attack_modifier() * 2
return DialogMessage('crit', self, attack).get_message(
) + "\n" + other.take_damage_from(attack, self)
else:
attack = self.get_attack() * self.get_attack_modifier()
return other.take_damage_from(attack, self)
def take_damage_pure(self, damage, attacker):
"""
Takes pure damage
"""
self._hp -= damage
log = DialogMessage('attack_pure_CAT', {
'char': attacker,
'amount': damage,
'target': self.get_class()
}).get_message() + "\n"
return log
def boss_choice(self, message):
"""
Battle enemy_choice part
Fight or flight, battle() or base()
"""
if message not in self.get_state_input(
): # standard check for right input
self.enqueue_message('Please input correct command', self._chat_id,
self._player_id)
self.enqueue_message(
DialogMessage('attack_enemy').get_message(), self._chat_id,
self._player_id, self._keyboard)
else:
if message == 'Attack Boss':
self.set_state('Battle')
self.battle(self._boss)
elif message == 'Return to base':
self.set_state('Base')
self.enqueue_message(
DialogMessage('base').get_message(), self._chat_id,
self._player_id, self._keyboard)
def add_exp(self, exp):
"""
Adds an amount of exp to character
"""
self._exp += exp
if self._exp >= self.get_exp_to_next_lvl():
self._lvl += 1
lvlup = DialogMessage('lvlup_CA', self,
self.get_lvl()).get_message()
self.lvlup()
lvlup += StatusMessage(self).stats_message()
return lvlup
def take_damage_from(self, damage, other):
"""
Takes other character's attack and reduces self es or/and hp by it
Prints message about that attack
"""
if self._es > 0 and damage < self._es:
self._es -= damage
return DialogMessage('attack_es_CAT', other, damage,
self).get_message() + "\n"
elif 0 < self._es <= damage:
if self._es == damage:
self._es = 0
return DialogMessage('broke_es_C', self).get_message() + "\n"
else:
leftoverdmg = damage - self._es
self._hp -= leftoverdmg * self.get_attack_modifier()
self._es = 0
return DialogMessage('broke_es_dmg_hp_CAT', other,
leftoverdmg * self.get_attack_modifier(),
self).get_message() + "\n"
else:
return super().take_damage_from(damage, other)
def take_damage_magic(self, damage, attacker):
"""
Takes magic damage
"""
leftoverdamage, log = self.check_defence_skills(damage, attacker)
if leftoverdamage > 0:
self._hp -= leftoverdamage
log += DialogMessage(
'attack_magic_CAT', {
'char': attacker,
'amount': leftoverdamage,
'target': self.get_class()
}).get_message() + "\n"
return log
def take_damage_normal(self, damage, attacker):
"""
Takes normal damage
"""
leftoverdamage, log = self.check_defence_skills(damage, attacker)
if leftoverdamage > 0:
self._hp -= leftoverdamage * self.get_defence_modifier()
log += DialogMessage(
'attack_CAT', {
'char': attacker,
'amount': leftoverdamage * self.get_defence_modifier(),
'target': self.get_class()
}).get_message() + "\n"
return log
def start_new_game(self, chat_id, player_id):
"""Starts a new game, and returns appropriate messages"""
self.user_list[player_id] = Game(chat_id, player_id)
print(f"Game started for {chat_id, player_id}")
keyboard = json.dumps({
'keyboard': [['Mage', 'Warrior', 'Rogue']],
'one_time_keyboard': False,
'resize_keyboard': True
})
return [
OutMessage('Ready Player One', chat_id, player_id),
OutMessage(
DialogMessage('start_game').get_message(), chat_id, player_id,
keyboard)
]
def generate_replays(self, text):
messages_to_send = []
new_message = MyMessageTest(text)
if new_message.get_type() != 'text':
pass
else:
player_id = new_message.get_user_id()
chat_id = new_message.get_chat_id()
content = new_message.get_content()
if player_id['id'] not in self.user_list.keys(
) and content == '/start':
messages_to_send.append(
OutMessage('Ready Player One', chat_id, player_id))
messages_to_send.append(
OutMessage(
DialogMessage('start_game').get_message(), chat_id,
player_id))
player_game = Game(chat_id, player_id)
self.user_list[player_id['id']] = player_game
elif player_id['id'] in self.user_list:
if new_message.get_content() == '/restart':
self.user_list.pop(player_id['id'])
messages_to_send.append(
OutMessage('Game reset', chat_id, player_id))
else:
player_game = self.user_list[player_id['id']]
game_state = player_game.check_state()
if game_state == 'Game Start':
player_game.game_start(content)
elif game_state == 'Base':
player_game.base(content)
elif game_state == 'Battle Choice':
player_game.battle_choice(content)
elif game_state == 'Item Choice':
player_game.item_choice(content)
elif game_state == 'Shop':
player_game.shop(content)
messages_to_send += player_game.send_all_messages()
else:
messages_to_send.append(
OutMessage('Type /start to enter the game', chat_id,
player_id))
return self.merge_messages(messages_to_send)
def use_attack_skill(self, skill, other):
damage = skill.get_damage()
return DialogMessage(
'used_skill_C',
self).get_message() + "\n" + other.take_damage_pure(damage, self)
