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 xref(): Board.DISABLE_SPRITE_MANAGER = True # Initialize objects to read to input_obj = '' # Read from STDIN indefinitely until stream is closed for k in sys.stdin: input_obj += k # Load from read string json_obj = json.loads(input_obj) # Get rows, columns, players, and fish from json_obj rows = json_obj['row'] columns = json_obj['column'] fish = json_obj['fish'] players = [] # initialize players; for p in json_obj['players']: players.append(Player(name=p[0], search_depth=p[1])) # Create Referee Referee.DIFFICULTY_FACTOR = 0 Referee.PLAYER_TIMEOUT = 60 referee = Referee(rows, columns, players, fish) # Run complete game referee.start() # Print referee winners output_str = json.dumps(sorted([winner.name for winner in referee.winners])) print(output_str)
def test_game_info_1(self): test_player_1 = Player() test_player_2 = Player() ex_referee = Referee([test_player_1, test_player_2],4,4) # Make sure get game info returns not started if the game has not started with placement phase self.assertEqual(ex_referee.get_game_info(),"Not Started")
def run(self): ref = Referee() p1 = Player() p2 = DummyAI() ref.add_player(p1) ref.add_player(p2)
def test_init_fail2(self): # Tests failing init due to cols being invalid with self.assertRaises(TypeError): Referee(2, '2', [self.__p1, self.__p2]) with self.assertRaises(TypeError): Referee(2, 0, [self.__p1, self.__p2])
def test_init_fail1(self): # Tests failing init due to rows being invalid with self.assertRaises(TypeError): Referee('', 2, [self.__p1, self.__p2]) with self.assertRaises(TypeError): Referee(0, 2, [self.__p1, self.__p2])
def __init__(self, connections=[], player1="Josh", player2="Drake"): player_holder = [] for connection in connections: player_holder.append(RemotePlayer(connection)) # Fill in non-connections with local players if len(player_holder) == 0: player_holder.append(player.Player(name=player1)) player_holder.append(player.Player(name=player2)) elif len(player_holder) == 1: if player1 != "Josh": player_holder.insert(0, player.Player(name=player1)) elif player2 != "Drake": player_holder.append(player.Player(name=player2)) self.player_holder = player_holder self.ref = Referee() first_name = self.player_holder[0].get_name() self.player_holder[0].set_stone("B") self.ref.set_player(stone="B", name=first_name) second_name = self.player_holder[1].get_name() self.player_holder[1].set_stone("W") self.ref.set_player(stone="W", name=second_name)
def executeCommands(self): referee = Referee() for command in self.list_of_commands: #Handling single board -> count score output, output1 = referee.parse_command(command) self.list_of_outputs.append(output) if output else None self.list_of_outputs.append(output1) if output1 else None
def load_p_vs_p(screen): """ Load the gamemode PvP. """ run = True board = init_board() player_color = 'b' ref = Referee() while run: display_board(screen, board) for event in pygame.event.get(): if event.type == pygame.QUIT: run = False elif event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: run = False elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: coord_x, coord_y = pygame.mouse.get_pos() coord_x = int((coord_x - 5) / 40) coord_y = int((coord_y - 5) / 40) rboard, score, msg = ref.set_stone(board, player_color, [coord_y, coord_x]) if rboard is not None: board = rboard win = ref.check5(board, [coord_y, coord_x], player_color) player_color = 'b' if player_color == 'w' else 'w' run = ref.display_score(score, player_color, win, msg) display_board(screen, board) update_stone_player(screen, player_color) pygame.display.update() return True
def __init__(self, file1=None, file2=None): pygame.mixer.pre_init(44100, -16, 2, 2048) pygame.init() self.fps = pygame.time.Clock() flag = DOUBLEBUF self.board = pygame.display.set_mode(screenRect, flag) pygame.display.set_caption('[ --- Pong --- ]') self.state = 1 # 1 - run, 0 - exit self.track = Tracking(file1, file2) self.sound = Sound() self.p1 = Paddle(self.board, (200, 100, 100), screenRect) self.p1.setInitialPostition(0, screenHeight / 2) self.p2 = Paddle(self.board, (100, 200, 100), screenRect) self.p2.setInitialPostition(screenWidth - self.p2.get()['width'], screenHeight / 2) self.ball = Ball(self.board, (50, 50, 250), screenRect, self.sound) self.ball.setInitialPostition(screenWidth / 2, screenHeight / 2) self.arena = Arena(self.board, screenRect) self.referee = Referee(self.ball, self.p1, self.p2, screenRect, self.sound) self.t = Thread(target=self.track.run) #self.track.run() self.t.start() self.p1_pos = 0 self.p2_pos = 0 self.loop()
def __is_goal_state(self,estado): #Si no existen mas jugadas para ninguno de los colores con el tablero actual entonces el juego termino y estamos en una hoja if not Referee.is_at_least_one_move(estado.turno, estado.tablero): if not Referee.is_at_least_one_move(-1*estado.turno, estado.tablero): return True else: return False else: return False
def startMatch(self, player1, player2): referee = Referee() player1.chooseWeapon() player2.chooseWeapon() referee.getChoice(player1, player2) referee.calcWinner(player1, player2) self.addPoint(player1, player2, referee)
class Ref_Wrapper: def __init__(self): self.ref = Referee() def set_players(self, name1, name2): return self.ref.set_players(name1, name2) def make_action(self, action): return self.ref.make_action(action)
def __is_goal_state(self, estado): #Si no existen mas jugadas para ninguno de los colores con el tablero actual entonces el juego termino y estamos en una hoja if not Referee.is_at_least_one_move(estado.turno, estado.tablero): if not Referee.is_at_least_one_move(-1 * estado.turno, estado.tablero): return True else: return False else: return False
def test_referee_error(self): test_player_1 = Player() # a bad player class is define at the top of the class - where the placement it returns is invalid test_player_2 = BadPlayer() ex_referee = Referee([test_player_1, test_player_2],4,4) ex_referee.start_game() #make sure that the bad player has been kicked self.assertEqual([test_player_2], ex_referee.get_game_info()[2])
def start_game(self): choice = random.randint(0, 1) if choice: referee = Referee(self.proxy_player, self.default_player) else: referee = Referee(self.default_player, self.proxy_player) # referee = Referee(self.proxy_player, self.default_player) if choice else Referee(self.default_player, self.proxy_player) print(json.dumps(referee.get_winner())) self.close_connection()
def __init__(self): self.welcome_text = lmgr.GLOBAL_LANGUAGE.Global.welcome_text self.help_ps = 'help' self.__each_score = 10 self.__referee = Referee() self.__players = [ComputerPlayer(), HumanPlayer()] self.__global_socre = 0 self.__global_save = None
def test_check(): # Set of moves to get us to check fast white_moves = ['e2e3', 'f1b5'] black_moves = ['d7d6'] white = QueuePlayer(white_moves) black = QueuePlayer(black_moves) r = Referee(white, black) r.play_game() print('All we were looking for was the " - check"')
def test_run_game_tie(self): board = Board(2, 5, {0: [0, 1]}, num_of_fish_per_tile=2) player1 = Player(1) player2 = Player(2) player_seq = [player1, player2] referee = Referee(player_seq, test_board=board) assert referee.run_game() == { 'won': [player1, player2], 'lost': [], 'cheated/failed': [] }
def raw_eval(board): if str(board) in terminal_board_dict: return terminal_board_dict[str(board)] player_a = Player() player_b = Player() ref = Referee() result = ref.playgame(player_a, player_b, board=board, lookup=terminal_board_dict) # print(len(terminal_board_dict)) return result
def ai_check_win(board, coord, color, depth): """ Check if the move made the AI win. """ coord_x = coord[0] coord_y = coord[1] ref = Referee() if ref.check5(board, coord, color): board[coord_y][coord_x] = None if not depth: return True return False return False
def __init__(self, first_player_first_move: bool, debug: bool = True): self.board = Board() self.referee = Referee() self.bot = Bot(self.board.config) self.first_player_first_move = first_player_first_move self.bot_alias = { "alex": self.bot.alex_bot, "tei": self.bot.tei_bot, "tei_v2" : self.bot.tei_bot_v2, "jw": self.bot.alex_bot } self.winner = "no one" self.debug = debug
def game_test(player1, player2): ref = Referee([player1, player2]) scores = ref.play_game() print("GAME RESULTS: ", scores) # game_test(HeuristicPlayer(), HeuristicPlayer()) # game_test(IterativeDeepeningPlayer(), IterativeDeepeningPlayer()) # game_test(MinimaxPlayer(), MinimaxPlayer()) # game_test(GreedyPlayer(), GreedyPlayer()) # game_test(RandomPlayer(), RandomPlayer()) # game_test(ExpectimaxPlayer(), ExpectimaxPlayer()) # game_test(AlphaBetaPlayer(), AlphaBetaPlayer()) # board_game_test() # board_test()
def main(): # Parse the text input into a list of JSON elements. txt = sys.stdin.read().rstrip() json_elements = txt2json(txt) rf = Referee() results = [] res_print = [] for i, json_element in enumerate(json_elements): # If the move is a pass if i == 0: results.append(rf.register_black_player(json_element)) # print(rf.register_black_player(json_element)) continue elif i == 1: results.append(rf.register_white_player(json_element)) # print(rf.register_white_player(json_element)) continue elif i == 2: res = copy.deepcopy(rf.board_history) results.append(res) # print("[") # for b in res: # print(b) # print("]") # print() if rf.is_game_ended: break else: if json_element == PASS: play_or_pass = PASS else: play_or_pass = Point.from_str(json_element) res = copy.deepcopy(rf.play_point(play_or_pass)) if isinstance(res[0], Board): results.append(res) # print("[") # for b in res: # print(b) # print("]") # print() else: results.append(res) # print(res) if rf.is_game_ended == False: results.pop() print(jsonpickle.encode(results, unpicklable=False))
def run(self): """ Explanation: -Creates a schedule = [(player_idx0, player_idx1), (player_idx0, player_idx2), ...] -Enumerates through the schedule and sends players to the referee to administer a game and handles the following cases: -Cheating: Creates a default player, update the scores and backtrack through existing results to award player points to players eliminated by the cheating player -Not Cheating: Coin flip if there's a draw and update scores """ print("starting league") self.schedule = combinations(range(len(self.players)), 2) for matchup in self.schedule: print(matchup) game = Referee(self.players[matchup[0]], self.players[matchup[1]]).get_results() print(game) if game[2]: self.handle_cheater(game, matchup) else: #Draw situation winner,loser = 0,1 if game[0][1] == game[1][1]: coin_flip = random.randint(0,1) winner = coin_flip loser = 0 if coin_flip else 1 self.player_score[game[winner][0]] += 1 self.player_score[game[loser][0]] += 0 winning_player = game[winner][0] if winning_player == self.players[matchup[0]]: self.game_results[matchup] = matchup[0] else: self.game_results[matchup] = matchup[1] return
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 on_new_game(self, game_id: str): try: print("Starting game with id {}".format(game_id)) self.games[game_id] = Referee(game_id, self.mqtt_client, self.game_repo, self.on_game_stop) except ReferenceError: print("Invalid game ID {}".format(game_id))
def run(self): """ Runs the game visualization, effectively playing through an entire game and visually displaying the game state every time it is updated in the game. A referee is created to facilitate the game being played and an __update_gameboard function is used as a callback to update the GUI every time the game state is updated by the referee. Upon completion of the game, the GUI's window is destroyed, effectively removing it. :return: None """ # creates referee referee: Referee = Referee(self.__board_row_no, self.__board_col_no, self.__players, self.__num_fish) # Displays initial game board referee.state.render(self.__frame) self.__window.update() # subscribe referee game updates to update the game board in real time referee.subscribe_game_updates(self.__update_gameboard) # subscribe to game outcome from referee (for testing) referee.subscribe_final_game_report(self.__handle_final_game_report) # start game referee.start() # Destroys the GUI window effectively removing it self.__window.destroy() # return final game results return self.final_game_report
def __init__(self, file1=None, file2=None): pygame.mixer.pre_init(44100, -16, 2, 2048) pygame.init() self.fps = pygame.time.Clock() flag = DOUBLEBUF self.board = pygame.display.set_mode(screenRect, flag) pygame.display.set_caption('[ --- Pong --- ]') self.state = 1 # 1 - run, 0 - exit self.track = Tracking(file1, file2) self.sound = Sound() self.p1 = Paddle(self.board, (200,100,100),screenRect) self.p1.setInitialPostition(0,screenHeight/2) self.p2 = Paddle(self.board, (100,200,100),screenRect) self.p2.setInitialPostition(screenWidth-self.p2.get()['width'],screenHeight/2) self.ball = Ball(self.board, (50,50,250), screenRect, self.sound) self.ball.setInitialPostition(screenWidth/2,screenHeight/2) self.arena = Arena(self.board, screenRect) self.referee = Referee(self.ball, self.p1, self.p2, screenRect, self.sound) self.t = Thread(target=self.track.run) #self.track.run() self.t.start() self.p1_pos = 0 self.p2_pos = 0 self.loop()
def __value(self, estado): tablero = estado.tablero if estado.turno == BLANCO: fichas_jugador = tablero.get_can_fichas_blancas() fichas_oponente = tablero.get_can_fichas_negras() else: fichas_jugador = tablero.get_can_fichas_negras() fichas_oponente = tablero.get_can_fichas_blancas() movimientos_validos_oponente = estado.cantidad_hnos jugador_frontera = self.__border_pieces(tablero, estado.turno) oponente_frontera = self.__border_pieces(tablero, -1 * estado.turno) movimientos_validos = Referee.number_of_successors( estado.turno, tablero) fichas_estables_jugador = self.__stable_pieces(tablero, estado.turno) fichas_estables_oponente = self.__stable_pieces( tablero, -1 * estado.turno) dif_can_fichas = fichas_jugador - fichas_oponente v = self.__frontera_peso * ( oponente_frontera - jugador_frontera) + self.__movilidad_peso * estado.turno * ( movimientos_validos - movimientos_validos_oponente) + self.__estabilidad_peso * ( fichas_estables_jugador - fichas_estables_oponente ) + self.__diferencia_cantidad_fichas_peso * dif_can_fichas return v
def get_lines(self,color,coord): pos_fin = Coordinate(coord.x,coord.y) pos_inicial = Coordinate(coord.x,coord.y) can_fichas_volteables = 0 vec_lineas = [] for inc_fila in xrange(-1,2): for inc_col in xrange(-1,2): pos_fin.x = pos_inicial.x + inc_fila pos_fin.y = pos_inicial.y + inc_col #Verifica que haya al menos una ficha del color opuesto para voltear if Referee.can_turn(color, pos_inicial, inc_fila, inc_col, self): hash_linea = {} vec_casillas = [] #Contar las fichas volteables en esa linea while True: can_fichas_volteables += 1 vec_casillas.append(Coordinate(pos_fin.x,pos_fin.y)) pos_fin.x += inc_fila pos_fin.y += inc_col if not self.__casilla[pos_fin.x][pos_fin.y] == -color: break hash_linea["casilla_inicial"] = pos_inicial hash_linea["casilla_final"] = Coordinate(pos_fin.x,pos_fin.y) hash_linea["can_fichas_volteables"] = can_fichas_volteables hash_linea["casillas_volteables"] = vec_casillas vec_lineas.append(hash_linea) can_fichas_volteables = 0 return vec_lineas
def run(self, players: list): """ Input: players: a list of the players in the current round, always a power of 2 Explanation: -called recursively until there is only one player left. -sends players two-by-two to the referee -updates the list of players and the result dictionary """ next_round_players = [] if len(players) == 1: self.results['winner'] = [players[0]] return for p in range(0, len(players), 2): game = Referee(players[p], players[p+1]).get_results() print(game) winner, loser = 0,1 if game[0][1] == game[1][1]: coin_flip = random.randint(0,1) winner = coin_flip loser = 0 if winner else 1 next_round_players.append(game[winner][0]) loser_player_name = game[loser][0] if self.round in self.results: self.results[self.round].append(loser_player_name) else: self.results[self.round] = [loser_player_name] self.round += 1 self.run(next_round_players)
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 run(self): print("starting league") self.schedule = combinations(range(len(self.players)), 2) for matchup in self.schedule: print(matchup) game = Referee(self.players[matchup[0]], self.players[matchup[1]]).get_results() print(game) if game[2]: self.handle_cheater(game, matchup) else: #Draw situation winner, loser = 0, 1 if game[0][1] == game[1][1]: coin_flip = random.randint(0, 1) winner = coin_flip loser = 0 if coin_flip else 1 self.player_score[game[winner][0]] += 1 self.player_score[game[loser][0]] += 0 winning_player = game[winner][0] if winning_player == self.players[matchup[0]]: self.game_results[matchup] = matchup[0] else: self.game_results[matchup] = matchup[1] return
def get_lines(self, color, coord): pos_fin = Coordinate(coord.x, coord.y) pos_inicial = Coordinate(coord.x, coord.y) can_fichas_volteables = 0 vec_lineas = [] for inc_fila in xrange(-1, 2): for inc_col in xrange(-1, 2): pos_fin.x = pos_inicial.x + inc_fila pos_fin.y = pos_inicial.y + inc_col #Verifica que haya al menos una ficha del color opuesto para voltear if Referee.can_turn(color, pos_inicial, inc_fila, inc_col, self): hash_linea = {} vec_casillas = [] #Contar las fichas volteables en esa linea while True: can_fichas_volteables += 1 vec_casillas.append(Coordinate(pos_fin.x, pos_fin.y)) pos_fin.x += inc_fila pos_fin.y += inc_col if not self.__casilla[pos_fin.x][pos_fin.y] == -color: break hash_linea["casilla_inicial"] = pos_inicial hash_linea["casilla_final"] = Coordinate( pos_fin.x, pos_fin.y) hash_linea["can_fichas_volteables"] = can_fichas_volteables hash_linea["casillas_volteables"] = vec_casillas vec_lineas.append(hash_linea) can_fichas_volteables = 0 return vec_lineas
def __is_leaf(self,estado): #Si la profundidad del nodo actual es mayor (nunca deberia llegar) o igual ya estamos en la hoja del recorrido actual if estado.profundidad >= self.__profundidad_maxima: return True else: if len(Referee.possibles_moves(estado.turno,estado.tablero)) == 0: return True else: return False
def play(self, tablero, turno): profundidad_raiz = 0 cantidad_hnos_raiz = 0 if Referee.is_at_least_one_move(turno, tablero): estado_raiz = State(tablero,turno,MAX,profundidad_raiz,cantidad_hnos_raiz) self.__negamax(estado_raiz, MEN_INFI, MAS_INFI) self.__ultima_jugada.set(estado_raiz.mejor_sucesor) return True else: return False
def set_piece(self, coord, color): if self.valid_coord(coord): #Verifico que sea una jugada valida if Referee.is_valid_move(color, coord, self): self.__casilla[coord.x][coord.y] = color self.update_pieces_counters() return True else: return False else: return False
def __init__(self ,progs, visualizer,gwidth = 90, glength = 120 , gfriction = 1): self.cycle = Cycle() self.ground = Ground(glength , gwidth ,gfriction ) self.players =[] for i in range(2): for j in range(5): self.players.append(Player(self.ground, progs[i] , i , j , Vector( ((1.0*indexi[j]) * (gwidth / 2)) , (1.0*indexj[j]) * (glength / 2) * ((-1) ** (i)) ) )) #print >>sys.stderr, 'PLAYER %d, %d: %f, %f'%(i, j, self.players[j].pos.x, self.players[j].pos.y) #print >>sys.stderr, 'PLAYER %d, %d: %f, %f'%(i, j, indexi[j] * gwidth / 2, indexj[j] * glength / 2 * (-1) ** (i)) self.ball = Ball(self.ground) self.state = State(self.players , self.ball) self.referee = Referee(self.state) self.visualizer = visualizer
def __value(self,estado): tablero = estado.tablero if estado.turno == BLANCO: fichas_jugador = tablero.get_can_fichas_blancas() fichas_oponente = tablero.get_can_fichas_negras() else: fichas_jugador = tablero.get_can_fichas_negras() fichas_oponente = tablero.get_can_fichas_blancas() movimientos_validos_oponente = estado.cantidad_hnos jugador_frontera = self.__border_pieces(tablero, estado.turno) oponente_frontera = self.__border_pieces(tablero, -1*estado.turno) movimientos_validos = Referee.number_of_successors(estado.turno, tablero) fichas_estables_jugador = self.__stable_pieces(tablero, estado.turno) fichas_estables_oponente = self.__stable_pieces(tablero, -1*estado.turno) dif_can_fichas = fichas_jugador - fichas_oponente v = self.__frontera_peso * (oponente_frontera - jugador_frontera) + self.__movilidad_peso * estado.turno * (movimientos_validos - movimientos_validos_oponente) + self.__estabilidad_peso * (fichas_estables_jugador - fichas_estables_oponente) + self.__diferencia_cantidad_fichas_peso * dif_can_fichas return v
def turn_pieces(self, color, pos_ini): pos_fin = Coordinate(pos_ini.x, pos_ini.y) for inc_fila in xrange(-1,2): for inc_col in xrange(-1,2): pos_fin.x = pos_ini.x + inc_fila pos_fin.y = pos_ini.y + inc_col #Verifica que haya al menos una ficha del color opuesto para voltear if Referee.can_turn(color, pos_ini, inc_fila, inc_col, self): #Voltear las fichas while True: self.__casilla[pos_fin.x][pos_fin.y] = color pos_fin.x += inc_fila pos_fin.y += inc_col if not self.__casilla[pos_fin.x][pos_fin.y] == -color: break #Actualizo los contadores de las fichas blancas o negras dependiendo del color self.update_pieces_counters()
def __childrens(self,estado): n_etiqueta = estado.etiqueta * -1 n_profundidad = estado.profundidad + 1 n_turno = estado.turno * -1 aux_tablero = Board(estado.tablero.get_dimension()) aux_tablero.set_casillas(estado.tablero.get_casillas()) nuevos_estados = [] lista_jugadas = Referee.possibles_moves(estado.turno,estado.tablero) can_hijos = len(lista_jugadas) for jugada in lista_jugadas: aux_tablero.set_piece_and_turn_oponent_pieces(jugada,estado.turno) #Creo el nuevo estado n_estado = State(aux_tablero,n_turno,n_etiqueta,n_profundidad,can_hijos) n_estado.iniciador = jugada nuevos_estados.append(n_estado) aux_tablero.set_casillas(estado.tablero.get_casillas()) return nuevos_estados
class Pong(object): def __init__(self, file1=None, file2=None): pygame.mixer.pre_init(44100, -16, 2, 2048) pygame.init() self.fps = pygame.time.Clock() flag = DOUBLEBUF self.board = pygame.display.set_mode(screenRect, flag) pygame.display.set_caption('[ --- Pong --- ]') self.state = 1 # 1 - run, 0 - exit self.track = Tracking(file1, file2) self.sound = Sound() self.p1 = Paddle(self.board, (200,100,100),screenRect) self.p1.setInitialPostition(0,screenHeight/2) self.p2 = Paddle(self.board, (100,200,100),screenRect) self.p2.setInitialPostition(screenWidth-self.p2.get()['width'],screenHeight/2) self.ball = Ball(self.board, (50,50,250), screenRect, self.sound) self.ball.setInitialPostition(screenWidth/2,screenHeight/2) self.arena = Arena(self.board, screenRect) self.referee = Referee(self.ball, self.p1, self.p2, screenRect, self.sound) self.t = Thread(target=self.track.run) #self.track.run() self.t.start() self.p1_pos = 0 self.p2_pos = 0 self.loop() def movep1(self, diry): '''Player1 moves support''' self.p1.move(diry) def movep2(self, diry): '''Player2 moves support''' self.p2.move(diry) def game_exit(self): exit() def loop(self): flaga = 1 while self.state==1: for event in pygame.event.get(): if event.type==QUIT or (event.type==KEYDOWN and event.key==K_ESCAPE): self.state=0 keys = pygame.key.get_pressed() dirp1 = copysign(1, self.track.p1_position - self.p1_pos) dirp2 = copysign(1, self.track.p2_position - self.p2_pos) self.p1_pos += dirp1 self.p2_pos += dirp2 self.p1.set(self.track.p1_position+45) self.p2.set(self.track.p2_position+45) if keys[K_f]: pygame.display.toggle_fullscreen() self.arena.render(self.track.frame) font = pygame.font.Font("gfx/ATARCC__.TTF",40) text1 = font.render('P1={}'.format(self.p1.getScore()), True,(200,200,200)) text2 = font.render('P2={}'.format(self.p2.getScore()), True,(200,200,200)) quartWidth = screenWidth/4 self.board.blit(text1,(quartWidth * 1 - quartWidth/2,10)) self.board.blit(text2,(quartWidth * 3 - quartWidth/2,10)) self.p1.render() self.p2.render() self.ball.render() self.referee.judge() pygame.display.flip() # wyswietlamy obrazki self.fps.tick(80) self.track.running = False self.game_exit()
host = sys.argv[1] port = int(sys.argv[2]) user_connection_id = sys.argv[3] docker_id = sys.argv[4] try: log_level = int(sys.argv[5]) except IndexError: init_logging(logging.INFO) else: init_logging(log_level, config={ 'root': { 'handlers': ['console'], } }) logger = logging.getLogger() logger.info("START Host:{} PORT:{} CONNECTION_ID:{} DOCKER_ID:{}".format( host, port, user_connection_id, docker_id)) def handle_signal(sig, frame): IOLoop.instance().add_callback(IOLoop.instance().stop) signal.signal(signal.SIGINT, handle_signal) signal.signal(signal.SIGTERM, handle_signal) io_loop = IOLoop.instance() referee = Referee(host, port, user_connection_id=user_connection_id, docker_id=docker_id, io_loop=io_loop) referee.start() io_loop.start()
class TestReferee(unittest.TestCase): def setUp(self): self.referee = Referee() def test_has_won_on_row(self): self.referee.board.board = [ ['x', 'x', 'x'], [0, 0, 0], [0, 0, 0], ] self.assertTrue(self.referee.has_won('x')) def test_has_not_won_row(self): self.referee.board.board = [ ['x', 'x', 0], [0, 0, 0], [0, 0, 0], ] self.assertFalse(self.referee.has_won('x')) def test_has_won_on_column(self): self.referee.board.board = [ ['x', 0, 0], ['x', 0, 0], ['x', 0, 0], ] self.assertTrue(self.referee.has_won('x')) def test_has_not_won_column(self): self.referee.board.board = [ ['x', 0, 0], [0, 0, 0], ['x', 0, 0], ] self.assertFalse(self.referee.has_won('x')) def test_has_won_diagonally_down_right(self): self.referee.board.board = [ ['x', 0, 0], [0, 'x', 0], [0, 0, 'x'], ] self.assertTrue(self.referee.has_won('x')) def test_has_won_diagonally_down_left(self): self.referee.board.board = [ [0, 0, 'x'], [0, 'x', 0], ['x', 0, 0], ] self.assertTrue(self.referee.has_won('x')) def test_valid_move_with_valid_moves(self): self.assertTrue(self.referee.valid_move(Move('x', 1, 1))) def test_valid_move_with_invalid_moves(self): self.assertFalse(self.referee.valid_move(Move('x', 3, 1))) self.assertFalse(self.referee.valid_move(Move('x', 1, 3))) self.assertFalse(self.referee.valid_move(Move('x', -1, 1))) self.assertFalse(self.referee.valid_move(Move('x', 1, -1))) def test_valid_move_with_position_already_taken(self): self.referee.board.board[0][1] = 'x' self.assertFalse(self.referee.valid_move(Move('x', 0, 1)))
def update_possible_moves(self): self.__lista_jugadas_posibles = Referee.possibles_moves(self.get_turn().get_color(), self.__tablero)
def setUp(self): self.referee = Referee()
class Simulator(object): def __init__(self ,progs, visualizer,gwidth = 90, glength = 120 , gfriction = 1): self.cycle = Cycle() self.ground = Ground(glength , gwidth ,gfriction ) self.players =[] for i in range(2): for j in range(5): self.players.append(Player(self.ground, progs[i] , i , j , Vector( ((1.0*indexi[j]) * (gwidth / 2)) , (1.0*indexj[j]) * (glength / 2) * ((-1) ** (i)) ) )) #print >>sys.stderr, 'PLAYER %d, %d: %f, %f'%(i, j, self.players[j].pos.x, self.players[j].pos.y) #print >>sys.stderr, 'PLAYER %d, %d: %f, %f'%(i, j, indexi[j] * gwidth / 2, indexj[j] * glength / 2 * (-1) ** (i)) self.ball = Ball(self.ground) self.state = State(self.players , self.ball) self.referee = Referee(self.state) self.visualizer = visualizer def send_data(self): for i in range(10): self.visualizer.stdin.write(`int(self.state.players[i].pos.x)`+'\n') self.visualizer.stdin.write(`int(self.state.players[i].pos.y)`+'\n') #print >>sys.stderr, 'THIS IS RS, PLAYER %d: %d, %d'%(i, int(self.state.players[i].pos.x), int(self.state.players[i].pos.y)) self.visualizer.stdin.write(`int(self.state.ball.pos.x)`+'\n') self.visualizer.stdin.write(`int(self.state.ball.pos.y)`+'\n') self.visualizer.stdin.write(`self.state.game_state `+'\n') #def player_move(self, i , coefficient=1.0/100): # self.players[i].move(coefficient) def ball_move(self , coefficient=1.0/100): self.ball.move(coefficient) width = self.ground.width length = self.ground.length while True: x = self.ball.pos.x y = self.ball.pos.y if x <= width/2 and x >= -width/2 and y <= length/2 and y >= -length/2: break #print >>sys.stderr, 'BALL IS OUTSIDE GROUND, VELOCITY IS: %f, %f'%(self.ball.vel.x, self.ball.vel.y) if x>(width/2) : self.ball.vel.x= -self.ball.vel.x self.ball.pos.x= width-x #print >>sys.stderr, 'THE BALL WENT TOO RIGHT, NEW X: %f'%(self.ball.pos.x) if x<-(width/2) : self.ball.vel.x= -self.ball.vel.x self.ball.pos.x= -width-x #print >>sys.stderr, 'THE BALL WENT TOO LEFT, NEW X: %f'%(self.ball.pos.x) if y>(length/2) : self.state.update( self.referee.is_goal(self.ball , self.ground) ) self.ball.vel.y= -self.ball.vel.y self.ball.pos.y= length-y #print >>sys.stderr, 'THE BALL WENT TOO UP, NEW Y: %f'%(self.ball.pos.y) if y<(-(length/2)) : self.state.update( self.referee.is_goal(self.ball , self.ground) ) self.ball.pos.y= -length-y self.ball.vel.y=-self.ball.vel.y #print >>sys.stderr, 'THE BALL WENT TOO DOWN, NEW Y: %f'%(self.ball.pos.y) # def check_pos(self , coefficient=1.0/100): # a = range(10) # random.shuffle(a) # sizes = [i/20.0 for i in xrange(1, 11)] # random.shuffle(sizes) # for i in a: # temp_pos = self.players[i].pos # for j in range(10): # if( ( self.players[j].is_overlap(sizes[i], sizes[j], temp_pos) ) and (j!=i)): # self.players[i].move(-coefficient) # break def move(self): # for j in xrange(100): # for i in xrange(10): # self.player_move(i) # self.ball_move() # self.check_pos() #for t in xrange(steps_per_cycle): coefficient = 1.0/config.steps_per_cycle q = deque(self.players) if self.state.kicked: if self.ball.vel.len() < 4: self.ball.vel = Vector(2*random.choice([-1, 1]), 2*random.choice([-1, 1])) for t in xrange(config.steps_per_cycle): self.ball_move(coefficient) for p in self.players: p.rsteps = config.steps_per_cycle no_change = 0 #print >>sys.stderr, 'move called' #player_size = random.choice([0.3, 0.4, 0.5]) while len(q): c = q.popleft() #print >>sys.stderr, 'moving %d, %d, %d'%(c.team, c.number, c.rsteps) c.move(coefficient) c.rsteps-=1 change = True for other in self.players: if c==other: continue if c.is_overlap(config.player_size, config.player_size, other.pos): c.move(-coefficient) c.rsteps+=1 change = False break if change: no_change=0 else: no_change+=1 if c.rsteps: q.append(c) if no_change==20: #print >>sys.stderr, 'breaking' #for p in self.players: # print >>sys.stderr, 'PLAYER %d, %d: %f, %f'%(p.team, # p.number, # p.pos.x, # p.pos.y) #print >>sys.stderr, 'BALL: %f, %f'%(self.ball.pos.x, # self.ball.pos.y) break # while True: # change = False # for p in self.players: # if not p.rsteps: # continue # p.move(coefficient) # p.rsteps-=1 # change = True # for other in self.players: # if other==p: # continue # if p.is_overlap(config.player_size, config.player_size, # other.pos): # p.move(-coefficient) # change = False # break # if not change: # break def goto_kickoff(self): self.ball.pos = Vector(0, 0) self.ball.vel = Vector(0, 0) gwidth = config.gwidth glength = config.glength for i in xrange(2): for j in xrange(5): self.players[i*5+j].pos=Vector( ((1.0*indexi[j]) * (gwidth / 2)) , (1.0*indexj[j]) * (glength / 2) * ((-1) ** (i)) ) self.players[i*5+j].vel = Vector(0, 0) def simulate(self) : global cycle_length #print self.state.game_state prev_locs = [Vector(0, 0) for i in xrange(10)] for i in xrange(game_duration): #print >>sys.stderr, 'CYCLE #%d'%(i) self.state.kicked = False self.referee.update_state() self.send_data() #self.state.update() for j in xrange(10): self.players[j].comm.send_state(self.state) #print >>sys.stderr, 'DOOOOOOOOOOOOOOOOOOOOOOONE SENDING DATA AT %f'%(time.time()) time.sleep(cycle_length) self.cycle.update_players(self.state) self.move() soc = 0 for (i, p) in enumerate(self.players): soc += (p.pos-prev_locs[i]).len() if soc < 1 and self.state.game_state!=state.kickoff_team1 and self.state.game_state!=state.kickoff_team2: self.ball.vel += Vector(random.choice([-1, 1])*5, random.choice([-1, 1])*5) print 'accel' prev_locs = [Vector(p.pos.x, p.pos.y) for p in self.players] if self.state.game_state==state.team1_goal: self.state.game_state = state.kickoff_team2 self.goto_kickoff() if self.state.game_state==state.team2_goal: self.state.game_state = state.kickoff_team1 self.goto_kickoff() if(self.state.last_kicked != None): pass for i in xrange(10): self.players[i].comm.terminate()