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 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
class Game:
BG = (255, 255, 255)
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 draw(self):
self.win.fill(self.BG)
self.leaderboard.draw(self.win)
self.top_bar.draw(self.win)
self.board.draw(self.win)
pygame.display.update()
def run(self):
run = True
clock = pygame.time.Clock()
while run:
clock.tick(30)
self.draw()
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
break
pygame.quit()
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 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 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 []}
class Game1(IGame):
"Game1 implements IGame"
def __init__(self):
self.leaderboard = Leaderboard()
def add_winner(self, position, name):
self.leaderboard.add_winner(position, name)
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)
class Game2(IGame): # pylint: disable=too-few-public-methods
"Game2 implements IGame"
def __init__(self):
self.leaderboard = Leaderboard()
def add_winner(self, position, name):
self.leaderboard.add_winner(position, name)
def time_leader_fetch(num=50000):
highscore_lb = Leaderboard('highscores')
page = random.randint(0, highscore_lb.total_pages())
lb_request_time = 0
for i in range(num):
start = time()
highscore_lb.leaders(page)
lb_request_time += time()-start
print "%d fetches, avg %f seconds" % (num, lb_request_time / num)
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 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 = ""
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 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_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 __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 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 __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 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 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_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 appStarted(app):
app.startMode = StartMode()
app.gameMode = GameMode()
app.helpMode = HelpMode()
app.leaderboard = Leaderboard()
app.loginScreen = LoginScreen()
app.setActiveMode(app.startMode)
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 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 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 __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()
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 __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)
class LeaderboardOperations:
"""
Proxy class between HTTP requests (see request_handler.RequestHandler) and leaderboard.Leaderboard.
Parses the request and forwards it.
"""
kStatus_ok = {"status": "OK"}
kStatus_ko = {"status": "KO"}
def __init__(self):
self.leaderboard = Leaderboard()
def get_top(self, path):
"""
Retrieve top XX of the leaderboard
"""
top_number = path.rsplit('/', 1).pop()
try:
sorted_list = self.leaderboard.get_top(int(top_number))
return JSONResponse(200, sorted_list)
except ValueError:
raise RequestError(
400,
"Wrong parameter type expected int got {}".format(top_number))
def get_partial(self, path):
"""
Retrieve relative ranking around a position
"""
splitted = path.rsplit('/', 2)
try:
sorted_list = self.leaderboard.get_partial(int(splitted[1]),
int(splitted[2]))
return JSONResponse(200, sorted_list)
except ValueError:
raise RequestError(
400,
"Wrong parameter type expected int got {}".format(splitted))
def insert_or_update(self, parsed_req):
"""
As updating a score in absolute "in this case" is equivalent to creating a new user we don't need separated operations
"""
self.leaderboard.insert_user_or_update_user_score(parsed_req)
return JSONResponse(200, self.kStatus_ok)
def update(self, parsed_req):
"""
Update the score of a specific user ,if exists otherwise rise RequestError
"""
if not self.leaderboard.has_user(parsed_req['user']):
raise RequestError(
404, "User {} does not exist".format(parsed_req['user']))
self.leaderboard.update_user_score(parsed_req)
return JSONResponse(200, self.kStatus_ok)
def __init__(self):
self.WIDTH = 1300
self.HEIGHT = 1000
self.win = pygame.display.set_mode((self.WIDTH, self.HEIGHT))
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 = [
Player("Tim"),
Player("Joe"),
Player("Bill"),
Player("Jeff"),
Player("TBob")
]
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)
for player in self.players:
self.leaderboard.add_player(player)
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 post(self, request, game, page=1):
"""
Creates new rankings
Params:
game: game identifier
user_id: pk of the user
score: positive integer
Returns:
1 on creation, 0 on updation
"""
user_id = request.POST.get('user_id')
score = request.POST.get('score')
try:
user = User.objects.get(pk=user_id)
except:
return Response(404, 'User Not Found')
leaderboard = Leaderboard(game)
status = leaderboard.rank_member(user.id, int(score))
return {"status": status}
def post(self, request, game, page=1):
"""
Creates new rankings
Params:
game: game identifier
user_id: pk of the user
score: positive integer
Returns:
1 on creation, 0 on updation
"""
user_id = request.POST.get('user_id')
score = request.POST.get('score')
try:
user = User.objects.get(pk=user_id)
except:
return Response(404, 'User Not Found')
leaderboard = Leaderboard(game)
status = leaderboard.rank_member(user.id, int(score))
return {"status": status}
def main():
# set window position
a = 3
b = 23
os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (a, b)
file = 'scores.csv'
pg.init()
pg.mixer.music.load('sounds/background.wav')
pg.mixer.music.play(-1)
start_screen = StartScreen(IMAGES_PATH + 'shuttle.ico',
IMAGES_PATH + 'galaxy.jpg', SCREEN_TITLE,
SCREEN_WIDTH, SCREEN_HEIGHT)
action = start_screen.get_action()
while action != 3:
if action == 0:
new_game = Game(IMAGES_PATH + 'shuttle.ico', file,
IMAGES_PATH + 'galaxy.jpg', SCREEN_TITLE,
SCREEN_WIDTH, SCREEN_HEIGHT)
new_game.run_game_loop(0, 0)
pg.mixer.music.load('sounds/background.wav')
pg.mixer.music.play(-1)
elif action == 1:
# show leaderboard
leaderboard = Leaderboard(IMAGES_PATH + 'shuttle.ico',
IMAGES_PATH + 'galaxy.jpg', file,
SCREEN_TITLE, SCREEN_WIDTH,
SCREEN_HEIGHT)
leaderboard.draw()
action = start_screen.get_action()
pg.quit()
quit()
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 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 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()
class LeaderboardTest(unittest.TestCase):
def setUp(self):
self.leaderboard = Leaderboard('name')
def tearDown(self):
self.leaderboard.redis_connection.flushdb()
def test_version(self):
Leaderboard.VERSION.should.equal('2.2.0')
def test_init_with_defaults(self):
'name'.should.equal(self.leaderboard.leaderboard_name)
len(self.leaderboard.options).should.be(1)
self.leaderboard.options['connection_pool'].should.be.a(ConnectionPool)
self.leaderboard.redis_connection.should.be.a(Redis)
self.leaderboard.DEFAULT_PAGE_SIZE.should.equal(self.leaderboard.page_size)
def test_init_sets_page_size_to_default_if_set_to_invalid_value(self):
self.leaderboard = Leaderboard('name', page_size = 0)
self.leaderboard.page_size.should.equal(Leaderboard.DEFAULT_PAGE_SIZE)
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 test_delete_leaderboard(self):
self.__rank_members_in_leaderboard()
self.leaderboard.redis_connection.exists('name').should.be.true
self.leaderboard.delete_leaderboard()
self.leaderboard.redis_connection.exists('name').should.be.false
def test_member_data_for(self):
self.__rank_members_in_leaderboard()
self.leaderboard.member_data_for('member_1').should.eql(str({'member_name': 'Leaderboard member 1'}))
def test_update_member_data(self):
self.__rank_members_in_leaderboard()
self.leaderboard.update_member_data('member_1', {'member_name': 'Updated Leaderboard member 1'})
self.leaderboard.member_data_for('member_1').should.eql(str({'member_name': 'Updated Leaderboard member 1'}))
def test_remove_member_data(self):
self.__rank_members_in_leaderboard()
self.leaderboard.remove_member_data('member_1')
self.leaderboard.member_data_for('member_1').should.be(None)
def test_total_members(self):
self.__rank_members_in_leaderboard()
self.leaderboard.total_members().should.be(5)
def test_remove_member(self):
self.__rank_members_in_leaderboard()
self.leaderboard.total_members().should.be(5)
self.leaderboard.remove_member('member_1')
self.leaderboard.total_members().should.be(4)
def test_total_pages(self):
self.__rank_members_in_leaderboard(26)
self.leaderboard.total_members().should.be(26)
self.leaderboard.total_pages().should.be(2)
def test_total_members_in_score_range(self):
self.__rank_members_in_leaderboard()
self.leaderboard.total_members_in_score_range(2, 4).should.be(3)
def test_score_for(self):
self.__rank_members_in_leaderboard()
self.leaderboard.score_for('member_5').should.be(5.0)
self.leaderboard.score_for('jones').should.be(None)
def test_check_member(self):
self.__rank_members_in_leaderboard()
self.leaderboard.check_member('member_3').should.be.true
self.leaderboard.check_member('member_6').should.be.false
def test_rank_for(self):
self.__rank_members_in_leaderboard()
self.leaderboard.rank_for('member_5').should.be(1)
def test_change_score_for(self):
self.__rank_members_in_leaderboard()
self.leaderboard.change_score_for('member_1', 99)
self.leaderboard.rank_for('member_1').should.be(1)
self.leaderboard.score_for('member_1').should.be(99.0)
def test_score_and_rank_for(self):
self.__rank_members_in_leaderboard()
score_and_rank = self.leaderboard.score_and_rank_for('member_3')
score_and_rank['member'].should.be('member_3')
score_and_rank['score'].should.be(3.0)
score_and_rank['rank'].should.be(3)
score_and_rank = self.leaderboard.score_and_rank_for('jones')
score_and_rank['member'].should.be('jones')
score_and_rank['score'].should.be(None)
score_and_rank['rank'].should.be(None)
def test_remove_members_in_score_range(self):
self.__rank_members_in_leaderboard()
self.leaderboard.total_members().should.be(5)
self.leaderboard.remove_members_in_score_range(2, 4)
self.leaderboard.total_members().should.be(2)
def test_page_for(self):
self.leaderboard.page_for('jones').should.be(0)
self.__rank_members_in_leaderboard(20)
self.leaderboard.page_for('member_17').should.be(1)
self.leaderboard.page_for('member_11').should.be(1)
self.leaderboard.page_for('member_10').should.be(1)
self.leaderboard.page_for('member_1').should.be(1)
self.leaderboard.page_for('member_17', 10).should.be(1)
self.leaderboard.page_for('member_11', 10).should.be(1)
self.leaderboard.page_for('member_10', 10).should.be(2)
self.leaderboard.page_for('member_1', 10).should.be(2)
def test_percentile_for(self):
self.__rank_members_in_leaderboard(13)
self.leaderboard.percentile_for('member_1').should.eql(0)
self.leaderboard.percentile_for('member_2').should.eql(9)
self.leaderboard.percentile_for('member_3').should.eql(17)
self.leaderboard.percentile_for('member_4').should.eql(25)
self.leaderboard.percentile_for('member_12').should.eql(92)
def test_expire_leaderboard(self):
self.__rank_members_in_leaderboard()
self.leaderboard.expire_leaderboard(3)
ttl = self.leaderboard.redis_connection.ttl(self.leaderboard.leaderboard_name)
ttl.should.be.greater_than(1)
def test_expire_leaderboard_at(self):
self.__rank_members_in_leaderboard()
self.leaderboard.expire_leaderboard_at(int(time.time() + 10))
ttl = self.leaderboard.redis_connection.ttl(self.leaderboard.leaderboard_name)
ttl.should.be.lower_than(11)
def test_leaders(self):
self.__rank_members_in_leaderboard(27)
leaders = self.leaderboard.leaders(1)
len(leaders).should.be(25)
leaders[0]['member'].should.be('member_26')
leaders[0]['rank'].should.be(1)
leaders[24]['member'].should.be('member_2')
leaders = self.leaderboard.leaders(2)
len(leaders).should.be(1)
leaders[0]['member'].should.be('member_1')
leaders[0]['rank'].should.be(26)
leaders = self.leaderboard.leaders(1, page_size = 5)
len(leaders).should.be(5)
def test_leaders_with_optional_member_data(self):
self.__rank_members_in_leaderboard()
leaders = self.leaderboard.leaders(1, with_member_data = True)
len(leaders).should.be(5)
leaders[0]['member'].should.be('member_1')
leaders[0]['member_data'].should.be(str({'member_name': 'Leaderboard member 1'}))
def test_ranked_in_list_with_sort_by(self):
self.__rank_members_in_leaderboard(26)
leaders = self.leaderboard.ranked_in_list(['member_25', 'member_1', 'member_15'], sort_by = 'score')
len(leaders).should.be(3)
leaders[0]['member'].should.be('member_1')
leaders[1]['member'].should.be('member_15')
leaders[2]['member'].should.be('member_25')
leaders = self.leaderboard.ranked_in_list(['member_25', 'member_1', 'member_15'], sort_by = 'rank')
len(leaders).should.be(3)
leaders[0]['member'].should.be('member_1')
leaders[1]['member'].should.be('member_15')
leaders[2]['member'].should.be('member_25')
def test_ranked_in_list(self):
self.__rank_members_in_leaderboard(27)
leaders = self.leaderboard.ranked_in_list(['member_1', 'member_15', 'member_25'])
len(leaders).should.be(3)
leaders[0]['member'].should.be('member_1')
leaders[1]['member'].should.be('member_15')
leaders[2]['member'].should.be('member_25')
def test_ranked_in_list_with_unknown_member(self):
self.__rank_members_in_leaderboard(27)
leaders = self.leaderboard.ranked_in_list(['jones'])
len(leaders).should.be(1)
leaders[0]['member'].should.be('jones')
leaders[0]['score'].should.be(None)
leaders[0]['rank'].should.be(None)
def test_all_leaders(self):
self.__rank_members_in_leaderboard(26)
leaders = self.leaderboard.all_leaders()
len(leaders).should.be(25)
leaders[0]['member'].should.be('member_25')
def test_members_from_score_range(self):
self.__rank_members_in_leaderboard(26)
members = self.leaderboard.members_from_score_range(10, 15)
member_15 = {
'member': 'member_15',
'score': 15.0,
'rank': 11
}
members[0].should.eql(member_15)
member_10 = {
'member': 'member_10',
'score': 10.0,
'rank': 16
}
members[5].should.eql(member_10)
def test_members_from_rank_range(self):
self.__rank_members_in_leaderboard(26)
members = self.leaderboard.members_from_rank_range(5, 9)
len(members).should.be(5)
members[0]['member'].should.eql('member_21')
members[0]['score'].should.be(21.0)
members[4]['member'].should.eql('member_17')
members = self.leaderboard.members_from_rank_range(1, 1)
len(members).should.be(1)
members[0]['member'].should.eql('member_25')
members = self.leaderboard.members_from_rank_range(1, 26)
len(members).should.be(25)
members[0]['member'].should.eql('member_25')
members[0]['score'].should.be(25)
members[24]['member'].should.eql('member_1')
def test_member_at(self):
self.__rank_members_in_leaderboard(51)
self.leaderboard.member_at(1)['rank'].should.be(1)
self.leaderboard.member_at(1)['score'].should.be(50.0)
self.leaderboard.member_at(26)['rank'].should.be(26)
self.leaderboard.member_at(50)['rank'].should.be(50)
self.leaderboard.member_at(51).should.be(None)
self.leaderboard.member_at(1, with_member_data = True)['member_data'].should.be(str({'member_name': 'Leaderboard member 1'}))
def test_around_me(self):
self.__rank_members_in_leaderboard(Leaderboard.DEFAULT_PAGE_SIZE * 3 + 1)
self.leaderboard.total_members().should.be(Leaderboard.DEFAULT_PAGE_SIZE * 3 + 1)
leaders_around_me = self.leaderboard.around_me('member_30')
(len(leaders_around_me) / 2).should.be(self.leaderboard.page_size / 2)
leaders_around_me = self.leaderboard.around_me('member_1')
len(leaders_around_me).should.be(self.leaderboard.page_size / 2 + 1)
leaders_around_me = self.leaderboard.around_me('member_76')
(len(leaders_around_me) / 2).should.be(self.leaderboard.page_size / 2)
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.be(5)
foobar_leaderboard.leaders(1)[0]['member'].should.be('bar_3')
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.be(2)
foobar_leaderboard.leaders(1)[0]['member'].should.be('bar_3')
def test_rank_member_if(self):
def highscore_check(self, member, current_score, score, member_data, leaderboard_options):
if (current_score is None):
return True
if (score > current_score):
return True
return False
self.leaderboard.total_members().should.be(0)
self.leaderboard.rank_member_if(highscore_check, 'david', 1337)
self.leaderboard.total_members().should.be(1)
self.leaderboard.score_for('david').should.be(1337.0)
self.leaderboard.rank_member_if(highscore_check, 'david', 1336)
self.leaderboard.score_for('david').should.be(1337.0)
self.leaderboard.rank_member_if(highscore_check, 'david', 1338)
self.leaderboard.score_for('david').should.be(1338.0)
def test_rank_members(self):
self.leaderboard.total_members().should.be(0)
self.leaderboard.rank_members(['member_1', 1000, 'member_2', 3000])
self.leaderboard.total_members().should.be(2)
def __rank_members_in_leaderboard(self, members_to_add = 6):
for index in range(1, members_to_add):
self.leaderboard.rank_member('member_%s' % index, index, { 'member_name': 'Leaderboard member %s' % index })
def setUp(self):
self.leaderboard = Leaderboard('name')
class LeaderboardTest(unittest.TestCase):
def setUp(self):
self.leaderboard = Leaderboard('name')
def tearDown(self):
self.leaderboard.redis_connection.flushdb()
Leaderboard.MEMBER_KEY = 'member'
Leaderboard.SCORE_KEY = 'score'
Leaderboard.RANK_KEY = 'rank'
Leaderboard.MEMBER_DATA_KEY = 'member_data'
def test_version(self):
Leaderboard.VERSION.should.equal('2.8.0')
def test_init_with_defaults(self):
'name'.should.equal(self.leaderboard.leaderboard_name)
len(self.leaderboard.options).should.be(1)
self.leaderboard.options['connection_pool'].should.be.a(ConnectionPool)
self.leaderboard.redis_connection.should.be.a(Redis)
self.leaderboard.DEFAULT_PAGE_SIZE.should.equal(self.leaderboard.page_size)
def test_init_sets_page_size_to_default_if_set_to_invalid_value(self):
self.leaderboard = Leaderboard('name', page_size = 0)
self.leaderboard.page_size.should.equal(Leaderboard.DEFAULT_PAGE_SIZE)
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 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)
def test_delete_leaderboard(self):
self.__rank_members_in_leaderboard()
self.leaderboard.redis_connection.exists('name').should.be.true
self.leaderboard.delete_leaderboard()
self.leaderboard.redis_connection.exists('name').should.be.false
def test_member_data_for(self):
self.__rank_members_in_leaderboard()
self.leaderboard.member_data_for('member_1').should.eql(str({'member_name': 'Leaderboard member 1'}))
def test_update_member_data(self):
self.__rank_members_in_leaderboard()
self.leaderboard.update_member_data('member_1', {'member_name': 'Updated Leaderboard member 1'})
self.leaderboard.member_data_for('member_1').should.eql(str({'member_name': 'Updated Leaderboard member 1'}))
def test_remove_member_data(self):
self.__rank_members_in_leaderboard()
self.leaderboard.remove_member_data('member_1')
self.leaderboard.member_data_for('member_1').should.be(None)
def test_total_members(self):
self.__rank_members_in_leaderboard()
self.leaderboard.total_members().should.equal(5)
def test_remove_member(self):
self.__rank_members_in_leaderboard()
self.leaderboard.total_members().should.equal(5)
self.leaderboard.remove_member('member_1')
self.leaderboard.total_members().should.equal(4)
def test_remove_member_also_removes_member_data(self):
self.__rank_members_in_leaderboard()
self.leaderboard.redis_connection.exists("name:member_data").should.be.true
len(self.leaderboard.redis_connection.hgetall("name:member_data")).should.equal(5)
self.leaderboard.total_members().should.equal(5)
self.leaderboard.remove_member('member_1')
self.leaderboard.redis_connection.exists("name:member_data").should.be.true
len(self.leaderboard.redis_connection.hgetall("name:member_data")).should.equal(4)
self.leaderboard.total_members().should.equal(4)
def test_total_pages(self):
self.__rank_members_in_leaderboard(27)
self.leaderboard.total_members().should.equal(26)
self.leaderboard.total_pages().should.equal(2)
def test_total_members_in_score_range(self):
self.__rank_members_in_leaderboard()
self.leaderboard.total_members_in_score_range(2, 4).should.equal(3)
def test_score_for(self):
self.__rank_members_in_leaderboard()
self.leaderboard.score_for('member_5').should.equal(5.0)
self.leaderboard.score_for('jones').should.be(None)
def test_check_member(self):
self.__rank_members_in_leaderboard()
self.leaderboard.check_member('member_3').should.be.true
self.leaderboard.check_member('member_6').should.be.false
def test_rank_for(self):
self.__rank_members_in_leaderboard()
self.leaderboard.rank_for('member_5').should.equal(1)
def test_change_score_for(self):
self.__rank_members_in_leaderboard()
self.leaderboard.change_score_for('member_1', 99)
self.leaderboard.rank_for('member_1').should.equal(1)
self.leaderboard.score_for('member_1').should.equal(100.0)
def test_score_and_rank_for(self):
self.__rank_members_in_leaderboard()
score_and_rank = self.leaderboard.score_and_rank_for('member_3')
score_and_rank['member'].should.equal('member_3')
score_and_rank['score'].should.equal(3.0)
score_and_rank['rank'].should.equal(3)
score_and_rank = self.leaderboard.score_and_rank_for('jones')
score_and_rank['member'].should.equal('jones')
score_and_rank['score'].should.be(None)
score_and_rank['rank'].should.be(None)
def test_remove_members_in_score_range(self):
self.__rank_members_in_leaderboard()
self.leaderboard.total_members().should.equal(5)
self.leaderboard.remove_members_in_score_range(2, 4)
self.leaderboard.total_members().should.equal(2)
def test_remove_members_outside_rank(self):
self.__rank_members_in_leaderboard()
self.leaderboard.total_members().should.equal(5)
self.leaderboard.remove_members_outside_rank(3).should.equal(2)
leaders = self.leaderboard.leaders(1)
len(leaders).should.equal(3)
leaders[0]['member'].should.equal('member_5')
leaders[2]['member'].should.equal('member_3')
self.leaderboard.order = Leaderboard.ASC
self.__rank_members_in_leaderboard()
self.leaderboard.total_members().should.equal(5)
self.leaderboard.remove_members_outside_rank(3).should.equal(2)
leaders = self.leaderboard.leaders(1)
len(leaders).should.equal(3)
leaders[0]['member'].should.equal('member_1')
leaders[2]['member'].should.equal('member_3')
def test_page_for(self):
self.leaderboard.page_for('jones').should.equal(0)
self.__rank_members_in_leaderboard(21)
self.leaderboard.page_for('member_17').should.equal(1)
self.leaderboard.page_for('member_11').should.equal(1)
self.leaderboard.page_for('member_10').should.equal(1)
self.leaderboard.page_for('member_1').should.equal(1)
self.leaderboard.page_for('member_17', 10).should.equal(1)
self.leaderboard.page_for('member_11', 10).should.equal(1)
self.leaderboard.page_for('member_10', 10).should.equal(2)
self.leaderboard.page_for('member_1', 10).should.equal(2)
def test_page_for_with_sort_option_ASC(self):
self.leaderboard.order = Leaderboard.ASC
self.leaderboard.page_for('jones').should.equal(0)
self.__rank_members_in_leaderboard(21)
self.leaderboard.page_for('member_10', 10).should.equal(1)
self.leaderboard.page_for('member_1', 10).should.equal(1)
self.leaderboard.page_for('member_17', 10).should.equal(2)
self.leaderboard.page_for('member_11', 10).should.equal(2)
def test_percentile_for(self):
self.__rank_members_in_leaderboard(13)
self.leaderboard.percentile_for('member_1').should.eql(0)
self.leaderboard.percentile_for('member_2').should.eql(9)
self.leaderboard.percentile_for('member_3').should.eql(17)
self.leaderboard.percentile_for('member_4').should.eql(25)
self.leaderboard.percentile_for('member_12').should.eql(92)
def test_score_for_percentile(self):
self.__rank_members_in_leaderboard(6)
self.leaderboard.score_for_percentile(0).should.eql(1.0)
self.leaderboard.score_for_percentile(75).should.eql(4.0)
self.leaderboard.score_for_percentile(87.5).should.eql(4.5)
self.leaderboard.score_for_percentile(93.75).should.eql(4.75)
self.leaderboard.score_for_percentile(100).should.eql(5.0)
def test_score_for_percentile_with_sort_option_ASC(self):
self.leaderboard.order = Leaderboard.ASC
self.__rank_members_in_leaderboard(6)
self.leaderboard.score_for_percentile(0).should.eql(5.0)
self.leaderboard.score_for_percentile(75).should.eql(2.0)
self.leaderboard.score_for_percentile(87.5).should.eql(1.5)
self.leaderboard.score_for_percentile(93.75).should.eql(1.25)
self.leaderboard.score_for_percentile(100).should.eql(1.0)
def test_expire_leaderboard(self):
self.__rank_members_in_leaderboard()
self.leaderboard.expire_leaderboard(3)
ttl = self.leaderboard.redis_connection.ttl(self.leaderboard.leaderboard_name)
ttl.should.be.greater_than(1)
ttl = self.leaderboard.redis_connection.ttl('%s:member_data' % self.leaderboard.leaderboard_name)
ttl.should.be.greater_than(1)
def test_expire_leaderboard_at(self):
self.__rank_members_in_leaderboard()
self.leaderboard.expire_leaderboard_at(int(time.time() + 10))
ttl = self.leaderboard.redis_connection.ttl(self.leaderboard.leaderboard_name)
ttl.should.be.lower_than(11)
ttl = self.leaderboard.redis_connection.ttl('%s:member_data' % self.leaderboard.leaderboard_name)
ttl.should.be.lower_than(11)
def test_leaders(self):
self.__rank_members_in_leaderboard(27)
leaders = self.leaderboard.leaders(1)
len(leaders).should.equal(25)
leaders[0]['member'].should.equal('member_26')
leaders[0]['rank'].should.equal(1)
leaders[24]['member'].should.equal('member_2')
leaders = self.leaderboard.leaders(2)
len(leaders).should.equal(1)
leaders[0]['member'].should.equal('member_1')
leaders[0]['rank'].should.equal(26)
leaders = self.leaderboard.leaders(1, page_size = 5)
len(leaders).should.equal(5)
def test_leaders_with_optional_member_data(self):
self.__rank_members_in_leaderboard()
leaders = self.leaderboard.leaders(1, with_member_data = True)
len(leaders).should.equal(5)
leaders[0]['member'].should.equal('member_5')
leaders[0]['member_data'].should.be(str({'member_name': 'Leaderboard member 5'}))
def test_leaders_return_type(self):
leaders = self.leaderboard.leaders(1)
type(leaders).should.equal(type([]))
leaders.should.equal([])
def test_ranked_in_list_with_sort_by(self):
self.__rank_members_in_leaderboard(26)
leaders = self.leaderboard.ranked_in_list(['member_25', 'member_1', 'member_15'], sort_by = 'score')
len(leaders).should.equal(3)
leaders[0]['member'].should.equal('member_1')
leaders[1]['member'].should.equal('member_15')
leaders[2]['member'].should.equal('member_25')
leaders = self.leaderboard.ranked_in_list(['member_25', 'member_1', 'member_15'], sort_by = 'rank')
len(leaders).should.be(3)
leaders[0]['member'].should.equal('member_25')
leaders[1]['member'].should.equal('member_15')
leaders[2]['member'].should.equal('member_1')
def test_ranked_in_list(self):
self.__rank_members_in_leaderboard(27)
leaders = self.leaderboard.ranked_in_list(['member_1', 'member_15', 'member_25'])
len(leaders).should.be(3)
leaders[0]['member'].should.equal('member_1')
leaders[1]['member'].should.equal('member_15')
leaders[2]['member'].should.equal('member_25')
def test_ranked_in_list_with_unknown_member(self):
self.__rank_members_in_leaderboard(27)
leaders = self.leaderboard.ranked_in_list(['jones'])
len(leaders).should.be(1)
leaders[0]['member'].should.equal('jones')
leaders[0]['score'].should.be(None)
leaders[0]['rank'].should.be(None)
def test_all_leaders(self):
self.__rank_members_in_leaderboard(26)
leaders = self.leaderboard.all_leaders()
len(leaders).should.be(25)
leaders[0]['member'].should.equal('member_25')
def test_members_from_score_range(self):
self.__rank_members_in_leaderboard(26)
members = self.leaderboard.members_from_score_range(10, 15)
member_15 = {
'member': 'member_15',
'score': 15.0,
'rank': 11
}
members[0].should.eql(member_15)
member_10 = {
'member': 'member_10',
'score': 10.0,
'rank': 16
}
members[5].should.eql(member_10)
def test_members_from_rank_range(self):
self.__rank_members_in_leaderboard(26)
members = self.leaderboard.members_from_rank_range(5, 9)
len(members).should.be(5)
members[0]['member'].should.eql('member_21')
members[0]['score'].should.equal(21.0)
members[4]['member'].should.eql('member_17')
members = self.leaderboard.members_from_rank_range(1, 1)
len(members).should.equal(1)
members[0]['member'].should.eql('member_25')
members = self.leaderboard.members_from_rank_range(1, 26)
len(members).should.equal(25)
members[0]['member'].should.eql('member_25')
members[0]['score'].should.equal(25)
members[24]['member'].should.eql('member_1')
def test_member_at(self):
self.__rank_members_in_leaderboard(51)
self.leaderboard.member_at(1)['rank'].should.equal(1)
self.leaderboard.member_at(1)['score'].should.equal(50.0)
self.leaderboard.member_at(26)['rank'].should.equal(26)
self.leaderboard.member_at(50)['rank'].should.equal(50)
self.leaderboard.member_at(51).should.equal(None)
self.leaderboard.member_at(1, with_member_data = True)['member_data'].should.eql(str({'member_name': 'Leaderboard member 50'}))
def test_around_me(self):
self.__rank_members_in_leaderboard(Leaderboard.DEFAULT_PAGE_SIZE * 3 + 2)
self.leaderboard.total_members().should.be(Leaderboard.DEFAULT_PAGE_SIZE * 3 + 1)
leaders_around_me = self.leaderboard.around_me('member_30')
(len(leaders_around_me) / 2).should.equal(self.leaderboard.page_size / 2)
leaders_around_me = self.leaderboard.around_me('member_1')
len(leaders_around_me).should.equal(self.leaderboard.page_size / 2 + 1)
leaders_around_me = self.leaderboard.around_me('member_76')
(len(leaders_around_me) / 2).should.equal(self.leaderboard.page_size / 2)
def test_members_only(self):
exp = [{'member': 'member_%d' % x} for x in reversed(range(1, 27))]
self.__rank_members_in_leaderboard(27)
leaders = self.leaderboard.leaders(1, members_only=True)
leaders.should.equal(exp[0:25])
leaders = self.leaderboard.leaders(2, members_only=True)
leaders.should.equal(exp[25:26])
members = self.leaderboard.all_leaders(members_only=True)
members.should.equal(exp)
members = self.leaderboard.members_from_score_range(10, 15, members_only=True)
members.should.equal(exp[11:17])
members = self.leaderboard.members_from_rank_range(5, 9, members_only=True)
members.should.equal(exp[4:9])
leaders_around_me = self.leaderboard.around_me('member_25', page_size=3, members_only=True)
leaders_around_me.should.equal(exp[0:3])
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_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 test_rank_member_if(self):
def highscore_check(self, member, current_score, score, member_data, leaderboard_options):
if (current_score is None):
return True
if (score > current_score):
return True
return False
self.leaderboard.total_members().should.equal(0)
self.leaderboard.rank_member_if(highscore_check, 'david', 1337)
self.leaderboard.total_members().should.equal(1)
self.leaderboard.score_for('david').should.equal(1337.0)
self.leaderboard.rank_member_if(highscore_check, 'david', 1336)
self.leaderboard.score_for('david').should.equal(1337.0)
self.leaderboard.rank_member_if(highscore_check, 'david', 1338)
self.leaderboard.score_for('david').should.equal(1338.0)
def test_rank_members(self):
self.leaderboard.total_members().should.equal(0)
self.leaderboard.rank_members(['member_1', 1000, 'member_2', 3000])
self.leaderboard.total_members().should.equal(2)
def test_rank_member_across(self):
self.leaderboard.rank_member_across(['highscores', 'more_highscores'], 'david', 50000, { 'member_name': 'david' })
len(self.leaderboard.leaders_in('highscores', 1)).should.equal(1)
len(self.leaderboard.leaders_in('more_highscores', 1)).should.equal(1)
def test_custom_keys_for_member_score_rank_and_member_data(self):
Leaderboard.MEMBER_KEY = 'member_custom'
Leaderboard.SCORE_KEY = 'score_custom'
Leaderboard.RANK_KEY = 'rank_custom'
Leaderboard.MEMBER_DATA_KEY = 'member_data_custom'
self.__rank_members_in_leaderboard(26)
leaders = self.leaderboard.leaders(1, with_member_data = True)
len(leaders).should.equal(25)
leaders[0]['member_custom'].should.equal('member_25')
leaders[0]['score_custom'].should.equal(25)
leaders[0]['rank_custom'].should.equal(1)
leaders[0]['member_data_custom'].should.equal("{'member_name': 'Leaderboard member 25'}")
def test_can_use_StrictRedis_class_for_connection(self):
lb = Leaderboard('lb1', connection = StrictRedis(db = 0))
lb.rank_member('david', 50.1)
lb.score_for('david').should.equal(50.1)
lb.rank_for('david').should.equal(1)
len(lb.leaders(1)).should.equal(1)
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 __rank_members_in_leaderboard(self, members_to_add = 6):
for index in range(1, members_to_add):
self.leaderboard.rank_member('member_%s' % index, index, { 'member_name': 'Leaderboard member %s' % index })
def test_can_use_StrictRedis_class_for_connection(self):
lb = Leaderboard('lb1', connection = StrictRedis(db = 0))
lb.rank_member('david', 50.1)
lb.score_for('david').should.equal(50.1)
lb.rank_for('david').should.equal(1)
len(lb.leaders(1)).should.equal(1)
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 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_init_sets_page_size_to_default_if_set_to_invalid_value(self):
self.leaderboard = Leaderboard('name', page_size = 0)
self.leaderboard.page_size.should.equal(Leaderboard.DEFAULT_PAGE_SIZE)
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)
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
