def __init__(self):
"""Creates all game objects needed, loads resources, initializes
pygame library and sound mixer, sets display mode, etc."""
self.state = STATE_TITLE
pygame.mixer.pre_init(buffer=SOUND_BUFFER)
pygame.init()
self.clock = Clock()
self.scr = pygame.display.set_mode(SCREEN_SIZE, VID_MODE_FLAGS)
pygame.display.set_caption(WINDOW_CAPTION)
pygame.mouse.set_visible(False)
LoadingScreen(self.scr).draw()
sound_box.init()
self.level = GameLevel()
self.stats = GameStats(self.scr)
self.view_pt = ViewPoint(self.scr)
self.stars = Stars(self.scr, self.view_pt)
self.track = Track(self.scr, self.view_pt)
self.explosions = Explosions(self.scr, self.view_pt)
self.ship = Ship(self.scr, self.view_pt, self.explosions)
self.asteroids = Asteroids(self.scr, self.view_pt, self.explosions,
self.track)
self.title_screen = TitleScreen(self.scr, self.view_pt, self.stars)
self.level_start_screen = LevelStartScreen(self.scr)
self.level_complete_effect = LevelCompleteEffect(self.scr)
self.game_over_effect = GameOverEffect(self.scr)
self.pause_screen = PauseScreen(self.scr)
self.ending_screen = EndingScreen(self.scr)
self._init_title()
def main_loop():
"""
Begins the main loop of Conflict Resolution. This method calls for the title screen loop.
:return:
"""
title = TitleScreen()
title.title_loop()
def main():
t_screen = TitleScreen()
active_id, players, client_socket, deck = t_screen.run()
game = Mongoose(client_socket, deck)
game.setup_game(active_id, players)
game.run()
def run():
pygame.init()
screen = pygame.display.set_mode(SIZE)
caption = pygame.display.set_caption('Lost In Africa')
""""Get the title screen."""
title = TitleScreen(screen)
title.main()
"""Get the menu going."""
Game()
def run_game():
# Initialize pygame, settings, and screen object
pygame.mixer.pre_init(44100, -16, 1, 512)
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height)
)
game_master = GameMaster(screen)
title_screen = TitleScreen(screen)
pygame.display.set_caption("Space Invaders")
# Make the Play button
play_button = Button(screen, "Play")
# Create an instance to store game statistics and create a scoreboard
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
# Make a ship, group of bunkers, a group of bullets, and a group of aliens
ship = Ship(ai_settings, screen)
bunkers = Group()
bullets = Group()
aliens = Group()
lasers = Group()
game_master.last_laser_shot = pygame.time.get_ticks()
game_master.next_laser_shot = game_master.last_laser_shot + random.randrange(250, 2000)
gf.create_bunkers(bunkers, screen)
gf.create_fleet(ai_settings, screen, aliens)
# Start the main loop for the game
while True:
gf.check_events(ai_settings, game_master, screen, stats, sb, play_button, ship, aliens, bullets)
if stats.game_active:
ship.update()
gf.update_bullets(ai_settings, game_master, screen, stats, sb, bunkers, aliens, bullets)
gf.update_aliens(ai_settings, stats, screen, sb, ship, aliens, bullets)
gf.update_lasers(ai_settings, screen, game_master, aliens, lasers, ship, bunkers, stats, sb, bullets)
gf.update_screen(ai_settings, screen, sb, ship, bunkers, aliens, game_master.alien_explosions,
lasers, bullets, game_master.ufo)
game_master.check_ufo_spawn(screen, bullets, stats, sb)
else:
gf.update_title_screen(play_button, title_screen)
def setup(self):
## setup scenes
# 0 = title screen
title_screen = TitleScreen(self)
self.scenes.append(title_screen)
# 1 = game menu
game_menu = GameMenu(self)
self.scenes.append(game_menu)
# 2 = present catch
present_catch = PresentCatch(self)
self.scenes.append(present_catch)
# 3 = present snap
present_snap = PresentSnap(self)
self.scenes.append(present_snap)
# 4 = present match
present_match = PresentMatch(self)
self.scenes.append(present_match)
# setup initial scene
self.setup_current_scene()
def main(self):
self.music.play()
# Screen base
self.screen.fill((0,0,0))
self.screen.blit(self.img_background,self.img_background_rect)
highscores = Highscores()
# Main instances
pavement = Pavement(self.unit)
snake = Snake(self.unit)
foods = Foods(self.unit)
walls = Walls(self.unit)
score = Score(self.unit,self.surface_rect)
nextgold = random.randint(*Constants.TIMERANGE_GOLD) * Constants.FPS # first gold between 30 & 60 seconds
makegold = False
nextwall = random.randint(*Constants.TIMERANGE_WALL) * Constants.FPS # first gold between 30 & 60 seconds
makewall = False
updatestats = True
counter = 0
flag_music = True
flag_pause = False
#MAIN LOOP
while self.running:
time = pygame.time.get_ticks()
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.running = False
elif event.key == pygame.K_m:
flag_music = not flag_music
if flag_music:
self.music.play()
else:
self.music.stop()
elif event.key == pygame.K_1:
pygame.image.save(self.screen, "screenshot.jpg")
elif event.key == pygame.K_SPACE or event.key == pygame.K_p:
flag_pause = True
self.print_text("PAUSE")
while flag_pause:
for event in pygame.event.get():
if event.type==pygame.KEYDOWN:
if event.key==pygame.K_p or event.key == pygame.K_SPACE:
flag_pause = False
else:
# Time to change direction
action = 0
if event.key == pygame.K_UP or event.key == pygame.K_w: action = 1
elif event.key == pygame.K_DOWN or event.key == pygame.K_s: action = 2
elif event.key == pygame.K_LEFT or event.key == pygame.K_a: action = 3
elif event.key == pygame.K_RIGHT or event.key == pygame.K_d: action = 4
if action:
self.sounds.play("move")
snake.action(action)
# Snake movements and pavement reactions
snake.move()
pavement.passage(snake.head)
pavement.make_regrow(snake.tail)
# Snake has eaten?
if foods.check(snake.head):
updatestats = True
snake.grow(Constants.GROW)
score.add_score(foods.score)
self.sounds.play("eat")
# Snake
if walls.check(snake.head):
snake.alive = False
# Snake is dead?
if not snake.alive:
#blood splash (bin on head, little on body)
pavement.bloodsplat(snake.head)
[pavement.bloodsplat(x,1) for x in snake.body if random.randint(0,2)==0]
#redraw all the snake
snake.set_dirty(1)
self.sounds.play("splat")
self.running = False
# Gold generator (After pseudo-random time a golden apple will appear)
nextgold-=1
if nextgold<0:
makegold = True
nextgold = random.randint(*Constants.TIMERANGE_GOLD)*Constants.FPS
# Wall generator (After pseudo-random time a wall will appear)
nextwall-=1
if nextwall<0:
makewall = True
nextwall = random.randint(*Constants.TIMERANGE_WALL)*Constants.FPS
# Foods request to create an apple
# Game has to provide to Foods the list of forbidden blocks
if foods.needapple or makegold or makewall:
forbidden = [[-1,-1]]
forbidden.extend(foods.get_forbidden())
forbidden.extend(snake.get_forbidden())
forbidden.extend(walls.get_forbidden())
# Creates the apples and make the pavement Grass
if foods.needapple:
newpos = foods.make_apple(forbidden)
pavement.make_grass(newpos)
forbidden.extend(newpos)
if makegold:
self.sounds.play('ding')
newpos = foods.make_gold(forbidden)
pavement.make_grass(newpos)
forbidden.extend(newpos)
makegold = False
if makewall:
self.sounds.play('fall')
newpos = walls.make_solid(forbidden)
pavement.make_none(newpos)
forbidden.extend(newpos)
makewall = False
# Foods request pavement update
for pos in foods.refresh:
pavement.passage(pos)
foods.refresh.remove(pos)
del pos
# Updates and draws
pavement.update()
pavement.draw(self.surface)
walls.update()
walls.draw(self.surface)
snake.update()
snake.draw(self.surface)
foods.update()
foods.draw(self.surface)
if updatestats or not counter % Constants.FPS:
score.set_length(snake.length)
score.update()
score.draw(self.screen)
updatestats = False
if not counter % Constants.FPS:
score.add_second()
counter = 0
# Surface on surface... weeee!
self.screen.blit(self.surface,self.surface_rect)
pygame.display.update()
self.clock.tick(self.tick)
counter+=1
#END OF MAIN LOOP
if not snake.alive:
self.print_text("GAME OVER")
if highscores.check(score.score,score.elapse):
current_string = ''
complete = False
inputbox = InputBox(self.unit)
inputbox.rect.centerx = self.screen.get_rect().centerx
inputbox.rect.centery = self.screen.get_rect().centery
inputbox.draw(self.screen)
pygame.display.update()
pygame.event.clear()
redraw = False
while not complete:
event = pygame.event.wait()
if event.type == pygame.QUIT:
return
if event.type != pygame.KEYDOWN:
continue
if event.key == pygame.K_BACKSPACE:
current_string = current_string[:-1]
redraw = True
elif event.key == pygame.K_RETURN:
if len(current_string) == 0:
current_string = 'Mysterious player'
complete = True
elif event.unicode:
if len(current_string) <= 15:
c = ord(event.unicode)
if c >= 32 and c <= 126 or c==8:
current_string += event.unicode
redraw = True
if redraw:
redraw = False
inputbox.set_text(current_string)
inputbox.update()
inputbox.draw(self.screen)
pygame.display.update()
position = highscores.insert(current_string,score.score,score.elapse)
highscores.save()
scored = {'index':position,'scored':True}
else:
counter = Constants.FPS*3 # 3 seconds
pygame.display.update()
while counter > 0:
for event in pygame.event.get():
if event.type == pygame.QUIT or event.type == pygame.KEYDOWN:
counter = 0
self.clock.tick(self.tick)
pygame.display.update()
counter-=1
scored = {'elapse':score.elapse,'score':score.score,'scored':False}
ts = TitleScreen(self.screen,self.unit,self.preferences)
ts.highscores(scored)
del ts
self.music.stop()
return
u.set_score_spots()
u.set_score_indices()
u.set_player_score_sprites()
u.assign_x_pos_to_player_score_sprites()
u.set_score_values_x()
################################################################################
# Problem setup
#Problems
question = c.NEW_QUESTION
problem = s.Problem()
################################################################################
# Menu screens setup
title = TitleScreen()
options = OptionsScreen()
################################################################################
# Game event loop
@c.GAME_WINDOW.event
def on_key_release(symbol, modifiers):
# options screen
if u.is_options_screen():
if symbol == key.UP:
options.selector_up()
elif symbol == key.DOWN:
options.selector_down()
elif symbol == key.B:
class SpaceRacer():
"""Represents the game itself"""
def __init__(self):
"""Creates all game objects needed, loads resources, initializes
pygame library and sound mixer, sets display mode, etc."""
self.state = STATE_TITLE
pygame.mixer.pre_init(buffer=SOUND_BUFFER)
pygame.init()
self.clock = Clock()
self.scr = pygame.display.set_mode(SCREEN_SIZE, VID_MODE_FLAGS)
pygame.display.set_caption(WINDOW_CAPTION)
pygame.mouse.set_visible(False)
LoadingScreen(self.scr).draw()
sound_box.init()
self.level = GameLevel()
self.stats = GameStats(self.scr)
self.view_pt = ViewPoint(self.scr)
self.stars = Stars(self.scr, self.view_pt)
self.track = Track(self.scr, self.view_pt)
self.explosions = Explosions(self.scr, self.view_pt)
self.ship = Ship(self.scr, self.view_pt, self.explosions)
self.asteroids = Asteroids(self.scr, self.view_pt, self.explosions,
self.track)
self.title_screen = TitleScreen(self.scr, self.view_pt, self.stars)
self.level_start_screen = LevelStartScreen(self.scr)
self.level_complete_effect = LevelCompleteEffect(self.scr)
self.game_over_effect = GameOverEffect(self.scr)
self.pause_screen = PauseScreen(self.scr)
self.ending_screen = EndingScreen(self.scr)
self._init_title()
def run(self):
"""The only public method just runs the game. It starts infinite
loop where game objects are updated, drawn and interacts with
each other. Also system events are processed."""
while True:
self.clock.tick(FRAMERATE)
# print(f"FPS: {round(self.clock.get_fps(), 2)}")
self._process_events()
self._update_objects()
self._interact_objects()
self._draw_objects()
def _init_title(self):
self.state = STATE_TITLE
self.stats.reset()
self.level.restart()
self.title_screen.restart()
self.title_screen.play_music()
def _init_level_starting(self):
self.state = STATE_LEVEL_STARTING
self.level_start_screen.set_level_number(self.level.get_level())
self.level_start_screen.set_subtitle_text(self.level.get_description())
self.level_start_screen.restart()
def _init_level_playing(self):
self.state = STATE_LEVEL_PLAYING
self.level.play_music()
self.view_pt.reset()
self.stars.respawn()
self.track.set_tile_map(self.level.get_map())
top_limit = (self.track.get_track_height() -
self.scr.get_rect().height / 2)
bottom_limit = self.scr.get_rect().height / 2
self.view_pt.set_limits(top=top_limit, bottom=bottom_limit)
self.explosions.items.empty()
self.asteroids.set_spawn_density(self.level.get_asteroids_density())
self.asteroids.respawn(self.level.get_asteroid_spawns())
self.ship.set_speed(self.level.get_ship_speed())
self.ship.set_acceleration(self.level.get_ship_acceleration())
self.ship.restore((0, 0), reset_control=True)
def _init_level_finishing(self):
self.state = STATE_LEVEL_FINISHING
self.stats.increase_score(LEVEL_COMPLETE_PTS)
self.level_complete_effect.restart()
self.ship.set_autopilot()
pygame.mixer.music.fadeout(MUSIC_FADEOUT)
def _init_game_over(self):
self.state = STATE_GAME_OVER
self.game_over_effect.restart()
pygame.mixer.music.fadeout(MUSIC_FADEOUT)
def _init_ending(self):
self.state = STATE_ENDING
self.ending_screen.set_score(self.stats.score)
self.ending_screen.restart()
self.ending_screen.play_music()
def _init_pause(self):
self.state = STATE_PAUSE
self.pause_screen.refresh_background()
pygame.mixer.music.pause()
def _ship_control(self, key, control_status):
"""Returns True if the key was a ship direction control key."""
key_processed = True
if key == pygame.K_UP:
self.ship.moving_up = control_status
elif key == pygame.K_DOWN:
self.ship.moving_down = control_status
elif key == pygame.K_LEFT:
self.ship.moving_left = control_status
elif key == pygame.K_RIGHT:
self.ship.moving_right = control_status
elif key == pygame.K_SPACE:
self.ship.shooting = control_status
else:
key_processed = False
return key_processed
def _process_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
if self.state == STATE_TITLE:
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
sys.exit()
elif event.key == pygame.K_RETURN:
pygame.mixer.music.fadeout(MUSIC_FADEOUT)
self._init_level_starting()
elif self.state == STATE_PAUSE:
if event.type == pygame.KEYDOWN:
if event.key in (pygame.K_ESCAPE, pygame.K_PAUSE):
self.state = STATE_LEVEL_PLAYING
pygame.mixer.music.unpause()
elif event.key == pygame.K_RETURN:
sys.exit()
elif self.state == STATE_LEVEL_PLAYING:
if event.type == pygame.KEYDOWN:
if event.key in (pygame.K_ESCAPE, pygame.K_PAUSE):
self._init_pause()
else:
self._ship_control(event.key, control_status=True)
elif event.type == pygame.KEYUP:
self._ship_control(event.key, control_status=False)
if self.state == STATE_ENDING:
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
sys.exit()
elif event.key == pygame.K_RETURN:
self._init_title()
def _update_objects(self):
if self.state == STATE_TITLE:
self.title_screen.update()
if self.state == STATE_LEVEL_STARTING:
self.level_start_screen.update()
if self.state in (STATE_LEVEL_PLAYING, STATE_LEVEL_FINISHING,
STATE_GAME_OVER):
self.view_pt.update()
self.stars.update()
self.track.update()
self.asteroids.update()
self.ship.update()
self.explosions.update()
if self.state == STATE_LEVEL_FINISHING:
self.level_complete_effect.update()
if self.state == STATE_GAME_OVER:
self.game_over_effect.update()
if self.state == STATE_ENDING:
self.ending_screen.update()
def _crossed_finish_line(self):
finish_line_y = (self.track.get_track_height() -
self.scr.get_rect().height / 2)
return self.ship.y > finish_line_y
def _interact_objects(self):
if self.state == STATE_LEVEL_STARTING:
if self.level_start_screen.finished():
self._init_level_playing()
elif self.state == STATE_LEVEL_PLAYING:
if self.stats.game_over():
self._init_game_over()
elif self._crossed_finish_line():
self._init_level_finishing()
elif self.ship.status == SHIP_STATUS_NORMAL:
self._check_collisions()
elif self.ship.status == SHIP_STATUS_INACTIVE:
self._ship_restore()
elif self.state == STATE_LEVEL_FINISHING:
if self.level_complete_effect.finished():
if self.level.last_level():
self._init_ending()
else:
self.level.next_level()
self._init_level_starting()
elif self.state == STATE_GAME_OVER:
if self.game_over_effect.finished():
self._init_title()
def _draw_objects(self):
if self.state == STATE_TITLE:
self.title_screen.draw()
if self.state == STATE_PAUSE:
self.pause_screen.draw()
if self.state == STATE_LEVEL_STARTING:
self.level_start_screen.draw()
if self.state in (STATE_LEVEL_PLAYING, STATE_LEVEL_FINISHING,
STATE_GAME_OVER):
self.scr.blit(self.level.get_background(), (0, 0))
self.stars.draw()
self.track.draw()
self.asteroids.draw()
self.ship.draw()
self.explosions.draw()
self.stats.draw()
if self.state == STATE_LEVEL_FINISHING:
self.level_complete_effect.draw()
if self.state == STATE_GAME_OVER:
self.game_over_effect.draw()
if self.state == STATE_ENDING:
self.ending_screen.draw()
pygame.display.flip()
def _ship_explode(self, collide_point=None):
"""collide_point is a tuple of absolute coordinates: (x, y)"""
self.stats.lost_life()
self.ship.explode(collide_point)
def _ship_restore(self):
restore_x, restore_y = self.ship.get_center()
borders = self.track.get_track_borders(restore_y)
if borders:
restore_x = mean(borders)
if self.ship.restore((restore_x, restore_y)):
self.asteroids.explode_nearest(self.ship.get_center())
def _check_ship_penalty(self):
borders = self.track.get_track_borders(self.ship.get_center()[1])
if borders:
left = self.ship.x
right = left + self.ship.rect.width
if right < borders[0] or left > borders[1]:
self._ship_explode()
return True
return False
def _check_collisions(self):
collide_point = self.track.collidemask(self.ship.mask, self.ship.rect)
if collide_point:
self._ship_explode(collide_point)
return True
collide_point = self.asteroids.collidemask(self.ship.mask,
self.ship.rect,
explode=True)
if collide_point:
self._ship_explode(collide_point)
return True
if self.ship.laser.shooting():
if self.asteroids.collidemask(self.ship.laser.mask,
self.ship.laser.rect,
explode=True):
self.stats.increase_score(ASTEROID_HIT_PTS)
return self._check_ship_penalty()
def title(self):
""" Display the title screen. """
ts = TitleScreen(self.screen)
ts.main()
self.choice = ts.choice
return ts.running
def next_scene(self):
return TitleScreen(self.game)
def main(self):
self.music.play()
# Screen base
self.screen.fill((0, 0, 0))
self.screen.blit(self.img_background, self.img_background_rect)
highscores = Highscores()
# Main instances
pavement = Pavement(self.unit)
snake = Snake(self.unit)
foods = Foods(self.unit)
walls = Walls(self.unit)
score = Score(self.unit, self.surface_rect)
nextgold = random.randint(
*Constants.TIMERANGE_GOLD
) * Constants.FPS # first gold between 30 & 60 seconds
makegold = False
nextwall = random.randint(
*Constants.TIMERANGE_WALL
) * Constants.FPS # first gold between 30 & 60 seconds
makewall = False
updatestats = True
counter = 0
flag_music = True
flag_pause = False
#MAIN LOOP
while self.running:
time = pygame.time.get_ticks()
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.running = False
elif event.key == pygame.K_m:
flag_music = not flag_music
if flag_music:
self.music.play()
else:
self.music.stop()
elif event.key == pygame.K_1:
pygame.image.save(self.screen, "screenshot.jpg")
elif event.key == pygame.K_SPACE or event.key == pygame.K_p:
flag_pause = True
self.print_text("PAUSE")
while flag_pause:
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_p or event.key == pygame.K_SPACE:
flag_pause = False
else:
# Time to change direction
action = 0
if event.key == pygame.K_UP or event.key == pygame.K_w:
action = 1
elif event.key == pygame.K_DOWN or event.key == pygame.K_s:
action = 2
elif event.key == pygame.K_LEFT or event.key == pygame.K_a:
action = 3
elif event.key == pygame.K_RIGHT or event.key == pygame.K_d:
action = 4
if action:
self.sounds.play("move")
snake.action(action)
# Snake movements and pavement reactions
snake.move()
pavement.passage(snake.head)
pavement.make_regrow(snake.tail)
# Snake has eaten?
if foods.check(snake.head):
updatestats = True
snake.grow(Constants.GROW)
score.add_score(foods.score)
self.sounds.play("eat")
# Snake
if walls.check(snake.head):
snake.alive = False
# Snake is dead?
if not snake.alive:
#blood splash (bin on head, little on body)
pavement.bloodsplat(snake.head)
[
pavement.bloodsplat(x, 1) for x in snake.body
if random.randint(0, 2) == 0
]
#redraw all the snake
snake.set_dirty(1)
self.sounds.play("splat")
self.running = False
# Gold generator (After pseudo-random time a golden apple will appear)
nextgold -= 1
if nextgold < 0:
makegold = True
nextgold = random.randint(
*Constants.TIMERANGE_GOLD) * Constants.FPS
# Wall generator (After pseudo-random time a wall will appear)
nextwall -= 1
if nextwall < 0:
makewall = True
nextwall = random.randint(
*Constants.TIMERANGE_WALL) * Constants.FPS
# Foods request to create an apple
# Game has to provide to Foods the list of forbidden blocks
if foods.needapple or makegold or makewall:
forbidden = [[-1, -1]]
forbidden.extend(foods.get_forbidden())
forbidden.extend(snake.get_forbidden())
forbidden.extend(walls.get_forbidden())
# Creates the apples and make the pavement Grass
if foods.needapple:
newpos = foods.make_apple(forbidden)
pavement.make_grass(newpos)
forbidden.extend(newpos)
if makegold:
self.sounds.play('ding')
newpos = foods.make_gold(forbidden)
pavement.make_grass(newpos)
forbidden.extend(newpos)
makegold = False
if makewall:
self.sounds.play('fall')
newpos = walls.make_solid(forbidden)
pavement.make_none(newpos)
forbidden.extend(newpos)
makewall = False
# Foods request pavement update
for pos in foods.refresh:
pavement.passage(pos)
foods.refresh.remove(pos)
del pos
# Updates and draws
pavement.update()
pavement.draw(self.surface)
walls.update()
walls.draw(self.surface)
snake.update()
snake.draw(self.surface)
foods.update()
foods.draw(self.surface)
if updatestats or not counter % Constants.FPS:
score.set_length(snake.length)
score.update()
score.draw(self.screen)
updatestats = False
if not counter % Constants.FPS:
score.add_second()
counter = 0
# Surface on surface... weeee!
self.screen.blit(self.surface, self.surface_rect)
pygame.display.update()
self.clock.tick(self.tick)
counter += 1
#END OF MAIN LOOP
if not snake.alive:
self.print_text("GAME OVER")
if highscores.check(score.score, score.elapse):
current_string = ''
complete = False
inputbox = InputBox(self.unit)
inputbox.rect.centerx = self.screen.get_rect().centerx
inputbox.rect.centery = self.screen.get_rect().centery
inputbox.draw(self.screen)
pygame.display.update()
pygame.event.clear()
redraw = False
while not complete:
event = pygame.event.wait()
if event.type == pygame.QUIT:
return
if event.type != pygame.KEYDOWN:
continue
if event.key == pygame.K_BACKSPACE:
current_string = current_string[:-1]
redraw = True
elif event.key == pygame.K_RETURN:
if len(current_string) == 0:
current_string = 'Mysterious player'
complete = True
elif event.unicode:
if len(current_string) <= 15:
c = ord(event.unicode)
if c >= 32 and c <= 126 or c == 8:
current_string += event.unicode
redraw = True
if redraw:
redraw = False
inputbox.set_text(current_string)
inputbox.update()
inputbox.draw(self.screen)
pygame.display.update()
position = highscores.insert(current_string, score.score,
score.elapse)
highscores.save()
scored = {'index': position, 'scored': True}
else:
counter = Constants.FPS * 3 # 3 seconds
pygame.display.update()
while counter > 0:
for event in pygame.event.get():
if event.type == pygame.QUIT or event.type == pygame.KEYDOWN:
counter = 0
self.clock.tick(self.tick)
pygame.display.update()
counter -= 1
scored = {
'elapse': score.elapse,
'score': score.score,
'scored': False
}
ts = TitleScreen(self.screen, self.unit, self.preferences)
ts.highscores(scored)
del ts
self.music.stop()
return
def title(self):
""" Display the title screen. """
ts = TitleScreen(self.screen)
ts.main()
self.choice = ts.choice
return ts.running
def next_scene(self):
if self.refresh:
return HighScores(self.game)
return TitleScreen(self.game)
def title_screen(self):
self.go_mode()
ts = TitleScreen(self.screen, self.unit, self.preferences)
ts.main()
return ts.running
