def load_tournament(self, tournament_json): tournament = Tournament( tournament_json['name'], tournament_json['description'], tournament_json['place'], tournament_json['start_date'], tournament_json['end_date'], tournament_json['number_of_rounds'], tournament_json['time_control']) for player_data in tournament_json['players']: tournament.players.append(Player(**player_data)) for round_ in tournament_json['rounds']: new_round = Round(tournament) new_round.start_time = datetime( round_['start']['y'], round_['start']['mo'], round_['start']['d'], round_['start']['h'], round_['start']['mi'], ) new_round.end_time = datetime( round_['end']['y'], round_['end']['mo'], round_['end']['d'], round_['end']['h'], round_['end']['mi'], ) new_round.end_confirmation = round_['end_confirmation'] for game_data in round_['games']: new_game = Game(Player(**game_data['player1']), Player(**game_data['player2'])) new_game.update_result(game_data['result']) new_round.games.append(new_game) tournament.rounds.append(new_round) return tournament
def test_prop_backup(): player1 = Player(250, 250, [50, 50]) assert player1.backpack == 0 player1.backpack = 2 assert player1.backpack == 2
def test_patch(mock_get_user, app): mock_get_user.return_value = { "id": "TEST", "profile": { "real_name": "ogek", "display_name": "Giuseppe" } } with app.app_context(): player = Player() player.slack_id = "TEST" db.session.add(player) db.session.flush() data = {'dishonors': 10} with app.test_client() as tc: rv = tc.patch('/api/players/{}/'.format(player.slack_id), data=json.dumps(data), follow_redirects=True) json_data = json.loads(rv.data) p = Player.query.get(player.slack_id) assert rv.status_code == 200 assert player.slack_id == p.slack_id assert p.dishonors == data['dishonors'] assert json_data['data']['dishonors'] == data['dishonors']
async def draw_player( draw: ImageDraw.Draw, composite: Image, player: Player, character: Image, rank: Image, y_offset: int, ) -> None: ready = is_ready if player.is_ready() else not_ready voice = voice_on if player.is_in_voice() else voice_off y_offset += PLAYER_ONE_START composite.paste(rank, (88, y_offset), rank) composite.paste(ready, (132, y_offset + 11), ready) composite.paste(voice, (155, y_offset + 5), voice) composite.paste(character, (183, y_offset)) try: profile = await player.get_avatar() composite.paste(profile.resize((19, 19)), (226, y_offset + 8)) except Exception: pass draw.text( (255, y_offset + 11), player.get_name(), font=name_font, fill=(81, 81, 81, 255), )
def initialization(): deck = Deck() deck.shuffle() player = Player() dealer = Player() start_game(deck, player, dealer)
def main(): cprint( ' ███▄ ▄███▓ ▒█████ ███▄ █ ██████ ▄▄▄█████▓▓█████ ██▀███ ██▓███ ██▓ ▄▄▄ ███▄ █ ▓█████▄▄▄█████▓ ', 'green') cprint( ' ▓██▒▀█▀ ██▒▒██▒ ██▒ ██ ▀█ █ ▒██ ▒ ▓ ██▒ ▓▒▓█ ▀ ▓██ ▒ ██▒ ▓██░ ██▒▓██▒ ▒████▄ ██ ▀█ █ ▓█ ▀▓ ██▒ ▓▒', 'green') cprint( ' ▓██ ▓██░▒██░ ██▒▓██ ▀█ ██▒░ ▓██▄ ▒ ▓██░ ▒░▒███ ▓██ ░▄█ ▒ ▓██░ ██▓▒▒██░ ▒██ ▀█▄ ▓██ ▀█ ██▒▒███ ▒ ▓██░ ▒░', 'green') cprint( ' ▒██ ▒██ ▒██ ██░▓██▒ ▐▌██▒ ▒ ██▒░ ▓██▓ ░ ▒▓█ ▄ ▒██▀▀█▄ ▒██▄█▓▒ ▒▒██░ ░██▄▄▄▄██ ▓██▒ ▐▌██▒▒▓█ ▄░ ▓██▓ ░ ', 'green') cprint( ' ▒██▒ ░██▒░ ████▓▒░▒██░ ▓██░▒██████▒▒ ▒██▒ ░ ░▒████▒░██▓ ▒██▒ ▒██▒ ░ ░░██████▒▓█ ▓██▒▒██░ ▓██░░▒████▒ ▒██▒ ░ ', 'green') cprint( ' ░ ▒░ ░ ░░ ▒░▒░▒░ ░ ▒░ ▒ ▒ ▒ ▒▓▒ ▒ ░ ▒ ░░ ░░ ▒░ ░░ ▒▓ ░▒▓░ ▒▓▒░ ░ ░░ ▒░▓ ░▒▒ ▓▒█░░ ▒░ ▒ ▒ ░░ ▒░ ░ ▒ ░░ ', 'green') cprint( ' ░ ░ ░ ░ ▒ ▒░ ░ ░░ ░ ▒░░ ░▒ ░ ░ ░ ░ ░ ░ ░▒ ░ ▒░ ░▒ ░ ░ ░ ▒ ░ ▒ ▒▒ ░░ ░░ ░ ▒░ ░ ░ ░ ░ ', 'green') cprint( ' ░ ░ ░ ░ ░ ▒ ░ ░ ░ ░ ░ ░ ░ ░ ░░ ░ ░░ ░ ░ ░ ▒ ░ ░ ░ ░ ░ ', 'green') cprint( ' ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ', 'green') print() player = Player(hp=30) map = Map() player.set_location(map.get_starting_location()) game = CommandInterpreter(player, map) game.run()
def setUp(self): team_1 = Team("Barcelona", 27) team_2 = Team("Real Madrid", 24) self.teams = [team_1, team_2] self.player_1 = Player("Hazard", "Real Madrid", "Forward", 12, 8, 0, 0) self.player_2 = Player("Rodrygo", "Real Madrid", "Forward", 4, 9, 0, 0)
def __init__(self): self.screen_width = self.DEFAULT_SCREEN_WIDTH self.screen_height = self.DEFAULT_SCREEN_HEIGHT # Needs to happen before objects are initted pygame.init() windowSize = (self.screen_width, self.screen_height) self.screen = pygame.display.set_mode(windowSize, pygame.DOUBLEBUF | pygame.OPENGL) # void gluPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar); gluPerspective(60, (windowSize[0] / windowSize[1]), 0.1, 100.0) # gluOrtho2D(60, (windowSize[0]/windowSize[1]), 0.1, 100.0) glTranslatef(0.0, 0.0, -5) self.cubeEdges = ((0, 1), (0, 3), (0, 4), (1, 2), (1, 7), (2, 5), (2, 3), (3, 6), (4, 6), (4, 7), (5, 6), (5, 7)) self.cubeVertices = ((1, 1, 1), (1, 1, -1), (1, -1, -1), (1, -1, 1), (-1, 1, 1), (-1, -1, -1), (-1, -1, 1), (-1, 1, -1)) # self.screen = pygame.display.set_mode((self.screen_width, self.screen_height)) self.player = Player(self.screen_width / 2, self.screen_height / 2) self.cursor = Cursor() self.running = True pygame.mouse.set_visible(False) self.event_listeners = { 'in_game_state': [self.player, self.cursor], 'menu': [self.cursor] } self.game_states = ['in_game_state', 'menu', 'options'] self.current_state = self.game_states[0]
def progress_next_rounds( self, tournament, players, serialized_rounds, nb_rounds, ): """Run the following rounds.""" while nb_rounds > 0: rounds = tournament.rounds round = self.get_next_round(tournament, rounds, players) serialized_round = Round.serialized(round) serialized_rounds.append(serialized_round) tournament.update_round(serialized_rounds) tournament.update_players(players) if nb_rounds > 1: command = self.update(players, tournament) if command == "main menu": return "main menu" players = sorted( sorted( players, key=lambda player: player.rank, ), key=lambda player: player.points, reverse=True, ) nb_rounds = 4 - len(rounds) for player in players: score = player.add_final_score(player.points, player.score) Player.update_score(player, score) View.display_final_score(tournament, players)
def get_player_by_gender_html(column, gender: Gender): players = [] if not column.table: return players for link in column.table.tbody.find_all('tr', recursive=False): elements = link.find_all("td", recursive=False) name = elements[1].text # flags = elements[2].text number = elements[3].text # played = elements[4].text single = elements[5].text double = elements[6].text mix = elements[7].text player = Player(name, gender, number, PlayerRanking(single, double, mix)) comp_id = re.search(r'aspx\?id=(.+?)((?=\&)|$)', elements[1].a.get('href')).group(1) player_comp_id = re.search(r'player=(\d+)', elements[1].a.get('href')).group(1) player.add_competition(comp_id, player_comp_id) players.append(player) return players
class TestPlayer(unittest.TestCase): def setUp(self): self.player_1 = Player("*****@*****.**", "password1", "John", "Smith", "Hopp Suisse") def test_player_has_email(self): self.assertEqual("*****@*****.**", self.player_1.email) def test_player_has_password(self): self.assertEqual("password1", self.player_1.password) def test_player_has_first_name(self): self.assertEqual("John", self.player_1.first_name) def test_player_has_last_name(self): self.assertEqual("Smith", self.player_1.last_name) def test_player_has_team_name(self): self.assertEqual("Hopp Suisse", self.player_1.team_name) def test_player_can_encode_jwt(self): auth_token = self.player_1.encode_jwt(1) self.assertTrue(isinstance(auth_token, str)) def test_player_can_decode_jwt(self): auth_token = self.player_1.encode_jwt(1) player_id = self.player_1.decode_jwt(auth_token) self.assertEqual(1, player_id)
def add_player(self): c = main.MainController() last_name = c.input_with_options('Last name : ') first_name = c.input_with_options('First name : ') date_regex = re.compile(r'^(0[1-9]|[1-2][0-9]|3[0-1])' r'/(0[1-9]|1[0-2])/[0-9]{4}$') birthday = c.input_with_options( 'Birthday (dd/mm/yyyy) : ', date_regex, 'Please enter a valid date format (dd/mm/yyyy)', loop=True) gender = c.input_with_options('gender (m/w) : ', re.compile(r'^[m|w]$'), 'Please enter m or w', loop=True) rank = c.input_with_options('Current rank : ', re.compile('^[0-9]+$'), 'Please enter en positive number', loop=True) player = Player(last_name, first_name, birthday, gender, rank) Player.add_player(player)
def read_player(self): """ Generates a table of players and allows to choose a day thanks to its TinyDB ID :return: ID choice """ cls() icon() self.list_all_players = list() for self.player_id in search_all_player(): self.player = Player() self.player.load_player(self.player_id) self.list_all_players.append(self.player) print('Rechercher un Joueur pour ce Tournoi\n') print(("=" * 177).center(width_calculated())) print(f'| {"ID du Joueur".center(25)} |' f'{"Nom du Joueur".center(35)} |' f'{"Prénom du Joueur".center(35)} |' f'{"Date de naissance du joueur".center(35)} |' f'{"Rang".center(35)} |'.center(width_calculated()) ) self.list_all_players = sorted(self.list_all_players, key=lambda player: player.name) for self.player in self.list_all_players: print(("-" * 177).center(width_calculated())) print(f'| {str(self.player.id).center(25)} |' f'{self.player.name.center(35)} |' f'{self.player.first_name.center(35)} |' f'{self.player.date_born.center(35)} |' f'{str(self.player.rank).center(35)} |'.center(width_calculated()) ) print(("-" * 177).center(width_calculated())) self.ID = str() while not re.match(r"^[0-9]+$", self.ID): self.ID = input('Taper l ID du Joueur : ') return self.ID
def post(self): name = self.request.get("name") email = self.request.get("email") phone = self.request.get("phone") if not name: self.redirect("http://vote.ouarfc.co.uk/admin/add_player?err=" + str(ERROR_NO_NAME)) return if not email: self.redirect("http://vote.ouarfc.co.uk/admin/add_player?err=" + str(ERROR_NO_EMAIL)) return if Player.query(Player.name == name).count() > 0: self.redirect("http://vote.ouarfc.co.uk/admin/add_player?err=" + str(ERROR_ALREADY_EXISTS)) return player = Player(name=name, email=email) if phone: # Remove special characters phone = re.sub('[\s+=\-.]','',phone) # Place UK area code at start phone = re.sub('^0','44', phone) if phone.isdigit(): player.phone = phone player.put() template = jinja_environment.get_template("templates/player_added.html") self.response.out.write(template.render({'name':name}))
def __init__(self): """ Create the main player menu stats """ cls() icon() self.list_all_player_id = search_all_player() self.list_players = [] for self.player_id in self.list_all_player_id: self.player = Player() self.player.load_player(int(self.player_id)) self.list_players.append(self.player) print("Menu des stats Joueur \n\n" "1. Voir la liste des Joueurs par ordre Alphabétique\n" "2. Voir la liste des Joueurs par ordre de Rang\n" "3. Retour\n") self.choice_menu = 0 while not 3 >= int(self.choice_menu) >= 1: self.choice_menu = input( "Faites votre choix un tapant le numéro de menu (ex. 1, 2, ne taper qu'un seul choix) : " ) if not self.choice_menu.isdigit(): self.choice_menu = 0 if int(self.choice_menu) == 1: self.show_players_sort(False) input() elif int(self.choice_menu) == 2: self.show_players_sort(True) input() elif int(self.choice_menu) == 3: pass
def playerConnected(self,protocol,playerID, roomID): ip, port = protocol.transport.socket.getpeername() if roomID != "RoomServer": # Normal player connection player = Player(protocol,playerID) player.playerID = playerID player.name = str(playerID) else: # Special case where a room server connected to the lobby player = Server(protocol,playerID) player.address = ip player.port = settings.PORT_ROOM_DEFAULT player.playerID = playerID player.name = ip player.roomID = roomID protocol.player = player self.players.append(player) # Add the player to the room if self.rooms.has_key(player.roomID) == False: print "Creating Room " + str(player.roomID) self.rooms[player.roomID] = Room(player.roomID) self.rooms[player.roomID].players.append(player) player.room = self.rooms[player.roomID] if self.messageHandler != None: self.messageHandler.playerConnected(player)
def test_board_place_building(): b = Board(2,2) players = [ Player(0, PlayerColour.RED), Player(1, PlayerColour.ORANGE), Player(2, PlayerColour.YELLOW) ] b.place_building(BuildingType.SETTLEMENT, players[0], 0, 0) b.place_building(BuildingType.SETTLEMENT, players[1], 0, 2) b.place_building(BuildingType.SETTLEMENT, players[2], 0, 4) b.place_building(BuildingType.SETTLEMENT, players[0], 1, 1) b.place_building(BuildingType.SETTLEMENT, players[1], 1, 3) b.place_building(BuildingType.SETTLEMENT, players[2], 2, 2) assert b.corners[0][0].owner.id == 0 assert b.corners[0][1].owner is None assert b.corners[0][2].owner.id == 1 assert b.corners[0][3].owner is None assert b.corners[0][4].owner.id == 2 assert b.corners[1][0].owner is None assert b.corners[1][1].owner.id == 0 assert b.corners[1][2].owner is None assert b.corners[1][3].owner.id == 1 assert b.corners[1][4].owner is None assert b.corners[2][0].owner is None assert b.corners[2][1].owner is None assert b.corners[2][2].owner.id is 2 assert b.corners[2][3].owner is None assert b.corners[2][4].owner is None
def tearDown(self): # clear player info for p_id in self.player_ids: p = Player(id=p_id).load() p.delete() # device link for d in DeviceLink.load_by_attribute("player_id", p_id): d.delete() # creature team ct = CreatureTeam(player_id=p_id).load() ct.delete() # creatures for c in CreatureInstance.load_by_attribute("player_id", p_id): c.delete() delete_data(CreatureInstance.cid_key_tpl % p_id) # session for s in Session.load_by_attribute("player_id", p_id): s.delete() # remove from latest login list active_players = latest_login_players.load() if p_id in active_players: active_players.remove(p_id) latest_login_players.store(active_players)
def get_create_player_table_sqls(self): sqls = [Player.get_create_model_sql('player_%s' % self.id)] # player索引建立 player_index = connection.creation.sql_indexes_for_model(Player, no_style()) sqls.extend( [pi_sql.replace(Player.get_table_name(), 'player_%s' % self.id).replace('ON ', 'ON %s.' % self.db_name) for pi_sql in player_index]) return sqls
def edit_rank(self, player: Player): c = main.MainController() ViewPlayer.rank(player) rank = c.input_with_options('', re.compile('^[0-9]+$'), 'Please enter en positive number', loop=True) player.set_rank(rank)
def update_info_to_store(self, user: Player): collection = self.db.collection(u'users') if (user.id): user_ref = collection.document(user.id) user_ref.update(user.to_dict()) else: collection.add(user.to_dict())
def get_player_by_device(self, device_id): device = DeviceLink(device_id=device_id).load() player_id = device.player_id if player_id: player = Player(id=player_id) player.load() return player return
def __init__(self): """ Initializing what instances of classes """ self.snake = Snake() self.view = GameView() self.apple = Apple() self.poison = Poison() self.player = Player() self.gameover = GameOverController() self.gamestart = GameStartController()
def init_player(self, msg): # TODO - verify with 3rd party? kwargs = {"is_new": True, "name": msg.name, self.player_index: self.get_pip_id(msg)} player = Player(**kwargs) player.store() log.info("Create player with basic info: %s" % str(kwargs)) return player
def show_latest_pairs(self) -> list: pairs = [] latest_round = list(self.rounds.keys())[-1] for item in self.rounds[latest_round]['matches']: pairs.append({ 'player_1': Player({'id': item[0][0]}).get_player_name(), 'player_2': Player({'id': item[1][0]}).get_player_name() }) return pairs
def main(): arena = Arena(surf=DISPLAY_SURF) player_1 = Player(name=settings.PLAYER_ONE, surf=DISPLAY_SURF, pos=get_player_default_pos(num=settings.PLAYER_ONE)) player_2 = Player(name=settings.PLAYER_TWO, surf=DISPLAY_SURF, pos=get_player_default_pos(num=settings.PLAYER_TWO)) ball = Ball(surf=DISPLAY_SURF, pos=get_ball_default_pos(), speed=settings.EASY) clock = Clock(surf=DISPLAY_SURF) clock.start() # Stack used to maintain render order game_objects = [ arena, player_1, player_2, ball, clock, ] # Main loop while True: # Events for event in pygame.event.get(): if event.type == pygame.QUIT: exit_game() elif event.type == pygame.MOUSEMOTION: player_1.move((0, event.pos[1] - player_1.y)) # Logic game_over = check_point_scored(ball) if game_over: SoundController.play_game_over() clock.stop() elapsed = clock.get_elapsed_seconds() show_game_over_screen(DISPLAY_SURF, FPS_CLOCK, elapsed) clock.reset() clock.start() ball.reset_velocity() ball.reposition(get_ball_default_pos()) handle_ball_movement(ball, player_1, player_2) handle_player_movement(player_2, ball) # Rendering render_game_objects(game_objects) pygame.display.update() FPS_CLOCK.tick(settings.FPS)
def setUp(self) -> None: self.playground_a = Playground(name='Ramot Sapir', address='Gotel Levin 1, Haifa, Israel', location=(32.783800, 35.004821), opening_hours=[('0800', '1400'), ('1600', '2200')]) self.playground_b = Playground(name='Gan Daniel', address='HaShikma 3, Haifa, Israel', location=(32.786935, 34.994653), opening_hours=[('0800', '2359')]) self.players = [Player('botzer', 'Amit Botzer', datetime.datetime(1992, 12, 13), 'Haifa'), Player('botzer92', 'Michael Botzer', datetime.datetime(1992, 12, 13), 'Haifa')]
def init_game(self, seed): """Inicializa um novo jogo e retorna seu estado.""" player_1 = Player(player_id=1, player_type=PlayerType.IMPULSIVE, balance=300) player_2 = Player(player_id=2, player_type=PlayerType.RIGOROUS, balance=300) player_3 = Player(player_id=3, player_type=PlayerType.CAUTIOUS, balance=300) player_4 = Player(player_id=4, player_type=PlayerType.RANDOM, balance=300) # retira random seed por hora # random.seed(seed) # atribui a ordem dos jogadores aleatoriamente players_list = [player_1, player_2, player_3, player_4] players_order = players_list.copy() random.shuffle(players_order) players_list.insert(0, None) # Posição -1 é o ponto de partida # após o começo do jogo essa posição deixa de existir # ao passar novamente na posição 0, o jogador ganha 100 board = [] board.append(Estate(price=50, rent=10, estate_id=0)) board.append(Estate(price=100, rent=20, estate_id=1)) board.append(Estate(price=150, rent=30, estate_id=2)) board.append(Estate(price=200, rent=40, estate_id=3)) board.append(Estate(price=250, rent=55, estate_id=4)) board.append(Estate(price=300, rent=60, estate_id=5)) board.append(Estate(price=50, rent=10, estate_id=6)) board.append(Estate(price=100, rent=20, estate_id=7)) board.append(Estate(price=150, rent=30, estate_id=8)) board.append(Estate(price=200, rent=40, estate_id=9)) board.append(Estate(price=250, rent=55, estate_id=10)) board.append(Estate(price=300, rent=60, estate_id=11)) board.append(Estate(price=50, rent=10, estate_id=12)) board.append(Estate(price=100, rent=20, estate_id=13)) board.append(Estate(price=150, rent=30, estate_id=14)) board.append(Estate(price=200, rent=40, estate_id=15)) board.append(Estate(price=250, rent=55, estate_id=16)) board.append(Estate(price=300, rent=60, estate_id=17)) board.append(Estate(price=50, rent=10, estate_id=18)) board.append(Estate(price=100, rent=20, estate_id=19)) self.players_list = players_list self.players_order = players_order self.board = board self.round_ = 0 return players_list, players_order, board
def initialize_info_from_store(self, user: Player): users_ref = self.db.collection(u'users').where( u'displayName', u'==', user.get_full_name().replace(',', '')) docs = users_ref.stream() for doc in docs: user.id = doc.id return
def create_multiple_player(self, player_info: dict): """Create player instance, add to players list Args: player_info (dict): player informations from user """ player_obj = Player() player_obj.add_player(player_info) self.players.append(player_obj)
def register(self, pseudo, password): if ((pseudo and not pseudo.isspace()) and (password and not password.isspace())): player = Player(pseudo, 0, password, 0) session.add(player) session.commit() # session.close() p = Player.getPlayer(player.pseudo) return p
def test_GameStateMarshallingWithEnoughPlayers_GameStartAction_StateIsNight(): state = Game() state.state = GameStates.MARSHALLING state.players = [Player(), Player(), Player(), Player()] systemUnderTest = getInstance(state) success = systemUnderTest.transition(Actions.START_GAME) assert state.state == GameStates.NIGHT assert success
def _handle_register(self, text): import hashlib self.logger.debug("Recieved register request.") # register|username|password|password_confirm usr = text.split("|")[1] pwd1 = text.split("|")[2] pwd2 = text.split("|")[3] if Player.where("name", usr).count() > 0: self.request.sendall("username_taken".encode("utf8")) self.request.close() return if pwd1 != pwd2: self.request.sendall("invalid_password".encode("utf8")) self.request.close() return player = Player() player.name = usr player.hashed_password = hashlib.sha224( pwd1.encode("utf8")).hexdigest() player.save() # Needed to get an ID in the DB player.guid = hashlib.sha224( (str(player.id) + player.name + player.hashed_password).encode("utf8")).hexdigest() if player.save(): self.request.sendall( f"register_success|{player.guid}".encode("utf8")) self.request.close() else: self.request.sendall("register_failed!".encode("utf8")) self.request.close()
def fill_player_list(raw_place=None, place=None): global player_list for i, raw_player in enumerate(raw_place.player_list): player = Player() player.name = raw_player.name player.username = raw_player.username player.is_female = raw_player.is_female player.district = place # initial items initial_items = [] if hasattr(raw_player, 'weapon_list'): for weapon_name in raw_player.weapon_list: reserved_item = [x for x in item_list if x.name == weapon_name] initial_items.append(reserved_item[0]) item_list.pop(item_list.index(reserved_item[0])) player.item_list = initial_items player_list.append(player) if config.general.match_type == MatchType.districts: if raw_player is not None and player.district != '': location = next(x for x in place_list if x.name == place.name) player.district = location # only to store p[3] location.tributes.append(player) # idem elif config.general.match_type == MatchType.standard: location = random.choice(place_list) player.location = location location.players.append(player)
def init_player(attr): p = Player.load_by_attribute("agc_id", attr.get("agc_id")) p = p and p[0] if not p: # create players if player not exist params = {"default_creatures": random_creatures(), "is_new": True} params.update(attr) p = Player(**params) p.store() update_latest_login_players(p.id)
def __init__(self, app_ref): super().__init__(app_ref) self.current_player_label = Label(self, '', 20) self.current_player_checker_label = Button(self, '') self.current_player_checker_label.config(state=tk.DISABLED, width=5) self.max_depth_label = Label(self, '', 12) self.board = Board(self) self.players: {PlayerType: Player} = { PlayerType.COMPUTER: Player(self, PlayerType.COMPUTER, self.board.blue_checkers), PlayerType.USER: Player(self, PlayerType.USER, self.board.orange_checkers) }
def find_or_create_player(name: str) -> Player: session = session_factory.create_session() player = session.query(Player).filter(Player.name == name).first() if player: session.close() return player player = Player() player.name = name session.add(player) session.commit() player = session.query(Player).filter(Player.name == name).first() return player
def get(self): game_id = int(self.request.get('game_id')) player_added_to_game = self.request.get('player_added_to_game') players_in_game = self.request.get('players_in_game') player_exists = False if player_added_to_game: game = get_game(game_id) if player_is_in_game(game, player_added_to_game): player_exists = player_added_to_game else: game.add_player(player_added_to_game) if players_in_game: players_in_game += ", " + player_added_to_game else: players_in_game = player_added_to_game players = Player.query().fetch() context = { 'players': players, 'game_id': game_id, 'players_in_game': players_in_game, 'player_exists': player_exists } template = JINJA_ENVIRONMENT.get_template('templates/choose_players.html') self.response.write(template.render(context))
def teardown_test(test): # clear player info for p_id in player_ids: p = Player(id=p_id) p.delete() # device link for d in DeviceLink.load_by_attribute("player_id", p_id): d.delete() # creature team ct = CreatureTeam(player_id=p_id) ct.delete() # creatures for c in CreatureInstance.load_by_attribute("player_id", p_id): c.delete() delete_data(CreatureInstance.cid_key_tpl % p_id)
def leave_game(self, player_name): player = Player.get_player(player_name) game_id = player.game_id game = Game.get_game(game_id) if game.remove_player(player_name): return self.redirect('/') else: return self.response.http_status_message(404)
def post(self): game_id = self.request.get("game") voter_id = self.request.get("player") voter = Player.get_by_id(int(voter_id)) game = Game.get_by_id(int(game_id)) value = base64.urlsafe_b64encode(os.urandom(16)) token = Token(value=value, voter=voter.key, game=game.key, used=False) token.put() url = "http://vote.ouarfc.co.uk/vote/" + value self.response.out.write(url)
def get(self): game = create_game() players = Player.query().fetch() context = { 'players': players, 'game_id': game.game_id } template = JINJA_ENVIRONMENT.get_template('templates/choose_players.html') self.response.write(template.render(context))
def playerConnected(self,protocol,playerID, roomID): # Normal player connection player = Player(protocol,playerID) player.playerID = playerID player.name = str(playerID) player.roomID = roomID protocol.player = player self.players.append(player) self.playerCount = self.playerCount + 1 # Add the player to the room if self.rooms.has_key(player.roomID) == False or self.rooms[player.roomID].open == False: if(player.roomID == None or player.roomID == "Create" or (self.rooms.has_key(player.roomID) and self.rooms[player.roomID].open == False)): # Let the server create a room player.roomID = str(uuid.uuid1()) self.rooms[player.roomID] = Room(player.roomID) print "Creating Generated Room " + str(player.roomID) else: print "Creating Room " + str(player.roomID) self.rooms[player.roomID] = Room(player.roomID) self.rooms[player.roomID].players.append(player) player.room = self.rooms[player.roomID] if self.messageHandler != None: self.messageHandler.playerConnected(player) if self.lobbyClientFactory != None: self.lobbyClientFactory.client.sendServerStatus(None)
def testGetProductsList(self): def _verify_products(products, p_settings): for p in products: p_s = p_settings.get(p.pid) self.assertEquals(p.quantity, p_s.get("quantity")) self.assertEquals(p.price, p_s.get("price")) self.assertEquals(p.currency, p_s.get("currency")) session_id, msg = self.create_player(os_type=OSType.Value("IOS")) req = ProductsReq() resp = self.post_message(req, ProductsResp, session_id=session_id) self.assertEquals(resp.result_code, GetProductsResultCode.Value("GET_PRODUCTS_SUCCESS")) iap = PURCHASE_ITEMS.get(OSType.Value("IOS")) _verify_products(resp.products, iap) # update player os_type to Android player = Player(id=msg.player_info.userId) player.load() player.os_type = OSType.Value("Android") player.store() resp = self.post_message(req, ProductsResp, session_id=session_id) self.assertEquals(resp.result_code, GetProductsResultCode.Value("GET_PRODUCTS_SUCCESS")) iab = PURCHASE_ITEMS.get(OSType.Value("Android")) _verify_products(resp.products, iab)
def get(self, player_id=None): if not player_id: template = jinja_environment.get_template("templates/player_list.html") players = Player.query().order(Player.name).fetch(1000) self.response.out.write(template.render({'players':players})) return errmsg = None if self.request.get("err") == str(ERROR_NO_NAME): errmsg = "You didn't supply a name" elif self.request.get("err") == str(ERROR_NO_EMAIL): errmsg = "You didn't supply an email" elif self.request.get("err") == str(ERROR_INVALID_PHONE): errmsg = "Invalid phone number" player = Player.get_by_id(int(player_id)) if not player: self.response.out.write("Error: invalid player ID") logging.error("Invalid player ID: " + str(player_id)) template = jinja_environment.get_template("templates/add_edit_player.html") self.response.out.write(template.render({'player':player, 'errmsg':errmsg}))
def GetHelper(self, msg): helper_conf = GameRule.helper_conf fb_friend_factor = helper_conf.get("facebook_friend_factor") favorite_factor = helper_conf.get("favorite_factor") friend_factor = helper_conf.get("friend_factor") helper_num = helper_conf.get("total_num") player_id = self.parent.pid friend = Friend(player_id=player_id) friends = set(friend.get_friend_list()) favorites = set(friend.get_favorite_list()) fb_friends = set(friend.get_facebook_list()) active_players = set(get_latest_login_players()) normal_p = active_players - friends - fb_friends - set([player_id]) favorites = favorites - fb_friends normal_f = friends - favorites - fb_friends # TODO - Design: filter normal_p players = (list(fb_friends) * fb_friend_factor + list(favorites) * favorite_factor + list(normal_f) * friend_factor + list(normal_p)) _players = set(players) if len(_players) <= helper_num: helper_ids = _players else: helper_ids = set() while len(helper_ids) < helper_num: _ids = random.sample(players, helper_num - len(helper_ids)) helper_ids.update(_ids) rep = GetHelperRep() helpers = [] for pid in helper_ids: h = Helper() player = Player(id=pid).load() player.set_info(h.player_info, simple_mode=True) h.creature.CopyFrom(player.get_help_creature().to_proto_class()) helpers.append(h) rep.helpers.extend(helpers) rep.result_code = GetHelperResultCode.Value("GET_HELPER_SUCCESS") return self.resp(rep)
def remove_player(self, player_name): if player_name not in self.players: return False self.players.remove(player_name) self.num_players -= 1 self.ready -= 1 player = Player.get_player(player_name) player.clear_game() self.put() memcache.set(self.game_index, self) return True
def post(self): token_string = self.request.get("token") token = Token.query(Token.value == token_string).get() if not token: template = jinja_environment.get_template("templates/error.html") self.response.out.write(template.render({'errmsg': "invalid voting token"})) return if token.used: template = jinja_environment.get_template("templates/error.html") self.response.out.write(template.render({'errmsg': "You've already voted!"})) return game = token.game voter = token.voter three = self.request.get("three") two = self.request.get("two") one = self.request.get("one") if one in [two, three] or two == three: return self.redirect("/vote/" + token.value + "?err=" + str(ERROR_DUPLICATE_VOTE)) if str(voter.id()) in [one, two, three]: return self.redirect("/vote/" + token.value + "?err=" + str(ERROR_VOTE_FOR_SELF)) three_player = Player.get_by_id(int(three)) two_player = Player.get_by_id(int(two)) one_player = Player.get_by_id(int(one)) vote = Vote(game=game, three=three_player.key, two=two_player.key, one=one_player.key) token.used = True vote.put() token.put() template = jinja_environment.get_template('templates/success.html') self.response.out.write(template.render({}))
def testLinkAccount(self): device_id = "test_link_account_device" session_id, msg = self.create_player(device_id=device_id) player_id = msg.player_info.userId player = Player(id=player_id).load() l_acc = LinkAccount() for sign_type, handler in LinkAccountActor.link_acc_map.iteritems(): attr_name = handler.player_index self.assertIsNone(getattr(player, attr_name)) # Try link from an device not exist pip_id1 = "123" l_acc.type = sign_type l_acc.pip_id = pip_id1 l_acc.device_id = "link_account_not_exist_one" msg = self.post_message(l_acc, LinkAccountRep, session_id=session_id) self.assertEquals(msg.result_code, LinkAccountResultCode.Value("LINK_ACC_OTHER")) player.load() self.assertIsNone(getattr(player, attr_name)) # link l_acc.device_id = device_id msg = self.post_message(l_acc, LinkAccountRep, session_id=session_id) self.assertEquals(msg.result_code, LinkAccountResultCode.Value("LINK_ACC_OTHER")) player.load() self.assertEquals(str(getattr(player, attr_name)), pip_id1) # try link another pip_id2 = "1234" l_acc.pip_id = pip_id2 msg = self.post_message(l_acc, LinkAccountRep, session_id=session_id) self.assertEquals(msg.result_code, LinkAccountResultCode.Value( "LINK_ACC_DIFFERENT_PIP")) player.load() self.assertEquals(str(getattr(player, attr_name)), pip_id1) # unsupported sign type for sign_type in set(SignType.values()) - \ set(LinkAccountActor.link_acc_map.keys()): l_acc.type = sign_type msg = self.post_message(l_acc, LinkAccountRep, session_id=session_id) self.assertEquals(msg.result_code, LinkAccountResultCode.Value("LINK_ACC_OTHER"))
def give_reward(self, user_id, product_info): qt = product_info.get("quantity") player = Player(id=user_id) if player.exist(): player.load() player.gems += qt player.store() log.info("%s purchase - add %s gems to player(%s)" % (self.os_type, qt, user_id)) return True
def add_player(self, player_name): if self.num_players < constants.MAX_PLAYERS: if self.num_players == 0: players = [] else: players = self.players self.num_players += 1 players.append(player_name) player = Player.get_player(player_name) if not player.add_game(self.game_index): return False self.players = players self.put() memcache.set(self.game_index, self) return True else: return False
def pay(self, speed_turns): pay_data = {'drops':[]} player = Player(id=self.player_id).load() passed_dungeons = PassedDungeons(player_id=self.player_id).load() if not passed_dungeons.slugs: passed_dungeons.slugs = [] if self.dungeon_slug not in passed_dungeons.slugs: passed_dungeons.slugs.append(self.dungeon_slug) passed_dungeons.store() self.eggs.extend(self._dungeon_eggs) coins = self.coins gems = 0 self.calc_speed_eggs(speed_turns) for egg in self.eggs: egg = simplejson.loads(egg) if egg['type'] == GameRule.FAERIE_EGG or egg['type'] == GameRule.SELF_EGG: c_data = egg['creature'] c = CreatureInstance(player_id=self.player_id).create(c_data['slug'], level=c_data.get('level', 1), xp=c_data.get('xp', 0), plusHP=c_data.get('plusHP', 0), plusAttack=c_data.get('plusAttack', 0), plusSpeed=c_data.get('plusSpeed', 0), plusLuck=c_data.get('plusLuck', 0), ) c.store() pay_data['drops'].append({'type': egg['type'], 'slug': c_data['slug']}) elif egg['type'] == GameRule.MATERIAL_EGG: m = egg.get('material') setattr(player, m, getattr(player, m) + 1) pay_data['drops'].append({'type': egg['type'], 'slug': m}) elif egg['type'] == GameRule.COIN_EGG: coins += egg.get('coins') elif egg['type'] == GameRule.GEM_EGG: gems += egg.get('gems') player.set_progress(self.progress) player.add_xp(self.xp) player.coins += coins player.gems += gems pay_data['xp'] = self.xp pay_data['coins'] = self.coins pay_data['gems'] = gems player.store() return pay_data, player
def get(self, game_id=None): if not game_id: template = jinja_environment.get_template("templates/email_list.html") games = Game.query().order(Game.date).fetch(100) self.response.out.write(template.render({'games':games})) return game = Game.get_by_id(int(game_id)) if not game: self.response.out.write("Error: invalid game ID") logging.error("Invalid game ID: " + str(game_id)) return players = Player.query().order(Player.name).fetch(100) playing = [p for p in players if p.key in game.players] not_playing = [p for p in players if p.key not in game.players] template = jinja_environment.get_template("templates/send_emails.html") args = {'playing':playing,'not_playing':not_playing,'game':game} self.response.out.write(template.render(args))
def post(self): player_id = self.request.get("player_id") player = Player.get_by_id(int(player_id)) if not player: self.response.out.write("Error: invalid player ID") logging.error("Invalid player ID: " + str(player_id)) name = self.request.get("name") email = self.request.get("email") phone = self.request.get("phone") if not name: self.redirect( "http://vote.ouarfc.co.uk/admin/edit_player/" + str(player_id) + "?err=" + str(ERROR_NO_NAME)) return if not email: self.redirect( "http://vote.ouarfc.co.uk/admin/edit_player/" + str(player_id) + "?err=" + str(ERROR_NO_EMAIL)) return if phone: # Remove special characters phone = re.sub('[\s+=\-.]','',phone) # Place UK area code at start phone = re.sub('^0','44', phone) if phone.isdigit(): player.phone = phone else: self.redirect( "http://vote.ouarfc.co.uk/admin/edit_player/" + str(player_id) + "?err=" + str(ERROR_INVALID_PHONE)) return else: player.phone = None player.name = name player.email = email player.put() template = jinja_environment.get_template("templates/player_saved.html") self.response.out.write(template.render({'name':name}))
def scrape_field(field_url, tournament): r = requests.get(field_url) soup = BeautifulSoup(r.text) field_table = soup.find('div', class_='field-table') non_alts = field_table.find_all('div', class_='field-table-content')[0] # players = field_table.find_all('div', class_='even') # players += field_table.find_all('div', class_='odd') names = [] for player in non_alts.find_all('p'): names.append(player.text) for name in names: snames = name.split(', ') if len(snames) == 2: lname, fname = name.split(', ') elif len(snames) == 3: lname = name.split(', ')[0:1] fname = name.split(', ')[2] pl = Player.objects(first_name=fname,last_name=lname) if len(pl) > 0: tournament.update(add_to_set__field=pl[0]) tournament.save()
def get(self): game_id = int(self.request.get('game_id')) game = get_game(game_id) max_payment = float(self.request.get('max_payment') or game.max_payment) point_value = float(self.request.get('point_value') or game.point_value) game.edit_game(max_payment, point_value) players = Player.query().fetch() context = { 'game_id': game_id, 'players': players, 'players_in_game': self.request.get('players_in_game'), } template = JINJA_ENVIRONMENT.get_template('templates/choose_players.html') self.response.write(template.render(context)) #self.redirect(webapp2.uri_for('choose_players'))
def generate_proto(self, player_id): player = Player(id=player_id).load() return player.to_proto_class(simple_mode=True)
def get_list(self): if not ENABLE_FACEBOOK: return [] # TODO - use real data, mock up for test now. return Player.load_oids_by_attribute("facebook_id", FB_SAMPLE_ID)
def post(self): player_id = self.request.get("player") game_id = self.request.get("game") player = Player.get_by_id(int(player_id)) game = Game.get_by_id(int(game_id)) token = Token.query(ndb.AND(Token.game == game.key, Token.voter == player.key)).get() if not token: logging.info("No token found for %s. Creating new token.", player.name) token_string = base64.urlsafe_b64encode(os.urandom(16)) token = Token(value=token_string, voter=player.key, game=game.key, used=False) token.put() else: logging.info("Token found for %s.", player.name) if token.used: logging.info("%s has already voted, not sending email.", player.name) return url = "http://vote.ouarfc.co.uk/vote/" + token.value if player.phone: logging.info("Sending SMS to %s", player.name) template = jinja_environment.get_template("templates/sms.txt") sms_data = { "ORIGINATOR": "OUARFC", "NUMBERS": player.phone, "BODY": template.render({"url": url, "opponent": game.opponent, "team": Team.getString(game.team)}), } response = urlfetch.fetch( "https://api.zensend.io/v3/sendsms", payload=urllib.urlencode(sms_data), method=urlfetch.POST, headers={"X-API-KEY": config.zensend_key}, ) content_type = response.headers["content-type"] if content_type is not None and "application/json" in content_type: result = json.loads(response.content) if "success" in result: logging.info("Successfully sent SMS to " + player.phone) if config.phone_only: # SMS was a success, don't send email return elif "failure" in result: failure = result["failure"] logging.error( "SMS send failed. Player: %s, phone: %s, parameter: %s, error code: %s, status code: %s", player.name, player.phone, failure["parameter"], failure["failcode"], response.status_code, ) else: logging.error("SMS send failed. Status code: %s", response.status_code) else: logging.error("SMS send failed. Status code: %s", response.status_code) template = jinja_environment.get_template("templates/email.txt") subject = "OUARFC: Please Vote For Best & Fairest" message = mail.EmailMessage(sender="OUARFC <*****@*****.**>", subject=subject) message.to = player.email message.body = template.render( { "name": player.name, "opponent": game.opponent, "date": game.date, "team": Team.getString(game.team), "url": url, } ) logging.info("Sending email to " + player.email) message.send() logging.info(message.body)
def generate_proto(self, player_id): friend = FriendInfo() player = Player(id=player_id).load() player.set_info(friend.player_info, simple_mode=True) friend.is_favorite = player_id in self.get_favorite_list() return friend