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
