def generateLeaderboard(self):
leaderboard = []
leaderboard_a = []
cntr = 0
for user in Users.query().fetch():
u = user.get(user.key.id())
p = user.get_points_sum(user.key.id())
leaderboard.append(Leaderboard_entry_m(user=u, points=p))
if p > 0:
cntr += 1
logging.info("total playing count: " + str(cntr))
leaderboard.sort(key=lambda x: x.points, reverse=True)
lb_m = Leaderboard_m(leaderboard=leaderboard[:20])
if Leaderboard().query().get():
lb = Leaderboard().query().get()
lb.leaderboard = lb_m
lb.put()
else:
lb = Leaderboard(leaderboard=lb_m)
lb.put()
# lb_short = Leaderboard_m(leaderboard=lb_m.leaderboard[:20])
memcache.add(key="leaderboard", value=lb_m, time=500)
def start(currentUser):
global win, curUsr, best
curUsr = currentUser
session = boto3.resource(
'dynamodb',
aws_access_key_id='AKIAIOPUXE2QS7QN2MMQ',
aws_secret_access_key='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',
region_name="ca-central-1")
table = session.Table('highscores')
try:
response = table.get_item(Key={'peopleid': curUsr})
best = response['Item']['quicktype']
except:
best = 10000000
win = pygame.display.set_mode((w_width, w_height))
pygame.display.set_caption('Quick Type')
title = startfont1.render('Quick Type', 1, (255, 255, 255))
startBtn = button('Start Game', 30, 250, 50, (40, 40, 40))
infoBtn = button('Learn to Play', 30, 250, 50, (40, 40, 40))
btns = [startBtn, infoBtn]
run = True
globalTable = Leaderboard(curUsr, 'quicktype', 'global', win, 300, 380,
150, 130)
friendTable = Leaderboard(curUsr, 'quicktype', 'friend', win, 300, 380,
550, 130)
while run:
pygame.time.delay(50)
win.fill(bg)
globalTable.draw()
friendTable.draw()
win.blit(title, (w_width / 2 - title.get_width() / 2, 0))
startBtn.draw(win, 175, w_height - 80)
infoBtn.draw(win, w_width - 425, w_height - 80)
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
if event.type == pygame.MOUSEMOTION:
pos = pygame.mouse.get_pos()
for btn in btns:
if btn.isMouseOver(pos):
btn.hover(win)
else:
btn.update(win)
if event.type == pygame.MOUSEBUTTONDOWN:
pos = pygame.mouse.get_pos()
if startBtn.isMouseOver(pos):
run = False
elif infoBtn.isMouseOver(pos):
showInfoScreen()
pygame.display.update()
win.fill(bg)
pygame.display.update()
main()
def test_init_uses_connection_pooling(self):
lb0 = Leaderboard('lb0', db=0)
lb1 = Leaderboard('lb1', db=0)
lb2 = Leaderboard('lb2', db=1)
lb0.redis_connection.connection_pool.should.equal(
lb1.redis_connection.connection_pool)
lb0.redis_connection.connection_pool.should_not.equal(
lb2.redis_connection.connection_pool)
def leaderboards():
os.system("clear")
# Load the leaderboard
users = Leaderboard()
users.readLeaderboard()
print("===========================")
print("= aMAZE =")
print("===========================")
print("= Leaderboards =")
print("===========================")
print()
print()
print("|# | Name | Score |")
print("===========================")
# Print the leaderboard
print(users)
print("1) Back ")
next_Menu = None
# Get the next menu from the user
while next_Menu == None:
next_Menu = get_ch().lower()
if next_Menu == '1':
os.system("clear")
return MENU_MAIN
else:
next_Menu = None
def __init__(self):
#Initialize the game and create game resources
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
pygame.display.set_caption("Alien Invasion")
#Create an instance to store game statistics
#And create a scoreboard
self.stats = GameStats(self)
self.sb = Scoreboard(self)
self.lb = Leaderboard(self)
#Set background color
self.bg_color = (230, 230, 230)
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
#Make the play button, resume button, and quit button
self.play_button = Button(self, "Play")
self.resume_button = Button(self, "Resume", self.play_button.rect.x,
240)
self.quit_button = Button(self, "Quit", self.play_button.rect.x, 360)
self.replay_button = Button(self, "Replay", self.play_button.rect.x,
240)
self.leaderboard_button = Button(self, "Leaderboard",
self.play_button.rect.x, 300)
self.back_button = Button(self, "Back", self.play_button.rect.x, 450)
def appStarted(app):
app.startMode = StartMode()
app.gameMode = GameMode()
app.helpMode = HelpMode()
app.leaderboard = Leaderboard()
app.loginScreen = LoginScreen()
app.setActiveMode(app.startMode)
def test_merge_leaderboards(self):
foo_leaderboard = Leaderboard('foo')
bar_leaderboard = Leaderboard('bar')
foo_leaderboard.rank_member('foo_1', 1)
foo_leaderboard.rank_member('foo_2', 2)
bar_leaderboard.rank_member('bar_1', 1)
bar_leaderboard.rank_member('bar_2', 2)
bar_leaderboard.rank_member('bar_3', 5)
foo_leaderboard.merge_leaderboards('foobar', ['bar'], aggregate='SUM')
foobar_leaderboard = Leaderboard('foobar')
foobar_leaderboard.total_members().should.equal(5)
foobar_leaderboard.leaders(1)[0]['member'].should.equal('bar_3')
def test_can_set_member_data_namespace_option(self):
self.leaderboard = Leaderboard('name', member_data_namespace='md')
self.__rank_members_in_leaderboard()
self.leaderboard.redis_connection.exists(
"name:member_data").should.be.false
self.leaderboard.redis_connection.exists("name:md").should.be.true
def get(self, request, game, user_id):
"""
Returns the scores around the user
"""
leaderboard = Leaderboard(game)
scores = leaderboard.around_me(user_id)
return {"meta": {}, "scores": scores if scores else []}
def __init__(self):
self.WIDTH = 1300
self.HEIGHT = 900
self.win = pygame.display.set_mode((self.WIDTH, self.HEIGHT))
self.leaderboard = Leaderboard(100, 120)
self.board = Board(310, 120)
self.top_bar = TopBar(10, 10, 1280, 100)
self.top_bar.change_round(1)
def test_db_insert(self):
lb = Leaderboard('test')
lb.clear_database()
lb.add_score('TRIVIAL', 120, 'me')
lb.add_score('NORMAL', 150, 'notme')
val = lb.get_top('TRIVIAL')
self.assertEqual(1, len(val))
self.assertEqual(120, val[0]['time'])
self.assertEqual('me', val[0]['name'])
def test_intersect_leaderboards(self):
foo_leaderboard = Leaderboard('foo')
bar_leaderboard = Leaderboard('bar')
foo_leaderboard.rank_member('foo_1', 1)
foo_leaderboard.rank_member('foo_2', 2)
foo_leaderboard.rank_member('bar_3', 6)
bar_leaderboard.rank_member('bar_1', 3)
bar_leaderboard.rank_member('foo_1', 4)
bar_leaderboard.rank_member('bar_3', 5)
foo_leaderboard.intersect_leaderboards('foobar', ['bar'],
aggregate='SUM')
foobar_leaderboard = Leaderboard('foobar')
foobar_leaderboard.total_members().should.equal(2)
foobar_leaderboard.leaders(1)[0]['member'].should.equal('bar_3')
def reset(self):
pygame.draw.rect(game.display.gameDisplay, (0, 0, 100),
(0, 0, GLOBAL.MAP_WIDTH, GLOBAL.MAP_HEIGHT))
# initialize Hp bar
self.hp = Hp(GLOBAL.HOMEBOT_HEALTH) # the full health is 760
# initialize Home robot
self.homeBot = HomeBot()
self.initializeBoxes()
self.docs = []
self.docDuration = 7000
self.initializeCompetitors()
# initialize player
self.player = Player(GLOBAL.PLAYER_WIDTH, GLOBAL.PLAYER_HEIGHT,
GLOBAL.PLAYER_SPEED, 0)
self.player.setRect(self.display.dogImages[0][0].get_rect())
self.leaderboard = Leaderboard()
self.playerCooldownEvent = pygame.USEREVENT + 3
pygame.time.set_timer(self.playerBryanEvent, GLOBAL.BRYAN_COOLDOWN)
self.bryans = []
self.clock = pygame.time.Clock()
self.keepPlaying = True
self.postGame = False
# Initializes and activates vkeyboard
self.renderer = VKeyboardRenderer(
# Key font.
pygame.font.Font('assets/PressStart2P.ttf', 20),
# Keyboard background color.
(50, 50, 50),
# Key background color (one per state, 0 for released, 1 for pressed).
((255, 255, 255), (0, 0, 0)),
# Text color for key (one per state as for the key background).
((0, 0, 0), (255, 255, 255)),
# (Optional) special key background color.
((255, 255, 255), (0, 0, 0)),
)
self.diff = 0
pygame.time.set_timer(self.increaseDifficultyEvent,
GLOBAL.INCREASE_DIFF_TIME)
self.layout = VKeyboardLayout(VKeyboardLayout.AZERTY,
allow_uppercase=False,
key_size=100,
allow_special_chars=False)
self.keyboard = VKeyboard(self.display.gameDisplay,
self.consumer,
self.layout,
renderer=self.renderer)
self.keyboard.enable()
self.text = ""
async def get_leaderboard_ids(self):
url = API_BASE + "?xml=1"
with aiohttp.ClientSession() as session:
async with session.get(url) as response:
tree = et.fromstring(await response.text())
for data in tree.iter("leaderboard"):
ldb = Leaderboard(self, data)
self.leaderboards.append(ldb)
def leaderboard(self, limit):
data = memcache.get('leaderboard_a')
if data is not None:
return data
else:
data = memcache.get('leaderboard')
if data is not None:
return data
else:
lb_m = Leaderboard().query().get()
memcache.add(key="leaderboard", value=lb_m, time=500)
return lb_m
def create_ui(self):
"""
Create UI in main panel
"""
self.main_sizer = wx.BoxSizer(wx.VERTICAL)
# Add leaderboard button
btn_sizer = wx.BoxSizer()
bmp = wx.ArtProvider.GetBitmap(wx.ART_TICK_MARK, wx.ART_TOOLBAR,
(16, 16))
self.leaderboard_btn = wx.ToggleButton(self, size=(40, 40))
self.leaderboard_btn.SetBitmap(bmp)
self.leaderboard_btn.Bind(wx.EVT_TOGGLEBUTTON, self.on_leaderboard)
btn_sizer.AddStretchSpacer(prop=2)
btn_sizer.Add(self.leaderboard_btn, 0, wx.ALL, 5)
self.main_sizer.Add(btn_sizer, 0, wx.EXPAND)
# Add notebook
hsizer = wx.BoxSizer(wx.HORIZONTAL)
self.notebook = fnb.FlatNotebook(self)
style = self.notebook.GetAGWWindowStyleFlag()
style |= fnb.FNB_NO_X_BUTTON
self.notebook.SetAGWWindowStyleFlag(style)
self.notebook.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, self.on_tab_change)
for tab in range(8):
tab_panel = FilePanel(self.notebook)
self.notebook.AddPage(tab_panel, f'File {tab+1}')
hsizer.Add(self.notebook, 2, wx.ALL | wx.EXPAND, 5)
# Add leaderboard widget (HtmlWindow)
self.leaderboard = Leaderboard(self)
self.leaderboard.SetPage('''
<h2>Leaderboard</h2>
''')
hsizer.Add(self.leaderboard, 1, wx.ALL | wx.EXPAND, 5)
self.leaderboard.Hide()
self.main_sizer.Add(hsizer, 1, wx.ALL | wx.EXPAND)
# Add counters
self.current_count = wx.StaticText(
self, label='Current: Characters: 0 / Words: 0')
self.main_sizer.Add(self.current_count, 0, wx.TOP | wx.LEFT, 5)
self.remaining = wx.StaticText(
self, label='Remaining: Characters: 5000 / Words 2500')
self.main_sizer.Add(self.remaining, 0, wx.LEFT, 5)
target = wx.StaticText(self,
label='(Target: 5000 Characters / 2500 Words)')
self.main_sizer.Add(target, 0, wx.LEFT | wx.BOTTOM, 5)
self.SetSizer(self.main_sizer)
self.main_sizer.Layout()
def test_db_top5(self):
lb = Leaderboard('test')
lb.clear_database()
lb.add_score('HARD', 120, 'a')
lb.add_score('HARD', 118, 'b')
lb.add_score('HARD', 122, 'c')
lb.add_score('HARD', -3, 'd')
lb.add_score('HARD', -8, 'e')
lb.add_score('HARD', 2, 'f')
val = lb.get_top('HARD')
self.assertEqual(5, len(val))
self.assertEqual(-8, val[0]['time'])
self.assertEqual(120, val[4]['time'])
def mainScreen(usr, hover=False):
global shopButton, title, curUsr
curUsr = usr
surf = pygame.Surface((1080, 600))
w = title.get_width()
h = title.get_height()
surf.blit(back, (0, 0))
surf.blit(title, ((1080 / 2 - (w / 2)), 50))
# For Shop Button
'''
if hover == True:S
text = font.render('Ball Shop', 1,(0, 0, 0))
else:
text = font.render('Ball Shop', 1, (51, 51, 153))
surf.blit(text, (960, 12))
shopButton = text.get_rect()
shopButton[0] = 960
shopButton[1] = 12'''
# For course Button
i = buttons[0]
surf.blit(course1, (i[0], i[1]))
text = font.render(i[4], 1, (51, 51, 153))
surf.blit(text, (i[0] + ((i[3] - text.get_width()) / 2), i[1] + i[3] + 10))
text = font.render('Best: ' + getBest(), 1, (51, 51, 153))
surf.blit(text, (i[0] + ((i[3] - text.get_width()) / 2), i[1] + i[3] + 40))
#text = font.render('Coins: ' + getCoins(), 1, (51,51,153))
#surf.blit(text, (10, 10))
#draw leaderboard
globalTable = Leaderboard(curUsr, 'golf', 'global', surf, 300, 380, 90,
200)
friendTable = Leaderboard(curUsr, 'golf', 'friend', surf, 300, 380, 680,
200)
globalTable.draw((0, 0, 0))
friendTable.draw((0, 0, 0))
win.blit(surf, (0, 0))
pygame.display.update()
def __init__(self, win, connection=None):
pygame.font.init()
self.connection = connection
self.win = win
self.leaderboard = Leaderboard(50, 125)
self.board = Board(305, 125)
self.top_bar = TopBar(10, 10, 1280, 100)
self.top_bar.change_round(1)
self.players = []
self.skip_button = TextButton(85, 830, 125, 60, (255, 255, 0), "Skip")
self.bottom_bar = BottomBar(305, 880, self)
self.chat = Chat(1050, 125)
self.draw_color = (0, 0, 0)
self.drawing = False
def __init__(self, win, connection=None):
pygame.font.init()
self.connection = connection
self.win = win
self.leaderboard = Leaderboard(30, 95)
self.board = Board(200, 100)
self.top_bar = TopBar(10, 10, 1080, 80)
self.bottom_bar = BottomBar(200, 714, self)
self.top_bar.change_round(1)
self.players = []
self.chat = Chat(860, 95)
self.skip_button = TextButton(70, 700, 100, 45, (255, 255, 0), "Skip")
self.draw_color = (0, 0, 0)
self.drawing = False
def test_db_is_high(self):
lb = Leaderboard('test')
lb.clear_database()
self.assertTrue(lb.is_high_score('HARD', 99999999))
lb.add_score('HARD', 120, 'a')
lb.add_score('HARD', 118, 'b')
lb.add_score('HARD', 122, 'c')
lb.add_score('HARD', -3, 'd')
self.assertTrue(lb.is_high_score('HARD', 99999999))
lb.add_score('HARD', -8, 'e')
self.assertFalse(lb.is_high_score('HARD', 99999999))
lb.add_score('HARD', 2, 'f')
self.assertTrue(lb.is_high_score('HARD', 119))
self.assertFalse(lb.is_high_score('HARD', 120))
def get(self, request, game, page=1):
"""
Returns the high scores
@todo: pagination
"""
leaderboard = Leaderboard(game)
scores = leaderboard.leaders(int(page))
total_pages = leaderboard.total_pages()
return {
"meta": {
"total_pages": int(total_pages)
},
"scores": scores if scores else []
}
def highscores(request, game, page=1):
"""
displays the leaderboard table
"""
# You can set the default page size
#Leaderboard.DEFAULT_PAGE_SIZE = 2
page = int(page)
leaderboard = Leaderboard(game)
scores = leaderboard.leaders(int(page))
if not scores:
scores = []
total_pages = int(leaderboard.total_pages())
# Pagination values
has_next = True if (page < total_pages) else False
has_prev = True if (page != 1) else False
next_page = page + 1 if has_next else page
prev_page = page - 1 if has_prev else page
# hashmap to get the score instance quickly
score_list = {}
# Collect the user ids
user_ids = []
for score in scores:
user_ids.append(score["member"])
score_list[int(score["member"])] = score
# Fetch users in question
users = User.objects.filter(pk__in=user_ids)
for user in users:
score_list[user.pk]["user"] = user
return render_to_response("django_leaderboard/highscores.html", {
"scores": scores,
"total_pages": total_pages,
"game": game,
"page": page,
'has_next': has_next,
'has_prev': has_prev,
'next_page': next_page,
'prev_page': prev_page,
},
context_instance=RequestContext(request))
def client(conn, player):
with conn:
db = Leaderboard()
#init game with map player ID
conn.send(pickle.dumps((maps, player,db.get_leaderboard())))
#add player to leaderboard db if not already there
username = pickle.loads(conn.recv(config.buffer_size))
db.insert_new_player(username)
while True: #continously run whilst client still connected
try:
data = pickle.loads(conn.recv(config.buffer_size)) #received player attrs
stats = list(players[player]['stats'].values())
#a players stats have been updated, update the leaderboard db
if any(list(data['stats'].values())[i] != stats[i] for i in range(len(stats))):
kills = data['stats']['kills']
deaths = data['stats']['deaths']
kd = data['stats']['K/D']
db.update_player(data['username'],kills,deaths,kd)
print('leaderboard updated.')
players[player] = data
if not data:
print('Disconnected from server.')
break
else:
#slice out this player and return other players only, or we could do a deepcopy
reply = (players[:player]+players[player+1:])
conn.sendall(pickle.dumps(reply))
except:
break
current_player = players[player]['username']
print(f'connection dropped ({current_player}, ID:{player}).')
#player DCed so reset to defaults and add to DC list so we can re-add if they re-connect
players[player] = attributes
DC.append(player)
def run():
# Initialize game and create a screen object
settings = Config()
stats = Stats(settings)
pygame.init()
pygame.mixer.init()
screen = pygame.display.set_mode(settings.default_size)
pygame.display.set_caption(settings.default_name)
play_button = Button(settings, screen, "Play")
game_over = Button(settings, screen, "Game Over", 600, 75)
leader = Leaderboard(settings, screen, stats)
stars = Group()
# Make a ship
ship = Ship(settings, screen)
# Make a group to store projectiles in
projectiles = Group()
# Make an invasion group
aliens = Group()
game.create_fleet(settings, screen, ship, aliens)
# Start the main game loop
while True:
# Watch for keyboard and mouse events
game.check_events(settings, screen, stats, leader, play_button, ship,
aliens, projectiles)
#game.update_screen(settings, screen, stats, leader, ship, aliens, projectiles, play_button)
if stats.game_active:
ship.update()
game.update_projectiles(settings, screen, stats, leader, ship,
aliens, projectiles)
game.update_aliens(settings, stats, screen, leader, ship, aliens,
projectiles)
game.update_screen(settings, screen, stats, leader, ship, aliens,
projectiles, play_button, game_over)
def __init__(self, font, screen):
self.font = font
self.screen=screen
self.screen_rect=screen.get_rect()
self.off_rect = self.screen_rect.copy()
self.off_rect.height=self.screen_rect.height - 200
self.off_text_surface = pygame.Surface(self.off_rect.size)
print(self.off_rect)
logos = pygame.image.load("img/kmakers.png")
image_rect = logos.get_rect()
image_rect.y = self.screen_rect.height-70
image_rect.x = self.screen_rect.width - 210
self.screen.blit(logos, image_rect)
self.music = ShepherdMusic()
self.leaderboard = Leaderboard()
self.reset_buttons()
def __init__(self, gameDisplay, musicPlayer):
self.__gameDisplay = gameDisplay
self.__musicPlayer = musicPlayer
self.__fastLeaderEasy = Leaderboard("fast_easy.pickle")
self.__smartLeaderEasy = Leaderboard("smart_easy.pickle")
self.__fastLeaderMedium = Leaderboard("fast_medium.pickle")
self.__smartLeaderMedium = Leaderboard("smart_medium.pickle")
self.__fastLeaderHard = Leaderboard("fast_hard.pickle")
self.__smartLeaderHard = Leaderboard("smart_hard.pickle")
self.__vitezaSoundCuePath = os.path.join(os.getcwd(), "Music")
self.__vitezaSoundCuePath = os.path.join(
self.__vitezaSoundCuePath, LeaderboardScreen.VITEZA_SOUND_CUE)
def game_over(score):
os.system("clear")
print("===========================")
print("= aMAZE =")
print("===========================")
print("= GAME OVER :( =")
print("===========================")
print("= Enter your Name =")
print("= 10 Characters max =")
print("===========================")
# Get the users name
name = input()
# Update the leaderboard with the user that just played
leaderboard = Leaderboard()
leaderboard.readLeaderboard()
leaderboard.addUser(name, score)
leaderboard.writeLeaderboard()
def __init__(self, win, connection):
"""
:param win: Window
:param connection: Connection object
"""
self.win = win
self.connection = connection
self.is_drawing = False
self.players = []
self.draw_color = COLORS[1]
self.game_ended = False
self.drawer = "No one"
self.top_bar = TopBar(20, 20, 1040, 80, self)
self.leaderboard = Leaderboard(20, 120, 270, 60)
self.board = Board(310, 120, 6)
self.chat = Chat(810, 120, 250, 580, 30)
self.bottom_bar = BottomBar(20, 620, 770, 80, self)
self.person_is_drawing = PersonIsDrawing(310, 620, 480, 80)
def test_init_uses_connection(self):
lb = Leaderboard('lb0', connection=Redis(db=1))
lb.redis_connection.connection_pool.connection_kwargs[
'db'].should.equal(1)
lb = Leaderboard('lb1', connection=StrictRedis(db=1))
lb.redis_connection.connection_pool.connection_kwargs[
'db'].should.equal(1)
