def wait(self): """Shows high scores until a new player is ready.""" heading_font = pygame.font.Font(s.FONTS["fipps"], 44) content_font = pygame.font.Font(s.FONTS["retro_computer"], 15) background = pygame.image.load(os.path.join("lib", "title.png")) heading_text = heading_font.render("High Scores", 1, s.COLOURS["text"]) y = 120 self.window.fill(s.COLOURS["black"]) self.window.blit(background, (0, 0)) self.window.blit(heading_text, (30, 3)) for score in self.high_scores.high_scores: date_text = content_font.render(score[0].strftime("%d %b %Y"), 1, s.COLOURS["text"]) score_text = content_font.render(str(score[1]), 1, s.COLOURS["text"]) self.window.blit(date_text, (30, y)) self.window.blit(score_text, (230, y)) y += 35 pygame.display.update() while self.waiting: for e in pygame.event.get(): u.try_quit(e) if e.type == KEYDOWN and e.key in [K_UP, K_RETURN]: self.waiting = False self.clock.tick(s.FPS)
def __pause_cycle(self): path = rospack.get_path('uchile_fun') path += "/src/uchile_fun/SwervinMervin/" # rospy.init_node('listener', anonymous=True) rospy.Subscriber("/bender/joy/joy0", Joy, callback) global pausa pause_font = pygame.font.Font(path + "lib/retro_computer.ttf", 64) pause_text = pause_font.render("Paused", 1, s.COLOURS["text"]) x = (s.DIMENSIONS[0] - pause_text.get_width()) / 2 y = (s.DIMENSIONS[1] - pause_text.get_height()) / 2 self.window.fill(s.COLOURS["black"]) self.window.blit(pause_text, (x, y)) for e in pygame.event.get(): u.try_quit(e) if e.type == pygame.KEYDOWN and e.key == pygame.K_RETURN: pygame.mixer.music.unpause() self.paused = False if pausa == 1: pygame.mixer.music.unpause() self.paused = False pausa = 0
def progress(self, window): self.frame += 1 window.fill(s.COLOURS["black"]) self.state_0_step(window) self.state_1_step(window) self.state_2_step(window) for e in pygame.event.get(): u.try_quit(e) if e.type == pygame.KEYDOWN and e.key == pygame.K_RETURN and self.ready: pygame.mixer.music.fadeout(1500) self.finished = True
def __pause_cycle(self): pause_font = pygame.font.Font(s.FONTS["retro_computer"], 64) pause_text = pause_font.render("Paused", 1, s.COLOURS["text"]) x = (s.DIMENSIONS[0] - pause_text.get_width()) / 2 y = (s.DIMENSIONS[1] - pause_text.get_height()) / 2 self.window.fill(s.COLOURS["black"]) self.window.blit(pause_text, (x, y)) for e in pygame.event.get(): u.try_quit(e) if e.type == pygame.KEYDOWN and e.key == pygame.K_RETURN: pygame.mixer.music.unpause() self.paused = False
def wait(self): """Shows high scores until a new player is ready.""" rospy.Subscriber("/bender/joy/joy0", Joy, callback) path = rospack.get_path('uchile_fun') path += "/src/uchile_fun/SwervinMervin/" global pausa # heading_font = pygame.font.Font(s.FONTS["fipps"], 44) # content_font = pygame.font.Font(s.FONTS["retro_computer"], 15) heading_font = pygame.font.Font(path + "lib/fipps.ttf", 44) content_font = pygame.font.Font(path + "lib/retro_computer.ttf", 15) background = pygame.image.load(os.path.join(path + "lib", "title.png")) heading_text = heading_font.render("High Scores", 1, s.COLOURS["text"]) y = 120 self.window.fill(s.COLOURS["black"]) self.window.blit(background, (0, 0)) self.window.blit(heading_text, (30, 3)) for score in self.high_scores.high_scores: date_text = content_font.render(score[0].strftime("%d %b %Y"), 1, s.COLOURS["text"]) score_text = content_font.render(str(score[1]), 1, s.COLOURS["text"]) self.window.blit(date_text, (30, y)) self.window.blit(score_text, (230, y)) y += 35 pygame.display.update() while self.waiting: for e in pygame.event.get(): u.try_quit(e) if e.type == KEYDOWN and e.key in [K_UP, K_RETURN]: self.waiting = False if pausa == 1: self.waiting = False pausa = 0 self.clock.tick(s.FPS)
def progress(self, window): txt_title = self.fonts["title"].render("Player Select", 1, s.COLOURS["text"]) player = s.PLAYERS[self.selected] lpad = 40 start_point = (s.DIMENSIONS[0] / 2) + (lpad / 2) step = player["sprites"]["mugshot_small"]["width"] large_mugshot = pygame.image.load(os.path.join("lib", player["sprites"]["mugshot_large"]["path"])) self.selection_colour = 1 if self.selection_colour == 0 else 0 window.blit(self.background, (0, 0)) window.blit(txt_title, ((s.DIMENSIONS[0] / 2) - (txt_title.get_size()[0] / 2), 10)) for i, p in enumerate(s.PLAYERS): details = p["sprites"]["mugshot_small"] mugshot = pygame.image.load(os.path.join("lib", details["path"])) x = start_point + (i * (step + lpad)) y = 120 window.blit(mugshot, (x, y)) if i == self.selected: bw = 10 pygame.draw.rect(window, s.COLOURS["selection"][self.selection_colour], [x - (bw / 2), y - (bw / 2), details["width"] + bw, details["width"] + bw], bw) # Player name and picture. window.blit(large_mugshot, (0, s.DIMENSIONS[1] - player["sprites"]["mugshot_large"]["height"])) window.blit(self.fonts["name"].render(player["name"], 1, s.COLOURS["text"]), (start_point - bw, 200)) window.blit(self.fonts["details"].render(player["city"], 1, s.COLOURS["text"]), (start_point - bw, 228)) # Player stats. desired_acceleration = int(self.normalise(player["acceleration_factor"], *s.HARD_ACCELERATION) * 155) desired_handling = int((1.0 - self.normalise(player["centrifugal_force"], *s.HARD_HANDLING)) * 155) desired_top_speed = int(self.normalise(player["top_speed"], *s.HARD_TOP_SPEED) * 155) window.blit(self.fonts["stats"].render("Acceleration", 1, s.COLOURS["text"]), (start_point - bw, 290)) window.blit(self.fonts["stats"].render("Handling", 1, s.COLOURS["text"]), (start_point - bw, 314)) window.blit(self.fonts["stats"].render("Speed", 1, s.COLOURS["text"]), (start_point - bw, 338)) su = pygame.Surface((155, 18), pygame.SRCALPHA) su.fill(s.COLOURS["opaque_white"]) window.blit(su, (start_point + 105, 285)) window.blit(su, (start_point + 105, 309)) window.blit(su, (start_point + 105, 333)) pygame.draw.rect(window, s.COLOURS["text"], [start_point + 105, 285, desired_acceleration, 18]) pygame.draw.rect(window, s.COLOURS["text"], [start_point + 105, 309, desired_handling, 18]) pygame.draw.rect(window, s.COLOURS["text"], [start_point + 105, 333, desired_top_speed, 18]) if self.player_chosen: self.finalise_selection(player) for e in pygame.event.get(): u.try_quit(e) if e.type == pygame.KEYDOWN and not self.player_chosen: if e.key == pygame.K_LEFT and self.selected > 0: self.selected -= 1 elif e.key == pygame.K_RIGHT and self.selected < len(s.PLAYERS) - 1: self.selected += 1 elif e.key == pygame.K_RETURN: self.player_chosen = True
def progress(self, window): txt_title = self.fonts["title"].render("Player Select", 1, s.COLOURS["text"]) player = s.PLAYERS[self.selected] lpad = 40 start_point = (s.DIMENSIONS[0] / 2) + (lpad / 2) step = player["sprites"]["mugshot_small"]["width"] large_mugshot = pygame.image.load( os.path.join("lib", player["sprites"]["mugshot_large"]["path"])) self.selection_colour = 1 if self.selection_colour == 0 else 0 window.blit(self.background, (0, 0)) window.blit(txt_title, ((s.DIMENSIONS[0] / 2) - (txt_title.get_size()[0] / 2), 10)) for i, p in enumerate(s.PLAYERS): details = p["sprites"]["mugshot_small"] mugshot = pygame.image.load(os.path.join("lib", details["path"])) x = start_point + (i * (step + lpad)) y = 120 window.blit(mugshot, (x, y)) if i == self.selected: bw = 10 pygame.draw.rect( window, s.COLOURS["selection"][self.selection_colour], [ x - (bw / 2), y - (bw / 2), details["width"] + bw, details["width"] + bw ], bw) # Player name and picture. window.blit(large_mugshot, (0, s.DIMENSIONS[1] - player["sprites"]["mugshot_large"]["height"])) window.blit( self.fonts["name"].render(player["name"], 1, s.COLOURS["text"]), (start_point - bw, 200)) window.blit( self.fonts["details"].render(player["city"], 1, s.COLOURS["text"]), (start_point - bw, 228)) # Player stats. desired_acceleration = int( self.normalise(player["acceleration_factor"], *s.HARD_ACCELERATION) * 155) desired_handling = int( (1.0 - self.normalise(player["centrifugal_force"], *s.HARD_HANDLING)) * 155) desired_top_speed = int( self.normalise(player["top_speed"], *s.HARD_TOP_SPEED) * 155) window.blit( self.fonts["stats"].render("Acceleration", 1, s.COLOURS["text"]), (start_point - bw, 290)) window.blit( self.fonts["stats"].render("Handling", 1, s.COLOURS["text"]), (start_point - bw, 314)) window.blit(self.fonts["stats"].render("Speed", 1, s.COLOURS["text"]), (start_point - bw, 338)) su = pygame.Surface((155, 18), pygame.SRCALPHA) su.fill(s.COLOURS["opaque_white"]) window.blit(su, (start_point + 105, 285)) window.blit(su, (start_point + 105, 309)) window.blit(su, (start_point + 105, 333)) pygame.draw.rect(window, s.COLOURS["text"], [start_point + 105, 285, desired_acceleration, 18]) pygame.draw.rect(window, s.COLOURS["text"], [start_point + 105, 309, desired_handling, 18]) pygame.draw.rect(window, s.COLOURS["text"], [start_point + 105, 333, desired_top_speed, 18]) if self.player_chosen: self.finalise_selection(player) for e in pygame.event.get(): u.try_quit(e) if e.type == pygame.KEYDOWN and not self.player_chosen: if e.key == pygame.K_LEFT and self.selected > 0: self.selected -= 1 elif e.key == pygame.K_RIGHT and self.selected < len( s.PLAYERS) - 1: self.selected += 1 elif e.key == pygame.K_RETURN: self.player_chosen = True
def progress(self, window): # rospy.init_node('listener', anonymous=True) rospy.Subscriber("/bender/joy/joy0", Joy, callback) path = rospack.get_path('uchile_fun') path += "/src/uchile_fun/SwervinMervin/" global RIGHT_LEFT global A global EXIT txt_title = self.fonts["title"].render("Player: Bender", 1, s.COLOURS["text"]) player = s.PLAYERS[self.selected] lpad = 40 start_point = (s.DIMENSIONS[0] / 2) + (lpad / 2) step = player["sprites"]["mugshot_small"]["width"] large_mugshot = pygame.image.load( os.path.join(path + "lib", player["sprites"]["mugshot_large"]["path"])) self.selection_colour = 1 if self.selection_colour == 0 else 0 window.blit(self.background, (0, 0)) window.blit(txt_title, ((s.DIMENSIONS[0] / 2) - (txt_title.get_size()[0] / 2), 10)) for i, p in enumerate(s.PLAYERS): details = p["sprites"]["mugshot_small"] mugshot = pygame.image.load( os.path.join(path + "lib", details["path"])) x = start_point + (i * (step + lpad)) y = 120 window.blit(mugshot, (x, y)) if i == self.selected: bw = 10 pygame.draw.rect( window, s.COLOURS["selection"][self.selection_colour], [ x - (bw / 2), y - (bw / 2), details["width"] + bw, details["width"] + bw ], bw) # Player name and picture. window.blit(large_mugshot, (0, s.DIMENSIONS[1] - player["sprites"]["mugshot_large"]["height"])) window.blit( self.fonts["name"].render(player["name"], 1, s.COLOURS["text"]), (start_point - bw, 200)) window.blit( self.fonts["details"].render(player["city"], 1, s.COLOURS["text"]), (start_point - bw, 228)) # Player stats. desired_acceleration = int( self.normalise(player["acceleration_factor"], *s.HARD_ACCELERATION) * 155) desired_handling = int( (1.0 - self.normalise(player["centrifugal_force"], *s.HARD_HANDLING)) * 155) desired_top_speed = int( self.normalise(player["top_speed"], *s.HARD_TOP_SPEED) * 155) window.blit( self.fonts["stats"].render("Acceleration", 1, s.COLOURS["text"]), (start_point - bw, 260)) window.blit( self.fonts["stats"].render("Handling", 1, s.COLOURS["text"]), (start_point - bw, 284)) window.blit(self.fonts["stats"].render("Speed", 1, s.COLOURS["text"]), (start_point - bw, 308)) su = pygame.Surface((155, 18), pygame.SRCALPHA) su.fill(s.COLOURS["opaque_white"]) window.blit(su, (start_point + 105, 255)) window.blit(su, (start_point + 105, 279)) window.blit(su, (start_point + 105, 303)) pygame.draw.rect(window, s.COLOURS["text"], [start_point + 105, 255, desired_acceleration, 18]) pygame.draw.rect(window, s.COLOURS["text"], [start_point + 105, 279, desired_handling, 18]) pygame.draw.rect(window, s.COLOURS["text"], [start_point + 105, 303, desired_top_speed, 18]) if self.player_chosen: self.finalise_selection(player) for e in pygame.event.get(): u.try_quit(e) if e.type == pygame.KEYDOWN and not self.player_chosen: if e.key == pygame.K_LEFT and self.selected > 0: self.selected -= 1 elif e.key == pygame.K_RIGHT and self.selected < len( s.PLAYERS) - 1: self.selected += 1 elif e.key == pygame.K_RETURN: self.player_chosen = True #self.selected += 1 if not self.player_chosen: # if RIGHT_LEFT>0 and self.selected > 0: # self.selected -= 1 # elif RIGHT_LEFT<0 and self.selected < len(s.PLAYERS) - 1: # self.selected += 1 if A == 1: FaceOrder.ChangeFace("happy3") self.player_chosen = True elif EXIT == 1: FaceOrder.ChangeFace("sad2") pygame.mixer.music.fadeout(2000) rospy.sleep(2) Talk.getInstance("oh! you don't want to play this game! ", 4) Talk.getInstance("let's go to the next one! ", 4) FaceOrder.ChangeFace("happy1") pygame.quit() #return sys.exit()
def __game_cycle(self): p = self.player l = self.level p.travel(l.track_length(), self.window) base_segment = l.find_segment(p.position) player_segment = l.find_segment(p.position + s.PLAYER_Z) p.accelerate() p.steer(player_segment) p.climb(base_segment) p.detect_collisions(player_segment) p.handle_crash() # Sprinkle some random bonuses into the next lap if we are lucky. if p.new_lap: if random.randint(1, s.CHANCE_OF_BONUSES) == 1: l.insert_bonuses() # Move the other players. for c in l.competitors: old_seg = l.find_segment(c.position) c.travel(l.track_length()) new_seg = l.find_segment(c.position) c.play_engine(p.position) if old_seg.index != new_seg.index: if c in old_seg.competitors: old_seg.competitors.remove(c) new_seg.competitors.append(c) coverage = [base_segment, base_segment, base_segment] tunnel_exit = base_segment pre_renders = [] curve = 0 curve_delta = -(base_segment.curve * p.segment_percent()) # Position backgrounds according to current curve. for bg in l.backgrounds: if base_segment.curve != 0: bg.step(base_segment.curve, p.speed_percent()) bg.render(self.window) # Loop through segments we should draw for this frame. for i in range(s.DRAW_DISTANCE): segment = l.offset_segment(base_segment.index + i) projected_position = p.position camera_x = p.x * s.ROAD_WIDTH # Past end of track and looped back. if segment.index < base_segment.index: projected_position -= l.track_length() segment.project(camera_x, curve, curve_delta, projected_position, p.y) curve += curve_delta curve_delta += segment.curve # Remember biggest LEFT, TOP, RIGHT coordinates so we can clip sprites later. segment.clip = [ coverage[0].bottom["screen"]["x"] - coverage[0].bottom["screen"]["w"], coverage[1].top["screen"]["y"], coverage[2].bottom["screen"]["x"] + coverage[2].bottom["screen"]["w"]] if len(segment.pre_polygons) > 0: pre_renders.append(segment) if segment.tunnel_end: tunnel_exit = segment if segment.should_ignore(coverage[1]): continue segment.render_grass(self.window) segment.render_road(self.window) if (segment.top["screen"]["y"] > coverage[1].top["screen"]["y"]): coverage[1] = segment # Remember where we should draw the left and right tunnel walls. if segment.in_tunnel: s_top = segment.top["screen"] tl_top = coverage[0].top["screen"] tr_top = coverage[2].top["screen"] if (s_top["x"] - s_top["w"]) > (tl_top["x"] - tl_top["w"]): coverage[0] = segment if (s_top["x"] + s_top["w"]) < (tr_top["x"] + tr_top["w"]): coverage[2] = segment # Draw tunnel roof and walls. if base_segment.in_tunnel: self.player.in_tunnel = True tunnel_exit.render_tunnel_roof(self.window, coverage[1].top["screen"]["y"]) coverage[0].render_left_tunnel(self.window) coverage[2].render_right_tunnel(self.window) else: self.player.in_tunnel = False # Let backgrounds know how much height they need to cover on the next paint. for bg in l.backgrounds: bg.visible_height = s.DIMENSIONS[1] - coverage[1].top["screen"]["y"] # Draw sprites in from back to front (painters algorithm). for segment in reversed(pre_renders): segment.render_polygons(self.window, coverage) for i in reversed(range(1, s.DRAW_DISTANCE)): segment = l.offset_segment(base_segment.index + i) segment.render_world_objects(self.window) p.render(self.window, base_segment) p.render_hud(self.window) if p.blood_alpha > 0: p.render_blood(self.window) for e in pygame.event.get(): u.try_quit(e) if e.type == pygame.KEYDOWN and e.key == pygame.K_RETURN: pygame.mixer.music.pause() self.paused = True # Steering, acceleration. keys = pygame.key.get_pressed() p.set_acceleration(keys) p.set_direction(keys)
def __game_cycle(self): p = self.player l = self.level p.travel(l.track_length(), self.window) base_segment = l.find_segment(p.position) player_segment = l.find_segment(p.position + s.PLAYER_Z) p.accelerate() p.steer(player_segment) p.climb(base_segment) p.detect_collisions(player_segment) p.handle_crash() # Sprinkle some random bonuses into the next lap if we are lucky. if p.new_lap: if random.randint(1, s.CHANCE_OF_BONUSES) == 1: l.insert_bonuses() # Move the other players. for c in l.competitors: old_seg = l.find_segment(c.position) c.travel(l.track_length()) new_seg = l.find_segment(c.position) c.play_engine(p.position) if old_seg.index != new_seg.index: if c in old_seg.competitors: old_seg.competitors.remove(c) new_seg.competitors.append(c) coverage = [base_segment, base_segment, base_segment] tunnel_exit = base_segment pre_renders = [] curve = 0 curve_delta = -(base_segment.curve * p.segment_percent()) # Position backgrounds according to current curve. for bg in l.backgrounds: if base_segment.curve != 0: bg.step(base_segment.curve, p.speed_percent()) bg.render(self.window) # Loop through segments we should draw for this frame. for i in range(s.DRAW_DISTANCE): segment = l.offset_segment(base_segment.index + i) projected_position = p.position camera_x = p.x * s.ROAD_WIDTH # Past end of track and looped back. if segment.index < base_segment.index: projected_position -= l.track_length() segment.project(camera_x, curve, curve_delta, projected_position, p.y) curve += curve_delta curve_delta += segment.curve # Remember biggest LEFT, TOP, RIGHT coordinates so we can clip sprites later. segment.clip = [ coverage[0].bottom["screen"]["x"] - coverage[0].bottom["screen"]["w"], coverage[1].top["screen"]["y"], coverage[2].bottom["screen"]["x"] + coverage[2].bottom["screen"]["w"] ] if len(segment.pre_polygons) > 0: pre_renders.append(segment) if segment.tunnel_end: tunnel_exit = segment if segment.should_ignore(coverage[1]): continue segment.render_grass(self.window) segment.render_road(self.window) if (segment.top["screen"]["y"] > coverage[1].top["screen"]["y"]): coverage[1] = segment # Remember where we should draw the left and right tunnel walls. if segment.in_tunnel: s_top = segment.top["screen"] tl_top = coverage[0].top["screen"] tr_top = coverage[2].top["screen"] if (s_top["x"] - s_top["w"]) > (tl_top["x"] - tl_top["w"]): coverage[0] = segment if (s_top["x"] + s_top["w"]) < (tr_top["x"] + tr_top["w"]): coverage[2] = segment # Draw tunnel roof and walls. if base_segment.in_tunnel: self.player.in_tunnel = True tunnel_exit.render_tunnel_roof(self.window, coverage[1].top["screen"]["y"]) coverage[0].render_left_tunnel(self.window) coverage[2].render_right_tunnel(self.window) else: self.player.in_tunnel = False # Let backgrounds know how much height they need to cover on the next paint. for bg in l.backgrounds: bg.visible_height = s.DIMENSIONS[1] - coverage[1].top["screen"]["y"] # Draw sprites in from back to front (painters algorithm). for segment in reversed(pre_renders): segment.render_polygons(self.window, coverage) for i in reversed(range(1, s.DRAW_DISTANCE)): segment = l.offset_segment(base_segment.index + i) segment.render_world_objects(self.window) p.render(self.window, base_segment) p.render_hud(self.window) if p.blood_alpha > 0: p.render_blood(self.window) for e in pygame.event.get(): u.try_quit(e) if e.type == pygame.KEYDOWN and e.key == pygame.K_RETURN: pygame.mixer.music.pause() self.paused = True # Steering, acceleration. keys = pygame.key.get_pressed() p.set_acceleration(keys) p.set_direction(keys) gameplay = np.flip(pygame.surfarray.pixels3d(self.window), axis=(0, 2)) gameplay = np.rot90(gameplay, k=-1) ret, gameplay = cv2.imencode('.jpg', gameplay) ret, video = self.cam.read() video = cv2.resize(video, s.DIMENSIONS) ret, video = cv2.imencode('.jpg', video) publish.single("gameplay", gameplay.tobytes(), hostname="mr4b11zrabb.messaging.mymaas.net", port=1883, auth={ 'username': "******", 'password': "******" }, transport="tcp") publish.single("video", video.tobytes(), hostname="mr4b11zrabb.messaging.mymaas.net", port=1883, auth={ 'username': "******", 'password': "******" }, transport="tcp")
def __game_cycle(self): # rospy.init_node('listener', anonymous=True) rospy.Subscriber("/bender/joy/joy0", Joy, callback) global pausa p = self.player l = self.level resp = p.travel(l.track_length(), self.window) if resp == "exit": return resp base_segment = l.find_segment(p.position) player_segment = l.find_segment(p.position + s.PLAYER_Z) p.accelerate() p.steer(player_segment) p.climb(base_segment) p.detect_collisions(player_segment) p.handle_crash() # Sprinkle some random bonuses into the next lap if we are lucky. if p.new_lap: if random.randint(1, s.CHANCE_OF_BONUSES) == 1: l.insert_bonuses() # Move the other players. for c in l.competitors: old_seg = l.find_segment(c.position) c.travel(l.track_length()) new_seg = l.find_segment(c.position) c.play_engine(p.position) if old_seg.index != new_seg.index: if c in old_seg.competitors: old_seg.competitors.remove(c) new_seg.competitors.append(c) coverage = [base_segment, base_segment, base_segment] tunnel_exit = base_segment pre_renders = [] curve = 0 curve_delta = -(base_segment.curve * p.segment_percent()) # Position backgrounds according to current curve. for bg in l.backgrounds: if base_segment.curve != 0: bg.step(base_segment.curve, p.speed_percent()) bg.render(self.window) # Loop through segments we should draw for this frame. for i in range(s.DRAW_DISTANCE): segment = l.offset_segment(base_segment.index + i) projected_position = p.position camera_x = p.x * s.ROAD_WIDTH # Past end of track and looped back. if segment.index < base_segment.index: projected_position -= l.track_length() segment.project(camera_x, curve, curve_delta, projected_position, p.y) curve += curve_delta curve_delta += segment.curve # Remember biggest LEFT, TOP, RIGHT coordinates so we can clip sprites later. segment.clip = [ coverage[0].bottom["screen"]["x"] - coverage[0].bottom["screen"]["w"], coverage[1].top["screen"]["y"], coverage[2].bottom["screen"]["x"] + coverage[2].bottom["screen"]["w"] ] if len(segment.pre_polygons) > 0: pre_renders.append(segment) if segment.tunnel_end: tunnel_exit = segment if segment.should_ignore(coverage[1]): continue segment.render_grass(self.window) segment.render_road(self.window) if (segment.top["screen"]["y"] > coverage[1].top["screen"]["y"]): coverage[1] = segment # Remember where we should draw the left and right tunnel walls. if segment.in_tunnel: s_top = segment.top["screen"] tl_top = coverage[0].top["screen"] tr_top = coverage[2].top["screen"] if (s_top["x"] - s_top["w"]) > (tl_top["x"] - tl_top["w"]): coverage[0] = segment if (s_top["x"] + s_top["w"]) < (tr_top["x"] + tr_top["w"]): coverage[2] = segment # Draw tunnel roof and walls. if base_segment.in_tunnel: self.player.in_tunnel = True tunnel_exit.render_tunnel_roof(self.window, coverage[1].top["screen"]["y"]) coverage[0].render_left_tunnel(self.window) coverage[2].render_right_tunnel(self.window) else: self.player.in_tunnel = False # Let backgrounds know how much height they need to cover on the next paint. for bg in l.backgrounds: bg.visible_height = s.DIMENSIONS[1] - coverage[1].top["screen"]["y"] # Draw sprites in from back to front (painters algorithm). for segment in reversed(pre_renders): segment.render_polygons(self.window, coverage) for i in reversed(range(1, s.DRAW_DISTANCE)): segment = l.offset_segment(base_segment.index + i) segment.render_world_objects(self.window) p.render(self.window, base_segment) # p.render_hud(self.window) resp = p.render_hud(self.window) #print resp if resp == "over": return resp if resp == "win": return resp if p.blood_alpha > 0: p.render_blood(self.window) for e in pygame.event.get(): u.try_quit(e) if e.type == pygame.KEYDOWN and e.key == pygame.K_RETURN: pygame.mixer.music.pause() self.paused = True if pausa == 1: pygame.mixer.music.pause() self.paused = True pausa = 0 # Steering, acceleration. keys = pygame.key.get_pressed() p.set_acceleration(keys) p.set_direction(keys)