237 lines
8.7 KiB
Python
237 lines
8.7 KiB
Python
import random
|
|
import math
|
|
import copy
|
|
import game_data as gd
|
|
|
|
class Pokemon:
|
|
def __init__(self, input_series):
|
|
self.national_pokedex_number = input_series['national_pokedex_number']
|
|
self.name = input_series['name']
|
|
self.level = random.randint(1,20)
|
|
self.types = input_series['types']
|
|
self.baseStats = input_series['baseStats']
|
|
self.moves_dict = {}
|
|
moves = input_series['moves']
|
|
if len(moves) > 4:
|
|
raise ValueError("A Pokemon can only have 4 moves.")
|
|
else:
|
|
for move in moves:
|
|
#check if the move is in the available_moves dataframe
|
|
if move not in gd.available_moves_df.index:
|
|
raise ValueError(f"{move} is not an available move.")
|
|
else:
|
|
self.moves_dict[move] = copy.deepcopy(gd.available_moves_df.loc[move])
|
|
|
|
self.ActStats = self._compute_ActStats()
|
|
self.curr_hp = self.ActStats['hp']
|
|
|
|
def _compute_ActStats(self):
|
|
ActStats = {}
|
|
|
|
for baseKey in self.baseStats.keys():
|
|
if baseKey == 'hp':
|
|
ActStats[baseKey] = math.floor(self.baseStats[baseKey] * 2 * self.level / 100) + self.level + 10
|
|
else:
|
|
ActStats[baseKey] = math.floor(self.baseStats[baseKey] * 2 * self.level / 100) + 5
|
|
return ActStats
|
|
def _get_baseStats(self):
|
|
return self.baseStats
|
|
|
|
def get_current_hp(self):
|
|
return self.curr_hp
|
|
|
|
def get_current_hp_percent(self):
|
|
return self.curr_hp / self.baseStats['hp']
|
|
|
|
def can_battle(self):
|
|
condition1 = self.curr_hp > 0
|
|
condition2 = False
|
|
for move in self.moves_dict:
|
|
move_usage_avail = True #disregard pp in random battle
|
|
#move_usage_avail = self.moves_dict[move]['pp'] > 0
|
|
if move_usage_avail:
|
|
condition2 = True
|
|
break
|
|
else:
|
|
condition2 = False
|
|
return condition1 and condition2
|
|
|
|
def learnMove(self, move):
|
|
if len(self.moves_dict) >= 4:
|
|
raise ValueError("A Pokemon can only have 4 moves.")
|
|
else:
|
|
self.moves_dict[move] = copy.deepcopy(gd.available_moves_df[move])
|
|
|
|
def _compute_effect(self, move, opponent):
|
|
#check the move type (attack) and the defending
|
|
#pokemon type (defend) and look at effectiveness list.
|
|
#this should be done for all type of the defending pokemon
|
|
attack_move_type = move['type']
|
|
defending_types = opponent.get_types()
|
|
|
|
effect = 1
|
|
|
|
for def_t in defending_types:
|
|
for effectiveness_dataset in gd.type_effectiveness:
|
|
if effectiveness_dataset['attack'] == attack_move_type and effectiveness_dataset['defend'] == def_t:
|
|
effect = effect * effectiveness_dataset['effectiveness']
|
|
break
|
|
return effect
|
|
|
|
def _useMove(self, move, opponent, game_status = None):
|
|
if random.random() < move['accuracy']:
|
|
if move['category'] == 'physical':
|
|
attack = self.ActStats['attack']
|
|
defense = opponent.ActStats['defense']
|
|
assert defense>0
|
|
else:
|
|
attack = self.ActStats['special']
|
|
defense = opponent.ActStats['special']
|
|
assert defense>0
|
|
stability = 1.5 if move['type'] in self.types else 1
|
|
effect = self._compute_effect(move,opponent)
|
|
critical = 2 if random.random() < self.ActStats['speed']/512 else 1
|
|
luck = random.uniform(0.85, 1.0)
|
|
modifier = stability * effect * critical * luck
|
|
damage = math.floor(((2*self.level+10)/250 * (attack/defense) * move['power'] + 2) * modifier)
|
|
opponent.curr_hp -= damage
|
|
if opponent.curr_hp < 0:
|
|
opponent.curr_hp = 0
|
|
if not game_status == 'new_random_battle':
|
|
print(f"{self.name} used {move['name']} and dealt {damage} damage to {opponent.name}!")
|
|
else:
|
|
damage = 0
|
|
if not game_status == 'new_random_battle':
|
|
print(f"{self.name}'s attack missed!")
|
|
return damage
|
|
|
|
def useMove(self, move_name, opponent, game_status = None):
|
|
if move_name not in self.moves_dict:
|
|
raise ValueError(f"{self.name} does not know the move {move_name}.")
|
|
else:
|
|
return self._useMove(self.moves_dict[move_name], opponent, game_status)
|
|
|
|
def print_move(self,move):
|
|
print(f"Move: {self.moves_dict[move]['name']}")
|
|
print(f"Type: {self.moves_dict[move]['type']}")
|
|
print(f"Category: {self.moves_dict[move]['category']}")
|
|
print(f"Power: {self.moves_dict[move]['power']}")
|
|
print(f"Accuracy: {self.moves_dict[move]['accuracy']}")
|
|
print(f"PP: {self.moves_dict[move]['pp']}")
|
|
|
|
def get_moves(self):
|
|
return list(self.moves_dict.keys())
|
|
|
|
def get_types(self):
|
|
return self.types
|
|
|
|
def checkout_move(self, move_name):
|
|
if move_name not in self.moves_dict:
|
|
raise ValueError(f"{self.name} does not know the move {move_name}.")
|
|
else:
|
|
self.print_move(move_name)
|
|
|
|
def _status(self):
|
|
print(f"Pokemon: {self.name}")
|
|
print(f"Level: {self.level}")
|
|
print(f"Types: {self.types}")
|
|
print(f"Base Stats: {self.baseStats}")
|
|
print(f"Current HP: {self.curr_hp}")
|
|
print(f"Moves: {self.moves_dict}")
|
|
|
|
def print_pokemon_info(self):
|
|
self._status()
|
|
|
|
|
|
class Trainer:
|
|
def __init__(self, name, starter_name, items = {"potions": 0, "pokeball": 0}, is_CPU = False):
|
|
self.name = name
|
|
|
|
self.starter = starter_name
|
|
self.active_pokemon = Pokemon(gd.pokemons_df.loc[starter_name])
|
|
self.pokemon_list = []
|
|
self.add_pokemon(self.active_pokemon)
|
|
|
|
self.items = items
|
|
self.is_CPU = is_CPU
|
|
|
|
def add_pokemon(self, pokemon):
|
|
if len(self.pokemon_list) >= 6:
|
|
raise ValueError("A trainer can only have 6 Pokemon.")
|
|
else:
|
|
self.pokemon_list.append(pokemon)
|
|
|
|
def get_pokemon_list(self):
|
|
return [pok.name for pok in self.pokemon_list]
|
|
|
|
def get_pokemon(self, name):
|
|
for pokemon in self.pokemon_list:
|
|
if pokemon.name == name:
|
|
return pokemon
|
|
raise ValueError(f"{name} is not in the trainer's Pokemon list.")
|
|
|
|
def can_battle(self):
|
|
for pokemon in self.pokemon_list:
|
|
if pokemon.can_battle():
|
|
return True
|
|
return False
|
|
|
|
def active_pokemon_can_battle(self):
|
|
return self.active_pokemon.can_battle()
|
|
|
|
def _change_active_pokemon(self,new_pokemon):
|
|
self.active_pokemon = new_pokemon
|
|
|
|
def get_active_pokemon(self):
|
|
return self.active_pokemon
|
|
|
|
def change_active_pokemon(self,pokemon_name):
|
|
try:
|
|
new_pokemon = self.get_pokemon(pokemon_name)
|
|
self._change_active_pokemon(new_pokemon)
|
|
print("Pokemon change successfull!")
|
|
except ValueError as e:
|
|
raise e
|
|
|
|
def print_items(self):
|
|
print(f"1) Potions: {self.items['potions']}")
|
|
print(f"2) Pokeballs: {self.items['pokeball']}")
|
|
|
|
def use_item(self, item_name):
|
|
if item_name not in self.items:
|
|
raise ValueError(f"{item_name} is not an available item.")
|
|
else:
|
|
if self.items[item_name] > 0:
|
|
self.items[item_name] -= 1 #use the item
|
|
print(f"Used {item_name}. Remaining: {self.items[item_name]}")
|
|
if item_name == "potions":
|
|
self.active_pokemon.curr_hp += 20
|
|
if self.active_pokemon.curr_hp > self.active_pokemon.baseStats['hp']:
|
|
self.active_pokemon.curr_hp = self.active_pokemon.baseStats['hp']
|
|
print(f"{self.active_pokemon.name} has been healed by 20 HP!")
|
|
return False
|
|
elif item_name == "pokeball":
|
|
return True
|
|
else:
|
|
raise ValueError(f"You have no {item_name} left.")
|
|
|
|
def update_pokemon_list(self, pokemon):
|
|
pass
|
|
|
|
def _status(self):
|
|
print('='*30)
|
|
print(f"Trainer name: {self.name}")
|
|
print(f"Starter Pokemon: {self.starter}")
|
|
print(f"Pokemon List: {[pok.name for pok in self.pokemon_list]}")
|
|
print("Active Pokemon info:")
|
|
self.active_pokemon.print_pokemon_info()
|
|
print("Detailed info of Pokemons in your list:")
|
|
print("-"*30)
|
|
for pokemon in self.pokemon_list:
|
|
pokemon.print_pokemon_info()
|
|
print("-"*30)
|
|
print(f"Items: {self.items}")
|
|
print('='*30)
|
|
|
|
def print_trainer_info(self):
|
|
self._status() |