def __init__(self):
super().__init__()
self._board = Board()
self._game_state = "UNFINISHED"
self._players = (Player("b"), Player("w"))
self._active = 0
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 __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 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 __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 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 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 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 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 __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 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 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
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_free(self):
script = """
SELECT p.player_id, p.first_name, p.last_name
FROM players p
WHERE club_id is NULL"""
with self.get_cursor() as cur:
cur.execute(script)
db_players = cur.fetchall()
res = [
Player(first_name=p['first_name'],
last_name=p['last_name'],
id=p['player_id']) for p in db_players
]
res.reverse()
return res
def get_player(self, player_id: int) -> Player:
script = """
SELECT * FROM players
WHERE player_id = %s"""
with self.get_cursor() as cur:
cur.execute(script, [player_id])
db_player = cur.fetchone()
return Player(id=db_player['player_id'],
first_name=db_player['first_name'],
last_name=db_player['last_name'],
date_of_birth=db_player['date_of_birth'],
is_injured=db_player['is_injured'],
height=db_player['height'],
club_id=db_player['club_id'],
position_id=db_player['position_id'])
def test_update_wrong_fortnite(self):
"""
Test the route PUT /api/players/:id/clash_royale to add stats from Fortnite with wrong username
"""
new_player = Player(email="*****@*****.**",
username="******",
firstname="john",
lastname="doe")
self.db.session.add(new_player)
self.db.session.commit()
payload = json.dumps({
"username": "******",
})
response = self.app.put('/api/players/1/fortnite',
headers={"Content-Type": "application/json"},
data=payload)
response_json = response.get_json()
player = Player.query.filter_by(id=1).first()
self.assertEqual(404, response.status_code)
self.assertEqual(None, player.username_game2)
def test_update_clash_royale(self):
"""
Test the route PUT /api/players/:id/clash_royale to add stats from Clash Royale
"""
new_player = Player(email="*****@*****.**",
username="******",
firstname="john",
lastname="doe")
self.db.session.add(new_player)
self.db.session.commit()
payload = json.dumps({
"game_id": "GYUQQCLV",
})
response = self.app.put('/api/players/1/clash_royale',
headers={"Content-Type": "application/json"},
data=payload)
response_json = response.get_json()
player = Player.query.filter_by(id=1).first()
self.assertEqual(200, response.status_code)
self.assertTrue('info' in response_json and 'matches' in response_json)
self.assertEqual('GYUQQCLV', player.id_game1)
def test_update(self):
"""
Test the route PUT /api/players/:id to update a player
"""
new_player = Player(email="*****@*****.**",
username="******",
firstname="john",
lastname="doe")
self.db.session.add(new_player)
self.db.session.commit()
payload = json.dumps({
"email": "*****@*****.**",
"username": "******",
"firstname": "john",
"lastname": "doe"
})
response = self.app.put('/api/players/1',
headers={"Content-Type": "application/json"},
data=payload)
player = Player.query.filter_by(id=1).first()
self.assertEqual(200, response.status_code)
self.assertEqual("*****@*****.**", player.email)
def register():
try:
data = request.get_json()
player = Player.objects(nickname=data.get('nickname')).first()
if player:
return make_response({
'status': 'fail',
'message': 'Nickname already taken'
}), 202
# Create new player
nickname = data.get('nickname')
hash_password = generate_password_hash(data.get('password'), 10)
Player(nickname=nickname, password=hash_password).save()
return make_response({
'status': 'success',
'message': 'Player created'
}), 201
except Exception as e:
print(e)
return make_response({
'status': 'fail',
'message': 'Something went wrong!'
}), 500
async def printMatches(playersInGame, gameIds, client):
for i in range(0, len(playersInGame)):
if (i >= len(playersInGame)):
break
currGameId = gameIds[i]
currPlayers = []
currPlayers.append(playersInGame[i])
j = i + 1
while j < len(playersInGame):
if currGameId == gameIds[j]:
currPlayers.append(playersInGame[j])
del gameIds[j]
del playersInGame[j]
j = j - 1
j = j + 1
matchRes = await Api.getMatchInfo(currGameId)
if matchRes.status != 200:
return
matchResData = await matchRes.json()
serverAndMap = matchResData.get('voting')
server = ''
mapName = ''
if type(serverAndMap) is list:
server = serverAndMap[0].get('location').get('name')
mapName = serverAndMap[0].get('map').get('name')
else:
server = serverAndMap.get('location').get('pick')[0]
mapName = serverAndMap.get('map').get('pick')[0]
factionOne = matchResData.get('teams').get('faction1')
factionTwo = matchResData.get('teams').get('faction2')
factionOneList = factionOne.get('roster_v1')
factionTwoList = factionTwo.get('roster_v1')
if factionOneList == None:
factionOneList = factionOne.get('roster')
factionTwoList = factionTwo.get('roster')
currentTime = time.strftime('%B %d, %I:%M %p',
time.localtime(time.time()))
print(currentTime + '::: ' + mapName + ' at ' + server)
factionOneMembers = []
factionTwoMembers = []
isFactionOne = False
# Made two separate for loops just incase it is a match with uneven teams (for whatever reason)
for i in range(0, len(factionOneList)):
player = Player()
player.nickname = factionOneList[i].get('nickname')
player.party_id = factionOneList[i].get('active_team_id')
factionOneMembers.append(player)
if player.nickname == playersInGame[0]:
isFactionOne = True
for i in range(0, len(factionTwoList)):
player = Player()
player.nickname = factionTwoList[i].get('nickname')
player.party_id = factionTwoList[i].get('active_team_id')
factionTwoMembers.append(player)
matchData = {
'matchId':
matchResData.get('match_id'),
'matchUrl':
matchResData.get('faceit_url')[0:23] + "en/" +
matchResData.get('faceit_url')[30:],
'server':
server,
'mapName':
mapName,
'start':
matchResData.get('started_at'),
'end':
matchResData.get('finished_at'),
'winner':
matchResData.get('results').get('winner'),
'factionOneName':
factionOne.get('name'),
'factionTwoName':
factionTwo.get('name'),
'factionOne':
factionOneMembers,
'factionTwo':
factionTwoMembers,
'isFactionOne':
isFactionOne
}
match = Match()
match.__dict__.update(matchData)
global addToDatabase
addToDatabase.append(match)
embed = await createMatchEmbed(match, currPlayers)
outcome = '**' + currPlayers[0] + '**'
for i in range(1, len(currPlayers)):
outcome += ', **' + currPlayers[i] + '**'
# if embed == green, add ' won!' , else add ' lost :('
if (match.winner == 'faction1'
and match.isFactionOne) or (match.winner == 'faction2'
and not match.isFactionOne):
outcome += ' won their match!'
else:
outcome += ' lost their match :('
message = await client.send_message(discord.Object(id=CHANNEL_ID_1),
outcome)
await client.edit_message(message=message, embed=embed)
if CHANNEL_ID_2 != 'null':
message = await client.send_message(
discord.Object(id=CHANNEL_ID_2), outcome)
await client.edit_message(message=message, embed=embed)
# Update the rightBound of match searches.
# - 120 because the search happens every 2 minutes.
global rightBound
rightBound = int(time.time()) - 120
def get(self):
Utils.reset(self) # reset/clean standard variables
# validate and assign parameters
passwd = Utils.required(self, 'passwd')
uuid = self.request.get('uuid')
guid = self.request.get('guid')
fbid = self.request.get('fbid')
self.game = self.request.get('game') or ''
version = config.data_version['building']
token = self.request.get('token') or ''
lang = self.request.get('lang') or config.server["defaultLanguage"]
name = self.request.get('name') or ''
image = 'Textures/profile-pic.png'
if fbid != '':
image = 'https://graph.facebook.com/' + fbid + '/picture?width=200&height=200'
# TODO : Get defaults from Data
gold = 10
cash = 50000
total_wins = 0
total_races = 0
advice_checklist = ''
player = None
# defaultitems = None
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
Utils.LogRequest(self)
# if error, skip this
if self.error == '':
if fbid != '':
player = Player.getplayerByFbid(self, fbid)
if player is None and uuid != '':
player = Player.getplayer(self,
uuid) # get player from Player model
# class helper, specified by uuid
# TODO : Only get defaultItems if needed, ie a new player
defaultitems = Data.getDataAsObj(
self, 'defaultitems', config.data_version['defaultitems'])
if defaultitems is not None:
if player is None: # if no player data
# returned or doesn't exist
################################################################################################
## Create new player data
player = Player(parent=db.Key.from_path(
'Player', config.db['playerdb_name'])
) # create a new player state data
uuid = Utils.genanyid(self, 'u')
#if fbid == '':
# fbid = uuid
player.uuid = uuid # assign uuid
player.fbid = fbid
# and assign all player info and state
player.info_obj = {
'uuid': player.uuid,
'fbid': player.fbid,
'token': token,
'name': 'Guest ' + str(random.randint(1000, 9999)),
'image': image,
'lang': lang
}
player.state_obj = {
'guid': guid,
'cash': cash,
'gold': gold,
'current_car': 'xxx',
'total_wins': total_wins,
'total_races': total_races,
'advice_checklist': advice_checklist,
'updated': start_time
}
logging.debug("New Player Created")
#################################################################################################
## Init default item for new player
buildings = Data.getbuildings(self, lang, float(version))
cars = Data.getcars(self, lang, float(version))
upgrades = Data.getupgrades(self, lang, float(version))
if buildings is not None and cars is not None and upgrades is not None:
logging.debug("building default stuff")
for item in defaultitems.obj:
if item['type'] == 'state':
player.state_obj[item['id']] = item['value']
elif item['type'] == 'building':
try:
building = buildings.as_obj[item['id']][0]
if building is not None:
new_building = Building.newbuilding(
self)
new_building.uuid = player.uuid
new_building.itid = item['id']
new_building.inid = Utils.genanyid(
self, 'b')
new_building.level = building['level']
new_building.status = Building.BuildingStatus.DELIVERED
new_building.location = item['value']
new_building.amount = 0
new_building.timestamp = int(
start_time)
Building.setmybuilding(
self, new_building)
except KeyError:
logging.warning('KeyError, key not found!')
elif item['type'] == 'car' and cars is not None:
type = ''
car = None
for _car in cars.as_obj:
if _car['id'] == item['id']:
car = _car
break
mycar = Car.create(self, player.uuid)
mycar.data_obj['info'] = {'crid': car['id']}
mycar.data_obj['upgrades'] = []
mycar.data_obj['equip'] = {}
player.state_obj['current_car'] = mycar.cuid
default_upgrades = car[
'default_upgrades'].replace(' ',
'').split(',')
for default_upgrade in default_upgrades:
mycar.data_obj['upgrades'].append(
default_upgrade)
for _type in upgrades.as_obj:
try:
mycar.data_obj['equip'][type]
except KeyError:
for upgrade in upgrades.as_obj[
_type]:
if upgrade[
'id'] == default_upgrade:
mycar.data_obj['equip'][
_type] = default_upgrade
break
break
Car.update(self, mycar)
else:
logging.warning("cant build default stuff")
else: # but if player does exist
#####################################################################################################################
## Found existing user
uuid = player.uuid
if token: # if token is provided from
# apple
player.state_obj[
'token'] = token # assign token to player state
if fbid != '':
player.fbid = fbid
player.info_obj['fbid'] = fbid
player.info_obj['image'] = image # assign image url
if name != '':
player.info_obj['name'] = name # assign name
try:
updated = player.state_obj['updated']
except KeyError:
player.state_obj['updated'] = start_time
if self.request.get('lang'):
player.info_obj['lang'] = lang
# Additional things that have been added and neeed checking for old players
# TODO : Remove try catch, or see performance impact in Python
try:
if guid:
player.state_obj['guid'] = guid
except KeyError:
player.state_obj['guid'] = ''
# try .. cash and assign new property
try:
cash = player.state_obj['cash']
except KeyError:
player.state_obj['cash'] = cash
try:
total_wins = player.state_obj['total_wins']
except KeyError:
player.state_obj['total_wins'] = total_wins
try:
advice_checklist = player.state_obj['advice_checklist']
except KeyError:
player.state_obj['advice_checklist'] = advice_checklist
if Player.setplayer(self, player):
# then obviously, no error
# compose JSON for frontend response
type = ''
for item in config.playerdata:
type += item + ','
type = type.rstrip(',')
self.respn = '{"uuid":"' + uuid + '",'
types = type.split(',')
for item in types:
if item == 'info':
self.respn += '"info":' + player.info + ','
elif item == 'state':
self.respn += '"state":' + player.state + ','
elif item == 'building':
buildings = Data.getbuildings(self, lang, version)
mybuildings = Building.getmybuildings(self, uuid)
if buildings is not None and mybuildings is not None:
self.respn += '"building":['
# loop through my buildings to find out which need their pending status updating
for new_building in mybuildings:
# update building status, determine production
_upd = False
if new_building.status == Building.BuildingStatus.PENDING:
if new_building.timestamp + (
buildings.as_obj[
new_building.itid][
new_building.level - 1]
['build_time'] * 60) <= start_time:
new_building.timestamp = int(
start_time)
new_building.status = Building.BuildingStatus.DELIVERED
_upd = True
elif new_building.status == Building.BuildingStatus.DELIVERED:
new_building.status = Building.BuildingStatus.OWNED
_upd = True
if _upd is True:
Building.setmybuilding(
self, new_building)
self.respn = Building.compose_mybuilding(
self.respn, new_building)
self.respn = self.respn.rstrip(',') + '],'
elif item == 'car':
mycars = Car.list(self, player.uuid)
self.respn += '"car":['
for _car in mycars:
self.respn += Car.compose_mycar('', _car) + ','
self.respn = self.respn.rstrip(',') + '],'
elif item == 'challenge':
Challenge.ComposeChallenges(self, player)
self.respn = self.respn.rstrip(',') + '}'
###################################################################################################
## Add to recent player list
recentplayerlist = Data.GetRecentPlayerList(self)
_add = True
# check if this user hasn't reached the maximum set challengers
# we don't add players to the recent list if they are stacked
num = 0
challengers = Challenge.GetChallengers(
self, player.info_obj['uuid'])
if challengers is None:
Challenge.GetChallengers(self, player.info_obj['fbid'])
if challengers is not None:
for challenger in challengers:
obj = json.loads(challenger.data)
if obj['friend'] is False:
num += 1
if num > config.recentplayer['maxchallengers']:
logging.warn(
'Recent player list exceeded for ' +
uuid)
_add = False
break
# find if it already exists?
num = 0
_deletelist = []
for recentplayer in recentplayerlist.obj:
if recentplayer['uuid'] == player.info_obj['uuid']:
if _add is False: # this player reach the maximum of challengers
_deletelist.append(
num
) # we should delete him from the list, so nobody can challenge him
else:
_add = False
# if the list is longer than maxlist, delete the rest
if num >= config.recentplayer['maxlist']:
_deletelist.append(num)
# remove if player does not exist any more
else:
someplayer = Player.getplayer(
self, recentplayer['uuid'])
if someplayer is None:
self.error = ''
_deletelist.append(num)
num += 1
num = len(_deletelist)
for i in range(0, num):
del recentplayerlist.obj[num - 1 - i]
if _add is True:
recentplayerlist.obj.append({
'fbid':
player.info_obj['fbid'],
'name':
player.info_obj['name'],
'uuid':
player.info_obj['uuid'],
'image':
player.info_obj['image'],
'total_wins':
player.state_obj['total_wins'],
'updated':
player.state_obj['updated']
})
Data.SetRecentPlayerList(self, recentplayerlist)
else: # but if write down to database was failed
self.error = 'unable to insert/update player data.' # inform user bia error message
logging.warn('unable to insert/update player data.')
# 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))
async def stats(client, message):
nickname = message.content[7:]
playerRes = await Api.getPlayer(nickname)
# No permission to post or user does not exist.
if playerRes.status != 200:
await client.send_message(
message.channel, 'No such player found. (stats is case sensitive)')
return
playerResData = await playerRes.json()
playerData = {
'player_id':
playerResData.get('player_id'),
'nickname':
playerResData.get('nickname'),
'avatar':
playerResData.get('avatar'),
'faceit_url':
playerResData.get('faceit_url')[0:23] + "en/" +
playerResData.get('faceit_url')[30:],
}
if 'csgo' not in playerResData.get('games'):
await client.send_message(
message.channel,
playerData['nickname'] + ' has no stats for CSGO.')
return
playerData.update({
'skill_level':
playerResData.get('games').get('csgo').get('skill_level'),
'faceit_elo':
playerResData.get('games').get('csgo').get('faceit_elo'),
})
playerStatsRes = await Api.getPlayerStats(playerData['player_id'])
if playerStatsRes.status != 200:
await client.send_message(
message.channel,
playerData['nickname'] + ' has no stats for CSGO.')
return
playerStatsResData = await playerStatsRes.json()
playerData.update({
'headshotPercentage':
playerStatsResData.get('lifetime').get('Average Headshots %'),
'matches':
playerStatsResData.get('lifetime').get('Matches'),
'winRate':
playerStatsResData.get('lifetime').get('Win Rate %'),
'kdRatio':
playerStatsResData.get('lifetime').get('Average K/D Ratio'),
})
player = Player()
player.__dict__.update(playerData)
embed = await createStatsEmbed(player)
await client.send_message(message.channel, embed=embed)
def __init__(self):
self.board = Board()
self.player1 = Player('y')
self.player2 = Player('x')
def __init__(self):
self.objects, self.locations = Parser().initilise_game_info()
self.player = Player(list(self.locations.values())[0])
self.handler = Handler()
from models.Player import Player
from models.Round import Round
from models.Rules import *
players = [Player("A"), Player("B"), Player("C")]
rules = [rule_cards_suit, rule_ace_card, rule_eight_card, rule_three_card]
newRound = Round(players, rules)
newRound.start()
while not newRound.is_round_over:
for p in players:
print(p.name + ":")
p.show_hand()
print(newRound)
p = input('player to play: ')
if p == 'q':
break
card = input('choose card index to play: ')
if card == 'd':
newRound.draw(players[int(p)])
else:
newRound.play(players[int(p)], players[int(p)].hand_cards[int(card)])
