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)