def main(): arcade.open_window(800, 800, "first window example") arcade.set_background_color(arcade.color.ALMOND) #now create objects main_house = arcade.create_rectangle(400, 200, 400, 400, arcade.color.ANTIQUE_BRASS) door = arcade.create_rectangle(400, 75, 100, 150, arcade.color.ARMY_GREEN) window_1 = arcade.create_ellipse(300, 300, 50, 50, arcade.color.AERO_BLUE) window_2 = arcade.create_ellipse(500, 300, 50, 50, arcade.color.AERO_BLUE) roof_points = [(200, 400), (400, 600), (600, 400)] roof = arcade.create_polygon(roof_points, arcade.color.DARK_GRAY) line = arcade.create_line(200, 730, 510, 730, arcade.color.ROSE) #now we will begin to draw arcade.start_render() #draw everything here arcade.draw_text("boy is that an ugly house", 200, 750, arcade.color.ALABAMA_CRIMSON, 22) main_house.draw() door.draw() window_1.draw() window_2.draw() roof.draw() line.draw() arcade.finish_render() arcade.run()
def main(): arcade.open_window(1000, 1000, "My Picture") arcade.set_background_color(arcade.color.WHITE) #create objects rubrix_cube = arcade.create_rectangle(500, 500, 500, 500, arcade.color.WHITE) individual_square_1 = arcade.create_rectangle(500, 500, 175, 175, arcade.color.BLUE)#second row middle piece individual_square_2 = arcade.create_rectangle(328, 500, 150, 175, arcade.color.BLUE)#second row left side piece individual_square_3 = arcade.create_rectangle(672, 500, 150, 175, arcade.color.BLUE)#second row right side piece individual_square_4 = arcade.create_rectangle(500, 670, 175, 150, arcade.color.BLUE)#top row middle peiece individual_square_5 = arcade.create_rectangle(672, 670, 150, 150, arcade.color.BLUE)#top row right side piece individual_square_6 = arcade.create_rectangle(328, 670, 150, 150, arcade.color.BLUE)#top row left side piece individual_square_7 = arcade.create_rectangle(500, 330, 175, 150, arcade.color.BLUE)#bottom row middle piece individual_square_8 = arcade.create_rectangle(672, 330, 150, 150, arcade.color.BLUE)#bottom right side piece individual_square_9 = arcade.create_rectangle(328, 330, 150, 150, arcade.color.BLUE)#bottom left side piece spikes = arcade.draw_triangle_filled(50, 50, 75, 75, 60, 60, arcade.color.RED) arcade.start_render() #Draw Everything rubrix_cube.draw() individual_square_1.draw() individual_square_2.draw() individual_square_3.draw() individual_square_4.draw() individual_square_5.draw() individual_square_6.draw() individual_square_7.draw() individual_square_8.draw() individual_square_9.draw() spikes.draw() arcade.finish_render() arcade.run()
def main (): arcade.open_window(800, 800, "Hey We Have a Window") arcade.set_background_color(arcade.color.ALMOND) # now create objects main_house = arcade.create_rectangle(400, 200, 400, 400, arcade.color.ANTIQUE_BRASS) door = arcade.create_rectangle(400, 75, 100, 150, arcade.color.ARMY_GREEN) window1 = arcade.create_ellipse(300, 300, 50, 50, arcade.color.BABY_BLUE) window2 = arcade.create_ellipse(500, 300, 50, 50, arcade.color.BABY_BLUE) roof_points = [(200, 400), (400, 600), (600, 400)] roof = arcade.create_polygon(roof_points, arcade.color.DARK_GRAY) line = arcade.create_line(175, 725, 550, 725, arcade.color.FALU_RED) # now we will begin to draw arcade.start_render() # draw everything here arcade.draw_text("Boy that was an ugly house", 200, 750, arcade.color.ALABAMA_CRIMSON, 22) main_house.draw() door.draw() window1.draw() window2.draw() roof.draw() line.draw() arcade.finish_render() arcade.run()
def solve(): with open('input.txt') as f: _input: List = f.read() width = 25 tall = 6 layers = list() data = _input while data: layer = list() for y in range(tall): row, data = data[:width], data[width:] layer.append(row) layers.append(layer) # Check sum counts = [] for layer in layers: print(layer) c = Counter(''.join(layer)) counts.append((c['0'], c['1'] * c['2'])) print(sorted(counts)[0][1]) # pic # 0 is black, 1 is white, and 2 is transparent SIZE = 50 PADDING = 50 arcade.open_window(width * SIZE + PADDING, tall * SIZE + PADDING, 'Image') shapes = arcade.ShapeElementList() for layer in reversed(layers): for y, row in enumerate(reversed(layer)): for x, pixel in enumerate(row): px = x * SIZE + SIZE / 2 + PADDING / 2 py = y * SIZE + SIZE / 2 + PADDING / 2 if pixel == '0': rect = arcade.create_rectangle(px, py, SIZE, SIZE, arcade.color.BLACK, filled=True) elif pixel == '1': rect = arcade.create_rectangle(px, py, SIZE, SIZE, arcade.color.WHITE, filled=True) else: continue shapes.append(rect) arcade.set_background_color(arcade.color.BLACK) arcade.start_render() shapes.draw() arcade.finish_render() arcade.run()
def make_dynamic_shape(self): # dynamic circle s = arcade.create_rectangle_filled(0, 0, self.box_width, self.box_height, self.box_color) self.dynamic_shape_element.append(s) r = self.box_color[0] + 50 r = r if r <= 255 else 255 g = self.box_color[1] + 50 g = g if g <= 255 else 255 b = self.box_color[2] + 50 b = b if b <= 255 else 255 border_color = (r, g, b) s = arcade.create_rectangle(0, 0, self.box_width, self.box_height, border_color, 3, filled=False) self.dynamic_shape_element.append(s) s = arcade.create_rectangle_filled(int(self.box_width * 0.35), 0, 3, int(self.box_height * 0.8), border_color) self.dynamic_shape_element.append(s)
def main(): arcade.open_window(800, 800, "Stripes") arcade.set_background_color(arcade.color.WHITE) arcade.start_render() stripe = arcade.create_rectangle(800, 0, 100, 1600, arcade.color.BLACK) stripe.draw() arcade.finish_render() arcade.run()
def _draw_keyboard(self): """ Draw keyboard """ keyboard = self._keyboard if not keyboard.change_resolved: keyboard.shape = arcade.create_rectangle( keyboard.center_x, keyboard.center_y, keyboard.width, keyboard.height, keyboard.rgba, border_width=keyboard.border_width, tilt_angle=keyboard.tilt_angle, filled=keyboard.filled) keyboard.change_resolved = True for key in self._keyboard.keys.values(): if not key.change_resolved: key.shape = arcade.create_rectangle( key.center_x, key.center_y, key.width, key.height, key.rgba, border_width=key.border_width, tilt_angle=key.tilt_angle, filled=key.filled) key.change_resolved = True for shape in [keyboard.shape] + [key.shape for key in keyboard.keys.values()]: shape.draw() for key in keyboard.keys.values(): # FIXME pyglet draw doesn't work in arcade if key.graphic: key.graphic.draw() else: if key.graphic is None: try: text = key_.MAP_SYMBOL_TEXT[key.symbol] multiline = False if '\n' in text: multiline = True label = pyglet.text.Label( text, 'Montserrat', key.height // 2, color=(255, 255, 255, 255), x=key.position[0], y=key.position[1], anchor_x='center', anchor_y='center', multiline=multiline) key.graphic = label key.graphic.draw() except KeyError: key.graphic = 0
def __init__(self, GRID_W: int = 0, GRID_H:int = 0, GRID_MARGIN:int = 1,SIZE:int = 0): self.GRID_W = GRID_W self.GRID_H = GRID_H self.GRID_MARGIN = GRID_MARGIN self.SIZE = SIZE self.GRID = [] self.SHAPE_LIST = [] for row in range(20): self.GRID.append([]) for col in range(20): self.GRID[row].append([]) x = (self.GRID_MARGIN + self.GRID_W ) * col + self.GRID_MARGIN + self.GRID_W //2 y = (self.GRID_MARGIN + self.GRID_H ) * row + self.GRID_MARGIN + self.GRID_H //2 self.SHAPE_LIST.append(create_rectangle(self.GRID_W,self.GRID_H,GREEN))
def create_shapes(win_width, win_height): x_scale = win_width / 4 win_height = win_height / 4 shape_list = [] rectangle = arcade.create_rectangle(x_scale, win_height, 100, win_height, arcade.color.COPPER_PENNY) circle = arcade.create_ellipse(x_scale * 3, win_height, 50, 50, arcade.color.DARK_TANGERINE) shape_list.append(rectangle) shape_list.append(circle) line = arcade.create_line(x_scale, 600, x_scale * 3, win_height, arcade.color.ENGLISH_LAVENDER, 3) shape_list.append(line) return shape_list
def main(): arcade.open_window(800, 800, "Rocketship") arcade.set_background_color(arcade.color.AFRICAN_VIOLET) arcade.start_render() rocketship_body = arcade.create_rectangle(200, 300, 100, 100, arcade.color.ALMOND) thruster = arcade.create_p rocketship_body.draw() arcade.finish_render() arcade.run()
def shapes(self, draw_event): """ Paint a basic beam """ shapes = [self.background_shape()] rect = self.geometry if self._mode == Bar.RIGHT_TO_LEFT: rect = Rect(rect.x, rect.y, rect.w * self._percent, rect.h).to_arcade_rect() elif self._mode == Bar.MIDDLE_OUT: rect = rect.to_arcade_rect() rect = Rect(rect.x, rect.y, rect.w * self._percent, rect.h) shapes.append(arcade.create_rectangle(*(rect), self._color)) return shapes
def make_kinematic_shape(self): # dynamic circle s = arcade.create_rectangle_filled(0, 0, self.box_width, self.box_height, arcade.color.GRAY) self.kinematic_shape_element.append(s) s = arcade.create_rectangle(0, 0, self.box_width, self.box_height, arcade.color.LAVENDER_GRAY, 3, filled=False) self.kinematic_shape_element.append(s) s = arcade.create_rectangle_filled(int(self.box_width * 0.35), 0, 3, int(self.box_height * 0.8), arcade.color.LAVENDER_GRAY) self.kinematic_shape_element.append(s)
def recreate_vbo(self): self._shape = arcade.create_rectangle(self.center_x, self.center_y, self.width, self.height, self.rgba, self._border_width, self._tilt_angle, self._filled) self.change_resolved = True
def setup(self): """ Set up all the necessary shapes and sprites which are used in the simulation. These elements are added to lists to make buffered rendering possible to improve performance. """ self.robot_elements = arcade.SpriteList() self.obstacle_elements = arcade.ShapeElementList() if self.large_sim_type: self.robot = RobotLarge(self.cfg, self.robot_pos[0], self.robot_pos[1], self.robot_pos[2]) else: self.robot = RobotSmall(self.cfg, self.robot_pos[0], self.robot_pos[1], self.robot_pos[2]) for s in self.robot.get_sprites(): self.robot_elements.append(s) for s in self.robot.get_sensors(): self.robot_state.load_sensor(s) self.blue_lake = BlueLake(self.cfg) self.green_lake = GreenLake(self.cfg) self.red_lake = RedLake(self.cfg) self.obstacle_elements.append(self.blue_lake.shape) self.obstacle_elements.append(self.green_lake.shape) self.obstacle_elements.append(self.red_lake.shape) self.border = Border( self.cfg, eval(self.cfg['obstacle_settings']['border_settings'] ['border_color'])) self.edge = Edge(self.cfg) for s in self.border.shapes: self.obstacle_elements.append(s) self.space = Space() if self.large_sim_type: self.rock1 = Rock(apply_scaling(825), apply_scaling(1050), apply_scaling(150), apply_scaling(60), arcade.color.DARK_GRAY, 10) self.rock2 = Rock(apply_scaling(975), apply_scaling(375), apply_scaling(300), apply_scaling(90), arcade.color.DARK_GRAY, 130) self.ground = arcade.create_rectangle(apply_scaling(1460), apply_scaling(950), apply_scaling(300), apply_scaling(10), arcade.color.BLACK) self.obstacle_elements.append(self.rock1.shape) self.obstacle_elements.append(self.rock2.shape) self.obstacle_elements.append(self.ground) touch_obstacles = [self.rock1, self.rock2] falling_obstacles = [ self.blue_lake.hole, self.green_lake.hole, self.red_lake.hole, self.edge ] self.space.add(self.rock1.poly) self.space.add(self.rock2.poly) else: self.bottle1 = Bottle(apply_scaling(1000), apply_scaling(300), apply_scaling(40), arcade.color.DARK_OLIVE_GREEN) self.obstacle_elements.append(self.bottle1.shape) touch_obstacles = [self.bottle1] falling_obstacles = [self.edge] self.space.add(self.bottle1.poly) color_obstacles = [ self.blue_lake, self.green_lake, self.red_lake, self.border ] self.robot.set_color_obstacles(color_obstacles) self.robot.set_touch_obstacles(touch_obstacles) self.robot.set_falling_obstacles(falling_obstacles)
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
def create_shape(self, x, y, width, height): """ Create the small and long rectangle shown below the sidebar arm. """ self.shape = create_rectangle(x, y, width, height, self.color)
import arcade arcade.open_window(800, 600, "Drawing Example") arcade.start_render() my_rect = arcade.create_rectangle(200, 200, 50, 50, (255, 255, 0), 3, 45) arcade.render(my_rect) arcade.finish_render() arcade.run()
def on_update(self, delta_time): self.max_fps = self.target_fps + TARGET_PLUS_MINUS self.min_fps = self.target_fps - TARGET_PLUS_MINUS self.shape_list = arcade.ShapeElementList() floor = arcade.create_rectangle(SCREEN_WIDTH // 2, int(SCREEN_HEIGHT * 0.25), SCREEN_WIDTH, SCREEN_HEIGHT // 2, FLOOR_COLOR) ceiling = arcade.create_rectangle(SCREEN_WIDTH // 2, int(SCREEN_HEIGHT * 0.75), SCREEN_WIDTH, SCREEN_HEIGHT // 2, CEILING_COLOR) self.shape_list.append(floor) self.shape_list.append(ceiling) point_list = [] color_list = [] # print(f'({self.posX}, {self.posY}) at time {self.time}') # arcade.start_render() for x in range(0, SCREEN_WIDTH + 1): # calculate the ray position and direction cameraX = (2 * x / SCREEN_WIDTH) - 1 if cameraX > 1 or cameraX < -1: print('cameraX is too big or too small!') sys.exit() rayDirX = self.dirX + self.planeX * cameraX rayDirY = self.dirY + self.planeY * cameraX # which box of the map we're in mapX = int(self.posX) mapY = int(self.posY) # print(f'({mapX}, {mapY})') # length of ray from current position to the next x- or y-side sideDistX = None sideDistY = None # length of the ray from one x- or y-side to the next x- or y-side try: deltaDistX = abs(1 / rayDirX) except ZeroDivisionError: if rayDirY == 0: deltaDistX = 0 else: if rayDirX == 0: deltaDistX = 1 else: deltaDistX = abs(1 / rayDirX) try: deltaDistY = abs(1 / rayDirY) except ZeroDivisionError: if rayDirX == 0: deltaDistY = 0 else: if rayDirY == 0: deltaDistY = 1 else: deltaDistY = abs(1 / rayDirY) perpWallDist = None # which direction to step in the x direction or y direction (either +1 or -1) stepX = None stepY = None hit = 0 # was there a wall hit? side = None # was a North/South wall hit or an East/West wall hit? if rayDirX < 0: stepX = -1 sideDistX = (self.posX - mapX) * deltaDistX else: stepX = 1 sideDistX = (mapX + 1.0 - self.posX) * deltaDistX if rayDirY < 0: stepY = -1 sideDistY = (self.posY - mapY) * deltaDistY else: stepY = 1 sideDistY = (mapY + 1.0 - self.posY) * deltaDistY # was a wall hit? 1 = yes. 0 = no. while hit == 0: if sideDistX < sideDistY: sideDistX += deltaDistX mapX += stepX side = 0 else: sideDistY += deltaDistY mapY += stepY side = 1 # check if ray has hit a wall if self.world_map[mapX][mapY] > 0: hit = 1 if side == 0: perpWallDist = (mapX - self.posX + (1 - stepX) / 2) / (rayDirX + 0.00000001) else: perpWallDist = (mapY - self.posY + (1 - stepY) / 2) / (rayDirY + 0.00000001) lineHeight = int(SCREEN_HEIGHT / (perpWallDist + 0.00000001)) drawStart = -lineHeight / 2 + SCREEN_HEIGHT / 2 if drawStart < 0: drawStart = 0 drawEnd = lineHeight / 2 + SCREEN_HEIGHT / 2 if drawEnd >= SCREEN_HEIGHT: drawEnd = SCREEN_HEIGHT - 1 # texturing calculations tex_num = self.world_map[mapX][ mapY] - 1 # 1 subtracted from it so that texture 0 acn be used! # calculate value of wallX wallX = None # where exactly the wall was hit if side == 0: wallX = self.posY + perpWallDist * rayDirY else: wallX = self.posX + perpWallDist * rayDirX wallX -= math.floor(wallX) # x coordinate on the texture texX = int(wallX * TEX_WIDTH) if side == 0 and rayDirX > 0: texX = TEX_WIDTH - texX - 1 if side == 1 and rayDirY < 0: texX = TEX_WIDTH - texX - 1 if side == 0: try: color = self.color_list[self.world_map[mapX][mapY]] except IndexError: color = arcade.color.YELLOW elif side == 1: try: color = self.dark_color_list[self.world_map[mapX][mapY]] except IndexError: color = arcade.color.DARK_YELLOW '''# how much to increase the texture coordinate per screen pixel step = 1.0 * TEX_HEIGHT / lineHeight tex_pos = (drawStart - SCREEN_HEIGHT / 2 + lineHeight / 2) * step for y in range(drawStart, drawEnd): texY = int(tex_pos) tex_pos += step if side == 1: tex_to_use = self.alt_texture else: tex_to_use = self.texture''' draw_start_pos = (x, drawStart) draw_end_pos = (x, drawEnd) point_list.append(draw_end_pos) point_list.append(draw_start_pos) for i in range(2): color_list.append(color) # self.shape_list.append(arcade.create_line(x, drawStart, x, drawEnd, color, self.render_resolution)) shape = arcade.create_line_generic_with_colors(point_list, color_list, 3) self.shape_list.append(shape) self.oldTime = self.time self.time += delta_time self.frameTime = ( self.time - self.oldTime ) # frameTime is the time this frame has taken in seconds # print(1.0 / self.frameTime) # FPS counter FPS = 1 / self.frameTime if FPS < self.min_fps: self.render_resolution += 1 elif FPS > self.max_fps: self.render_resolution -= 1 self.move_speed = self.frameTime * MOVE_SPEED # constant value in squares/second self.rotation_speed = self.frameTime * ROTATION_SPEED # constant value in radians/second # print(self.rotation_speed) if self.moveForward: if not self.world_map[int(self.posX + self.dirX * self.move_speed)][int( self.posY)]: self.posX += self.dirX * self.move_speed if not self.world_map[int( self.posX)][int(self.posY + self.dirY * self.move_speed)]: self.posY += self.dirY * self.move_speed elif self.moveBackward: if not self.world_map[int(self.posX - self.dirX * self.move_speed)][int( self.posY)]: self.posX -= self.dirX * self.move_speed if not self.world_map[int( self.posX)][int(self.posY - self.dirY * self.move_speed)]: self.posY -= self.dirY * self.move_speed if self.strafeLeft: if not self.world_map[int(self.posX - self.dirY * self.move_speed)][int( self.posY)]: self.posX -= self.dirY * self.move_speed if not self.world_map[int( self.posX)][int(self.posY + self.dirX * self.move_speed)]: self.posY += self.dirX * self.move_speed elif self.strafeRight: if not self.world_map[int(self.posX + self.dirY * self.move_speed)][int( self.posY)]: self.posX += self.dirY * self.move_speed if not self.world_map[int( self.posX)][int(self.posY - self.dirX * self.move_speed)]: self.posY -= self.dirX * self.move_speed if self.rotateLeft: # both camera direction and camera plane must be rotated oldDirX = self.dirX self.dirX = self.dirX * math.cos( self.rotation_speed) - self.dirY * math.sin( self.rotation_speed) self.dirY = oldDirX * math.sin( self.rotation_speed) + self.dirY * math.cos( self.rotation_speed) oldPlaneX = self.planeX self.planeX = self.planeX * math.cos( self.rotation_speed) - self.planeY * math.sin( self.rotation_speed) self.planeY = oldPlaneX * math.sin( self.rotation_speed) + self.planeY * math.cos( self.rotation_speed) elif self.rotateRight: # both camera direction and camera plane must be rotated oldDirX = self.dirX self.dirX = self.dirX * math.cos( -self.rotation_speed) - self.dirY * math.sin( -self.rotation_speed) self.dirY = oldDirX * math.sin( -self.rotation_speed) + self.dirY * math.cos( -self.rotation_speed) oldPlaneX = self.planeX self.planeX = self.planeX * math.cos( -self.rotation_speed) - self.planeY * math.sin( -self.rotation_speed) self.planeY = oldPlaneX * math.sin( -self.rotation_speed) + self.planeY * math.cos( -self.rotation_speed)
def create_shape(self, x, y, width, height): self.shape = create_rectangle(x, y, width, height, self.color)
def background_shape(self): """ Have arcade paint our rect """ return arcade.create_rectangle(*(self.geometry.to_arcade_rect()), self._background_color)