def test_play(game_factory, faker): lobby = Lobby() player1 = Player(faker.pystr(), faker.name()) player2 = Player(faker.pystr(), faker.name()) lobby.register_player(player1) lobby.register_player(player2) char1 = lobby.create_character() char2 = lobby.create_character() lobby.assign_character(player1, char1) lobby.assign_character(player2, char2) game = lobby.start_game(Grid(20, 20)) char1.spawn(game.grid, (1, 1), Direction.DOWN) char2.spawn(game.grid, (1, 2), Direction.UP) with pytest.raises(ActionNotAllowedError): game.action(char1, ActionType.STEP, step=Step.FORWARD) game.action(char1, ActionType.TURN, turn=Turn.LEFT) game.action(char1, ActionType.STEP, step=Step.FORWARD) game.action(char1, ActionType.STEP, step=Step.FORWARD) game.action(char1, ActionType.TURN, turn=Turn.LEFT) assert game.turn_manager.current_character() == char2 assert game.characters[char1.char_id].address == (3, 1) assert game.characters[char1.char_id].direction == Direction.UP
def createPlayer(self, team): player = Player() player.team = team playerId = id(player) self.players[playerId] = player for o in self.observers: o.callRemote('createPlayer', playerId, player) return player
def test_create_4x4_board(self): player1 = Player(name="test1", symbol="o") player2 = Player(name="test2", symbol="x") self.board = Board(player1, player2, 4) self.assertEqual(self.board.grid_map, [['1', '2', '3', '4'], ['5', '6', '7', '8'], ['9', '10', '11', '12'], ['13', '14', '15', '16']])
def test_figures_out_own_best_hand(self): mock_hand = MagicMock() mock_hand.best_rank.return_value = "Royal Flush" player = Player(name="Boris", hand=mock_hand) self.assertEqual(player.best_hand(), "Royal Flush") mock_hand.best_rank.assert_called()
def redeem_property(self, player: Player, field): logger = logging.getLogger('redeem_property') logger.info('Игрок {} выкупает поле {}'.format(player, field)) self.take_money_from_player(player, field.redeem_cost) player.redeem_field(field) field.redeem() self.check_fill_color(player)
def __init__(self): self.high = np.array([1.1, 1.1, 0.85, 1.03, 1.03]) self.low = np.array([-1.1, -1.1, -0.01, -0.04, -0.04]) self.WIDTH = world_settings["WIDTH"] self.HEIGHT = world_settings["HEIGHT"] self.display_render = False self.game_over = False self.player = Player( self, random.randint(0, self.WIDTH - player_setting["width"]), #Randon position x self.HEIGHT - player_setting["height"] - player_setting["padding"], #position bottom ) self.autoplayer = Player( self, random.randint(0, self.WIDTH - player_setting["width"]), #Randon position x player_setting["height"] - player_setting["padding"], #position top ) self.ball = Ball( self, random.randint(16, self.WIDTH - 16), self.HEIGHT / 2 - 8, [self.player, self.autoplayer] #Interact with ) self.clock = pg.time.Clock()
def mortgage_property(self, player: Player, field): logger = logging.getLogger('mortgage_property') logger.info('Игрок {} закладывает поле {}'.format(player, field)) amount = field.mortgage() self.give_money_to_player(player, amount) player.mortgage_field(field) self.check_fill_color(player)
def joinGame(self, game_id=None, password=None): if password: password = self._generatePassword(password) self._refreshSeriesState() if not game_id: game = Game.getPlayerLastGame(series_id=self._seriesState['id'], player_id=self._playerState['id']) if not game or game['status'] == Base_Game.STATUS_ENDED: game = Game.getLastGameInSeries( series_id=self._seriesState['id']) if not game: raise GameWasNotCreateError else: game = Game.get(game_id=game_id) if not game: raise GameWasNotCreateError self._isPlayerHasAccessToGame(game['id'], password) if self._playerState['game_id'] != game['id']: Player.joinGame(player_id=self._playerState['id'], role=Game.PLAYER_ROLE_MEMBER, game_id=game['id']) if password: Player.setGamePassword(player_id=self._playerState['id'], game_id=game['id'], password=password) # self._refreshGameState(password=password, game_id=game['id'], checkGameStatus=False) return game, "Иииха! Ты присовокупился к игре с ID %d серии игр с ID %d" % ( game['id'], self._seriesState['id'])
def test_pay_player(self): chloe = Player("Chloe", 0) lucien = Player("Lucien", 1) amount = 1000 chloe.pay_player(lucien, amount) self.assertEqual(INITIAL_MONEY - amount, chloe.money) self.assertEqual(INITIAL_MONEY + amount, lucien.money)
class TestPlayer(TestCase): def test_win_set(self): ball = Ball(pong.config.white, 10) engine = ComputerControlEngine(ball) self.player = Player('left', 'left', engine) self.player.win_set() self.assertEqual(1, self.player.sets())
def apply_active_spells(player: Player, boss: Boss): for spell in player.active_spells: spell["turns"] -= 1 if spell["name"] == "Shield": # print(f"Shield increasing armor by 7 for {spell['turns']} turns.") player.armor = spell["armor"] elif spell["name"] == "Recharge": # print(f"{spell['name']} provides {spell['mana']} mana; its timer is now " # f"{spell['turns']}.") player.mana += spell["mana"] else: raise NotImplementedError("Unknown Spell!") if not spell["turns"]: # print(f"{spell['name']} wears off.") player.active_spells.remove(spell) if spell["name"] == "Shield": player.armor = 0 for spell in boss.active_spells: spell["turns"] -= 1 if spell["name"] == "Poison": # print(f"{spell['name']} deals {spell['damage']} damage; its timer " # f"is now {spell['turns']}.") boss.hit_points -= spell['damage'] else: raise NotImplementedError("Unknown Spell!") if not spell["turns"]: # print(f"{spell['name']} wears off.") boss.active_spells.remove(spell)
def _addRandomWord(self): if 'randomPlayers' not in self._roundSettings or not self._roundSettings[ 'randomPlayers']: return if 'randomWordsLimit' not in self._roundSettings or not self._roundSettings[ 'randomWordsLimit']: return randomPlayersProcessed = 0 for randomPlayer in self._RANDOM_PLAYER: if randomPlayersProcessed >= self._roundSettings['randomPlayers']: break if not Player.get(telegram_id=randomPlayer['id']): Player.add(telegram_id=randomPlayer['id'], name=randomPlayer['first_name']) randomPlayersProcessed += 1 if Word.getListByRoundId(telegram_id=randomPlayer['id'], **self._gameState['query']): continue randomWordsCount = 0 wordsAdded = 0 while wordsAdded <= self._roundSettings['randomWordsLimit']: if randomWordsCount > 20: break randomWordsCount += 1 word = self._getRandom( "ushakov", wordMinLength=self._roundSettings['minWordsPerPlayer']) if not word: continue Word.add(word=word, player_id=Player.getId(randomPlayer), wordsLimit=self._roundSettings['randomWordsLimit'], wordMinLength=self._roundSettings['minWordLength'], **self._gameState['query']) wordsAdded += 1
def __init__(self, snakes, apples, speed, autoplay): if getattr(sys, 'frozen', False): CurrentPath = sys._MEIPASS else: CurrentPath = os.path.dirname(__file__) self.speed = speed self.window = Window() self.apples = Apples(apples) self.go = False self.goCount = 0 fontFile = os.path.join(CurrentPath, "freesansbold.ttf") if not os.path.exists(fontFile): fontFile = "freesansbold.ttf" self.font = pygame.font.Font(fontFile, 240) self.font.set_bold(True) self.fontSmall = pygame.font.Font(fontFile, 120) self.fontSmall.set_bold(True) self.textSurf = None self.end = False self.startPlayers = snakes self.players = [] self.players.append(Player(window = self.window, apples = self.apples, players = self.players, ki = bool(autoplay))) for i in range(snakes - 1): self.players.append(Player(color = (randint(0, 255), randint(0, 255), randint(0, 255)) ,window = self.window, apples = self.apples, players = self.players, ki = True)) self.loop()
def init_game_objects(self): self.grid = Grid(GRID_CELL_SIZE, GREY, pygame, self.screen, MAP_SIZE) self.player = Player(self.grid.center_x, self.grid.center_y, GRID_CELL_SIZE, BODY_LENGTH) self.food = Food(GRID_CELL_SIZE, self.grid.rows - 1, self.grid.columns - 1) self.controller = Controller(self.player)
def human_input_selection_screen_handler(interface_items, players, mouse_position): """ Captures the user input during the selection screen, initializes the player class instances depending on the user's selection on and append them into the players list. :param interface_items: type: dict Dictionary containing all of the user interface (UI) items to be displayed. From this dict, we can find the references for the objects that the user selects :param players: type: list Starts off as an empty list, used to contain the initialized players when the user selects a mark :param mouse_position: type: tuple Tuple of the X & Y coordinates of the mouse cursor on the pygame window """ if interface_items['x_sign'].is_mouse_hover( mouse_position) or interface_items['x_label'].is_mouse_hover( mouse_position): # Create players bot = Player(bot=True, state=BOT_STATE, mark="O") human = Player(bot=False, state=HUMAN_STATE, mark="X") players.append(bot) players.append(human) elif interface_items['o_sign'].is_mouse_hover( mouse_position) or interface_items['o_label'].is_mouse_hover( mouse_position): # Create players bot = Player(bot=True, state=BOT_STATE, mark="X") human = Player(bot=False, state=HUMAN_STATE, mark="O") players.append(bot) players.append(human)
def _init(**params): if 'status' not in params: params['status'] = Game.STATUS_PREPARATION game_id = DB.execute( """ INSERT INTO game SET creator_id = %(player_id)s, status = %(status)s, settings = %(settings)s, series_id = %(series_id)s """, params).lastrowid logging.info("New game was started. ID: %d" % game_id) Round.getId(game_id) params[ 'role'] = Series.PLAYER_ROLE_MEMBER if 'seriesRole' not in params else params[ 'seriesRole'] Player.joinSeries(**params) params[ 'role'] = Game.PLAYER_ROLE_ADMIN if 'gameRole' not in params else params[ 'gameRole'] Player.joinGame(game_id=game_id, **params) return game_id
def battle_fixed(player: Player, boss: Boss) -> bool: spell_list = [ 'Shield', 'Recharge', 'Poison', 'Drain', 'Recharge', 'Magic Missile', 'Poison', 'Drain', 'Recharge', 'Magic Missile', 'Magic Missile', 'Magic Missile', 'Shield', 'Drain', 'Drain', 'Poison', 'Drain' ] player_turn = True while player.hit_points > 0 and boss.hit_points > 0: print("-- Boss turn --") if not player_turn else print( "-- Player turn --") print( f"- Player has {player.hit_points} hit points, {player.armor} armor, " f"{player.mana} mana") print(f"- Boss has {boss.hit_points} hit points") apply_active_spells(player, boss) if player_turn: active_spells = [spell["name"] for spell in player.active_spells] + \ [spell["name"] for spell in boss.active_spells] # spell = player.cast_spell(active_spells) spell_name = spell_list.pop(0) for spell in player.get_spells(): if spell['name'] == spell_name: break if player.mana < spell["cost"]: print(f"Cannot cast spell, no mana left!") return False else: player.mana -= spell["cost"] player.mana_spent += spell["cost"] if spell["damage"]: if spell["turns"]: print(f"Player casts {spell['name']}.") boss.apply_spell(spell) else: if spell["heals"]: player.hit_points += spell["heals"] print(f"Player casts {spell['name']}, " f"dealing {spell['damage']} damage.") boss.hit_points -= spell["damage"] else: print(f"Player casts {spell['name']}.") player.apply_spell(spell) player_turn = False else: damage_dealt = boss.damage - player.armor if damage_dealt <= 0: damage_dealt = 1 player.hit_points -= damage_dealt print(f"Boss attacks for {damage_dealt} damage!") player_turn = True if player.hit_points <= 0: return False else: return True
def test_acid_bath_multi(self): test = Room(RoomType.acid_bath, False) player = Player() event = test.on_room_enter( [], player, [player, Player(), Player(), Player()]) self.assertEqual(player.current_room, test) self.assertEqual([], event)
def new_player(self, *args): p = None if len(self.players) == 0: p = self.owner = Player(0, *args) else: p = Player(len(self.players), *args) self.players.append(p) return p
def __init__(self, seed): self.random = Random(seed) self.lanes = [Lane(self), Lane(self), Lane(self)] self.players = [Player(0, self.lanes), Player(1, self.lanes)] self.current_lane, self.current_player = 0, 0 self.pass_lane = 0 self.initialize_game() pass
def test_card_validation(): with pytest.raises(Exception, match="Cards must be a list of type Card"): Player(cards=[1]) with pytest.raises(Exception, match="Cards must be a list of type Card"): cards = index.serialize_cards(make_cards([1, 2])) Player(cards=cards) with pytest.raises(Exception, match="Cards must be a list of type Card"): Player(cards=Card(1))
def open(self): log.debug("WebSocket opened") self.nextIsBinary = None Websocket.websocket_clients.append(self) self.player = Player(self) ans = {"cmd": "version"} self.write_message(json.dumps(ans)) # hier ok!
def test_player_input(self): player1 = Player(name="test1", symbol="o") player2 = Player(name="test2", symbol="x") self.board = Board(player1, player2) with mock.patch('builtins.input', return_value="1"): player1.input_move(self.board) new_grid_map = [['o', '2', '3'], ['4', '5', '6'], ['7', '8', '9']] self.assertEqual(self.board.grid_map, new_grid_map)
def setUp(self) -> None: ball = Ball(pong.config.white, 10) engine = ComputerControlEngine(ball) self.left_player = Player('left', 'left', engine) self.right_player = Player('right', 'right', engine) self.score_manager = ScoreManager(self.left_player, self.right_player, (1, 5)) self.score_board = ScoreBoard(self.score_manager) self.scene = Scene(Window(100, 100, 'Test'))
def __player_move(self, x: int, y: int, player: Player) -> bool: if player.get_player_id() == self.__active_player__.get_player_id(): if self.__field__.fill_cell(x, y, player.get_player_type()): self.__change_active_player() return True else: return False else: return False
def test_go_to_jai(self): chloe = Player("Chloe", 0) board = Board() board.boxes[3].players.append(0) chloe.position = 3 card = Card(card_id="666", name="", card_type="go-to-jail", value=-1) card.execute(chloe, None, board) self.assertTrue(chloe.in_jail) self.assertEqual(JAIL_POSITION, chloe.position)
def test03AGameStartsWithaChessBoardThatHas32Pieces(self): aChessBoard = NewGameChessBoard() twoPlayers = [ Player(aChessBoard.whitePieces()), Player(aChessBoard.blackPieces()) ] aChessGame = ChessGame(aChessBoard, twoPlayers[0], twoPlayers[1]) self.assertTrue(len(aChessGame.board().pieces()) is 32)
def test01AGameHasAChessBoard(self): aChessBoard = NewGameChessBoard() twoPlayers = [ Player(aChessBoard.whitePieces()), Player(aChessBoard.blackPieces()) ] aChessGame = ChessGame(aChessBoard, twoPlayers[0], twoPlayers[1]) self.assertIsInstance(aChessGame.board(), ChessBoard)
def test_acid_bath_two_same_room(self): test = Room(RoomType.acid_bath, False) player = Player() player2 = Player() players = [player, Player(), player2, Player()] test.on_room_enter([], player2, players) event = test.on_room_enter([], player, players)[0] self.assertEqual(player.current_room, test) self.assertEqual(RoomEvent(RoomEventType.player_death, player2), event)
class testPlayer(unittest.TestCase): def setUp(self): start_pos = (1, 2) self.knight = Player("Knightsebbe", "knight", start_pos) self.wizard = Player("wizSeb", "wizard", start_pos) self.thief = Player("thiefSeb", "thief", start_pos) self.dungeon = Map(4) self.char = Player("Bob", "knight", self.dungeon.get_room(1, 1)) self.char2 = Player("Bob", "knight", self.dungeon.get_room(0, 1)) def testKnightProperties(self): self.assertEqual(self.knight.initiative, 5) self.assertEqual(self.knight.hp, 9) self.assertEqual(self.knight.attack, 6) self.assertEqual(self.knight.dexterity, 4) def testWizardProperties(self): self.assertEqual(self.wizard.initiative, 6) self.assertEqual(self.wizard.hp, 4) self.assertEqual(self.wizard.attack, 9) self.assertEqual(self.wizard.dexterity, 5) def testThiefProperties(self): self.assertEqual(self.thief.initiative, 7) self.assertEqual(self.thief.hp, 5) self.assertEqual(self.thief.attack, 5) self.assertEqual(self.thief.dexterity, 7) def testPosition(self): self.assertEqual(self.char.show_location, (1, 1)) def testPosition2(self): self.assertEqual(self.char2.show_location, (0, 1)) def testMovePlayerNorth(self): new_room = self.char.move_character('N', self.dungeon) self.assertEqual(new_room, self.dungeon.get_room(1, 0)) def testMovePlayerSouth(self): new_room = self.char.move_character('S', self.dungeon) self.assertEqual(new_room, self.dungeon.get_room(1, 2)) def testMovePlayerEast(self): new_room = self.char.move_character('E', self.dungeon) self.assertEqual(new_room, self.dungeon.get_room(2, 1)) def testMovePlayerWest(self): new_room = self.char.move_character('W', self.dungeon) self.assertEqual(new_room, self.dungeon.get_room(0, 1)) def testMovePlayerOtOfBounds(self): new_room = self.char.move_character('N', self.dungeon) new_room = self.char.move_character('N', self.dungeon) self.assertFalse(new_room)
def setUp(self): self.player1 = Player("Player 1") self.player2 = Player("Player 2") self.edges, self.city_edges = self.create_test_board() self.deck, self.destinations = self.create_test_deck() self.game = Game([self.player1, self.player2], custom_settings=True, edges=self.edges, city_edges=self.city_edges, deck=self.deck, num_cars=12, destinations=self.destinations)
def createPlayer(self, player_id,team): '''add a player to the given team''' player = Player() player.team = team playerId = id(player) player.player_id = player_id self.players[playerId] = player return player
def setup(self): if self.state is not Table.State.CREATED: raise StateError('Table must be CREATED to be setup.') self.deck.shuffle() self.kitty = self.deck.deal(4) while self.deck.has_cards: for pid in self.players: card = self.deck.deal() Player.get(self._data_store, pid).hand.insert_card(card) self._update_model('deck') self.state = Table.State.BETTING self.player_turn = self.round_start_player
def createPlayer(self, player_id,team): '''add a player to the given team''' player = Player() player.team = team playerId = id(player) player.player_id = player_id #player.player_id = Environment.NEXT_PLAYER_ID #Environment.NEXT_PLAYER_ID = Environment.NEXT_PLAYER_ID + 1 self.players[playerId] = player return player
def createPlayer(self, team): player = Player() player.team = team # I have no idea if this is being set somewhere else #if self.team == None: # self.team = team playerId = id(player) self.players[playerId] = player for o in self.observers: o.callRemote('createPlayer', playerId, player) #player.sounds = self.sounds return player
def add_player(self, user, slot): """Add a player to the game. :param user: User -- The player's `User` object. :param team: str -- The team to join ('A' or 'B'). :raise: ValueError if `Game` is not in a state to add players, or the table is already full. """ if slot not in range(4): raise ValueError("Invalid player slot provided.") if self.players[slot] and not self.players[slot].abandoned: raise ValueError("Slot is taken. Cannot add player.") for p in self.players: if p and not p.abandoned and p.user.uid is user.uid: raise ValueError("User already apart of game.") team = 'A' if slot in (0, 2) else 'B' if self.state is Game.State.CREATED: self.players[slot] = Player.new(user, team, self._data_store) self._update_model('players') if self.active_players() == 4: self.state = Game.State.READY elif self.state is Game.State.PAUSED and self.players[slot].abandoned: self.players[slot].new_user(user) self._update_model('players') if self.active_players() == 4: self.state = Game.State.RUNNING self.table.resume()
def _end_betting(self): self.round_start_player = self.betters[0] p = Player.get(self.players[self.betters[0]], self._data_store) self.bet_team = p.team for c in self.kitty: p.hand.insert_card(c) self.kitty = [None] * 4 self.state = Table.State.PLAYING self.player_turn = self.round_start_player
def __init__(self, refToGameEntiyMngr, networkClient): self.refToGameEntiyMngr = refToGameEntiyMngr self.networkClient = networkClient self.refToGameEntiyMngr.loadUnit("Clone") self.refToPlayer = Player(0, False) self.refToPlayer.name = "Clone" self.refToGameEntiyMngr.addEntity(self.refToPlayer)
def get(self, *args, **kwargs): user_id = self.get_current_user() player_db = PlayerModel.objects.filter(playerId=user_id).first() player = self.desk.is_player_in(user_id) if player_db: if player: player.left = False player.desk = self.desk else: player = Player(user_id, player_db.player_name, player_db.player_phone, self.desk) player.db = player_db application.add_handlers(r'.*$', [(self.request.uri + '/' + str(player.id) + '/get', PokerWebSocket, {'player': player, 'desk': self.desk})]) self.write(self.request.uri + '/' + str(player.id) + '/get') return self.finish() else: return self.write(self.request.uri)
class LocalMapState(State): def __init__(self, state_map): super(LocalMapState, self).__init__() self.camera = ScrolledRenderer(state_map) self.hero = Player(155, 155) self.camera.group.add(self.hero) def on_exit(self): print 'local_map on_exit' def update(self, screen, dt): self.hero.handle_input() self.camera.group.center(self.hero.rect.center) self.camera.group.draw(screen) self.camera.group.update(dt) def on_enter(self, params=None): print 'local_map on_enter'
def __init__(self, **kwargs): super(PlayWidget, self).__init__(**kwargs) # 330, 220 playRect = Rectangle(pos=(50, 40), size=(610, 400)) self.enemyGroup = InstructionGroup() self.world = World() # Create Players self.player1 = Player('p1') self.player2 = Player('p2') # Create Beam self.beam = Beam(self.player1, self.player2) # Create Score Label self.scoreLabel = Label(text='', pos=(295, 400)) self.timerLabel = Label(text='', pos=(560, 350), font_size=100, halign='right') self.updateScoreDisplay() self.updateTimerDisplay() # Background self.canvas.add(Color(0.2, 0.2, 0.2)) #self.canvas.add(playRect) self.canvas.add(self.enemyGroup) self.canvas.add(self.beam.canvas) self.canvas.add(self.player1.canvas) self.canvas.add(self.player2.canvas) self.canvas.add(self.scoreLabel.canvas) self.canvas.add(self.timerLabel.canvas) self.timeOfLastSpawn = 0 self.nextSpawnIn = 0 self.shouldClose = False
def play_card(self, player_id, card): if not self.trump_suit: raise StateError("Cannot play card before trump suit is set.") if (self.state is not Table.State.PLAYING or player_id is not self.players[self.player_turn]): raise StateError("It is not the player's turn to play a card.") p = Player.get(player_id, self._data_store) if p: c = p.hand.remove_card(card) if not p or not c: raise ValueError("Invalid player or card supplied to play_card.") self.active_cards[self.player_turn] = c self._update_model('active_cards') self.next_turn()
def restore(cls, data_store, data_model): kwargs = { 'players': [Player.restore(data_store, x) if x is not DataModel.Null else None for x in data_model.players], 'spectators': [Spectator.restore(data_store, x) for x in data_model.spectators], 'state': data_model.state, 'table': (Table.restore(data_store, data_model.table) if data_model.table is not DataModel.Null else None), 'points': data_model.points, 'options': DotDict(data_model.options) } return super(Game, cls).restore(data_store, data_model, **kwargs)
def _end_round(self): high_card = self.active_cards[self.round_start_player] suits = [high_card.suit, self.trump_suit] for c in self.active_cards: if c is high_card: continue if (c.suit in suits and (suits.index(c.suit) > suits.index(high_card.suit) or (c.suit is high_card.suit and c.value > high_card.value))): high_card = c index = self.active_cards.index(high_card) winner = Player.get(self.players[index], self._data_store) for c in self.active_cards: self.discards[winner.team].append(c) self._update_model_collection('discards', {'action': 'append'}) self.active_cards = [None] * 4 if not winner.hand.card_count: self.state = Table.State.END else: self.round_start_player = index self.player_turn = index
class MainGameScene(GameScene): refToGameEntiyMngr = None refToPlayer = None mouseButtonPressed = False def __init__(self, refToGameEntiyMngr, networkClient): self.refToGameEntiyMngr = refToGameEntiyMngr self.networkClient = networkClient self.refToGameEntiyMngr.loadUnit("Clone") self.refToPlayer = Player(0, False) self.refToPlayer.name = "Clone" self.refToGameEntiyMngr.addEntity(self.refToPlayer) def handleMouseInput(self, mousebutton, mousePos, state="PRESSED"): if state == "PRESSED": if mousebutton == 1: # self.refToGameEntiyMngr.loadAndCreateUnit('objects/tree1', Vector2D(mousePos[0],mousePos[1]), Vector2D(0,0), 0) mousePosVector = Vector2D(mousePos[0], mousePos[1]) self.networkClient.execute( "explosion " + str(mousePosVector.x) + " " + str(mousePosVector.y), self.handleExplosion ) elif mousebutton == 3: self.mouseButtonPressed = True else: if mousebutton == 3: self.mouseButtonPressed = False self.refToPlayer.setMovment(Vector2D(0, 0), 0.0) def handleExplosion(self, coordinates): # self.refToGameEntiyMngr.createExplosion('explosions/bigDirty', coordinates, 0.2 ) pass def handleMouseMovment(self, mousePos): if self.refToPlayer is not None: self.refToPlayer.setCrosshairPos(mousePos) if self.mouseButtonPressed is True: trgtVec = Vector2D(mousePos[0], mousePos[1]) direction = direction = Vector2D.fromPoints(self.refToPlayer.position, trgtVec) direction.normalizeVector() self.refToPlayer.setMovment(direction, 20.0) def handleKeyInput(self, key, modifier, state="PRESSED"): pass
def main(): global player1 global player2 global serversocket global clientlist host = ''#raw_input("Host: ") port = int(raw_input("Port: ")) try: serversocket = socketSetup(host, port) while True: # first client to connect will be the player1 thread if SharedVar.clients[0] == None: link, addr = connectToClient() player1 = Player(threadID=1, name="player1", link=link, addr=addr, server=serversocket) player1.start() # SharedVar.clientlist[0] = link SharedVar.clients[0] = player1 # second client to connect will be the player2 thread elif SharedVar.clients[1] == None: link, addr = connectToClient() player2 = Player(threadID=2, name="player2", link=link, addr=addr, server=serversocket) # player2.other_link = player1.link # player1.other_link = link player2.start() # SharedVar.clientlist[1] = link SharedVar.clients[1] = player2 # don't connect to other clients (limit to two) # if something goes wrong... except Exception as error: print "Server: Error Occured! " + str(error) traceback.print_exc()
class PlayWidget(Widget): frameNum = 0 score = 0 enemies = [] player1 = None player2 = None world = None roundFrames = FRAMERATE * 30 def __init__(self, **kwargs): super(PlayWidget, self).__init__(**kwargs) # 330, 220 playRect = Rectangle(pos=(50, 40), size=(610, 400)) self.enemyGroup = InstructionGroup() self.world = World() # Create Players self.player1 = Player('p1') self.player2 = Player('p2') # Create Beam self.beam = Beam(self.player1, self.player2) # Create Score Label self.scoreLabel = Label(text='', pos=(295, 400)) self.timerLabel = Label(text='', pos=(560, 350), font_size=100, halign='right') self.updateScoreDisplay() self.updateTimerDisplay() # Background self.canvas.add(Color(0.2, 0.2, 0.2)) #self.canvas.add(playRect) self.canvas.add(self.enemyGroup) self.canvas.add(self.beam.canvas) self.canvas.add(self.player1.canvas) self.canvas.add(self.player2.canvas) self.canvas.add(self.scoreLabel.canvas) self.canvas.add(self.timerLabel.canvas) self.timeOfLastSpawn = 0 self.nextSpawnIn = 0 self.shouldClose = False def setKeyReport(self, keyReport): self.keyReport = keyReport self.beam.setKeyReport(keyReport) def reset(self): self.shouldClose = False self.frameNum = 0 self.world.reset() self.player1.reset() self.player2.reset() self.beam.reset() self.player1.setCenterPos((200, 220)) self.player2.setCenterPos((460, 220)) self.score = 0 self.timeOfLastSpawn = 0 self.nextSpawnIn = 0 def cleanup(self): self.enemyGroup.clear() self.enemies = [] def spawnEnemy(self, enemyType): enemy = Enemy(enemyType) enemy.reset(False) enemy.setWorld(self.world) self.enemyGroup.add(enemy.canvas) centerPos = self.world.nextEnemyPos(enemy.offsetTheta) enemy.setCenterPos(centerPos) self.enemies.append(enemy) def update(self, dt): self.frameNum += 1 if self.frameNum > self.roundFrames: self.shouldClose = True return if self.frameNum % FRAMERATE == 0: self.updateTimerDisplay() self.world.update(dt) # Update Players self.player1.update(dt) self.player2.update(dt) self.spawnNewEnemies() # Update Enemies for enemy in self.enemies: enemy.update(dt) if self.beam.beamState == 0: self.beam.setIsColliding(False) else: collisions = self.getCollisions() if len(collisions) > 0: self.beam.setIsColliding(True) self.consumeEnemies(collisions, self.beam.beamState) else: self.beam.setIsColliding(False) self.clearDeadEnemies() # Update Beam self.beam.update(dt) def consumeEnemies(self, collisions, beamState): totalDelta = 0 for enemy in collisions: delta = enemy.decrement(beamState) totalDelta += delta if not totalDelta == 0: self.score += totalDelta self.updateScoreDisplay() def updateScoreDisplay(self): self.scoreLabel.text = 'Score: ' + str(self.score) def updateTimerDisplay(self): seconds = int(math.ceil((self.roundFrames - self.frameNum) / FRAMERATE)) if seconds > 5: self.timerLabel.color[3] = 0.3 else: self.timerLabel.color[3] = 1 if seconds > 3: self.timerLabel.color[0] = 1 self.timerLabel.color[1] = 1 self.timerLabel.color[2] = 1 else: self.timerLabel.color[0] = 0.6 self.timerLabel.color[1] = 0 self.timerLabel.color[2] = 0 self.timerLabel.text = str(seconds) def spawnNewEnemies(self): if self.timeOfLastSpawn + self.nextSpawnIn > self.frameNum: return enemyType = 'normal' if random.random() < 0.3: enemyType = 'other' self.spawnEnemy(enemyType) self.timeOfLastSpawn = self.frameNum if self.frameNum < 200: self.nextSpawnIn = 10 def clearDeadEnemies(self): deadEnemies = [] for enemy in self.enemies: if enemy.shouldRemove: deadEnemies.append(enemy) if len(deadEnemies) == 0: return aliveEnemies = [] for enemy in self.enemies: if not enemy.shouldRemove: aliveEnemies.append(enemy) # rebuild self.enemyGroup.clear() for enemy in aliveEnemies: self.enemyGroup.add(enemy.canvas) self.enemies = aliveEnemies def getCollisions(self): beamLineCoords = (self.player2.pos[0], self.player2.pos[1], self.player1.pos[0], self.player1.pos[1]) collisions = [] for enemy in self.enemies: if enemy.sprite.collidesWithLine(beamLineCoords): collisions.append(enemy) return collisions
def main(): #test variables #curses.initscr(); one = Player("DakotaJAlton") Item1 = Item("axe", "weapon", 2, 10) Item2 = Item("sword", "weapon", 2, 10) Item3 = Item("helm", "helmet", 2, 10) Monster1 = Monster("goblin", "goblin") currentRoom = None Room1 = Room("Start", "dank hallway") Room2 = Room("Second", "dank Locker") Room2.addMonster(Monster1) Room2.addItem(Item1) Room2.addItem(Item2) Room2.addItem(Item3) Room1.setExit("north", Room2) Room2.setExit("south", Room1) currentRoom = Room1 print "Welcome to the Multiplayer Text Adventure! \nWritten by Dakota Alton and Cole Severson!" #termination while loop while True: user_input = map(lambda s: str.lower(s), str.split(raw_input('--> '))) if user_input[0] == "info": currentRoom.printInfo() elif user_input[0] == "quit": break elif user_input[0] == "go": if currentRoom.checkExit(user_input[1]): currentRoom = currentRoom.getExit(user_input[1]) currentRoom.printInfo() else: print "Exit spelled wrong or non-existing" elif user_input[0] == "inventory": one.backpack() elif user_input[0] == "grab": if currentRoom.hasItem(user_input[1]): one.pickup(currentRoom.snatchItem(user_input[1])) else: print "no such item here... scrub" elif user_input[0] == "status": one.getStats() elif user_input[0] == "equip": one.equipWeapon(user_input[1]) elif user_input[0] == "equipped": one.getEquipped() elif user_input[0] == "attack": marker = False for m in currentRoom.monsters: if m.name == user_input[1]: m.damageMonster(one.getDamage()) marker = True #TODO add flavor text attack statement if marker == False: print "there is no monster with this name here..." else: print "invalid selection" print termcolor.colored("-------------------", 'green') #end of the main running loop print "Thank you for playing..."
def __init__(self, state_map): super(LocalMapState, self).__init__() self.camera = ScrolledRenderer(state_map) self.hero = Player(155, 155) self.camera.group.add(self.hero)
def game_screen(): background = OrderedGroup(0) foreground = OrderedGroup(1) mp.queue(Resources.audio['game_bgm']) hand_board = MyRectangle(name = 'hand_board', curr_state = "GAME", opacity = 255, x = 650, y = 330, img = Resources.sprites['hand_board'], batch = game_batch, group = background) prog_board = MyRectangle(name = 'prog_board', curr_state = "GAME", opacity = 255, x = 650, y = 5, img = Resources.sprites['programming_board'], batch = game_batch, group = background) player1 = Player(actual_name = 'Player', name = 'Player1', img = Resources.sprites['no_sprite'], x = (Resources.window_width*0.5) - 150, y = Resources.window_height*0.5) player2 = Player(actual_name = 'Player', name = 'Player2', img = Resources.sprites['no_sprite'], x = Resources.window_width*0.5+100, y = Resources.window_height*0.5) label_player = UILabel(name = 'player', text = 'Player2:', x = hand_board.x+9, y = hand_board.y+hand_board.height-2, anchor_y = 'top', color = (57, 255, 20, 255), batch = game_batch, group = foreground) player_name = UILabel(name = 'player_name', text = player1.name, x = hand_board.x + 75, y = label_player.y, anchor_y = 'top', color = (57,255,20,255), batch = game_batch, group = foreground) label_hand_card = UILabel(name = 'label_hand_card', text = 'Card at Hand', x = hand_board.x + (hand_board.x/2) - 55, y = label_player.y, anchor_y = 'top', color = (57,255,20,255), batch = game_batch, group = foreground) label_prog_card = UILabel(name = 'label_prog_card', text = 'Programming Board', x = hand_board.x + (hand_board.x/2) - 80, y = prog_board.y+prog_board.height, anchor_y = 'top', color = (57,255,20,255), batch = game_batch, group = foreground) label_lives = UILabel(name = 'label_lives', text = 'Lives: ', x = hand_board.x+hand_board.width-170, y = hand_board.y+hand_board.height-2, anchor_y = 'top', color = (57, 255, 20, 255), batch = game_batch, group = foreground) lives = UILabel(name = 'lives', text = player1.get_life_label(), x = label_lives.x+55, y = label_lives.y, anchor_y = 'top', color = (57, 255, 20, 255), batch = game_batch, group = foreground) label_mana = UILabel(name = 'label_mana', text = 'Mana: ', x = hand_board.x+hand_board.width-80+2, y = hand_board.y+hand_board.height-2, anchor_y = 'top', color = (57, 255, 20, 255), batch = game_batch, group = foreground) mana = UILabel(name = 'mana', text = player1.get_mana_label(), x = hand_board.x+hand_board.width-30+2, y = hand_board.y+hand_board.height-2, anchor_y = 'top', color = (57, 255, 20, 255), batch = game_batch, group = foreground) end_turn_button = EndTurnButton(name = 'end_turn_button', curr_state = 'PLAYER1', world = world, img = Resources.sprites['end_turn_button'], x = mana.x - 46, y = label_prog_card.y - 20, batch = game_batch, group = foreground) program_button = ProgramButton(name = 'program_button', curr_state = 'PLAYER1', world = world, img = Resources.sprites['program_button'], x = prog_board.x+9, y = end_turn_button.y, batch = game_batch, group = foreground) game_board = GameBoard(name = 'game_board', world = world, x = 5, y = 7, img = Resources.sprites['game_board']) blocker = MyRectangle(name = 'blocker', curr_state = "GAME", opacity = 200, x = 650, y = 5, img = Resources.sprites['blocker']) glow = MyRectangle(name = 'glow', curr_state = "GAME", opacity = 255, x = 0, y = 0, img = Resources.sprites['tile_glow']) glow.image.anchor_x += 20 glow.image.anchor_y += 20 #for manual programming terminal = Terminal(name = 'terminal', curr_state = 'PLAYER1', world = world, img = Resources.sprites['terminal'], x = prog_board.x + 20, y = prog_board.y + 109, batch = programming_batch) line_widget_1 = TextWidget(name = 'line_widget_1', text = '', x = terminal.x - 7, y = terminal.y - 35, width = 500, cursor = game_window.get_system_mouse_cursor('text'), curr_state = 'PROGRAMMING1', world = world, batch = text_batch_1) line_widget_2 = TextWidget(name = 'line_widget_2', text = '', x = terminal.x - 7, y = terminal.y - 35, width = 500, cursor = game_window.get_system_mouse_cursor('text'), curr_state = 'PROGRAMMING2', world = world, batch = text_batch_2) return_button = ReturnButton(name = 'return_button', curr_state = 'PLAYER1', world = world, img = Resources.sprites['return_button'], x = line_widget_1.x+500+13, y = line_widget_1.y - 3, batch = programming_batch) game_window.push_handlers(player1) game_window.push_handlers(player2) game_window.push_handlers(game_board) game_window.push_handlers(end_turn_button) game_window.push_handlers(program_button) game_window.push_handlers(line_widget_1) game_window.push_handlers(line_widget_2) game_window.push_handlers(return_button) world.add_game_object(game_board) world.add_widget(blocker) world.add_widget(glow) world.add_widget(end_turn_button) world.add_widget(program_button) world.add_widget(terminal) world.add_widget(line_widget_1) world.add_widget(line_widget_2) world.add_widget(return_button) world.add_widget(world) world.add_widget(hand_board) world.add_widget(prog_board) world.add_game_object(player1) world.add_game_object(player2) world.add_label(label_player) world.add_label(player_name) world.add_label(label_hand_card) world.add_label(label_prog_card) world.add_label(label_lives) world.add_label(lives) world.add_label(label_mana) world.add_label(mana)