def primitive_create(self): circle1 = arcade.create_ellipse_filled(self.x1, self.y1, self.mass1, self.mass1, self.color) circle2 = arcade.create_ellipse_filled(self.x2, self.y2, self.mass2, self.mass2, self.color) line1 = arcade.create_line(self.offsetX, self.offsetY, self.x1, self.y1, self.color, self.linewidth) line2 = arcade.create_line(self.x1, self.y1, self.x2, self.y2, self.color, self.linewidth) trail = arcade.create_line_strip(self.traillist, self.color, self.trailwidth) self.circle1 = arcade.ShapeElementList() self.circle1.append(circle1) self.circle2 = arcade.ShapeElementList() self.circle2.append(circle2) self.line1 = arcade.ShapeElementList() self.line1.append(line1) self.line2 = arcade.ShapeElementList() self.line2.append(line2) self.trail = arcade.ShapeElementList()
def __init__(self): # Call the parent class initializer super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Earth Moon Sun") self.sun_x = SCREEN_WIDTH / 2 self.sun_y = SCREEN_HEIGHT / 2 self.earth_dist = 180 self.moon_dist = 40 self.sun_dia = 20 self.earth_dia = 10 self.moon_dia = 5 self.moon_shape_list = arcade.ShapeElementList() moon = arcade.create_ellipse_filled(self.moon_dist, 0, self.moon_dia, self.moon_dia, arcade.color.WHITE) self.moon_shape_list.append(moon) self.moon_angle = 0 self.earth_angle = 0 self.earth_shape_list = arcade.ShapeElementList() sun = arcade.create_ellipse_filled(0, 0, self.sun_dia, self.sun_dia, arcade.color.YELLOW) earth = arcade.create_ellipse_filled(self.earth_dist, 0, self.earth_dia, self.earth_dia, arcade.color.BRIGHT_GREEN) self.earth_shape_list.append(sun) self.earth_shape_list.append(earth) self.earth_shape_list.center_x = self.sun_x self.earth_shape_list.center_y = self.sun_y self.moon_shape_list.center_x = self.sun_x + self.earth_dist self.moon_shape_list.center_y = self.sun_y arcade.set_background_color(arcade.color.DARK_MIDNIGHT_BLUE)
def __init__(self, width: int, height: int, players: List[Player]): super().__init__(width, height) arcade.set_background_color(arcade.color.AMAZON) self.game = Game() self.scores = [0, 0] self.freeze = self.NEW_GAME_FREEZE self.players = players self.background_list = arcade.ShapeElementList() self.background_list.append( arcade.create_ellipse_filled( *self.translate_point(np.array([0, 0])), width=self.game.ARENA_RADIUS * self.SCALE, height=self.game.ARENA_RADIUS * self.SCALE, color=arcade.color.ORANGE_PEEL)) self.p_list = [arcade.ShapeElementList() for _ in range(2)] self.p_list[0].append( arcade.create_ellipse_filled( 0, 0, width=self.game.PLAYER_RADIUS * self.SCALE, height=self.game.PLAYER_RADIUS * self.SCALE, color=arcade.color.AERO_BLUE)) self.p_list[1].append( arcade.create_ellipse_filled( 0, 0, width=self.game.PLAYER_RADIUS * self.SCALE, height=self.game.PLAYER_RADIUS * self.SCALE, color=arcade.color.ANTIQUE_RUBY))
def __init__(self, width, height, title): super().__init__(width, height, title) self.center_window() # A batch ami egy ShapeElementList objektum self.batch = arcade.ShapeElementList() # Ellipses - Ellipszisek ellipse1 = arcade.create_ellipse_filled(440, 360, 50, 50, arcade.color.ROSE) ellipse2 = arcade.create_ellipse_outline(640, 360, 50, 80, arcade.color.RED) ellipse3 = arcade.create_ellipse_filled_with_colors( 840, 360, 50, 80, arcade.color.RED, arcade.color.BLUE, 45) # Triangle - Háromszög triangle = arcade.create_polygon([[0, 0], [100, 0], [50, 100]], arcade.color.BLUE) # Rectangle - Téglalap rect = arcade.create_rectangle_filled(100, 360, 100, 150, arcade.color.GREEN) # Invisible Rectangle 1 pixel - Láthatalan 1 pixel átmérőjű négyzet invisible_rect = arcade.create_rectangle_filled( 0, 0, 1, 1, arcade.color.BLACK) # Itt adjuk hozzá a batch-oz a geometriai alakzatokat self.batch.append(ellipse1) self.batch.append(ellipse2) self.batch.append(ellipse3) self.batch.append(triangle) self.batch.append(rect) # Ezt mindig utoljára adjuk a batch-hoz, amíg a hibát ki nem javítják az Arcade fejlesztői. self.batch.append(invisible_rect)
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 generate_star_list(self): new_universe = [] new_star_list = arcade.ShapeElementList() # procedurally generate all the StarSystem objects on the screen and store as VBOs for x in range(0, SECTORS_X): # a row of sectors, will be appended to self.universe row = [] for y in range(0, SECTORS_Y): seed_x = int(self.galaxy_offset["x"]) + x seed_y = int(self.galaxy_offset["y"]) + y s = StarSystem(seed_x, seed_y) row.append(s) if s.star_exists: star = arcade.create_ellipse_filled(x * SECTOR_SIZE, y * SECTOR_SIZE, s.star_diameter, s.star_diameter, s.star_color) new_star_list.append(star) new_universe.append(row) self.universe = new_universe self.star_list = new_star_list
def build_map_items(self): shape_list = arcade.ShapeElementList() # targets (blue) for target in self.world.map.targets: shape_list.append( arcade.create_rectangle_filled(target.x + 0.5, target.y + 0.5, 2, 2, color=(0, 0, 255))) # towers (red) for tower in self.world.map.towers: shape_list.append( arcade.create_rectangle_filled(tower.x + 0.5, tower.y + 0.5, 2, 2, color=(255, 0, 0))) # communication markers (circles) for marker in self.world.map.markers: shape_list.append( arcade.create_ellipse_filled(marker.location.x + 0.5, marker.location.y + 0.5, 1, 1, color=(255, 0, 255))) # TODO: self.gates self.map_items = shape_list
def __init__(self, x, y, width, height, angle): alpha = 96 if random.choice((True, True)): self.color = random.choice(( arcade.color.RED + (alpha, ), arcade.color.BLUE + (alpha, ), arcade.color.YELLOW + (alpha, ), )) else: self.color = random.choice(( arcade.color.RED + (alpha, ), arcade.color.RED + (alpha, ), arcade.color.RED + (alpha, ), arcade.color.BLUE + (alpha, ), arcade.color.BLUE + (alpha, ), arcade.color.BLUE + (alpha, ), arcade.color.WHITE + (alpha, ), )) self.x = x self.y = y self.angle = angle self.delta_angle = random.uniform(0.2, 0.6) shape = arcade.create_ellipse_filled(0, 0, width, height, self.color, 0) self.shape_list = arcade.ShapeElementList() self.shape_list.append(shape) self.shape_list.center_x = self.x self.shape_list.center_y = self.y
def draw(self, game, x, y): game.draw_list.append( arcade.create_ellipse_outline(x, y, self.size_x, self.size_y, colors["db"], 4)) game.draw_list.append( arcade.create_ellipse_filled(x, y, self.size_x / 3, self.size_y / 3, colors["sky"]))
def make_big_hills(): shape_list = arcade.ShapeElementList() for i in range(3): shape = arcade.create_ellipse_filled(i * 400, 60, 200, 200, (129, 122, 198)) shape_list.append(shape) return shape_list
def make_small_hills(): shape_list = arcade.ShapeElementList() for i in range(6): shape = arcade.create_ellipse_filled(i * 200, 60, 100, 100, (146, 82, 161)) shape_list.append(shape) return shape_list
def update(self, board): width = Square.WIDTH height = Square.HEIGHT margin = Square.MARGIN for shape in self: self.remove(shape) for row in board.state: for square in row: color = None if square.player_state == SquarePlayerState.CHECKER_RED: color = arcade.color.RED elif square.player_state == SquarePlayerState.CHECKER_BLUE: color = arcade.color.BLUE if square.player_state != SquarePlayerState.EMPTY: current_cir = arcade.create_ellipse_filled( (margin + width) * square.column + margin + width // 2, (margin + height) * square.row + margin + height // 2, 30, 30, color ) self.append(current_cir)
def make_person(head_radius, chest_height, chest_width, leg_width, leg_height, arm_width, arm_length, arm_gap, shoulder_height): shape_list = arcade.ShapeElementList() # Head shape = arcade.create_ellipse_filled(0, chest_height / 2 + head_radius, head_radius, head_radius, arcade.color.WHITE) shape_list.append(shape) # Chest shape = arcade.create_rectangle_filled(0, 0, chest_width, chest_height, arcade.color.BLACK) shape_list.append(shape) # Left leg shape = arcade.create_rectangle_filled( -(chest_width / 2) + leg_width / 2, -(chest_height / 2) - leg_height / 2, leg_width, leg_height, arcade.color.RED) shape_list.append(shape) # Right leg shape = arcade.create_rectangle_filled( (chest_width / 2) - leg_width / 2, -(chest_height / 2) - leg_height / 2, leg_width, leg_height, arcade.color.RED) shape_list.append(shape) # Left arm shape = arcade.create_rectangle_filled( -(chest_width / 2) - arm_width / 2 - arm_gap, (chest_height / 2) - arm_length / 2 - shoulder_height, arm_width, arm_length, arcade.color.BLUE) shape_list.append(shape) # Left shoulder shape = arcade.create_rectangle_filled( -(chest_width / 2) - (arm_gap + arm_width) / 2, (chest_height / 2) - shoulder_height / 2, arm_gap + arm_width, shoulder_height, arcade.color.BLUE_BELL) shape_list.append(shape) # Right arm shape = arcade.create_rectangle_filled( (chest_width / 2) + arm_width / 2 + arm_gap, (chest_height / 2) - arm_length / 2 - shoulder_height, arm_width, arm_length, arcade.color.BLUE) shape_list.append(shape) # Right shoulder shape = arcade.create_rectangle_filled( (chest_width / 2) + (arm_gap + arm_width) / 2, (chest_height / 2) - shoulder_height / 2, arm_gap + arm_width, shoulder_height, arcade.color.BLUE_BELL) shape_list.append(shape) return shape_list
def __init__(self, x, y, size,color, kind): self.x = x self.y = y self.kind = kind if self.kind == 0: self.shape = arcade.create_rectangle_filled(self.x, self.y, size, size, color) else: self.shape = arcade.create_ellipse_filled(self.x, self.y, size / 2, size / 2, color)
def create_Zbiggy(self): self.Zbiggi = arcade.ShapeElementList() for ex, ey in self.engine.enemies: self.Zbiggi.append( arcade.create_ellipse_filled( (ex + 0.5) * self.SQUARE_WIDTH, (ey + 0.5) * self.SQUARE_HEIGHT, self.SQUARE_WIDTH / 2, self.SQUARE_HEIGHT / 2, ZBIGGY_COLOR))
def __init__(self, xpos, ypos): self._radius = 17.5 super().__init__(xpos, ypos, self._radius, self._radius, 0, arcade.color.BLUE) shape = arcade.create_ellipse_filled(0, 0, self.width, self.height, self.color, self.angle) self.shape_list = arcade.ShapeElementList() self.shape_list.append(shape)
def render(self, et, dt): if self.shapes is None: self.shapes = arcade.ShapeElementList() for m in self.markers: (x, y) = self.map.project(m[0]) self.shapes.append( arcade.create_line(x, y, x, y + 24, (0, 0, 0, 128), 4)) self.shapes.append( arcade.create_ellipse_filled(x, y, 4, 4, (0, 0, 0, 128), 0, 18)) self.shapes.append( arcade.create_ellipse_filled(x, y + 24, 8, 8, arcade.color.AMAZON, 0, 18)) self.shapes.draw()
def set_wall(self, row, col): spot = self.spots[row][col] self.spots_list[row * DIV + col] = arcade.create_ellipse_filled( spot.x * G_W + G_W / 2, spot.y * G_H + G_H / 2, 3, 3, arcade.color.RED) self.spots[row][col].set_wall() self.obstacles.append( pymunk.Vec2d(spot.x * G_W + G_W / 2, spot.y * G_H + G_H / 2)) self.__recalculate_grid()
def __init__(self, x, y, width, height, angle, delta_x, delta_y, delta_angle, color): super().__init__(x, y, width, height, angle, delta_x, delta_y, delta_angle, color) shape = arcade.create_ellipse_filled(0, 0, self.width, self.height, self.color, self.angle) self.shape_list = arcade.ShapeElementList() self.shape_list.append(shape)
def __init__(self, xpos, ypos): self._radius = AGENT_RADIUS super().__init__(xpos, ypos, self._radius, self._radius, 0, arcade.color.BLUE) shape = arcade.create_ellipse_filled(0, 0, self.width, self.height, self.color, self.angle) lin = arcade.create_line(0, 0, 0 + self._radius, 0, arcade.color.WHITE, 5) self.shape_list = arcade.ShapeElementList() self.shape_list.append(shape) self.shape_list.append(lin)
def render(self, et, dt): if self.shapes is None: self.shapes = arcade.ShapeElementList() l = None for e in self.waypoints.points: n = self.map.project(e[0]) if l is not None: self.shapes.append( arcade.create_line_strip((l, n), (0, 40, 150, 64), 3)) rx, ry = self.map.project_radius(e[0], self.waypoints.radius) self.shapes.append( arcade.create_ellipse_filled(*n, rx, ry, (0, 40, 150, 32), 0, 18)) self.shapes.append( arcade.create_ellipse_filled(*n, 5, 5, (0, 40, 150, 128), 0, 9)) l = n self.shapes.draw()
def _create_shape(self, scale) -> Shape: """ Create a shape representing this lake. :return: a Arcade shape object. """ if self.hole is not None: points = self._create_points(scale) return create_line_strip(points, self.color, self.border_width * scale) return create_ellipse_filled(self.center_x, self.center_y, self.outer_radius * scale, self.outer_radius * scale, self.color)
def __init__(self, xpos, ypos): self._radius = BOT_RADIUS super().__init__(xpos, ypos, self._radius, self._radius, 0, arcade.color.GREEN) shape = arcade.create_ellipse_filled(0, 0, self.width, self.height, self.color, self.angle) self.shape_list = arcade.ShapeElementList() self.shape_list.append(shape) point_list = ((self.x, self.y), (self.x + 10, self.y + 10), (self.x + 14, self.y + 18)) self.planned_path = Line(point_list)
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 make_kinematic_shape(self): # dynamic circle #s = arcade.create_ellipse_filled(0, 0, self.radius, self.radius, ball_color) s = arcade.create_ellipse_filled_with_colors( 0, 0, self.radius, self.radius, arcade.color.GRAY, arcade.color.UNMELLOW_YELLOW) self.kinematic_shape_element.append(s) # dot s_radius = int(self.radius * 0.15) s = arcade.create_ellipse_filled(self.radius - s_radius * 2, 0, s_radius, s_radius, arcade.color.WHITE) self.kinematic_shape_element.append(s)
def make_shape(): shape_list = arcade.ShapeElementList() # Shape center around which we will rotate center_x = 20 center_y = 30 width = 30 height = 40 shape = arcade.create_ellipse_filled(center_x, center_y, width, height, arcade.color.WHITE) shape_list.append(shape) return shape_list
def update(self, delta_time, walls, ball, my_gate, enemy_gate, team_player, enemy_1, enemy_2): self.batches = defaultdict(_Batch) distances = np.min(self.distances(walls), axis=1) cut_sensors = np.multiply(np.resize(distances, (N_SENSORS, 1)), self.sensors) for [sx, sy, ex, ey] in cut_sensors: self.append(arcade.create_line(sx, sy, ex, ey, color=self.g_color)) circ = arcade.create_ellipse_filled(0, 0, width=20, height=20, color=self.color) self.append(circ) self.append(circ) self.holding_ball = self.check_for_collision_with_ball(ball) self.on_wall = np.min(distances) < 0.05 return self.generate_input(distances, ball, my_gate, enemy_gate, team_player, enemy_1, enemy_2)
def setup_draw(self): ''' Creating the inital shapes to be rendered later by the BoxCar class. ''' self.visuals.center_x = self.body.position.x self.visuals.center_y = self.body.position.y # Draws the wheel shape = arcade.create_ellipse_filled(0, 0, self.radius, self.radius, arcade.color.GRAY) self.visuals.append(shape) # Draws the orientation of wheel end = self.body.rotation_vector * self.radius shape = arcade.create_line(0, 0, end.x, end.y, arcade.color.BLACK, 2) self.visuals.append(shape)
def follow_path(self): if self.following_path: if self.boundaries[self.path_index].has_crossed_line( self.body.position): if self.path[self.path_index] == self.goal: target = self.path[self.path_index] self.__slow_down(target) else: self.path_index += 1 if self.following_path: target = self.path[self.path_index] self.__seek(target) self.debug.append( arcade.create_ellipse_filled( target.x, target.y, 4, 4, arcade.color.BANGLADESH_GREEN)) return self.following_path
def make_clouds(): shape_list = arcade.ShapeElementList() shape_list.center_x = SCREEN_WIDTH / 2 for i in range(4): if i == 0: x = shape_list.center_x y = SCREEN_HEIGHT - 100 elif i == 1: x = shape_list.center_x y = SCREEN_HEIGHT - 150 elif i == 2: x = shape_list.center_x - 50 y = SCREEN_HEIGHT - 150 else: x = shape_list.center_x + 50 y = SCREEN_HEIGHT - 150 shape = arcade.create_ellipse_filled(x, y, 50, 50, (255, 255, 255)) shape_list.append(shape) return shape_list