def conjuros_conocidos(clase, nv_cls, nv_cnj, conjuros, CLASES, CONJUROS,
ESCUELAS):
conocidos = []
elects = []
conjuros_nuevos = sort_conj_clase(CLASES[clase]['Abr'], nv_cnj, conjuros,
CONJUROS, ESCUELAS)
if 'Conjuros_Conocidos' in CLASES[clase]:
cantidad = CLASES[clase]['Conjuros_Conocidos'][str(nv_cls)][str(
nv_cnj)]
print('\nPuede elegir ' + str(cantidad) +
' conjuros, de entre los siguientes:\n')
elect = v.subselector('Conjuro', conjuros_nuevos, True, cantidad)
for i in elect:
elects.append(i)
else:
while True:
vueltas = ''
while vueltas == '':
vueltas = input('\n¿Cuantos conjuros desea agregar? ')
if not vueltas.isnumeric():
print('\nLa cantidad debe ser numérica.')
vueltas = ''
elif int(vueltas) > len(conjuros_nuevos):
print(
'\nNo puede seleccionar tantos conjuros. El máximo es '
+ str(len(conjuros_nuevos)) + '.')
vueltas = ''
else:
vueltas = int(vueltas)
if vueltas > 1:
elect = v.subselector('Conjuro', conjuros_nuevos, True,
vueltas)
for i in elect:
elects.append(i)
else:
elect = v.subselector('Conjuro', conjuros_nuevos, True)
elects.append(elect)
if not input('\n¿Desea agregar más conjuros? ').lower().startswith(
's'):
break
for index in elects:
for c in CONJUROS:
if CONJUROS[c]['Nombre'] == conjuros_nuevos[index]:
conocidos.append(c)
return conocidos
def equiparse(inventario, equipo):
nombres = []
equip = equipo.copy() # copia de trabajo
for item in inventario:
if item['subgrupo'] in ('armd', 'esc'):
nombres.append(
imprimir_nom_objmag(item, s.OBJMAG, s.ARMDS).rstrip(' '))
else:
nombres.append(
imprimir_nom_objmag(item, s.OBJMAG, s.ARMAS).rstrip(' '))
nombres.append('\nSalir')
while True:
ver_equipado(equip)
sel = subselector('Item', nombres)
if nombres[sel].lstrip('\n') == 'Salir':
break
else:
item = inventario[sel]
if item['grupo'] == 'armas':
item = equipar_obj(item, s.ARMAS)
elif item['grupo'] == 'armds':
item = equipar_obj(item, s.ARMDS)
else:
print('Este objeto no es equipable')
if equip[item['espacio']] == '':
equip[item['espacio']] = item
del nombres[sel], inventario[sel]
else:
print('Primero libere el espacio para equipar ese objeto')
return equip
def preferencias(prefs):
from func.core.viz import subselector
from func.core.lang import t, sel_idioma
from func.data.setup import data as d
from func.core.intro import imprimir_titulo
while True:
opciones = [
t('Cambiar idioma'),
t('Cambiar las advertencias'),
t('Cambiar el método de generación de características'),
t('Salir')
]
imprimir_titulo()
print(t('Menú: Preferencias'), t('Elije una opción'), sep='\n\n')
op = subselector(t('Opción'), opciones)
if op == 0:
global idioma
idioma = sel_idioma()
prefs['idioma'] = idioma
aplicar_idioma(idioma)
d.cambiar_idioma(idioma)
elif op == 1:
global advt
advt = not advt
prefs['advt'] = advt
elif op == 2:
global puntgen
puntgen = menu_puntuacion()
prefs['puntgen'] = puntgen
elif op == 3:
break
guardar_preferencias(prefs)
def menu():
while True:
opciones = [
t('Crear un nuevo personaje'),
t('Avanzar un personaje existente'),
t('Editar preferencias'),
t('Salir'), '\n' + t('Ver licencia')
]
intro.imprimir_titulo()
intro.introduccion()
print(t('Elije una opción'))
op = subselector(t('Opción'), opciones)
if op == 0: # Crear un nuevo Pj
import func.core.chargen
Pj.nuevo_pj()
func.core.chargen.go()
elif op == 1: # Avanzar un Pj existente
import func.core.chargen
Pj.cargar_pj(cargar_archivo('Personaje', 'Guardar'))
func.core.chargen.go()
elif op == 2: # preferencias
c.preferencias(c.abrir_json('config.json'))
elif op == 3: # exit
break
elif op == 4:
intro.licencia('LICENSE.txt')
input(t('\n[Presione Enter para continuar]\n'))
def menu_puntuacion():
from func.core.intro import imprimir_titulo
from func.core.viz import subselector
opciones = [
'Tiradas aleatorias', 'Compra de Puntos', 'Puntuaciones fijas', 'Salir'
]
while True:
imprimir_titulo()
print('Seleccione un método de generación de características')
print('\n¿Que desea hacer?')
op = subselector('Opción', opciones)
if op == 0:
ops = [('Tirada estándar', 'A2'),
('Tirada variable con repetición', 'A4'),
('Personaje orgánico', 'A3'),
('Personaje promedio a medida', 'A1'),
('Personaje promedio aleatorio', 'A0'),
('Personaje muy poderoso', 'A5')]
while True:
imprimir_titulo()
print('Seleccione el método aleatorio que desee')
op2 = ops[subselector('Opción', [i[0] for i in ops])][1]
break
elif op == 1:
ops = [('Campaña estándar', 'B0'), ('Campaña poco poderosa', 'B1'),
('Campaña desafiante', 'B2'), ('Campaña ardua', 'B3'),
('Campaña muy poderosa', 'B4')]
while True:
imprimir_titulo()
print('Seleccione el tipo de compra de puntos')
op2 = ops[subselector('Opción', [i[0] for i in ops])][1]
break
elif op == 2:
ops = [('Puntuaciones de élite', 'C0'),
('Punutaciones corrientes', 'C1'),
('Puntuaciones estándar', 'C2')]
while True:
imprimir_titulo()
print('Seleccione el tipo de puntuación que desea')
op2 = ops[subselector('Opción', [i[0] for i in ops])][1]
break
elif op == 3:
break
return op2
def tipo_r(ap, tipo, sub='', prompt=''):
if sub != '':
print('\n' + s.ATPS[ap]['Intro'])
elec = v.subselector(prompt, sub, dos_col=True)
apt = [str(ap), {'sub': str(elec)}, 'r' + tipo]
else:
apt = [str(ap), {}, 'r' + tipo]
return apt
def tipo_a(ap, sub='', prompt=''):
if sub != '':
print('\n' + s.APTS[ap]['Intro'])
elec = v.subselector(prompt, sub)
for d in s.DOTES:
if s.DOTES[d]['Nombre'] == sub[elec]:
dote = [d, {}, 'd']
else:
dote = [str(s.APTS[ap]['ID_dt']), {}, 'd']
return dote
def elegir_dotes(dotes, clase):
opciones = [
t('Elegir una nueva dote'),
t('Ver las dotes que ya se tienen'),
t('Ver una lista de las dotes elegibles'),
t('Ver información sobre una dote específica'),
t('Ver una lista de todas las dotes')
]
while True:
imprimir_titulo()
print(v.barra(p.CARS, s.alins[p.alini]['Abr'], p.raza['Nombre']))
print(t('Seleccione sus Dotes para este nivel'))
sublista = posicion(p.e_dts, clase, len(p.cla), s.CLASES, s.DOTES)
print('\n' + t('¿Que desea hacer?'))
op = v.subselector(t('Opción'), opciones)
if op == 0: # Elegir una nueva dote
if not any(p.e_dts.values()):
print('\n' + t('No se pueden elegir más dotes por el momento'))
else:
todas = AutoDot(sublista[0], p.competencias['Armas'],
p.conjuros, s.DOTES, s.ARMAS, s.HABS,
s.ESCUELAS)
posibles = GenerarListadeAyuda(todas, s.DOTES)
dote = SelDot(s.DOTES, posibles)
if dote != '':
p.agregar_dote(dote, sublista[1])
if not any(p.e_dts.values()):
opciones.append(t('Nada más'))
elif op == 1: # Ver las dotes que ya se tienen
if len(dotes) < 1:
print(t('No hay dotes elegidas de momento'))
else:
lista = ver_dotes(dotes, s.DOTES, s.ARMAS, s.HABS, s.ESCUELAS)
v.paginar_dos_columnas(15, lista)
elif op == 2: # Ver una lista de las dotes elegibles
if not any(p.e_dts.values()):
print('\n' + t('No se pueden elegir más dotes por el momento'))
else:
todas = AutoDot(sublista[0], p.competencias['Armas'],
p.conjuros, s.DOTES, s.ARMAS, s.HABS,
s.ESCUELAS)
posibles = GenerarListadeAyuda(todas, s.DOTES)
v.paginar_dos_columnas(
15, [s.DOTES[str(i)]['Nombre'] for i in posibles])
elif op == 3: # Ver información sobre una dote específica
print(info_dote(s.DOTES))
elif op == 4: # Ver una lista de todas las dotes
lista_de_dotes(s.DOTES)
elif op == 5:
break
input(t('\n[Presione Enter para continuar]\n'))
def u_w(dt, comp_armas, dotes_pj, ARMAS, nom, pre, des, DOTES):
print(DOTES[str(nom.index(dt))]['Intro'])
armas = []
for i in comp_armas:
i = str(i)
if str(nom.index(dt)) + ':' + i not in dotes_pj:
armas.append(ARMAS[i]['Nombre'])
armas.sort()
arma = v.subselector('Arma', armas, dos_col=True)
prinfo(dt, nom, pre, des)
dote = comprobacion(dt, nom, ARMAS, armas, arma)
return dote
def u_w2(dt, nom, pre, des, DOTES):
print(DOTES[str(nom.index(dt))]['Intro'])
subs = AutoDot(DOTES, [nom.index(dt)], p.compW, p.conjuros, s.ARMAS,
s.HABS, s.ESCUELAS)
armas = []
for ID in subs:
if validar_requisitos(ID, DOTES):
armas.append(int(ID.split(':')[1]))
arma = v.subselector('Arma', armas)
prinfo(dt, nom, pre, des)
dote = comprobacion(dt, nom, ARMAS, armas, arma)
return dote
def u_c(dt, INT_mod, cnj_pj, CONJUROS, nom, pre, des, DOTES):
print(DOTES[str(nom.index(dt))]['Intro'].format(str(INT_mod)))
subs = AutoDot(DOTES, [nom.index(dt)], p.compW, p.conjuros, s.ARMAS,
s.HABS, s.ESCUELAS)
conjs = []
for ID in subs:
if validar_requisitos(ID, DOTES):
conjs.append(CONJUROS[int(ID.split(':')[1])]['Nombre'])
cnj = v.subselector('Conjuro', conjs, vueltas=INT_mod)
prinfo(dt, nom, pre, des)
dote = comprobacion(dt, nom, CONJUROS, conjs, cnj)
return dote
def equipar_obj(obj, GRUPO):
if GRUPO[obj['index']]['Tipo'] == 'esc':
obj['espacio'] = 'mm'
elif GRUPO[obj['index']]['Tipo'] == 'armd':
obj['espacio'] = 'armd'
elif GRUPO[obj['index']]['Subtipo'] == 'dm':
obj['espacio'] = 'dm'
else:
ops = [('Mano buena', 'mb'), ('Mano mala', 'mm'), ('Dos manos', 'dm')]
op = subselector('Opción', [ops[i][0] for i in range(len(ops))])
obj['espacio'] = ops[op][1]
return obj
def u_h(dt, HABS, nom, pre, des, DOTES):
print(DOTES[str(nom.index(dt))]['Intro'])
subs = AutoDot([nom.index(dt)], p.compW, p.conjuros, DOTES, s.ARMAS, HABS,
s.ESCUELAS)
habs = []
for ID in subs:
if validar_requisitos(ID, s.DOTES):
habs.append(HABS[ID.split(':')[1]]['Nombre'])
hab = v.subselector('Habilidad', habs, True)
prinfo(dt, nom, pre, des)
dote = comprobacion(dt, nom, HABS, habs, hab)
return dote
def u_e2(dt, nom, pre, des, DOTES, ESCUELAS):
print(DOTES[str(nom.index(dt))]['Intro'])
subs = AutoDot([nom.index(dt)], p.compW, p.conjuros, DOTES, s.ARMAS,
s.HABS, ESCUELAS)
escuelas = []
for ID in subs:
if validar_requisitos(ID, DOTES):
escuelas.append(ESCUELAS[ID.split(':')[1]]["Nombre"])
esc = v.subselector('Escuela', escuelas)
prinfo(dt, nom, pre, des)
dote = comprobacion(dt, nom, ESCUELAS, escuelas, esc)
return dote
def u_e(dt, dotes_pj, ESCUELAS, nom, pre, des, DOTES):
print(DOTES[str(nom.index(dt))]['Intro'])
escuelas = []
for i in range(len(ESCUELAS)):
if str(nom.index(dt)) + ':' + str(i) not in dotes_pj:
if not ESCUELAS[str(i)]["Nombre"] == 'Universal':
escuelas.append(ESCUELAS[str(i)]["Nombre"])
esc = v.subselector('Escuela', escuelas, dos_col=True)
prinfo(dt, nom, pre, des)
dote = comprobacion(dt, nom, ESCUELAS, escuelas, esc)
return dote
def tipo_v(ap, sub='', prompt=''):
if sub != '':
print('\n' + s.APTS[ap]['Intro'])
elec = v.subselector(prompt, sub, dos_col=True)
apt = [
str(ap), {
'sub': str(elec),
'In_Val': s.APTS[ap]['Valor_Inicial']
}, 'c'
]
else:
apt = [str(ap), {'cant': s.APTS[ap]['Valor_Inicial']}, 'c']
return apt
def cargar_archivo(prompt, carpeta):
from func.data.setup import data as s
ars, nom = [], []
for ar in os.listdir(carpeta):
if os.path.isfile(carpeta + '/' + ar):
personaje = c.abrir_json(carpeta + '/' + ar)
nom.append(personaje['nombre'] + ' (' +
imprimir_clases(personaje['cla'], s.CLASES) + ')')
ars.append(ar)
sel = subselector(prompt, nom, True)
data = c.abrir_json(carpeta + '/' + ars[sel])
return data
def u_m(dt, comp_armas, dotes_pj, nom, pre, des, ARMAS, DOTES):
print(DOTES[str(nom.index(dt))]['Intro'])
armas = []
for i in range(len(ARMAS)):
i = str(i)
if ARMAS[i]['Competencia'] == nom.index(dt):
if i not in comp_armas:
if str(nom.index(dt)) + ':' + i not in dotes_pj:
armas.append(ARMAS[i]['Nombre'])
arma = v.subselector('Arma', armas, dos_col=True)
prinfo(dt, nom, pre, des)
dote = comprobacion(dt, nom, ARMAS, armas, arma)
return dote
def generar_tiradas(metodo):
''''Genera las 6 tiradas segun el método elegido'''
Tirs = []
total = 0
if metodo in (0,1):
while total <= 0:
for i in range(6):
Tirs.append(sum(UnaTir(3)))
total += CarMod(Tirs[i])
if total >0:
break
else:
total = 0
Tirs = []
elif metodo in (2,3):
for i in range(6):
Tirs.append(sum(UnaTir(4,1)))
elif metodo == 4:
tirs = []
tirsp = []
for i in range(6):
t = UnaTir(4)
tirs.append(t)
tirsp.append(','.join([str(i) for i in t]))
lineas = []
for i in range(len(tirs)):
lineas.append('el '+str(tirs[i][-1])+' de la '+str(i+1)+'º tirada ('+tirsp[i]+': '+str(sum(tirs[i][0:-1]))+')')
print ('¿que valor desea retirar?')
op = subselector('Opción',lineas,True)
tirs[op] = retirar(tirs[op])
for t in range(len(tirs)):
del tirs[t][-1]
Tirs.append(sum(tirs[t]))
elif metodo == 5:
for i in range(6):
Tirs.append(sum(UnaTir(5,2)))
Tirs.sort(reverse=True)
return Tirs
def comprar_equipo(clase):
compras = []
opciones = [
'Comprar armas y munición', 'Comprar armaduras y escudos',
'Comprar equipo de aventura',
'Ver las propiedades de un objeto, arma o armadura',
'Ver los objetos poseídos', 'Devolver objetos comprados'
]
dinero = riqueza(clase, s.CLASES, len(p.cla))
while True:
imprimir_titulo()
print(barra(p.CARS, s.alins[p.alini]['Abr'], p.raza['Nombre']))
print('\nTienes ' + unificar_precio(convertir_precio(dinero)) +
' para gastar')
op = subselector('Opción', opciones)
if op == 0: # Comprar armas y munición
nuevas = comprar(dinero, s.ARMAS, 'armas')
compras += nuevas
subtotal = 0
for i in nuevas:
dinero -= calcular_precio(i, s.ARMAS, s.OBJMAG)
if 'Nada más' not in opciones: opciones.append('Nada más')
elif op == 1: # Comprar armaduras y escudos
nuevas = comprar(dinero, s.ARMDS, 'armds')
compras += nuevas
subtotal = 0
for i in nuevas:
dinero -= calcular_precio(i, s.ARMDS, s.OBJMAG)
if 'Nada más' not in opciones: opciones.append('Nada más')
elif op == 2: # Comprar objetos varios
print('Opción aún no disponible')
# compras['Otros'] += comprar(dinero,Otros)
#if 'Nada más' not in opciones: opciones.append('Nada más')
elif op == 3: # Ver las estadísticas de un objeto, arma o armadura
print('Opción aún no disponible')
elif op == 4: # Ver los objetos poseídos
print('Opción aún no disponible')
elif op == 5: # Devolver objetos comprados
print('Opción aún no disponible')
elif op == 6: # Nada más
return compras, dinero
def nuevos_idiomas(IDIOMAS, idi_pj, pool):
lista = []
for i in idi_pj:
lista.append(IDIOMAS[i])
print('Sus idiomas actuales son: ' + ', '.join(lista) + '.' +
'\nPuede elegir ' + str(pool) +
' idiomas nuevos, de entre los siguientes:\n')
posibles = []
for i in range(len(IDIOMAS)):
if i not in idi_pj:
posibles.append(IDIOMAS[i])
sels = v.subselector('Idioma', posibles, dos_col=True, vueltas=pool)
if type(sels) == list:
for i in sels:
idi_pj.append(IDIOMAS.index(posibles[i]))
else:
idi_pj.append(IDIOMAS.index(posibles[sels]))
idi_pj.sort()
return idi_pj
def elegir_aumento_de_caracteristica (nivel,Cars):
nom = [Cars[i]['Nom'] for i in range(len(Cars))]
while True:
imprimir_titulo()
print ('\nEn el '+str(nivel)+'º nivel, tienes un aumento de características')
print (t('Selecciona la característica que quieres aumentar'))
car = subselector('Característica',nom)
if car.isnumeric():
Car = Cars[car]['Abr']
else:
car = probar_input(Car,nom)
if car == '':
print (t('La característica es inválida o inexistente'))
else:
car = nom.index(car)
Car = Cars[car]['Abr']
p.aumentar_caracteristicas(Car)
print ('El personaje tiene ahora '+d.Cars[car]['Nom']+
' '+str(p.CARS[Car]['Punt'])+' (+'+str(p.CARS[Car]['M'])+')')
def idiomas_iniciales(IDIOMAS, Clase, Raza, pool):
lang = [IDIOMAS[str(i)]['Nombre'] for i in range(len(IDIOMAS))]
autos = []
adics = []
nom = Clase['Nombre']
for i in Raza['Idioma_auto']:
autos.append(lang[i])
for i in Raza['Idioma_adic']:
adics.append(lang[i])
if 'Idiomas' in Clase:
idi_clas = Clase['Idiomas']
for i in idi_clas:
if lang[i] not in adics:
adics.append(lang[i])
print('\n' + t('Los idiomas automáticos de tu raza son: ') +
','.join(autos) + '.')
idiomas = []
if pool > 0:
print('\n' + t('Además, tu personaje puede conocer ') + str(pool) +
t(' idiomas adicionales') + '.\n' +
t('Eligelos de la siguiente lista:'))
elecs = subselector(t('Idioma'), adics, dos_col=True, vueltas=pool)
if type(elecs) == list:
for i in elecs:
idiomas.append(lang.index(adics[i]))
else:
idiomas.append(lang.index(adics[elecs]))
for i in autos:
idiomas.append(lang.index(i))
idiomas.sort()
input(t('\n[Presione Enter para continuar]\n'))
return idiomas
def elegir_dominio(alini, cant, DOMINIOS):
'''Provee un selector para los dominios de clérigo'''
imprimir_titulo()
disponibles = []
for i in DOMINIOS:
if 'Req_AL' in DOMINIOS[i]:
if alini in DOMINIOS[i]['Req_AL']:
disponibles.append(DOMINIOS[i]['Nombre'])
else:
disponibles.append(DOMINIOS[i]['Nombre'])
disponibles.sort()
print('Debes elegir ' + str(cant) + ' dominios de entre los siguientes:')
elect = v.subselector('Dominio', disponibles, True, cant)
keys = []
for i in elect:
for key in DOMINIOS:
if disponibles[i] == DOMINIOS[key]['Nombre']:
keys.append(key)
return keys
def elegir_conjuros(clase, nv_cls, conjuros, CLASES, CONJUROS, ESCUELAS):
'''Selección de conjuros.'''
def nivel_conjuro():
nv_cnj = ''
while nv_cnj == '':
nv_cnj = input('\nElija un nivel de conjuros [0 - 9]: ')
if not nv_cnj.isnumeric():
print('\nEl nivel de conjuros debe ser numérico.')
nv_cnj = ''
elif not 0 <= int(nv_cnj) <= 9:
print('\nEl nivel de conjuros debe ser un número entre 0 y 9')
nv_cnj = ''
else:
nv_cnj = int(nv_cnj)
return nv_cnj
opciones = [
'Elegir nuevos conjuros conocidos', 'Preparar un set de conjuros',
'Ver los conjuros de clase disponibles',
'Ver la información de un conjuro específico',
'Ver los conjuros conocidos',
'Ver todos los conjuros de una escuela de magia'
]
op = ''
while op == '':
imprimir_titulo()
print('En este nivel, debe elegir conjuros', end='\n\n')
print('¿Que desea hacer?\n')
op = v.subselector('Opción', opciones)
if op == 0: # Elegir nuevos conjuros conocidos
nv_cnj = nivel_conjuro()
conjuros += conjuros_conocidos(clase, nv_cls, nv_cnj, conjuros,
CLASES, CONJUROS, ESCUELAS)
opciones.append('Nada más')
op = ''
elif op == 1: # Preparar un set de conjuros
print('\nEsta opción aún no se encuentra en funcionamiento')
elif op == 2: # Ver los conjuros de clase disponibles
nv_cnj = nivel_conjuro()
v.paginar_dos_columnas(
10,
(sort_conj_clase(clase, nv_cnj, conjuros, CONJUROS, ESCUELAS)))
elif op == 3: # Ver la información de un conjuro específico
print('\n' + info_conjuro(CONJUROS, ESCUELAS))
elif op == 4: # Ver los conjuros conocidos
if len(conjuros) == 0:
print('\nNo hay conjuros que mostrar aún.')
else:
lineas = [CONJUROS[i]['Nombre'] for i in conjuros]
v.paginar_dos_columnas(10, lineas)
elif op == 5: # Ver todos los conjuros de una escuela de magia
print('\nElija una escuela de magia')
escuelas = [ESCUELAS[i]['Nombre'] for i in range(len(ESCUELAS))]
esc = v.subselector('Escuela', escuelas)
v.paginar_dos_columnas(
10, (sort_conj_escuela(esc, CONJUROS, ESCUELAS)))
op = ''
elif op == 6: # Nada más
return sorted(conjuros)
input('\n[Presione Enter para continuar]')
def objeto_magico(obj, subgrupo, GRUPO, OBJMAG):
objeto = {}
objeto['index'] = obj
objeto['subgrupo'] = subgrupo
if subgrupo in ('cc', 'ad'):
objeto['grupo'] = 'armas'
elif subgrupo in ('armd', 'esc'):
objeto['grupo'] = 'armds'
op1 = ['Gran Calidad', 'Mágico']
while True:
imprimir_titulo()
print(barra(p.CARS, s.alins[p.alini]['Abr'], p.raza['Nombre']))
print(GRUPO[str(obj)]['Nombre'])
op = subselector('Tipo', op1)
if op == 0:
objeto['gc'] = True
objeto['bon'] = 0
objeto['apts'] = []
elif op == 1:
objeto['gc'] = True
while True:
bon = input('\nBonificador de mejora: ')
try:
bon = int(bon)
except ValueError:
print('El bonificador de mejora debe ser numerico')
finally:
bon = int(bon)
if bon > 5:
print(
'No se puede tener un bonificador de mejora mayor a 5'
)
if bon < 1:
print(
'El bonificador de mejora debe ser al menos de +1')
else:
objeto['bon'] = bon
break
if input('\n¿Desea agregar aptitudes especiales a este objeto? '
).lower().startswith('s'):
os.system(['clear', 'cls'][os.name == 'nt'])
objeto['apts'] = []
op2, nom = [], []
for i in range(len(OBJMAG)):
i = str(i)
nom.append(OBJMAG[i]['Nombre'])
if subgrupo in OBJMAG[i]['Subgrupo']:
op2.append(nom[i])
copia = op2 * 1
while bon < 10:
print('\nEl bonificador de mejora actual es de +' +
str(bon))
imprimir_nom_objmag(objeto, OBJMAG, GRUPO)
op = subselector('Aptitud', op2, True)
for i in range(len(nom)):
if op2[op] == nom[i]:
sel = i
if not OBJMAG[sel]['Precio'].isnumeric():
bon += int(OBJMAG[sel]['Precio'].split('+')[1])
del op2[op]
if 'Sublista' in OBJMAG[sel]:
print(OBJMAG[sel]['Intro'])
opsel = subselector(OBJMAG[sel]['Sub_sel'],
OBJMAG[sel]['Sublista'], True)
objeto['apts'].append(str(sel) + ':' + str(opsel))
else:
objeto['apts'].append(str(sel))
if not input('Desea continuar? ').lower().startswith('s'):
break
else:
objeto['apts'] = []
os.system(['clear', 'cls'][os.name == 'nt'])
return objeto
def elegir_habs(rangos, clase, nivel, HABS):
'''Proporciona un más completo selector de habilidades.'''
opciones = [
t('Maximizar/actualizar habilidades'),
t('Repartir rango por rango'),
t('Ver las habilidades que tienen rangos'),
t('Ver las habilidades que no tienen rangos'),
t('Ver las habilidades de clase'),
t('Ver una lista de todas las habilidades')
]
op = ''
hab_rng = rangos
while op == '':
imprimir_titulo()
print(v.barra(p.CARS, s.alins[p.alini]['Abr'], p.raza['Nombre']))
print(t('Seleccione sus Habiliades para este nivel'), end='\n\n')
print(t('¿Que desea hacer?'))
op = v.subselector(t('Opción'), opciones)
print()
if op == 0: # Maximizar/actualizar habilidades
if t('Nada más') in opciones:
print('\n' + t(
'Ya has repartido todos los rangos de habilidad disponibles.'
) + '\n')
else:
puntos = PuntHab(s.CLASES, clase, nivel, p.CARS['INT']['Mod'],
p.subtipo, True)
hab_cla = Claseas(s.CLASES, clase, HABS)
if nivel == 1:
act = maximizar_habs(puntos, p.cla.count(clase), hab_cla,
HABS)
hab_rng = act[0]
restante = act[1]
else:
act = actualizar_habs_max(hab_rng, p.cla.count(clase),
hab_cla, puntos, HABS)
hab_rng = act[0]
restante = act[1]
if restante == 0:
opciones.append(t('Nada más'))
else:
print('Se han repatido ' + str(puntos - restante) +
' puntos. Quedan ' + str(restante) + ' puntos.')
elif op == 1: # Repartir rango por rango
if t('Nada más') in opciones:
print('\n' + t(
'Ya has repartido todos los rangos de habilidad disponibles.'
) + '\n')
else:
hab_cla = Claseas(s.CLASES, clase, s.HABS)
puntos = PuntHab(lista_de_clases, clase, nivel,
p.CARS['INT']['Mod'], p.subtipo)
hab_rng = repartir_rangos(puntos, p.cla.count(clase), hab_cla,
HABS, hab_rng)
if puntos <= 0:
opciones.append(t('Nada más'))
elif op == 2: # Ver las habilidades que tienen rangos
lineas = v.a_dos_columnas(HabcR(hab_rng, HABS))
if len(lineas) == 0:
print('\n' +
t('Ninguna habilidad tiene rangos por el momento'))
else:
for i in lineas:
print(i)
elif op == 3: # Ver las habilidades que no tienen rangos
for i in v.a_dos_columnas(HabcR(hab_rng, HABS, inverso=True)):
print(i)
elif op == 4: # Ver las habilidades de clase
for i in v.a_dos_columnas(Claseas(s.CLASES, clase, s.HABS)):
print(i)
elif op == 5: # Ver una lista de todas las habilidades
habs = [HABS[str(i)]['Nombre'] for i in range(len(s.HABS))]
for i in v.a_dos_columnas(habs):
print(i)
elif op == 6: ## Nada más ##
return hab_rng
op = ''
input(t('\n[Presione Enter para continuar]\n'))
def comprar(dinero, objetos, grupo):
# crea dos listas, filtrando los objetos que no tienen precio
nom = [
objetos[str(i)]['Nombre'] for i in range(len(objetos))
if 'Precio' in objetos[str(i)]
]
pre = [
objetos[str(i)]['Precio'] for i in range(len(objetos))
if 'Precio' in objetos[str(i)]
]
compras = []
while dinero > 0:
imprimir_titulo()
print(barra(p.CARS, s.alins[p.alini]['Abr'], p.raza['Nombre']))
print('\nTe quedan ' + unificar_precio(convertir_precio(dinero)) +
' para gastar')
op = str(subselector('Objeto', nom, dos_col=True))
if input('Deseas una versión mágica/de gran calidad de este objeto? '
).lower().startswith('s'):
if objetos[op]['Tipo'] in ('cc', 'ad'):
obj = objeto_magico(op, objetos[op]['Tipo'], s.ARMAS, s.OBJMAG)
precio = calcular_precio(obj, s.ARMAS, s.OBJMAG)
elif objetos[op]['Tipo'] in ('armd', 'esc'):
obj = objeto_magico(op, objetos[op]['Tipo'], s.ARMDS, s.OBJMAG)
precio = calcular_precio(obj, s.ARMDS, s.OBJMAG)
costo = unificar_precio(convertir_precio(precio))
else:
costo = unificar_precio(convertir_precio(pre[int(op)]))
precio = pre[int(op)]
if objetos[op]['Tipo'] in ('cc', 'ad'): grupo = 'armas'
elif objetos[op]['Tipo'] in ('armd', 'esc'): grupo = 'armds'
obj = {
'index': op,
'grupo': grupo,
'subgrupo': objetos[op]['Tipo'],
'gc': False,
'bon': 0,
'apts': []
}
imprimir_titulo()
print(barra(p.CARS, s.alins[p.alini]['Abr'], p.raza['Nombre']))
print('\nTe quedan ' + unificar_precio(convertir_precio(dinero)) +
' para gastar',
'\n' + imprimir_nom_objmag(obj, s.OBJMAG, objetos),
'\nEste objeto cuesta ' + costo + '.',
sep='\n\n')
if precio > dinero:
print('\nNecesitas más riqueza para poder pagarlo.')
else:
if input('\nEstas seguro de querer adquirirlo? ').lower(
).startswith('s'):
compras.append(obj)
dinero -= precio
if not input('\n¿Deseas continuar comprando? ').lower().startswith(
's'):
return compras
