class StartQt4(QtGui.QMainWindow): def __init__(self, parent=None): QtGui.QWidget.__init__(self,parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.view = BoardView(self.ui.graphicsView) self.opponent = Ai() #event bindings QtCore.QObject.connect(self.ui.newGameButton,QtCore.SIGNAL("clicked()"),self.newGame) def newGame(self): self.view.clearBoard() self.board = None self.ui.winnerLabel.setText("Player goes first") def mousePressEvent(self, event): """ Event executed after every mouse press; All internal game loop logic contained here """ if self.view.winCheck(): self.playerWin() #AI move self.opponent.updateBoard(self.view.boardMatrix) self.opponent.move() #check win def playerWin(self): self.ui.winnerLabel.setText("Congratulations! You won!")
def runAI_2(self, weights, limitPiece): self.gameover = False self.paused = False #dont_burn_my_cpu = pygame.time.Clock() while 1: if (self.nbPiece >= limitPiece and limitPiece > 0) or (self.moves_left <= 0): self.gameover = True if self.playWithUI: self.gui.update(self) if self.gameover: return self.lines * 1000 + self.nbPiece if not self.computed: self.computed = True Ai.choose(self.board, self.stone, self.next_stone, self.stone_x, weights, self) if self.playWithUI: for event in pygame.event.get(): if event.type == pygame.USEREVENT + 1: self.drop(True) elif event.type == pygame.QUIT: self.quit() elif event.type == pygame.KEYDOWN: if event.key == eval("pygame.K_s"): self.speed_up() elif event.key == eval("pygame.K_p"): self.toggle_pause()
def test_random(self): board = Board(tk.Toplevel()) ai = Ai('black', board.squares, board, None, None) ai.random() piece = board.squares[(ai.rowpiece, ai.colpiece)]['piece'] if piece is not None: self.assertTrue(piece.color == 'black')
def __init__(self): self._board = Board() self._other_board = Board() self._game = Game(self._board) self.control_game = Game(self._other_board) # Takes the exact board as the displayed game self._ai = Ai(self.control_game)
def click(self, button): """Print symbol in button. Create Ai object, leads the gameplay of player and ai, check wrong moves and draw.""" intel = Ai() if button['text'] == ' ' and Button.clickable: if Game.computer_move_quantity < 4: button['text'] = 'X' Game.player_move_quantity += 1 Button.clickable = False gameboardcls.Gameboard.gameboard_obj.check_global_win('X') if not Button.clickable: if Game.player_move_quantity <= 4: intel.move_to_win() Game.computer_move_quantity += 1 Button.clickable = True gameboardcls.Gameboard.gameboard_obj.check_global_win( 'O') else: messagebox.showinfo( 'Attention', 'It seems to be a draft\n Lets restart game') self.new_game_button_func() else: messagebox.showinfo( 'Attention', 'It seems to be a draft\n Lets restart game') self.new_game_button_func() else: messagebox.showerror( 'Attention', 'Oops... This button has already been pushed\n Choose another one' )
def __init__(self): pygame.init() self.manager = GameManager() self.enemy = Ai() pygame.display.set_caption("Tic Tac Toe") self.WIDTH = 540 self.HEIGHT = 540 self.screen = pygame.display.set_mode((self.WIDTH, self.HEIGHT)) self.background = pygame.Surface((self.WIDTH, self.HEIGHT)) self.background.fill(pygame.Color('#E3E3E3')) # FONTS self.playerFont = pygame.font.SysFont('arial', 70) self.resultFont = pygame.font.SysFont('arial', 60, bold=True) self.infoFont = pygame.font.SysFont('arial', 30, italic=True) # define cell dimensions self.cellWidth = self.WIDTH / 3 self.cellHeight = self.HEIGHT / 3 self.board = [] # to create the 3x3 grid for i in range(3): for j in range(3): self.board.append( Cell(self.cellWidth * i, self.cellHeight * j, self.cellWidth, self.cellHeight)) self.manager.gameState = 'progress' self.running = True
def startGame(): '''Start the game.''' print "The computer makes the first step" ai = Ai() started = True ai.play() print "The board now looks like this:" printBoard(convert(status))
def get_move(): fen_str = request.args.get('fen') print(fen_str) if fen_str is None: return "Provide fen" ai = Ai() value, move = ai.get_move(fen_str=fen_str) return move
def index(): rawData = request.get_json() if rawData: fetch = [block for block in rawData['boardInfo']['blocks']] blocks = sorted(fetch, key=lambda k: k['x']) ai = Ai(blocks, rawData['side']) #logging.debug('EXPECT:' + str(ai.expect_score)) move = ai.get_move_score() #logging.debug('MOVE:' + str(move)) keep = ai.get_keep_score() #logging.debug('KEEP:' + str(keep)) flip = ai.get_flip_score() #logging.debug('FLIP:' + str(flip)) collector = {'move': move, 'keep': keep, 'flip': flip} scores = { 'move': move['score'], 'keep': keep['score'], 'flip': flip['score'] } action = max(scores, key=scores.get) if action == 'keep': scores.pop('keep') action = max(scores, key=scores.get) result = collector[action] logging.error( str({ 'EXPECT': ai.expect_score, 'MOVE': move, 'KEEP': keep, 'FLIP': flip, 'RESULT': result, 'DETAIL': { 'move': move['detail'], 'keep': keep['detail'], 'flip': flip['detail'] } })) if result['action'] == 'move': return jsonify({ 'pid': result['from']['id'], 'type': 'move', 'x': result['block']['x'], 'y': result['block']['y'] }) elif result['action'] == 'flip': return jsonify({ 'pid': result['block']['id'], 'type': 'flip', 'x': None, 'y': None }) else: # TODO return jsonify({'pid': None, 'type': 'keep', 'x': None, 'y': None})
def runAI_1(self, weights, limitPiece): key_actions1 = { 'ESCAPE': self.quit, 'LEFT': lambda: self.move(-1), 'RIGHT': lambda: self.move(+1), 'DOWN': lambda: self.drop(True), 'UP': self.rotate_stone, 'p': self.toggle_pause, 'SPACE': self.start_game, 'RETURN': self.insta_drop } key_actions2 = { 'ESCAPE': self.quit, 'a': lambda: self.move(-1), 'd': lambda: self.move(+1), 's': lambda: self.drop(True), 'w': self.rotate_stone, 'p': self.toggle_pause, 'SPACE': self.start_game, 'LSHIFT': self.insta_drop } self.gameover = False self.paused = False #slow it down pygame.time.set_timer(pygame.USEREVENT + 1, 750) dont_burn_my_cpu = pygame.time.Clock() while 1: if (self.nbPiece >= limitPiece and limitPiece > 0) or (self.moves_left <= 0): self.gameover = True if self.playWithUI: self.gui.update(self) if self.gameover: return self.lines * 1000 + self.nbPiece if not self.computed: self.computed = True Ai.choose(self.board, self.stone, self.next_stone, self.stone_x, weights, self) if self.playWithUI: for event in pygame.event.get(): if event.type == pygame.USEREVENT + 1: self.drop(True) elif event.type == pygame.QUIT: self.quit() elif event.type == pygame.KEYDOWN: if self.player == 1: if event.key == eval("pygame.K_p"): self.toggle_pause() elif self.player == 2: for key in key_actions2: if event.key == eval("pygame.K_" + key): key_actions2[key]()
def init_players(self): self.bot = Ai(self.choices[randint(0,1)]); self.player = "X" if self.bot.choice == "O" else "O" if randint(0,1) == 1: self.bot.make_move(self.board, self.winning_combos) greeting = "Hello Player! Bot plays first! You are playing with \"" + self.player + "\"" else: greeting = "Hello Player! You are playing with \"" + self.player + "\"" self.popup_message(greeting)
class Connect4(): def __init__(self): self.game_board = board.Board() self.moves = self.game_board.moves self.player1 = Ai(self.moves) self.player2 = Ai(self.moves) def test(self, input_values): def mock_input(s): print(s) return input_values.pop(0) human.input = mock_input def start(self): self.players() player = 2 not_over = True turn = 1 while not_over and turn <= 42: if player == 1: player = 2 self.game_board.make_move(2, self.player2.move()) else: player = 1 self.game_board.make_move(1, self.player1.move()) self.show_board() not_over = not self.gameover() turn += 1 if not_over == True: print("It's a Draw!") else: self.show_board() print(f'Player {player} wins') def show_board(self): string = "" i = len(self.game_board.game_board) - 1 while i > -1: row = self.game_board.game_board[i] for token in row: string += f'|{token}|' string += "\n" i -= 1 print(string) def gameover(self): return self.game_board.moves.check_win() def players(self): if input("Player 1 is a Human or AI?") == "Human": self.player1 = human.Human(self.moves) if input("Player 2 is a Human or AI?") == "Human": self.player2 = human.Human(self.moves) return
def __init__(self, root): self.__root = root self.__board = Board(root) self.__bag = Bag() self.__human = Human(root) self.__ai = Ai(root, self.__board, self.__bag) self.__turn = 1 self.__player = self.__human self.__human_score = StringVar() self.__ai_score = StringVar()
def predict(): # Getting the data transmitted in a JSON by the POST request parameters = request.get_json(force=True) # Creating the AI ai = Ai() # Checking if the POST request was made from Postman if str(parameters['image'])[0] == '/': predicted_value: int = ai.predict(parameters['image'], True) else: # Collecting image from JSON picture_request = str(parameters['image']) starter = picture_request.find(',') image_data = picture_request[starter + 1:] image_data = bytes(image_data, encoding="ascii") # The image has been transferred encoded in base64 model, the line just below decode it and create an image form it with open('./assets/image.jpeg', 'wb') as fh: fh.write(base64.decodebytes(image_data)) # Launching the prediction predicted_value: int = ai.predict("./assets/image.jpeg", True) # Creating the data for the JSON file to be returned data_set = { "image": { "name": parameters['image'], "reshaped size": "28*28", "color scale": "grey scale" }, "Multi-Layers Perceptron spec": { "hidden_layer_sizes": "(200,)", "activation": "logistic", "alpha": "1e-4", "solver": "sgd", "tol": "1e-4", "random_state": 2, "max_iter": 200, "learning_rate_init": .0001, "verbose": "True" }, "ML algorithm score on NMIST digits": { "time": "0:05:53", "accuracy score on training data": "0.960970871012443" }, "Predicted value": predicted_value } # Creating the JSON json_to_be_returned = json.dumps(data_set) # Returning the JSON return json_to_be_returned
def define_contestants(self): # prompts user to pick a human or ai opponent self.opening_statement() opponent = input("\nPress 1 to play against a Human or type anything else to play against an AI" "\n >") if opponent == '1': self.player_one = Human() self.player_two = Human() else: self.player_one = Human() self.player_two = Ai()
def action(self, ai: ai.Ai, radblock: randomwall.Radblock, beans: randomwall.Beans, wall: randomwall.Wall): self.__move(ai.points, wall.points1, radblock.points2) if self.__point == beans.point3: ai.exchange = 1 radblock.init_points(ai.points, self.__point) beans.quickly_move(ai.points, radblock.points2, self.__point)
def main(): pb = PiecesBank() app = UI() ### DO NOT F*****G REMOVE THIS. I DARE YOU. ### app.preloadPieces(pb.pieceslist) ai = Ai() arbiter = Arbiter() board = Board() app.setBatchMethod(lambda loop, fitness, mutation: ai.main_function( pb, app, arbiter, board, loop, fitness, mutation)) # app.drawTable(board) app.drawTable(generatedSolvedPuzzle(pb)) ### DO NOT F*****G REMOVE THIS EITHER. ### app.mainloop()
def test_can_not_place_in_a_full_collum(): class Moves(): def __init__(self): self.legal_moves = [ "Full", [1, 0], [2, 0], [3, 0], [4, 0], [5, 0], [6, 0] ] move_array = [0, 1] def mock_move(): return move_array.pop(0) computer = Ai(Moves()) computer.select_move = mock_move i = 0 assert computer.move() == 1
def __init__(self, parent=None): QtGui.QWidget.__init__(self,parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.view = BoardView(self.ui.graphicsView) self.opponent = Ai() #event bindings QtCore.QObject.connect(self.ui.newGameButton,QtCore.SIGNAL("clicked()"),self.newGame)
def __init__(self, rows=None, cols=None): self.rows = rows or 6 self.cols = cols or 7 self.board = Board(self.rows, self.cols) player = input("Player 1 human or cpu?(h/c)") if player == 'h': self.players.append(Player("O")) else: self.players.append(Ai("O", 4)) player = input("Player 2 human or cpu?(h/c)") if player == 'h': self.players.append(Player("X")) else: self.players.append(Ai("X", 4)) self.currentTurn = self.players[0]
def initGame(): global MINE_LEFT mines = initMines() numbers = initNumbers(mines) marked = initMarked() revealed = initRevealed() ai = Ai(mines, revealed, marked, numbers, TILE_H_NUMBER, TILE_V_NUMBER, MINE_COUNT) MINE_LEFT = MINE_COUNT return mines, numbers, revealed, marked, ai
def test(): newB = B() newS = s(newB) newAi = AI(newB, newS) newS.move(0, 0, 1) assert newB.get_b(0, 0) == 1 count = 0 for i in range(6): for j in range(6): if newB.get_b(i, j) == 1: count += 1 assert count == 1 newS.move(0, 1, 1) newS.move(0, 2, 1) newS.move(0, 3, 1) assert newS.Order_won() == False newS.move(0, 4, 1) assert newS.Order_won() == True assert newAi.free_moves() == 6 * 6 - 5
def start(): g = Game() try: choice2 = (int(input("Write 1 to reload or 0 to have a new game:"))) if choice2 == 1: g.service.read_file() elif choice2 != 0: print("Wrong number!") except Exception as e: print(e) print(g) ai = Ai(g.board, g.service) while True: try: g.input() if g.service.Order_won() == True: raise ex.HumanWon("Order has Won!!!") ai.random_move() if g.service.Order_won() == True: raise ex.HumanWon("Order has Won!!!") print(g) ai.free_moves() except ex.HumanWon as e: print(e) break except Exception as e: print(e)
def __init__(self,tablero,jugador1,jugador2,con_jugadas_posibles=True,nivel=Ai.FACIL, write_path=""): #self.__gui = Gui() #self.__tablero = self.__gui.init_board().get_board() self.__tablero_g = tablero self.__tablero = tablero.get_logical_board() #Iniciliazo la inteligencia para la PC self.__pc = Ai(nivel) #Inicializo un vector de jugadores self.__jugadores = [jugador1,jugador2] self.__ganador = "" self.__nro_turno = 0 self.__termino_juego = False self.__juego_mesh = False self.__con_jugadas_posibles = con_jugadas_posibles self.__lista_jugadas_posibles = [] if write_path != "": #Imprimo en el log la configuracion del juego que se inicia try: f = open(os.path.abspath(write_path + "/data/game.log"),'r') f.close() self.__log_file = open(os.path.abspath(write_path + "/data/game.log"),'a') print >> self.__log_file, '\nGAME LOG: ' + time.asctime() except: self.__log_file = open(os.path.abspath(write_path + "/data/game.log"),'w') print >> self.__log_file, 'GAME LOG: ' + time.asctime() print >> self.__log_file, 'Tablero: ' + str(self.__tablero.get_dimension()) + 'x' + str(self.__tablero.get_dimension()) if jugador1.get_color() == board.BLANCO and jugador1.get_name() == PC: print >> self.__log_file, 'PC: Blanco' print >> self.__log_file, 'Jugador: Negro' elif jugador1.get_name() == HUMANO and jugador2.get_name() == HUMANO: if jugador1.get_color() == board.BLANCO: print >> self.__log_file, 'Jugador1: Blanco' print >> self.__log_file, 'Jugador2: Negro' else: print >> self.__log_file, 'Jugador1: Negro' print >> self.__log_file, 'Jugador2: Blanco' else: print >> self.__log_file, 'PC: Negro' print >> self.__log_file, 'Jugador: Blanco'
def __init__(self, root, parent, port, ip=None): self.game_obj = Game() self._ai_mode = False print('parent:', parent) print('port:', port) """ Initializes the GUI and connects the communicator. :param parent: the tkinter root. :param ip: the ip to connect to. :param port: the port to connect to. :param server: true if the communicator is a server, otherwise false. """ self._root = root self._parent = parent self.__communicator = Communicator(root, port, ip) self.__communicator.connect() self.__communicator.bind_action_to_message(self.__handle_message) self.__place_widgets() #self.frame = t.Frame(self._parent, width=800, height=800) self._canvas = t.Canvas(root, width=700, height=600, bg='blue') self._grid = t.Grid() #self.frame.pack() self._canvas.pack() self._create_circle() if parent == 'ai': self.ai_obj = Ai() self._ai_mode = True if (server == True and self.game_obj.get_current_player() == 0) or (server == False and self.game_obj.get_current_player() == 1): self.ai_move() else: self._canvas.bind("<Button-1>", self.callback)
def __init__(self, players, board_length, board_height, goal, gravity, depth, win): self.players = players self.board_length = board_length self.board_height = board_height self.goal = goal self.gravity = gravity self.win = win self.win_size = win.get_size() self.tile_length = int(self.win_size[0] * 0.9 / board_length) self.tile_height = int(self.win_size[1] * 0.9 / board_height) self.length_offset = int(self.win_size[0] * 0.05) self.height_offset = int(self.win_size[1] * 0.05) self.game_board = self.get_game_board() self.event = None self.turn = 0 self.winner = None self.ai = Ai(self.game_board, gravity, goal, players, depth)
def MainMenu(self): userInput = input( "Press 1 for Human vs AI, Press 2 for Human vs Human") if userInput != '1' and userInput != '2': self.MainMenu() if userInput == "1": self.p1 = Human("P1") self.p2 = Ai("P2", random) #console clear self.PlayGame() else: self.p1 = Human("P1") self.p2 = Human("P2") #console clear self.PlayGame()
def run(): pygame.init() screen = pygame.display.set_mode(Settings.resolution) pygame.display.set_caption('Snake') generate_all_positions(screen) wall = Wall(screen) snake = Snake(screen) food = Food(screen, snake) ai = Ai(screen, snake, food) Settings.ai = ai Settings.ai.get_shortest_path(food.rect.x, food.rect.y) Settings.ai.set_new_path() while True: check_events(screen, snake) update(screen, snake, food, ai, wall) time.sleep(0.01)
def create_player(self): """P1 is blue, P2 is Yellow, P3 is Red, P4 is Green, P5 is Purple.""" color_idx = len(constants.COLORS) - 1 for i in range(self.humans): x, y = self.get_random_coord() self.players.append( Player("P" + str(i + 1), x, y, constants.COLORS[color_idx])) color_idx -= 1 for i in range(self.bots): x, y = self.get_random_coord() self.players.append( Ai( "COM" + str(i + 1), x, y, constants.COLORS[color_idx], self.difficulty, )) color_idx -= 1
def __init__(self, tablero, jugador1, jugador2, con_jugadas_posibles=True, nivel=Ai.FACIL, write_path=""): # self.__gui = Gui() # self.__tablero = self.__gui.init_board().get_board() self.__tablero_g = tablero self.__tablero = tablero.get_logical_board() # Iniciliazo la inteligencia para la PC self.__pc = Ai(nivel) # Inicializo un vector de jugadores self.__jugadores = [jugador1, jugador2] self.__ganador = "" self.__nro_turno = 0 self.__termino_juego = False self.__juego_mesh = False self.__con_jugadas_posibles = con_jugadas_posibles self.__lista_jugadas_posibles = [] if write_path != "": # Imprimo en el log la configuracion del juego que se inicia try: f = open(os.path.abspath(write_path + "/data/game.log"), "r") f.close() self.__log_file = open(os.path.abspath(write_path + "/data/game.log"), "a") print >> self.__log_file, "\nGAME LOG: " + time.asctime() except: self.__log_file = open(os.path.abspath(write_path + "/data/game.log"), "w") print >> self.__log_file, "GAME LOG: " + time.asctime() print >> self.__log_file, "Tablero: " + str(self.__tablero.get_dimension()) + "x" + str( self.__tablero.get_dimension() ) if jugador1.get_color() == board.BLANCO and jugador1.get_name() == PC: print >> self.__log_file, "PC: Blanco" print >> self.__log_file, "Jugador: Negro" elif jugador1.get_name() == HUMANO and jugador2.get_name() == HUMANO: if jugador1.get_color() == board.BLANCO: print >> self.__log_file, "Jugador1: Blanco" print >> self.__log_file, "Jugador2: Negro" else: print >> self.__log_file, "Jugador1: Negro" print >> self.__log_file, "Jugador2: Blanco" else: print >> self.__log_file, "PC: Negro" print >> self.__log_file, "Jugador: Blanco"
def computer_v_computer(current_state, player1, player2): game_over = False while game_over is False: Ui.msg(BoardPresenter.display_terminal_board(current_state)) computers_move = Ai.make_move(current_state) BoardState.update_state(current_state, User.current_player, computers_move) if EndStates.did_a_player_win(current_state, User.current_player, win_config.winning_combos): Ui.msg(BoardPresenter.display_terminal_board(current_state)) Ui.msg('Game Over: ' + User.current_player + ' WINS!') return True if EndStates.is_draw(current_state): Ui.msg('DRAW. GameOver') return True if User.current_player == player1: User.switch_current_user(User.current_player, player2) else: User.switch_current_user(User.current_player, player1)
def human_v_computer(current_state, player1, player2): game_over = False while game_over is False: if User.current_player == player2: Ui.msg("Computer has moved") computers_move = Ai.make_move(current_state) BoardState.update_state(current_state, User.current_player, computers_move) if User.current_player == player1: User.switch_current_user(User.current_player, player2) User.switch_current_user(User.current_player, player1) else: response = False while response is False: Ui.msg( BoardPresenter.display_terminal_board(current_state)) response = CommandLinePrompt.get_input( "Enter a number from 1-9: ") response = UserActions.make_move(current_state, response) BoardState.update_state(current_state, User.current_player, response) if EndStates.did_a_player_win(current_state, User.current_player, win_config.winning_combos): Ui.msg( BoardPresenter.display_terminal_board(current_state)) Ui.msg('Game Over: ' + User.current_player + ' WINS!') return True if EndStates.is_draw(current_state): Ui.msg('DRAW. GameOver') return True if User.current_player == player1: User.switch_current_user(User.current_player, player2) else: User.switch_current_user(User.current_player, player1)
def post(self): print("Test") i = "input.jpg" lan = "hi" text, interface_lang, label_, arr_all = Core(i, lan) find, aware, type_, certain_tag, awarness = Ai(interface_lang, label_) img = cv.imread('p3/' + i) for i in arr_all: pts = np.array(i, np.int32) pts = pts.reshape((-1, 1, 2)) cv.polylines(img, [pts], True, (0, 0, 255), 5) cv.imwrite('static/test_img.jpg', img) assign_cluster = 0 analysis = { "regional_language": str(text), "translated_text": str(interface_lang), "cluster": assign_cluster, "tags": label_, "type": type_ } print(analysis) return jsonify(analysis)
class Game(): def __init__(self): self.ai = Ai() self.board = Board(9) self.player = Player() self.on_turn = self.player def start(self): in_progres = True while in_progres: if self.on_turn == self.player: player_choice = self.player.ask_for_move(self.board) try: self.board.make_move(player_choice, self.player.symbol) except ValueError: return self.player.ask_for_move(self.board) self.on_turn = self.ai print(self.board.draw()) else: print('Ai move:') ai_move = self.ai.get_ai_move(self.board) self.board.make_move(ai_move, self.ai.symbol) self.on_turn = self.player print(self.board.draw()) if self.board.check_winning(self.player.symbol): print('Congrats, You win!!!') break elif self.board.check_winning(self.ai.symbol): print('You are LOOOOOOOOOOSER :P') break elif self.board.is_full(): print('TIE') in_progres = not self.board.is_full()
def loop(self, screen): screen.blit(self.text, self.textRect) screen.blit(self.text2, self.textRect2) clock = pygame.time.Clock() self.snake = Snake(self.display, -(Config['snake']['width'])) self.snake2 = Snake(self.display, (Config['snake']['width'])) apple = Apple(self.display) ai = Ai() x_change = Config['snake']['speed'] y_change = 0 x_change2 = -Config['snake']['speed'] y_change2 = 0 while True: for event in pygame.event.get(): if event.type == pygame.QUIT: exit() if event.type == pygame.KEYDOWN: if event.key == pygame.K_LEFT and x_change == 0: x_change = -Config['snake']['speed'] y_change = 0 elif event.key == pygame.K_RIGHT and x_change == 0: x_change = Config['snake']['speed'] y_change = 0 elif event.key == pygame.K_UP and y_change == 0: x_change = 0 y_change = -Config['snake']['speed'] elif event.key == pygame.K_DOWN and y_change == 0: x_change = 0 y_change = Config['snake']['speed'] if event.key == pygame.K_a and x_change2 == 0: x_change2 = -Config['snake']['speed'] y_change2 = 0 elif event.key == pygame.K_d and x_change2 == 0: x_change2 = Config['snake']['speed'] y_change2 = 0 elif event.key == pygame.K_w and y_change2 == 0: x_change2 = 0 y_change2 = -Config['snake']['speed'] elif event.key == pygame.K_s and y_change2 == 0: x_change2 = 0 y_change2 = Config['snake']['speed'] snake_rect = self.snake.draw(Config['colors']['blue']) snake_rect2 = self.snake2.draw(Config['colors']['green']) apple_rect = apple.draw() ai.update(pos=(snake_rect[0], snake_rect[1]), apple=(apple_rect[0], apple_rect[1]), size=self.snake.max_size) move = ai.action() bumper_x = Config['game']['width'] - Config['game']['bumper_size'] bumper_y = Config['game']['height'] - Config['game']['bumper_size'] if apple_rect.colliderect(snake_rect): apple.remove() apple.randomize() self.snake.eat() elif apple_rect.colliderect(snake_rect2): apple.remove() apple.randomize() self.snake2.eat() snakehit = self.snake.hit(self.snake2.body, bumper_x, bumper_y) snakehit2 = self.snake2.hit(self.snake.body, bumper_x, bumper_y) if (snakehit or snakehit2): if (snakehit and snakehit2): print("Tie") elif snakehit: self.snake2.score += 1 self.player2score += 1 else: self.snake.score += 1 self.player1score += 1 apple.remove() # snake.remove() self.map(screen) self.loop(screen) self.snake.move(x_change, y_change) self.snake2.move(x_change2, y_change2) pygame.display.update() clock.tick(Config['game']['fps'])
class Game: def __init__(self, tablero, jugador1, jugador2, con_jugadas_posibles=True, nivel=Ai.FACIL, write_path=""): # self.__gui = Gui() # self.__tablero = self.__gui.init_board().get_board() self.__tablero_g = tablero self.__tablero = tablero.get_logical_board() # Iniciliazo la inteligencia para la PC self.__pc = Ai(nivel) # Inicializo un vector de jugadores self.__jugadores = [jugador1, jugador2] self.__ganador = "" self.__nro_turno = 0 self.__termino_juego = False self.__juego_mesh = False self.__con_jugadas_posibles = con_jugadas_posibles self.__lista_jugadas_posibles = [] if write_path != "": # Imprimo en el log la configuracion del juego que se inicia try: f = open(os.path.abspath(write_path + "/data/game.log"), "r") f.close() self.__log_file = open(os.path.abspath(write_path + "/data/game.log"), "a") print >> self.__log_file, "\nGAME LOG: " + time.asctime() except: self.__log_file = open(os.path.abspath(write_path + "/data/game.log"), "w") print >> self.__log_file, "GAME LOG: " + time.asctime() print >> self.__log_file, "Tablero: " + str(self.__tablero.get_dimension()) + "x" + str( self.__tablero.get_dimension() ) if jugador1.get_color() == board.BLANCO and jugador1.get_name() == PC: print >> self.__log_file, "PC: Blanco" print >> self.__log_file, "Jugador: Negro" elif jugador1.get_name() == HUMANO and jugador2.get_name() == HUMANO: if jugador1.get_color() == board.BLANCO: print >> self.__log_file, "Jugador1: Blanco" print >> self.__log_file, "Jugador2: Negro" else: print >> self.__log_file, "Jugador1: Negro" print >> self.__log_file, "Jugador2: Blanco" else: print >> self.__log_file, "PC: Negro" print >> self.__log_file, "Jugador: Blanco" def __del__(self): try: self.__log_file.close() except: log.debug("Problemas al cerrar el descriptor de archivo. (Game Class)") def get_game_log_file(self): return self.__log_file def get_turn(self): return self.__jugadores[self.__turno] def set_turn(self, jugador): if jugador.equal(self.__jugadores[0]): self.__turno = 0 elif jugador.equal(self.__jugadores[1]): self.__turno = 1 else: raise Exception("No se pudo asignar el turno, el jugador no existe! (Game Class)") self.update_possible_moves() def update_possible_moves(self): self.__lista_jugadas_posibles = Referee.possibles_moves(self.get_turn().get_color(), self.__tablero) def increase_turn_number(self): self.__nro_turno += 1 def get_turn_number(self): return self.__nro_turno def __next_turn(self): color = self.__jugadores[self.__turno].get_color() # Veo si hay jugada posible para el turno siguiente, es decir si era Blanco para el Negro if Referee.is_at_least_one_move(color * -1, self.__tablero): return True else: return False def with_possibles_moves(self): return self.__con_jugadas_posibles def change_turn(self): # if self.__next_turn(): self.__turno = (self.__turno - 1) * -1 self.increase_turn_number() # return True # else: # return False def is_over(self): if Referee.is_at_least_one_move(board.BLANCO, self.__tablero): return False elif Referee.is_at_least_one_move(board.NEGRO, self.__tablero): return False else: return True def init_next_turn(self): pass def __print_log(self, mensaje): try: print >> self.__log_file, mensaje except: print mensaje def get_mesh_game(self): return self.__juego_mesh def set_mesh_game(self, valor): self.__juego_mesh = valor def play(self, coord="", audio="", marcador="", ventana="", extra=""): pc_manual = False if not self.is_over(): jugadas_posibles_real = len(self.__lista_jugadas_posibles) self.__ultima_jugada_humano = "" if jugadas_posibles_real > 0: nombre_de_turno = self.get_turn().get_name() color_de_turno = self.get_turn().get_color() if nombre_de_turno == HUMANO or nombre_de_turno == VIRTUAL: if coord == "": coord = self.__tablero_g.get_coord_selected_cell() if color_de_turno == board.BLANCO: pudo_jugar = self.__tablero_g.set_piece(coord, color_de_turno, "blanco", audio, ventana) sonido_voltear = "voltear_negro" else: pudo_jugar = self.__tablero_g.set_piece(coord, color_de_turno, "negro", audio, ventana) sonido_voltear = "voltear_blanco" if pudo_jugar: marcador.render_numbers(self.__tablero, self.get_turn().get_color(), ventana) self.__ultima_jugada_humano = coord self.__print_log("JUGADOR jugo en: " + str(self.__ultima_jugada_humano)) if nombre_de_turno == VIRTUAL: self.__tablero_g.set_coord_selected_cell(coord) elif nombre_de_turno == PC: if coord == "": pudo_jugar = self.play_pc() else: pudo_jugar = self.__tablero_g.set_piece(coord, color_de_turno, "blanco", audio, ventana) sonido_voltear = "voltear_negro" pc_manual = True if pudo_jugar: if coord == "": coord = self.get_last_pc_move() self.__tablero_g.set_coord_selected_cell(coord) if not pc_manual: if color_de_turno == board.BLANCO: pudo_jugar = self.__tablero_g.set_piece(coord, color_de_turno, "blanco", audio, ventana) sonido_voltear = "voltear_negro" else: pudo_jugar = self.__tablero_g.set_piece(coord, color_de_turno, "negro", audio, ventana) sonido_voltear = "voltear_blanco" marcador.render_numbers(self.__tablero, self.get_turn().get_color(), ventana) self.__print_log("PC jugo en: " + str(coord)) if pudo_jugar: audio.wait_sound_end() self.__tablero_g.do_line_animation(coord, color_de_turno, sonido_voltear, audio, marcador, ventana) else: pudo_jugar = True audio.play_voice_sound("game", "pasa_el_turno") audio.wait_sound_end() # extra = {"play_turn_sound":False} if pudo_jugar: if not self.is_over(): self.change_turn() self.update_possible_moves() if self.__con_jugadas_posibles: if extra == "" or (not extra == "" and not "update_possibles_moves" in extra): self.__tablero_g.lista_jugadas = self.__lista_jugadas_posibles if not extra == "": if not "change_score_color" in extra: marcador.render_all(self.__tablero, self.get_turn().get_color(), ventana) if not "play_turn_sound" in extra: audio.play_init_turn_sounds(self.__tablero_g, self) else: audio.play_init_turn_sounds(self.__tablero_g, self) marcador.render_all(self.__tablero, self.get_turn().get_color(), ventana) if self.__con_jugadas_posibles: self.__tablero_g.render_list_possible_moves(ventana) pygame.display.update() else: self.__lista_jugadas_posibles = [] if extra == "": self.__termino_juego = True marcador.render_all(self.__tablero, self.get_turn().get_color(), ventana) pygame.display.update() audio.play_end_game_sounds(self.__tablero_g, self) else: audio.play_end_game_sounds(self.__tablero_g, self) self.__termino_juego = True return pudo_jugar def game_ended(self): return self.__termino_juego def play_pc(self): return self.__make_a_move() def __make_a_move(self): if self.__pc.play(self.__tablero, self.__jugadores[self.__turno].get_color()): self.__ultima_jugada_pc = self.__pc.get_last_move() return True else: return False def get_player_by_color(self, color=board.BLANCO): for jugador in self.__jugadores: if jugador.get_color() == color: return jugador def get_player_by_name(self, nombre=PC): for jugador in self.__jugadores: if jugador.get_name() == nombre: return jugador def get_final_result(self): if self.__tablero.get_can_fichas_blancas() > self.__tablero.get_can_fichas_negras(): return self.get_player_by_color(board.BLANCO) elif self.__tablero.get_can_fichas_blancas() < self.__tablero.get_can_fichas_negras(): return self.get_player_by_color(board.NEGRO) else: return "" def get_last_pc_move(self): return self.__ultima_jugada_pc def get_last_human_move(self): return self.__ultima_jugada_humano def get_players(self): """ Retorna un vector con los datos de los jugadores.""" jugador1 = self.__jugadores[0] jugador2 = self.__jugadores[1] return [ {"nombre": jugador1.get_name(), "color": jugador1.get_color()}, {"nombre": jugador2.get_name(), "color": jugador2.get_color()}, ] def get_board_configuration(self): """ Retorna un diccionario con la configuracion actual del tablero.""" return {"dimension": self.__tablero.get_dimension(), "configuracion": self.__tablero.get_casillas()} def get_board(self): return self.__tablero def shorcut_lose_game(self): jug_humano = self.get_player_by_name(HUMANO) if jug_humano.get_color() == board.BLANCO: self.__tablero.set_can_fichas_blancas(0) self.__tablero.set_can_fichas_negras(1) else: self.__tablero.set_can_fichas_blancas(1) self.__tablero.set_can_fichas_negras(0) def shorcut_win_game(self): jug_humano = self.get_player_by_name(HUMANO) if jug_humano.get_color() == board.BLANCO: self.__tablero.set_can_fichas_blancas(1) self.__tablero.set_can_fichas_negras(0) else: self.__tablero.set_can_fichas_blancas(0) self.__tablero.set_can_fichas_negras(1) def shorcut_draw_game(self): self.__tablero.set_can_fichas_blancas(1) self.__tablero.set_can_fichas_negras(1) def get_list_possible_moves(self): return self.__lista_jugadas_posibles
def __init__(self): self.ai = Ai() self.board = Board(9) self.player = Player() self.on_turn = self.player