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 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 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 __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)
