def __init__(self,name,password,indicador_nuevo):
#usuario elige si es un nuevo jugador o no (indicado_nuevo)
#En el caso de que no lo sea se debe veridicar previamente si es que pass y name son correctos
if indicador_nuevo==False:
#leemos el json del jugador seleccionado
dict_jugador=jsonReader.jsonToDict(str(name)+'.json')['id_jugador']
self.name=dict_jugador['name']
self.password=dict_jugador['password']
self.medals=dict_jugador['medals']
self.money=dict_jugador['money']
self.team=dict_jugador['team']
self.battles=dict_jugador['battles']
self.qty_prograbolas=dict_jugador['qty_prograbolas']
self.programon=[]
##generar metodo que genere de diccionario a programon
for dict_mono in dict_jugador['programon']:
self.programon.append(Programon(dict_mono['id'],dict_mono['level'],dict_mono['iv'],dict_mono['ev']))
self.progradex=dict_jugador['progradex']
##generar metodo en ciudad o ruta que entregue intancia a partir de dict
self.actual_location=dict_jugador['actual_location']
else:
#inicializamos un jugador desde cero
self.name=name
self.password=password
self.medals=[]
self.money=1000
list_programones=jsonReader.jsonToDict('programones.json')
#consultar que pokemon inicial quiere
while True:
pokemon_inicial=input('Selecciona un programon inicial:\n (0) Charmander \n (1) Squirtle \n (2) Bulbasaur :\n')
if pokemon_inicial=='0':
nombre_inicial="Charmander"
break
elif pokemon_inicial=='1':
nombre_inicial="Squirtle"
break
elif pokemon_inicial=='2':
nombre_inicial="Bulbasaur"
break
else:
print('Selecione un numero válido')
#realizar clase de creación de programon para inicilizar
dict_programon =[programon for programon in list_programones if programon['name']==nombre_inicial][0]
#realizar clase de creación de programon para inicilizar self.programones
self.programon=[Programon(dict_programon['id'],level=5)]
#Definimos el team como una lista con los id de cada programon
self.team=[dict_programon['id']]
#se inicia la lista de progradex con el pokemon elegido
self.progradex=[dict_programon['id']]
#batallas lista de diccionarios de registros
self.battles=[]
self.qty_prograbolas=10
# crear instancia de ciudad pueblo paleta
self.actual_location=0
def ultima_ciudad(ciudad):
rutas = jsonToDict("routes.json")
ultima = True
for ruta in rutas:
if ciudad == ruta["starting_point"]:
ultima = False
return ultima
def __init__(self,id,level,iv=random.randint(0,15),ev=random.randint(0,65535)):
#buscamos el diccionario del programon en programones.json
dict_programon=[programon for programon in jsonReader.jsonToDict('programones.json') if programon['id']==id][0]
self.id=dict_programon['id']
self.type=dict_programon['type']
self.level=level
self.name=dict_programon['name']
#asignar evolucion si es que tiene en el caso de que no tenga entregar none
if 'evolveLevel' in dict_programon.keys():
self.evolveLevel=dict_programon['evolveLevel']
self.evolveTo=dict_programon['evolveTo']
#se dejara como none en los que no tengan evolucion
else:
self.evolveLevel=None
self.evolveTo=None
self.base_hp=dict_programon['hp']
self.base_special_defense=dict_programon['special_defense']
self.base_special_attack=dict_programon['special_attack']
self.base_defense=dict_programon['defense']
self.base_attack=dict_programon['attack']
self.base_speed=dict_programon['speed']
self.moves=dict_programon['moves']
self.iv=iv
self.ev=ev
self.peleo=False
def evolucion(id):
if id:
lista_programones = jsonToDict("programones.json")
for p in lista_programones:
if str(p["id"]) == str(id):
return p["name"]
return "No evoluciona."
def display_progradex(jugador):
progradex = jugador.progradex
vistos = progradex.programones_vistos
atrapados = jugador.progradex.programones_atrapados
lista_programones = jsonToDict("programones.json")
if len(atrapados) > 0:
print("\nProgramones capturados: ")
for nombre in atrapados:
for programon in lista_programones:
if nombre == programon["name"]:
print("\nNombre: " + str(programon["name"]))
print(" ID: " + str(programon["id"]))
print(" Type: " + str(programon["type"]))
print(" HP: " + str(programon["hp"]))
print(" Speed: " + str(programon["speed"]))
print(" Attack: " + str(programon["attack"]))
print(" Special Attack: " + str(programon["special_attack"]))
print(" Defense: " + str(programon["defense"]))
print(" Special Defense: " + str(programon["special_defense"]))
print(" Evolve To: " + str(evolucion(programon.get("evolveTo"))))
print(" Evolve Level: " + str(programon.get("evolveLevel")))
if len(vistos) > 0:
print("\nProgramones vistos: ")
for nombre in vistos:
for programon in lista_programones:
if nombre == programon["name"]:
print("\nNombre: " + str(programon["name"]))
print(" ID: " + str(programon["id"]))
def __init__(self,route,i):
rout_dict=[ruta for ruta in jsonReader.jsonToDict('routes.json') if ruta['route']==route][0]
self.starting_point=rout_dict['starting_point']
self.destination=rout_dict['destination']
self.name=rout_dict['route']
self.levels=rout_dict['levels']
self.pos=i
def __init__(self, mode_test=False):
self.mode_test = mode_test
# Diccionario
self.pal_data = jsonReader.jsonToDict(PATH_DATA)
# Listas
self.pal_user = tuple(jsonReader.jsonToDict(PATH_USER_LESSON))
self.list_pal_mistaken = list()
self.list_pal_seccion = tuple()
self.mode_repeat = False
self.mode_seccion = False
self.score = 0
self.pal_hechas = 0
def password_correcta(nombre, password):
password = str(password)
nombre = str(nombre)
lista_jugadores = jsonToDict("jugadores.json")
password_correcta = False
for jugador in lista_jugadores:
if password == jugador["password"] and nombre == jugador["nombre"]:
password_correcta = True
return password_correcta
def __init__(self,move):
#lista de todos lo moves lista de diccionarios
lista_moves=jsonReader.jsonToDict('programonMoves.json')
dict_mov=[i for i in lista_moves if i['name']==move][0]
self.pp=dict_mov['pp']
self.accuracy=dict_mov['accuracy']
self.type=dict_mov['type']
self.power=dict_mov['power']
self.name=dict_mov['name']
def __init__(self,id):
if id==0:
self.name='Pallet Town'
self.id=0
self.leader=None
self.trainers=None
else:
city_dict=[city for city in jsonReader.jsonToDict('gyms.json') if city['id']==id][0]
self.name=city_dict['city']
self.id=city_dict['id']
self.leader=city_dict['leader']
self.trainers=city_dict['trainers']
def __init__(self, pal_user):
self.pal_user = pal_user
self.pal_data = jsonReader.jsonToDict(PATH_DATA)
for key in self.pal_user:
del self.pal_data[key]
self.attr_pal = ['Definition', 'Translation', 'Example']
self.mode_repeat = False
self.score = 0
self.pal_hechas = 0
def guardar_info_jugador(jugador):
data = jsonToDict("jugadores.json")
for player in data:
if player["nombre"] == jugador.nombre:
data.remove(player)
dict_jugador = {}
dict_jugador["id"] = jugador.id
dict_jugador["nombre"] = jugador.nombre
dict_jugador["dinero"] = jugador.dinero
dict_jugador["medallas"] = jugador.medallas
dict_jugador["gyms"] = jugador.gyms
dict_jugador["password"] = jugador.password
dict_jugador["ubicacion"] = jugador.ubicacion
dict_jugador["prograbolas"] = jugador.prograbolas
dict_jugador["PC"] = jugador.PC
team = jugador.equipo
team2 = []
for programon in team:
dict_programon = {}
dict_programon["name"] = programon.name
dict_programon["unique_id"] = programon.unique_id
dict_programon["level"] = programon.level
dict_programon["IV"] = programon.IV
dict_programon["EV"] = programon.EV
team2.append(dict_programon)
dict_jugador["equipo"] = team2
batallas2 = []
for batalla in jugador.batallas:
batalla_i = {}
batalla_i["victoria"] = batalla.victoria
batalla_i["tipo"] = batalla.tipo
if batalla.entrenador:
batalla_i["entrenador"] = str(batalla.entrenador)
batalla_i["programon_enemigo"] = batalla.programon_enemigo
batalla_i["equipo"] = batalla.equipo
batalla_i["dinero"] = batalla.dinero
batallas2.append(batalla_i)
dict_jugador["batallas"] = batallas2
vistos = jugador.progradex.programones_vistos
vistos2 = []
for programon in vistos:
vistos2.append(programon)
atrapados = jugador.progradex.programones_atrapados
atrapados2 = []
for programon in atrapados:
atrapados2.append(programon)
dict_aux = {}
dict_aux["vistos"] = vistos2
dict_aux["atrapados"] = atrapados2
dict_jugador["progradex"] = dict_aux
data.append(dict_jugador)
dictToJson("jugadores.json", data)
def __init__(self, city, leader, name=None):
dict_city=[dict for dict in jsonReader.jsonToDict('gyms.json') if dict['city']==city][0]
if leader==True:
dict_trainer=dict_city['leader']
else:
dict_trainer= [dict for dict in dict_city['trainers'] if dict['name']==name][0]
self.name=dict_trainer['name']
self.programon=[Programon(programon['id'],programon['level']) for programon in dict_trainer['programones']]
self.team=[programon['id'] for programon in dict_trainer['programones']]
if leader==True:
self.leader=True
else:
self.leader=False
def __init__(self, nombre, password, id, ubicacion=None, progradex=None, PC=None, prograbolas=None, batallas=None,
dinero=None, gyms=None):
self.id = id
self.nombre = nombre
self.password = password
self.medallas = []
if dinero:
self.dinero = dinero
else:
self.dinero = 1000
if progradex:
self.progradex = progradex
else:
self.progradex = Progradex()
if PC:
self.PC = PC
else:
self.PC = []
self.equipo = []
if prograbolas:
self.prograbolas = prograbolas
else:
self.prograbolas = 10
if batallas:
self.batallas = batallas
else:
self.batallas = []
if ubicacion:
self.ubicacion = ubicacion
else:
self.ubicacion = ["Pallet Town", 0]
if gyms:
self.gyms = gyms
else:
self.gyms = []
lista_gimnasios = jsonToDict("gyms_creados.json")
for gimnasio in lista_gimnasios:
gimnasio_i = {}
gimnasio_i["lucho"] = False
gimnasio_i["name"] = gimnasio["name"]
gimnasio_i["leader"] = False
trainers = []
for trainer in gimnasio["trainers"]:
trainer_dict = {}
trainer_dict["name"] = trainer["name"]
trainer_dict["unique_id"] = trainer["unique_id"]
trainer_dict["gano"] = False
trainers.append(trainer_dict)
gimnasio_i["trainers"] = trainers
self.gyms.append(gimnasio_i)
def programon_factible_route(self):
#límites de la ruta
low_limit=mapa[self.actual_location].levels[0]
up_limit=mapa[self.actual_location].levels[1]
list_programones=jsonReader.jsonToDict('programones.json')
#programones con evolucion
programones_ce=[i for i in list_programones if 'evolveTo' in i.keys()]
#programones sin evolucion
programones_se=[i for i in list_programones if not('evolveTo' in i.keys())]
list_programones_factibles=[]
#retorna el pokemon anterior a el si es que tiene
def evolucion_de(programon,list_programones):
viene_de=None
for i in list_programones:
if programon['id']==i['evolveTo']:
viene_de=i
return viene_de
#los que tienen evolucion
for programono in programones_ce:
#si no es evolucion de nadie y su nivel de evolucion es mayor a low
if evolucion_de(programono,programones_ce)==None and programono['evolveLevel']>low_limit:
arriba=min(up_limit,programono['evolveLevel'])
abajo=low_limit
list_programones_factibles.append((abajo,arriba,programono))
#si es evolucion de alguien y su nivel de evolucion es mayor a low
elif programono['evolveLevel']>low_limit and evolucion_de(programono,programones_ce)!=None:
arriba=min(up_limit,programono['evolveLevel'])
abajo=max(evolucion_de(programono,programones_ce)['evolveLevel'],low_limit)
list_programones_factibles.append((abajo,arriba,programono))
# para programon sin evolucion
for programono in programones_se:
if evolucion_de(programono,programones_ce)==None:
#si no es evolucion de alguien
arriba=up_limit
abajo=low_limit
list_programones_factibles.append((abajo,arriba,programono))
elif evolucion_de(programono,programones_ce)!=None and evolucion_de(programono,programones_ce)['evolveLevel']<up_limit:
# es evolucion de alguien
arriba=up_limit
abajo=max(evolucion_de(programono,programones_ce)['evolveLevel'],low_limit)
list_programones_factibles.append((abajo,arriba,programono))
#Elegir un progrmamon al azar
random_programon=random.choice(list_programones_factibles)
random_nivel=random.randint(random_programon[0],random_programon[1])
id=random_programon[2]['id']
return Programon(id,random_nivel)
def calculo_daño(self,p_atacante,p_defensor):
#calculamos el modificador primero
#potenciador si ataque es del mismo tipo que el programon que ataca
STAB= 1.5 if self.type==p_atacante.type else 1
#modificador de daños segun tipo del ataque y tipo de programon defensor
lista_types=jsonReader.jsonToDict('types.json')
Tipo=lista_types[self.type][p_defensor.type] if p_defensor.type in lista_types[self.type].keys() else 1
#factor de ataque crítico
T=p_atacante.base_speed/2
P=random.randint(0, 256)
Critico= 2 if P<=T else 1
#numero random de ataque
num_random=random.randint(85,100)/100
#valor modificador
modificador=STAB*Tipo*Critico*num_random
#definir si es que el ataque es de algún tipo especial
dict_category=jsonReader.jsonToDict('moveCategories.json')
especial=True if self.type in dict_category["special_moves"] else False
#calculo daño
if especial:
daño=((2*p_atacante.level+10)/250*(p_atacante.special_attack/p_defensor.special_defense)*self.power+2)*modificador
else:
daño=((2*p_atacante.level+10)/250*(p_atacante.attack/p_defensor.defense)*self.power+2)*modificador
return daño
def guardar_info_gimnasio(gym):
data = jsonToDict("gyms_creados.json")
for gim in data:
if gim["name"] == gym.name:
data.remove(gim)
dict_gym = {}
dict_gym["id"] = gym.id
dict_gym["name"] = gym.name
dict_lider_gym = {}
dict_lider_gym["name"] = gym.leader.name
dict_lider_gym["unique_id"] = gym.leader.unique_id
programones_lider = []
for programon in gym.leader.programones:
dict_programon = {}
dict_programon["name"] = programon.name
dict_programon["unique_id"] = programon.unique_id
dict_programon["level"] = programon.level
dict_programon["IV"] = programon.IV
dict_programon["EV"] = programon.EV
programones_lider.append(dict_programon)
dict_lider_gym["programones"] = programones_lider
dict_gym["leader"] = dict_lider_gym
entrenadores = []
for trainer in gym.trainers:
dict_trainer = {}
dict_trainer["name"] = trainer.name
dict_trainer["unique_id"] = trainer.unique_id
programones_trainer = []
for programon in trainer.programones:
dict_programon = {}
dict_programon["name"] = programon.name
dict_programon["unique_id"] = programon.unique_id
dict_programon["level"] = programon.level
dict_programon["IV"] = programon.IV
dict_programon["EV"] = programon.EV
programones_trainer.append(dict_programon)
dict_trainer["programones"] = programones_trainer
entrenadores.append(dict_trainer)
dict_gym["trainers"] = entrenadores
data.append(dict_gym)
dictToJson("gyms_creados.json", data)
def __init__(self):
# Diccionarios
self.pal_data = jsonReader.jsonToDict(PATH_DATA)
self.pal_user = jsonReader.jsonToDict(PATH_USER_LESSON)
self.attr_pal = ['Definition', 'Translation', 'Example']
def __init__(self):
# Diccionarios
self.pal_data = jsonReader.jsonToDict(PATH_DATA)
self.pal_user = jsonReader.jsonToDict(PATH_USER_LESSON)
def ruta_ciudad(ciudad):
rutas = jsonToDict("routes.json")
for ruta in rutas:
if ruta["starting_point"] == ciudad:
return ruta["route"]
import jsonReader as Js
import random
import math as m
import ClasesProgramonRojo as CpR
DictProgramones = Js.jsonToDict("programones.json")
DictGyms = Js.jsonToDict("gyms.json")
DictProgramonesMoves = Js.jsonToDict("programonMoves.json")
DictRoutes = Js.jsonToDict("routes.json")
DictTypes = Js.jsonToDict("types.json")
DictMoveCategories = Js.jsonToDict("moveCategories.json")
Jugador_actual = CpR.Jugador(None, None, None)
Programon_actual_salvaje = None
dicc_progradex = {}
Contrincante_actual = None
lista_de_todos_programones = []
lista_de_todos_moves = []
lista_de_todos_los_gimnasios = []
lista_de_todas_las_rutas = []
lista_categoria_physic = None
lista_categoria_special = None
lista_de_todos_los_jugadores = []
lista_de_todas_las_ciudades = []
mapa = []
i = 0
for diccionari in DictProgramonesMoves:
puntos_de_poder_aux = None
tipo_aux = None
name = input('Cual es tu nombre:\n')
while True:
password = input('Crea una contraseña:\n')
verificar = input('Confirma tu contraseña:\n')
if password == verificar:
jugador = clases.Jugador(name, password, True)
break
else:
print('Fallaste en verificar tu contraseña\n')
break
elif opcion == '1':
name = input('Cual es tu nombre:\n')
while True:
password = input('Cual es la contraseña de la partida\n')
try:
dict_jugador = jsonReader.jsonToDict(str(name) +
'.json')['id_jugador']
except:
print('Partida no existe\n')
if dict_jugador['password'] == password:
jugador = clases.Jugador(name, password, False)
print('Partida cargada\n')
break
else:
print('Contraseña incorrecta\n')
continue
break
else:
print('opcion inválida\n')
print('\n\n')
while True:
import jsonReader as Js
import random
import math as m
import ClasesProgramonRojo as CpR
DictProgramones = Js.jsonToDict("programones.json")
DictGyms = Js.jsonToDict("gyms.json")
DictProgramonesMoves = Js.jsonToDict("programonMoves.json")
DictRoutes = Js.jsonToDict("routes.json")
DictTypes = Js.jsonToDict("types.json")
DictMoveCategories = Js.jsonToDict("moveCategories.json")
Jugador_actual = CpR.Jugador(None, None, None)
Programon_actual_salvaje = None
dicc_progradex = {}
Contrincante_actual = None
lista_de_todos_programones = []
lista_de_todos_moves = []
lista_de_todos_los_gimnasios = []
lista_de_todas_las_rutas = []
lista_categoria_physic = None
lista_categoria_special = None
lista_de_todos_los_jugadores = []
lista_de_todas_las_ciudades = []
mapa = []
i = 0
for diccionari in DictProgramonesMoves:
def llegar_ciudad2(jugador):
opciones = input("\nQue opcion desea?: \n"
" 1. Retroceder\n"
" 2. Comprar prograbolas\n"
" 3. Ir a centro programon\n"
" 4. Ir a gimnasio\n"
" 5. Volver al menu anterior\n"
"Su opcion: ")
while opciones != "5":
if opciones == "1":
jugador.ubicacion[0] = ciudad_anterior(jugador.ubicacion[0])
jugador.ubicacion[1] = 3
print("\nAhora usted se encuentra en Ruta {} Parte 3.".format(ruta_ciudad(jugador.ubicacion[0])))
enemigo = encontrar_programon(jugador)
if enemigo:
if not(enemigo.name in jugador.progradex.programones_vistos):
jugador.progradex.agregar_visto(enemigo.name)
print("\nUn " + str(enemigo.name) + " salvaje ha aparecido!")
batalla_salvaje(jugador, enemigo)
break
else:
break
elif opciones == "2":
cantidad = input("\nBienvenido a la tienda programon.\n"
"Ingrese el numero de prograbolas que desea: ")
if cantidad == "0":
print("\nQue vuelva pronto!")
opciones = input("\nQue opcion desea?: \n"
" 1. Retroceder\n"
" 2. Comprar prograbolas\n"
" 3. Ir a centro programon\n"
" 4. Ir a gimnasio\n"
" 5. Volver al menu anterior\n"
"Su opcion: ")
else:
while not (cantidad.isdigit() and int(cantidad) >= 0 and int(cantidad) * 500 <= jugador.dinero):
if cantidad == "0":
break
elif not (cantidad.isdigit() and int(cantidad) >= 0):
cantidad = input("\nIngrese un numero valido: ")
elif int(cantidad) * 500 > jugador.dinero:
cantidad = input("\nNo tiene dinero suficiente para comprar todas esas prograbolas.\n"
"Elija un numero menor: ")
if cantidad == "0":
print("\nQue vuelva pronto!")
else:
print("\nHa comprado {0} prograbolas por un total de {1} yenes.".format(cantidad,
str(int(cantidad) * 500)))
jugador.dinero -= int(cantidad) * 500
jugador.prograbolas += int(cantidad)
opciones = input("\nQue opcion desea?: \n"
" 1. Retroceder\n"
" 2. Comprar prograbolas\n"
" 3. Ir a centro programon\n"
" 4. Ir a gimnasio\n"
" 5. Volver al menu anterior\n"
"Su opcion: ")
elif opciones == "3":
eleccion = input("\nBienvenido al PC de Bastian.\n"
"Elija una opcion:\n"
" 1. Retirar programon\n"
" 2. Guardar programon\n"
" 3. Volver al menu anterior\n"
"Su opcion: ")
if eleccion == "3":
print("\nHasta pronto.")
opciones = input("\nQue opcion desea?: \n"
" 1. Retroceder\n"
" 2. Comprar prograbolas\n"
" 3. Ir a centro programon\n"
" 4. Ir a gimnasio\n"
" 5. Volver al menu anterior\n"
"Su opcion: ")
else:
while eleccion != "3":
if eleccion == "1":
if len(jugador.PC) == 0:
print("\nNo tiene programones en PC para retirar.")
eleccion = input("\nElija una opcion:\n"
" 1. Retirar programon\n"
" 2. Guardar programon\n"
" 3. Volver al menu anterior\n"
"Su opcion: ")
elif len(jugador.equipo) == 6:
print("\n Su equipo esta lleno, no puede retirar programones del PC.")
eleccion = input("\nElija una opcion:\n"
" 1. Retirar programon\n"
" 2. Guardar programon\n"
" 3. Volver al menu anterior\n"
"Su opcion: ")
else:
print("\nElija un programon de su PC: ")
contador = 1
for programon in jugador.PC:
print(" " + str(contador) + ". " + str(programon["name"]))
contador += 1
guerrero = input("Su opcion: ")
while not(guerrero.isdigit() and 0 < int(guerrero) <= len(jugador.PC)):
guerrero = input("\nIngrese una opcion valida: ")
programon_elegido = jugador.PC[int(guerrero)-1]
jugador.PC.remove(programon_elegido)
IV = programon_elegido["IV"]
EV = programon_elegido["EV"]
level = programon_elegido["level"]
nombre = programon_elegido["name"]
unique_id = programon_elegido["unique_id"]
programones_lista = jsonToDict("programones.json")
for poke in programones_lista:
if poke["name"] == nombre:
id = poke["id"]
moves = poke["moves"]
type = poke["type"]
hp = poke["hp"]
speed = poke["speed"]
attack = poke["attack"]
special_attack = poke["special_attack"]
defense = poke["defense"]
special_defense = poke["special_defense"]
evolveTo = poke.get("evolveTo")
evolveLevel = poke.get("evolveLevel")
programon_creado = Programon(id, unique_id, moves, nombre, type, hp, speed, attack,
special_attack, defense, special_defense, level, evolveLevel,
evolveTo, IV, EV)
jugador.equipo.append(programon_creado)
print("\n {} se ha sumado a su equipo!".format(programon_creado.name))
eleccion = input("\nElija una opcion:\n"
" 1. Retirar programon\n"
" 2. Guardar programon\n"
" 3. Volver al menu anterior\n"
"Su opcion: ")
elif eleccion == "2":
if len(jugador.equipo) > 1:
print("\nElija un programon de su equipo para guardar: ")
contador = 1
for programon in jugador.equipo:
print(" " + str(contador) + ". " + str(programon.name))
contador += 1
guerrero = input("Su opcion: ")
while not(guerrero.isdigit() and 0 < int(guerrero) <= len(jugador.equipo)):
guerrero = input("\nIngrese una opcion valida: ")
programon_elegido = jugador.equipo[int(guerrero)-1]
jugador.equipo.remove(programon_elegido)
dic_aux = {}
dic_aux["name"] = programon_elegido.name
dic_aux["unique_id"] = programon_elegido.unique_id
dic_aux["EV"] = programon_elegido.EV
dic_aux["IV"] = programon_elegido.IV
dic_aux["level"] = programon_elegido.level
jugador.PC.append(dic_aux)
print("\nSe ha agregado {} al PC".format(programon_elegido.name))
eleccion = input("\nElija una opcion:\n"
" 1. Retirar programon\n"
" 2. Guardar programon\n"
" 3. Volver al menu anterior\n"
"Su opcion: ")
else:
print("\nSolo tiene un programon.")
print("No puede guardarlo o quedara sin programones para defenderse.")
eleccion = input("\nElija una opcion:\n"
" 1. Retirar programon\n"
" 2. Guardar programon\n"
" 3. Volver al menu anterior\n"
"Su opcion: ")
elif eleccion == "3":
break
else:
eleccion = input("\nIngrese una opcion valida:\n"
" 1. Retirar programon\n"
" 2. Guardar programon\n"
" 3. Volver al menu anterior\n"
"Su opcion: ")
print("\nHasta pronto.")
opciones = input("\nQue opcion desea?: \n"
" 1. Retroceder\n"
" 2. Comprar prograbolas\n"
" 3. Ir a centro programon\n"
" 4. Ir a gimnasio\n"
" 5. Volver al menu anterior\n"
"Su opcion: ")
elif opciones == "4":
llegar_gimnasio(jugador)
opciones = input("\nQue opcion desea?: \n"
" 1. Retroceder\n"
" 2. Comprar prograbolas\n"
" 3. Ir a centro programon\n"
" 4. Ir a gimnasio\n"
" 5. Volver al menu anterior\n"
"Su opcion: ")
elif opciones == "5":
break
else:
print("\nOpcion no valida. Elija otra.")
opciones = input("\nQue opcion desea?: \n"
" 1. Retroceder\n"
" 2. Comprar prograbolas\n"
" 3. Ir a centro programon\n"
" 4. Ir a gimnasio\n"
" 5. Volver al menu anterior\n"
"Su opcion: ")
def ciudad_anterior(ciudad):
rutas = jsonToDict("routes.json")
for ruta in rutas:
if ruta["destination"] == ciudad:
return ruta["starting_point"]
def lista_programones():
return jsonToDict("programones.json")
def cargar_info_gimnasio(nombre_gimnasio):
gimnasios_existentes = jsonToDict("gyms_creados.json")
for gimnasio in gimnasios_existentes:
if gimnasio["name"] == nombre_gimnasio:
name_gym = gimnasio["name"]
id_gym = gimnasio["id"]
dict_leader = gimnasio["leader"]
leader_name = dict_leader["name"]
leader_id = dict_leader["unique_id"]
leader_programones = dict_leader["programones"]
leader_programones2 = []
for programon in leader_programones:
unique_id = programon["unique_id"]
IV = programon["IV"]
level = programon["level"]
EV = programon["EV"]
nombre_programon = programon["name"]
programones = jsonToDict("programones.json")
for poke in programones:
if poke["name"] == nombre_programon:
id = poke["id"]
moves = poke["moves"]
type = poke["type"]
hp = poke["hp"]
speed = poke["speed"]
attack = poke["attack"]
special_attack = poke["special_attack"]
defense = poke["defense"]
special_defense = poke["special_defense"]
evolveTo = poke.get("evolveTo")
evolveLevel = poke.get("evolveLevel")
programon_creado = Programon(id, unique_id, moves, nombre_programon, type, hp, speed, attack,
special_attack, defense, special_defense, level, evolveLevel, evolveTo,
IV, EV)
leader_programones2.append(programon_creado)
lider = Entrenador(leader_name, leader_programones2, leader_id)
dict_trainers = gimnasio["trainers"]
entrenadores = []
for trainer in dict_trainers:
trainer_name = trainer["name"]
trainer_id = trainer["unique_id"]
trainer_programones = trainer["programones"]
trainer_programones2 = []
for programon in trainer_programones:
unique_id = programon["unique_id"]
IV = programon["IV"]
level = programon["level"]
EV = programon["EV"]
nombre_programon = programon["name"]
programones = jsonToDict("programones.json")
for poke in programones:
if poke["name"] == nombre_programon:
id = poke["id"]
moves = poke["moves"]
type = poke["type"]
hp = poke["hp"]
speed = poke["speed"]
attack = poke["attack"]
special_attack = poke["special_attack"]
defense = poke["defense"]
special_defense = poke["special_defense"]
evolveTo = poke.get("evolveTo")
evolveLevel = poke.get("evolveLevel")
programon_creado = Programon(id, unique_id, moves, nombre_programon, type, hp, speed, attack,
special_attack, defense, special_defense, level, evolveLevel,
evolveTo, IV, EV)
trainer_programones2.append(programon_creado)
entrenador_i = Entrenador(trainer_name, trainer_programones2, trainer_id)
entrenadores.append(entrenador_i)
gimnasio = Gimnasio(name_gym, id_gym, lider, entrenadores)
return gimnasio
def crear_gyms():
gimnasios = jsonToDict("gyms.json")
for gimnasio in gimnasios:
nombre = gimnasio["city"]
id = gimnasio["id"]
leader_dict = gimnasio["leader"]
leader_programones = leader_dict["programones"]
lider_programones = []
lista_programones = jsonToDict("programones.json")
for programon_lider in leader_programones:
for programon in lista_programones:
if programon_lider["id"] == programon["id"]:
id = programon["id"]
unique_id = numero_programones()
moves = programon["moves"]
name = programon["name"]
type = programon["type"]
hp = programon["hp"]
speed = programon["speed"]
attack = programon["attack"]
special_attack = programon["special_attack"]
defense = programon["defense"]
special_defense = programon["special_defense"]
level = programon_lider["level"]
evolveTo = programon.get("evolveTo")
evolveLevel = programon.get("evolveLevel")
programon_creado = Programon(id, unique_id, moves, name, type, hp, speed, attack,
special_attack, defense, special_defense, level, evolveLevel,
evolveTo)
actualizar_numero_programones()
lider_programones.append(programon_creado)
lider = Entrenador(leader_dict["name"], lider_programones)
trainers = gimnasio["trainers"]
entrenadores = []
for trainer in trainers:
trainer_programones_dict = trainer["programones"]
trainer_programones = []
for programon_trainer in trainer_programones_dict:
for programon in lista_programones:
if programon_trainer["id"] == programon["id"]:
id = programon["id"]
unique_id = numero_programones()
moves = programon["moves"]
name = programon["name"]
type = programon["type"]
hp = programon["hp"]
speed = programon["speed"]
attack = programon["attack"]
special_attack = programon["special_attack"]
defense = programon["defense"]
special_defense = programon["special_defense"]
level = programon_trainer["level"]
evolveTo = programon.get("evolveTo")
evolveLevel = programon.get("evolveLevel")
programon_creado = Programon(id, unique_id, moves, name, type, hp, speed, attack,
special_attack,defense, special_defense, level,
evolveLevel, evolveTo)
actualizar_numero_programones()
trainer_programones.append(programon_creado)
entrenador_i = Entrenador(trainer["name"], trainer_programones)
entrenadores.append(entrenador_i)
gimnasio = Gimnasio(nombre, id, lider, entrenadores)
guardar_info_gimnasio(gimnasio)
def cargar_jugador(nombre):
lista_jugadores = jsonToDict("jugadores.json")
for jugador in lista_jugadores:
if jugador["nombre"] == nombre:
nombre_jugador = nombre
password = jugador["password"]
id_jugador = jugador["id"]
dinero = jugador["dinero"]
ubicacion = jugador["ubicacion"]
prograbolas = jugador["prograbolas"]
PC = jugador["PC"]
batallas = []
batallas_aux = jugador["batallas"]
for batalla in batallas_aux:
victoria_i = batalla["victoria"]
tipo_i = batalla["tipo"]
if batalla.get("entrenador"):
entrenador = batalla.get("entrenador")
else:
entrenador = None
programones_enemigo = []
peleadores_enemigo = []
for i in range(len(batalla["programon_enemigo"])):
programon_enemigo = batalla["programon_enemigo"][i]
IV_enemigo = programon_enemigo["IV"]
EV_enemigo = programon_enemigo["EV"]
level_enemigo = programon_enemigo["level"]
nombre_enemigo = programon_enemigo["name"]
unique_id_enemigo = programon_enemigo["unique_id"]
if programon_enemigo["peleo"]:
peleadores_enemigo.append(programon_enemigo["unique_id"])
programones_lista = jsonToDict("programones.json")
for poke in programones_lista:
if poke["name"] == nombre_enemigo:
id = poke["id"]
moves = poke["moves"]
type = poke["type"]
hp = poke["hp"]
speed = poke["speed"]
attack = poke["attack"]
special_attack = poke["special_attack"]
defense = poke["defense"]
special_defense = poke["special_defense"]
evolveTo = poke.get("evolveTo")
evolveLevel = poke.get("evolveLevel")
enemigo_creado = Programon(id, unique_id_enemigo, moves, nombre_enemigo, type, hp, speed, attack,
special_attack, defense, special_defense, level_enemigo, evolveLevel,
evolveTo, IV_enemigo, EV_enemigo)
programones_enemigo.append(enemigo_creado)
equipo2 = []
peleadores = []
equipo_aux = batalla["equipo"]
for programon in equipo_aux:
IV_i = programon["IV"]
EV_i = programon["EV"]
level_i = programon["level"]
nombre_i = programon["name"]
unique_id_i = programon["unique_id"]
if programon["peleo"]:
peleadores.append(unique_id_i)
programones_lista = jsonToDict("programones.json")
for poke in programones_lista:
if poke["name"] == nombre_i:
id = poke["id"]
moves = poke["moves"]
type = poke["type"]
hp = poke["hp"]
speed = poke["speed"]
attack = poke["attack"]
special_attack = poke["special_attack"]
defense = poke["defense"]
special_defense = poke["special_defense"]
evolveTo = poke.get("evolveTo")
evolveLevel = poke.get("evolveLevel")
programon_creado = Programon(id, unique_id_i, moves, nombre_i, type, hp, speed, attack,
special_attack, defense, special_defense, level_i, evolveLevel,
evolveTo, IV_i, EV_i)
equipo2.append(programon_creado)
batalla_i = Batalla(victoria_i, tipo_i, programones_enemigo, equipo2, peleadores, entrenador,
peleadores_enemigo)
batallas.append(batalla_i)
progradex = Progradex()
aux = jugador["progradex"]
name_vistos = aux["vistos"]
name_atrapados = aux["atrapados"]
for i in name_vistos:
progradex.agregar_visto(i)
for i in name_atrapados:
progradex.agregar_atrapado(i)
gyms = jugador["gyms"]
nuevo_jugador = Jugador(nombre_jugador, password, id_jugador, ubicacion, progradex, PC, prograbolas,
batallas, dinero, gyms)
lista_programones_equipo = jugador["equipo"]
lista_programones_equipo2 = []
for programon in lista_programones_equipo:
unique_id = programon["unique_id"]
IV = programon["IV"]
level = programon["level"]
EV = programon["EV"]
nombre_programon = programon["name"]
programones = jsonToDict("programones.json")
for poke in programones:
if poke["name"] == nombre_programon:
id = poke["id"]
moves = poke["moves"]
type = poke["type"]
hp = poke["hp"]
speed = poke["speed"]
attack = poke["attack"]
special_attack = poke["special_attack"]
defense = poke["defense"]
special_defense = poke["special_defense"]
evolveTo = poke.get("evolveTo")
evolveLevel = poke.get("evolveLevel")
programon_creado = Programon(id, unique_id, moves, nombre_programon, type, hp, speed, attack,
special_attack, defense, special_defense, level, evolveLevel, evolveTo,
IV, EV)
lista_programones_equipo2.append(programon_creado)
for poke in lista_programones_equipo2:
nuevo_jugador.agregar_programon(poke)
return nuevo_jugador
