def generate_shape_list(self): """ Regenerate the shape list based on the current state of the game """ self.shape_list = arcade.ShapeElementList() for row in range(self.game["board_height"]): for col in range(self.game["board_width"]): cell = self.game["board"][row][col] x_px = self.offset_x + (col * CELL_SIZE_PX) + (CELL_SIZE_PX / 2) y_px = SCREEN_HEIGHT - (row * CELL_SIZE_PX) - ( CELL_SIZE_PX / 2) - self.offset_y if cell["flagged"]: color = arcade.color.RED elif cell["visible"] or (self.game["game_over"] and not self.game["is_win"]): if cell["value"] == 'X': color = arcade.color.BLACK else: color = arcade.color.DARK_GRAY else: color = arcade.color.LIGHT_GRAY rect = arcade.create_rectangle_filled(x_px, y_px, CELL_SIZE_PX, CELL_SIZE_PX, color) border = arcade.create_rectangle_outline( x_px, y_px, CELL_SIZE_PX, CELL_SIZE_PX, arcade.color.BLACK) self.shape_list.append(rect) self.shape_list.append(border)
def update_next_queue(self, t_next): """Update the next queue box with the next piece in the queue. Arguments: t_next {Shape} -- The next shape that will be in play """ self.minos = arcade.ShapeElementList() self.t_next = t_next for i, row in enumerate(reversed(self.t_next.value[0])): for j, block in enumerate(row): if block > 1: x = SIDE_MARGIN + NEXT_QUEUE_X_OFFSET + (j) * 24 + 12 y = BOTTOM_MARGIN + NEXT_QUEUE_Y_OFFSET + (i) * 24 # Offset the tetrimino pieces to center in next queue box if self.t_next.value[1] in [2, 3]: x = SIDE_MARGIN + NEXT_QUEUE_X_OFFSET + (j) * 24 if self.t_next.value[1] == 3: y = BOTTOM_MARGIN + NEXT_QUEUE_Y_OFFSET + (i) * 24 - 12 self.minos.append( arcade.create_rectangle_filled( center_x=x, center_y=y, width=24, height=24, color=COLORS[self.t_next.value[1]])) self.minos.append( arcade.create_rectangle_outline(center_x=x, center_y=y, width=24, height=24, color=BLACK))
def __init__(self): self.show = 0 self.shape = arcade.create_rectangle_outline(Const.GAME_WIDTH / 2, Const.GAME_HEIGHT / 2, Const.GAME_WIDTH - 1, Const.GAME_HEIGHT - 2, (70, 127, 183), 3)
def scene3_render(self): self.draw_list = arcade.ShapeElementList() # self.stars_render() self.draw_list.append( arcade.create_rectangle_filled(400, 0, 800, 200, arcade.color.BLUE_GRAY, 0)) # self.draw_list.append(arcade.create_rectangle_filled(400, 800, 800, 200, arcade.color.BLUE_GRAY, 0)) self.draw_list.append( arcade.create_rectangle_filled(400, 113, 800, 25, arcade.color.LIGHT_GRAY, 0)) self.draw_list.append( arcade.create_line(2, 0, 2, 124, arcade.color.DARK_BLUE, 4)) self.draw_list.append( arcade.create_line(200, 0, 200, 101, arcade.color.DARK_BLUE, 4)) self.draw_list.append( arcade.create_line(400, 0, 400, 101, arcade.color.DARK_BLUE, 4)) self.draw_list.append( arcade.create_line(600, 0, 600, 101, arcade.color.DARK_BLUE, 4)) self.draw_list.append( arcade.create_line(798, 0, 798, 124, arcade.color.DARK_BLUE, 4)) self.draw_list.append( arcade.create_line(0, 100, 800, 100, arcade.color.DARK_BLUE, 4)) self.draw_list.append( arcade.create_line(0, 124, 800, 124, arcade.color.DARK_BLUE, 4)) self.draw_list.append( arcade.create_rectangle_outline(100 + (self.battle_cursor * 200), 50, 175, 75, colors["black"], 3)) self.draw_list.append( arcade.create_ellipse_outline(400, 600, self.enemy.size_x, self.enemy.size_y, colors["db"], 4)) self.draw_list.append( arcade.create_ellipse_filled(400, 600, self.enemy.size_x / 3, self.enemy.size_y / 3, colors["sky"]))
def next_state(self): # Set goal as new start colour spot = self.GOAL self.spots_list[spot.x * DIV + spot.y] = arcade.create_rectangle_filled( spot.x * G_W + G_W / 2, spot.y * G_H + G_H / 2, G_W, G_H, arcade.color.BITTER_LEMON) # Reset previous start colour spot = self.START self.spots_list[spot.x * DIV + spot.y] = arcade.create_rectangle_filled( spot.x * G_W + G_W / 2, spot.y * G_H + G_H / 2, G_W, G_H, arcade.color.WHITE) # Update changes self.__recalculate_grid() # Add new outline self.spots_list[spot.x * DIV + spot.y] = arcade.create_rectangle_outline( spot.x * G_W + G_W / 2, spot.y * G_H + G_H / 2, G_W, G_H, arcade.color.BLACK) # Set goal as new start self.START = self.GOAL self.START.reset() self.GOAL = None self.reset_goal()
def create_grid_rect(self, x, y): rect = arcade.create_rectangle_outline( center_x=x, center_y=y, width=24, height=24, color=BLACK) self.rect_list.append(rect)
def calculate_inital_grid(self): for col in self.spots: for spot in col: shape = arcade.create_rectangle_outline( spot.x * G_W + G_W / 2, spot.y * G_H + G_H / 2, G_W, G_H, arcade.color.BLACK) self.spots_list.append(shape) for shape in self.spots_list: self.spots_shape_list.append(shape)
def create_border_wall(self, colour): """ Create a border wall around the game board & scoreboard. Return an object that can be rendered to the screen efficiently. """ border_wall = arcade.create_rectangle_outline( settings.WINDOW_WIDTH / 2, settings.WINDOW_HEIGHT / 2, settings.WINDOW_WIDTH - (settings.CELL * 2), settings.WINDOW_HEIGHT - (settings.CELL * 2), colour, 8) return border_wall
def _SetupOutline(self): """Sets up outline.""" # End here if no outline wanted if self.outlineColor is None: self.outline = None return # Get shape as a list with two (so one side is not thiner) outline = arcade.ShapeElementList() shape = arcade.create_rectangle_outline(self.center_x,self.center_y,self.width,self.height,self.outlineColor,self.outlineThick) outline.append(shape) shape = arcade.create_rectangle_outline(self.center_x,self.center_y,self.width,self.height,self.outlineColor,self.outlineThick,180.0) outline.append(shape) # Save shape self.outline = outline return
def create_segment_border(self, position, colour, width=settings.CELL, height=settings.CELL): """Create the colour border for one segment of the snake.""" segment_border = arcade.create_rectangle_outline( position[0], position[1], width, height, colour, 2 ) return segment_border
def scene4_render(self): self.draw_list = arcade.ShapeElementList() self.draw_list.append( arcade.create_rectangle_filled(400, 400, 600, 600, colors["db"], 0)) self.draw_list.append( arcade.create_line(200, 100, 200, 700, arcade.color.DARK_BLUE, 4)) self.draw_list.append( arcade.create_rectangle_outline( menu_slots[self.station_cursor]["x"], menu_slots[self.station_cursor]["y"], 140, 140, arcade.color.DARK_BLUE, 3))
def create_menu_board_outline(self, colour): """ Create a small outline around the menu board. Keep a visual gap between snake objects & the border wall. Return an object that can be rendered to the screen efficiently. """ menu_board_outline = arcade.create_rectangle_outline( settings.WINDOW_WIDTH / 2, settings.WINDOW_HEIGHT / 2, settings.WINDOW_WIDTH - (settings.CELL * 2), settings.WINDOW_HEIGHT - (settings.CELL * 2), colour, 2) return menu_board_outline
def setup(self) -> None: for y in range(0, s.WINDOW_SIZE[1], Tile.SCALED): for x in range(0, s.WINDOW_SIZE[0], Tile.SCALED): center_x, center_y = find_grid_box(x, y) box = arcade.create_rectangle_outline(center_x=center_x, center_y=center_y, width=Tile.SCALED, height=Tile.SCALED, color=arcade.color.BLACK) self.boxes.append(box) self.boxes_hash_map[(center_x, center_y)] = box yield
def draw_map(bodies, window_width, window_height): map_shape_list = arcade.ShapeElementList() view = arcade.get_viewport() map_width = window_width / 3.5 map_height = window_height / 3.5 map_padding = window_height / 80 map_center_x = view[1] - (map_width / 2 + map_padding) map_center_y = view[2] + (map_height / 2 + map_padding) #view[0] = left, view[1] = right, view[2] = bottom, view[3] = top rec = arcade.create_rectangle_filled(map_center_x, map_center_y, map_width, map_height, arcade.color.BLACK) rec2 = arcade.create_rectangle_outline(map_center_x, map_center_y, map_width, map_height, arcade.color.WHITE, window_width / 400) map_shape_list.append(rec) map_shape_list.append(rec2) max_mass = 0 cm = None # find_center_of_mass(bodies) for bodie in bodies: if max_mass < bodie.mass: max_mass = bodie.mass cm = bodie.pos max_dist = 1 for bodie in bodies: this_dist = (cm - bodie.pos).get_mag() if max_dist < this_dist: max_dist = this_dist scaler = max_dist / ((map_height - map_padding) / 2) # print(scaler) # scaler = 60 for bodie in bodies: map_pos = (bodie.pos - cm) map_pos.x /= scaler map_pos.y /= scaler map_pos += Vec2D(map_center_x, map_center_y) map_shape_list.append( arcade.create_ellipse_filled(map_pos.x, map_pos.y, window_width / 300, window_width / 300, bodie.color)) # map_shpe_list.append( arcade. ) map_shape_list.draw()
def create_message_box_outline(self, colour): """ Create a small outline around the message box. Return an object that can be rendered to the screen efficiently. """ message_box_outline = arcade.create_rectangle_outline( settings.WINDOW_WIDTH / 2, settings.WINDOW_HEIGHT / 2 + settings.CELL, settings.WINDOW_WIDTH - (settings.CELL * 10), (settings.WINDOW_HEIGHT / 2) - (settings.CELL * 7), colour, 6 ) return message_box_outline
def scene2_render(self): self.draw_list = arcade.ShapeElementList() # self.stars_render() # self.draw_list.append(arcade.create_rectangle_filled(400, 400, 800, 800, arcade.color.DARK_BLUE, 0)) self.draw_list.append( arcade.create_rectangle_filled(400, 400, 600, 600, colors["white"], 0)) self.draw_list.append( arcade.create_line(300, 100, 300, 700, colors["black"], 4)) for i in range(0, 5): self.draw_list.append( arcade.create_rectangle_filled(200, 600 - (100 * i), 50, 75, arcade.color.SILVER_LAKE_BLUE)) self.draw_list.append( arcade.create_rectangle_outline(200, 200 + (self.cursor * 100), 50, 75, colors["black"], 3))
def __init__(self, center_x: float, center_y: float, width: float, height: float, fill_color: Union[Tuple[int, int, int], Tuple[int, int, int, int]] = arcade.color.WHITE, border_color: Union[Tuple[int, int, int], Tuple[int, int, int, int]] = arcade.color.BLACK, border_width: float = 1, **kwargs): super().__init__(**kwargs) self.center_x = center_x self.center_y = center_y self.width = width self.height = height self.fill_color = fill_color self.border_color = border_color self.border_width = border_width self.fill_box = arcade.create_rectangle_filled(center_x=center_x, center_y=center_y, width=width, height=height, color=fill_color) self.outline_box = arcade.create_rectangle_outline( center_x=center_x, center_y=center_y, width=width, height=height, color=border_color, border_width=border_width) self.shapes = arcade.ShapeElementList() self.shapes.append(self.fill_box) self.shapes.append(self.outline_box) self.elements: List[Type[InteractiveWidget]] = list()
def create_shape(self, x, y): if self.is_active: return arcade.create_rectangle_filled( x, y, self.settings.cell_size, self.settings.cell_size, self.palette.active_cell_background_color, ) cell_size = self.settings.cell_size outline = self.settings.passive_cell_outline_width return arcade.create_rectangle_outline( x, y, cell_size - outline, cell_size - outline, self.palette.passive_cell_background_color, outline, )
def hallways(self): try: if len(self.neighbors) == 0: return [] return self._hallways except AttributeError: pass self._hallways = [] for neighbor in self.neighbors: A = pymunk.Vec2d(*self.position) B = pymunk.Vec2d(*neighbor.position) C = (A + B) / 2 w, h = A - B shape = arcade.create_rectangle_outline(*C, w, h, (0, 127, 0, 127), 1) self._hallways.append(shape) return self._hallways
def __init__( self, text: str, center_x: float, center_y: float, width: float = None, height: float = None, scale: float = 1.0, on_click: Callable[[], None] = None, ) -> None: self.text: str = text self.center_x = center_x self.center_y = center_y self.width = width if width is not None else len( text) * scale * self.font_size * 0.6 self.height = height if height is not None else scale * self.font_size * 1.4 self.scale: float = scale self._on_click: Callable[ [], None] = on_click if on_click is not None else lambda: None self.state: ButtonState = ButtonState.NORMAL self.background: Dict[ButtonState, arcade.ShapeElementList] = { state: arcade.ShapeElementList() for state in ButtonState } for state in ButtonState: self.background[state].append( arcade.create_rectangle_filled( center_x=center_x, center_y=center_y, width=self.width, height=self.height, color=self.color[state]["background"], )) self.background[state].append( arcade.create_rectangle_outline( center_x=center_x, center_y=center_y, width=self.width, height=self.height, color=self.color[state]["outline"], border_width=2.0 * self.scale, ))
def __init__(self): """Initialize the Next Queue which displays the next Tetrimino that will be in play. """ self.t_next = None self.rects = arcade.ShapeElementList() self.minos = arcade.ShapeElementList() self.box = arcade.create_rectangle_filled( center_x=SIDE_MARGIN + NEXT_QUEUE_CX, center_y=BOTTOM_MARGIN + NEXT_QUEUE_CY, width=NEXT_QUEUE_WIDTH, height=NEXT_QUEUE_HEIGHT, color=WHITE) self.outline = arcade.create_rectangle_outline( center_x=SIDE_MARGIN + NEXT_QUEUE_CX, center_y=BOTTOM_MARGIN + NEXT_QUEUE_CY, width=NEXT_QUEUE_WIDTH, height=NEXT_QUEUE_HEIGHT, color=BLACK) self.rects.append(self.box) self.rects.append(self.outline)
def setup(self): self.not_navigable += [(x, 200) for x in range(100, 600, TILE_SIZE)] self.not_navigable += [(x, 600) for x in range(40, 800, TILE_SIZE)] self.not_navigable += [(x, 780) for x in range(800, 1200, TILE_SIZE)] self.not_navigable += [(800, y) for y in range(780, 900, TILE_SIZE)] self.not_navigable += [(500, y) for y in range(0, 200, TILE_SIZE)] self.not_navigable += [(x, 900) for x in range(800, 1200, TILE_SIZE)] self.not_navigable += [(x, 100) for x in range(900, 1200, TILE_SIZE)] self.navigable = [ item for item in self.tiles if item not in self.not_navigable ] self.agents_pos = [ self.navigable[randint(0, len(self.navigable) - 1)] for i in range(0, TOTAL_AGENTS) ] for tile in self.tiles: shape = arcade.create_rectangle_outline(tile[0] + TILE_SIZE / 2, tile[1] + TILE_SIZE / 2, TILE_SIZE, TILE_SIZE, arcade.color.BLUE, 1) self.shape_list.append(shape) self.collectable_pos = self.navigable[randint(0, len(self.navigable) - 1)] self.agents_path = [ self.pathfind_astar(self.agents_pos[i], self.collectable_pos) for i in range(0, TOTAL_AGENTS) ] for tile in self.not_navigable: shape = arcade.create_rectangle_filled(tile[0] + TILE_SIZE / 2, tile[1] + TILE_SIZE / 2, TILE_SIZE, TILE_SIZE, arcade.color.BLACK, 1) self.shape_list.append(shape)
def setup(self): # Create the sprite lists. self.tetrimino = Arcade.SpriteList() self.blocks_list = Arcade.SpriteList() # The tallest occupied space by column. # The lower the number, the higher the block is on the screen. self.max_by_col = self.find_max_by_col() # Generate first queue of tetriminos. self.tetrimino_queue = self.generate_queue() # Get the first tetrimino and add it to the field. self.tetrimino = tetrimino.Tetrimino(type=tetrimino.Tetrimino.Type[ self.tetrimino_queue.get()]).to_sprite_list() self.add_tetrimino_to_field(self.tetrimino) # Game area (with grid) self.game_area = Arcade.ShapeElementList() self.game_area.append( Arcade.create_rectangle_outline( Const.AREA_LEFT + (Const.AREA_RIGHT - Const.AREA_LEFT) / 2, Const.AREA_BOTTOM + (Const.AREA_TOP - Const.AREA_BOTTOM) / 2, Const.AREA_RIGHT - Const.AREA_LEFT, Const.AREA_TOP - Const.AREA_BOTTOM, Arcade.color.WHITE, 2)) for x in range(Const.AREA_LEFT + Const.BLOCK_SIZE, Const.AREA_RIGHT, Const.BLOCK_SIZE): self.game_area.append( Arcade.create_line( x, Const.AREA_TOP, x, Const.AREA_BOTTOM, (128, 128, 128, 128))) # Gray with 50% opacity for y in range(Const.AREA_BOTTOM + Const.BLOCK_SIZE, Const.AREA_TOP, Const.BLOCK_SIZE): self.game_area.append( Arcade.create_line(Const.AREA_LEFT, y, Const.AREA_RIGHT, y, (128, 128, 128, 128)))
def generate_shapes(self): size = sqrt(len(self.tiles)) shapes = [] for i, tile in enumerate(self.tiles): tx = i % size ty = i // size cx = TILE_SIZE + tx * TILE_SIZE cy = TILE_SIZE + ty * TILE_SIZE shape = ShapeElementList() for y, row in enumerate(reversed(tile.lines)): for x, pxl in enumerate(row): if pxl == "#": shape.append( create_rectangle_filled( cx + x * PIXEL, cy + y * PIXEL, PIXEL, PIXEL, color=WHITE, )) shapes.append(shape) # Add border print(shape.center_x, shape.center_y) rect = create_rectangle_outline( shape.center_x, shape.center_y, len(tile.lines) * PIXEL, len(tile.lines) * PIXEL, RED, # border_width=1, ) shapes.append(rect) return shapes
def generate_shape_list(self): """ Regenerate the shape list based on the current state of the game """ cells = self.ui_data["board"]["cells"] self.board_shape_list = arcade.ShapeElementList() for row in cells: for cell in row: rect = arcade.create_rectangle_filled( cell["x"], cell["y"], cell["width"], cell["height"], cell["color"] ) border = arcade.create_rectangle_outline( cell["x"], cell["y"], cell["width"], cell["height"], self.ui_data["colors"]["border"] ) self.board_shape_list.append(rect) self.board_shape_list.append(border)
def __init__( self, center_x: float, center_y: float, width: float = 300, height: float = 25, box_color: Tuple[int, int, int, int] = arcade.color.WHITE, border_color: Tuple[int, int, int, int] = arcade.color.BLACK, border_width: float = 1, text_color: Tuple[int, int, int, int] = arcade.color.BLACK, bold: bool = False, italic: bool = False, font_size: float = 12, horizontal_margin: float = 5, vertical_margin: float = 5, cursor_color: Tuple[int, int, int, int] = arcade.color.BLACK) -> None: self.center_x = center_x self.center_y = center_y self.width = width self.height = height self.box_color = box_color self.border_color = border_color self.border_width = border_width self.text = '' self.text_color = text_color self.bold = bold self.italic = italic self.font_size = font_size self.horizontal_margin = horizontal_margin self.vertical_margin = vertical_margin self.shapes = arcade.ShapeElementList() self.shapes.append( arcade.create_rectangle_filled(center_x=center_x, center_y=center_y, width=width, height=height, color=box_color), ) self.shapes.append( arcade.create_rectangle_outline(center_x=center_x, center_y=center_y, width=width, height=height, color=border_color, border_width=border_width)) self.text_sprites = arcade.SpriteList(is_static=True, use_spatial_hash=True) self.text_sprites.append( arcade.draw_text(text='', start_x=center_x - (width / 2) + horizontal_margin, start_y=center_y - (height / 2) + vertical_margin, color=text_color, font_size=font_size, bold=bold, italic=italic)) self.cursor_sprites = arcade.ShapeElementList() self.cursor = arcade.create_rectangle_filled( center_x=center_x - (width / 2) + horizontal_margin, center_y=center_y - (height / 2) + vertical_margin + self.text_sprites[0].height / 2, width=1, height=self.text_sprites[0].height, color=self.box_color) self.cursor_sprites.append(self.cursor) self.cursor_color = cursor_color self.prev_cursor_idx = 0 self.cursor_idx = 0 self.cursor_is_active = False self._cursor_blink_delta = 0 self._active = False self._current_key_pressed = None self._key_hold_delta = 0 self.KEY_SHIFTS = { arcade.key.GRAVE: arcade.key.ASCIITILDE, arcade.key.KEY_2: arcade.key.AT, arcade.key.KEY_6: arcade.key.ASCIICIRCUM, arcade.key.KEY_7: arcade.key.AMPERSAND, arcade.key.KEY_8: arcade.key.ASTERISK, arcade.key.KEY_9: arcade.key.PARENLEFT, arcade.key.KEY_0: arcade.key.PARENRIGHT, arcade.key.MINUS: arcade.key.UNDERSCORE, arcade.key.EQUAL: arcade.key.PLUS, arcade.key.BRACKETLEFT: arcade.key.BRACELEFT, arcade.key.BRACKETRIGHT: arcade.key.BRACERIGHT, arcade.key.BACKSLASH: arcade.key.BAR, arcade.key.SEMICOLON: arcade.key.COLON, arcade.key.APOSTROPHE: arcade.key.DOUBLEQUOTE, arcade.key.COMMA: arcade.key.LESS, arcade.key.PERIOD: arcade.key.GREATER, arcade.key.SLASH: arcade.key.QUESTION } self.KEY_NUMS = { arcade.key.NUM_1: arcade.key.KEY_1, arcade.key.NUM_2: arcade.key.KEY_2, arcade.key.NUM_3: arcade.key.KEY_3, arcade.key.NUM_4: arcade.key.KEY_4, arcade.key.NUM_5: arcade.key.KEY_5, arcade.key.NUM_6: arcade.key.KEY_6, arcade.key.NUM_7: arcade.key.KEY_7, arcade.key.NUM_8: arcade.key.KEY_8, arcade.key.NUM_9: arcade.key.KEY_9, arcade.key.NUM_0: arcade.key.KEY_0, arcade.key.NUM_DIVIDE: arcade.key.SLASH, arcade.key.NUM_MULTIPLY: arcade.key.ASTERISK, arcade.key.NUM_SUBTRACT: arcade.key.MINUS, arcade.key.NUM_ADD: arcade.key.PLUS, arcade.key.NUM_DECIMAL: arcade.key.PERIOD }
def __init__( self, center_x: float, center_y: float, width: float, height: float, nodes: List[Type[InteractiveWidget]] = list(), node_margin: float = 10, scroll_speed: float = 10, fill: bool = False, fill_color: Union[Tuple[int, int, int], Tuple[int, int, int, int]] = arcade.csscolor.WHITE, border: bool = False, border_color: Union[Tuple[int, int, int], Tuple[int, int, int, int]] = arcade.color.BLACK, border_width: float = 1 ) -> None: self.center_x = center_x self.center_y = center_y self.width = width self.height = height self.nodes = nodes self.node_margin = node_margin for node in self.nodes: node.active = ( node.center_y - node.height / 2 > self.center_y - self.height / 2 and node.center_y + node.height / 2 < self.center_y + self.height / 2 ) self.scroll_speed = scroll_speed self.fill = fill self.fill_color = fill_color self.border = border self.border_color = border_color self.border_width = border_width self.mouse_pos = (0, 0) self.shapes = arcade.ShapeElementList() if self.fill: self.fill_box = arcade.create_rectangle_filled( center_x=center_x, center_y=center_y, width=width, height=height, color=fill_color ) self.shapes.append(self.fill_box) if self.border: self.border_box = arcade.create_rectangle_outline( center_x=center_x, center_y=center_y, width=width, height=height, color=border_color, border_width=border_width ) self.shapes.append(self.border_box)
def on_update(self, delta_time: float): if self.music: position = self.music.get_stream_position() if position == 0.0: self.play_song() hang_test = [False, 0] self.frame_count += 1 self.player_sprite.current_background = self.window.background_color for item in self.primitive_list: self.primitive_list.remove(item) if self.w_pressed: jump_test = self.physics_engine.can_jump() if jump_test[0] and not self.jump_needs_reset: self.physics_engine.jump(12 + jump_test[1]) if self.sounds_enabled: arcade.play_sound(self.jump_sound, 0.01) self.jump_needs_reset = True self.hang_timer = 40 if self.space_pressed: hang_test = self.physics_engine.can_hang(self.hang_timer) if hang_test[0]: if self.hang_timer == 40: if self.sounds_enabled: arcade.play_sound(self.hang_sound, 0.05) self.hang_timer = self.physics_engine.hang(hang_test[1], self.hang_timer) if self.a_pressed and not self.d_pressed: if self.player_sprite.change_x > - C.MAX_SPEED: self.player_sprite.change_x -= 0.1 * self.player_sprite.speed_multiplier elif self.d_pressed and not self.a_pressed: if self.player_sprite.change_x < C.MAX_SPEED: self.player_sprite.change_x += 0.1 * self.player_sprite.speed_multiplier else: if self.player_sprite.change_x > C.FRICTION * self.player_sprite.speed_multiplier: self.player_sprite.change_x -= C.FRICTION * self.player_sprite.speed_multiplier elif self.player_sprite.change_x < - C.FRICTION * self.player_sprite.speed_multiplier: self.player_sprite.change_x += C.FRICTION * self.player_sprite.speed_multiplier else: self.player_sprite.change_x = 0 self.physics_engine.update(delta_time) if hang_test[0]: if self.player_sprite.change_x > 0: x_offset = self.player_sprite.change_x else: x_offset = 0 self.primitive_list.append(arcade.create_rectangle_filled( self.player_sprite.center_x + 20 + (self.hang_timer // 2) + x_offset, self.player_sprite.center_y + 30, self.hang_timer, 5, (255 - int(self.hang_timer * (255 / 40)), int(self.hang_timer * (255 / 40)), 0))) self.primitive_list.append(arcade.create_rectangle_outline( self.player_sprite.center_x + 40, self.player_sprite.center_y + 30, 40, 5, arcade.color.WHITE)) for enemy in self.ennemies: if arcade.has_line_of_sight(enemy.position, self.player_sprite.position, self.platforms): start_x = enemy.center_x start_y = enemy.center_y dest_x = self.player_sprite.center_x dest_y = self.player_sprite.center_y x_diff = dest_x - start_x y_diff = dest_y - start_y angle = math.atan2(y_diff, x_diff) enemy.angle = math.degrees(angle) - 90 # if self.frame_count % 30 == 0: # bullet = arcade.Sprite(":resources:images/space_shooter/laserBlue01.png", 0.5) # bullet.center_x = start_x # bullet.center_y = start_y # bullet.angle = math.degrees(angle) # bullet.change_x = math.cos(angle) * C.BULLET_SPEED # bullet.change_y = math.sin(angle) * C.BULLET_SPEED # self.bullet_list.append(bullet) for bullet in self.bullet_list: if self.view_left > bullet.center_x or bullet.center_x > C.SCREEN_WIDTH + self.view_left or \ self.view_bottom > bullet.center_y or bullet.center_y > C.SCREEN_HEIGHT + self.view_bottom: bullet.remove_from_sprite_lists() self.bullet_list.update() changed = False # Scroll left left_boundary = self.view_left + C.LEFT_VIEWPORT_MARGIN if self.player_sprite.left < left_boundary: self.view_left -= left_boundary - self.player_sprite.left changed = True # Scroll right right_boundary = self.view_left + C.SCREEN_WIDTH - C.RIGHT_VIEWPORT_MARGIN if self.player_sprite.right > right_boundary: self.view_left += self.player_sprite.right - right_boundary changed = True # Scroll up top_boundary = self.view_bottom + C.SCREEN_HEIGHT - C.TOP_VIEWPORT_MARGIN if self.player_sprite.top > top_boundary: self.view_bottom += self.player_sprite.top - top_boundary changed = True # Scroll down if changed: # Only scroll to integers. Otherwise we end up with pixels that # don't line up on the screen self.view_bottom = int(self.view_bottom) self.view_left = int(self.view_left) # Do the scrolling arcade.set_viewport(self.view_left, C.SCREEN_WIDTH + self.view_left, self.view_bottom, C.SCREEN_HEIGHT + self.view_bottom) if self.player_sprite.top >= self.platforms[0].center_y + 125 and self.platforms[ 0].left < self.player_sprite.center_x < self.platforms[0].right: if self.level_manager: if self.seed.lvl_id + 1 < len(self.level_manager.levels): self.seed = self.level_manager.levels[self.seed.lvl_id + 1] if self.seed.lvl_id == self.level_manager.current_level.lvl_id + 1: self.level_manager.current_level = self.level_manager.levels[self.seed.lvl_id] pickle_out = open(resource_path('data/current_level.save'), 'wb') pickle.dump(self.seed.lvl_id, pickle_out) pickle_out.close() self.setup() else: from main import Victory pickle_out = open(resource_path('data/current_level.save'), 'wb') pickle.dump(self.seed.lvl_id + 1, pickle_out) pickle_out.close() self.window.show_view(Victory(self.window)) else: self.seed.seed = None self.setup() if self.player_sprite.top <= self.view_bottom: self.setup() self.fps.tick()
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 draw(self, game, x, y): game.draw_list.append( arcade.create_ellipse_outline(x, y, self.size_x, self.size_y, colors["sky"], 10, 0)) game.draw_list.append( arcade.create_rectangle_filled(x, y, self.size_x / 2, self.size_y / 2, colors["sky"], 45)) game.draw_list.append( arcade.create_ellipse_outline(x - 20, y + 20, 10, 10, colors["db"], 5, 0)) game.draw_list.append( arcade.create_ellipse_outline(x - 20, y - 20, 10, 10, colors["db"], 5, 0)) game.draw_list.append( arcade.create_ellipse_outline(x + 20, y + 20, 10, 10, colors["db"], 5, 0)) game.draw_list.append( arcade.create_ellipse_outline(x + 20, y - 20, 10, 10, colors["db"], 5, 0)) game.draw_list.append( arcade.create_rectangle_outline(x, y + 30, 10, 10, colors["db"], 4, 45)) game.draw_list.append( arcade.create_rectangle_outline(x, y - 30, 10, 10, colors["db"], 4, 45)) game.draw_list.append( arcade.create_rectangle_outline(x + 30, y, 10, 10, colors["db"], 4, 45)) game.draw_list.append( arcade.create_rectangle_outline(x - 30, y, 10, 10, colors["db"], 4, 45)) game.draw_list.append( arcade.create_line(x - 80, y, x + 80, y, colors["db"], 2)) game.draw_list.append( arcade.create_line(x, y - 80, x, y + 80, colors["db"], 2)) game.draw_list.append( arcade.create_line(x - 60, y + 60, x + 60, y - 60, colors["db"], 1)) game.draw_list.append( arcade.create_line(x - 60, y - 60, x + 60, y + 60, colors["db"], 1)) game.draw_list.append( arcade.create_ellipse_filled(x - 60, y + 60, 14, 14, colors["db"])) game.draw_list.append( arcade.create_ellipse_filled(x + 60, y + 60, 14, 14, colors["db"])) game.draw_list.append( arcade.create_ellipse_filled(x - 60, y - 60, 14, 14, colors["db"])) game.draw_list.append( arcade.create_ellipse_filled(x + 60, y - 60, 14, 14, colors["db"])) game.draw_list.append( arcade.create_ellipse_filled(x - 80, y, 14, 14, colors["db"])) game.draw_list.append( arcade.create_ellipse_filled(x + 80, y, 14, 14, colors["db"])) game.draw_list.append( arcade.create_ellipse_filled(x, y + 80, 14, 14, colors["db"])) game.draw_list.append( arcade.create_ellipse_filled(x, y - 80, 14, 14, colors["db"])) game.draw_list.append( arcade.create_ellipse_filled(x - 60, y + 60, 6, 6, colors["white"])) game.draw_list.append( arcade.create_ellipse_filled(x + 60, y + 60, 6, 6, colors["white"])) game.draw_list.append( arcade.create_ellipse_filled(x - 60, y - 60, 6, 6, colors["white"])) game.draw_list.append( arcade.create_ellipse_filled(x + 60, y - 60, 6, 6, colors["white"])) game.draw_list.append( arcade.create_ellipse_filled(x - 80, y, 6, 6, colors["white"])) game.draw_list.append( arcade.create_ellipse_filled(x + 80, y, 6, 6, colors["white"])) game.draw_list.append( arcade.create_ellipse_filled(x, y + 80, 6, 6, colors["white"])) game.draw_list.append( arcade.create_ellipse_filled(x, y - 80, 6, 6, colors["white"])) game.draw_list.append( arcade.create_ellipse_filled(x, y, 10, 10, colors["white"]))