예제 #1
0
class Controlador:
    def __init__(self):
        self.game = Juego()
        self.interfaz = Interfaz(self)
        self.turno = 1

        #se instancian los jugadores
        self.jugador1 = Jugador(Pieza(1, 1), "Jugador 1")
        self.jugador2 = Jugador(Pieza(2, 2), "Jugador 2")

        #posiciones del tablero y tamanos
        self.cuadro = 50
        self.borde = 20
        self.tableroPos = 30
        self.BOARD_SIZE = 400
        self.nombreIngresado1 = ''
        self.nombreIngresado2 = ''

    def start(self):
        self.interfaz.game_menu()

    def get_tablero(self):
        return self.game.get_tablero()

#por el momento solo csv

    def leer_archivo(self, name):
        count_info = 0
        count_lineas = 1
        with open(name, newline='') as File:
            reader = csv.reader(File)
            for row in reader:
                if count_lineas % 2 != 0:
                    if count_info < 8:
                        self.game.llenar_tablero(row, count_info)
                    else:
                        self.turno = self.game.llenar_fichas(row)

                    count_info = count_info + 1

                count_lineas = count_lineas + 1

#por el momento solo csv

    def crear_archivo(self, name):
        myFile = open(name, 'w')
        with myFile:
            writer = csv.writer(myFile)
            writer.writerows(self.game.get_valores_tablero())
            writer.writerows(self.game.get_estado_juego(self.turno))

    def reset(self):
        self.game.clean_game()
        self.turno = 1

    def jugar_turno(self, x, y):
        pos_valida = self.convertir_pos(x, y)
        #esto es para colocar alguna ficha en el tablero(matriz) debe ser una posicion valida
        if self.turno == 1 and pos_valida != (
                -1, -1):  #si el jugador es ficha negra
            if self.game.set_ficha(pos_valida[0], pos_valida[1],
                                   1):  #si se logro colocar la ficha
                self.set_turno(2)  # ahora pasa a ser la ficha blanca
                self.game.cambiar_turno(2)
                if not self.game.hay_movimientos_validos():
                    self.set_turno(1)
                    self.game.cambiar_turno(1)
        elif self.turno == 2 and pos_valida != (
                -1, -1):  #si el jugador es ficha blanca
            if self.game.set_ficha(pos_valida[0], pos_valida[1],
                                   2):  #si se logro colocar la ficha
                self.set_turno(1)
                self.game.cambiar_turno(1)
                if not self.game.hay_movimientos_validos():
                    self.set_turno(2)
                    self.game.cambiar_turno(2)

    def setNombreJugador1(self):
        self.jugador1.set_nombre(self.nombreIngresado1)

    def getNombreJugador1(self):
        return self.jugador1.get_nombre()

    def setNombreJugador2(self):
        self.jugador2.set_nombre(self.nombreIngresado2)

    def getNombreJugador2(self):
        return self.jugador2.get_nombre()

    def get_reglas(self):
        #string con las reglas.
        reglas = [
            "El objetivo del juego es tener mas fichas del propio color.",
            "De inicio se colocan cuatro fichas como en el tablero:",
            "Dos fichas blancas en D4 y E5, y dos negras en E4 y D5.",
            "Comienzan a mover las negras: Un movimiento consiste",
            "en colocar una ficha propia sobre el tablero de",
            "forma que \'flanquee\' una o varias fichas contrarias.",
            "Las fichas flanqueadas son volteadas para mostrar",
            "el color propio. Es obligatorio voltear todas",
            "las fichas flanqueadas entre la ficha que se coloca",
            "y las que ya estaban colocadas.",
            "Una vez volteadas las fichas el turno pasa al contrario",
            "que procede de la misma forma con sus fichas.",
            "Si un jugador no tiene ninguna posibilidad",
            "de mover, el turno pasa al contrario.",
            "La partida termina cuando ninguno de los dos jugadores puede mover.",
            "Normalmente cuando el tablero esta lleno o practicamente lleno.",
            "Gana el jugador que acaba con mas fichas propias",
            "sobre el tablero Es posible el empate.", "Disfruta el Juego!"
        ]
        return reglas

    def set_turno(self, valor):
        self.turno = valor

    def get_turno(self):
        return self.turno

    def get_num_negras(self):
        return self.game.get_num_negras()

    def get_num_blancas(self):
        return self.game.get_num_blancas()

    def get_mover_negras(self):
        return self.game.get_mover_negras()

    def get_mover_blancas(self):
        return self.game.get_mover_blancas()

    def convertir_pos(self, mouse_x, mouse_y):
        # click was out of board, ignores
        if mouse_x > self.BOARD_SIZE + 50 or \
         mouse_x < 50 or \
         mouse_y > self.BOARD_SIZE + 50 or \
         mouse_y < 50:
            position = (-1, -1)
            return position

        # find place
        position = ((mouse_x - 50) // self.cuadro), ((mouse_y - 50) //
                                                     self.cuadro)
        # flip orientation
        position = (position[1], position[0])
        continar = False
        return position

    def eventos_reglas(self):
        for tipoEvento in pygame.event.get():
            if tipoEvento.type == pygame.QUIT:
                self.interfaz.quit()

            if tipoEvento.type == pygame.KEYDOWN:
                if tipoEvento.key == pygame.K_ESCAPE:
                    self.interfaz.blit()
                    return False
        return True

    def eventos_menu(self):
        for tipoEvento in pygame.event.get():
            if tipoEvento.type == pygame.QUIT:
                self.interfaz.quit()
        return True

    def eventos_tablero(self):
        for tipoEvento in pygame.event.get():
            if tipoEvento.type == pygame.QUIT:
                self.interfaz.quit()

            elif tipoEvento.type == pygame.KEYDOWN:
                if tipoEvento.key == pygame.K_ESCAPE:
                    self.interfaz.blit()
                    return False

            elif tipoEvento.type == pygame.MOUSEBUTTONUP:
                pos = pygame.mouse.get_pos()
                self.jugar_turno(pos[0], pos[1])

        return True

    def eventos_elegir_color(self, active1, active2):

        for tipoEvento in pygame.event.get():
            if tipoEvento.type == pygame.QUIT:
                self.interfaz.quit()

            if tipoEvento.type == pygame.KEYDOWN:
                if tipoEvento.key == pygame.K_ESCAPE:
                    self.interfaz.blit()
                    return False

                if tipoEvento.key == pygame.K_RETURN:
                    self.interfaz.guardar_jugadores()

                if active1:
                    if tipoEvento.key == pygame.K_BACKSPACE:
                        self.nombreIngresado1 = self.nombreIngresado1[:-1]
                    else:
                        self.nombreIngresado1 += tipoEvento.unicode
                    # Re-render the text.

                    self.interfaz.font_render(self.nombreIngresado1, 1)

                if active2:
                    if tipoEvento.key == pygame.K_BACKSPACE:
                        self.nombreIngresado2 = self.nombreIngresado2[:-1]
                    else:
                        self.nombreIngresado2 += tipoEvento.unicode
                        # Re-render the text.

                    self.interfaz.font_render(self.nombreIngresado2, 2)

            if tipoEvento.type == pygame.MOUSEBUTTONDOWN:
                # If the user clicked on the input_box rect.
                if self.interfaz.click_box(tipoEvento.pos, 1):
                    # Toggle the active variable.
                    return 2
                # If the user clicked on the input_box rect.
                if self.interfaz.click_box(tipoEvento.pos, 2):
                    # Toggle the active variable.
                    return 3

        return True
예제 #2
0
class Controlador(ControladorAbs):
	def __init__(self):
		self.interfaz = Interfaz(self)
		self.validador = Validador()
		#con estas variables se crea un tablero con filas=f y columnas=c
		#ademas la variable turno sera para el que es el jugador que juega en cada intante siendo i el tipo de pieza o colo a como se quiera definir
		self.tablero = Tablero(f,c) # Crea un tablero 8 x 8  
		self.turno = i

		#se instancian los jugadores
		#todos los juegos tienen dos jugadores 
		#donde i = tipo de pieza y j = color de pieza
		self.jugador1 = Jugador(Pieza(i,j),"Jugador 1") # Jugador con piezas negras
		self.jugador2 = Jugador(Pieza(i,j),"Jugador 2") # Jugador con piezas blancas
		self.nombreIngresado2 = ""
		self.nombreIngresado1 = ""
		#posiciones del tablero y tamanos
		#dichas variables para el tablero y distintos aspectos de dicho que se pueden cambiar a como desee el usuario del framework
		self.espacioVentanaTablero = 
		self.cuadro = 
		self.borde = 
		self.tableroPos = 
		self.BOARD_SIZE = 


	def start(self):
		#inicia la interfaz
		self.interfaz.game_menu()

	def get_tablero(self):
		return self.tablero.get_tablero()

	def get_turno(self):
		return self.turno

	def reset(self):
		##este metodo resetea el estado del juego 
		self.tablero.limpiar_tablero()
		self.validador.reset_validador()
		#con el turno i = tipo de ficha que se juega primerp
		self.turno=i
		#se vuelven a crear los jugadores
		#donde i = tipo de pieza y j = color de pieza
		self.jugador1 = Jugador(Pieza(i,j),"Jugador 1")
		self.jugador2 = Jugador(Pieza(i,j),"Jugador 2")
		
	def jugar_turno(self,x,y):
		pos_valida = self.convertir_pos(x,y)
		#esto es para colocar alguna ficha en el tablero(matriz) debe ser una posicion valida
		##este metodo realza la accion de jugar un turno cambiando el turno a la ficha que sigue
		#donde i= es el tipo de ficha con el turno actual y j = el tipo de ficha que sigue
		if self.turno==i and pos_valida!=(-1,-1):#pos valida en el rango del tablero con el mouse
			if self.validador.set_ficha(pos_valida[0], pos_valida[1], i, self.tablero):#si se logro colocar la ficha
				self.set_turno(j) # ahora pasa a la siguiente tipo de ficha
				self.validador.cambiar_turno(j, self.tablero)
				if not self.validador.hay_movimientos_validos(self.tablero):
					self.set_turno(i)
					self.validador.cambiar_turno(i, self.tablero)
		


	def setNombreJugador1(self):
		self.jugador1.set_nombre(self.nombreIngresado1)
		

	def getNombreJugador1(self):
		self.jugador1.set_nombre(self.nombreIngresado1)
		return self.jugador1.get_nombre()

	def setNombreJugador2(self):
		self.jugador2.set_nombre(self.nombreIngresado2)

	def getNombreJugador2(self):
		self.jugador2.set_nombre(self.nombreIngresado2)
		return self.jugador2.get_nombre()

	def get_reglas(self):
		#string con las reglas.
		#se llena el vector con las reglas del juego
		reglas = ["AQUI VAN LAS REGLAS"]
		return reglas

	def set_turno(self, ficha_que_sigue):
		#setea al la pieza que sigue
		self.turno = ficha_que_sigue

		
	#busca la cantidad de piezas en el tablero de una pieza especifica
	def get_num_piezas(self, pieza):
		return self.tablero.get_num_piezas(pieza)
		
	def get_filas(self):
		return self.tablero.get_filas()
		
	def get_columnas(self):
		return self.tablero.get_columnas()

	def convertir_pos(self,mouse_x ,mouse_y ):
		#CON ESTE METODO SE CONVIERTE LA POSICION DEL MOUESE EN UNA POSICION DEL TABLERO VALIDA SEGUN LOS PARAMETROS ESTABLECIDOS 
		#POR EL USUARIO DEL FRAMEWORK
		if mouse_x > self.BOARD_SIZE + self.espacioVentanaTablero or \
			mouse_x < self.espacioVentanaTablero or \
			mouse_y > self.BOARD_SIZE + self.espacioVentanaTablero or \
			mouse_y < self.espacioVentanaTablero:
			position = (-1,-1)
			return position

		
		position = ((mouse_x - self.espacioVentanaTablero) // self.cuadro),((mouse_y - self.espacioVentanaTablero) // self.cuadro)
		position = (position[1], position[0])
		continar = False
		return position

	
	#METODOS DE EVENTOS QUE APLICAN PARA TODOS LOS JUEGOS DE TABLER0

	#TODOS DEBEN TENER UNA OPCION PARA MOSTRAR REGLAS
	def eventos_reglas(self):
		for tipoEvento in pygame.event.get():
			if tipoEvento.type == pygame.QUIT:
					self.interfaz.quit()

			if tipoEvento.type == pygame.KEYDOWN:
				if tipoEvento.key == pygame.K_ESCAPE:
					self.interfaz.blit()
					return False
		return True
		
	#TODOS DEBEN TENER UNA OPCION DEL GAME MENU INICIAL
	def eventos_menu(self):
		for tipoEvento in pygame.event.get():
			if tipoEvento.type == pygame.QUIT:
					self.interfaz.quit()
		return True

	
	#TODOS DEN TENER UNA OPCION QUE MUESTRE TABLERO
	def eventos_tablero(self):
		for tipoEvento in pygame.event.get():
			if tipoEvento.type == pygame.QUIT:
				self.interfaz.quit()
			
			elif tipoEvento.type == pygame.KEYDOWN:
				if tipoEvento.key == pygame.K_ESCAPE:
					self.interfaz.blit()
					return False
			
			elif tipoEvento.type == pygame.MOUSEBUTTONUP:
				pos = pygame.mouse.get_pos()
				self.jugar_turno(pos[0],pos[1])
		

		return True



	#TODOS TIENEN DOS JUGADORES Y UNA OPCION DONDE SE ELIGA COLOR O TIPO DE FICHAS 
	#Y SE ASIGNEN NOMBRES DE JUGADOR
	def eventos_elegir_color(self,active1,active2):
		
		for tipoEvento in pygame.event.get():
			if tipoEvento.type == pygame.QUIT:
					self.interfaz.quit()
				
			if tipoEvento.type == pygame.KEYDOWN:
				if tipoEvento.key == pygame.K_ESCAPE:
					self.interfaz.blit()
					return False
						
				if tipoEvento.key== pygame.K_RETURN:
					self.interfaz.guardar_jugadores()


		return True
예제 #3
0
class Controlador:
    def __init__(self):
        self.game = Game()
        self.interfaz = Interfaz(self)
        self.turno = 1
        self.nombreJugador1 = "Jugador 1"
        self.nombreJugador2 = "Jugador 2"
		#posiciones del tablero y tamanos
        self.cuadro = 50
        self.borde = 20
        self.tableroPos = 30
        self.BOARD_SIZE = 400


    def start(self):
        self.interfaz.game_menu()

    def get_tablero(self):
        return self.game.get_tablero()
    #por el momento solo csv
    def leer_archivo(self, name):
       count_info=0
       count_lineas=1
       with open(name , newline='') as File:
           reader = csv.reader(File)
           for row in reader:
               if count_lineas % 2!=0:
                   if count_info < 8 :
                       self.game.llenar_tablero(row,count_info)
                   else:
                       self.turno=self.game.llenar_fichas(row)

                   count_info=count_info+1

               count_lineas=count_lineas+1



    #por el momento solo csv
    def crear_archivo(self, name):
        myFile = open(name, 'w')
        with myFile:
            writer = csv.writer(myFile)
            writer.writerows(self.game.get_tablero())
            writer.writerows(self.game.get_estado_juego(self.turno))

    def reset(self):
        self.game.clean_game()
        self.turno=1

    def jugar_turno(self,x,y):
        pos_valida = self.convertir_pos(x,y)
        #esto es para colocar alguna ficha en el tablero(matriz) debe ser una posicion valida
        if self.turno==1 and pos_valida!=(-1,-1):#si el jugador es ficha negra
            if self.game.set_ficha(pos_valida[0],pos_valida[1],1):#si se logro colocar la ficha
                self.set_turno(2) # ahora pasa a ser la ficha blanca
                self.game.cambiar_turno(2)
                if not self.game.hay_posiciones():
                    self.set_turno(1)
                    self.game.cambiar_turno(1)
        elif self.turno==2 and pos_valida!=(-1,-1):#si el jugador es ficha blanca
            if self.game.set_ficha(pos_valida[0],pos_valida[1],2):#si se logro colocar la ficha
                self.set_turno(1)
                self.game.cambiar_turno(1)
                if not self.game.hay_posiciones():
                    self.set_turno(2)
                    self.game.cambiar_turno(2)
				    

    def setNombreJugador1(self,nombre):
        self.nombreJugador1 = nombre

    def getNombreJugador1(self):
        return self.nombreJugador1

    def setNombreJugador2(self,nombre):
        self.nombreJugador2 = nombre

    def getNombreJugador2(self):
        return self.nombreJugador2

    def get_reglas(self):
        #string con las reglas.
        reglas = ["El objetivo del juego es tener mas fichas del propio color.",
        "De inicio se colocan cuatro fichas como en el tablero:",
        "Dos fichas blancas en D4 y E5, y dos negras en E4 y D5.",
        "Comienzan a mover las negras: Un movimiento consiste",
        "en colocar una ficha propia sobre el tablero de",
        "forma que \'flanquee\' una o varias fichas contrarias.",
        "Las fichas flanqueadas son volteadas para mostrar",
        "el color propio. Es obligatorio voltear todas",
        "las fichas flanqueadas entre la ficha que se coloca",
        "y las que ya estaban colocadas.",
        "Una vez volteadas las fichas el turno pasa al contrario",
        "que procede de la misma forma con sus fichas.",
        "Si un jugador no tiene ninguna posibilidad",
        "de mover, el turno pasa al contrario.",
        "La partida termina cuando ninguno de los dos jugadores puede mover.",
        "Normalmente cuando el tablero esta lleno o practicamente lleno.",
        "Gana el jugador que acaba con mas fichas propias",
        "sobre el tablero Es posible el empate.",
        "Disfruta el Juego!"]
        return reglas

    def set_turno(self, valor):
        self.turno = valor

    def get_turno(self):
        return self.turno

    def get_num_negras(self):
        return self.game.get_num_negras()

    def get_num_blancas(self):
        return self.game.get_num_blancas()

    def get_mover_negras(self):
        return self.game.get_mover_negras()

    def get_mover_blancas(self):
        return self.game.get_mover_blancas()

    def convertir_pos(self,mouse_x ,mouse_y ):
        # click was out of board, ignores
        if mouse_x > self.BOARD_SIZE + 50 or \
            mouse_x < 50 or \
            mouse_y > self.BOARD_SIZE + 50 or \
            mouse_y < 50:
            position = (-1,-1)
            return position

        # find place
        position = ((mouse_x - 50) // self.cuadro),((mouse_y - 50) // self.cuadro)
        # flip orientation
        position = (position[1], position[0])
        continar = False
        return position