def draw( self, frame ):
resman.get("game.hud_score_surf").draw( frame.surface, Vec2D(0,0) )
resman.get("game.hud_watch_surf").draw( frame.surface, Vec2D(5,290) )
y = 7
for goldcars in self.scenario.playfield.get_goldcar_ranking():
for goldcar in goldcars:
sprite = copy.copy(resman.get("game.car%d_sprite" % (goldcar.nr+1)))
sprite.nr = 20 * goldcar.amount
sprite.draw( frame.surface, Vec2D(24, y + 30) )
self.font_score.draw( "%d" % (goldcar.score), frame.surface,
(110, y + 4), align = gfx.Font.RIGHT )
y += 35
timeout = self.scenario.get_timeout()
if timeout is not None:
time_string = "%01d:%02d" % (timeout/60, timeout%60)
time_x = 0
for char in time_string:
self.font_watch.draw( char, frame.surface, (49 + time_x, 383), align=gfx.Font.CENTER )
time_x += 10
if self.dialog is not None:
self.dialog.draw( frame )
if not isinstance( self.dialog, IntroDlg ):
self.font_white.draw( self.scenario.mission_txt, frame.surface, (130, 5 ) )
self.menu_btn.draw( frame.surface, frame.interpol, frame.time_sec )
def draw_skill_bar(self, frame, x, y):
resman.get("game.skill_bar_surf").draw(frame.surface,
Vec2D(x + 10, y + 85))
MIN_Y = y
MAX_Y = y + 7 * 21 + 12
pointer_y = geo.lin_ipol(self.skill_value, MAX_Y + 7, MIN_Y + 17, 0.3,
1.0)
pointer_y = max(min(pointer_y, MAX_Y), MIN_Y)
# pointer_y = MAX_Y
resman.get("game.skill_pointer_surf").draw(frame.surface,
Vec2D(x + 10, pointer_y))
self.font_tiny_white.draw("%d" % int(self.skill_value * 100),
frame.surface, (x + 13, pointer_y + 2),
align=gfx.Font.CENTER,
valign=gfx.Font.MIDDLE)
for skill_name in settings.SkillLevel.NAMES:
if skill_name == self.game_data.skill_level.name:
self.font_tiny_red.draw(skill_name, frame.surface, (x + 40, y))
else:
self.font_tiny.draw(skill_name, frame.surface, (x + 40, y))
y += 21
def draw( self, frame ):
BaseDlg.draw( self, frame )
center = Vec2D( frame.surface.get_width()/2, frame.surface.get_height()/2 )
y = 365
if self.no_input_timeout <= 0:
self.font.draw( _("Press your button or click on the car"), frame.surface, (center.x, y+15), gfx.Font.CENTER )
y = 415
place = 0
for controller in self.ground_control.controllers:
goldcar = controller.goldcar
x = self.get_goldcar_x( place )
if isinstance(controller, ctrl.HumanController):
button_text = "< %s >" % controller.action_button.get_name()
self.small_font.draw( button_text, frame.surface, (x, y + 30), gfx.Font.CENTER )
sprite = copy.copy(resman.get("game.car%d_sprite" % (goldcar.nr+1)))
if self.readys is not None:
if self.readys[place]:
self.small_font.draw( _("Ready!"), frame.surface, (x, y+50), gfx.Font.CENTER )
sprite.nr = 60
else:
self.small_font.draw( _("waiting..."), frame.surface, (x, y+50), gfx.Font.CENTER )
sprite.nr = self.anim_timer.get_frame( frame.time_sec )
sprite.draw( frame.surface, Vec2D(x, y + 26) )
place += 1
def __init__(self, pos):
self.pos = pos
self.life = 10 + int(random.random() * 2)
self.move = Vec2D(random.uniform(-2.5, 2.5),
random.uniform(-2.5, 0.0))
self.surf = resman.get("game.sparkle_surf")
width, height = self.surf.get_size()
self.center = Vec2D(width / 2, height / 2)
def draw(self, frame):
if self.get_pos(frame) is None: return
font = Font(size=28, color=(255, 0, 0))
pos = self.get_pos(frame) + Vec2D(frame.X_OFFSET, frame.Y_OFFSET)
if self.model.goldcar is not None:
pos += Vec2D(0, 20)
font.draw("x2", frame.surface, pos.get_tuple(), Font.CENTER,
Font.MIDDLE)
def __init__(self, is_single_player, game_data):
super(IngameMenu,
self).__init__(Rectangle(140, 80, 800 - 400, 600 - 200))
self.background_image = resman.get("gui.paperdialog_surf")
self._is_done = False
self.game_data = game_data
btnFont = gfx.Font("data/edmunds.ttf",
color=(0, 0, 0),
size=32,
use_antialias=True)
BUTTON_X = 300
BUTTON_Y = 100
H = 75
self.continue_btn = gui.ImageButton(
copy.copy(resman.get("game.button02_sprite")),
Vec2D(BUTTON_X, BUTTON_Y))
self.continue_btn.set_label(_("Continue"), btnFont)
self.skip_btn = gui.ImageButton(
copy.copy(resman.get("game.button02_sprite")),
Vec2D(BUTTON_X, BUTTON_Y + 1 * H))
self.skip_btn.set_label(_("Skip Level"), btnFont)
self.options_btn = gui.ImageButton(
copy.copy(resman.get("game.button02_sprite")),
Vec2D(BUTTON_X, BUTTON_Y + 2 * H))
self.options_btn.set_label(_("Options"), btnFont)
self.menu_btn = gui.ImageButton(
copy.copy(resman.get("game.button02_sprite")),
Vec2D(BUTTON_X, BUTTON_Y + 3 * H))
self.menu_btn.set_label(_("To Menu"), btnFont)
self.quit_btn = gui.ImageButton(
copy.copy(resman.get("game.button02_sprite")),
Vec2D(BUTTON_X, BUTTON_Y + 4 * H))
self.quit_btn.set_label(_("Quit"), btnFont)
self.add_subcomponent(self.continue_btn)
if not is_single_player:
self.add_subcomponent(self.skip_btn)
self.add_subcomponent(self.options_btn)
self.add_subcomponent(self.menu_btn)
self.add_subcomponent(self.quit_btn)
self.update_neighbors()
self.options_dialog = None
self.to_menu = False
self.should_quit = False
self.to_next_level = False
def __init__(self, model):
PickupView.__init__(self)
self.model = model
self.sprite = resman.get("game.dynamite_sprite").clone()
self.sprite_delta = 1
self.prev_life = 1.0
w, h = self.sprite.get_size()
self.sparkle_offset = Vec2D(7, -h + 24)
self.sparkle_line = Vec2D(0, -22)
self.sparkles = []
self.sparkle_timer = Timer(25)
def draw(self, frame):
if self.get_pos(frame) is not None:
self.sprite.nr = self.animTimer.get_frame(frame.time_sec)
self.sprite.draw(
frame.surface,
self.get_pos(frame) +
Vec2D(frame.X_OFFSET, frame.Y_OFFSET - 10))
def __init__(self, scenario, ground_control, game_data):
self.font = gfx.Font("data/edmunds.ttf", 20, use_antialias=True)
self.font_white = gfx.Font("data/edmunds.ttf",
20, (255, 255, 255),
use_antialias=True)
self.font_score = gfx.Font("data/edmunds.ttf",
18, (255, 255, 255),
use_antialias=True)
self.font_watch = gfx.Font("data/edmunds.ttf",
18, (0, 0, 0),
use_antialias=True)
self.scenario = scenario
self.ground_control = ground_control
self.game_data = game_data
self.dialog = None
self.guistate = gui.GuiState()
btnFont = gfx.Font("data/edmunds.ttf",
color=(0, 0, 0),
size=19,
use_antialias=True)
self.menu_btn = gui.ImageButton(
copy.copy(resman.get("game.hud_menu_button_sprite")),
Vec2D(5, 257))
self.menu_btn.set_label(_("Menu"), btnFont)
self.last_clock_ring = None
def draw(self, frame):
if self.get_pos(
frame
) is not None and self.model.goldcar is None: # only draw on tile
self.sprite.draw(
frame.surface,
self.get_pos(frame) + Vec2D(frame.X_OFFSET, frame.Y_OFFSET))
def draw(self, frame):
if self.get_pos(frame) is None: return
# no time... must implement... bad code...
if self.model.life < pickups.Dynamite.DEC * 18 and\
self.model.life != self.prev_life:
self.prev_life = self.model.life
self.sprite.nr += self.sprite_delta
if self.sprite.nr < 0:
self.sprite.nr = 0
self.sprite_delta = 1
elif self.sprite.nr >= 4:
self.sprite.nr = 3
self.sprite_delta = -1
event.Event.dynamite_tick()
while self.sparkle_timer.do_tick(frame.time_sec):
self.sparkle_tick(frame)
self.sprite.draw(
frame.surface,
self.get_pos(frame) + Vec2D(frame.X_OFFSET, frame.Y_OFFSET))
for sparkle in self.sparkles:
sparkle.draw(frame)
def draw( self, frame ):
SingleDlg.draw( self, frame )
center = Vec2D( frame.surface.get_width()/2, frame.surface.get_height()/2 )
y = center.y - 180
self.large_font.draw( _("Game Over!"), frame.surface, (center.x, y), gfx.Font.CENTER )
def draw( self, frame ):
BaseDlg.draw( self, frame )
center = Vec2D( frame.surface.get_width()/2, frame.surface.get_height()/2 )
y = center.y - 200
self.large_font.draw( _("Info: "),
frame.surface, (center.x, y), gfx.Font.CENTER )
def draw(self, frame):
MultiDlg.draw(self, frame)
#winner = None
#for goldcar in self.playfield.goldcars:
# if winner is None or winner.score < goldcar.score:
# winner = goldcar
center = Vec2D(frame.surface.get_width() / 2,
frame.surface.get_height() / 2)
y = center.y - 180
self.large_font.draw(_("Game Ended!"), frame.surface, (center.x, y),
gfx.Font.CENTER)
y += 32
self.font.draw(_("Ranking"), frame.surface, (center.x - 150, y))
ranking = self.scenario.playfield.get_goldcar_ranking()
place = 1
y -= 5
for goldcars in ranking:
y += 32
self.font.draw("%d." % place, frame.surface, (center.x - 170, y),
gfx.Font.RIGHT)
goldcar_x = center.x - 140
for goldcar in goldcars:
sprite = copy.copy(
resman.get("game.car%d_sprite" % (goldcar.nr + 1)))
sprite.nr = 20 * goldcar.amount
sprite.draw(frame.surface, Vec2D(goldcar_x, y + 26))
goldcar_x += 40
place += 1
self.font.draw("%d" % goldcars[0].score, frame.surface,
(center.x + 100, y), gfx.Font.RIGHT)
def draw(self, frame):
if self.model.pos is None: return
pos = self.get_pos(frame)
self.align_car_to_track(pos)
# show amount of gold in car
self.sprite.nr += 20 * self.model.amount
while self.motionblur_timer.do_tick(frame.time_sec):
self.motionblur_tick(pos)
# draw motion blur
if isinstance(self.model.modifier, Oiler):
diff = 1.0 / (len(self.motionblur) + 1)
alpha = 0.0 + diff * 2
for ghost in self.motionblur:
if not self.alpha_surfs.has_key(alpha):
self.alpha_surfs[alpha] = self.sprite.surface.get_blended(
alpha)
ghost[1].surface = self.alpha_surfs[alpha]
ghost[1].draw(
frame.surface,
Vec2D(ghost[0][0] + frame.X_OFFSET,
ghost[0][1] + frame.Y_OFFSET))
alpha += diff
screen_x, screen_y = pos.get_screen_position()
screen_x += frame.X_OFFSET
screen_y += frame.Y_OFFSET
if isinstance(self.model.modifier, Ghost):
if self.ghost_sprite is None:
self.ghost_sprite = copy.copy(self.sprite)
self.ghost_sprite.surface = self.sprite.surface.get_blended(
0.6)
self.ghost_sprite.nr = self.sprite.nr
self.ghost_sprite.draw(frame.surface, Vec2D(screen_x, screen_y))
else:
self.sprite.draw(frame.surface, Vec2D(screen_x, screen_y))
def draw(self, frame):
MultiDlg.draw(self, frame)
center = Vec2D(frame.surface.get_width() / 2,
frame.surface.get_height() / 2)
y = center.y - 180
self.large_font.draw(_("All Games Total"), frame.surface,
(center.x, y), gfx.Font.CENTER)
y += 32
self.font.draw(_("Ranking"), frame.surface, (center.x - 150, y))
ranking = self.game_data.get_total_ranking()
place = 1
y -= 5
amount = 3
for goldcars in ranking:
y += 32
self.font.draw("%d." % place, frame.surface, (center.x - 170, y),
gfx.Font.RIGHT)
goldcar_x = center.x - 140
for goldcar in goldcars:
sprite = copy.copy(
resman.get("game.car%d_sprite" % (goldcar.nr + 1)))
sprite.nr = 20 * amount
sprite.draw(frame.surface, Vec2D(goldcar_x, y + 26))
goldcar_x += 40
place += 1
amount = max([0, amount - 1])
self.font.draw("%d" % goldcars[0].score, frame.surface,
(center.x + 100, y), gfx.Font.RIGHT)
def draw( self, frame ):
if self.model.type == Tile.Type.FLAT:
pos = Vec2D( self.model.pos.x * 32 + self.model.pos.y * 32 + frame.X_OFFSET,
-self.model.pos.x * 16 + self.model.pos.y * 16 + frame.Y_OFFSET)
if self.model.is_selected:
selected_surf = resman.get("game.selected_tile_surf")
selected_surf.draw( frame.surface, pos )
trail_surf = resman.get("game.trail%d_surf" % self.model.trail.type)
trail_surf.draw( frame.surface, pos )
if self.model.pickup is not None:
frame.draw( self.model.pickup )
def game_tick(self):
if self.progress <= 1.0:
end_pos = self.end_tile.get_center()
end_pos = Vec2D(end_pos[0], end_pos[1])
speed = 20.0 / (end_pos - self.start_pos).length()
self.progress += speed
self.pos = self.start_pos * (
1.0 - self.progress) + end_pos * self.progress
if self.progress > 1.0 and self.end_tile.pickup is None:
self.end_tile.pickup = pickups.CopperCoin()
x, y = self.end_tile.get_center()
self.end_tile.pickup.container = self.end_tile
def draw( self, frame ):
MultiDlg.draw( self, frame )
center = Vec2D( frame.surface.get_width()/2, frame.surface.get_height()/2 )
y = center.y - 180
skill = settings.SkillLevel(self.game_data.quest.get_skill(self.scenario))
self.font_tiny.draw( _("Played level as:"), frame.surface, (center.x-180, y + 70) )
self.font.draw( "%s" % skill.name, frame.surface, (center.x-140, y + 90) )
self.font_tiny.draw( _("Your current skill level:"), frame.surface, (center.x-180, y + 140) )
self.font_red.draw( "%s" % self.game_data.skill_level.name, frame.surface, (center.x-140, y + 160) )
self.draw_skill_bar( frame, center.x + 50, y + 70 )
def draw(self, frame):
for particle in self.particles:
particle.render(frame.surface, frame.X_OFFSET, frame.Y_OFFSET)
if self.animTimer is None:
self.animTimer = gfx.LoopAnimationTimer(
20, 0, 16) # real maxframe is in draw
self.animTimer.set_frame(frame.time_sec, 0)
if self.sprite is not None:
self.sprite.nr = self.animTimer.get_frame(frame.time_sec)
self.sprite.draw(frame.surface,
self.pos + Vec2D(frame.X_OFFSET, frame.Y_OFFSET))
if self.sprite.nr >= 15:
self.sprite = None
def draw( self, frame ):
MultiDlg.draw( self, frame )
center = Vec2D( frame.surface.get_width()/2, frame.surface.get_height()/2 )
y = center.y - 180
#self.large_font.draw( "Game: %s" % self.scenario.title,
# frame.surface, (center.x, y), gfx.Font.CENTER )
self.info.draw_title( frame.surface, frame.time_sec, (center.x, y) )
self.info.draw_pickup( frame.surface, frame.time_sec, (center.x + 50, 240 ) )
y += 50
self.font.draw( self.scenario.description, frame.surface,
(center.x, y), gfx.Font.CENTER )
def before_gameloop(self):
resman.read("data/resources.cfg")
self.game_data = GameData(self.userinput)
# apply configuration settings
SoundManager.set_sound_volume(self.config.sound_volume)
SoundManager.set_music_volume(self.config.music_volume)
# set state
self.menu = MonorailMenu(self.game_data)
self.game = MonorailGame(self.game_data)
self.editor = None
self.state = self.game
self.state = self.menu
# set window buttons
self.max_button = ImageButton(copy.copy(resman.get("game.max_button")),
Vec2D(800 - 16 - 4, 4))
def handle_events(self):
for event in pygame.event.get():
if event.type == QUIT:
self.game_is_done = True
self.user_exit = True
elif event.type == KEYDOWN and event.key == K_ESCAPE:
self.game_is_done = True
self.user_exit = True
# move mouse
self.userinput.mouse.feed_pos(
Vec2D(self.random(0, 800 - 1), self.random(0, 600 - 1)))
# maybe release mouse presses
down_buttons = self.userinput.mouse.down_buttons
while self.random(0, 1) == 0 and len(down_buttons) > 0:
self.userinput.mouse.feed_up(down_buttons[self.random(
0,
len(down_buttons) - 1)])
# generate mouse presses
while self.random(0, 1) == 0:
key = self.random(0, 5)
self.userinput.mouse.feed_down(key)
# maybe release key presses
down_buttons = self.userinput.key.down_buttons
while self.random(0, 1) == 0 and len(down_buttons) > 0:
self.userinput.key.feed_up(down_buttons[self.random(
0,
len(down_buttons) - 1)])
# feed random keys
while self.random(0, 10) <> 0:
key = ALL_KEYS[self.random(0, len(ALL_KEYS) - 1)]
self.userinput.key.feed_down(key)
# sometimes escape key
if self.random(0, 2**20) == 0:
key = K_ESCAPE
self.userinput.key.feed_down(key)
def get_pos(self, frame):
self.pos = None
if self.model.container is None or not hasattr(self.model.container,
"views"):
return None
self.pos = self.model.container.views[0].get_pickup_pos(frame)
if self.model.jump_cnt is not None:
if self.jump_pos is None:
self.jump_pos = self.pos
x = geo.lin_ipol(self.model.jump_cnt, self.jump_pos.x, self.pos.x)
y = geo.lin_ipol(self.model.jump_cnt, self.jump_pos.y, self.pos.y)
height = self.model.jump_cnt
if self.model.jump_cnt > 0.5:
height = 1.0 - self.model.jump_cnt
self.pos = Vec2D(x, y - 30 * height)
else:
self.jump_pos = None
return self.pos
def get_pickup_pos(self, frame):
x, y = self.model.get_center()
return Vec2D(x, y)
def get_pos(self, frame):
x = self.model.pos.x * 32 + self.model.pos.y * 32 + frame.X_OFFSET
y = -self.model.pos.x * 16 + self.model.pos.y * 16 + frame.Y_OFFSET
return Vec2D(x, y)
def draw(self, frame):
if self.get_pos(frame) is not None:
self.sprite.draw(
frame.surface,
self.get_pos(frame) +
Vec2D(frame.X_OFFSET, frame.Y_OFFSET - 20))
def draw(self, frame):
pos = self.pos + self.center + Vec2D(frame.X_OFFSET,
frame.Y_OFFSET)
self.surf.draw(frame.surface, pos)
def __init__(self):
Collectible.__init__(self, False)
self.pos = Vec2D(0, 0)
def get_screen_position( self, length ):
"""Returns tuple (x,y) of the position"""
in_dir = self.trail.get_in_direction()
out_dir = self.trail.get_out_direction()
if in_dir == Direction.NORTH:
if self.type == Tile.Type.NORTH_SLOPE_TOP: in_pos = Vec2D(-16, 8)
else: in_pos = Vec2D(-16, -8)
elif in_dir == Direction.EAST:
if self.type == Tile.Type.EAST_SLOPE_TOP: in_pos = Vec2D(16, 8)
else: in_pos = Vec2D(16,-8)
elif in_dir == Direction.SOUTH:
if self.type == Tile.Type.SOUTH_SLOPE_TOP: in_pos = Vec2D(16, 24)
else: in_pos = Vec2D(16,8)
elif in_dir == Direction.WEST:
if self.type == Tile.Type.WEST_SLOPE_TOP: in_pos = Vec2D(-16, 24)
else: in_pos = Vec2D(-16, 8)
if out_dir == Direction.NORTH:
if self.type == Tile.Type.SOUTH_SLOPE_BOT: out_pos = Vec2D(-16, -24)
else: out_pos = Vec2D(-16, -8)
elif out_dir == Direction.EAST:
if self.type == Tile.Type.WEST_SLOPE_BOT: out_pos = Vec2D(16, -24)
else: out_pos = Vec2D(16,-8)
elif out_dir == Direction.SOUTH:
if self.type == Tile.Type.NORTH_SLOPE_BOT: out_pos = Vec2D(16, -8)
else: out_pos = Vec2D(16,8)
elif out_dir == Direction.WEST:
if self.type == Tile.Type.EAST_SLOPE_BOT: out_pos = Vec2D(-16, -8)
else: out_pos = Vec2D(-16, 8)
if in_dir == out_dir.get_opposite():
pos = (in_pos * (self.get_length() - length) + out_pos * length) / self.get_length()
else:
interpol = float(length) / float( self.get_length() )
pos = in_pos - in_pos * math.sin( math.pi * interpol / 2.0 )
pos += out_pos * (1.0 - math.cos( math.pi * interpol / 2.0))
pos += Vec2D( self.pos.x * 32 + self.pos.y * 32 + 32,
-self.pos.x * 16 + self.pos.y * 16 + 16 )
return pos.get_tuple()
