def __init__(self):
pygame.init()
self.background_sound = Sound()
pygame.key.set_repeat(50, 50)
size = [SCREEN_WIDTH, SCREEN_HEIGHT]
self.screen = pygame.display.set_mode(size)
pygame.display.set_caption(TITLE)
self.clock = pygame.time.Clock()
self.font_name = pygame.font.match_font(FONT)
self.running = True
self.isover = False
self.gameispaused = False
self.levels = {
1: Level_01,
2: Level_02,
3: Level_03,
4: Level_04,
5: Level_05,
6: Level_06,
7: Level_07,
8: Level_08,
9: Level_09,
10: Level_10
}
self.show_start_screen()
def func(state, index, locus):
term = state[index]
term_value = term.get_at(locus)
new_value = None
add_part = False
# 1.1.54 ādeḥ parasya
if adi:
try:
new_value = sthani.value + term_value[1:]
except AttributeError:
new_value = sthani + term_value[1:]
elif isinstance(sthani, basestring):
# 1.1.52 alo 'ntyasya
# 1.1.55 anekālśit sarvasya
if len(sthani) <= 1:
new_value = term_value[:-1] + sthani
else:
new_value = sthani
elif not hasattr(sthani, 'value'):
# 1.1.50 sthāne 'ntaratamaḥ
last = Sound(term.antya).closest(sthani)
new_value = term_value[:-1] + last
# 1.1.47 mid aco 'ntyāt paraḥ
elif 'mit' in sthani.samjna:
ac = Sounds('ac')
for i, L in enumerate(reversed(term_value)):
if L in ac:
break
new_value = term_value[:-i] + sthani.value + term_value[-i:]
add_part = True
# 1.1.46 ādyantau ṭakitau
elif 'kit' in sthani.samjna:
new_value = term_value + sthani.value
add_part = True
elif 'wit' in sthani.samjna:
new_value = sthani.value + term_value
add_part = True
# 1.1.52 alo 'ntyasya
# 1.1.53 ṅic ca
elif len(sthani.value) == 1 or 'Nit' in sthani.samjna:
new_value = term_value[:-1] + sthani.value
# 1.1.55 anekālśit sarvasya
elif 'S' in sthani.it or len(sthani.value) > 1:
new_value = sthani.value
if new_value is not None:
new_term = term.set_at(locus, new_value)
if add_part:
new_term = new_term.add_part(sthani.raw)
return state.swap(index, new_term)
raise NotImplementedError(sthani)
def func(value):
letters = list(value)
for i, L in enumerate(letters):
if L in target:
letters[i] = Sound(L).closest(result)
# 1.1.51 ur aṇ raparaḥ
if L in 'fF' and letters[i] in Sounds('aR'):
letters[i] += 'r'
break
return ''.join(letters)
def on_create(self):
"""Called when an object is created"""
self.sound_player = Sound("FOREST")
self.set_background()
self.set_hero()
self.set_blocks()
self.set_enemies()
self.set_coins()
self.set_healing()
self.set_checkpoints()
self.set_spritegroups()
def __init__(self, parent, name='Anonymus'):
Location.__init__(self, parent, background)
pygame.key.set_repeat(10)
pygame.mouse.set_visible(mouse_enabled)
self.sound = Sound()
self.doodle = Doodle(name)
self.allsprites = pygame.sprite.Group()
self.allsprites.add(self.doodle)
for i in range(0, platform_count):
self.allsprites.add(self.randomPlatform(False))
for platform in self.allsprites:
if isinstance(platform, Platform) and platform.spring != None:
self.allsprites.add(platform.spring)
self.score = Score(50, 25, self.doodle.name, 45, (0, 0, 0))
self.allsprites.add(self.score)
self.window.blit(self.background, (0, 0))
def _random(self):
# We need to create a first instance of the sound to get its duration
self._sound = Sound(self.get_single_path(), self.volume)
sound_duration = self._sound.get_duration()
while not self.stop_event.is_set():
r = random.random()
if r <= self.random:
self._play_sound()
self.stop_event.wait(sound_duration + 1)
logger.debug('[%s] Stopping rand', self.path)
def load_sounds(self, score_cutoff=None, base_cost_cutoff=None):
self.sounds = OrderedDict()
sound_list = self.db.execute("SELECT * from sounds order by votes desc, name asc")
for dbsound in sound_list:
sound = Sound(
name=dbsound["name"],
file_name=dbsound["path"],
votes=dbsound["votes"],
cost=dbsound["cost"],
base_cost=dbsound["base_cost"],
downvotes=dbsound["downvotes"],
date_added=dt.datetime.fromtimestamp(dbsound["date_added"]),
sound_player=self.sound_player,
)
if score_cutoff and sound.get_score() < score_cutoff:
continue
if base_cost_cutoff and sound.base_cost > base_cost_cutoff:
continue
self.sounds[sound.name] = sound
return self.sounds
def __init__(self, caption=None, icon=None):
super().__init__(caption, icon)
self.snake = Snake()
self.food = Food()
self.food_consumed_sound = Sound("consumed.wav")
self.death_sound = Sound("death.mp3")
self.bg_sound = Sound("background.mp3")
self.background = Background()
self.play = False
self.score = 0
self.game_over = False
self.delay = 3
self.snake_die_time = None
def samprasarana(value):
rev_letters = list(reversed(value))
found = False
for i, L in enumerate(rev_letters):
# 1.1.45 ig yaNaH saMprasAraNAm
# TODO: enforce short vowels automatically
if L in Sounds('yaR'):
rev_letters[i] = Sound(L).closest('ifxu')
found = True
break
if not found:
return value
# 6.4.108 saMprasAraNAc ca
try:
L = rev_letters[i - 1]
if L in Sounds('ac'):
rev_letters[i - 1] = ''
except IndexError:
pass
return ''.join(reversed(rev_letters))
def ac_sandhi(x, y):
"""Apply the rules of ac sandhi to `x` as followed by `y`.
These rules are from 6.1. A rule is part of ac sandhi iff the first
letter is a vowel.
:param x: the first letter.
:param y: the second letter.
"""
# 6.1.97 ato guNe
if x == 'a' and y in Sounds('at eN'):
x = ''
# 6.1.101 akaH savarNe dIrghaH
elif Sound(x).savarna(y):
x = ''
y = dirgha(y)
# 6.1.77 iko yaN aci
elif x in Sounds('ik') and y in Sounds('ac'):
x = iko_yan_aci(x)
# 6.1.78 eco 'yavAyAvaH
elif x in Sounds('ec') and y in Sounds('ac'):
converter = dict(zip('eEoO', 'ay Ay av Av'.split()))
x = converter[x]
elif x in 'aA' and y in Sounds('ic'):
x = ''
# 6.1.87 Ad guNaH
# 6.1.88 vRddhir eci
y = vrddhi(y) if y in Sounds('ec') else guna(y)
return x, y
class GameLocation(Location):
def __init__(self, parent, name='Anonymus'):
Location.__init__(self, parent, background)
pygame.key.set_repeat(10)
pygame.mouse.set_visible(mouse_enabled)
self.sound = Sound()
self.doodle = Doodle(name)
self.allsprites = pygame.sprite.Group()
self.allsprites.add(self.doodle)
for i in range(0, platform_count):
self.allsprites.add(self.randomPlatform(False))
for platform in self.allsprites:
if isinstance(platform, Platform) and platform.spring != None:
self.allsprites.add(platform.spring)
self.score = Score(50, 25, self.doodle.name, 45, (0, 0, 0))
self.allsprites.add(self.score)
self.window.blit(self.background, (0, 0))
def randomPlatform(self, top=True):
x = random.randint(0, screen_width - platform_width)
bad_y = []
for spr in self.allsprites:
bad_y.append((spr.y - platform_y_padding, spr.y + platform_y_padding + spr.rect.height))
good = 0
while not good:
if top:
y = random.randint(-100, 100)
else:
y = random.randint(0, screen_height)
good = 1
for bad_y_item in bad_y:
if bad_y_item[0] <= y <= bad_y_item[1]:
good = 0
break
dig = random.randint(0, 100)
if dig < 35:
return MovingPlatform(x, y)
elif 35 <= dig < 50:
return CrashingPlatform(x, y)
else:
return Platform(x, y)
def draw(self):
if self.doodle.alive:
self.allsprites.clear(self.window, self.background)
mousePos = pygame.mouse.get_pos()
self.doodle.inc_y_speed(-gravitation)
if mouse_enabled:
self.doodle.set_x(mousePos[0])
else:
if transparent_walls:
if self.doodle.x < 0:
self.doodle.set_x(screen_width)
elif self.doodle.x > screen_width:
self.doodle.set_x(0)
self.doodle.move_y(-self.doodle.ySpeed)
for spr in self.allsprites:
if isinstance(spr, Spring) and self.doodle.get_legs_rect().colliderect(spr.get_top_surface()) and self.doodle.ySpeed <= 0:
self.sound.play_spring_sound()
spr.compress()
self.doodle.ySpeed = spring_speed
if isinstance(spr, Platform) and self.doodle.get_legs_rect().colliderect(spr.get_surface_rect()) and self.doodle.ySpeed <= 0:
if isinstance(spr, CrashingPlatform):
if not spr.is_playing:
spr.is_playing = True
self.sound.play_crashing_sound()
spr.crash()
break
self.sound.play_jump_sound()
self.doodle.ySpeed = jump_speed
if isinstance(spr, Platform):
if spr.y >= screen_height:
self.allsprites.remove(spr)
platform = self.randomPlatform()
self.allsprites.add(platform)
if isinstance(platform, Platform) and platform.spring != None:
self.allsprites.add(platform.spring)
if isinstance(spr,MovingPlatform) or (isinstance(spr,CrashingPlatform) and spr.crashed == 1):
spr.move()
if self.doodle.y < horizont:
self.doodle.inc_score(self.doodle.ySpeed)
for spr in self.allsprites:
if not isinstance(spr, Score):
spr.move_y(self.doodle.ySpeed)
self.allsprites.draw(self.window)
self.score.set_text(" %s" % (int(self.doodle.score/10)))
# self.window.blit()
else:
self.sound.play_falling_sound()
# self.parent.location = GameLocation(self.parent, self.doodle.name)
# self.parent.location = StartLocation(self.parent)
self.parent.location = EndLocation(self.parent, int(self.doodle.score/10))
def event(self, event):
if event.type == KEYDOWN:
if event.key == K_LEFT:
self.doodle.set_x(self.doodle.x - 10)
elif event.key == K_RIGHT:
self.doodle.set_x(self.doodle.x + 10)
def asiddha_helper(state):
"""Chapter 8.2 of the Ashtadhyayi starts the 'asiddha' section of
the text:
8.2.1 pUrvatrAsiddham
The asiddha section lasts until the end of the text, and for that
reason, it is often called the tripAdI ("having three pAdas").
The rules in the tripAdI are treated as not having taken effect
('asiddha') as far as the prior rules are concerned. This is an
abstract notion, but practically it means that these are the last
rules we apply in a derivation.
:param state:
"""
had_rs = False
editor = SoundEditor(state)
for c in editor:
p = c.prev
n = c.next
n2 = n.next
w, x, y, z = (p.value, c.value, n.value, n2.value)
# 8.2.29 skoH saMyogAdyor ante ca
# TODO: pada end
if x in 'sk' and y in Sounds('hal') and z in Sounds('Jal'):
x = '_'
if y in Sounds('Jal'):
# 8.2.30 coH kuH
cu = Sounds('cu')
if x in cu and y in Sounds('Jal') and y not in cu:
x = Sound(x).closest(Sounds('ku'))
# 8.2.31 ho DhaH
elif x == 'h':
x = 'Q'
# 8.2.36 vrazca-bhrasja-sRja-mRja-yaja-rAja-bhrAjacCazAM SaH
roots = {'vraSc', 'Brasj', 'sfj', 'mfj', 'yaj', 'rAj', 'BrAj'}
if c.last and (c.term.value in roots or c.term.antya in 'SC'):
x = 'z'
# 8.2.40 (TODO: not dhA)
if w in Sounds('Jaz') and x in 'tT':
x = 'D'
elif x == 'D' and y in 'tT':
continue
# 8.2.41 SaDhoH kaH si
elif x in 'zQ' and y == 's':
x = 'k'
# 8.2.41 SaDhoH kaH si
if x in 'zQ' and y == 's':
x = 'k'
# 8.3.23 mo 'nusvAraH
# elif x == 'm' and y in Sounds('hal'):
# x = 'M'
# 8.3.24 naz cApadAntasya jhali
elif x in 'mn' and y in Sounds('Jal'):
x = 'M'
# 8.3.59 AdezapratyayayoH
if w in Sounds('iN ku'):
if not c.last and x == 's' and (c.term.raw[0] == 'z'
or 'pratyaya' in c.term.samjna):
x = 'z'
# 8.3.78 iNaH SIdhvaMluGliTAM dho 'GgAt
# 8.3.79 vibhASeTaH
# TODO: SIdhvam, luG
if (x == 'D'
and w in Pratyahara('iR', second_R=True)
and c.first # not triggered by iT
and 'li~w' in c.term.lakshana):
x = 'Q'
# 8.4.1 raSAbhyAM no NaH samAnapade
# 8.4.2 aTkupvAGnuMvyavAye 'pi
# According to commentary, 8.4.1 also applies to 'f' and 'F'.
# TODO: AG, num
if x in 'rzfF':
had_rs = True
elif x == 'n' and had_rs and p.term.value != 'kzuB':
x = 'R'
had_rs = False
elif x not in Sounds('aw ku pu'):
had_rs = False
stu = Sounds('s tu')
if x in stu:
# 8.4.40 stoH zcunA zcuH
# 8.4.44 zAt (na)
scu = Sounds('S cu')
if w == 'S':
pass
elif w in scu or y in scu:
x = Sound(x).closest(scu)
# 8.4.41 STunA STuH
zwu = Sounds('z wu')
if w in zwu or y in zwu:
x = Sound(x).closest(zwu)
if x in Sounds('Jal'):
x_ = x
# 8.4.53 jhalAM jaz jhazi
if y in Sounds('JaS'):
x = Sound(x_).closest(Sounds('jaS'))
# 8.4.54 abhyAse car ca
if 'abhyasa' in c.term.samjna and c.first:
x = Sound(x_).closest(Sounds('car jaS'))
# 8.4.55 khari ca
if y in Sounds('Kar'):
x = Sound(x_).closest(Sounds('car'))
# 8.4.58 anusvArasya yayi parasavarNaH
if x == 'M' and y in Sounds('yay'):
x = Sound(x).closest(Sound(y).savarna_set)
c.value = x if x != '_' else ''
yield editor.join()
def __init__(self):
pygame.init()
self.__GameModel = GameModel(self)
self.__GameView = GameView(self, self.__GameModel)
self.__sounds = Sound()
class GameController:
def __init__(self):
pygame.init()
self.__GameModel = GameModel(self)
self.__GameView = GameView(self, self.__GameModel)
self.__sounds = Sound()
def start_screen(self):
self.__sounds.princess_hit_sound()
self.__sounds.background_sound()
waiting = True
while waiting:
self.__GameView.draw_start_screen()
self.start_events()
def game_over_screen(self):
self.__sounds.orc_sound()
waiting = True
new_highscore = False
if self.__GameModel.score > self.__GameModel.highscore.data:
self.__GameModel.highscore.new_hs(self.__GameModel.score)
new_highscore = True
self.__GameView.draw_game_over(new_highscore)
#time.sleep para fazer com que a tela não desapareça mto rápido
#um draw antes pra paralisar na tela correta
time.sleep(1.1)
while waiting:
self.__GameView.draw_game_over(new_highscore)
for sprite in self.__GameModel.all_sprites:
sprite.kill()
self.start_events()
def win_screen(self):
waiting = True
new_highscore = False
if self.__GameModel.score > self.__GameModel.highscore.data:
self.__GameModel.highscore.new_hs(self.__GameModel.score)
new_highscore = True
self.__GameView.draw_win_screen(new_highscore)
#time.sleep para fazer com que a tela não desapareça mto rápido
#um draw antes pra paralisar na tela correta
time.sleep(1.1)
while waiting:
self.__GameView.draw_win_screen(new_highscore)
for sprite in self.__GameModel.all_sprites:
sprite.kill()
self.start_events()
def start_game(self):
self.__GameModel.score = 0
self.__GameModel.load_map()
playing = True
while playing:
self.game_events()
self.__GameModel.update_positions()
self.__GameView.draw_game()
enemy_hits = pygame.sprite.spritecollide(
self.__GameModel.princess, self.__GameModel.enemies, False,
pygame.sprite.collide_mask)
door_found = pygame.sprite.collide_rect(self.__GameModel.princess,
self.__GameModel.door_tile)
if enemy_hits or door_found:
if enemy_hits:
self.game_over_screen()
if door_found:
self.win_screen()
def game_events(self):
# Eventos do jogo
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
def start_events(self):
#self.__sounds.background_sound()
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
if event.type == pygame.KEYUP:
self.start_game()
class Game(Foundation):
"""
A class that is responsible for running the game and handling all the
game related activities.
"""
def __init__(self, caption=None, icon=None):
super().__init__(caption, icon)
self.snake = Snake()
self.food = Food()
self.food_consumed_sound = Sound("consumed.wav")
self.death_sound = Sound("death.mp3")
self.bg_sound = Sound("background.mp3")
self.background = Background()
self.play = False
self.score = 0
self.game_over = False
self.delay = 3
self.snake_die_time = None
# self.bg = pygame.Surface((440, 440))
def draw_grid(self):
border = 0 # Settings.BLOCK_SIZE * 2 - 1
h = Settings.SCREEN_HEIGHT - border
w = Settings.SCREEN_WIDTH - border
for row in range(border, h, Settings.BLOCK_SIZE):
pygame.draw.line(self.screen, Colors.GREY.value, (border, row),
(w, row))
for col in range(border, w, Settings.BLOCK_SIZE):
pygame.draw.line(self.screen, Colors.GREY.value, (col, border),
(col, h))
def play_game(self, key_pressed):
"""
Start game on pressing the space bar key.
:param key_pressed:
:return: None
"""
if key_pressed == K_SPACE and not self.play:
self.snake.head_direction = 'Left'
self.play = True
# Setup the background sound but pause it by default
self.bg_sound.play_sound(loops=-1, vol=0.01)
self.bg_sound.pause_sound()
self.background.create_background()
def quit_game(self, key_pressed):
"""
Quit game on pressing the escape key.
:return: None
"""
if key_pressed == K_ESCAPE:
self.running = False
def render_score(self):
text = "Score: " + str(self.score)
score_surf = self.font.render(text, True, Colors.GREY.value)
score_surf.set_alpha(127)
self.screen.blit(score_surf, (0, 0))
def game_over_render_delay(self):
current_time = pygame.time.get_ticks()
if current_time >= self.snake_die_time + self.delay*1000:
self.running = False
def render_game_over(self):
text = "Game Over!"
game_over_surf = self.font.render(text, True, Colors.RED.value)
surf_rect = game_over_surf.get_rect(center=self.screen.get_rect().center)
self.screen.blit(game_over_surf, surf_rect)
self.game_over_render_delay()
def snake_hit_food(self):
head = self.snake.blocks_pos[0]
if head == self.food.position:
self.food_consumed_sound.play_sound(vol=0.1)
self.snake.increase_snake_length()
self.score += 1
return True
return False
def snake_hit_itself(self):
head = self.snake.blocks_pos[0]
if head in self.snake.blocks_pos[1:]:
self.death_sound.play_sound(vol=0.3)
pygame.time.delay(1000)
# self.running = False
self.play = False
self.game_over = True
self.snake_die_time = pygame.time.get_ticks()
return True
return False
def update_game_state(self):
"""
Update states of the game objects.
:return: None
"""
if self.play:
self.background.update()
hit_food = self.snake_hit_food()
hit_itself = self.snake_hit_itself()
if not hit_food and not hit_itself:
self.snake.update()
# Update food position until food is not one of the snake block
if hit_food and not hit_itself:
while True:
self.food.update()
if self.food.position not in self.snake.blocks_pos:
break
def render_objects(self):
"""
Draw all the game objects to the main game window/screen
:return: None
"""
self.screen.fill(Settings.BG_COLOR) # Not needed if creating tiles.
if self.play:
# self.draw_grid()
self.background.render(self.screen)
self.snake.render(self.screen)
self.food.render(self.screen)
self.render_score()
elif self.game_over:
self.render_game_over()
# Todo: Dirty rectangles
pygame.display.flip() # Updates the entire screen
def handle_keydown_events(self, event):
"""
Handle all key press events.
:param event: Event requested by user
:return: None
"""
self.play_game(event.key)
self.quit_game(event.key)
if self.play:
if event.key == K_RIGHT and self.snake.head_direction != 'Left':
self.snake.head_direction = 'Right'
elif event.key == K_LEFT and self.snake.head_direction != 'Right':
self.snake.head_direction = 'Left'
elif event.key == K_DOWN and self.snake.head_direction != 'Up':
self.snake.head_direction = 'Down'
elif event.key == K_UP and self.snake.head_direction != 'Down':
self.snake.head_direction = 'Up'
elif event.key == K_p:
self.bg_sound.pause_sound()
def handle_keyup_events(self, event):
"""
Handle all key release events.
:param event: Event requested by user
:return: None
"""
pass
def _play_sound(self):
self._sound = Sound(self.get_single_path(), self.volume)
self._sound.play(loop=self.loop)
class SceneSound(object):
def __init__(self, path):
self.path = path
self.loop = False
self.start_at = 0
self.volume = 100
self.random = 0
self.fade_in = 0
self.workers = []
self.stop_event = Event()
self._sound = None
self.bind_to = None
self.auto_start = True
def play(self):
if self.start_at == 0:
self._play_no_delay()
else:
p = Thread(target=self._play_delayed)
self.workers.append(p)
p.start()
def play_now(self):
self._play_no_delay(ignore_random=True)
def stop(self):
logger.debug("[%s] Received stop", self.path)
self.stop_event.set()
for process in self.workers:
process.join()
if self._sound is not None:
self._sound.destroy()
self.workers = []
self.stop_event = Event()
self._sound = None
def get_single_path(self):
"""
Returns the path of the file to play. The path can either be a string,
or a list. In the latter case, one of the paths in the list will be
picked randomly.
"""
if isinstance(self.path, list):
return random.choice(self.path)
return self.path
def _play_no_delay(self, ignore_random=False):
# This is useful in the case where a thread comes out from sleep
# and tries to play a sound while it has been stopped in the
# meantime (eg. delayed play)
if self.stop_event.is_set():
logger.debug("[%s] Wanted to be played but not doing so"
" because it\'s been stopped", self.path)
return
if self.random == 0 or ignore_random:
if self.fade_in > 0:
logger.debug("[%s] Playing sound with volume=0 and running"
" fade in process", self.path)
target_volume = self.volume
self.volume = 0
self._play_sound()
p = Thread(target=self._fade_in, args=(target_volume,))
self.workers.append(p)
p.start()
else:
logger.debug("[%s] Playing", self.path)
self._play_sound()
else:
# Random sounds can't be looped because it would make no sense
self.loop = False
logger.debug("[%s] Running random play thread", self.path)
p = Thread(target=self._random)
self.workers.append(p)
p.start()
def _play_sound(self):
self._sound = Sound(self.get_single_path(), self.volume)
self._sound.play(loop=self.loop)
def _play_delayed(self):
logger.debug("[%s] Delaying for %s seconds", self.path, self.start_at)
self.stop_event.wait(self.start_at)
logger.debug("[%s] It's time to play", self.path)
self._play_no_delay()
def _random(self):
# We need to create a first instance of the sound to get its duration
self._sound = Sound(self.get_single_path(), self.volume)
sound_duration = self._sound.get_duration()
while not self.stop_event.is_set():
r = random.random()
if r <= self.random:
self._play_sound()
self.stop_event.wait(sound_duration + 1)
logger.debug('[%s] Stopping rand', self.path)
def _fade_in(self, target_volume):
step = 2
step_delay = float(self.fade_in) / float(target_volume)
while self.volume < target_volume and not self.stop_event.is_set():
self._sound.set_volume(self.volume + step)
self.volume += step
self.stop_event.wait(step_delay)
cur_time = counter - (time.time() - start_time)
output = "%d.%3d" % (cur_time,score)
# print(output)
leds.update(output)
if cur_time <= 1 and not thread_started:
print("start capture thread")
cam_thread.start()
thread_started = True
cam_thread.join()
detach_int()
if __name__ == '__main__':
win_sound = Sound('win.wav')
win_sound.play()
end_sound = Sound('game_over.wav')
start_sound = Sound('start.wav')
#load high score
#pickle.dump(0,open("score.pk",'wb'))
try:
high_score = pickle.load(open("score.pk",'rb'))
except:
high_score = 0
print("high score = %d" % high_score)
setup()
leds = driver.driver()
leds.set_pwm(max_pwm)
while True:
class Game:
def __init__(self):
pygame.init()
self.background_sound = Sound()
pygame.key.set_repeat(50, 50)
size = [SCREEN_WIDTH, SCREEN_HEIGHT]
self.screen = pygame.display.set_mode(size)
pygame.display.set_caption(TITLE)
self.clock = pygame.time.Clock()
self.font_name = pygame.font.match_font(FONT)
self.running = True
self.isover = False
self.gameispaused = False
self.levels = {
1: Level_01,
2: Level_02,
3: Level_03,
4: Level_04,
5: Level_05,
6: Level_06,
7: Level_07,
8: Level_08,
9: Level_09,
10: Level_10
}
self.show_start_screen()
def new(self, level=0):
self.player = Player()
self.active_sprite_list = pygame.sprite.Group()
self.active_sprite_list.add(self.player)
self.level = level + 1
self.current_level = self.levels[self.level](self.player)
self.player.level = self.current_level
self.background_sound.next_song()
self.run()
def run(self):
self.playing = True
while self.playing:
self.events()
self.update()
self.draw()
self.end_game()
def update(self):
if self.player.iskill:
self.playing = False
self.isover = True
self.gameover()
return
if not self.gameispaused and self.running:
self.active_sprite_list.update()
self.current_level.update()
# If the player gets near the right side, shift the world left (-x)
if self.player.rect.right >= 500:
diff = self.player.rect.right - 500
self.player.rect.right = 500
self.current_level.shift_world(-diff)
# If the player gets near the left side, shift the world right (+x)
if self.player.rect.left <= 120:
diff = 120 - self.player.rect.left
self.player.rect.left = 120
self.current_level.shift_world(diff)
# If the player gets to the end of the level, go to the next level
current_position = (self.player.rect.x +
self.current_level.world_shift)
if current_position < self.current_level.level_limit:
self.player.rect.x = 120
if self.level < len(self.levels) - 1:
self.level += 1
self.current_level = self.levels[self.level](self.player)
self.player.level = self.current_level
else:
self.end_screen()
else:
return
def events(self):
for bullet in self.player.bullets:
for enemies in self.current_level.enemy_list:
if (bullet.y - bullet.radius < enemies.rect.y + 147
and bullet.y + bullet.radius > enemies.rect.y):
if (bullet.x + bullet.radius > enemies.rect.x and
bullet.x - bullet.radius < enemies.rect.x + 52):
enemies.loseenergy(self.player.power)
if bullet in self.player.bullets:
self.player.bullets.remove(bullet)
if bullet.x < SCREEN_WIDTH and bullet.x > 0:
bullet.x += bullet.vel
else:
if bullet in self.player.bullets:
self.player.bullets.remove(bullet)
for event in pygame.event.get():
if event.type == pygame.USEREVENT:
self.background_sound.next_song()
if event.type == pygame.QUIT:
if self.playing:
self.playing = False
self.running = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_p:
self.gameispaused = True
self.pause_screen()
if event.key == pygame.K_LEFT:
self.player.sprint(self.player.direction)
self.player.go_left()
if event.key == pygame.K_RIGHT:
self.player.sprint(self.player.direction)
self.player.go_right()
if event.key == pygame.K_UP:
self.last_key_pressed = pygame.K_UP
if self.level < 2:
self.draw_text(GRAVITY_WARN, 24, RED, SCREEN_WIDTH / 2,
SCREEN_HEIGHT / 2)
self.draw_text(OPTIONS, 22, RED, SCREEN_WIDTH / 2,
SCREEN_HEIGHT * 3 / 4)
pygame.display.flip()
self.wait_for_key()
else:
self.player.jump()
if event.key == pygame.K_SPACE:
self.player.increasepower()
self.player.shoot()
if event.key == pygame.K_DOWN:
self.player.invisibility()
if event.type == pygame.KEYUP:
self.player.stop()
def draw(self):
self.screen.fill(BLACK)
self.current_level.draw(self.screen)
font = pygame.font.SysFont(FONT, 20, True)
if not self.player.invisible:
self.active_sprite_list.draw(self.screen)
text = font.render(HEALTH.format(self.player.health), 1, RED)
self.screen.blit(
text, (self.player.rect.x - 10, self.player.rect.y - 20))
text = font.render(PRESS_ME, 1, WHITE)
self.screen.blit(text, (SCREEN_WIDTH - 200, 10))
for bullet in self.player.bullets:
bullet.draw(self.screen)
self.clock.tick(FPS)
for enemies in self.current_level.enemy_list:
enemies.draw(self.screen)
if enemies.power is not 0:
text = font.render(LEVEL.format(enemies.power), 1, WHITE)
self.screen.blit(text,
(enemies.rect.x - 10, enemies.rect.y - 20))
pygame.display.flip()
pygame.display.update()
def show_start_screen(self):
self.screen.fill(WHITE)
self.draw_text(TITLE, 48, BLACK, SCREEN_WIDTH / 2, SCREEN_HEIGHT / 4)
self.draw_text(START, 32, BLACK, SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2)
self.draw_text(TIP_LVL, 12, BLACK, SCREEN_WIDTH / 5,
SCREEN_HEIGHT - 21)
pygame.display.flip()
self.wait_for_key()
def gameover(self):
self.background_sound.stop_music()
self.screen.fill(WHITE)
self.draw_text(GAME_OVER, 48, BLACK, SCREEN_WIDTH / 2,
SCREEN_HEIGHT / 4)
self.draw_text(OPTIONS, 22, BLACK, SCREEN_WIDTH / 2,
SCREEN_HEIGHT * 3 / 4)
pygame.display.flip()
self.wait_for_key()
def pause_screen(self):
self.current_level.tip(self.screen)
self.draw_text(GAME_PAUSED, 22, WHITE, SCREEN_WIDTH / 2,
SCREEN_HEIGHT / 4)
self.draw_text(OPTIONS, 22, WHITE, SCREEN_WIDTH / 2,
SCREEN_HEIGHT * 1 / 2)
pygame.display.flip()
self.wait_for_key()
def wait_for_key(self):
waiting = True
while waiting:
self.clock.tick(FPS)
for event in pygame.event.get():
if event.type == pygame.QUIT:
waiting = False
self.running = False
if event.type == pygame.KEYUP:
if event.key == pygame.K_q:
self.running = False
self.playing = False
waiting = False
if event.key == pygame.K_RETURN:
waiting = False
if self.gameispaused:
self.gameispaused = False
if self.isover:
self.isover = False
self.new()
def end_screen(self):
self.screen.fill(WHITE)
self.isover = True
self.draw_text(GAME_WIN, 40, BLACK, SCREEN_WIDTH / 2,
SCREEN_HEIGHT / 2)
self.draw_text(OPTIONS, 22, BLACK, SCREEN_WIDTH / 2,
SCREEN_HEIGHT * 3 / 4)
pygame.display.flip()
self.wait_for_key()
def draw_text(self, text, size, color, x, y):
font = pygame.font.Font(self.font_name, size)
text_surface = font.render(text, True, color)
text_rect = text_surface.get_rect()
text_rect.midtop = (x, y)
self.screen.blit(text_surface, text_rect)
def end_game(self):
if self.isover and not self.running:
pygame.quit()
