def get_next_tile(self, pos):
x = pos.get_x()
y = pos.get_y()
port = pos.get_port()
if port == 0 or port == 1:
return Position(x, y - 1, 5 - port)
elif port == 2 or port == 3:
return Position(x + 1, y, 9 - port)
elif port == 4 or port == 5:
return Position(x, y + 1, 5 - port)
elif port == 6 or port == 7:
return Position(x - 1, y, 9 - port)
else:
return None
def get_path(self, pos):
next_step = self.get_next_tile(pos)
if (not next_step.get_x() in range(0, self.width)) or (
not next_step.get_y() in range(0, self.height)):
# Already on the edge of the board
return pos
elif self.get_tile(next_step.get_x(), next_step.get_y()).is_empty():
# No more tile to continue path
return pos
# If port is already occupied, has collided, stop moving
next_tile = self.get_tile(next_step.get_x(), next_step.get_y())
if next_tile.is_occupied(next_step.get_port()):
return next_step
# "Move" avatar to connecting port on next tile
connected_port = next_tile.get_path(next_step.get_port())
next_tile_pos = Position(next_step.get_x(), next_step.get_y(),
connected_port)
# If connecting port is already occupied, has collided, stop moving
if next_tile.is_occupied(connected_port):
return next_tile_pos
# "Moved" player to a new position, recursively call get_path on new position
return self.get_path(next_tile_pos)
def place_initial_tile(self, target_position, next_tile, player):
self.board.add_tile(next_tile, target_position.get_x(),
target_position.get_y())
connected_port = next_tile.get_path(target_position.get_port())
player_position = Position(target_position.get_x(),
target_position.get_y(), connected_port)
self.board.add_player(player.get_color(), player_position)
def execute_initial_placement(board, initial_placement):
rotated_tile = tiles_dict[initial_placement[0]]
rotation = initial_placement[1]
color = initial_placement[2]
port = convert_letter_to_int(initial_placement[3])
x = initial_placement[4]
y = initial_placement[5]
for i in range(rotation // 90):
rotated_tile = rotated_tile.rotate_90()
try:
board.add_initial_tile(rotated_tile, Position(x, y, port))
connected_port = rotated_tile.get_path(port)
board.add_player(color, Position(x, y, connected_port))
return True
except Exception as e:
print(e)
return False
def handle_board_position_update(self, board_position_update):
logging.info("CLIENT for " + self.name +
" handle board position update")
if not (len(board_position_update) == 2
and isinstance(board_position_update[1], list)):
raise Exception("invalid board position update")
new_positions = {}
for new_position in board_position_update[1]:
new_positions[new_position["color"]] = Position(
new_position["position"][0], new_position["position"][1],
new_position["position"][2])
self.player.update_board_positions(new_positions)
return None
def run_initial_turn(self, player, hand, player_move):
target_position = Position(player_move[1], player_move[2],
player_move[3])
if self.rule_checker.valid_initial_move(self.get_board_copy(),
target_position,
player_move[0], hand):
self.place_initial_tile(target_position, player_move[0], player)
self.update_player_board_placement(player, player_move)
else:
self.disqualified_players.append(player.get_name())
logging.info("Player " + player.get_name() +
" was disqualified for making an invalid move")
self.inactive_players.append(player)
def main():
# example render
root = Tk()
observer = Observer()
grid = [[0 for x in range(10)] for y in range(10)]
for x in range(0, 10):
for y in range(0, 10):
grid[x][y] = Tile([])
tile1 = Tile([[0, 1], [2, 3], [4, 5], [6, 7]])
tile2 = Tile([[0, 5], [1, 4], [2, 3], [6, 7]])
tile3 = Tile([[0, 3], [2, 1], [4, 5], [6, 7]])
grid[0][0] = tile1
grid[1][0] = tile2
grid[0][1] = tile3
board = Board()
observer.render_observer(board, "marcos", [Position(0, 2, 1), 90], False,
0, [tile1])
root.geometry("750x500+100+100")
root.mainloop()
def valid_initial_move(self, board, target_pos, tile, given_tiles):
# Check if chosen tile is a valid tile from given tiles
if not self.is_valid_tile(tile, given_tiles):
return False
# Check if target position is actually on the board
target_tile = board.get_tile(target_pos.get_x(), target_pos.get_y())
if not target_tile:
return False
# Check target position must be on the edge of the board
if not board.is_on_edge(target_pos):
return False
# Check if target position has an empty tile
if not target_tile.is_empty():
return False
# Check if surrounding tiles are empty
surroundings = board.get_surrounding_tiles(target_pos.get_x(),
target_pos.get_y())
for surrounding in surroundings:
if not surrounding.is_empty():
return False
# Check if connected_port is false, which means target port is out of range
connected_port = tile.get_path(target_pos.get_port())
if not connected_port:
return False
# Can't be suicidal
player_pos = Position(target_pos.get_x(), target_pos.get_y(),
connected_port)
try:
return not self.is_suicidal(board, tile, target_pos.get_x(),
target_pos.get_y(), player_pos)
except Exception:
# is_suicidal(Board.add_tile) threw exception, invalid target position
return False
parse_move(game_board, player_final_move)
observer.render_observer(game_board, "jack", list(), False, 0, list())
else:
given_tiles = player_final_move[1:]
index = given_tiles.index(player_final_move[0][1])
hand = list()
for tile in given_tiles:
temp_tile = Tile(convert_representation(get_representation(tile)))
hand.append(temp_tile)
if len(player_final_move) == 4:
player_port = player_final_move[0][5]
elif len(player_final_move) == 3:
player_port = 0
placement = Position(player_final_move[0][3], player_final_move[0][4],
player_port)
observer.render_observer(game_board, player_final_move[0][0],
[placement, player_final_move[0][2]],
len(player_final_move) == 4, index, hand)
root.geometry("750x500+100+100")
while True:
try:
root.update_idletasks()
root.update()
except:
break
def check_valid_move(self, x, y, tile, tiles):
curr_pos = self.board.get_player(self.get_color())
return self.rule_checker.valid_move(
Board(self.board.get_grid(), self.board.get_players()), x, y, tile,
tiles, Position(curr_pos[0], curr_pos[1], curr_pos[2]))
def check_valid_initial_move(self, x, y, port, tile, tiles):
return self.rule_checker.valid_initial_move(
Board(self.board.get_grid(), self.board.get_players()),
Position(x, y, port), tile, tiles)