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)
