def start_game(self): with open("./GameData/Text/story.json", encoding="utf-8") as infile: data = json.load(infile) self.intro = data['intro'] print(self.intro) directory = "./GameData/RoomTypes" # Iterate through room JSON files in directory and # initialize with Room class constructor using file name for fileName in os.listdir(directory): if fileName.endswith(".json"): room_path = directory + "/" + fileName cur_room = Room.from_file_name(room_path) # Set starting location if cur_room.name == "Serene Forest - South": cur_room.get_desc() cur_room.toggle_visit() self.location = cur_room self.rooms.append(cur_room) else: continue self.player = Player(None) self.play_game()
def _get_player_state(self, player: Player): """ Determines the state of the given player in the game. :return: the state of the player :rtype: PlayerState """ # short-circuit if the player hasn't made their first move, yet if player.tile is None: return PlayerState.ALIVE adjacent = self.board.get_tile_at(*get_coordinates_in_direction( player.tile.x, player.tile.y, player.port.direction)) if adjacent is not None and adjacent is not OutOfBounds: # advance the player onto the adjacent tile and recur player.tile = adjacent player.port = adjacent.get_exit_port(player.port.neighbor) return self._get_player_state(player) elif adjacent is OutOfBounds: death_tile = (player.tile, player.port) if death_tile in self.start_positions: # a player has collided if they end at another's start position return PlayerState.COLLIDED return PlayerState.DEAD elif adjacent is None: return PlayerState.ALIVE
def load_game(self): save_file = Path("./Saves/gameSave.json") if save_file.is_file(): with open("./Saves/gameSave.json") as infile: data = json.load(infile) # Receive JSON lists of data player_data = json.loads(data["player"]) location_data = json.loads(data["location"]) room_data = json.loads(data["rooms"]) # Call constructors for initializing using JSON data self.location = Room( location_data['name'], location_data['long_desc'], location_data['short_desc'], location_data['prior_visit'], location_data['connections'], location_data['inventory'], location_data['feature_list'], True) self.player = Player(player_data['inventory']) # Call constructors for each object in room list from JSON # and append to rooms list in Game for room in room_data: cur_room = Room(room['name'], room['long_desc'], room['short_desc'], room['prior_visit'], room['connections'], room['inventory'], room['feature_list'], True) self.rooms.append(cur_room) self.play_game() else: print("No save file found. Creating a new game...") self.start_game()
def test_player_failed_strategy() -> None: bs = BoardState() p = Player(Strategy()) r = p.generate_move([], bs) assert r.error() == "Strategy does not implement method generate_move!" r2 = p.generate_first_move([], bs) assert r2.error( ) == "Strategy does not implement method generate_first_move!"
def createNewPlayer(self, name): """ Create a New Player """ trainer = TrainerFactory.createNewTrainer("Pokemon Trainer", name) player = Player(trainer, "Player Bedroom - Pallet Town", 5, 5) self.setLastPlayer() playerElement = SubElement(self.rootElement, Tags.playerTag) trainerElement = SubElement(playerElement, Tags.trainerTag) nameElement = SubElement(trainerElement, Tags.nameTag) nameElement.text = trainer.name titleElement = SubElement(trainerElement, Tags.titleTag) titleElement.text = trainer.title zoneElement = SubElement(playerElement, Tags.zoneTag) zoneNameElement = SubElement(zoneElement, Tags.nameTag) zoneNameElement.text = player.zone rowElement = SubElement(zoneElement, Tags.rowTag) rowElement.text = str(player.row) columnElement = SubElement(zoneElement, Tags.columnTag) columnElement.text = str(player.column) lastPlayerElement = SubElement(playerElement, Tags.lastTag) lastPlayerElement.text = "true" self.saveXMLTree() return player
async def _dispatcher(self, websocket, path): player = Player(websocket) try: async for message in player.socket: data = json.loads(message) logging.info(self.MSG_RECEIVED + message) if player.state == PlayerState.USERNAME_SELECTION: if 'username' in data: name = data['username'] if self._is_valid_name(name): player.name = name self.register_player(player) await self.send_valid_username(player) else: await self.send_invalid_username(player) elif player.state == PlayerState.IN_LOBBY: if 'challengePlayer' in data: opponent_name = data['challengePlayer'] if self.name_in_use( opponent_name ) and opponent_name.lower() != player.lower_name: await self.send_challenge_by_name( player, opponent_name) else: pass elif 'joinQueue' in data: do_join = data['joinQueue'] if do_join: await self.join_queue(player) elif 'leaveQueue' in data: self.leave_queue(player) elif player.state == PlayerState.IN_GAME: if 'move' in data: move = data['move'] await self.handle_turn(player, move) finally: await self.disconnect_player(player)
def render_results(inputs): """ Performs placements and returns their results. """ placements = [PlacementFactory.create(x) for x in inputs] players = [] for i, placement in enumerate(placements): p = Player(name=str(i)) p.color = placement.color players.append(p) ref = Referee(players) ref.add_placements(placements) return observer.render_board(ref.board, ref.players)
def createPlayer(): #create a new player money = 0 new_player = Player( "P" + str(len(players) + 1)) #create a player with a new label while money <= 0: #set the money on the player try: money = int( input("How much money does %s have " % new_player.label)) #get input from the user if new_player.setMoney(money): break #try to put the money in the Player Objecet if it meets parameters except ValueError: print("Not a Number!") #money value must be some integer players.append(new_player)
def render_intermediate(inputs, requested): placements = [PlacementFactory.create(x) for x in inputs + [requested[0]]] players = [] for i, placement in enumerate(placements): p = Player(name=str(i)) p.color = placement.color players.append(p) ref = Referee(players) ref.add_placements(placements[:-1]) next_move = placements[-1] ref.players_by_color[next_move.color].tile_hand = [ Tile.Builder.build(i).readonly() for i in requested[1:] ] ref.players_by_color[next_move.color].strategy = Predetermined(next_move) ref.turn_index = ref.turn_order.index( ref.players_by_color[next_move.color]) return observer.render_board(ref.board, ref.players, ref.turn)
def getLastPlayer(self): """ Return the last Player played as """ playerElement = self.getLastPlayerElement() if playerElement is None: return None trainer = self.loadTrainerFromPlayerElement(playerElement) zoneElement = playerElement.find(Tags.zoneTag) zoneName = zoneElement.findtext(Tags.nameTag) row = int(zoneElement.findtext(Tags.rowTag)) column = int(zoneElement.findtext(Tags.columnTag)) return Player(trainer, zoneName, row, column)
def test_admin_by_function() -> None: tobs = TournamentObserver() admin = Administrator(SimpleBracketStrategy()) admin.add_observer(tobs) pid_to_idx = {} for idx in range(20): pid_r = admin.add_player(Player(SecondS())) assert pid_r.is_ok() pid_to_idx[pid_r.value()] = idx time.sleep(0.1) admin.run_tournament()
def create_players(player_info: JSON) -> List[Tuple]: all_players = [] for spec in player_info: if not any(spec["name"] == player[0] for player in all_players): Strat = None try: Strat = get_strategy_component(spec["strategy"]) except Exception: continue if Strat != None: all_players.append((spec["name"], Player(Strat()))) return all_players
def test_admin_10_second_s() -> None: # Assert that it runs in a reasonable amount of time with timeout(seconds=10): admin = Administrator(SimpleBracketStrategy()) pid_to_idx = {} for idx in range(10): pid_r = admin.add_player(Player(SecondS())) assert pid_r.is_ok() pid_to_idx[pid_r.value()] = idx winners_r = admin.run_tournament() assert winners_r.is_ok() real_winners = winners_r.value()[0][0] assert len(real_winners) assert set([pid_to_idx[pid] for pid in real_winners]) == {1, 5}
def test_referee_crashing_player() -> None: cp_exception_init = CrashingPlayer(True, True) cp_error_init = CrashingPlayer(False, True) cp_exception_inter = CrashingPlayer(True, False) cp_error_inter = CrashingPlayer(False, False) p = Player(FirstS()) ref = make_ref() assert ref.set_players([ cp_error_init, cp_exception_init, cp_error_inter, cp_exception_inter, p ]).assert_value() == ["white", "black", "red", "green", "blue"] ref.set_tile_iterator(deterministic_tile_iterator()) r = ref.run_game() assert r.is_ok() assert r.value() == ([{"blue"}], {"green", "red", "black", "white"})
def test_set_players_error() -> None: ref = make_ref() r = ref.set_players([]) assert r.is_error() assert r.error() == "there must be between 3 and 5 players, not 0." r = ref.set_players([Player(FirstS())] * 6) assert r.is_error() assert r.error() == "there must be between 3 and 5 players, not 6." r = ref.set_players([Player(FirstS())] * 4) assert r.is_error() assert ( r.error() == "the given set of players contains duplicates (or players that do not implement __hash__, __eq__)" ) r = ref.set_players([Player(FirstS()), Player(FirstS()), Player(FirstS())]) assert r.is_ok() assert r.value() == ["white", "black", "red"] r = ref.set_players([Player(FirstS()), Player(FirstS()), Player(FirstS())]) assert r.is_error() assert r.error() == "players have already been set for this game."
def test_admin_5_second_s() -> None: admin = Administrator(SimpleBracketStrategy()) pid_to_idx = {} players = [] for idx in range(5): player = Mock(wraps=Player(SecondS())) players.append(player) pid_r = admin.add_player(player) assert pid_r.is_ok() pid_to_idx[pid_r.value()] = idx winners_r = admin.run_tournament() assert winners_r.is_ok() real_winners = winners_r.value()[0][0] assert set([pid_to_idx[pid] for pid in real_winners]) == {0, 2} assert players[0].notify_won_tournament.call_args_list == [call(True)] assert players[1].notify_won_tournament.call_args_list == [call(False)] assert players[2].notify_won_tournament.call_args_list == [call(True)] assert players[3].notify_won_tournament.call_args_list == [call(False)] assert players[4].notify_won_tournament.call_args_list == [call(False)]
def test_admin_crashing_player() -> None: admin = Administrator(SimpleBracketStrategy()) cp_exception_init = CrashingPlayer(True, True) assert admin.add_player(cp_exception_init).is_ok() cp_error_init = CrashingPlayer(False, True) assert admin.add_player(cp_error_init).is_ok() cp_exception_inter = CrashingPlayer(True, False) assert admin.add_player(cp_exception_inter).is_ok() cp_error_inter = CrashingPlayer(False, False) assert admin.add_player(cp_error_inter).is_ok() p = Player(FirstS()) r = admin.add_player(p) assert r.is_ok() real_player_pid = r.value() winners_r = admin.run_tournament() assert winners_r.is_ok() real_winners = winners_r.value()[0][0] assert real_winners == {real_player_pid}
def game_setup(): player_name = '' player_balance = 0 while True: try: player_name = input("Please enter your name: ") player_balance = int(input("Please enter your balance: ")) break except ValueError: print("Enter your balance in number!") continue p1 = Player(player_name.capitalize(), player_balance) print("Thank you for the details.\nYour dealer for the game will be: {}. \n" "The balance for {} is USD {}. " "Let us begin!".format(d1.get_dealer_name(), p1.player_name, p1.money_balance)) start_game(p1)
def run_game(names): players = [Player(name=name, age=i) for i, name in enumerate(names)] ref = Referee(players=players) while ref.run_turn(): pass overall_losers, overall_winners = [], [] for round_number in reversed(sorted(ref.dead.keys())): results = ref.dead[round_number] winners = [] for player, reason in results: (overall_losers if reason is PlayerState.EJECTED else winners).append(player.name) if winners: overall_winners.append(winners) return {"losers": overall_losers, "winners": overall_winners}
def make_players(num_players: int) -> List[PlayerInterface]: return [Player(FirstS()) for _ in range(num_players)]
def run_game(self): log.info("started run game") soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: soc.connect((self.host, self.port)) log.info("connected") except: log.error("Connection error") sys.exit() is_active = True strategy = None if self.strategy_name.lower() == "dumb": strategy = Dumb() elif self.strategy_name.lower() == "second": strategy = Second() player = Player(self.player_name, strategy) while is_active: data = soc.recv(5120).decode("utf8") if not data: exit(code=0) server_message = json.loads(data) try: msg_type = ServerMessage(server_message["type"]) except ValueError: log.error( f"{server_message['type']} is not a valid message type") continue if msg_type is ServerMessage.ASK_FOR_PLAYER_INFO: # server should ask for join then send join request # fmt: off soc.sendall( json.dumps({ "type": ClientMessage.JOIN.value, "name": self.player_name, "strategy": self.strategy_name, }).encode("utf8")) # fmt: on if msg_type is ServerMessage.ASK_FOR_MOVE: # convert the json board into a Board # convert the json tiles into Tiles board = server_message["board"] real_board = ReadOnlyBoard.json_to_board(board) # player.receive_gamestate(real_board) # a list of tiles, call json to tile on each real_tiles = [ ReadOnlyTile.json_to_tile(tile) for tile in server_message["tiles"] ] player.receive_tiles(real_tiles) move = player.next_move() # fmt: off soc.sendall( json.dumps({ "type": ClientMessage.MOVE_REQUEST.value, **move.to_json() }).encode("utf8")) # fmt: on if msg_type is ServerMessage.RECEIVE_COLOR: player.receive_color(Color(server_message["color"])) if msg_type is ServerMessage.MOVE_ACCEPTED: player.receive_move_success() if msg_type is ServerMessage.EJECTED: player.receive_move_failure(server_message["reason"]) if msg_type is ServerMessage.RECEIVE_GAME_STATE: # their own message type and the interface for player should # support receiving them player.tile = (ReadOnlyTile.json_to_tile( server_message["tile"]) if server_message["tile"] is not None else None) player.port = (Port[server_message["port"]] if server_message["port"] is not None else None) player.receive_gamestate( ReadOnlyBoard.json_to_board(server_message["board"]), PlayerState[server_message["state"]], server_message["players"], )
def test_player_calls_observers() -> None: bs = BoardState() lo = LoggingPlayerObserver() p = Player(FirstS()) p.add_observer(lo) p.set_color("red") assert lo.set_colors == ["red"] p.set_color("green") assert lo.set_colors == ["red", "green"] assert p.generate_first_move( [index_to_tile(3), index_to_tile(4), index_to_tile(5)], bs).is_ok() assert lo.initial_move_offereds == [ ([index_to_tile(3), index_to_tile(4), index_to_tile(5)], bs) ] assert lo.initial_move_playeds == [( [index_to_tile(3), index_to_tile(4), index_to_tile(5)], bs, InitialMove(BoardPosition(1, 0), index_to_tile(5), Port.RightTop, "green"), )] assert p.generate_move([index_to_tile(10), index_to_tile(11)], bs).is_ok() assert lo.intermediate_move_offereds == [ ([index_to_tile(10), index_to_tile(11)], bs) ] assert lo.intermediate_move_playeds == [( [index_to_tile(10), index_to_tile(11)], bs, IntermediateMove(index_to_tile(10), "green"), )] gr = ([{"red"}, {"black", "green"}], {"white"}) p.game_result(gr) # type: ignore assert lo.game_results == [gr]
import numpy as np # pegartempo import time pygame.init() window = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) icon = pygame.image.load("./Img/icon.png") pygame.display.set_caption("Carros autonâmos") clock = pygame.time.Clock() pygame.display.set_icon(icon) # init players players = [] for i in range(N_PLAYERS): pose = Pose(PIX2M * round(907 + i * 65 / N_PLAYERS), PIX2M * 435, -pi / 2) players.append(Player(pose, 3 * FORWARD_SPEED, 3 * ANGULAR_SPEED, i)) player = np.array(players) simulation = Simulation(player) # cars cars = [] for i in range(N_PLAYERS): cars.append(pygame.image.load("./Img/carro" + str(i % 7) + ".png")) # collision array scale = 1 position = (0, 0) mapParameters = [scale, position] carsParameters = [] simulation.initScenario(window, mapParameters, cars)
def setUp(self): self.board = Board() self.board.add_tile(get_tile(0), x=5, y=5, rotation=0) self.player = Player() self.rule = FirstMoveCheckNeighbors()
def setUp(self): self.board = Board() self.player = Player() self.rule = FirstMoveOutsidePort()
def setUp(self): self.board = Board() self.player = Player() self.rule = FirstMoveOnBorder()
def test_invalid(self): placement = dummy_placement(x=0, y=0) is_valid, msg = self.rule.is_valid(placement, self.board, Player()) self.assertFalse(is_valid) self.assertEqual(msg, UnoccupiedSpace.ERROR_MSG)
def test_valid(self): placement = dummy_placement(x=1, y=1) is_valid, msg = self.rule.is_valid(placement, self.board, Player()) self.assertTrue(is_valid)
def setUp(self): self.board = Board() self.board.add_tile(get_tile(0), x=0, y=0, rotation=0) self.player = Player() self.rule = UnoccupiedSpace()
def __init__(self, ip: str, port: int, strategy: str): Strat = get_strategy_component(strategy) if Strat != None: self._remote_admin = RemoteAdmin(Player(Strat())) self._remote_admin.connect_to_admin(ip, port)