SHARE
TWEET

Untitled

a guest Dec 12th, 2019 71 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. # librerías que vamos a usar
  2. import random
  3.  
  4.  
  5. # creamos la función que usaremos para imprimir
  6. def imprimir(diccionario: dict):
  7.     # SI introducimos los valores del diccionario, los separamos de forma que:
  8.     lista_valores = list(diccionario.values())
  9.     for i in range(len(lista_valores)):
  10.         if lista_valores[i] == 0:
  11.             lista_valores[i] = ' '
  12.     print('''
  13.         _____________________________
  14.         |{:>7}{:>7}{:>7}{:>7}
  15.         |{:^6}{}{:^6}{}{:^6}{}{:^6}{}
  16.         |______|______|______|______|
  17.         |{:>7}{:>7}{:>7}{:>7}
  18.         |{:^6}{}{:^6}{}{:^6}{}{:^6}{}
  19.         |______|______|______|______|
  20.         |{:>7}{:>7}{:>7}{:>7}
  21.         |{:^6}{}{:^6}{}{:^6}{}{:^6}{}
  22.         |______|______|______|______|
  23.         |{:>7}{:>7}{:>7}{:>7}
  24.         |{:^6}{}{:^6}{}{:^6}{}{:^6}{}
  25.         |______|______|______|______|
  26.         '''.format(
  27.             '|', '|', '|', '|',
  28.             lista_valores[0], '|', lista_valores[1], '|', lista_valores[2], '|', lista_valores[3], '|',
  29.             '|', '|', '|', '|',
  30.             lista_valores[4], '|', lista_valores[5], '|', lista_valores[6], '|', lista_valores[7], '|',
  31.             '|', '|', '|', '|',
  32.             lista_valores[8], '|', lista_valores[9], '|', lista_valores[10], '|', lista_valores[11], '|',
  33.             '|', '|', '|', '|',
  34.             lista_valores[12], '|', lista_valores[13], '|', lista_valores[14], '|', lista_valores[15], '|'))
  35.  
  36. # creamos una función que nos escogerá un índice al azar donde colocar los valores al azar
  37. def posicion_azar(diccionario: dict):
  38.     opciones = []
  39.     for items in list(diccionario.keys()):
  40.         if diccionario[items] == 0:
  41.             opciones.append(items)
  42.     azar = random.choice(opciones)
  43.     return azar
  44.  
  45. # creamos una función que nos devuelve un valor al azar
  46. def valor_azar():
  47.     azar = random.randrange(2, 5, 2)
  48.     return(azar)
  49.  
  50. # tenemos esta función que solo utilizaremos al final para comprobar si hemos perdido
  51. def comprobacion_derrota(diccionario: dict) -> bool:
  52.     lista_valores = list(diccionario.values())
  53.  
  54.     for items in lista_valores:
  55.         lista_valores.remove(items)
  56.         if items in lista_valores:
  57.             return False
  58.  
  59. # creamos un diccionario donde iremos almacenando todos los valores del juego:
  60. valores = {'a1': 0, 'a2': 0, 'a3': 0, 'a4': 0, 'b1': 0, 'b2': 0, 'b3': 0, 'b4': 0, 'c1': 0, 'c2': 0, 'c3': 0, 'c4': 0, 'd1': 0, 'd2': 0, 'd3': 0, 'd4': 0}
  61.  
  62.  
  63. # damos por sentado que no perdemos antes de empezar:
  64. perder = False
  65.  
  66. # hasta que no perdamos no pararemos de ejecutar el código:
  67. while not perder:
  68.  
  69.     # lo primero que debemos hacer es comprobar si estamos empezando la partida (por lo que tendríamos que generar 2 valores aleatorios
  70.     # para empezar) o simplemente seguimos jugando
  71.     # Para ello, lo que haremos será sumar todos los valores de la partida, y si son 0, es que aún no hay fichas en juego
  72.  
  73.     suma_inicio = 0
  74.     for v in valores.values():
  75.         suma_inicio += int(v)
  76.  
  77.     # Comparamos ahora el resultado para obtener una conclusión
  78.     if suma_inicio == 0:
  79.  
  80.         # Llamamos a las funciones que hemos creado anteriormente con la finalidad de crear valores
  81.         valores[posicion_azar(valores)] = valor_azar()
  82.         valores[posicion_azar(valores)] = valor_azar()
  83.        
  84.  
  85.     imprimir(valores)
  86.  
  87.  
  88.     # empezamos a jugar; los movimientos posibles son w(arriba) a(izquierda) d(derecha) s(abajo)
  89.     # la variable que utilizaremos para registrar los movimientos sera 'movimiento'
  90.     moviemiento = ' '
  91.     while moviemiento not in ['w', 'W', 'a', 'A', 's', 'S', 'd', 'D']:
  92.         moviemiento = input('Introduzca su moviemiento')
  93.    
  94.     # aquí empezamos a jugar
  95.     if moviemiento in ['w', 'W']:
  96.         # movemos hacia arriba
  97.         ###################################
  98.         # Casos en los que se acumula en A1:
  99.         ###################################
  100.         # a1 = 0, b1 = algo, c1= cualquiera, d1= cualquiera
  101.         if valores['a1'] == 0 and valores['b1'] != 0:
  102.             if valores['b1'] == valores['c1']:
  103.                 valores['a1'] = valores['b1'] + valores['c1']
  104.                 valores['b1'] = valores['d1']
  105.                 valores['c1'] = 0
  106.                 valores['d1'] = 0
  107.             else:
  108.                 valores['a1'] = valores['b1']
  109.                 if valores['c1'] == valores['d1'] or valores['c1'] == 0:
  110.                     valores['b1'] = valores['c1'] + valores['d1']
  111.                     valores['c1'] = 0
  112.                     valores['d1'] = 0
  113.                 else:                  
  114.                     valores['b1'] = valores['c1']
  115.                     valores['c1'] = valores['d1']
  116.                     valores['d1'] = 0
  117.  
  118.         # a1 = 0, b1 = 0, c1 = algo, d1 =  cualquier cosa
  119.         elif valores['a1'] == 0 and valores['b1'] == 0 and valores['c1'] != 0:
  120.             if valores['c1'] == valores['d1']:
  121.                 valores['a1'] = valores['c1'] + valores['d1']
  122.                 valores['b1'] = 0
  123.                 valores['c1'] = 0
  124.                 valores['d1'] = 0
  125.             else:
  126.                 valores['a1'] = valores['c1']
  127.                 valores['b1'] = valores['d1']
  128.                 valores['c1'] = 0
  129.                 valores['d1'] = 0
  130.  
  131.         # a1 = 0, b1 = 0, c1 = 0, d1 = cualquier cosa
  132.         elif valores['a1'] == 0 and valores['b1'] == 0 and valores['c1'] == 0 and valores['d1'] != 0:
  133.             valores['a1'] = valores['d1']
  134.             valores['d1'] = 0
  135.  
  136.         # casos en los que a vale algo
  137.         #
  138.        
  139.             # a1 = b1 (es decir, se suman)
  140.         elif valores['a1'] == valores['b1']:
  141.                 # además coinciden c1 y d1, por lo que se suman también
  142.             if valores['c1'] == valores['d1']:
  143.                 valores['a1'] = valores['a1'] + valores['b1']
  144.                 valores['b1'] = valores['c1'] + valores['d1']
  145.                 valores['c1'] = 0
  146.                 valores['d1'] = 0
  147.                 # no coinciden, asi que solo se ordenan
  148.             else:
  149.                 valores['a1'] = valores['a1'] + valores['b1']
  150.                 valores['b1'] = valores['c1']
  151.                 valores['c1'] = valores['d1']
  152.                 valores['d1'] = 0
  153.             # casos en los que a1  y b1 son distintos de 0, pero no son iguales, por lo que b puede sumar con c o con d
  154.         elif valores['b1'] != 0:
  155.                 #casos en los que c1 es cero, por lo que d se acumula si es dintinto de b
  156.             if valores['c1'] == 0:
  157.                 if valores['b1'] == valores['d1']:
  158.                     valores['b1'] = valores['b1'] + valores['d1']
  159.                     valores['d1'] = 0
  160.                 else:
  161.                     valores['c1'] = valores['d1']
  162.                     valores['d1'] = 0
  163.  
  164.                 # casos en los que c es dinstinto de 0
  165.             else:
  166.                 if valores['b1'] == valores['c1']:
  167.                         valores['b1'] = valores['b1'] + valores['c1']
  168.                         valores['c1'] = valores['d1']
  169.                         valores['d1'] = 0
  170.                 else:
  171.                     if valores['c1'] == valores['d1']:
  172.                         valores['c1'] = valores['c1'] + valores['d1']
  173.                         valores['d1'] = 0
  174.             # casos en los que b es 0 siendo a diferente de 0, hay que comprobar si c es cero tambien
  175.            
  176.         elif valores['c1'] == 0:
  177.             if valores['d1'] == valores['a1']:
  178.                 valores['a1'] = valores['a1'] + valores['d1']
  179.                 valores['d1'] = 0
  180.             else:
  181.                 valores['b1'] = valores['d1']
  182.                 valores['d1'] = 0
  183.                
  184.         elif valores['a1'] == valores['c1']:
  185.             valores['a1'] = valores['a1'] + valores['c1']
  186.             valores['b1'] = valores['d1']
  187.             valores['c1'] = 0
  188.             valores['d1'] = 0
  189.  
  190.         elif valores['c1'] == valores['d1']:
  191.             valores['b1'] = valores['c1'] + valores['d1']
  192.             valores['c1'] = 0
  193.             valores['d1'] = 0
  194.  
  195.         elif valores['c1'] != valores['d1']:
  196.             valores['b1'] = valores['c1']
  197.             valores['c1'] = valores['d1']
  198.             valores['d1'] = 0
  199.         ##############################
  200.         # Casos columna 2
  201.         ##############################
  202.         if valores['a2'] == 0 and valores['b2'] != 0:
  203.             if valores['b2'] == valores['c2']:
  204.                 valores['a2'] = valores['b2'] + valores['c2']
  205.                 valores['b2'] = valores['d2']
  206.                 valores['c2'] = 0
  207.                 valores['d2'] = 0
  208.             else:
  209.                 valores['a2'] = valores['b2']
  210.                 if valores['c2'] == valores['d2'] or valores['c2'] == 0:
  211.                     valores['b2'] = valores['c2'] + valores['d2']
  212.                     valores['c2'] = 0
  213.                     valores['d2'] = 0
  214.                 else:                  
  215.                     valores['b2'] = valores['c2']
  216.                     valores['c2'] = valores['d2']
  217.                     valores['d2'] = 0
  218.  
  219.         # a2 = 0, b2 = 0, c2 = algo, d2 =  cualquier cosa
  220.         elif valores['a2'] == 0 and valores['b2'] == 0 and valores['c2'] != 0:
  221.             if valores['c2'] == valores['d2']:
  222.                 valores['a2'] = valores['c2'] + valores['d2']
  223.                 valores['b2'] = 0
  224.                 valores['c2'] = 0
  225.                 valores['d2'] = 0
  226.             else:
  227.                 valores['a2'] = valores['c2']
  228.                 valores['b2'] = valores['d2']
  229.                 valores['c2'] = 0
  230.                 valores['d2'] = 0
  231.  
  232.         # a2 = 0, b2 = 0, c2 = 0, d2 = cualquier cosa
  233.         elif valores['a2'] == 0 and valores['b2'] == 0 and valores['c2'] == 0 and valores['d2'] != 0:
  234.             valores['a2'] = valores['d2']
  235.             valores['d2'] = 0
  236.  
  237.         # casos en los que a vale algo
  238.         #
  239.        
  240.             # a2 = b2 (es decir, se suman)
  241.         elif valores['a2'] == valores['b2']:
  242.                 # además coinciden c2 y d2, por lo que se suman también
  243.             if valores['c2'] == valores['d2']:
  244.                 valores['a2'] = valores['a2'] + valores['b2']
  245.                 valores['b2'] = valores['c2'] + valores['d2']
  246.                 valores['c2'] = 0
  247.                 valores['d2'] = 0
  248.                 # no coinciden, asi que solo se ordenan
  249.             else:
  250.                 valores['a2'] = valores['a2'] + valores['b2']
  251.                 valores['b2'] = valores['c2']
  252.                 valores['c2'] = valores['d2']
  253.                 valores['d2'] = 0
  254.             # casos en los que a2  y b2 son distintos de 0, pero no son iguales, por lo que b puede sumar con c o con d
  255.         elif valores['b2'] != 0:
  256.                 #casos en los que c2 es cero, por lo que d se acumula si es dintinto de b
  257.             if valores['c2'] == 0:
  258.                 if valores['b2'] == valores['d2']:
  259.                     valores['b2'] = valores['b2'] + valores['d2']
  260.                     valores['d2'] = 0
  261.                 else:
  262.                     valores['c2'] = valores['d2']
  263.                     valores['d2'] = 0
  264.  
  265.                 # casos en los que c es dinstinto de 0
  266.             else:
  267.                 if valores['b2'] == valores['c2']:
  268.                         valores['b2'] = valores['b2'] + valores['c2']
  269.                         valores['c2'] = valores['d2']
  270.                         valores['d2'] = 0
  271.                 else:
  272.                     if valores['c2'] == valores['d2']:
  273.                         valores['c2'] = valores['c2'] + valores['d2']
  274.                         valores['d2'] = 0
  275.             # casos en los que b es 0 siendo a diferente de 0, hay que comprobar si c es cero tambien
  276.            
  277.         elif valores['c2'] == 0:
  278.             if valores['d2'] == valores['a2']:
  279.                 valores['a2'] = valores['a2'] + valores['d2']
  280.                 valores['d2'] = 0
  281.             else:
  282.                 valores['b2'] = valores['d2']
  283.                 valores['d2'] = 0
  284.                
  285.         elif valores['a2'] == valores['c2']:
  286.             valores['a2'] = valores['a2'] + valores['c2']
  287.             valores['b2'] = valores['d2']
  288.             valores['c2'] = 0
  289.             valores['d2'] = 0
  290.  
  291.         elif valores['c2'] == valores['d2']:
  292.             valores['b2'] = valores['c2'] + valores['d2']
  293.             valores['c2'] = 0
  294.             valores['d2'] = 0
  295.  
  296.         elif valores['c2'] != valores['d2']:
  297.             valores['b2'] = valores['c2']
  298.             valores['c2'] = valores['d2']
  299.             valores['d2'] = 0
  300.                
  301.         ####################
  302.         # Columna 3
  303.         ####################
  304.         if valores['a3'] == 0 and valores['b3'] != 0:
  305.             if valores['b3'] == valores['c3']:
  306.                 valores['a3'] = valores['b3'] + valores['c3']
  307.                 valores['b3'] = valores['d3']
  308.                 valores['c3'] = 0
  309.                 valores['d3'] = 0
  310.             else:
  311.                 valores['a3'] = valores['b3']
  312.                 if valores['c3'] == valores['d3'] or valores['c3'] == 0:
  313.                     valores['b3'] = valores['c3'] + valores['d3']
  314.                     valores['c3'] = 0
  315.                     valores['d3'] = 0
  316.                 else:                  
  317.                     valores['b3'] = valores['c3']
  318.                     valores['c3'] = valores['d3']
  319.                     valores['d3'] = 0
  320.  
  321.         # a3 = 0, b3 = 0, c3 = algo, d3 =  cualquier cosa
  322.         elif valores['a3'] == 0 and valores['b3'] == 0 and valores['c3'] != 0:
  323.             if valores['c3'] == valores['d3']:
  324.                 valores['a3'] = valores['c3'] + valores['d3']
  325.                 valores['b3'] = 0
  326.                 valores['c3'] = 0
  327.                 valores['d3'] = 0
  328.             else:
  329.                 valores['a3'] = valores['c3']
  330.                 valores['b3'] = valores['d3']
  331.                 valores['c3'] = 0
  332.                 valores['d3'] = 0
  333.  
  334.         # a3 = 0, b3 = 0, c3 = 0, d3 = cualquier cosa
  335.         elif valores['a3'] == 0 and valores['b3'] == 0 and valores['c3'] == 0 and valores['d3'] != 0:
  336.             valores['a3'] = valores['d3']
  337.             valores['d3'] = 0
  338.  
  339.         # casos en los que a vale algo
  340.         #
  341.        
  342.             # a3 = b3 (es decir, se suman)
  343.         elif valores['a3'] == valores['b3']:
  344.                 # además coinciden c3 y d3, por lo que se suman también
  345.             if valores['c3'] == valores['d3']:
  346.                 valores['a3'] = valores['a3'] + valores['b3']
  347.                 valores['b3'] = valores['c3'] + valores['d3']
  348.                 valores['c3'] = 0
  349.                 valores['d3'] = 0
  350.                 # no coinciden, asi que solo se ordenan
  351.             else:
  352.                 valores['a3'] = valores['a3'] + valores['b3']
  353.                 valores['b3'] = valores['c3']
  354.                 valores['c3'] = valores['d3']
  355.                 valores['d3'] = 0
  356.             # casos en los que a3  y b3 son distintos de 0, pero no son iguales, por lo que b puede sumar con c o con d
  357.         elif valores['b3'] != 0:
  358.                 #casos en los que c3 es cero, por lo que d se acumula si es dintinto de b
  359.             if valores['c3'] == 0:
  360.                 if valores['b3'] == valores['d3']:
  361.                     valores['b3'] = valores['b3'] + valores['d3']
  362.                     valores['d3'] = 0
  363.                 else:
  364.                     valores['c3'] = valores['d3']
  365.                     valores['d3'] = 0
  366.  
  367.                 # casos en los que c es dinstinto de 0
  368.             else:
  369.                 if valores['b3'] == valores['c3']:
  370.                         valores['b3'] = valores['b3'] + valores['c3']
  371.                         valores['c3'] = valores['d3']
  372.                         valores['d3'] = 0
  373.                 else:
  374.                     if valores['c3'] == valores['d3']:
  375.                         valores['c3'] = valores['c3'] + valores['d3']
  376.                         valores['d3'] = 0
  377.             # casos en los que b es 0 siendo a diferente de 0, hay que comprobar si c es cero tambien
  378.            
  379.         elif valores['c3'] == 0:
  380.             if valores['d3'] == valores['a3']:
  381.                 valores['a3'] = valores['a3'] + valores['d3']
  382.                 valores['d3'] = 0
  383.             else:
  384.                 valores['b3'] = valores['d3']
  385.                 valores['d3'] = 0
  386.                
  387.         elif valores['a3'] == valores['c3']:
  388.             valores['a3'] = valores['a3'] + valores['c3']
  389.             valores['b3'] = valores['d3']
  390.             valores['c3'] = 0
  391.             valores['d3'] = 0
  392.  
  393.         elif valores['c3'] == valores['d3']:
  394.             valores['b3'] = valores['c3'] + valores['d3']
  395.             valores['c3'] = 0
  396.             valores['d3'] = 0
  397.  
  398.         elif valores['c3'] != valores['d3']:
  399.             valores['b3'] = valores['c3']
  400.             valores['c3'] = valores['d3']
  401.             valores['d3'] = 0
  402.  
  403.  
  404.         ############
  405.         # Columna 4
  406.         ############
  407.         if valores['a4'] == 0 and valores['b4'] != 0:
  408.             if valores['b4'] == valores['c4']:
  409.                 valores['a4'] = valores['b4'] + valores['c4']
  410.                 valores['b4'] = valores['d4']
  411.                 valores['c4'] = 0
  412.                 valores['d4'] = 0
  413.             else:
  414.                 valores['a4'] = valores['b4']
  415.                 if valores['c4'] == valores['d4'] or valores['c4'] == 0:
  416.                     valores['b4'] = valores['c4'] + valores['d4']
  417.                     valores['c4'] = 0
  418.                     valores['d4'] = 0
  419.                 else:                  
  420.                     valores['b4'] = valores['c4']
  421.                     valores['c4'] = valores['d4']
  422.                     valores['d4'] = 0
  423.  
  424.         # a4 = 0, b4 = 0, c4 = algo, d4 =  cualquier cosa
  425.         elif valores['a4'] == 0 and valores['b4'] == 0 and valores['c4'] != 0:
  426.             if valores['c4'] == valores['d4']:
  427.                 valores['a4'] = valores['c4'] + valores['d4']
  428.                 valores['b4'] = 0
  429.                 valores['c4'] = 0
  430.                 valores['d4'] = 0
  431.             else:
  432.                 valores['a4'] = valores['c4']
  433.                 valores['b4'] = valores['d4']
  434.                 valores['c4'] = 0
  435.                 valores['d4'] = 0
  436.  
  437.         # a4 = 0, b4 = 0, c4 = 0, d4 = cualquier cosa
  438.         elif valores['a4'] == 0 and valores['b4'] == 0 and valores['c4'] == 0 and valores['d4'] != 0:
  439.             valores['a4'] = valores['d4']
  440.             valores['d4'] = 0
  441.  
  442.         # casos en los que a vale algo
  443.         #
  444.        
  445.             # a4 = b4 (es decir, se suman)
  446.         elif valores['a4'] == valores['b4']:
  447.                 # además coinciden c4 y d4, por lo que se suman también
  448.             if valores['c4'] == valores['d4']:
  449.                 valores['a4'] = valores['a4'] + valores['b4']
  450.                 valores['b4'] = valores['c4'] + valores['d4']
  451.                 valores['c4'] = 0
  452.                 valores['d4'] = 0
  453.                 # no coinciden, asi que solo se ordenan
  454.             else:
  455.                 valores['a4'] = valores['a4'] + valores['b4']
  456.                 valores['b4'] = valores['c4']
  457.                 valores['c4'] = valores['d4']
  458.                 valores['d4'] = 0
  459.             # casos en los que a4  y b4 son distintos de 0, pero no son iguales, por lo que b puede sumar con c o con d
  460.         elif valores['b4'] != 0:
  461.                 #casos en los que c4 es cero, por lo que d se acumula si es dintinto de b
  462.             if valores['c4'] == 0:
  463.                 if valores['b4'] == valores['d4']:
  464.                     valores['b4'] = valores['b4'] + valores['d4']
  465.                     valores['d4'] = 0
  466.                 else:
  467.                     valores['c4'] = valores['d4']
  468.                     valores['d4'] = 0
  469.  
  470.                 # casos en los que c es dinstinto de 0
  471.             else:
  472.                 if valores['b4'] == valores['c4']:
  473.                         valores['b4'] = valores['b4'] + valores['c4']
  474.                         valores['c4'] = valores['d4']
  475.                         valores['d4'] = 0
  476.                 else:
  477.                     if valores['c4'] == valores['d4']:
  478.                         valores['c4'] = valores['c4'] + valores['d4']
  479.                         valores['d4'] = 0
  480.             # casos en los que b es 0 siendo a diferente de 0, hay que comprobar si c es cero tambien
  481.            
  482.         elif valores['c4'] == 0:
  483.             if valores['d4'] == valores['a4']:
  484.                 valores['a4'] = valores['a4'] + valores['d4']
  485.                 valores['d4'] = 0
  486.             else:
  487.                 valores['b4'] = valores['d4']
  488.                 valores['d4'] = 0
  489.                
  490.         elif valores['a4'] == valores['c4']:
  491.             valores['a4'] = valores['a4'] + valores['c4']
  492.             valores['b4'] = valores['d4']
  493.             valores['c4'] = 0
  494.             valores['d4'] = 0
  495.  
  496.         elif valores['c4'] == valores['d4']:
  497.             valores['b4'] = valores['c4'] + valores['d4']
  498.             valores['c4'] = 0
  499.             valores['d4'] = 0
  500.  
  501.         elif valores['c4'] != valores['d4']:
  502.             valores['b4'] = valores['c4']
  503.             valores['c4'] = valores['d4']
  504.             valores['d4'] = 0
  505.  
  506.  
  507.  
  508.  
  509.  
  510.  
  511.  
  512.  
  513.  
  514.     # TENEMOS COMENTADOS LOS POSIBLES MOVIMIENTOS PORQUE SINO NO SE PUEDE PROBAR EL PRIMERO
  515.     #elif movimiento in ['a', 'A']:
  516.         # moviemiento hacia la izquierda
  517.     #elif movimiento in ['s', 'S']:
  518.         # movimiento hacia abajo
  519.     #elif movimiento in ['d', 'D']:
  520.         #movimiento hacia la derecha
  521.  
  522.  
  523.  
  524.  
  525.         # insertamos ahora un valor aleatorio (sino el juego no tiene gracia)
  526.  
  527.         valores[posicion_azar(valores)] = valor_azar()
  528.  
  529.         imprimir(valores)
  530.  
  531.  
  532.  
  533.  
  534.  
  535.     # comprobamos si hemos perdido la partida, esto sucede si, y solo si, el tablero está lleno de números distintos de 0
  536.  
  537.     lista_valores_comprobar_perder = list(valores.values())
  538.  
  539.     if 0 in lista_valores_comprobar_perder or not comprobacion_derrota(valores):
  540.         perder = False
  541.     else:
  542.         perder = True
  543.  
  544.  
  545.  
  546.  
  547.  
  548.     # dejamos ester perder aquí metido para que no sea un bucle infinito mientras no tengamos todas las funciones implementadas
  549.     perder = True
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top