def upsert_player(self, player_id: int, player: Player) -> None:
with session_scope(self.get_session) as session:
if player_id:
player.id = player_id
player.update(session)
else:
player.add(session)
def __init__(self):
super().__init__()
self._board = Board()
self._game_state = "UNFINISHED"
self._players = (Player("b"), Player("w"))
self._active = 0
def get(self):
Utils.reset(self) # reset/clean standard variables
name = self.request.get('name')
if name == '':
name = 'Guest?'
name2 = self.request.get('name2')
if name2 == '':
name2 = 'Guest??'
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
track = Utils.required(self, 'track')
toid = Utils.required(self, 'toid')
image = self.request.get('image')
image2 = self.request.get('image2')
friend = False
if self.request.get('friend'):
friend = bool(self.request.get('friend'))
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
Utils.LogRequest(self)
# logic variables
player = None
# if error, skip this
if self.error == '':
player = Player.getplayer(self, uuid)
if self.error == '' and player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
if self.error == '' and player is not None:
logging.warn('creating new challenge with' + player.uuid)
challenge = Challenge.Create(self, track, player.uuid, toid, name,
name2, image, image2, friend)
if challenge is not None:
self.respn = '{'
Challenge.ComposeActualChallenge(self, challenge)
self.respn = self.respn.rstrip(',') + '}'
# update timestamp for player
player.state_obj['updated'] = start_time
Player.setplayer(self, player)
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
chid = self.request.get('chid')
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# logic variables
player = None
# if error, skip this
if self.error == '':
player = Player.getplayer(self, uuid)
if self.error == '' and player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
result = None
if self.error == '' and player is not None:
if chid:
if Challenge.DeleteById(self, chid):
result = '"result":"deleted successfully"'
else:
result = '"result":"Challenge Id=' + chid + ' could not be found, nothing was deleted"}'
else:
if Challenge.DeleteByUserId(self, player.uuid):
result = '"result":"deleted successfully"'
elif Challenge.DeleteByUserId(self, player.fbid):
result = '"result":"deleted successfully"'
else:
result = '"result":"nothing was deleted"'
if self.error == '' and player is not None:
self.respn = '{'
Challenge.ComposeChallenges(self, player)
self.respn += ',' + result
self.respn = self.respn.rstrip(',') + '}'
# update timestamp for player
player.state_obj['updated'] = start_time
Player.setplayer(self, player)
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def __init__(self, screen, squareSize=30, mapSize=20, drawerParams={}):
self.screen = screen
self.players = [
Player(Objects.Player2, 0, 0),
Player(Objects.Player1, mapSize - 1, mapSize - 1)
]
self.map = MapModel(mapSize, self.players[0], self.players[1])
self.players[0].setMap(self.map)
self.players[1].setMap(self.map)
self.drawer = MapDrawer(self.map, screen, squareSize, mapSize,
**drawerParams)
def fight(self, opponent_nick_name):
"""
Allows a player to fight
Args:
opponent_nick_name (str): Nick name of the opponent character
"""
state = get_state()
character = state['character']
if not character:
print "You have not assumed a character yet!"
print "Run - "
print "python zestwar.py -- --help"
return
character_name = get_character_name(character)
place = state['place']
if not place:
print "You have to explore a place to start fighting!"
print "Run - "
print "python zestwar.py -- --help"
return
place_name = get_place_name(place)
if opponent_nick_name == character:
print "You cannot fight against yourself!"
return
if not character_exists_at_place(place, opponent_nick_name):
print "The character '{0}' does not exist at '{1}' to fight".format(
opponent_nick_name, place_name)
print "Explore {0} again!".format(place)
return
# instantiate place
place = Place(place, place_name, get_characters)
# instantiate character
character = Character(character, character_name,
get_weightage(character))
player = Player(character, place)
opponent_name = get_character_name(opponent_nick_name)
opponent_character = Character(opponent_nick_name, opponent_name,
get_weightage(opponent_nick_name))
opponent = Player(opponent_character, place)
experience = player.fight(opponent)
save_experience(experience)
print "Congrats! You gained {0} experience points.".format(experience)
print "Your total experience is now at {0} points".format(
get_total_experience())
def on_ok(self):
player = Player(height=self.wgHeight.value,
is_injured=bool(self.wgIsInjured.value[0]),
first_name=self.wgFirstName.value,
last_name=self.wgLastName.value,
date_of_birth=self.wgDateOfBirth.value)
if isinstance(self.wgClub.value[0], int):
player.club_id = self.wgClub.values[self.wgClub.value[0]][1]
if isinstance(self.wgPosition.value[0], int):
player.position_id = self.wgPosition.values[self.wgPosition.value[0]][1]
self.parentApp.database.upsert_player(self.player_id, player)
self.parentApp.switchFormPrevious()
def __init__(self):
# centrowanie okna
os.environ['SDL_VIDEO_CENTERED'] = '1'
pygame.init()
pygame.display.set_caption('Bomberman')
# ustawienia ekranu i gry
self.screen = pygame.display.set_mode(gm.SIZESCREEN)
self.clock = pygame.time.Clock()
self.player = Player(gm.STAND_R)
self.current_level = Level1(self.player)
self.player.level = self.current_level
self.player.rect.center = [96, 96]
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
version = config.data_version['building']
if self.request.get('version'):
version = self.request.get('version')
lang = config.server["defaultLanguage"]
if self.request.get('lang'):
lang = self.request.get('lang')
checklist = self.request.get('checklist')
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# logic variables
player = None
# if error, skip this
if self.error == '':
player = Player.getplayer(self, uuid)
if self.error == '' and player is not None and guid != '':
logging.info(guid + '==' + player.state_obj['guid'])
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
if self.error == '' and player is not None:
if checklist:
player.state_obj['advice_checklist'] = checklist
# update timestamp for player
player.state_obj['updated'] = start_time
Player.setplayer(self, player)
self.respn = '{"advice_checklist_saved":"true"}'
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def __init__(self):
print("Welcome to AWALE !\n")
self.board = [4] * 12
self.round = 0
# test if player 1 is machine
if confirm("Is player 1 a human ?"):
self.playerA = Player()
else:
self.playerA = AIPlayer(self.board, 0)
# test if player 2 machine
if confirm("Is player 2 a human ?", "N"):
self.playerB = Player()
else:
self.playerB = AIPlayer(self.board, 1)
def main(self):
numberOfSnakes = input("Enter number of snakes: ")
numberOfSnakes = int(numberOfSnakes)
for i in range(numberOfSnakes):
start = input("Enter start position of snake " + str(i + 1) +
" : ")
end = input("Enter end position of snake " + str(i + 1) + " : ")
self.snakes.append(Snake(int(start), int(end)))
numberOfLadders = int(input("Enter number of ladders: "))
for i in range(numberOfLadders):
start = input("Enter start position of ladder " + str(i + 1) +
" : ")
end = input("Enter end position of ladder " + str(i + 1) + " : ")
self.ladders.append(Ladder(int(start), int(end)))
numberOfPlayers = int(input("Enter number of players: "))
for i in range(numberOfPlayers):
name = input("Enter name of player " + str(i + 1) + " : ")
self.players.append(Player(name))
snakeAndLadderService = SnakeAndLadderService(100)
snakeAndLadderService.setPlayers(self.players)
snakeAndLadderService.setSnakes(self.snakes)
snakeAndLadderService.setLadders(self.ladders)
snakeAndLadderService.startGame()
def login():
try:
data = request.get_json()
player = Player.objects(nickname=data.get('nickname')).first()
if not player:
return make_response({
'status': 'fail',
'message': 'Player does not exist'
}), 404
if not check_password_hash(player.password, data.get('password')):
return make_response({
'status': 'fail',
'message': 'Invalid password or nickname'
}), 404
token = create_access_token(identity=player.nickname)
return make_response({
'status': 'success',
'message': 'Successfully logged in',
'token': token
}), 200
return 'test'
except Exception as e:
print(e)
return make_response({
'status': 'fail',
'message': 'Something went wrong!'
}), 500
def advanced_player_search(self, min_height: int, max_height: int,
min_number: int, max_number: int,
position_id: int) -> list:
script = """
SELECT p.first_name, p.last_name, p.height, c.name as club , c.number_of_trophies, pos.name as position
FROM players p
JOIN clubs c
ON p.club_id = c.club_id
JOIN positions pos
ON p.position_id = pos.position_id
WHERE (p.height BETWEEN %s AND %s)
AND (c.number_of_trophies BETWEEN %s AND %s)
AND p.position_id = %s;"""
with self.get_cursor() as cur:
try:
cur.execute(script, [
min_height, max_height, min_number, max_number, position_id
])
except Exception as e:
print(e)
return []
rows = cur.fetchall()
res = [(Club(name=r['club'],
number_of_trophies=r['number_of_trophies']),
Player(first_name=r['first_name'],
last_name=r['last_name'],
height=r['height']), Position(name=r['position']))
for r in rows]
res.reverse()
return res
def getPlayers(page_data):
json_data = json.loads(page_data)
players = json_data['gameData']['players']
playerObjects = []
for id in players:
player = Player.query.filter_by(player_id=players[id]['id']).first()
if player is not None:
new_player = player
else:
params = {
'player_id':
players[id]['id'],
'first_name':
players[id]['firstName'],
'last_name':
players[id]['lastName'],
'birth_date':
datetime.strptime(players[id]['birthDate'], '%Y-%m-%d'),
'current_age':
players[id]['currentAge']
if 'currentAge' in players[id].keys() else None,
'birth_city':
players[id]['birthCity'],
'birth_state_province':
players[id]['birthStateProvince']
if 'birthStateProvince' in players[id].keys() else None,
'birth_country':
players[id]['birthCountry'],
'height':
players[id]['height'],
'weight':
players[id]['weight'],
'active':
players[id]['active'],
'alternate_captain':
players[id]['alternateCaptain']
if 'alternateCaptain' in players[id].keys() else False,
'captain':
players[id]['captain']
if 'captain' in players[id].keys() else False,
'rookie':
players[id]['rookie']
if 'rookie' in players[id].keys() else False,
'shoots_catches':
players[id]['shootsCatches']
if 'shootsCatches' in players[id].keys() else None,
'roster_status':
players[id]['rosterStatus'],
'current_team_id':
players[id]['currentTeam']['id']
if 'currentTeam' in players[id].keys() else -1,
'primary_position':
players[id]['primaryPosition']['code']
}
new_player = Player(params)
db.session.add(new_player)
db.session.commit()
def createUser(nickname):
usernames.append(nickname)
max_id = 0
if players:
max_id = max(player.player_id for player in players) + 1
pl = Player(nickname, max_id)
players.append(pl)
return pl
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
chid = Utils.required(self, 'chid')
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
Utils.LogRequest(self)
# logic variables
player = None
# if error, skip this
if self.error == '':
player = Player.getplayer(self, uuid)
if self.error == '' and player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
if self.error == '' and player is not None:
challenge = Challenge.GetChallenge(self, chid)
if challenge is not None:
if player.fbid == challenge.uid1 or player.fbid == challenge.uid2 or player.uuid == challenge.uid1 or player.uuid == challenge.uid2:
self.respn = '{'
Challenge.ComposeActualChallenge(self, challenge)
self.respn = self.respn.rstrip(',') + '}'
else:
self.error = 'You don\'t have permission to access data of this challenge.'
# update timestamp for player
player.state_obj['updated'] = start_time
Player.setplayer(self, player)
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken,False))
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, GCVars.passwd)
guid = self.request.get('guid')
uuid = Utils.required(self, 'uuid')
key = Utils.required(self, 'key')
val = Utils.required(self, 'val')
Utils.LogRequest(self)
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# if error, skip this
if self.error != '' or self.error is None:
player = Player.getplayer(self, uuid)
if player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
if player is not None:
data = {}
if player.state_obj.has_key('data'):
data = json.loads(player.state_obj['data'])
data.setdefault(key, val)
player.state_obj.setdefault('data', json.dumps(data))
Player.setplayer(self, player)
self.respn = '{"state":' + player.state + '}'
else:
self.error = 'Cant find a player for ' + uuid
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def generate_random_players(self, players_count: int) -> None:
fake = Faker()
with session_scope(self.get_session) as session:
for i in range(players_count):
Player(first_name=fake.first_name_male(), last_name=fake.last_name_male(),
date_of_birth=fake.date_of_birth(tzinfo=None, minimum_age=17, maximum_age=35),
is_injured=random() > 0.5, height=math.ceil(random() * 39 + 160),
position_id=math.ceil(random() * 3 + 1), club_id=session.query(Club.id).order_by(func.random())
.first()).add(session)
async def mau(websocket, path):
# register(websocket) sends user_event() to websocket
await register(websocket)
try:
async for message in websocket:
data = json.loads(message)
if data["action"] == "create_room":
player = Player(data["name"], websocket)
room = Room(player)
ROOMS.append(room)
await notify_users_about_rooms()
elif data["action"] == "join_room":
player_name = data["player_name"]
player = Player(player_name, websocket)
LONELY_USERS.remove(player.websocket)
room = get_room_by_name(data["room_name"])
await room.add_player(player)
await notify_users_about_rooms()
elif data["action"] == "start_game":
room = get_room_by_name(data["room_name"])
await room.start_round()
elif data["action"] == "put_card":
player_name = data["player_name"]
card = data["card"]
room = get_room_by_name(data["room_name"])
player = room.get_player_by_name(player_name)
card = Card(card["number"], get_enum_from_suit_type(card["type"]))
await room.round.play(player, card)
elif data["action"] == "take_card":
player_name = data["player_name"]
room = get_room_by_name(data["room_name"])
player = room.get_player_by_name(player_name)
await room.round.draw(player)
else:
logging.error("unsupported event: {}", data)
finally:
logging.info("unregistered");
await unregister(websocket)
def get_players(self) -> list:
with self.get_cursor() as cur:
cur.execute('SELECT player_id, first_name, last_name FROM players')
db_players = cur.fetchall()
res = [
Player(id=p['player_id'],
first_name=p['first_name'],
last_name=p['last_name']) for p in db_players
]
res.reverse()
return res
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
if self.error == '' and passwd != config.testing['passwd']: # if password is incorrect
self.error = 'passwd is incorrect.' # inform user via error message
start_time = time.time() # start count
player = None
recentplayerlist = None
# if error, skip this
if self.error == '':
player = Player.getplayer(self, uuid) # get player state from Player helper class, specified by uuid
if self.error == '' and player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
if self.error == '' and player is not None: # if have some data returned
recentplayerlist = Data.GetRecentPlayerList(self)
if self.error == '' and recentplayerlist is not None:
_range = config.recentplayer['maxlist']
if _range > len(recentplayerlist.obj):
_range = len(recentplayerlist.obj)
self.respn = '['
if _range > 0:
_size = config.recentplayer['numlist'];
if _range < _size:
_size = _range
random = Utils.GetRandomOfNumberInArray(self, _size, _range)
for i in random:
recentplayer = recentplayerlist.obj[i]
if recentplayer['uuid'] != player.uuid:
self.respn += '{"fbid":"'+recentplayer['fbid']+'",'
self.respn += '"uuid":"'+recentplayer['uuid']+'",'
self.respn += '"name":"'+recentplayer['name']+'",'
self.respn += '"image":"'+recentplayer['image']+'",'
self.respn += '"total_wins":'+str(recentplayer['total_wins'])+','
self.respn += '"updated":'+str(recentplayer['updated'])+'},'
self.respn = self.respn.rstrip(',') + ']'
# calculate time taken and return result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def upsert_club(self, club_id: int, club: Club, free_players: list):
with session_scope(self.get_session) as session:
if club_id:
club.id = club_id
club.update(session)
else:
club.add(session)
session.refresh(club)
club_id = club.id
for player_id in free_players:
player = Player.get(session, player_id)
player.club_id = club_id
def get(self):
Utils.reset(self)
uuid = Utils.required(self, 'uuid')
version = config.data_version['building']
if self.request.get('version'):
version = self.request.get('version')
lang = config.server["defaultLanguage"]
if self.request.get('lang'):
lang = self.request.get('lang')
track = 'track.1'
if self.request.get('track'):
lang = self.request.get('track')
score = 0
if self.request.get('score'):
lang = self.request.get('score')
uuid = self.request.get('uuid')
start_time = time.time()
# find the right track in buildings and add the score total to it for collection
player = Player.getplayer(self, uuid)
# get all buildings types
buildings = Data.getbuildings(self, lang, version)
# get player buildings
mybuildings = Building.getmybuildings(self, uuid)
#find the building with the track id and give it cash
if buildings is not None and mybuildings is not None:
self.respn += '"building":['
for mybuilding in mybuildings:
_upd = False
# for example: "itid": "track.1",
if mybuilding.itid == track:
mybuilding.amount += score
Building.setmybuilding(self, mybuilding)
self.respn = Building.compose_mybuilding(
self.respn, mybuilding)
self.respn = self.respn.rstrip(',') + '],'
if self.error == '':
self.respn = '{"state":' + player.state + ', "building":['
self.respn = Building.compose_mybuilding(self.respn, mybuilding)
self.respn = self.respn.rstrip(',') + ']'
self.respn += '}'
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
# check password
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# logic variables
player = None
# if error, skip this
if self.error == '':
player = Player.getplayer(self, uuid)
if self.error == '' and player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
if self.error == '' and player is not None:
self.respn = '{'
Challenge.ComposeChallenges(self, player)
self.respn = self.respn.rstrip(',') + '}'
# update timestamp for player
player.state_obj['updated'] = start_time
Player.setplayer(self, player)
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def load_data_into_models(data):
categories = []
for item in data['category_data']:
c = Category(**item)
categories.append(c)
players = []
for player in data['player_data']:
p = Player(**player)
players.append(p)
populated_models = {'players': players, 'categories': categories}
return populated_models
def test_get_all(self):
"""
Test the route GET /api/players
"""
new_player = Player(email="*****@*****.**",
username="******",
firstname="john",
lastname="doe")
self.db.session.add(new_player)
self.db.session.commit()
response = self.app.get('/api/players')
self.assertEqual(200, response.status_code)
self.assertEqual(1, len(response.get_json()))
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
uuid = Utils.required(self, 'uuid')
guid = self.request.get('guid')
token = Utils.required(self, 'token')
# required password to process this action
if self.error == '' and passwd != config.testing['passwd']:
self.error = 'passwd is incorrect.'
start_time = time.time() # start count
# if any error, skip this
if self.error == '':
player = Player.getplayer(self, uuid) # get player as object
if self.error == '' and player is not None and guid != '':
if guid != player.state_obj['guid']:
player = None
self.error = config.error_message['dup_login']
# if any error on player is none
if self.error == '' and player is not None:
player.info_obj['token'] = token
# update timestamp for player
player.state_obj['updated'] = start_time
if Player.setplayer(self, player):
Player.compose_player_info(self, player)
else:
self.error = 'unable to update player data (token).'
# calculate time taken and return the result
time_taken = time.time() - start_time
self.response.headers['Content-Type'] = 'text/html'
self.response.write(Utils.RESTreturn(self, time_taken))
def test_get_by_id(self):
"""
Test the route GET /api/players/:id
"""
new_player = Player(email="*****@*****.**",
username="******",
firstname="john",
lastname="doe")
self.db.session.add(new_player)
self.db.session.commit()
response = self.app.get('/api/players/1')
player = response.get_json()
self.assertEqual(200, response.status_code)
self.assertEqual("jojo", player['username'])
def test_delete(self):
"""
Test the route DELETE /api/players/:id
"""
new_player = Player(email="*****@*****.**",
username="******",
firstname="john",
lastname="doe")
self.db.session.add(new_player)
self.db.session.commit()
response = self.app.delete('/api/players/1')
players = Player.query.all()
self.assertEqual(200, response.status_code)
self.assertEqual(0, len(players))
def get_players_by_club(self, club_id) -> list:
script = """
SELECT p.first_name, p.last_name
FROM players AS p
WHERE p.club_id = %s"""
with self.get_cursor() as cur:
cur.execute(script, [club_id])
db_players = cur.fetchall()
res = [
Player(first_name=p['first_name'], last_name=p['last_name'])
for p in db_players
]
res.reverse()
return res
#! /usr/bin/python
import sys
import os
_root_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
sys.path.insert(0, _root_dir)
from models.Player import Player
if (len(sys.argv) < 3):
print "Usage:" + sys.argv[0] + " first_name last_name"
sys.exit()
player = Player(sys.argv[1], sys.argv[2])
player.save()
