async def join_chan(user: Player, p: bytes) -> None:
name = (reader.handle_packet(p, (('chan', osuTypes.string),)))['chan']
if name == '#spectator':
if user.spectating is not None:
uid = user.spectating.id
elif user.spectators:
uid = user.id
else:
return # not spectating
chan = glob.channels.get(f'#spec_{uid}')
elif name == '#multiplayer':
if not user.match:
return
m = user.match.id
chan = glob.channels.get(f'#multi_{m}')
elif name == '#clan':
if not user.clan:
return
chan = user.clan.chan
else:
chan = glob.channels.get(name)
if not chan:
return
user.join_chan(chan)
def initialize_match(self):
from modules.matches import Matches
self.season = Matches.get_season_by_id(self.raw_match['seasonId'])
self.queue = Matches.get_queue_by_id(self.raw_match['queueId'])
participant_identities = self.raw_match['participantIdentities']
for pid in participant_identities:
try:
player = Player(pid['player']['summonerName'])
player.participant_id = pid['participantId']
self.players.append(player)
except HTTPError as err:
if err.response.status_code == 429:
print('We should retry in {} seconds.')
print(
'this retry-after is handled by default by the RiotWatcher library'
)
print(
'future requests wait until the retry-after time passes'
)
elif err.response.status_code == 404:
print('Failed to fetch summoner!')
else:
raise
def new(self):
self.score = 0
self.player = Player(0, (screenHeight / 2 - 60), 60, 60)
self.font = pg.font.SysFont('helvetica', 30, True)
self.bullets = [] # container for our bullet
self.packages = []
self.shark = Enemy(screenWidth - 100, (screenHeight / 2 - 60), 60, 40,
800)
self.shark2 = Enemy(screenWidth - 200, (screenHeight / 3 - 60), 60, 40,
800)
self.shark3 = Enemy(screenWidth - 300, (screenHeight / 5 - 60), 60, 40,
800)
self.shark4 = Enemy(screenWidth - 200, (400 - 60), 60, 40, 800)
self.shark5 = Enemy(screenWidth - 300, (500 - 60), 60, 40, 800)
self.inkLoop = 0
self.music = pg.mixer.music.load('music.mp3')
pg.mixer.music.play(-1)
self.ink = pg.mixer.Sound('inkshoot.wav')
self.hurt = pg.mixer.Sound('hurt.wav')
self.pickup = pg.mixer.Sound('pickup.wav')
self.whirlpool = pg.mixer.Sound('whirlpool.wav')
## randomize squid coord:
self.squidSize = 60
self.sX = random.randint(0, screenWidth - self.squidSize)
self.sY = random.randint(0, screenHeight - self.squidSize)
self.squid = Neighbor(
self.sX, self.sY, 40, 60,
600) # randomize the squid velocity & position, up & down motion
# run has to be last on the list
self.run()
async def handle(self, p: Player) -> None:
unrestrcted_ids = [p.id for p in glob.players.unrestricted]
is_online = lambda o: o in unrestrcted_ids and o != p.id
for online in filter(is_online, self.user_ids):
if t := glob.players.get(id=online):
p.enqueue(packets.userStats(t))
def get(self):
check_admin(self)
games=Game.all().run()
for g in games:
g.delete()
days=[26,27,28,28,29,30]
for i in range(1,6):
g=Game(round=i,date=date(2012,12,days[i]))
g.put()
us=Utilities.all().run()
for u in us:
u.delete()
u=Utilities()
u.current_round=1
u.next_game=Game.all().filter('round =',1).get()
u.put()
teams=Team.all().run()
for t in teams:
t.delete()
games=PlayerGame.all().run()
for g in games:
g.delete()
self.response.out.write('done')
player=Player(first_name="any",surname="player",active=False)
player.put()
async def switch_server(p: Player, c: Messageable, msg: Sequence[str]) -> str:
"""Switch servers to a specified ip address."""
if len(msg) != 1:
return 'Invalid syntax: !switch <endpoint>'
p.enqueue(packets.switchTournamentServer(msg[0]))
return 'Have a nice journey..'
class Game:
def __init__(self, width, height):
pygame.init()
pygame.display.set_caption('Pykémon')
self.window_width = width
self.window_height = height
self.win = pygame.display.set_mode(
(self.window_width, self.window_height))
self.player = Player(self.window_width / 2, self.window_height / 2,
self.win)
self.pokeballs = []
self.background = Background(self.window_width, self.window_height,
self.win)
self.pokemon = ''
self.run = True
def mainLoop(self):
clock = pygame.time.Clock()
while self.run:
pygame.time.delay(40) # Clock
for event in pygame.event.get():
if event.type == pygame.QUIT: # Check if X-Button has been clicked
self.run = False
checkKeyPresses(self)
self.win.fill((101, 67, 20))
self.handlePokeballs() # POKEBALLS
self.background.draw() # BACKGROUND
self.player.draw() # PLAYER
self.handlePokemon() # POKEMON
pygame.display.update()
def redrawGameWindow(self):
self.win.fill((0, 0, 0))
def handlePokeballs(self):
for pokeball in self.pokeballs:
ball_outside_window = pokeball.checkBoundaries(
self.window_width, self.window_height)
if ball_outside_window:
self.pokeballs.pop(0)
print('BALLS on screen: %i' % len(self.pokeballs))
else:
pokeball.draw()
pokeball.move(10)
def handlePokemon(self):
if (self.pokemon != ''):
self.pokemon.draw()
def moveBackground(self):
self.background.move(15, self.player.direction)
def __init__(self, conf: Config, screen: pg.Surface):
self.conf = conf
self.screen = screen
self.player = Player(conf)
self.blocks = list()
self.score = Score(conf)
self.clock = pg.time.Clock()
async def handle(self, p: Player) -> None:
c = glob.channels[self.name]
if not c or not await p.join_channel(c):
log(f'{p} failed to join {self.name}.', Ansi.YELLOW)
return
# enqueue channelJoin to our player.
p.enqueue(packets.channelJoin(c.name))
def logout(p: Player, pr: PacketReader) -> None:
pr.ignore(4) # osu client sends \x00\x00\x00\x00 every time lol
if (time() - p.login_time) < 2:
# osu! has a weird tendency to log out immediately when
# it logs in, then reconnects? not sure why..?
return
p.logout()
printlog(f'{p} logged out.', Ansi.LIGHT_YELLOW)
async def handle(self, p: Player) -> None:
# XXX: this only sends when the client can see > 256 players,
# so this probably won't have much use for private servers.
# NOTE: i'm not exactly sure how bancho implements this and whether
# i'm supposed to filter the users presences to send back with the
# player's presence filter; i can add it in the future perhaps.
for t in glob.players:
if p is not t:
p.enqueue(packets.userPresence(t))
async def handle(self, p: Player) -> None:
if (time.time() - p.login_time) < 1:
# osu! has a weird tendency to log out immediately when
# it logs in, then reconnects? not sure why..?
return
p.logout()
await p.update_latest_activity()
log(f'{p} logged out.', Ansi.LYELLOW)
async def channelJoin(p: Player, pr: BanchoPacketReader) -> None:
chan_name, = await pr.read(osuTypes.string)
c = glob.channels[chan_name]
if not c or not await p.join_channel(c):
plog(f'{p} failed to join {chan_name}.', Ansi.YELLOW)
return
# Enqueue channelJoin to our player.
p.enqueue(await packets.channelJoin(c.name))
async def statsRequest(p: Player, pr: BanchoPacketReader) -> None:
if len(pr.data) < 6:
return
userIDs = await pr.read(osuTypes.i32_list)
is_online = lambda o: o in glob.players.ids and o != p.id
for online in filter(is_online, userIDs):
if t := await glob.players.get_by_id(online):
p.enqueue(await packets.userStats(t))
def statsRequest(p: Player, pr: PacketReader) -> None:
if len(pr.data) < 6:
return
userIDs = pr.read(osuTypes.i32_list)
is_online = lambda o: o in glob.players.ids and o != p.id
for online in filter(is_online, userIDs):
target = glob.players.get_by_id(online)
p.enqueue(packets.userStats(target))
async def ping(p: Player, pr: BanchoPacketReader) -> None:
# TODO: this should be last packet time, not just
# ping.. this handler shouldn't even exist lol
p.ping_time = int(time.time())
# osu! seems to error when i send nothing back,
# so perhaps the official bancho implementation
# expects something like a stats update.. i'm
# just gonna ping it back, as i don't really
# want to something more expensive so often lol
p.enqueue(b'\x04\x00\x00\x00\x00\x00\x00')
def enable_bot_and_player(_game):
player = Player(settings.PLAYER_SKINS[0], 175, 100, 290, "Player")
bot = Bot(settings.BOT_SKINS[0], 75, 200, 300, 290, "Bot")
obs_player = Observer(player, [wall])
obs_bot = Observer(bot, [wall])
player.obs = obs_player
bot.set_target(wall)
bot.obs = obs_bot
_game.player = player
_game.add_object(bot)
async def handle(self, p: Player) -> None:
if not 0 <= self.match_id < 64:
if self.match_id >= 64:
# NOTE: this function is unrelated to mp.
await check_menu_option(p, self.match_id)
p.enqueue(packets.matchJoinFail())
return
if not (m := glob.matches[self.match_id]):
log(f'{p} tried to join a non-existant mp lobby?')
p.enqueue(packets.matchJoinFail())
return
async def channelJoin(p: Player, pr: PacketReader) -> None:
chan_name, = await pr.read(osuTypes.string)
c = glob.channels.get(chan_name)
if not c or not await p.join_channel(c):
await plog(f'{p} failed to join {chan_name}.', Ansi.YELLOW)
return
# Enqueue new channelinfo (playercount) to a ll players.
#glob.players.enqueue(await packets.channelInfo(*c.basic_info))
# Enqueue channelJoin to our player.
p.enqueue(await packets.channelJoin(c.name))
async def handle(self, p: Player) -> None:
c = glob.channels[self.name]
if not c:
log(f'{p} failed to leave {self.name}.', Ansi.LYELLOW)
return
if p not in c:
# user not in chan
return
# leave the chan server-side.
p.leave_channel(c)
async def create_match(user: Player, p: bytes) -> None:
match = (reader.handle_packet(p, (('match', osuTypes.match),)))['match']
glob.matches[match.id] = match
if not glob.matches.get(match.id):
return user.enqueue(writer.matchJoinFail())
mp_chan = Channel(name='#multiplayer', desc=f'Multiplayer channel for match ID {match.id}', auto=False, perm=False)
glob.channels[f'#multi_{match.id}'] = mp_chan
match.chat = mp_chan
user.join_match(match, match.pw)
log(f'{user.name} created a new multiplayer lobby.', Ansi.LBLUE)
def __init__(self):
self.scroll = 0
self.player = Player(WIN_WIDTH / 2, 360)
self.items = [Chest(WIN_WIDTH / 2 + 540, 310, 'images/case.png', "Сейф 1", 320 // 4, 240 // 3),
Picture(WIN_WIDTH / 2 - 150, 240, 'images/picture.png', "Картина", 320 // 4, 240 // 3),
Books(WIN_WIDTH / 2 + 200, 300, 'images/books.png', "Книги",320 // 2, 240 // 2),
Jail(WIN_WIDTH / 2 + 750, 269, 'images/jail.png', "Заключенный", 320, 240),
Table(WIN_WIDTH / 2 - 300, 300, 'images/table.png', "Стол", 320 // 2, 240 // 2)]
self.dialog = Dialog("- Добро пожаловать в мир твоих самых страшных кошмаров, жалкий офисный червяк.")
self.left = self.right = self.up = self.down = False
async def handle(self, p: Player) -> None:
# TODO: match validation..?
if p.silenced:
p.enqueue(packets.matchJoinFail() + packets.notification(
'Multiplayer is not available while silenced.'))
return
if not glob.matches.append(self.match):
# failed to create match (match slots full).
p.send('Failed to create match (no slots available).',
sender=glob.bot)
p.enqueue(packets.matchJoinFail())
return
# create the channel and add it
# to the global channel list as
# an instanced channel.
chan = Channel(name=f'#multi_{self.match.id}',
topic=f"MID {self.match.id}'s multiplayer channel.",
auto_join=False,
instance=True)
glob.channels.append(chan)
self.match.chat = chan
await p.update_latest_activity()
p.join_match(self.match, self.match.passwd)
log(f'{p} created a new multiplayer match.')
async def run_server(addr: Address) -> None:
glob.version = Version(2, 8, 5)
glob.http = aiohttp.ClientSession(json_serialize=orjson.dumps)
loop = asyncio.get_event_loop()
try:
loop.add_signal_handler(signal.SIGINT, loop.stop)
loop.add_signal_handler(signal.SIGTERM, loop.stop)
except NotImplementedError:
pass
glob.db = AsyncSQLPoolWrapper()
await glob.db.connect(**glob.config.mysql)
# create our bot & append it to the global player list.
glob.bot = Player(id=1, name='Aika', priv=Privileges.Normal)
glob.bot.last_recv_time = 0x7fffffff
glob.players.add(glob.bot)
# add all channels from db.
async for chan in glob.db.iterall('SELECT * FROM channels'):
await glob.channels.add(Channel(**chan))
# run background process to
# disconnect inactive clients.
loop.create_task(disconnect_inactive())
async with AsyncTCPServer(addr) as glob.serv:
log(f'Gulag v{glob.version} online!', AnsiRGB(0x00ff7f))
async for conn in glob.serv.listen(glob.config.max_conns):
loop.create_task(handle_conn(conn))
def on_resize(self, width, height):
self.width = width
self.height = height
# reinitialize score with current values:
current_score = self.hud.score.value
current_kill_count = self.hud.kill_count.killed
self.hud = HUD(self.width, self.height,
self.levels[self.current_level]['enemy_amount'],
(255, 69, 0, 255))
self.hud.score.update_score(current_score)
self.hud.kill_count.killed = current_kill_count
# reinit player and player_handler
self.player = Player(self.width / 2, 40, self.level_background)
self.bullet_handler = BulletHandler(self.player, self.level_background)
self.player_handler = PlayerHandler(self.player, self.width,
self.height, self.bullet_handler,
self.cursor)
# reinit menus:
self.pause_menu = Menu(self.width, self.height)
# add handlers:
self.pop_handlers()
self.game_event_handler = GameEventHandler(
self.update_mouse_coordinates,
self.toggle_menu,
self.mouse_click_tracker,
self.mouse_motion_tracker,
self.player_handler.player_action_handler,
)
self.push_handlers(self.game_event_handler)
return super().on_resize(width, height)
def joinGame(data):
"""Socket to join game"""
print(request.sid, "Wants to join")
username = data['player']['username']
email = data['player']['email']
userid = data['player']['userid']
gameid = data['gameid']
player = Player(userid, username, email)
if(gameid in gameLst):
if(player.userid in gameLst[gameid].players):
emit('join-game', {"status": "success",
"reason": "You are already in this game",
"gameid": gameid},
room=request.sid)
join_room(gameid)
return
else:
join_room(gameid)
gameLst[gameid].addPlayer(player)
emit('join-game', {"status": "success", "gameid": gameid},
room=request.sid)
else:
print("Not a valid gameid: " + gameid)
emit('join-game', {"status": "failure",
"reason": "Not a valid gameid"}, room=request.sid)
return
async def get_login(self, name: str, phash: str) -> Optional[Player]:
# Only used cached results - the user should have
# logged into bancho at least once. (This does not
# mean they're logged in now).
# Let them pass as a string for ease of access
phash = phash.encode()
bcrypt_cache = glob.cache['bcrypt']
if phash not in bcrypt_cache:
# User has not logged in through bancho.
return
res = await glob.db.fetch(
'SELECT pw_hash FROM users WHERE name_safe = %s',
[Player.ensure_safe(name)])
if not res:
# Could not find user in the DB.
return
if bcrypt_cache[phash] != res['pw_hash']:
# Password bcrypts do not match.
return
return await self.get_by_name(name)
async def run_server(addr: cmyui.Address) -> None:
glob.version = cmyui.Version(2, 7, 0)
glob.http = aiohttp.ClientSession(json_serialize=orjson.dumps)
loop = asyncio.get_event_loop()
try:
loop.add_signal_handler(signal.SIGINT, lambda: loop.stop())
loop.add_signal_handler(signal.SIGTERM, lambda: loop.stop())
except NotImplementedError:
pass
glob.db = cmyui.AsyncSQLPoolWrapper()
await glob.db.connect(**glob.config.mysql)
# Aika
glob.bot = Player(id = 1, name = 'Aika', priv = Privileges.Normal)
glob.bot.ping_time = 0x7fffffff
await glob.bot.stats_from_sql_full() # no need to get friends
await glob.players.add(glob.bot)
# Add all channels from db.
async for chan in glob.db.iterall('SELECT * FROM channels'):
await glob.channels.add(Channel(**chan))
async with cmyui.AsyncTCPServer(addr) as glob.serv:
plog(f'Gulag v{glob.version} online!', Ansi.LGREEN)
async for conn in glob.serv.listen(glob.config.max_conns):
asyncio.create_task(handle_conn(conn))
def get(self):
check_admin(self)
template_values={'user_meta':get_meta()}
player_scores = memcache.get('horse')
if player_scores is None:
players=Player.all().run()
player_scores=[]
for p in players:
score=0
games=p.playergame_set
for g in games:
if g.batted and not g.not_out and g.how_out == 'Bowled':
score += 1
if g.batted and g.runs == 0 and not g.not_out:
if g.balls_faced <= 1:
score += 5
else:
score += 3
score += 2*g.sixes
score += 3*g.drops + g.diving_drops + 5*g.non_attempts + g.misfields + g.other
player_scores.append([p.first_name + ' ' + p.surname,score])
player_scores=sorted(player_scores,key=lambda player: -player[1])
memcache.add('horse',player_scores)
template_values['player_scores']=player_scores
template=jinja_environment.get_template('templates/horse.html')
self.response.out.write(template.render(template_values))
def build_fixtures():
cache_dir = __file__.replace("loader.py", "cache")
obj_map = {
"division": list(Division()),
"position": list(Position()),
"category": list(Category()),
"team": list(Team()),
"record": list(Record()),
"profile": list(Profile()),
"color": list(Color()),
"teamnav": list(TeamNav()),
"player": list(Player()),
"playernav": list(PlayerNav()),
"stat": list(Stat()),
"teamstat": list(TeamStat()),
"oppstat": list(OppStat()),
"playerstat": list(PlayerStat())
}
fixture_dir = f"{cache_dir}/fixtures"
os.makedirs(fixture_dir, exist_ok=True)
fixtures = []
for key, value in obj_map.items():
filename = f"{fixture_dir}/{key}.json"
with open(filename, "w") as f:
json.dump(value, f)
fixtures += value
with open(f"{fixture_dir}/all.json", "w") as f:
json.dump(fixtures, f)
def __init__(self, cursor, levels, pause_menu, background, *args, **kwrgs):
super().__init__(*args, **kwrgs, vsync=False)
pyglet.gl.glClearColor(0.7, 0.6, 0.4, 0.29)
self.cursor = cursor
self.levels = levels
self.current_level = 0
self.level_background = background
self.level_active = False
self.enemy_handler = self.spawn_enemies_for_level(self.current_level)
self.player = Player(self.width / 2, 40, self.level_background)
self.bullet_handler = BulletHandler(self.player, self.level_background)
self.player_handler = PlayerHandler(self.player, self.width,
self.height, self.bullet_handler,
self.cursor)
self.hud = HUD(self.width, self.height,
len(self.enemy_handler.enemies), (255, 69, 0, 255))
self.pause_menu = pause_menu
self.menu_visible = True
self.end_screen = EndScreen(self.width, self.height, 0, 0, 0)
self.end_screen_visible = False
self.mouse_x = 0
self.mouse_y = 0
self.game_event_handler = GameEventHandler(
self.update_mouse_coordinates,
self.toggle_menu,
self.mouse_click_tracker,
self.mouse_motion_tracker,
self.player_handler.player_action_handler,
)
self.push_handlers(self.game_event_handler)
def add_player(self, pid):
"""
Adds a player using the player's ID
@param pid: The Player ID you want to add
@type pid: int
@return: if successful
@rtype: bool
"""
self.notify.debug(
f"[add_player] Adding player {pid} to game {self.gid}")
p = Player(self.generate_local_id(), pid=pid)
self.players.append(p)
self.notify.debug(f"[add_player] List of players now: {self.players}")
if self.message_all_players(dg_add_player(p.local_id),
exclude=[p.local_id]):
# send all players to the new player
for existing in self.players:
if not self.message_player(
dg_add_player(existing.local_id, existing.name),
p.local_id):
return False
else:
return False
return True
def selected_available(selected_keys,active_only=True):
selected=[]
available=[]
all_players=set(Player.all(keys_only=True).filter('active =',active_only).fetch(1000))
#selected_keys=set(selected_keys)
available_keys=all_players.difference(selected_keys)
for key in selected_keys:
selected.append(db.get(key))
for key in available_keys:
available.append(db.get(key))
return (selected,available)
def get(self,game_id):
check_admin(self)
game=Game.get_by_id(int(game_id))
players=Player.all().filter('active =',True).order('surname').fetch(1000)
fielders=PlayerGame.all().filter('game =',game)
batting_order=sorted(fielders,key=lambda p: p.batting_position)
bowling_order=sorted(fielders,key=lambda p: p.bowling_position)
template_values={'user_meta':get_meta(),'game':game,'players':players,'dismissal_types':dismissal_types,'batting_order':batting_order,'bowling_order':bowling_order,
'fielders':fielders}
template=jinja_environment.get_template('templates/edit_game.html')
self.response.out.write(template.render(template_values))
def get(self):
user_meta=get_meta()
if not user_meta:
self.redirect("/")
players=Player.all().filter('active =',True).run()
template_values={'user_meta':user_meta,'players':players}
if check_mobile():
template=jinja_environment.get_template('templates/mobile/players.html')
else:
template=jinja_environment.get_template('templates/players.html')
self.response.out.write(template.render(template_values))
def get(self,id,name=None):
user_meta=get_meta()
if not user_meta:
self.redirect("/")
player=Player.get_by_id(int(id))
no_layout=self.request.get('noLayout')
template_values={'user_meta':user_meta,'player':player,'no_layout':no_layout}
if check_mobile():
template=jinja_environment.get_template('templates/mobile/player.html')
else:
template=jinja_environment.get_template('templates/player.html')
self.response.out.write(template.render(template_values))
def post(self):
if self.request.get('code')!='RESET':
return self.response.out.write("Reset failed. No harm done")
check_admin(self)
players=Player.all().run()
for p in players:
p.batting_price=p.initial_batting_price
p.bowling_price=p.initial_bowling_price
p.fielding_price=p.initial_fielding_price
p.put()
usermetas=UserMeta.all().run()
for u in usermetas:
u.total_trades=10
u.round_trades=2
u.total_points=0
u.put()
teams=Team.all().run()
for t in teams:
if t.game.round > 1:
t.delete()
else:
t.batting_score=0
t.bowling_score=0
t.fielding_score=0
t.total_score=0
t.put()
playergames=PlayerGame.all().run()
for p in playergames:
p.delete()
games=Game.all().run()
for g in games:
g.played=False
g.result='tie'
g.score="0/0"
g.opposition_score="0/0"
g.batExtras=0
g.bowlExtras=0
g.put()
u=Utilities.all().get()
u.current_round=1
u.next_game=Game.all().filter('round =',1).get()
u.lockout=False
u.put()
memcache.flush_all()
self.response.out.write('System reset. I hope you meant to do that!');
def get(self):
template_values={'user_meta':get_meta()}
players=Player.all().run()
ps=[]
for p in players:
bat_runs=0
innings=0
not_outs=0
balls_faced=0
highest=0
ducks=0
bat_fours=0
bat_sixes=0
overs=0
maidens=0
wickets=0
bowl_runs=0
wides=0
no_balls=0
catches=0
run_outs=0
misfields=0
drops=0
diving=0
non_attempts=0
other=0
games=p.playergame_set
for g in games:
bat_runs+=g.runs
if g.batted:
innings += 1
if g.runs == 0 and not g.not_out:
ducks +=1
if g.not_out:
not_outs+=1
if g.runs > highest:
highest=g.runs
bat_fours+=g.fours_hit
bat_sixes+=g.sixes_hit
balls_faced+=g.balls_faced
overs+=g.overs+1/6.0*g.balls
maidens+=g.maidens
wickets+=g.wickets
bowl_runs+=g.runs_conceded
wides+=g.wides
no_balls+=g.no_balls
catches+=g.catches
drops+=g.drops
drops+=g.diving_drops
diving+=g.diving_drops
run_outs+=g.run_outs
misfields+=g.misfields
non_attempts+=g.non_attempts
other+=g.other
bat_average=0
if innings-not_outs > 0:
bat_average=bat_runs*1.0/(innings-not_outs)
else:
bat_average='-'
bowl_strike_rate=0
bowl_average=0
economy=0
if wickets > 0:
bowl_average=bowl_runs*1.0/wickets
bowl_strike_rate=overs*6.0/wickets
if overs > 0:
economy=bowl_runs*1.0/overs
pl={'first_name':p.first_name,'surname':p.surname,
'bat_runs':bat_runs,'innings':innings,'not_outs':not_outs,'balls_faced':balls_faced,
'bat_average':bat_average,'highest_score':highest,'bat_strike_rate':bat_runs*100.0/balls_faced,
'ducks':ducks,'bat_fours':bat_fours,'bat_sixes':bat_sixes,'overs':str(int(overs))+'.'+str(int(overs-int(overs))),
'bowl_runs':bowl_runs,'wides':wides,'no_balls':no_balls,'bowl_average':bowl_average,'bowl_strike_rate':bowl_strike_rate,
'economy':economy,'catches':catches,'run_outs':run_outs,'misfields':misfields,'drops':drops,'diving':diving,'non_attempts':non_attempts,
'other':other,'wickets':wickets,'maidens':maidens}
ps.append(pl)
template_values['players']=ps
template=jinja_environment.get_template('templates/stats.html')
self.response.out.write(template.render(template_values))
def post(self):
players={}
check_admin(self)
game=Game.get_by_id(int(self.request.get('game')))
batsmen=[]
bowlers=[]
fielders=[]
# TODO: convert to a background task
# Check Duplicates
for i in range(1,13):
if self.request.get('batsman-'+str(i)+'-batted'):
batsmen.append(self.request.get('batsman-'+str(i)))
if self.request.get('bowler-'+str(i)+'-bowled'):
bowlers.append(self.request.get('bowler-'+str(i)))
if self.request.get('fielder-'+str(i)) != '0':
fielders.append(self.request.get('fielder-'+str(i)))
if len(set(batsmen)) != len(batsmen):
self.response.out.write("Error. Duplicate batsmen")
return
if len(set(bowlers)) != len(bowlers):
self.response.out.write("Error. Duplicate bowlers")
return
if len(set(fielders)) != len(fielders):
self.response.out.write("Error. Duplicate fielders")
return
memcache.delete('horse')
pg=None
# batting
for i in range(1,12):
si='batsman-'+str(i)
if not self.request.get(si+'-batted') or self.request.get(si) == '0':
continue
p_id=self.request.get(si)
try:
pg=players[p_id]
except:
player=Player.get_by_id(int(p_id))
pg=PlayerGame(player=player,game=game)
players[p_id]=pg
pg.batted=True
if self.request.get(si+'-not_out'):
pg.not_out=True
else:
pg.not_out=False
pg.runs=int(self.request.get(si+'-runs',default_value="0"))
pg.balls_faced=int(self.request.get(si+'-balls',default_value="0"))
pg.fours_hit=int(self.request.get(si+'-fours',default_value="0"))
pg.sixes_hit=int(self.request.get(si+'-sixes',default_value="0"))
if not pg.not_out:
pg.how_out=db.Category(self.request.get(si+'-how_out').replace('-',' '))
else:
pg.how_out=None
pg.batting_position=i
# bowling
total_conceded=0
for i in range(1,12):
si='bowler-'+str(i)
if not self.request.get(si+'-bowled') or self.request.get(si) == '0':
continue
p_id=self.request.get(si)
try:
pg=players[p_id]
except:
player=Player.get_by_id(int(p_id))
pg=PlayerGame(player=player,game=game)
players[p_id]=pg
pg.bowled=True
overs_tokens=self.request.get(si+'-overs',default_value="0.0").split('.')
pg.overs=int(overs_tokens[0])
if len(overs_tokens) > 1:
pg.balls=int(overs_tokens[1])
else:
pg.balls=0
pg.maidens=int(self.request.get(si+'-maidens',default_value="0"))
pg.runs_conceded=int(self.request.get(si+'-runs',default_value="0"))
total_conceded+=pg.runs_conceded
pg.wickets=int(self.request.get(si+'-wickets',default_value="0"))
pg.wides=int(self.request.get(si+'-wides',default_value="0"))
pg.no_balls=int(self.request.get(si+'-no_balls',default_value="0"))
pg.fours=int(self.request.get(si+'-fours',default_value="0"))
pg.sixes=int(self.request.get(si+'-sixes',default_value="0"))
pg.bowling_position=i
# fielding
for i in range(1,13):
si='fielder-'+str(i)
if self.request.get(si)=='0':
continue
p_id=self.request.get(si)
try:
pg=players[p_id]
except:
player=Player.get_by_id(int(p_id))
pg=PlayerGame(player=player,game=game)
players[p_id]=pg
pg.catches=int(self.request.get(si+'-catches',default_value="0"))
pg.drops=int(self.request.get(si+'-drops',default_value="0"))
pg.diving_drops=int(self.request.get(si+'-diving',default_value="0"))
pg.non_attempts=int(self.request.get(si+'-non_attempts',default_value="0"))
pg.run_outs=int(self.request.get(si+'-run_outs',default_value="0"))
pg.misfields=int(self.request.get(si+'-misfields',default_value="0"))
pg.other=int(self.request.get(si+'-other',default_value="0"))
# TODO: Validation
for pg in game.playergame_set:
pg.delete()
bat_total=0
bowl_total=0
bat_scores={}
bowl_scores={}
for key,pg in players.iteritems():
bat_scores[key]=batting_score(pg)
bat_total+=bat_scores[key]
bowl_scores[key]=bowling_score(pg,total_conceded)
bowl_total+=bowl_scores[key]
pg.fielding_points=fielding_score(pg)
bat_factor = 1
bowl_factor = 1
if bat_total > 0:
bat_factor = 100.0/bat_total
if bowl_total > 0:
if game.overs == 20:
bowl_factor = 80.0/bowl_total
else:
bowl_factor = 100.0/bowl_total
for key,pg in players.iteritems():
pg.batting_points=int(round(bat_scores[key]*bat_factor))
pg.bowling_points=int(round(bowl_scores[key]*bowl_factor))
pg.put()
completed=self.request.get('completed')
if completed:
game_completed(game)
for key,pg in players.iteritems():
p=pg.player
update_prices(p)
p.put()
else:
game.played=False
game.opposition=self.request.get('opposition')
game.score=self.request.get('dedication-score')
game.opposition_score=self.request.get('opposition-score')
game.result=self.request.get('result')
game.put()
self.redirect('/admin')
