def update(self):
if MenuManager.showingCredits and self.x - self.left_pos > 3:
self.x = GameMath.lerp(self.x, self.left_pos, 0.1)
elif (not MenuManager.showingCredits) and self.right_pos - self.x > 3:
self.x = GameMath.lerp(self.x, self.right_pos, 0.1)
self.shouldDraw = not MenuManager.selectingLevels
def update(self):
if not MenuManager.showingCredits and not MenuManager.selectingLevels:
if (pygame.key.get_pressed()[pygame.K_RIGHT]
or pygame.key.get_pressed()[pygame.K_DOWN]
) and not self.previous_right and not self.previous_down:
self.switch_fx.play()
if self.currentTarget == 2:
Camera.rotation = -2 * math.pi / 6 + math.pi / 6
self.currentTarget += 1
if (pygame.key.get_pressed()[pygame.K_LEFT]
or pygame.key.get_pressed()[pygame.K_UP]
) and not self.previous_left and not self.previous_up:
self.switch_fx.play()
if self.currentTarget == 0:
Camera.rotation = 8 * math.pi / 6
self.currentTarget -= 1
if pygame.key.get_pressed()[pygame.K_RETURN] and not self.last_enter:
if self.currentTarget == 0 and not MenuManager.selectingLevels: # Play
MenuManager.selectingLevels = True
LevelPointer.current_level = 0
self.sweep_fx.play()
elif self.currentTarget == 1 and not MenuManager.showingCredits: # Credits
MenuManager.showingCredits = True
self.sweep_fx.play()
elif self.currentTarget == 2: # Exit
self.sweep_fx.play()
pygame.quit()
sys.exit(0)
elif self.currentTarget == 0 and MenuManager.selectingLevels: # Confirm level selection
MenuManager.level_to_load = LevelPointer.current_level
self.sweep_fx.play()
if pygame.key.get_pressed()[pygame.K_BACKSPACE]:
if MenuManager.selectingLevels or MenuManager.showingCredits:
self.sweep_fx.play()
MenuManager.selectingLevels = False
MenuManager.showingCredits = False
self.currentTarget = self.currentTarget % 3
self.level_to_play = self.level_to_play % 3
self.previous_left = pygame.key.get_pressed()[pygame.K_LEFT]
self.previous_right = pygame.key.get_pressed()[pygame.K_RIGHT]
self.previous_up = pygame.key.get_pressed()[pygame.K_UP]
self.previous_down = pygame.key.get_pressed()[pygame.K_DOWN]
self.last_enter = pygame.key.get_pressed()[pygame.K_RETURN]
Camera.rotation = GameMath.lerp(
Camera.rotation, self.currentTarget * math.pi / 3 + math.pi / 6,
0.15)
Colors.currentPalette = GameMath.palette_lerp(
Colors.currentPalette, Colors.menuPalettes[self.currentTarget],
0.15)
def get_window_pos(self):
normalized_pos = (GameMath.inverse_lerp(0, Settings.SCREEN_WIDTH,
self.x),
GameMath.inverse_lerp(0, Settings.SCREEN_HEIGHT,
self.y))
return (GameMath.no_clamp_lerp(0, Settings.WINDOW_WIDTH,
normalized_pos[0]),
GameMath.no_clamp_lerp(0, Settings.WINDOW_HEIGHT,
normalized_pos[1]))
def update_colors(self):
current_lerp_time = GameMath.inverse_lerp(self.last_changed_beat, self.last_changed_beat + MusicManager.crotchet * self.beats_to_change, MusicManager.get_song_position())
p1 = Levels.levels[GameManager.currentLevelIndex].current_palettes[0]
p2 = Levels.levels[GameManager.currentLevelIndex].current_palettes[1]
if self.fading_in:
Colors.currentPalette = GameMath.palette_lerp(p2, p1, current_lerp_time)
else:
Colors.currentPalette = GameMath.palette_lerp(p1, p2, current_lerp_time)
def get_max_magnitude(self, angle):
delta_angle = math.pi / GameManager.levelCurrentSides
p1 = GameMath.cil2cart_local(self.vert_mag + self.width / 2,
self.vert_angle - delta_angle)
p2 = GameMath.cil2cart_local(self.vert_mag + self.width / 2,
self.vert_angle + delta_angle)
p3 = (0, 0)
p4 = (math.cos(angle), math.sin(angle))
intersection = GameMath.intersection_between_lines(p1, p2, p3, p4)
return GameMath.cart2cil_local(intersection[0], intersection[1])[0]
def get_window_vertices(self):
window_verts = []
for v in self.get_camera_vertices():
normalized_vert = (GameMath.inverse_lerp(0, Settings.SCREEN_WIDTH,
v[0]),
GameMath.inverse_lerp(0, Settings.SCREEN_HEIGHT,
v[1]))
window_verts.append(
(GameMath.no_clamp_lerp(0, Settings.WINDOW_WIDTH,
normalized_vert[0]),
GameMath.no_clamp_lerp(0, Settings.WINDOW_HEIGHT,
normalized_vert[1])))
return window_verts
def RunGame(gameselector):
if not gameselector:
Mbox(gameselector, 0)
print('You are supposed to select a game you numbskul!')
return 0
elif gameselector[0] == 0:
GameCircles.GameRun()
return 0
elif gameselector[0] == 1:
GameSquares.GameRun()
return 0
elif gameselector[0] == 2:
GameMath.GameRun()
return 0
elif gameselector[0] == 3:
GameAlphabet.GameRun()
return 0
else:
Mbox(gameselector, 0)
print("Game is not yet developed")
def get_initial_verts(self):
verts = []
for i in range(6):
verts.append(
GameMath.cil2cart_local(Settings.MENU_HEXAGON_RADIUS,
i * math.pi * 2 / 6))
return verts
def set_verts(self):
delta_angle = math.pi / GameManager.levelCurrentSides
if GameManager.sideChangePercent != 0:
min_sides = min(GameManager.levelCurrentSides,
GameManager.levelNextSides)
if self.posIndex < min_sides:
delta_angle = GameMath.pow_lerp(
math.pi / GameManager.levelCurrentSides,
math.pi / GameManager.levelNextSides,
GameManager.sideChangePercent, Settings.LERP_POW)
else:
if min_sides == GameManager.levelNextSides:
delta_angle = GameMath.pow_lerp(
math.pi / GameManager.levelCurrentSides, 0,
GameManager.sideChangePercent, Settings.LERP_POW)
else:
delta_angle = GameMath.pow_lerp(
0, math.pi / GameManager.levelNextSides,
GameManager.sideChangePercent, Settings.LERP_POW)
vert1 = GameMath.cil2cart_local(self.vert_mag - self.width / 2,
self.vert_angle + delta_angle)
vert2 = GameMath.cil2cart_local(self.vert_mag - self.width / 2,
self.vert_angle - delta_angle)
vert3 = GameMath.cil2cart_local(self.vert_mag + self.width / 2,
self.vert_angle + delta_angle)
vert4 = GameMath.cil2cart_local(self.vert_mag + self.width / 2,
self.vert_angle - delta_angle)
self.vertices = [vert1, vert2, vert4, vert3]
def get_polygon_vertices(self, sides):
verts = []
delta_angle = 2 * math.pi / sides
for i in range(sides):
verts.append(
GameMath.cil2cart_local(self.polygonSize, i * delta_angle))
return verts
def set_vertices(self):
min_sides = min(GameManager.levelCurrentSides,
GameManager.levelNextSides)
start_delta_angle = (2 * math.pi / GameManager.levelCurrentSides)
end_delta_angle = (2 * math.pi / GameManager.levelNextSides)
current_delta_angle = GameMath.pow_lerp(start_delta_angle,
end_delta_angle,
GameManager.sideChangePercent,
Settings.LERP_POW)
vert1 = (0, 0)
vert2 = GameMath.cil2cart_local(self.max_screen_size * 2,
current_delta_angle * self.index)
vert3 = GameMath.cil2cart_local(self.max_screen_size * 2,
current_delta_angle * (self.index + 1))
if GameManager.sideChangePercent != 0 and self.index >= min_sides:
if GameManager.levelCurrentSides > GameManager.levelNextSides:
vert2 = GameMath.cil2cart_local(self.max_screen_size * 2,
start_delta_angle * self.index)
vert3 = GameMath.cil2cart_local(
self.max_screen_size * 2,
GameMath.pow_lerp(start_delta_angle * (self.index + 1),
2 * math.pi,
GameManager.sideChangePercent,
Settings.LERP_POW))
else:
vert2 = GameMath.cil2cart_local(self.max_screen_size * 2,
end_delta_angle * self.index)
vert3 = GameMath.cil2cart_local(
self.max_screen_size * 2,
GameMath.pow_lerp(2 * math.pi,
end_delta_angle * (self.index + 1),
GameManager.sideChangePercent,
Settings.LERP_POW))
self.vertices = [vert1, vert2, vert3]
def get_world_vertices(self):
world_verts = []
for v in self.vertices:
s_x = v[0] * self.scale
s_y = v[1] * self.scale
scaled_vert = (s_x, s_y)
r_x = scaled_vert[0] * math.cos(
self.rotation -
self.y) + scaled_vert[1] * math.sin(self.rotation - self.y)
r_y = -scaled_vert[0] * math.sin(
self.rotation -
self.y) + scaled_vert[1] * math.cos(self.rotation - self.y)
cart_pos = GameMath.cil2cart(self.x, self.y)
panned_x = r_x + cart_pos[0]
panned_y = r_y + cart_pos[1]
world_verts.append((panned_x, panned_y))
return world_verts
def get_angle(self):
angle = (self.posIndex + 0.5) * (math.pi * 2 /
GameManager.levelCurrentSides)
if GameManager.sideChangePercent != 0:
min_sides = min(GameManager.levelCurrentSides,
GameManager.levelNextSides)
start_angle = (self.posIndex +
0.5) * (math.pi * 2 / GameManager.levelCurrentSides)
end_angle = (self.posIndex + 0.5) * (math.pi * 2 /
GameManager.levelNextSides)
if self.posIndex >= min_sides:
if min_sides == GameManager.levelNextSides:
end_angle = 2 * math.pi
else:
start_angle = 2 * math.pi
angle = GameMath.pow_lerp(start_angle, end_angle,
GameManager.sideChangePercent,
Settings.LERP_POW)
return angle
def get_lerped_vertices(self, start_sides, end_sides, t):
min_sides = min(start_sides, end_sides)
power_to_lerp = Settings.LERP_POW
verts = []
start_delta_angle = 2 * math.pi / start_sides
end_delta_angle = 2 * math.pi / end_sides
current_delta_angle = GameMath.pow_lerp(start_delta_angle,
end_delta_angle, t,
power_to_lerp)
for i in range(min_sides):
verts.append(
GameMath.cil2cart_local(self.polygonSize,
i * current_delta_angle))
for i in range(abs(start_sides - end_sides)):
if start_sides > end_sides:
extra_end_angle = 2 * math.pi
extra_current_delta_angle = GameMath.pow_lerp(
start_delta_angle * (i + min_sides), extra_end_angle, t,
power_to_lerp)
verts.append(
GameMath.cil2cart_local(self.polygonSize,
extra_current_delta_angle))
else:
extra_start_angle = 2 * math.pi
extra_current_angle = GameMath.pow_lerp(
extra_start_angle, end_delta_angle * (i + min_sides), t,
power_to_lerp)
verts.append(
GameMath.cil2cart_local(self.polygonSize,
extra_current_angle))
return verts
def update(self):
if MenuManager.selectingLevels and self.x - self.left_pos > 3:
self.x = GameMath.lerp(self.x, self.left_pos, 0.1)
elif (not MenuManager.selectingLevels) and self.right_pos - self.x > 3:
self.x = GameMath.lerp(self.x, self.right_pos, 0.1)
def update_camera():
Camera.rotation += Camera.angular_speed
Camera.zoom = GameMath.lerp(Camera.zoom, Camera.target_zoom, 0.2)
def get_world_pos(self):
return GameMath.cil2cart(self.x, self.y)
def update(self):
if MenuManager.selectingLevels and self.x - 150 > 3:
self.x = GameMath.lerp(self.x, 150, 0.1)
elif (not MenuManager.selectingLevels) and 480 - self.x > 3:
self.x = GameMath.lerp(self.x, 480, 0.1)
