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 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 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()
