def __init__(self, width=1000, height=600):
super().__init__()
color = (255, 255, 255)
gate_width = 100
gate_height = 300
self.width = width
self.width = height
self.points = [[-width / 2, gate_height / 2, -width / 2, height / 2],
[-width / 2, height / 2, width / 2, height / 2],
[width / 2, height / 2, width / 2, gate_height / 2],
[-width / 2, -gate_height / 2, -width / 2, -height / 2],
[-width / 2, -height / 2, width / 2, -height / 2],
[width / 2, -height / 2, width / 2, -gate_height / 2]]
for [s_x, s_y, e_x, e_y] in self.points:
self.append(
arcade.create_line(s_x,
s_y,
e_x,
e_y,
color=color,
line_width=5))
points = [(-width / 2 - gate_width, -gate_height / 2),
(-width / 2 - gate_width, +gate_height / 2),
(-width / 2, +gate_height / 2),
(-width / 2, -gate_height / 2)]
self.gate_b = arcade.create_rectangle_filled_with_colors(
point_list=points, color_list=[(40, 40, 200)] * len(points))
self.gate_b.center_x = SCREEN_WIDTH / 2 - width / 2 - gate_width / 2
self.gate_b.center_y = SCREEN_HEIGHT / 2
points = [(width / 2 + gate_width, -gate_height / 2),
(width / 2 + gate_width, +gate_height / 2),
(width / 2, +gate_height / 2), (width / 2, -gate_height / 2)]
self.gate_r = arcade.create_rectangle_filled_with_colors(
point_list=points, color_list=[(200, 40, 40)] * len(points))
self.gate_r.center_x = SCREEN_WIDTH / 2 + width / 2 + gate_width / 2
self.gate_r.center_y = SCREEN_HEIGHT / 2
self.center_x = SCREEN_WIDTH / 2
self.center_y = SCREEN_HEIGHT / 2
self.append(self.gate_b)
self.append(self.gate_r)
self.append(
arcade.create_line(s_x, s_y, e_x, e_y, color=color, line_width=5))
self.append(
arcade.create_line(s_x, s_y, e_x, e_y, color=color, line_width=5))
def __init__(self, width, height, title):
"""
Set up the application.
"""
super().__init__(width, height, title)
arcade.set_background_color(arcade.color.BLACK)
self.shapes = arcade.ShapeElementList()
# This is a large rectangle that fills the whole
# background. The gradient goes between the two colors
# top to bottom.
color1 = (215, 214, 165)
color2 = (219, 166, 123)
points = (0, 0), (SCREEN_WIDTH, 0), (SCREEN_WIDTH, SCREEN_HEIGHT), (0, SCREEN_HEIGHT)
colors = (color1, color1, color2, color2)
rect = arcade.create_rectangle_filled_with_colors(points, colors)
self.shapes.append(rect)
# Another rectangle, but in this case the color doesn't change. Just the
# transparency. This time it goes from left to right.
color1 = (165, 92, 85, 255)
color2 = (165, 92, 85, 0)
points = (100, 100), (SCREEN_WIDTH - 100, 100), (SCREEN_WIDTH - 100, 300), (100, 300)
colors = (color2, color1, color1, color2)
rect = arcade.create_rectangle_filled_with_colors(points, colors)
self.shapes.append(rect)
# Two lines
color1 = (7, 67, 88)
color2 = (69, 137, 133)
points = (100, 400), (SCREEN_WIDTH - 100, 400), (SCREEN_WIDTH - 100, 500), (100, 500)
colors = [color2, color1, color2, color1]
shape = arcade.create_lines_with_colors(points, colors, line_width=5)
self.shapes.append(shape)
# Triangle
color1 = (215, 214, 165)
color2 = (219, 166, 123)
color3 = (165, 92, 85)
points = (SCREEN_WIDTH // 2, 500), (SCREEN_WIDTH // 2 - 100, 400), (SCREEN_WIDTH // 2 + 100, 400)
colors = (color1, color2, color3)
shape = arcade.create_triangles_filled_with_colors(points, colors)
self.shapes.append(shape)
# Ellipse, gradient between center and outside
color1 = (69, 137, 133, 127)
color2 = (7, 67, 88, 127)
shape = arcade.create_ellipse_filled_with_colors(SCREEN_WIDTH // 2, 350, 50, 50,
inside_color=color1, outside_color=color2)
self.shapes.append(shape)
def setup(self):
"""
This, and any function with the arcade.decorator.init decorator,
is run automatically on start-up.
"""
self.mountains = []
background = arcade.ShapeElementList()
color1 = (195, 157, 224)
color2 = (240, 203, 163)
points = (0, 0), (SCREEN_WIDTH, 0), (SCREEN_WIDTH,
SCREEN_HEIGHT), (0, SCREEN_HEIGHT)
colors = (color1, color1, color2, color2)
rect = arcade.create_rectangle_filled_with_colors(points, colors)
background.append(rect)
self.mountains.append(background)
layer_4 = create_mountain_range([0, 350], [SCREEN_WIDTH, 320], 1.1,
250, 8, (158, 98, 204))
self.mountains.append(layer_4)
layer_3 = create_mountain_range([0, 270], [SCREEN_WIDTH, 190], 1.1,
120, 9, (130, 79, 138))
self.mountains.append(layer_3)
layer_2 = create_mountain_range([0, 180], [SCREEN_WIDTH, 80], 1.2, 30,
12, (68, 28, 99))
self.mountains.append(layer_2)
layer_1 = create_mountain_range([250, 0], [SCREEN_WIDTH, 200], 1.4, 20,
12, (49, 7, 82))
self.mountains.append(layer_1)
def generate_gradient_background(self):
color1 = (26, 15, 35)
color2 = (75, 39, 83)
points = (0, 0), (SCREEN_WIDTH, 0), (SCREEN_WIDTH,
SCREEN_HEIGHT), (0, SCREEN_HEIGHT)
colors = (color1, color1, color2, color2)
rect = arcade.create_rectangle_filled_with_colors(points, colors)
self.shapes.append(rect)
def __init__(self, width, height, title):
"""
Set up the application.
"""
super().__init__(width, height, title)
self.shape_list = arcade.ShapeElementList()
self.shape_list.center_x = SCREEN_WIDTH // 2
self.shape_list.center_y = SCREEN_HEIGHT // 2
self.shape_list.angle = 0
point_list = ((0, 50), (10, 10), (50, 0), (10, -10), (0, -50),
(-10, -10), (-50, 0), (-10, 10), (0, 50))
colors = [
getattr(arcade.color, color) for color in dir(arcade.color)
if not color.startswith("__")
]
for i in range(5):
x = SCREEN_WIDTH // 2 - random.randrange(SCREEN_WIDTH - 50)
y = SCREEN_HEIGHT // 2 - random.randrange(SCREEN_HEIGHT - 50)
color = random.choice(colors)
points = [(px + x, py + y) for px, py in point_list]
my_line_strip = arcade.create_line_strip(points, color, 5)
self.shape_list.append(my_line_strip)
point_list = ((-50, -50), (0, 40), (50, -50))
for i in range(5):
x = SCREEN_WIDTH // 2 - random.randrange(SCREEN_WIDTH - 50)
y = SCREEN_HEIGHT // 2 - random.randrange(SCREEN_HEIGHT - 50)
points = [(px + x, py + y) for px, py in point_list]
triangle_filled = arcade.create_triangles_filled_with_colors(
points, random.sample(colors, 3))
self.shape_list.append(triangle_filled)
point_list = ((-50, -70), (-50, 70), (50, 70), (50, -70))
for i in range(5):
x = SCREEN_WIDTH // 2 - random.randrange(SCREEN_WIDTH - 50)
y = SCREEN_HEIGHT // 2 - random.randrange(SCREEN_HEIGHT - 50)
points = [(px + x, py + y) for px, py in point_list]
rect_filled = arcade.create_rectangle_filled_with_colors(
points, random.sample(colors, 4))
self.shape_list.append(rect_filled)
point_list = ((100, 100), (50, 150), (100, 200), (200, 200),
(250, 150), (200, 100))
poly = arcade.create_polygon(point_list, (255, 10, 10))
self.shape_list.append(poly)
ellipse = arcade.create_ellipse(20, 30, 50, 20, (230, 230, 0))
self.shape_list.append(ellipse)
arcade.set_background_color(arcade.color.BLACK)
self.offscreen = self.ctx.framebuffer(
color_attachments=self.ctx.texture((SCREEN_WIDTH, SCREEN_HEIGHT),
wrap_x=gl.GL_CLAMP_TO_EDGE,
wrap_y=gl.GL_CLAMP_TO_EDGE))
self.glow = postprocessing.BloomEffect((SCREEN_WIDTH, SCREEN_HEIGHT))
def __init__(self, width, height):
"""
Set up the application.
"""
super().__init__(width, height)
self.shape_list = arcade.ShapeElementList()
self.shape_list.center_x = SCREEN_WIDTH // 2
self.shape_list.center_y = SCREEN_HEIGHT // 2
self.shape_list.angle = 0
point_list = ((0, 50), (10, 10), (50, 0), (10, -10), (0, -50),
(-10, -10), (-50, 0), (-10, 10), (0, 50))
colors = [
getattr(arcade.color, color) for color in dir(arcade.color)
if not color.startswith("__")
]
for i in range(5):
x = SCREEN_WIDTH // 2 - random.randrange(SCREEN_WIDTH - 50)
y = SCREEN_HEIGHT // 2 - random.randrange(SCREEN_HEIGHT - 50)
color = random.choice(colors)
points = [(px + x, py + y) for px, py in point_list]
my_line_strip = arcade.create_line_strip(points, color, 5)
self.shape_list.append(my_line_strip)
point_list = ((-50, -50), (0, 40), (50, -50))
for i in range(5):
x = SCREEN_WIDTH // 2 - random.randrange(SCREEN_WIDTH - 50)
y = SCREEN_HEIGHT // 2 - random.randrange(SCREEN_HEIGHT - 50)
points = [(px + x, py + y) for px, py in point_list]
triangle_filled = arcade.create_triangles_filled_with_colors(
points, random.sample(colors, 3))
self.shape_list.append(triangle_filled)
point_list = ((-50, -70), (-50, 70), (50, 70), (50, -70))
for i in range(5):
x = SCREEN_WIDTH // 2 - random.randrange(SCREEN_WIDTH - 50)
y = SCREEN_HEIGHT // 2 - random.randrange(SCREEN_HEIGHT - 50)
points = [(px + x, py + y) for px, py in point_list]
rect_filled = arcade.create_rectangle_filled_with_colors(
points, random.sample(colors, 4))
self.shape_list.append(rect_filled)
point_list = ((100, 100), (50, 150), (100, 200), (200, 200),
(250, 150), (200, 100))
poly = arcade.create_polygon(point_list, (255, 10, 10), 5)
self.shape_list.append(poly)
ellipse = arcade.create_ellipse(20, 30, 50, 20, (230, 230, 0))
self.shape_list.append(ellipse)
arcade.set_background_color(arcade.color.BLACK)
def __init__(self, width, height, title):
super().__init__(width, height, title)
self.shapes = arcade.ShapeElementList()
color1 = (10, 90, 120)
color2 = (0, 20, 32)
points = (0, 0), (SCREEN_WIDTH, 0), (SCREEN_WIDTH, SCREEN_HEIGHT), (0, SCREEN_HEIGHT)
colors = (color1, color1, color2, color2)
rect = arcade.create_rectangle_filled_with_colors(points, colors)
self.shapes.append(rect)
self.raindrop_list = None
def create_mountain_range(start, end, roughness, vertical_displacement,
num_of_iterations, color_start):
shape_list = arcade.ShapeElementList()
layer_1 = midpoint_displacement(start, end, roughness,
vertical_displacement, num_of_iterations)
layer_1 = fix_points(layer_1)
color_list = [color_start] * len(layer_1)
lines = arcade.create_rectangle_filled_with_colors(layer_1, color_list)
shape_list.append(lines)
return shape_list
def __init__(self, width, height):
super().__init__()
self.width = width
self.height = height
# Create the background color and append to the shape list.
bg_points = [(0, height), (width, height), (width, 0), (0, 0)]
bg_color_top = arcade.color.BLACK
bg_color_bottom = arcade.color.MIDNIGHT_BLUE
bg_colors = [
bg_color_top, bg_color_top, bg_color_bottom, bg_color_bottom
]
bg_rect = arcade.create_rectangle_filled_with_colors(
bg_points, bg_colors)
self.append(bg_rect)
# Generate a large number of small stars and a few big ones.
self.generate_stars(SMALL_STARS_MIN, SMALL_STARS_MAX,
SMALL_STAR_RADIUS_MIN, SMALL_STAR_RADIUS_MAX)
self.generate_stars(LARGE_STARS_MIN, LARGE_STARS_MAX,
LARGE_STAR_RADIUS_MIN, LARGE_STAR_RADIUS_MAX)
def on_draw(self):
arcade.start_render()
arcade.draw_lrwh_rectangle_textured(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT,
self.background)
self.title_text.draw()
arcade.draw_text(self.progress_message,
SCREEN_WIDTH // 2,
SCREEN_HEIGHT * 0.6,
arcade.color.WHITE,
font_size=18,
anchor_x="center")
gradient_color1 = (255, 215, 0, 255)
gradient_color2 = (255, 215, 0, 0)
gradient_colors = (gradient_color2, gradient_color1, gradient_color1,
gradient_color2)
loading_bar_x_left = SCREEN_WIDTH * 0.1
loading_bar_y_down = SCREEN_HEIGHT * 0.45
loading_bar_y_up = SCREEN_HEIGHT * 0.55
loading_bar_progress_x = SCREEN_WIDTH * 0.8 * (
self.progress / GAME_LOAD_COUNT) + SCREEN_WIDTH * 0.1
points = ((loading_bar_x_left, loading_bar_y_down),
(loading_bar_progress_x, loading_bar_y_down),
(loading_bar_progress_x,
loading_bar_y_up), (loading_bar_x_left, loading_bar_y_up))
loading_bar = arcade.create_rectangle_filled_with_colors(
points, gradient_colors)
loading_bar.draw()
self.star.center_x = loading_bar_progress_x
self.star.draw()
def __init__(self):
"""
Set up the application.
"""
super().__init__()
self.shapes = arcade.ShapeElementList()
# This is a large rectangle that fills the whole
# background. The gradient goes between the two colors
# top to bottom.
color1 = (6, 90, 182)
color2 = (72, 177, 191)
points = (0, 0), (SCREEN_WIDTH, 0), (SCREEN_WIDTH, SCREEN_HEIGHT), (0, SCREEN_HEIGHT)
colors = (color1, color1, color2, color2)
rect = arcade.create_rectangle_filled_with_colors(points, colors)
self.shapes.append(rect)
self.alexander_image = arcade.Sprite(":resources:images/hamilton.png", 0.3)
self.alexander_image.center_x = 80
self.alexander_image.center_y = 200
self.welcome_image = arcade.Sprite(":resources:images/wel.png", 1)
self.welcome_image.center_x = 200
self.welcome_image.center_y = 500
def make_objects():
shape_list = arcade.ShapeElementList()
center_x = 0
center_y = 0
width = 20
height = 20
shape = arcade.create_ellipse_filled(center_x, center_y, width, height,
arcade.color.WHITE)
shape_list.append(shape)
center_x += 40
shape = arcade.create_ellipse_outline(center_x,
center_y,
width,
height,
arcade.color.RED,
border_width=1)
shape_list.append(shape)
center_x += 40
shape = arcade.create_ellipse_outline(center_x,
center_y,
width,
height,
arcade.color.DARK_RED,
border_width=1)
shape_list.append(shape)
shape = arcade.create_line(0, 0, 80, 0, arcade.color.BLUE, line_width=1)
shape_list.append(shape)
shape = arcade.create_line(0,
0,
80,
0,
arcade.color.LIGHT_BLUE,
line_width=1)
shape_list.append(shape)
center_x = 0
center_y = 50
width = 20
height = 20
outside_color = arcade.color.AERO_BLUE
inside_color = arcade.color.AFRICAN_VIOLET
tilt_angle = 45
shape = arcade.create_ellipse_filled_with_colors(center_x, center_y, width,
height, outside_color,
inside_color, tilt_angle)
shape_list.append(shape)
center_x = 0
center_y = -50
width = 20
height = 20
shape = arcade.create_rectangle_filled(center_x, center_y, width, height,
arcade.color.WHITE)
shape_list.append(shape)
shape = arcade.create_rectangle_outline(center_x,
center_y,
width,
height,
arcade.color.BLACK,
border_width=1)
shape_list.append(shape)
shape = arcade.create_rectangle_outline(center_x,
center_y,
width,
height,
arcade.color.AMERICAN_ROSE,
border_width=1)
shape_list.append(shape)
color1 = (215, 214, 165)
color2 = (219, 166, 123)
points = (70, 70), (150, 70), (150, 150), (70, 150)
colors = (color1, color1, color2, color2)
shape = arcade.create_rectangle_filled_with_colors(points, colors)
shape_list.append(shape)
points = (0, 0), (150, 150), (0, 150), (0, 250)
shape = arcade.create_line_strip(points, arcade.color.AFRICAN_VIOLET)
shape_list.append(shape)
points = (0, 0), (75, 90), (60, 150), (90, 250)
shape = arcade.create_line_generic(points, arcade.color.ALIZARIN_CRIMSON,
gl.GL_TRIANGLE_FAN)
shape_list.append(shape)
return shape_list
def setup(self):
super().setup()
# Load song and get waveform
with LogSection(logger, "loading song and waveform"):
with pkg_resources.path(charm.data.audio, "fourth_wall.wav") as p:
self._song = arcade.load_sound(p)
load = librosa.load(p, mono=True)
self.waveform: ndarray[float] = load[0]
self.sample_rate: int = load[1]
# Create an index of samples
with LogSection(logger, "indexing samples"):
samples: list[SoundPoint] = []
for n, s in enumerate(self.waveform):
samples.append(SoundPoint((1 / self.sample_rate) * n, s))
self.samples = nindex.Index(samples, "time")
# Create an index of beats
with LogSection(logger, "indexing beats"):
self.bpm, beats = librosa.beat.beat_track(y = self.waveform, sr = self.sample_rate, units = "time")
self.beats = nindex.Index([Beat(t) for t in beats[::2]], "time")
self.chart_available = False
# Create an index of chart notes
with LogSection(logger, "parsing chart"):
path = songspath / "fnf" / "fourth-wall"
self.songdata = FNFSong.parse(path)
if self.songdata:
with LogSection(logger, "indexing notes"):
self.chart_available = True
self.player_chart = nindex.Index(self.songdata.charts[0].notes, "time")
enemy_chart = self.songdata.get_chart(2, self.songdata.charts[0].difficulty)
self.enemy_chart = nindex.Index(enemy_chart.notes, "time")
with LogSection(logger, "generating highway"):
self.highway = FNFHighway(self.songdata.charts[0], (((Settings.width // 3) * 2), 0), auto = True)
# Create background stars
with LogSection(logger, "creating stars"):
self.star_camera = arcade.Camera()
self.stars = arcade.SpriteList()
self.scroll_speed = 20 # px/s
stars_per_screen = 100
star_height = Settings.height + int(self._song.source.duration * self.scroll_speed)
star_amount = int(stars_per_screen * (star_height / Settings.height))
logger.info(f"Generating {star_amount} stars...")
for i in range(star_amount):
sprite = arcade.SpriteCircle(5, arcade.color.WHITE + (255,), True)
sprite.center_x = randint(0, Settings.width)
sprite.center_y = randint(-(star_height - Settings.height), Settings.height)
self.stars.append(sprite)
with LogSection(logger, "creating text"):
self.text = arcade.Text("Fourth Wall by Jacaris", Settings.width / 4, Settings.height * (0.9),
font_name = "Determination Sans", font_size = 32, align="center", anchor_x="center", anchor_y="center", width = Settings.width)
with LogSection(logger, "making gradient"):
# Gradient
self.gradient = arcade.create_rectangle_filled_with_colors(
[(-250, Settings.height), (Settings.width + 250, Settings.height), (Settings.width + 250, -250), (-250, -250)],
[arcade.color.BLACK, arcade.color.BLACK, arcade.color.DARK_PASTEL_PURPLE, arcade.color.DARK_PASTEL_PURPLE]
)
with LogSection(logger, "loading sprites"):
self.scott_atlas = arcade.TextureAtlas((8192, 8192))
self.sprite_list = arcade.SpriteList(atlas = self.scott_atlas)
self.sprite = sprite_from_adobe("scott", ("bottom", "left"))
self.boyfriend = sprite_from_adobe("bfScott", ("bottom", "right"))
self.sprite_list.append(self.sprite)
self.sprite_list.append(self.boyfriend)
self.sprite.cache_textures()
self.boyfriend.cache_textures()
self.sprite.bottom = 0
self.sprite.left = 0
self.boyfriend.bottom = 0
self.boyfriend.right = Settings.width - 50
self.sprite.set_animation("idle")
self.boyfriend.set_animation("idle")
# Settings
with LogSection(logger, "finalizing setup"):
self.multiplier = 250
self.y = Settings.height // 2
self.line_width = 1
self.x_scale = 2
self.resolution = 4
self.beat_time = 0.5
self.show_text = False
# RAM
self.pixels: list[tuple[int, int]] = [(0, 0) * Settings.width]
self.last_beat = -self.beat_time
self.last_enemy_note: FNFNote = None
self.last_player_note: FNFNote = None
self.did_harcode = False
def on_update(self, delta_time):
# clear the shape list for the new frame
self.shape_list = arcade.ShapeElementList()
# self.minimap_shape_list = arcade.ShapeElementList()
# set the floor and ceiling colors
floor = arcade.create_rectangle(
self.screen_width // 2, int(self.screen_height * 0.25),
self.screen_width, self.screen_height // 2,
self.floor_color
)
ceiling = arcade.create_rectangle(
self.screen_width // 2, int(self.screen_height * 0.75),
self.screen_width, self.screen_height // 2,
self.ceiling_color
)
# add the floor and ceiling shapes to the shape_list
self.shape_list.append(floor)
self.shape_list.append(ceiling)
# create the point_list and color_list for raycasting
point_list = []
color_list = []
# begin raycasting
for x in range(0, self.screen_width + 1):
# calculate the ray position and direction
camera_x = (2 * x / self.screen_width) - 1
if camera_x > 1 or camera_x < -1:
print('camera_x is too big or too small!')
print(f'camera_x = {camera_x}')
ray_dir_x = self.dir_x + self.plane_x * camera_x
ray_dir_y = self.dir_y + self.plane_y * camera_x
# determine which grid-square of the map we're in
map_x = int(self.pos_x)
map_y = int(self.pos_y)
# length of ray from the current position to the next vertical gridline
side_dist_x = None
# length of ray from the current position to the next horizontal gridline
side_dist_y = None
# length of the ray from one horizontal or vertical gridline to the next one
try:
delta_dist_x = abs(1 / ray_dir_x)
except ZeroDivisionError:
if ray_dir_y == 0:
delta_dist_x = 0
elif ray_dir_x == 0:
delta_dist_x = 1
else:
delta_dist_x = abs(1 / ray_dir_x)
try:
delta_dist_y = abs(1 / ray_dir_y)
except ZeroDivisionError:
if ray_dir_x == 0:
delta_dist_y = 0
elif ray_dir_y == 0:
delta_dist_y = 1
else:
delta_dist_y = abs(1 / ray_dir_y)
# the distance to the next perpendicular wall
perpendicular_wall_dist = None
# which direction to step in the x direction or the y direction (either +1 or -1)
step_x = None
step_y = None
# was a there a wall hit?
hit = 0
# was a North/South wall hit or an East/West wall hit?
side = None
if ray_dir_x < 0:
step_x = -1
side_dist_x = (self.pos_x - map_x) * delta_dist_x
else:
step_x = 1
side_dist_x = (map_x + 1 - self.pos_x) * delta_dist_x
if ray_dir_y < 0:
step_y = -1
side_dist_y = (self.pos_y - map_y) * delta_dist_y
else:
step_y = 1
side_dist_y = (map_y + 1 - self.pos_y) * delta_dist_y
new_map_x = False
new_map_y = False
# continually cast the ray out into the distance until it hits a wall
while hit == 0:
if side_dist_x < side_dist_y:
side_dist_x += delta_dist_x
map_x += step_x
side = 0
else:
side_dist_y += delta_dist_y
map_y += step_y
side = 1
# check if the ray has hit a wall yet
if 0 < self.map[map_x][map_y] < 10:
hit = 1
if map_x != self.last_map_x:
new_map_x = True
self.last_map_x = map_x
if map_y != self.last_map_y:
new_map_y = True
self.last_map_y = map_y
if not self.minimap[map_x][map_y]:
self.minimap[map_x][map_y] = True
# top-left
self.mm_point_list.append(
(MINIMAP_POS_X + map_x * MINIMAP_SIZE, MINIMAP_POS_Y + map_y * MINIMAP_SIZE + MINIMAP_SIZE))
self.mm_color_list.append(arcade.color.BLACK)
# top-right
self.mm_point_list.append((MINIMAP_POS_X + map_x * MINIMAP_SIZE + MINIMAP_SIZE,
MINIMAP_POS_Y + map_y * MINIMAP_SIZE + MINIMAP_SIZE))
self.mm_color_list.append(arcade.color.BLACK)
# bottom-right
self.mm_point_list.append(
(MINIMAP_POS_X + map_x * MINIMAP_SIZE + MINIMAP_SIZE, MINIMAP_POS_Y + map_y * MINIMAP_SIZE))
self.mm_color_list.append(arcade.color.BLACK)
# bottom-left
self.mm_point_list.append(
(MINIMAP_POS_X + map_x * MINIMAP_SIZE, MINIMAP_POS_Y + map_y * MINIMAP_SIZE))
self.mm_color_list.append(arcade.color.BLACK)
elif 10 <= self.map[map_x][map_y] < 20:
hit = 2
if side == 0:
perpendicular_wall_dist = (map_x - self.pos_x + (1 - step_x) / 2) / (ray_dir_x + 0.00000001)
else:
perpendicular_wall_dist = (map_y - self.pos_y + (1 - step_y) / 2) / (ray_dir_y + 0.00000001)
"""
**********************************************
MODIFY CODE BELOW FOR ALLOWING PITS/HIGH WALLS
**********************************************
"""
# the height of the wall at the given pixel column
line_height = int(self.screen_height / (perpendicular_wall_dist + 0.00000001))
# the pixel (height) at which to start drawing the wall
draw_start = -line_height / 2 + self.screen_height / 2
if draw_start < 0:
draw_start = 0
if hit == 1: # if the wall is single-height
draw_end = line_height / 2 + self.screen_height / 2
elif hit == 2: # otherwise, if the wall is double-height
draw_end = line_height + self.screen_height / 2
if draw_end >= self.screen_height:
draw_end = self.screen_height - 1
# set the color with which to draw the given pixel column
if side == 0:
try:
color = self.main_wall_color_list[self.map[map_x][map_y] % 10]
except IndexError:
color = arcade.color.YELLOW
elif side == 1:
try:
color = self.dark_wall_color_list[self.map[map_x][map_y] % 10]
except IndexError:
color = arcade.color.DARK_YELLOW
draw_start_pos = (x, draw_start)
draw_end_pos = (x, draw_end)
point_list.append(draw_start_pos)
point_list.append(draw_end_pos)
if new_map_x or new_map_y:
color = arcade.color.BLACK
for i in range(2):
color_list.append(color)
shape = arcade.create_line_generic_with_colors(point_list, color_list, 3)
self.shape_list.append(shape)
minimap_background = arcade.create_rectangle_filled_with_colors(self.mm_bg_points, self.mm_bg_colors)
self.shape_list.append(minimap_background)
minimap_shape = arcade.create_rectangles_filled_with_colors(self.mm_point_list, self.mm_color_list)
self.shape_list.append(minimap_shape)
ppos_point_list = []
ppos_color_list = []
# top-left
ppos_point_list.append(
(MINIMAP_POS_X + self.pos_x * MINIMAP_SIZE, MINIMAP_POS_Y + self.pos_y * MINIMAP_SIZE + MINIMAP_SIZE))
ppos_color_list.append(arcade.color.BLUE)
# top-right
ppos_point_list.append((MINIMAP_POS_X + self.pos_x * MINIMAP_SIZE + MINIMAP_SIZE,
MINIMAP_POS_Y + self.pos_y * MINIMAP_SIZE + MINIMAP_SIZE))
ppos_color_list.append(arcade.color.RED)
# bottom-right
ppos_point_list.append(
(MINIMAP_POS_X + self.pos_x * MINIMAP_SIZE + MINIMAP_SIZE, MINIMAP_POS_Y + self.pos_y * MINIMAP_SIZE))
ppos_color_list.append(arcade.color.BLUE)
# bottom-left
ppos_point_list.append((MINIMAP_POS_X + self.pos_x * MINIMAP_SIZE, MINIMAP_POS_Y + self.pos_y * MINIMAP_SIZE))
ppos_color_list.append(arcade.color.BLUE)
player_shape = arcade.create_rectangle_filled_with_colors(ppos_point_list, ppos_color_list)
self.shape_list.append(player_shape)
self.old_time = self.time
self.time += delta_time
# frame_time is the amount of time this frame spent on screen (in seconds)
self.frame_time = (self.time - self.old_time)
FPS = 1 / self.frame_time
"""
********************************************************
HERE IS WHERE THE CODE FOR AUTO QUALITY ADJUST SHOULD GO
********************************************************
"""
if FPS < 60 and self.render_resolution > 2:
self.render_resolution -= 1
if FPS > 60:
self.render_resolution += 1
self.move_speed = self.frame_time * self.constant_move_speed
self.rotation_speed = self.frame_time * self.constant_rotation_speed
# print(f'constant rotation speed: {self.constant_rotation_speed}\nframe time: {frame_time}\nadjusted rotation speed: {self.rotation_speed}')
self.rotation_speed *= (self.rotate_x_magnitude / 100)
if self.move_forward:
if not self.map[int(self.pos_x + self.dir_x * self.move_speed)][int(self.pos_y)]:
self.pos_x += self.dir_x * self.move_speed
if not self.map[int(self.pos_x)][int(self.pos_y + self.dir_y * self.move_speed)]:
self.pos_y += self.dir_y * self.move_speed
elif self.move_backward:
if not self.map[int(self.pos_x - self.dir_x * self.move_speed)][int(self.pos_y)]:
self.pos_x -= self.dir_x * self.move_speed
if not self.map[int(self.pos_x)][int(self.pos_y - self.dir_y * self.move_speed)]:
self.pos_y -= self.dir_y * self.move_speed
if self.strafe_left:
if not self.map[int(self.pos_x - self.dir_y * self.move_speed)][int(self.pos_y)]:
self.pos_x -= self.dir_y * self.move_speed
if not self.map[int(self.pos_x)][int(self.pos_y + self.dir_x * self.move_speed)]:
self.pos_y += self.dir_x * self.move_speed
elif self.strafe_right:
if not self.map[int(self.pos_x + self.dir_y * self.move_speed)][int(self.pos_y)]:
self.pos_x += self.dir_y * self.move_speed
if not self.map[int(self.pos_x)][int(self.pos_y - self.dir_x * self.move_speed)]:
self.pos_y -= self.dir_x * self.move_speed
if self.rotate_left:
# both camera direction and camera plane must be rotated
old_dir_x = self.dir_x
self.dir_x = self.dir_x * math.cos(self.rotation_speed) - self.dir_y * math.sin(self.rotation_speed)
self.dir_y = old_dir_x * math.sin(self.rotation_speed) + self.dir_y * math.cos(self.rotation_speed)
old_plane_x = self.plane_x
self.plane_x = self.plane_x * math.cos(self.rotation_speed) - self.plane_y * math.sin(self.rotation_speed)
self.plane_y = old_plane_x * math.sin(self.rotation_speed) + self.plane_y * math.cos(self.rotation_speed)
elif self.rotate_right:
# both camera direction and camera plane must be rotated
old_dir_x = self.dir_x
self.dir_x = self.dir_x * math.cos(-self.rotation_speed) - self.dir_y * math.sin(-self.rotation_speed)
self.dir_y = old_dir_x * math.sin(-self.rotation_speed) + self.dir_y * math.cos(-self.rotation_speed)
old_plane_x = self.plane_x
self.plane_x = self.plane_x * math.cos(-self.rotation_speed) - self.plane_y * math.sin(-self.rotation_speed)
self.plane_y = old_plane_x * math.sin(-self.rotation_speed) + self.plane_y * math.cos(-self.rotation_speed)
if self.mouse_look:
self.mouse_look = False
self.rotate_right = False
self.rotate_left = False
