def __init__(self, nombre, tablero):
self.nombre = nombre
self.mano = [] #Mano de la computadora
self.mazo = Mazo() #Objeto mazo para usar posteriormente
self.cartas = self.mazo.getCartas(
) #Conjunto de cartas no jugadas y que no posee el CPU con el cual se verán las posibilidades
self.posibilidades = Posibilidades(
) #Objeto manejador de posibilidades
self.arbol = ArbolDecision() #Objeto manejador del arbol de decisiones
self.tablero = tablero #Tablero en que se juega
self.juegos = [] #Manejador de posibles juegos
self.contador = 0
def test_montecarlos(self):
print("Test de monte carlos")
mazo = Mazo()
usuario = []
usuario.append(mazo.repartirc(12))
usuario.append(mazo.repartirc(25))
for a in usuario:
print(a)
m_carlos = probabilidades(mazo, usuario)
prob_carlos = m_carlos.montecarlo()
def test_hand_par(self):
mazo = Mazo()
usuario = []
usuario.append(mazo.repartirc(0))
usuario.append(mazo.repartirc(12))
mesa = []
mesa.append(mazo.repartirc(25))
mesa.append(mazo.repartirc(34))
mesa.append(mazo.repartirc(28))
mesa.append(mazo.repartirc(42))
mesa.append(mazo.repartirc(6))
evaluar = hand(usuario, mesa)
evaluar.unir()
res = evaluar.manos()
p = pro(res)
proba = p.prob()
if res == 1:
print("Usuario tiene Mano de par, probabilidad de ganar", proba,
"%\n")
else:
print("No tiene par")
def barajar(self):
""" Crea un mazo nuevo, lo mezcla y le reparte una carta a cada jugador hasta
que el mismo queda vacío. """
self.mazo = Mazo()
self.mazo.mezclar()
while not self.mazo.es_vacio():
for n in xrange(len(self.jugadores)):
self.jugadores[n].recibir_carta(self.mazo.obtener_tope())
self.turno = -1
def __init__(self, ciega, jugadores):
'''
Constructor
p es un número entre 0 y 1 para determinar la estrategia de juego del bot
'''
self.ciega = ciega
self.mazo = Mazo()
self.bote = 0
self.jugadores = jugadores
self.dealer = 0 #posicion en la lista jugaores
self.comunitarias = [None, None, None, None, None]
self.ronda_actual = None
self.nro_jugadores = 2
self.jugador_actual = 0
self.allin = False
def test_hand_escalera(self):
mazo = Mazo()
usuario = []
usuario.append(mazo.repartirc(1))
usuario.append(mazo.repartirc(3))
mesa = []
mesa.append(mazo.repartirc(26))
mesa.append(mazo.repartirc(25))
mesa.append(mazo.repartirc(14))
mesa.append(mazo.repartirc(39))
mesa.append(mazo.repartirc(29))
evaluar = hand(usuario, mesa)
evaluar.unir()
evaluar.mostrar()
res = evaluar.manos()
propensa = evaluar.propensa_escalera()
print("pro", propensa)
print("Mano de escalera")
p = pro(res)
proba = p.prob()
if res == 4:
print("Usuario tiene Mano de escalera, probabilidad de ganar",
proba, "%\n")
else:
print("No tiene escalera", proba)
desempates = parametros(usuario, mesa)
desempates.unir()
print("carga")
n, cm, cartasA, s_cartasA = desempates.ganar(res)
print("n", n)
print("cm", cm)
print("jugada")
for a in cartasA:
print(a)
print("resto")
for b in s_cartasA:
print(b)
def test_hand_escalera(self):
mazo = Mazo()
usuario = []
usuario.append(mazo.repartirc(0))
usuario.append(mazo.repartirc(14))
mesa = []
mesa.append(mazo.repartirc(13))
mesa.append(mazo.repartirc(11))
mesa.append(mazo.repartirc(26))
mesa.append(mazo.repartirc(37))
mesa.append(mazo.repartirc(9))
evaluar = hand(usuario, mesa)
evaluar.unir()
res = evaluar.manos()
print("Mano de escalera")
for c in usuario:
print(c)
for c in mesa:
print(c)
p = pro(res)
proba = p.prob()
if res == 4:
print("Usuario tiene Mano de escalera, probabilidad de ganar",
proba, "%\n")
else:
print("No tiene escalera", proba)
def test_hand_Full(self):
mazo = Mazo()
usuario = []
usuario.append(mazo.repartirc(0))
usuario.append(mazo.repartirc(12))
mesa = []
mesa.append(mazo.repartirc(24))
mesa.append(mazo.repartirc(34))
mesa.append(mazo.repartirc(28))
mesa.append(mazo.repartirc(42))
mesa.append(mazo.repartirc(4))
evaluar = hand(usuario, mesa)
evaluar.unir()
res = evaluar.manos()
print("Mano de Full")
for c in usuario:
print(c)
for c in mesa:
print(c)
p = pro(res)
proba = p.prob()
if res == 6:
print("Usuario tiene Mano de FullHouse, probabilidad de ganar",
proba, "%\n")
else:
print("No tiene FullHouse")
def test_hand_color(self):
mazo = Mazo()
usuario = []
usuario.append(mazo.repartirc(0))
usuario.append(mazo.repartirc(4))
mesa = []
mesa.append(mazo.repartirc(8))
mesa.append(mazo.repartirc(39))
mesa.append(mazo.repartirc(2))
mesa.append(mazo.repartirc(5))
mesa.append(mazo.repartirc(24))
evaluar = hand(usuario, mesa)
evaluar.unir()
res = evaluar.manos()
print("Mano de color")
for c in usuario:
print(c)
for c in mesa:
print(c)
p = pro(res)
proba = p.prob()
if res == 5:
print("Usuario tiene Mano de color, probabilidad de ganar", proba,
"%\n")
else:
print("No tiene color")
def test_hand_doble_par(self):
mazo = Mazo()
usuario = []
usuario.append(mazo.repartirc(1))
usuario.append(mazo.repartirc(13))
mesa = []
mesa.append(mazo.repartirc(26))
mesa.append(mazo.repartirc(34))
mesa.append(mazo.repartirc(28))
mesa.append(mazo.repartirc(42))
mesa.append(mazo.repartirc(4))
evaluar = hand(usuario, mesa)
evaluar.unir()
res = evaluar.manos()
p = pro(res)
proba = p.prob()
print("mano de doble par")
for c in usuario:
print(c)
for c in mesa:
print(c)
if res == 2:
print("Usuario tiene Mano de doble par, probabilidad de ganar",
proba, "%\n")
else:
print("No tiene doble par")
class Jugador:
"""
Constructor del jugador
Nombre: nombre del jugador
"""
def __init__(self, nombre):
self.nombre = nombre
self.mano = []
self.topCard = None
self.mazo = Mazo()
"""
Metodo encargado de que el jugador tome una carta del Mazo
Mazo: cartas disponibles para tomar
"""
def tomarCarta(self):
if (len(self.mazo.getCartas()) > 0):
self.mano.append(self.mazo.tomarCarta())
return "Hay cartas"
return "Ya no hay cartas"
"""Getter del atributo mano"""
def getMano(self):
return self.mano
"""
Metodo encargado de recibir una carta
a diferencia de tomar carta esta no la toma del mazo
carta: carta a recibir
"""
def recibeCarta(self, carta):
self.mano.append(carta)
self.topCard = carta
"""Metodo encargado de dejar la carta indidcada por el usuario"""
def dejaCarta(self, iterator):
if (iterator >= len(self.mano)):
return self.mano[len(self.mano) - 1]
return self.mano.pop(iterator)
"""Getter de la carta indicada por el usuario"""
def getCarta(self, iterator):
if (iterator >= len(self.mano)):
return self.mano[len(self.mano) - 1]
return self.mano[iterator]
"""Metodo encargado de mostrar la mano del usuario"""
def mostrarMano(self):
i = 0
print(len(self.mano))
for carta in self.mano:
print(str(i) + ") ", end="")
carta.mostrar()
i = i + 1
print("\n")
"""Getter del nombre del usuario"""
def getName(self):
return self.nombre
"""Getter de la ultima carta en la lista del usuario"""
def getUltimaCarta(self):
return self.mano[len(self.mano) - 1]
"""Getter de la penultima carta en la lista del usuario"""
def getPenultimaCarta(self):
return self.mano[len(self.mano) - 2]
"""Metodod encargado de retonar el tamaño de la mano de cartas restantes"""
def getTamCartas(self):
return len(self.mano)
def __init__(self, nombre):
self.nombre = nombre
self.mano = []
self.topCard = None
self.mazo = Mazo()
from NodoPosibilidad import NodoPosibilidad
from arbolDecision import ArbolDecision
from Carta import Carta
from posibilidades import Posibilidades
from Mazo import Mazo
mazo = Mazo()
mazo.generar()
mazo.revolver()
mano = []
for i in range(0, 7):
mano.append(mazo.tomarCarta())
cartas = []
for i in ["Rojo", "Azul", "Amarillo", "Verde"]:
for j in range(0, 10):
carta = Carta(j, i, "")
cartas.append(carta)
for i in ["Rojo", "Azul", "Amarillo", "Verde"]:
for Especial in ["Salto", "Reversa", "+2"]:
cartas.append(Carta("", i, Especial))
for i in mano:
for j in cartas:
if (j.toString() == i.toString()):
position = cartas.index(j)
cartas.pop(position)
arbol = ArbolDecision()
arbol.setRoot(cartas[13])
class JuegoCorazones(object):
""" Clase que representa un juego de Corazones.
Atributos:
jugadores: lista de jugadores.
jugadores_id: lista con los id de los jugadores.
puntajes: lista con los puntajes de los jugadores.
mazo: instancia de Mazo con el que se juega.
turno: entero representando el índice del jugador al que le toca
jugar primero en el próximo turno.
"""
def __init__(self, jugadores):
""" Crea un juego en base a una lista de jugadores.
Argumentos:
jugadores: lista con instancias de Jugador.
Excepciones:
ValueError: hay más del límite de jugadores.
"""
if len(jugadores) != 4:
raise ValueError("No pueden haber más de 4 jugadores.")
self.jugadores = jugadores
self.jugadores_id = [jugador.obtener_id_jugador() for jugador in self.jugadores]
self.puntajes = [0, 0, 0, 0]
self.mazo = None
self.turno = -1
self.cartas_levantadas = {}
for id in self.jugadores_id:
self.cartas_levantadas[id] = []
def termino(self):
""" Devuelve True si alguno de los jugadores alcanzo los 100 puntos. """
for puntaje in self.puntajes:
if puntaje >= 100:
return True
return False
def imprimir_puntajes(self):
""" Imprime los puntajes de cada jugador hasta el momento. """
for n in xrange(len(self.jugadores)):
print self.jugadores[n], self.puntajes[n]
def barajar(self):
""" Crea un mazo nuevo, lo mezcla y le reparte una carta a cada jugador hasta
que el mismo queda vacío. """
self.mazo = Mazo()
self.mazo.mezclar()
while not self.mazo.es_vacio():
for n in xrange(len(self.jugadores)):
self.jugadores[n].recibir_carta(self.mazo.obtener_tope())
self.turno = -1
def identificar_jugador_que_inicia(self):
""" Se fija cual de los jugadores es primero y devuelve su id. """
if self.turno == -1:
# Estamos en el primer turno. Buscar el jugador que tiene el 2
# de treboles.
self.turno = 0
for jugador in jugadores:
if jugador.es_primero():
break
self.turno += 1
return self.jugadores_id[self.turno]
def identificar_jugador_que_perdio(self, cartas_jugadas, id_primero):
""" Recibe las cartas jugadas en la mano y el id del jugador que
abrió la jugada. Devuelve el id del jugador que perdió.
Pierde el jugador que juega la carta mas alta del palo con el que
inicio la jugada el primer jugador. Las cartas por orden creciente
son: 2, 3,..., 10, J, Q, K, A. """
# Definimos cuál es la carta más alta.
indice_carta = 0
for indice in xrange(1, len(cartas_jugadas)):
if cartas_jugadas[indice].obtener_palo() == cartas_jugadas[0].obtener_palo():
numero = cartas_jugadas[indice].obtener_numero()
if numero == 1:
# La carta es el As, así que dejamos de recorrer.
indice_carta = indice
break
elif cartas_jugadas[indice_carta].obtener_numero == 1:
# La carta de indice máximo ya es el As.
break
elif numero > cartas_jugadas[indice_carta].obtener_numero():
indice_carta = indice
# Indice del jugador que tiró la carta más alta.
try:
indice_jugador = jugadores_id.index(id_primero) + indice_carta
except ValueError:
raise ValueError("El primer jugador no existe.")
# Hacemos que el indice del jugador quede determinado.
while not 0 <= indice_jugador < len(self.jugadores):
indice_jugador -= len(self.jugadores)
return self.jugadores_id[indice_jugador]
def __contar_puntos_en_lista(self, cartas):
""" Cuenta el puntaje que obtiene el jugador que levantó las cartas
en la lista. """
puntos = 0
for carta in cartas:
if carta.obtener_palo() == Carta.CORAZONES:
puntos += 1
elif carta.obtener_palo() == Carta.PICAS and carta.obtener_numero == Carta.NUMEROS.index("Q"):
puntos += 13
return puntos
def procesar_e_informar_resultado(self, cartas_jugadas, id_primero, id_perdedor):
""" Recibe las cartas de la jugada, el id del primer jugador, y el id del
jugador que perdió.
Almacena lo necesario para llevar la cuenta de puntos e informa a todos
los jugadores del resultado de la jugada. """
## TODO: TERMINAR ################################################
try:
self.turno = jugadores_id.index(id_perdedor)
except ValueError:
raise ValueError("El no existe el jugador perdedor.")
self.cartas_levantadas[id_perdedor].append(cartas_jugadas)
puntos_luna = self.__contar_puntos_en_lista(self.cartas_levantadas[id_perdedor])
if puntos_luna == 26:
self.puntajes[self.turno] -= 26
pass
puntos_jugada = self.__contar_puntos_en_lista(cartas_jugadas)
for jugador in self.jugadores:
jugador.conocer_jugada(cartas_jugadas, id_primero, id_perdedor)
raise NotImplementedError
def hay_corazones(self, cartas):
""" Devuelve True si hay algun corazon entre las cartas pasadas. """
for carta in cartas:
if carta.obtener_palo == Carta.CORAZONES:
return True
return False
def realizar_jugada(self, nro_mano, nro_jugada, id_primero, corazon_jugado):
""" Recibe el numero de mano, de jugada el id del primer jugador y si ya
se jugaron corazones hasta el momento.
Hace jugar una carta a cada uno de los jugadores empezando por el primero.
Devuelve las 4 cartas jugadas. """
raise NotImplementedError
def calcular_puntajes(self):
"""Al finalizar la mano, calcula y actualiza los puntajes de los jugadores.
Cada jugador suma un punto por cada corazon levantado en la mano y 13 puntos
si levanto la Q de picas, salvo en el caso de que un solo jugador haya
levantado todos los corazones y la Q de picas, caso en el cual todos los
jugadores salvo el suman 26 puntos."""
raise NotImplementedError
def intercambiar_cartas(self, nro_mano):
""" Antes de hacer la primer jugada se pasan 3 cartas entre los rivales.
En la primer mano, las cartas se pasan al jugador de la izquierda; en la
segunda al jugador de la derecha; en la tercera al jugador del frente y
en la cuarta no se pasan cartas. A partir de la quinta mano, se repite el
mismo ciclo.
El metodo debe primero pedirle las 3 cartas a pasar a cada oponente y luego
entregarle las cartas que le fueron pasadas. """
raise NotImplementedError
def ganadores(self):
""" Una vez terminado el juego, devuelve la lista de ganadores.
Son ganadores todos los jugadores que hayan alcanzado el menor
puntaje. """
ganadores = []
for indice, jugador in enumerate(self.jugadores):
if min(self.puntajes) == self.puntajes[indice]:
ganadores.append(jugador)
return ganadores
def jugar_mano(self, nro_mano):
"""Realiza las 13 jugadas que corresponden a una mano completa."""
corazon_jugado = False
id_primero = self.identificar_jugador_que_inicia()
# INICIO: Chequeos de trampa
palos_faltantes = [[], [], [], []]
cartas_en_mesa = []
solo_tiene_corazones = [False] * 4
# FIN: Chequeos de trampa
for nro_jugada in xrange(1, 13 + 1):
print "Jugada %i" % nro_jugada
print "Empieza %s" % self.jugadores[id_primero]
cartas_jugadas = self.realizar_jugada(nro_mano, nro_jugada, id_primero, corazon_jugado)
id_perdedor = self.identificar_jugador_que_perdio(cartas_jugadas, id_primero)
print "Levanta %s" % self.jugadores[id_perdedor]
self.procesar_e_informar_resultado(cartas_jugadas, id_primero, id_perdedor)
# INICIO: Chequeos de trampa
if nro_jugada == 1 and not cartas_jugadas[0] == Carta(2, Carta.TREBOLES):
raise Exception("El primer jugador no jugo el 2 de treboles""")
if nro_jugada == 1 and (corazon_jugado or Carta(12, Carta.PICAS) in cartas_jugadas):
raise Exception("Jugador jugo carta especial en primer juego""")
for i in xrange(4):
if cartas_jugadas[i].obtener_palo() in palos_faltantes[(i + id_primero) % 4]:
raise Exception("El jugador %s dijo que no tenia %s" % (self.jugadores[(i + id_primero) % 4], Carta.PALOS[cartas_jugadas[i].obtener_palo()]))
if solo_tiene_corazones[(i + id_primero) % 4] and cartas_jugadas[i].obtener_palo() != Carta.CORAZONES:
raise Exception("El jugador %s dijo que solo tenia %s" % (self.jugadores[(i + id_primero) % 4], Carta.PALOS[Carta.CORAZONES]))
palo_jugada = cartas_jugadas[0].obtener_palo()
for i in xrange(1, 4):
if cartas_jugadas[i].obtener_palo() != palo_jugada and palo_jugada not in palos_faltantes[(i + id_primero) % 4]:
palos_faltantes[(i + id_primero) % 4].append(palo_jugada)
for carta in cartas_jugadas:
if carta in cartas_en_mesa:
raise Exception("Alguien se matufio el %s" % carta)
cartas_en_mesa.append(carta)
if not corazon_jugado and palo_jugada == Carta.CORAZONES:
solo_tiene_corazones[id_primero] = True
# FIN: Chequeos de trampa
corazon_jugado = corazon_jugado or self.hay_corazones(cartas_jugadas)
id_primero = id_perdedor
def jugar(self):
""" Juega una partida completa de Corazones. """
nro_mano = 1
while not self.termino():
print "Mano %d" % nro_mano
self.barajar()
self.intercambiar_cartas(nro_mano)
self.jugar_mano(nro_mano)
self.calcular_puntajes()
self.imprimir_puntajes()
nro_mano += 1
--------------------- python juego.py --------------------- """ import pygame, sys, os from Mazo import Mazo from Jugador import Jugador from pygame import mixer """ Variables Globales """ # Objeto mazo para el juego mazo = Mazo() # Array que se va a llenar de objetos Jugador jugadores = [] # Array que se usa para almacenar las cartas que un jugador desea cambiar cartasSeleccionadas = [] intro = True jugando = True pantallaPuntos = False puedeCambiarCartas = True # El array se llena de 4 jugadores # for i in range(0, 4): # jugadores.append(Jugador(mazo)) """ Iniciando pygame
aces = 0
for carta in self.cartas:
valor = carta.obtener_numero()
if (valor == 1):
aces += 1
suma += valor
if (aces > 0 and suma + 10 <= 21):
suma += 10
return suma
def jugar(self, mazo):
interfaz = Interfaz() # pedir variable de tipo entero
solicitar = True
titulo = "Digite: \n1 -Pedir Carta \n2- Quedarse \n Valor:"
while (solicitar and self.sumar_cartas() <= 21):
self.imprimir()
valor = interfaz.solicitar_numero_entero(titulo)
if (valor == 1):
self.cartas.append(mazo.obtener_siguiente_carta())
self.cartas[-1].imprimir()
elif (valor == 2):
solicitar = False
return self.sumar_cartas()
if __name__ == "__main__":
mazo1 = Mazo()
j1 = Jugador("Mario")
j1.jugar(mazo1)
class Mesa(object):
'''
Manejadora del juego
the person with the dealer button posts the small blind,
while his/her opponent places the big blind.
The dealer acts first before the flop. After the flop,
the dealer acts last and continues to do so for the remainder of the hand.
'''
def __init__(self, ciega, jugadores):
'''
Constructor
p es un número entre 0 y 1 para determinar la estrategia de juego del bot
'''
self.ciega = ciega
self.mazo = Mazo()
self.bote = 0
self.jugadores = jugadores
self.dealer = 0 #posicion en la lista jugaores
self.comunitarias = [None, None, None, None, None]
self.ronda_actual = None
self.nro_jugadores = 2
self.jugador_actual = 0
self.allin = False
def juego(self):
'''
Devuelve el resultado de juego en una lista
la primera posición es True si el juego continúa
la segunda es la posición en la lista de jugadores de la mesa
del jugador que ganó esta iteración del juego y la
tercera posición indica el nombre de la jugada
ganadora.
'''
for tipo in range(1,5): #iterador de rondas
self.ronda(tipo)
def ronda(self, tipo_ronda):
if tipo_ronda == 1: #pre-flop, juega primero el dealer, tiene la ciega chica
self.poner_ciegas()
self.croupier(tipo_ronda) #acciones del croupier
for nro_apuesta in range(0, 4):
for i in range(0, self.nro_jugadores):
if not self.allin:
ronda = Ronda(tipo_ronda, nro_apuesta, self.ciega, self.bote)
nro_jugador = self.siguiente_jugador()
jugada = self.jugadores[nro_jugador].obtener_jugada(ronda, self.comunitarias)
self.actualizar_mesa(jugada, nro_apuesta, self.jugadores[nro_jugador].dealer)
'''
if not self.allin:
ronda = Ronda(tipo_ronda, nro_apuesta, self.ciega, self.bote)
jugada = self.jugadores[self.dealer].obtener_jugada(ronda, self.comunitarias)
self.actualizar_mesa(jugada, nro_apuesta, self.jugadores[self.dealer])
if not self.allin:
jugada = self.jugadores[self.obtener_no_dealer()].obtener_jugada(ronda, self.comunitarias)
self.actualizar_mesa(jugada, nro_apuesta, self.jugadores[self.dealer])
'''
elif tipo_ronda == 2:#flop, juega primero el que no es dealer.
elif tipo_ronda == 3:#turn, juega primero el que no es dealer.
self.croupier(tipo_ronda)
elif tipo_ronda == 4:#river, juega primero el que no es dealer.
self.croupier(tipo_ronda)
def actualizar_mesa(self, jugada, nro_apuesta, dealer):
if jugada == "apostar":
def siguiente_jugador(self):
retorno = self.jugador_actual
if self.jugador_actual == self.dealer:
self.jugador_actual = self.obtener_no_dealer()
else:
self.jugador_actual = self.dealer
return retorno
def poner_ciegas(self):
self.bote = 0
#el dealer pone la ciega chica.
if self.jugadores[self.dealer].verficar_allin():
self.establecer_allin(self.dealer)
else:
self.jugadores[self.dealer].fichas -= self.ciega / 2
#el otro pone la ciega grande.
if self.jugadores[self.obtener_no_dealer()].verficar_allin():
self.establecer_allin(self.obtener_no_dealer())
else:
self.jugadores[self.obtener_no_dealer()].fichas -= self.ciega
def establecer_allin(self, jugador):
self.allin = True
self.bote += self.jugadores[jugador].fichas
self.jugadores[jugador].fichas = 0
def establecer_siguiente_dealer(self):
if self.dealer == 0:
self.dealer = 1
else:
self.dealer = 0
def obtener_no_dealer(self):
if self.dealer == 0:
return 1
else:
return 0
def croupier(self, tipo_ronda):
if tipo_ronda == 1: #pre-flop, repartir dos cartas a cada jugador
self.mazo.mezclar()
for i in range(0, self.nro_jugadores):
for jug in self.jugadores:
self.jugadores[jug].mano[i] = self.mazo.obtener_siguiente()
elif tipo_ronda == 2:#flop
for i in range(0, 3):
self.comunitarias[i] = self.mazo.obtener_siguiente()
elif tipo_ronda == 3:#turn
self.comunitarias[3] = self.mazo.obtener_siguiente()
return "No paso"
if __name__ == "__main__":
while (estado):
#Inicio del Juego
if (turno == 0):
Presentacion()
nametag = input("Ingrese su nombre para comenzar a jugar: ")
#Se inicializan el mazo junto a los jugadores
mazo = Mazo()
P1 = Jugador(nametag)
Tablero = Jugador("Tablero")
IA = IA("PC", Tablero)
#Se revuelve el mazo
mazo.revolver()
returned = Tablero.tomarCarta()
print(returned)
#Repartir las 7 Cartas iniciales
for i in range(0, 7):
IA.tomarCarta()
P1.tomarCarta()
#Se toma una carta del Mazo para iniciar el juego:
#!/usr/bin/env python
import sys
from PyQt5 import uic, QtWidgets, QtCore, QtGui
from sala_juego import Ui_sala
from Mazo import Mazo, Carta
from imgcarta import imagen
from Jugador import Jugador
from Charmi import Charmi
from Mano import hand
from Mesa import Mesa
from Probabilidades import pro
from montecarlo import probabilidades
from desempate import parametros
mazo_poker = Mazo()
mazo_poker.mezclar()
mesa = Mesa()
usuario = Jugador("user", 1000)
charmi = Charmi("charmi", 1000)
minima = 50
maxima = 100
apuesta = 0
ronda = 0
altura = 0
quemada = 0
prob_carlos = 0
qtCreatorFile = "inicio.ui" # Nombre del archivo aquí.
Ui_MainWindow, QtBaseClass = uic.loadUiType(qtCreatorFile)
def setup(self):
"""
Preparar el juego para jugar.
"""
#Lista de Cartas que arrastramos con el mouse
self.held_cards = []
self.piles = []
#Pilas de juego
for i in range(PILE_COUNT):
self.piles.append(arcade.SpriteList())
#Posicion original de las cartas que se estan moviendo..
self.held_card_original_position = []
#Sprite list de las cartas
self.lista_cartas = arcade.SpriteList()
#Configurar Mazo y Jugadores
self.deck = Mazo()
self.deck.inicializar()
self.deck.revolver()
self.tablero = []
self.players.append(Jugador("Player 1"))
self.players.append(Jugador("IA"))
self.players[JUGADOR1].mano = self.piles[PLAYER_PILE]
self.players[IA].mano = self.piles[IA_PILE]
for card in self.deck.cartas:
carta = arcade.Sprite(card.im_filename, CARD_SCALE)
carta.center_y = self.height / 2
carta.position = START_X, BOTTOM_Y
self.lista_cartas.append(carta)
for i in range(0, 7):
carta = self.lista_cartas.pop()
carta.position = START_X, BOTTOM_Y + 150
self.piles[PLAYER_PILE].append(carta)
carta = self.lista_cartas.pop()
carta.position = START_X, BOTTOM_Y + 350
self.piles[IA_PILE].append(carta)
# --- Crear los tapetes donde las cartas van.
# Sprite list con los tapetes donde van las cartas
self.pile_mat_list: arcade.SpriteList = arcade.SpriteList()
#Crear los tapetes para las cartas boca arriba y boca abajo.
pila = arcade.SpriteSolidColor(MAT_WIDTH, MAT_HEIGHT,
arcade.csscolor.DARK_OLIVE_GREEN)
pila.position = START_X, BOTTOM_Y
self.pile_mat_list.append(pila)
pila = arcade.SpriteSolidColor(MAT_WIDTH, MAT_HEIGHT,
arcade.csscolor.DARK_OLIVE_GREEN)
pila.position = START_X + X_SPACING, BOTTOM_Y
self.pile_mat_list.append(pila)
pila_c = arcade.SpriteSolidColor(MAT_WIDTH, MAT_HEIGHT,
arcade.csscolor.DARK_OLIVE_GREEN)
pila_c.position = SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2
self.pile_mat_list.append(pila_c)
#-*- coding: utf-8 -*-
"""Script de prueba para probar la clase Mazo"""
from Mazo import Mazo
if __name__ == '__main__':
listaCartas = [
"Contrahechizo", "Mana azul", "Mana azul", "Darting Merfolk"
]
magicMazo = Mazo("Mazo prueba", 4, listaCartas)
magicMazo.setListaBiblioteca(magicMazo.getListaCartasMazo())
print "Nombre: " + magicMazo.getNombreMazo() + ", Número de cartas: " + \
str(magicMazo.getNCartasMazo()) + "\nBiblioteca: " + str(magicMazo.getListaBiblioteca())
print magicMazo.robarCartaBiblioteca()
print "Biblioteca: " + str(magicMazo.getListaBiblioteca())
class UnoGame(arcade.Window):
"""
CLase para juego UNO
"""
def __init__(self,
width,
height,
title,
fullscreen=False,
resizable=False,
update_rate=1 / 60,
antialiasing=True):
super().__init__(width=width,
height=height,
title=title,
fullscreen=fullscreen,
resizable=resizable,
update_rate=update_rate,
antialiasing=antialiasing)
#Entidades de juego
self.tablero = None
self.players = []
#Definir sprites de las cartas.
self.lista_cartas = arcade.SpriteList()
#Lista de cartas que se esten jugando o no
arcade.set_background_color(arcade.color.AMAZON)
#Lista de carta que vamos a mover
self.held_cards = None
#Posicion original de las cartas que se estan moviendo.
self.held_card_original_position = None
#Sprite list con los tapetes donde se ponen las cartas
self.pile_mat_list = None
#
self.piles = []
self.paused = False
def setup(self):
"""
Preparar el juego para jugar.
"""
#Lista de Cartas que arrastramos con el mouse
self.held_cards = []
self.piles = []
#Pilas de juego
for i in range(PILE_COUNT):
self.piles.append(arcade.SpriteList())
#Posicion original de las cartas que se estan moviendo..
self.held_card_original_position = []
#Sprite list de las cartas
self.lista_cartas = arcade.SpriteList()
#Configurar Mazo y Jugadores
self.deck = Mazo()
self.deck.inicializar()
self.deck.revolver()
self.tablero = []
self.players.append(Jugador("Player 1"))
self.players.append(Jugador("IA"))
self.players[JUGADOR1].mano = self.piles[PLAYER_PILE]
self.players[IA].mano = self.piles[IA_PILE]
for card in self.deck.cartas:
carta = arcade.Sprite(card.im_filename, CARD_SCALE)
carta.center_y = self.height / 2
carta.position = START_X, BOTTOM_Y
self.lista_cartas.append(carta)
for i in range(0, 7):
carta = self.lista_cartas.pop()
carta.position = START_X, BOTTOM_Y + 150
self.piles[PLAYER_PILE].append(carta)
carta = self.lista_cartas.pop()
carta.position = START_X, BOTTOM_Y + 350
self.piles[IA_PILE].append(carta)
# --- Crear los tapetes donde las cartas van.
# Sprite list con los tapetes donde van las cartas
self.pile_mat_list: arcade.SpriteList = arcade.SpriteList()
#Crear los tapetes para las cartas boca arriba y boca abajo.
pila = arcade.SpriteSolidColor(MAT_WIDTH, MAT_HEIGHT,
arcade.csscolor.DARK_OLIVE_GREEN)
pila.position = START_X, BOTTOM_Y
self.pile_mat_list.append(pila)
pila = arcade.SpriteSolidColor(MAT_WIDTH, MAT_HEIGHT,
arcade.csscolor.DARK_OLIVE_GREEN)
pila.position = START_X + X_SPACING, BOTTOM_Y
self.pile_mat_list.append(pila)
pila_c = arcade.SpriteSolidColor(MAT_WIDTH, MAT_HEIGHT,
arcade.csscolor.DARK_OLIVE_GREEN)
pila_c.position = SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2
self.pile_mat_list.append(pila_c)
def on_update(self, delta_time: float):
"""Actualizar el frame
Argumentos:
delta_time {float} -- Tiempo desde la ultima actualizacion
"""
#Si estamos pausados, no actualizamos nada
if self.paused:
return
#Actualizar todo lo demas
self.lista_cartas.update()
self.piles[PLAYER_PILE].update()
self.piles[IA_PILE].update()
#Mas cosas por hacer ...
def on_draw(self):
"""Dibuja todos los objetos del juego en pantalla
"""
#Limpiar la pantalla
arcade.start_render()
#Dibujar los tapetes de cartas
self.pile_mat_list.draw()
#Dibujar las cartas
self.lista_cartas.draw()
self.piles[PLAYER_PILE].draw()
self.piles[IA_PILE].draw()
self.piles[PLAY_PILE].draw()
def pull_to_top(self, card, cardpile):
""" Pull card to top of rendering order (last to render, looks on-top) """
# Find the index of the card
index = cardpile.index(card)
# Loop and pull all the other cards down towards the zero end
for i in range(index, len(cardpile) - 1):
cardpile[i] = cardpile[i + 1]
# Put this card at the right-side/top/size of list
cardpile[len(cardpile) - 1] = card
def on_mouse_press(self, x, y, button, modifiers):
"""Se llama cuando el usuario presiana un boton del mouse
"""
#Revisar si hemos hecho click en la el mazo de cartas.
cartas = arcade.get_sprites_at_point((x, y), self.lista_cartas)
#Revisamos si hemos hecho click en el mazo del jugador
if (not cartas):
cartas = arcade.get_sprites_at_point((x, y),
self.piles[PLAYER_PILE])
cardpile = self.piles[PLAYER_PILE]
#Actualizar como se muestran las cartas al jugador:
i = 0
for carta in self.piles[PLAYER_PILE]:
carta.position = START_X + i * 25, BOTTOM_Y + 150
i += 1
else:
cardpile = self.lista_cartas
#Revisamos si hemos clickeado una carta
if (len(cartas) > 0):
#Puede que sea una carta en una pila de cartas
carta_primaria = cartas[-1]
#En todos los demas casos tomaremos la carta boca arriba
self.held_cards = [carta_primaria]
#Guardar la posicion
self.held_card_original_position = [self.held_cards[0].position]
#Poner la carta en la cima
card = self.held_cards[0]
self.pull_to_top(card, cardpile)
#return super().on_mouse_press(x, y, button, modifiers)
def on_mouse_motion(self, x, y, dx, dy):
"""Usuario mueve el mouse
"""
#Si estamos haciendo click en una carta esta se movera con el mouse
for carta in self.held_cards:
carta.center_x += dx
carta.center_y += dy
#return super().on_mouse_motion(x, y, dx, dy)
def on_mouse_release(self, x, y, button, modifiers):
"""Llamada cuando el usuario deja de hacer click en un boton
"""
#Si no tenemos cartas no ocurre nada
if len(self.held_cards) == 0:
return
#Encontrar la pila de cartas mas cercana, en caso de que estemos en contacto con mas de una.
pila, distancia = arcade.get_closest_sprite(self.held_cards[0],
self.pile_mat_list)
reiniciar_pos = True
lcx, lcy = self.lista_cartas._get_center()
#pcx, pcy = self.piles[PLAY_PILE]._get_center()
if (pila.center_y == lcy):
cardpile = self.lista_cartas
else:
cardpile = self.piles[PLAY_PILE]
#Checamos si estamos en contacto con la pila mas cercana
if arcade.check_for_collision(self.held_cards[0], pila):
#Por carta, moverla en la pila que soltemos
for i, carta_soltada in enumerate(self.held_cards):
#Mover las cartas a la posicion adecuada.
carta_soltada.position = pila.center_x, pila.center_y
try:
cardpile.append(carta_soltada)
self.lista_cartas.pop(
self.lista_cartas.index(carta_soltada))
pass
except:
cardpile.append(carta_soltada)
self.piles[PLAYER_PILE].pop(
self.piles[PLAYER_PILE].index(carta_soltada))
pass
#Exito no hay que reiniciar la posicion de la carta
reiniciar_pos = False
if reiniciar_pos:
#Donde soltamos no fue una posicion valida por lo tante regresamos al lugar inicial
for pile_index, carta in enumerate(self.held_cards):
carta.position = self.held_card_original_position[pile_index]
#Ya no estamos sosteniendo ninguna carta
self.held_cards = []
#return super().on_mouse_release(x, y, button, modifiers)
def on_key_press(self, symbol, modifiers):
"""Manejar los inputs del usuario en el teclado
Q: Salir del Juego
P: Pausar:
Argumentos:
symbol {int} -- Cual tecla fue presionada
modifiers {int} -- Which modifiers were pressed
"""
if symbol == arcade.key.Q:
#Salir inmediatamente
arcade.close_window()
if symbol == arcade.key.P:
self.paused = not self.paused
#-*- coding: utf-8 -*-
"""Script de prueba para probar la clase Mazo"""
from Mazo import Mazo
if __name__ == '__main__':
listaCartas = ["Contrahechizo", "Mana azul", "Mana azul", "Darting Merfolk"]
magicMazo = Mazo("Mazo prueba", 4, listaCartas)
magicMazo.setListaBiblioteca(magicMazo.getListaCartasMazo())
print "Nombre: " + magicMazo.getNombreMazo() + ", Número de cartas: " + \
str(magicMazo.getNCartasMazo()) + "\nBiblioteca: " + str(magicMazo.getListaBiblioteca())
print magicMazo.robarCartaBiblioteca()
print "Biblioteca: " + str(magicMazo.getListaBiblioteca())
def mostrarMesa(turnoJugador=True):
os.system('cls' if os.name == 'nt' else 'clear')
if turnoJugador:
print("Cartas de %s: %s" % (jugador.nombre, cartasA))
print("Cartas de la casa: %s XX" % (cartasB[0]))
elif turnoJugador == False:
print("Cartas de %s: %s" % (jugador.nombre, cartasA))
print("Cartas de la casa: %s" % (cartasB))
if __name__ == '__main__':
#jugador = Jugador(input("Ingrese el nombre del jugador: "))
jugador = Jugador('Nico')
print("Hola {}".format(jugador))
mazo = Mazo()
mazo.nuevoMazo()
#apuesta = input("Ingrese el monto a apostar: ")
apuestas = 50
cartasA = [mazo.sacarCarta(), mazo.sacarCarta()]
cartasB = [mazo.sacarCarta(), mazo.sacarCarta()]
#print("Cartas de %s: %s %s" % (jugador.nombre,cartasA[0],cartasA[1]))
mostrarMesa()
if chequear21(cartasA) == False:
respuesta1 = 's'
while respuesta1 == 's' and chequearPerder(
cartasA) == False and chequear21(cartasA) == False:
respuesta1 = input("Desea una carta mas? (s/n): ")
if respuesta1 == 's':
class IA(Jugador):
def __init__(self, nombre, tablero):
self.nombre = nombre
self.mano = [] #Mano de la computadora
self.mazo = Mazo() #Objeto mazo para usar posteriormente
self.cartas = self.mazo.getCartas(
) #Conjunto de cartas no jugadas y que no posee el CPU con el cual se verán las posibilidades
self.posibilidades = Posibilidades(
) #Objeto manejador de posibilidades
self.arbol = ArbolDecision() #Objeto manejador del arbol de decisiones
self.tablero = tablero #Tablero en que se juega
self.juegos = [] #Manejador de posibles juegos
self.contador = 0
"""Metodo encargado de tomar una carta del mazo"""
def tomarCarta(self):
if (len(self.mazo.getCartas()) > 0):
self.mano.append(self.mazo.tomarCarta())
#Buscamos borrar del conjunto de cartas no jugado las cartas que posee el CPU
for i in self.mano:
for j in self.cartas:
if (j.toString() == i.toString()):
self.cartas.pop(self.cartas.index(j))
return "Hay cartas"
else:
return "Ya no hay cartas"
"""Getter de la mano de la CPU"""
def getMano(self):
return self.mano
"""Metodo encargado de recibir una carta, no del mazo"""
def recibeCarta(self, carta):
self.mano.append(carta)
"""Metodo encargado de actualizar los juegos posibles a futuro e indicar si todavia posibilidades calculadas"""
def actualizaPosibilidades(self):
#tam=0
self.getPosibilities()
inDeck = False
#Eliminamos la ultima carta jugada del conjunto de cartas posibles
iter = 0
for i in self.cartas:
if (i.toString() == self.tablero.getUltimaCarta().toString()):
self.cartas.pop(iter)
iter = iter + 1
#Checamos que la carta jugada se encuentre dentro de las posibilidades calculadas
#De ser asi agregamos dichas posibilidades en la lista de nuevas posibilidades
nuevoJuego = []
for i in self.juegos:
#print(i)
if (len(i) > 0):
if (i[0].toString() ==
self.tablero.getUltimaCarta().toString()):
#print(self.tablero.getUltimaCarta().toString())
inDeck = True
nuevoJuego.append(i)
#print("Saliendo")
#Si si se hay posibilidades las actualizamos
if (inDeck == True):
self.juegos = []
for i in nuevoJuego:
self.juegos.append(i)
else:
#Sino indicamos que no hay
#return False
return False
#self.actualizaPosibilidades()
"""Funcion encargada de dejar la siguiente carta"""
def dejaCarta(self):
#Obtenemos las posibilidades (Siempre se ven n turnos a futuro)
self.getPosibilities()
print("Falg 1")
#Si por algun motivo no hay jugadas y tras actualizar siguen sin haber posibles retornamos que no hay carta a dejar
if (len(self.juegos) == 0):
self.actualizaPosibilidades()
if (len(self.juegos) == 0):
return False
print("Flag 2")
#Checamos entre las mejores jugadas y elejimos un juego al azar
out = False
cont = 0
numeros = []
carta = None
#Checamos que no se haya jugado un comodin anteriormente
if (self.tablero.getUltimaCarta().getEfecto() != ""
or (self.tablero.getPenultimaCarta().getEfecto() != ""
and self.tablero.getUltimaCarta().getValue() == "")):
for i in self.mano:
if (i.getColor() == self.tablero.getUltimaCarta().getColor()):
carta = i
break
else:
#Si quedan pocos juegos le damos prioridad a los comodines
if (len(self.juegos[0]) <= 1
and self.tablero.getUltimaCarta().getEfecto() == ""
and self.tablero.getPenultimaCarta().getEfecto() == ""):
for i in self.juegos:
#print("Flag 3")
if (len(i) > 0):
if (i[0].getEfecto() != "" and
(i[0].getColor() == "" or i[0].getColor()
== self.tablero.getUltimaCarta().getColor())):
print("Flag 4")
carta = i[0]
out = True
break
if (carta == None):
while (out == False):
carta = None
#Si no agarramos una de entre todas las cartas
r = random.randint(0, len(self.juegos) - 1)
if (numeros.count(r) == 0):
print(r)
numeros.append(r)
#Obtenemos el r-esimo juego y su primera carta
juego = self.juegos[r]
cont = cont + 1
if (len(juego) > 0):
carta = juego[0]
#Si la carta esta en la mano de la IA, que deberia, checamos si es valido usando PAT
#for i in self.mano:
#if(i.toString() == carta.toString()):
out = jugadaValida([
self.tablero.getPenultimaCarta(),
self.tablero.getUltimaCarta(), carta
])
#break
print("Jugada:", out)
#Igualmente checamos que no hayamos intentado ya con todas las posibilidades que hay
if (cont >= len(self.juegos)):
return False
print("Saliendo")
if (type(carta) is type(None)):
return False
#Ya que el juego es valido obtenemos todos los juegos que contienen esa carta en dicho paso
nuevoJuego = []
for i in self.juegos:
if (len(i) > 0):
if (type(i[0]) is type(carta)):
if (i[0].toString() == carta.toString()):
i.pop(0)
nuevoJuego.append(i)
#Actualizamos la lista de juegos
self.juegos = []
for i in nuevoJuego:
self.juegos.append(i)
#Eliminamos la carta de nuestra mano
iter = 0
for i in self.mano:
if (type(i) is type(carta)):
if (i.toString() == carta.toString()):
self.mano.pop(iter)
break
iter = iter + 1
#La retornamos
return carta
"""Metodo encargado de mostrar la mano de la computadora (usado para depuracion)"""
def mostrarMano(self):
iter = 0
for carta in self.mano:
print(str(iter) + ") ", end="")
carta.mostrar()
iter = iter + 1
"""Getter del atributo Nombre"""
def getName(self):
return self.nombre
"""Funcion encargada de obtener todos los posibles juegos"""
def getPosibilities(self):
#Reiniciamos la lista de opciones
self.juegos = []
#Hacemos que el arbol vuelva a calcular las posibilidades y las guardamos en una lista
self.arbol.setRoot(self.tablero.getUltimaCarta())
self.arbol.insertPosibilities(self.cartas, self.mano, 5,
self.arbol.getRoot())
juegos = self.posibilidades.getCards(self.arbol)
for i in juegos:
if (i[len(i) - 1].getEfecto() != ""):
self.juegos.append(i)
#Si las posibilidades siguen vacías obtenemos un n numero de jugadas
#if(len(self.juegos)==0):
numeros = []
for i in range(0, len(juegos)):
r = random.randint(0, len(juegos) - 1)
if (numeros.count(r) == 0):
numeros.append(r)
self.juegos.append(juegos[r])
#No se que hace esta linea, favor de no quitar
for i in self.juegos:
if (len(i) > 0):
i.pop(0)
#print("Juegos:",self.juegos)
"""Funcion encargada de ver si es un momento optimo para dejar un comodin +4"""
def ifDejaMasCuatro(self):
carta = False
color = ""
#Checamos que sea un momento optimo para tirarlo o que no tengamos mas cartas
if (self.contador < 3 or self.actualizaPosibilidades() == False):
iter = 0
#Checamos que tengamos el comodin
for i in self.mano:
if (i.getEfecto() == "Comodin +4"):
carta = self.mano.pop(iter)
#Buscamos cual es el color mas presente en nuestra mano para cambiar a usar dicho color
colors = [0, 0, 0, 0]
for i in self.mano:
if (i.getColor() == "Azul"):
colors[0] = colors[0] + 1
elif (i.getColor() == "Rojo"):
colors[1] = colors[1] + 1
elif (i.getColor() == "Amarillo"):
colors[2] = colors[2] + 1
else:
colors[3] = colors[3] + 1
highest = 0
#Vemos de que color se presentan mas
for i in range(1, 3):
if (colors[i] > colors[i - 1]):
highest = highest + 1
opciones = ["Azul", "Rojo", "Amarillo", "Verde"]
#Retornamos la carta +4 y el color a que cambiaremos
color = opciones[highest]
return [carta, color]
iter = iter + 1
#Retornamos que no hay carta +4 y no cambiaremos de color
return [carta, color]
"""Funcion encargada de ver si es un momento optimo para dejar un comodin cambio de color"""
def ifDejaComodinColor(self):
carta = False
color = ""
#Checamos que sea un momento optimo para tirarlo o que no tengamos mas cartas
if (len(self.mano) == 2):
for i in self.mano:
#Vemos que tenemos el comodin en caso de que queden solo dos cartas
if (i.getEfecto() == "Comodin"):
carta = i
#Checamos el color de la otra carta para cambiar a dicho color
if (self.mano[0].getColor() != ""):
color = self.mano[0].getColor()
else:
color = self.mano[1].getColor()
break
elif (self.actualizaPosibilidades() == False):
iter = 0
#En caso de no tener cartas para tirar obtenemos la carta
for i in self.mano:
if i.getEfecto() == "Comodin":
break
iter = iter + 1
if (iter < len(self.mano)):
carta = self.mano.pop(iter)
#Proceso para ver cuantas cartas hay de cada color
colors = [0, 0, 0, 0]
for i in self.mano:
if (i.getColor() == "Azul"):
colors[0] = colors[0] + 1
elif (i.getColor() == "Rojo"):
colors[1] = colors[1] + 1
elif (i.getColor() == "Amarillo"):
colors[2] = colors[2] + 1
else:
colors[3] = colors[3] + 1
#Vemos que carta hay de mas colores
highest = 0
for i in range(1, 3):
if (colors[i] > colors[i - 1]):
highest = highest + 1
opciones = ["Azul", "Rojo", "Amarillo", "Verde"]
color = opciones[highest]
#Retornamos la carta +4 y el color a que cambiaremos o que no tenemos la carta segun el caso
return [carta, color]
"""Funcion encargada de actualizar el contador de cartas del juego"""
def setContador(self, cont):
self.contador = cont
"""Metodod encargado de retonar el tamaño de la mano de cartas restantes"""
def getTamCartas(self):
return len(self.mano)
