def __init__(self, screen):
Mode.__init__(self, screen)
#create a loading screen
Loading(screen)
self.loading = True
#border color
self.surface.fill((0, 0, 0))
screen.blit(self.surface, (0, 0))
#create border at top and bottom
self.game_dimension = (screen.get_size()[0],
screen.get_size()[1] * 0.75)
self.game_surface = pygame.Surface(self.game_dimension)
#MUST BE FIXED
self.stage = Stage(self.game_dimension)
self.stage.load_stage('Intro')
self.map = self.stage.rooms[0]
#133442__klankbeeld__horror-ambience-11.wav
pygame.mixer.init(frequency=22050, size=-16, channels=2, buffer=4096)
self.fade = Fade(screen, 'in', 3)
#add player
self.player = Player(self.map.spawn_x, self.map.spawn_y,
self.map.entity)
self.map.entity.append(self.player)
self.shade = Shade(self.player, 0, self.fade.surface)
#test
self.loading = False
self.next_before = True
def extended_fade_in(self, segment, duration):
"""Add a fade-in to a segment that extends the beginning of the
segment.
:param segment: Segment to fade in
:type segment: :py:class:`radiotool.composer.Segment`
:param duration: Duration of fade-in (in seconds)
:returns: The fade that has been added to the composition
:rtype: :py:class:`Fade`
"""
dur = int(duration * segment.track.samplerate)
if segment.start - dur >= 0:
segment.start -= dur
else:
raise Exception("Cannot create fade-in that extends "
"past the track's beginning")
if segment.comp_location - dur >= 0:
segment.comp_location -= dur
else:
raise Exception(
"Cannot create fade-in the extends past the score's beginning")
segment.duration += dur
f = Fade(segment.track, segment.comp_location_in_seconds, duration,
0.0, 1.0)
self.add_dynamic(f)
return f
def __init__(self,screen):
Mode.__init__(self,screen)
#create a loading screen
Loading(screen)
self.loading = True
#border color
self.surface.fill((0,0,0))
screen.blit(self.surface,(0,0))
#create border at top and bottom
self.game_dimension = (screen.get_size()[0],screen.get_size()[1]*0.75)
self.game_surface = pygame.Surface(self.game_dimension)
#MUST BE FIXED
self.stage = Stage(self.game_dimension)
self.stage.load_stage('Intro')
self.map = self.stage.rooms[0]
#133442__klankbeeld__horror-ambience-11.wav
pygame.mixer.init(frequency=22050, size=-16, channels=2, buffer=4096)
self.fade = Fade(screen,'in',3)
#add player
self.player = Player(self.map.spawn_x,self.map.spawn_y,self.map.entity)
self.map.entity.append(self.player)
self.shade = Shade(self.player,0,self.fade.surface)
#test
self.loading = False
self.next_before = True
def fade_out(self, segment, duration, fade_type="linear"):
"""Adds a fade out to a segment in the composition
:param segment: Segment to fade out
:type segment: :py:class:`radiotool.composer.Segment`
:param duration: Duration of fade-out (in seconds)
:type duration: float
:returns: The fade that has been added to the composition
:rtype: :py:class:`Fade`
"""
score_loc_in_seconds = segment.comp_location_in_seconds + segment.duration_in_seconds - duration
f = Fade(segment.track, score_loc_in_seconds, duration, 1.0, 0.0, fade_type=fade_type)
# bug fixing... perhaps
f.comp_location = segment.comp_location + segment.duration - int(duration * segment.track.samplerate)
self.add_dynamic(f)
return f
def update(self):
# atack
if self.time_to_atack == -1 and self.in_range(
) and self.atack_is_ready(): # ready to atack
self.time_to_atack = self.reaction # time to atack
elif self.time_to_atack > 0: # wait to atack
self.time_to_atack -= 1
elif self.time_to_atack == 0: # atack
Atack.atack(self)
Fade.fadein(self)
self.time_to_atack -= 1 # goes back to ready
# movement
x_speed, y_speed = self.calc_direction()
Movement.accelerate(self, x_speed, y_speed)
Movement.update(self)
# fade
Fade.update(self)
def __init__(self, screen):
Mode.__init__(self, screen)
#create a loading screen
Loading(screen)
#now do all the intial stuff
self.surface.fill((0, 0, 0))
screen.blit(self.surface, (0, 0))
#create border at top and bottom
game_dimension = (screen.get_size()[0], screen.get_size()[1] * 0.75)
self.game_surface = pygame.Surface(game_dimension)
self.stage = Stage(game_dimension)
self.stage.load_stage('round_1')
self.map = self.stage.rooms[0]
self.fade = Fade(screen, 'in', 3)
#add player
self.player = Player(self.map.spawn_x, self.map.spawn_y,
self.map.entity)
self.map.entity.append(self.player)
def process(infile, day, timeid):
try:
page = Image.open(os.path.join('base', 'Calendar_2014.png'))
except IOError:
print "Cannot open calendar page base"
return
photo_size = (A4_WIDTH * 3 / 4, A4_HEIGHT * 3 / 8)
fade = Fade()
photo = fade.apply_mask(infile, photo_size)
photo_left = (A4_WIDTH - photo_size[0]) / 2
photo_top = 520
photo_right = photo_left + photo_size[0]
photo_bottom = photo_top + photo_size[1]
photo_rect = (photo_left, photo_top, photo_right, photo_bottom)
page.paste(photo, photo_rect)
create_title(page, (A4_WIDTH, A4_HEIGHT), photo_rect, day, timeid)
tools.mkdir_p(os.path.join('png', day))
png_file = os.path.join('png', day, '{}.jpg'.format(timeid))
page.save(png_file, quality=75)
tools.print_image(png_file)
def __init__(self, x, y, color, size, lifes, atack_time, sec_div10,
temporary_list, enemy_list):
self.size = size
self.type = -1 # just to atack function work
self.sec_div10 = sec_div10
self.lifes = lifes
self.msgs_list = [] # damage and kill text displays
# statistics
self.type_list = [] # types of dead enemies
self.kills = 0
self.bombs = 0
# self.temporary_list = temporary_list
# self.enemy_list = enemy_list
# Movement(x, y, max_speed, acceleration, decelerate)
Movement.__init__(self, x, y, 1.8, 0.105, 0.955)
#Fade(color, time_fade, start_fadein)
Fade.__init__(self, color, 0, True)
#Atack(x, y, atack_time, range, color, fadeout_time, sec_div10, temporary_list, enemy_list)
Atack.__init__(self, x, y, atack_time, size * 5, color, 40, sec_div10,
temporary_list, enemy_list)
def process(infile, day, timeid):
try:
page = Image.open(os.path.join('base', 'Calendar_2014.png'))
except IOError:
print "Cannot open calendar page base"
return
photo_size = (A4_WIDTH * 3 / 4, A4_HEIGHT * 3 / 8)
fade = Fade()
photo = fade.apply_mask(infile, photo_size)
photo_left = (A4_WIDTH - photo_size[0]) / 2
photo_top = 520
photo_right = photo_left + photo_size[0]
photo_bottom = photo_top + photo_size[1]
photo_rect = (photo_left, photo_top, photo_right, photo_bottom)
page.paste(photo, photo_rect)
create_title(page, (A4_WIDTH, A4_HEIGHT), photo_rect, day, timeid)
if not os.path.exists(os.path.join('png', day)):
os.mkdir(os.path.join('png', day))
png_file = os.path.join('png', day, '{}.jpg'.format(timeid))
page.save(png_file, quality=75)
tools.print_image(png_file)
def __init__(self, x, y, type, color, size, time_fade, sec_div10,
temporary_list, sub):
self.type = type
self.size = size
self.sec_div10 = sec_div10
self.sub = sub
self.time_to_atack = -1
# move
max_speed, accel, decel, self.lifes = self.movem_attributes(type)
# Movement(x, y, max_speed, acceleration, decelerate)
Movement.__init__(self, x, y, max_speed, accel, decel)
# fade
#Fade(color, time_fade, start_fadein)
Fade.__init__(self, color, time_fade, False)
# atack
atack_time, self.reaction, range, fadeout_time_atack = self.atack_attributes(
type)
#Atack(x, y, atack_time, range, color, fadeout_time, sec_div10, temporary_list, enemy_list)
Atack.__init__(self, x, y, atack_time, range, color,
fadeout_time_atack, sec_div10, temporary_list, [sub])
def fade_out(self, segment, duration, fade_type="linear"):
"""Adds a fade out to a segment in the composition
:param segment: Segment to fade out
:type segment: :py:class:`radiotool.composer.Segment`
:param duration: Duration of fade-out (in seconds)
:type duration: float
:returns: The fade that has been added to the composition
:rtype: :py:class:`Fade`
"""
score_loc_in_seconds = segment.comp_location_in_seconds +\
segment.duration_in_seconds - duration
f = Fade(segment.track,
score_loc_in_seconds,
duration,
1.0,
0.0,
fade_type=fade_type)
# bug fixing... perhaps
f.comp_location = segment.comp_location + segment.duration -\
int(duration * segment.track.samplerate)
self.add_dynamic(f)
return f
def fade_in(self, segment, duration, fade_type="linear"):
"""Adds a fade in to a segment in the composition
:param segment: Segment to fade in to
:type segment: :py:class:`radiotool.composer.Segment`
:param duration: Duration of fade-in (in seconds)
:type duration: float
:returns: The fade that has been added to the composition
:rtype: :py:class:`Fade`
"""
f = Fade(segment.track,
segment.comp_location_in_seconds,
duration,
0.0,
1.0,
fade_type=fade_type)
self.add_dynamic(f)
return f
def __init__(self,screen):
Mode.__init__(self,screen)
#create a loading screen
Loading(screen)
#now do all the intial stuff
self.surface.fill((0,0,0))
screen.blit(self.surface,(0,0))
#create border at top and bottom
game_dimension = (screen.get_size()[0],screen.get_size()[1]*0.75)
self.game_surface = pygame.Surface(game_dimension)
self.stage = Stage(game_dimension)
self.stage.load_stage('round_1')
self.map = self.stage.rooms[0]
self.fade = Fade(screen,'in',3)
#add player
self.player = Player(self.map.spawn_x,self.map.spawn_y,self.map.entity)
self.map.entity.append(self.player)
def extended_fade_out(self, segment, duration):
"""Add a fade-out to a segment that extends the beginning of the
segment.
:param segment: Segment to fade out
:type segment: :py:class:`radiotool.composer.Segment`
:param duration: Duration of fade-out (in seconds)
:returns: The fade that has been added to the composition
:rtype: :py:class:`Fade`
"""
dur = int(duration * segment.track.samplerate)
if segment.start + segment.duration + dur <\
segment.track.duration:
segment.duration += dur
else:
raise Exception(
"Cannot create fade-out that extends past the track's end")
score_loc_in_seconds = segment.comp_location_in_seconds +\
segment.duration_in_seconds - duration
f = Fade(segment.track, score_loc_in_seconds, duration, 1.0, 0.0)
self.add_dynamic(f)
return f
def update(self):
Movement.update(self)
Fade.update(self)
def __init__(self, x, y, color, size, time_fade, start_fadein):
self.x = x
self.y = y
self.size = size
Fade.__init__(self, color, time_fade, start_fadein)
class Game(Mode):
def __init__(self,screen):
Mode.__init__(self,screen)
#create a loading screen
Loading(screen)
self.loading = True
#border color
self.surface.fill((0,0,0))
screen.blit(self.surface,(0,0))
#create border at top and bottom
self.game_dimension = (screen.get_size()[0],screen.get_size()[1]*0.75)
self.game_surface = pygame.Surface(self.game_dimension)
#MUST BE FIXED
self.stage = Stage(self.game_dimension)
self.stage.load_stage('Intro')
self.map = self.stage.rooms[0]
#133442__klankbeeld__horror-ambience-11.wav
pygame.mixer.init(frequency=22050, size=-16, channels=2, buffer=4096)
self.fade = Fade(screen,'in',3)
#add player
self.player = Player(self.map.spawn_x,self.map.spawn_y,self.map.entity)
self.map.entity.append(self.player)
self.shade = Shade(self.player,0,self.fade.surface)
#test
self.loading = False
self.next_before = True
def exit_stage(self):
self.loading = True
self.fade.switch_mode()
def next_stage(self):
if self.fade.done:
self.fade.switch_mode()
self.player.stage += self.next_before
self.map = self.stage.rooms[self.player.stage]
if self.player.stage == 5:
self.next_before = 0
self.player.brightness = 0
return
self.player.set_spawn(self.map.spawn_x,self.map.spawn_y)
self.player.place(self.map.entity)
self.loading = False
if self.player.stamina_regen:
self.player.stamina_reset()
# if self.player.stage > 0:
# self.shade = Shade(self.player,self.player.stage,self.fade.surface)
# else:
# self.shade = Shade(self.player,0,self.fade.surface)
#
self.bgm = pygame.mixer.Sound(os.path.join('data','music',"wind.wav"))
self.bgm2 = pygame.mixer.Sound(os.path.join('data','music',"horror_converted.ogg"))
self.bgm3 = pygame.mixer.Sound(os.path.join('data','music',"stomping.ogg"))
if self.player.stage == 0:
self.bgm.stop()
self.bgm2.stop()
#self.bgm.fadeout(1000)
if self.player.stage == 1:
self.bgm.play(loops = -1,fade_ms = 10000)
if self.player.stage == 3:
self.bgm2.play(loops = -1,fade_ms = 10000)
if self.player.stage < 3:
self.bgm2.stop()
if self.player.stage == 4:
self.bgm3.play(loops = -1, fade_ms = 5000)
if self.player.stage < 4:
self.bgm3.stop()
def set_button(self,button,state):
self.player.inputhandler.button_list[button] = state
def tick(self,events):
if self.loading:
if self.fade.loop():
if self.next_before != 0:
self.next_stage()
for e in events:
if e.type == KEYDOWN:
if e.key == K_ESCAPE:
sys.exit()
else:
if self.player.out_of_screen(self.map.map_size):
self.player.status['health'].current = 0
self.player.interacting = False
for e in self.map.entity:
if e.dead:
self.map.entity.remove(e)
for e in events:
if e.type == KEYDOWN:
if e.key == K_RIGHT:
self.set_button('right',True)
if e.key == K_LEFT:
self.set_button('left',True)
if e.key == K_UP:
self.set_button('up',True)
self.player.jumping = True
if e.key == K_LSHIFT:
self.set_button('sprint',True)
if e.key == K_DOWN:
self.set_button('down',True)
if e.key == K_z:
self.set_button('jump',True)
if e.key == K_x:
self.set_button('low_jump',True)
if e.key == K_r:
self.player.reset(self.map.entity)
if e.key == K_t:
self.player.admin = not self.player.admin
if e.key == K_TAB:
self.player.running = not self.player.running
if e.key == K_RETURN:
self.player.interacting = True
if e.key == K_RIGHTBRACKET:
self.next_before = 1
self.exit_stage()
if e.key == K_LEFTBRACKET:
self.next_before = -1
self.exit_stage()
if e.key == K_ESCAPE:
return 'Menu'
elif e.type == KEYUP:
if e.key == K_RIGHT:
self.set_button('right',False)
if e.key == K_LEFT:
self.set_button('left',False)
if e.key == K_LSHIFT:
self.set_button('sprint',False)
if e.key == K_UP:
self.set_button('up',False)
if e.key == K_DOWN:
self.set_button('down',False)
if e.key == K_z:
self.set_button('jump',False)
elif e.type == QUIT:
pygame.display.quit()
sys.exit()
if self.map.previous_stage != None:
if pygame.sprite.collide_rect(self.player, self.map.previous_stage) and not self.loading and self.player.interacting:
self.next_before = -1
self.exit_stage()
if pygame.sprite.collide_rect(self.player, self.map.next_stage) and not self.loading and self.player.interacting:
self.next_before = 1
self.exit_stage()
for i in self.map.interactables:
if pygame.sprite.collide_rect(self.player, i) and self.player.interacting and not self.loading:
self.interacting = False
return 'Shop'
for c in self.map.coins:
if pygame.sprite.collide_rect(self.player, c):
self.map.coins[self.map.coins.index(c)].dead = True
self.map.coins.remove(c)
self.player.status['money'].gain(10)
coin= pygame.mixer.Sound(os.path.join('data','music',"coin_flip.wav"))
coin.play()
self.fade.loop()
self.map.camera.update(self.player)
if not self.player.dead:
if not self.player.admin:
self.player.tick(self.map.platforms,self.map.entity)
elif self.player.admin:
self.player.admin_tick()
def render(self,screen):
self.layer_1(screen)
self.layer_2(screen)
self.layer_3(screen)
self.layer_4(screen)
self.layer_5(screen)
def __str__(self):
return 'Game'
#background
def layer_1(self,screen):
Mode.render(self,screen)
#map obstacles + player
def layer_2(self,screen):
self.game_surface.fill((255,255,255))
for e in self.map.entity:
self.game_surface.blit(e.image, self.map.camera.apply(e))
screen.blit(self.game_surface,(0,screen.get_size()[1]*0.125))
#player status
def layer_3(self,screen):
for s in self.player.status.values():
s.render(screen)
#fade in/out
def layer_4(self,screen):
screen.blit(self.fade.surface,(0,0))
def layer_5(self,screen):
self.shade = Shade(self.player, self.player.stage * self.player.brightness,screen)
#self.shade.loop(self.player)
screen.blit(self.shade.surface,(0,(self.shade.surface.get_size()[1] - self.game_dimension[1])//2))
class Game(Mode):
def __init__(self,screen):
Mode.__init__(self,screen)
#create a loading screen
Loading(screen)
#now do all the intial stuff
self.surface.fill((0,0,0))
screen.blit(self.surface,(0,0))
#create border at top and bottom
game_dimension = (screen.get_size()[0],screen.get_size()[1]*0.75)
self.game_surface = pygame.Surface(game_dimension)
self.stage = Stage(game_dimension)
self.stage.load_stage('round_1')
self.map = self.stage.rooms[0]
self.fade = Fade(screen,'in',3)
#add player
self.player = Player(self.map.spawn_x,self.map.spawn_y,self.map.entity)
self.map.entity.append(self.player)
def set_button(self,button,state):
self.player.inputhandler.button_list[button] = state
def tick(self,events):
for e in self.map.entity:
if e.dead:
self.map.entity.remove(e)
for e in events:
if e.type == KEYDOWN:
if e.key == K_RIGHT:
self.set_button('right',True)
if e.key == K_LEFT:
self.set_button('left',True)
if e.key == K_UP:
self.set_button('up',True)
self.player.jumping = True
if e.key == K_LSHIFT:
self.set_button('sprint',True)
if e.key == K_DOWN:
self.set_button('down',True)
if e.key == K_z:
self.set_button('jump',True)
if e.key == K_r:
self.player.reset(self.map.entity)
if e.key == K_t:
self.player.admin = not self.player.admin
if e.key == K_TAB:
self.player.running = not self.player.running
if e.key == K_ESCAPE:
return 'Menu'
elif e.type == KEYUP:
if e.key == K_RIGHT:
self.set_button('right',False)
if e.key == K_LEFT:
self.set_button('left',False)
if e.key == K_LSHIFT:
self.set_button('sprint',False)
if e.key == K_UP:
self.set_button('up',False)
if e.key == K_DOWN:
self.set_button('down',False)
if e.key == K_z:
self.set_button('jump',False)
elif e.type == QUIT:
pygame.display.quit()
sys.exit()
self.fade.loop()
self.map.camera.update(self.player)
if not self.player.dead:
if not self.player.admin:
self.player.tick(self.map.platforms,self.map.entity)
elif self.player.admin:
self.player.admin_tick()
def render(self,screen):
self.layer_1(screen)
self.layer_2(screen)
self.layer_3(screen)
self.layer_4(screen)
def __str__(self):
return 'Game'
def layer_1(self,screen):
Mode.render(self,screen)
def layer_2(self,screen):
self.game_surface.fill((255,255,255))
for e in self.map.entity:
self.game_surface.blit(e.image, self.map.camera.apply(e))
screen.blit(self.game_surface,(0,screen.get_size()[1]*0.125))
def layer_3(self,screen):
for s in self.player.status.values():
s.render(screen)
def layer_4(self,screen):
screen.blit(self.fade.surface,(0,0))
class Game(Mode):
def __init__(self, screen):
Mode.__init__(self, screen)
#create a loading screen
Loading(screen)
#now do all the intial stuff
self.surface.fill((0, 0, 0))
screen.blit(self.surface, (0, 0))
#create border at top and bottom
game_dimension = (screen.get_size()[0], screen.get_size()[1] * 0.75)
self.game_surface = pygame.Surface(game_dimension)
self.stage = Stage(game_dimension)
self.stage.load_stage('round_1')
self.map = self.stage.rooms[0]
self.fade = Fade(screen, 'in', 3)
#add player
self.player = Player(self.map.spawn_x, self.map.spawn_y,
self.map.entity)
self.map.entity.append(self.player)
def set_button(self, button, state):
self.player.inputhandler.button_list[button] = state
def tick(self, events):
for e in self.map.entity:
if e.dead:
self.map.entity.remove(e)
for e in events:
if e.type == KEYDOWN:
if e.key == K_RIGHT:
self.set_button('right', True)
if e.key == K_LEFT:
self.set_button('left', True)
if e.key == K_UP:
self.set_button('up', True)
self.player.jumping = True
if e.key == K_LSHIFT:
self.set_button('sprint', True)
if e.key == K_DOWN:
self.set_button('down', True)
if e.key == K_z:
self.set_button('jump', True)
if e.key == K_r:
self.player.reset(self.map.entity)
if e.key == K_t:
self.player.admin = not self.player.admin
if e.key == K_TAB:
self.player.running = not self.player.running
if e.key == K_ESCAPE:
return 'Menu'
elif e.type == KEYUP:
if e.key == K_RIGHT:
self.set_button('right', False)
if e.key == K_LEFT:
self.set_button('left', False)
if e.key == K_LSHIFT:
self.set_button('sprint', False)
if e.key == K_UP:
self.set_button('up', False)
if e.key == K_DOWN:
self.set_button('down', False)
if e.key == K_z:
self.set_button('jump', False)
elif e.type == QUIT:
pygame.display.quit()
sys.exit()
self.fade.loop()
self.map.camera.update(self.player)
if not self.player.dead:
if not self.player.admin:
self.player.tick(self.map.platforms, self.map.entity)
elif self.player.admin:
self.player.admin_tick()
def render(self, screen):
self.layer_1(screen)
self.layer_2(screen)
self.layer_3(screen)
self.layer_4(screen)
def __str__(self):
return 'Game'
def layer_1(self, screen):
Mode.render(self, screen)
def layer_2(self, screen):
self.game_surface.fill((255, 255, 255))
for e in self.map.entity:
self.game_surface.blit(e.image, self.map.camera.apply(e))
screen.blit(self.game_surface, (0, screen.get_size()[1] * 0.125))
def layer_3(self, screen):
for s in self.player.status.values():
s.render(screen)
def layer_4(self, screen):
screen.blit(self.fade.surface, (0, 0))
class Game(Mode):
def __init__(self, screen):
Mode.__init__(self, screen)
#create a loading screen
Loading(screen)
self.loading = True
#border color
self.surface.fill((0, 0, 0))
screen.blit(self.surface, (0, 0))
#create border at top and bottom
self.game_dimension = (screen.get_size()[0],
screen.get_size()[1] * 0.75)
self.game_surface = pygame.Surface(self.game_dimension)
#MUST BE FIXED
self.stage = Stage(self.game_dimension)
self.stage.load_stage('Intro')
self.map = self.stage.rooms[0]
#133442__klankbeeld__horror-ambience-11.wav
pygame.mixer.init(frequency=22050, size=-16, channels=2, buffer=4096)
self.fade = Fade(screen, 'in', 3)
#add player
self.player = Player(self.map.spawn_x, self.map.spawn_y,
self.map.entity)
self.map.entity.append(self.player)
self.shade = Shade(self.player, 0, self.fade.surface)
#test
self.loading = False
self.next_before = True
def exit_stage(self):
self.loading = True
self.fade.switch_mode()
def next_stage(self):
if self.fade.done:
self.fade.switch_mode()
self.player.stage += self.next_before
self.map = self.stage.rooms[self.player.stage]
if self.player.stage == 5:
self.next_before = 0
self.player.brightness = 0
return
self.player.set_spawn(self.map.spawn_x, self.map.spawn_y)
self.player.place(self.map.entity)
self.loading = False
if self.player.stamina_regen:
self.player.stamina_reset()
# if self.player.stage > 0:
# self.shade = Shade(self.player,self.player.stage,self.fade.surface)
# else:
# self.shade = Shade(self.player,0,self.fade.surface)
#
self.bgm = pygame.mixer.Sound(
os.path.join('data', 'music', "wind.wav"))
self.bgm2 = pygame.mixer.Sound(
os.path.join('data', 'music', "horror_converted.ogg"))
self.bgm3 = pygame.mixer.Sound(
os.path.join('data', 'music', "stomping.ogg"))
if self.player.stage == 0:
self.bgm.stop()
self.bgm2.stop()
#self.bgm.fadeout(1000)
if self.player.stage == 1:
self.bgm.play(loops=-1, fade_ms=10000)
if self.player.stage == 3:
self.bgm2.play(loops=-1, fade_ms=10000)
if self.player.stage < 3:
self.bgm2.stop()
if self.player.stage == 4:
self.bgm3.play(loops=-1, fade_ms=5000)
if self.player.stage < 4:
self.bgm3.stop()
def set_button(self, button, state):
self.player.inputhandler.button_list[button] = state
def tick(self, events):
if self.loading:
if self.fade.loop():
if self.next_before != 0:
self.next_stage()
for e in events:
if e.type == KEYDOWN:
if e.key == K_ESCAPE:
sys.exit()
else:
if self.player.out_of_screen(self.map.map_size):
self.player.status['health'].current = 0
self.player.interacting = False
for e in self.map.entity:
if e.dead:
self.map.entity.remove(e)
for e in events:
if e.type == KEYDOWN:
if e.key == K_RIGHT:
self.set_button('right', True)
if e.key == K_LEFT:
self.set_button('left', True)
if e.key == K_UP:
self.set_button('up', True)
self.player.jumping = True
if e.key == K_LSHIFT:
self.set_button('sprint', True)
if e.key == K_DOWN:
self.set_button('down', True)
if e.key == K_z:
self.set_button('jump', True)
if e.key == K_x:
self.set_button('low_jump', True)
if e.key == K_r:
self.player.reset(self.map.entity)
if e.key == K_t:
self.player.admin = not self.player.admin
if e.key == K_TAB:
self.player.running = not self.player.running
if e.key == K_RETURN:
self.player.interacting = True
if e.key == K_RIGHTBRACKET:
self.next_before = 1
self.exit_stage()
if e.key == K_LEFTBRACKET:
self.next_before = -1
self.exit_stage()
if e.key == K_ESCAPE:
return 'Menu'
elif e.type == KEYUP:
if e.key == K_RIGHT:
self.set_button('right', False)
if e.key == K_LEFT:
self.set_button('left', False)
if e.key == K_LSHIFT:
self.set_button('sprint', False)
if e.key == K_UP:
self.set_button('up', False)
if e.key == K_DOWN:
self.set_button('down', False)
if e.key == K_z:
self.set_button('jump', False)
elif e.type == QUIT:
pygame.display.quit()
sys.exit()
if self.map.previous_stage != None:
if pygame.sprite.collide_rect(
self.player, self.map.previous_stage
) and not self.loading and self.player.interacting:
self.next_before = -1
self.exit_stage()
if pygame.sprite.collide_rect(
self.player, self.map.next_stage
) and not self.loading and self.player.interacting:
self.next_before = 1
self.exit_stage()
for i in self.map.interactables:
if pygame.sprite.collide_rect(
self.player,
i) and self.player.interacting and not self.loading:
self.interacting = False
return 'Shop'
for c in self.map.coins:
if pygame.sprite.collide_rect(self.player, c):
self.map.coins[self.map.coins.index(c)].dead = True
self.map.coins.remove(c)
self.player.status['money'].gain(10)
coin = pygame.mixer.Sound(
os.path.join('data', 'music', "coin_flip.wav"))
coin.play()
self.fade.loop()
self.map.camera.update(self.player)
if not self.player.dead:
if not self.player.admin:
self.player.tick(self.map.platforms, self.map.entity)
elif self.player.admin:
self.player.admin_tick()
def render(self, screen):
self.layer_1(screen)
self.layer_2(screen)
self.layer_3(screen)
self.layer_4(screen)
self.layer_5(screen)
def __str__(self):
return 'Game'
#background
def layer_1(self, screen):
Mode.render(self, screen)
#map obstacles + player
def layer_2(self, screen):
self.game_surface.fill((255, 255, 255))
for e in self.map.entity:
self.game_surface.blit(e.image, self.map.camera.apply(e))
screen.blit(self.game_surface, (0, screen.get_size()[1] * 0.125))
#player status
def layer_3(self, screen):
for s in self.player.status.values():
s.render(screen)
#fade in/out
def layer_4(self, screen):
screen.blit(self.fade.surface, (0, 0))
def layer_5(self, screen):
self.shade = Shade(self.player,
self.player.stage * self.player.brightness, screen)
#self.shade.loop(self.player)
screen.blit(
self.shade.surface,
(0,
(self.shade.surface.get_size()[1] - self.game_dimension[1]) // 2))
def add_music_cue(self,
track,
comp_cue,
song_cue,
duration=6.0,
padding_before=12.0,
padding_after=12.0):
"""Add a music cue to the composition. This doesn't do any audio
analysis, it just aligns a specified point in the track
(presumably music) with a location in the composition. See
UnderScore_ for a visualization of what this is doing to the
music track.
.. _UnderScore: http://vis.berkeley.edu/papers/underscore/
:param track: Track to align in the composition
:type track: :py:class:`radiotool.composer.Track`
:param float comp_cue: Location in composition to align music cue (in seconds)
:param float song_cue: Location in the music track to align with the composition cue (in seconds)
:param float duration: Duration of music after the song cue before the music starts to fade out (in seconds)
:param float padding_before: Duration of music playing softly before the music cue/composition cue (in seconds)
:param float padding_after: Duration of music playing softly after the music cue/composition cue (in seconds)
"""
self.tracks.add(track)
pre_fade = 3
post_fade = 3
if padding_before + pre_fade > song_cue:
padding_before = song_cue - pre_fade
if padding_before + pre_fade > score_cue:
padding_before = score_cue - pre_fade
s = Segment(
track, score_cue - padding_before - pre_fade,
song_cue - padding_before - pre_fade,
pre_fade + padding_before + duration + padding_after + post_fade)
self.add_segment(s)
d = []
dyn_adj = 1
track.current_frame = 0
d.append(
Fade(track,
score_cue - padding_before - pre_fade,
pre_fade,
0,
.1 * dyn_adj,
fade_type="linear"))
d.append(
Fade(track,
score_cue - padding_before,
padding_before,
.1 * dyn_adj,
.4 * dyn_adj,
fade_type="exponential"))
d.append(Volume(track, score_cue, duration, .4 * dyn_adj))
d.append(
Fade(track,
score_cue + duration,
padding_after,
.4 * dyn_adj,
0,
fade_type="exponential"))
d.append(
Fade(track,
score_cue + duration + padding_after,
post_fade,
.1 * dyn_adj,
0,
fade_type="linear"))
self.add_dynamics(d)
