def __init__( self, username: str, score: int, timestamp: str, center_x: float, center_y: float, width: float, height: float, text_color: Tuple[int, int, int, int] = arcade.color.BLACK, display_color: Tuple[int, int, int, int] = arcade.color.WHITE, outline_color: Tuple[int, int, int, int] = arcade.color.BLACK, outline_width: float = 1 ) -> None: self.username = username self.score = score self.timestamp = datetime.fromisoformat(timestamp).strftime(r'%d/%m/%Y | %I:%M %p') self._center_x = center_x self._center_y = center_y self.width = width self.height = height self.text_color = text_color self.display_color = display_color self.outline_color = outline_color self.outline_width = outline_width self.display = arcade.create_rectangle_filled( center_x=center_x, center_y=center_y, width=width, height=height, color=display_color ) self.display_outline = arcade.create_rectangle_outline( center_x=center_x, center_y=center_y, width=width, height=height, color=outline_color, border_width=outline_width ) self.elements = arcade.ShapeElementList() self.elements.append(self.display) self.elements.append(self.display_outline) self.username_text = arcade.draw_text( text=username, start_x=center_x - width / 2 + 20, start_y=center_y, color=text_color, anchor_y='center' ) self.score_text = arcade.draw_text( text=str(score), start_x=center_x, start_y=center_y, color=text_color, anchor_y='center' ) self.timestamp_text = arcade.draw_text( text=self.timestamp, start_x=center_x + width / 2 - 200, start_y=center_y, color=text_color, anchor_y='center' ) arcade.text.draw_text_cache.clear()
def __init__(self, width, height, title): super().__init__(width, height, title) self.set_location(0, 25) # variables for coordinate calculation relative to the board and relative to the screen self.board_pieces_location = [[0 for i in range(9)] for j in range(9)] self.white_captured_location = [[0 for i in range(3)] for j in range(3)] self.black_captured_location = [[0 for i in range(3)] for j in range(3)] self.coordinates_map = [[[x, y] for x in range(170, 845, 75)] for y in range(700, 25, -75)] self.white_coordinates = [[[x, y] for x in range(975, 1275, 75)] for y in range(275, -25, -75)] self.black_coordinates = [[[x, y] for x in range(975, 1275, 75)] for y in range(675, 375, -75)] # initialize variables self.mouse_x = 0 self.mouse_y = 0 self.selected_piece = 0 #stores selected piece object self.turn_number = 1 # booleans and somewhat boolean self.pieces_selected = False self.turn = "white" self.promotion_prompt = False self.king_checked = False self.king_checkmated = False self.capture_done = False self.checked_for_promotion = False # lists self.prev_position = [ [0, 0], [0, 0], [0, 0], [0, 0] ] #not the prev pos of last turn, but prev pos of last click (which could be from either this or last turn) self.new_position = [] self.possible_moves = [] self.checking_pieces = [] self.covered_squares = ["test"] self.check_possible_responses = [None] self.move_history = [["1"]] # sound files self.place_sound = arcade.Sound( os.path.join(sys.path[0], "sound", "clack.wav")) self.disgrace_sound = arcade.Sound( os.path.join(sys.path[0], "sound", "disgrace.wav")) # sprite files self.sprites = os.path.join(sys.path[0], "sprites") self.all_pieces = arcade.SpriteList() self.highlight = arcade.ShapeElementList() # places pieces on their correct locations self.initialize_pieces() # save file name = datetime.now().strftime("%m.%d.%Y,%H;%M;%S") + ".txt" saves = os.path.join(sys.path[0], "saves") self.save_file = open(os.path.join(saves, name), "w", encoding='utf-8')
def change_color(self, new_color): self.color = new_color shape = arcade.create_rectangle_filled(0, 0, self.width, self.height, self.color, self.angle) self.shape_list = arcade.ShapeElementList() self.shape_list.append(shape)
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 setup( self, config: Dict[str, bool], attack: ProgramType, defend: ProgramType, o_attack: ProgramType, o_defend: ProgramType, ): """set up everything""" # background self.background: arcade.Texture = arcade.load_texture( "images/field.jpg") # pymunk space self.space: pymunk.Space = pymunk.Space() self.space.gravity = (0, 0) # self.space.damping = 0.4 self.space.collision_slop = 0.1 # lists self.dynamicSpriteList = arcade.SpriteList() self.arrowsList = arcade.ShapeElementList() # field elements body = pymunk.Body(body_type=pymunk.Body.STATIC) self.space.add(body) # walls walls = [ pymunk.Segment(body, (0, 0), (SCREEN_WIDTH, 0), 2.0), pymunk.Segment(body, (0, 0), (0, SCREEN_HEIGHT), 2.0), pymunk.Segment(body, (0, SCREEN_HEIGHT), (SCREEN_WIDTH, SCREEN_HEIGHT), 2.0), pymunk.Segment(body, (SCREEN_WIDTH, SCREEN_HEIGHT), (SCREEN_WIDTH, 0), 2.0), ] for line in walls: line.friction = 0.7 line.elasticity = 0.6 line.filter = pymunk.ShapeFilter(categories=1) self.space.add(*walls) # goals goals = [ pymunk.Segment(body, (180, 78), (SCREEN_WIDTH - 180, 78), 2.0), # yellow crossbar pymunk.Segment( body, (180, SCREEN_HEIGHT - 78), (SCREEN_WIDTH - 180, SCREEN_HEIGHT - 78), 2.0, ), # blue crossbar pymunk.Segment(body, (180, 60), (SCREEN_WIDTH - 180, 60), 2.0), pymunk.Segment(body, (180, 78), (180, 60), 2.0), pymunk.Segment(body, (SCREEN_WIDTH - 180, 78), (SCREEN_WIDTH - 180, 60), 2.0), pymunk.Segment( body, (180, SCREEN_HEIGHT - 60), (SCREEN_WIDTH - 180, SCREEN_HEIGHT - 60), 2.0, ), pymunk.Segment(body, (180, SCREEN_HEIGHT - 78), (180, SCREEN_HEIGHT - 60), 2.0), pymunk.Segment( body, (SCREEN_WIDTH - 180, SCREEN_HEIGHT - 78), (SCREEN_WIDTH - 180, SCREEN_HEIGHT - 60), 2.0, ), ] for idx, line in enumerate(goals): line.elasticity = 0.9 if idx < 2: line.friction = 0.2 line.filter = pymunk.ShapeFilter(categories=2) else: line.friction = 1 line.filter = pymunk.ShapeFilter(categories=1) self.space.add(*goals) # white lines around the field self.fieldLines = [ pymunk.Segment(body, (77, 77), (77, SCREEN_HEIGHT - 77), 4.0), pymunk.Segment( body, (77, SCREEN_HEIGHT - 77), (SCREEN_WIDTH - 77, SCREEN_HEIGHT - 77), 4.0, ), pymunk.Segment( body, (SCREEN_WIDTH - 77, SCREEN_HEIGHT - 77), (SCREEN_WIDTH - 77, 77), 4.0, ), pymunk.Segment(body, (SCREEN_WIDTH - 77, 77), (77, 77), 4.0), ] for line in self.fieldLines: line.filter = pymunk.ShapeFilter(categories=4) line.collision_type = 3 self.space.add(*self.fieldLines) # penalty area lines self.penaltyLines = [ pymunk.Circle(body, 40, (210, 110)), pymunk.Circle(body, 40, (210, SCREEN_HEIGHT - 110)), pymunk.Circle(body, 40, (SCREEN_WIDTH - 210, 110)), pymunk.Circle(body, 40, (SCREEN_WIDTH - 210, SCREEN_HEIGHT - 110)), pymunk.Segment(body, (171, 77), (171, 112), 4.0), pymunk.Segment(body, (211, 152), (SCREEN_WIDTH - 211, 152), 4.0), pymunk.Segment(body, (SCREEN_WIDTH - 171, 77), (SCREEN_WIDTH - 171, 112), 4.0), pymunk.Segment(body, (171, SCREEN_HEIGHT - 77), (171, SCREEN_HEIGHT - 112), 4.0), pymunk.Segment( body, (211, SCREEN_HEIGHT - 152), (SCREEN_WIDTH - 211, SCREEN_HEIGHT - 152), 4.0, ), pymunk.Segment( body, (SCREEN_WIDTH - 171, SCREEN_HEIGHT - 77), (SCREEN_WIDTH - 171, SCREEN_HEIGHT - 112), 4.0, ), ] for line in self.penaltyLines: line.filter = pymunk.ShapeFilter(categories=4) line.collision_type = 3 self.space.add(*self.penaltyLines) # robots self.robots = [ Robot( "images/robot.png", 0.02176, 2.1, SCREEN_WIDTH / 2, SCREEN_HEIGHT * 17 / 40, orientation=0, ), Robot( "images/robot.png", 0.02176, 2.1, SCREEN_WIDTH / 2, SCREEN_HEIGHT / 6, orientation=0, ), Robot( "images/enemy.png", 0.01611170784103114930182599355532, 2.1, SCREEN_WIDTH / 2, SCREEN_HEIGHT * 7 / 10, ), Robot( "images/enemy.png", 0.01611170784103114930182599355532, 2.1, SCREEN_WIDTH / 2, SCREEN_HEIGHT * 5 / 6, ), ] for i in range(4): self.dynamicSpriteList.append(self.robots[i].sprite) self.robots[i].sprite.shape.filter = pymunk.ShapeFilter( categories=8, mask=pymunk.ShapeFilter.ALL_MASKS() ^ 0b100) self.robots[i].sprite.shape.collision_type = 1 self.j1 = pymunk.constraints.PivotJoint( self.robots[i].targetPointBody, self.robots[i].sprite.body, (0, 0), (0, 0), ) self.j1.max_force = 7000 self.j1.max_bias = 0 self.j2 = pymunk.constraints.GearJoint( self.robots[i].targetPointBody, self.robots[i].sprite.body, 0, 1) self.j2.max_force = 50000 self.space.add( self.robots[i].sprite.body, self.robots[i].sprite.shape, self.j1, self.j2, ) # ball self.ball = PymunkSprite( "images/ball.png", 0.01897533206831119544592030360531, 0.07, SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, ) self.dynamicSpriteList.append(self.ball) self.ball.shape.filter = pymunk.ShapeFilter( categories=16, mask=pymunk.ShapeFilter.ALL_MASKS() ^ 0b110) self.ball.shape.collision_type = 2 self.space.add(self.ball.body, self.ball.shape) self.ballAngle = 0 self.j1 = pymunk.constraints.PivotJoint(self.space.static_body, self.ball.body, (0, 0), (0, 0)) self.j1.max_force = 10 self.j1.max_bias = 0 self.j2 = pymunk.constraints.GearJoint(self.space.static_body, self.ball.body, 0, 1) self.j2.max_force = 1000 self.space.add(self.j1, self.j2) # programs self.pconfig = config self.attack = attack self.defend = defend self.o_attack = o_attack self.o_defend = o_defend
def setup(self): self.draw_buffer = arcade.ShapeElementList()
def __init__(self, text: str, 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, text_color: Union[Tuple[int, int, int], Tuple[int, int, int, int]] = arcade.color.BLACK, bold: bool = False, italic: bool = False, font_name: Union[str, Tuple[str, ...]] = ('calibri', 'arial'), font_size: float = 12, anchor_x: str = 'center', anchor_y: str = 'center', horizontal_margin: float = 5, vertical_margin: float = 5, **kwargs): for k, v in kwargs.items(): setattr(self, k, v) self._text = text self._orig_cx = center_x self._orig_cy = center_y 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.text_color = text_color self.bold = bold self.italic = italic self.font_name = font_name self.font_size = font_size self.anchor_x = anchor_x self.anchor_y = anchor_y self.horizontal_margin = horizontal_margin self.vertical_margin = vertical_margin 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) if anchor_x == 'left': self.start_x = center_x - (width / 2) + horizontal_margin elif anchor_x == 'center': self.start_x = center_x elif anchor_x == 'right': self.start_x = center_x + (width / 2) - horizontal_margin else: raise ValueError( 'ListView.start_x must be "left", "center", or "right"') if anchor_y == 'bottom': self.start_y = center_y - (height / 2) + vertical_margin elif anchor_y == 'center': self.start_y = center_y elif anchor_y == 'top': self.start_y = center_y + (height / 2) - vertical_margin else: raise ValueError( 'ListView.start_y must be "bottom", "center", or "top"') self.text_sprite = arcade.draw_text(text=text, start_x=self.start_x, start_y=self.start_y, color=text_color, font_name=font_name, font_size=font_size, bold=bold, italic=italic, anchor_x=anchor_x, anchor_y=anchor_y) arcade.text.draw_text_cache.clear()
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 make_pool(center_x, center_y, width, height): radius = 50 top_right_x = center_x + width / 2 top_right_y = center_y + height / 2 bottom_right_x = center_x + width / 2 bottom_right_y = center_y - height / 2 center_left_x = center_x - width / 2 center_left_y = center_y offset_x = center_x - width / 2 offset_y = center_y - height / 2 a = height * (1 / 5) p_width = width * (1 - a / height) p_height = height - 2 * a p_center_x = offset_x + p_width / 2 p_center_y = center_y b = height / 3 g_width = width * (1 - b / height) g_height = height - 2 * b g_center_x = offset_x + g_width / 2 g_center_y = center_y shape_list = arcade.ShapeElementList() shape = arcade.create_rectangle_filled(center_x, center_y, width, height, arcade.color.WHITE) shape_list.append(shape) shape = arcade.create_ellipse_outline(center_x, center_y, radius, radius, arcade.color.BLACK) shape_list.append(shape) shape = arcade.create_line(center_x, center_y, top_right_x, top_right_y, arcade.color.BLACK) shape_list.append(shape) shape = arcade.create_line(center_x, center_y, bottom_right_x, bottom_right_y, arcade.color.BLACK) shape_list.append(shape) shape = arcade.create_line(center_x, center_y, center_left_x, center_left_y, arcade.color.BLACK) shape_list.append(shape) shape = arcade.create_rectangle_outline(p_center_x, p_center_y, p_width, p_height, arcade.color.BLACK) shape_list.append(shape) shape = arcade.create_rectangle_outline(g_center_x, g_center_y, g_width, g_height, arcade.color.BLACK) shape_list.append(shape) shape = arcade.create_line(p_center_x, offset_y, p_center_x, offset_y + a, arcade.color.BLACK) shape_list.append(shape) shape = arcade.create_line(p_center_x, offset_y + a + p_height, p_center_x, offset_y + 2 * a + p_height, arcade.color.BLACK) shape_list.append(shape) shape = arcade.create_line(offset_x + p_width, center_y, offset_x + width, center_y, arcade.color.BLACK) shape_list.append(shape) return shape_list
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 __init__(self, width, height, title): super().__init__(width, height, title) self.shape_list = arcade.ShapeElementList() arcade.set_background_color(arcade.color.ASH_GREY) self.setup()
import arcade, random # setting variables SCREEN_WIDTH = 500 SCREEN_HEIGHT = 500 WIDTH = 1500 HEIGHT = 100 ROW_COUNT = 5 COLUMN_COUNT = 1 finish = 1500 box = arcade.ShapeElementList() box_x_position = [] box_y_position = [] grid = [] up_pressed = False down_pressed = False left_pressed = False right_pressed = False collision = False player_x = 50 player_y = 250 # setting images
arcade.start_render() arcade.draw_lrtb_rectangle_filled(10, 200, 300, 10, arcade.color.BLACK) arcade.draw_rectangle_filled(390, 150, 45, 105, arcade.color.BLUSH) arcade.draw_triangle_filled(500, 500, 400, 300, 600, 300, arcade.color.BLACK) arcade.draw_xywh_rectangle_filled(500, 200, 100, 100, arcade.color.BLACK) arcade.finish_render() arcade.quick_run(3) import arcade arcade.open_window(800, 600, "Drawing Example") arcade.set_background_color(arcade.color.WHITE) my_list = arcade.ShapeElementList() my_shape = arcade.create_ellipse_outline(50, 50, 20, 20, arcade.color.RED, 45) my_list.append(my_shape) my_shape = arcade.create_ellipse_filled(50, 50, 20, 20, arcade.color.RED, 2, 45) my_list.append(my_shape) my_shape = arcade.create_rectangle_filled(250, 50, 20, 20, arcade.color.RED, 45) my_list.append(my_shape) my_shape = arcade.create_rectangle_outline(450, 50, 20, 20, (127, 0, 27, 127), 2, 45) my_list.append(my_shape) my_shape = arcade.create_lines_with_colors( ([0, 400], [700, 400]), ((127, 0, 27, 127), arcade.color.GREEN), 2) my_list.append(my_shape) my_list.move(5, 5)
def __init__(self): self.shapes: Dict[Tuple[int, int], Shape] = {} self.shape_list = arcade.ShapeElementList() self.meta = {} self._dirty = False
def draw(self): print('draw', len(self.debug_list)) self.debug_list.draw() self.debug_list = arcade.ShapeElementList()
def make_skyline(width, skyline_height, skyline_color, gap_chance=0.70, window_chance=0.30, light_on_chance=0.5, window_color=(255, 255, 200), window_margin=3, window_gap=2, cap_chance=0.20): """ Make a skyline """ shape_list = arcade.ShapeElementList() # Add the "base" that we build the buildings on shape = arcade.create_rectangle_filled(width / 2, skyline_height / 2, width, skyline_height, skyline_color) shape_list.append(shape) building_center_x = 0 skyline_point_list = [] color_list = [] while building_center_x < width: # Is there a gap between the buildings? if random.random() < gap_chance: gap_width = random.randrange(10, 50) else: gap_width = 0 # Figure out location and size of building building_width = random.randrange(20, 70) building_height = random.randrange(40, 150) building_center_x += gap_width + (building_width / 2) building_center_y = skyline_height + (building_height / 2) x1 = building_center_x - building_width / 2 x2 = building_center_x + building_width / 2 y1 = skyline_height y2 = skyline_height + building_height skyline_point_list.append([x1, y1]) skyline_point_list.append([x1, y2]) skyline_point_list.append([x2, y2]) skyline_point_list.append([x2, y1]) for i in range(4): color_list.append( [skyline_color[0], skyline_color[1], skyline_color[2]]) if random.random() < cap_chance: x1 = building_center_x - building_width / 2 x2 = building_center_x + building_width / 2 x3 = building_center_x y1 = y2 = building_center_y + building_height / 2 y3 = y1 + building_width / 2 shape = arcade.create_polygon([[x1, y1], [x2, y2], [x3, y3]], skyline_color) shape_list.append(shape) # See if we should have some windows if random.random() < window_chance: # Yes windows! How many windows? window_rows = random.randrange(10, 15) window_columns = random.randrange(1, 7) # Based on that, how big should they be? window_height = (building_height - window_margin * 2) / window_rows window_width = (building_width - window_margin * 2 - window_gap * (window_columns - 1)) / window_columns # Find the bottom left of the building so we can start adding widows building_base_y = building_center_y - building_height / 2 building_left_x = building_center_x - building_width / 2 # Loop through each window for row in range(window_rows): for column in range(window_columns): if random.random() < light_on_chance: x1 = building_left_x + column * ( window_width + window_gap) + window_margin x2 = building_left_x + column * ( window_width + window_gap) + window_width + window_margin y1 = building_base_y + row * window_height y2 = building_base_y + row * window_height + window_height * .8 skyline_point_list.append([x1, y1]) skyline_point_list.append([x1, y2]) skyline_point_list.append([x2, y2]) skyline_point_list.append([x2, y1]) for i in range(4): color_list.append( (window_color[0], window_color[1], window_color[2])) building_center_x += (building_width / 2) shape = arcade.create_rectangles_filled_with_colors( skyline_point_list, color_list) shape_list.append(shape) return shape_list
def __init__(self, level, name): super().__init__(level, name) badwing.app.debug_layer = self self.debug_list = arcade.ShapeElementList()
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 __init__(self, client): super().__init__(width=SCREEN_WIDTH, height=SCREEN_HEIGHT, title=SCREEN_TITLE) arcade.set_background_color(arcade.color.AMAZON) self.client = client # Client used to send events to the server and to receive game state updates. self.GS = None # Current game state self.connection: bool = False # Server connection self.player_name: str = "" # Player's name self.player_id = None # Player's integer id assigned by the server # GUI Elements: self.shapes = arcade.ShapeElementList() self.center_x = int(SCREEN_WIDTH / 2) self.center_y = int(SCREEN_HEIGHT / 2) self.third_line_y = int(2 * SCREEN_HEIGHT / 3) + 50 # Gradient Background: self.generate_gradient_background() # Player Names and Locations: self.name_tabs = {} # store NameTab objects self.name_loc = { 'bot': (self.center_x, int(NAME_HEIGHT / 2)), # locations of NameTab objects 'left': (int(NAME_WIDTH / 2), self.third_line_y), 'top': (self.center_x, int(SCREEN_HEIGHT - NAME_HEIGHT / 2)), 'right': (int(SCREEN_WIDTH - NAME_WIDTH / 2), self.third_line_y) } self.player_locations = {} # KEY: int VALUE: (x, y) # Buttons: self.info_btn = TextButton(center_x=SCREEN_WIDTH - BUTTON_WIDTH / 2 - MARGIN, center_y=BUTTON_HEIGHT / 2 + MARGIN, width=BUTTON_WIDTH, height=BUTTON_HEIGHT, text='Info', action_function=self.info_btn_click, face_color=arcade.color.AIR_FORCE_BLUE) self.burn_btn = TextButton(center_x=SCREEN_WIDTH - 5 * BUTTON_WIDTH / 2 - 3 * MARGIN, center_y=BUTTON_HEIGHT / 2 + MARGIN, width=BUTTON_WIDTH, height=BUTTON_HEIGHT, text='Burn', action_function=self.burn_btn_click, face_color=arcade.color.ALMOND) self.place_btn = TextButton(center_x=SCREEN_WIDTH - 3 * BUTTON_WIDTH / 2 - 2 * MARGIN, center_y=BUTTON_HEIGHT / 2 + MARGIN, width=BUTTON_WIDTH, height=BUTTON_HEIGHT, text='Place', action_function=self.place_btn_click, face_color=arcade.color.BLOND) self.pull_btn = TextButton(center_x=BUTTON_WIDTH / 2 + MARGIN, center_y=BUTTON_HEIGHT / 2 + MARGIN, width=BUTTON_WIDTH, height=BUTTON_HEIGHT, text='PULL', action_function=self.pull_btn_click, face_color=arcade.color.ORANGE) self.next_btn = TextButton(center_x=3 * BUTTON_WIDTH / 2 + 2 * MARGIN, center_y=BUTTON_HEIGHT / 2 + MARGIN, width=BUTTON_WIDTH, height=BUTTON_HEIGHT, text='NEXT', action_function=self.next_btn_click, face_color=arcade.color.BARBIE_PINK) self.buttons = [ self.info_btn, self.burn_btn, self.place_btn, self.pull_btn, self.next_btn ] # Cards: self.cards_generated = False self.card_tab_list = CardTabList() # Card Tab arcade.Spritelist self.selected_card_tab = None # Message Pop-up: self.message_text = None # text to display as a message self.message_timer = None # time of the message popup start self.message_duration = 2.0 # seconds for the message to disappear # Some game state logic on the client side: self.action_done = False # Keep track of the top card in the discard pile and the number of cards here to keep track. self.discard_pile_card_tabs_top = None self.discard_pile_size = 0
def on_draw(self): arcade.start_render() if self.state == "GameMenu": arcade.draw_text("Snail Game", 400, 300, arcade.color.WHITE, font_size=60, anchor_x="center") arcade.draw_text("Press 'ENTER' To Start Game", 400, 250, arcade.color.WHITE, font_size=30, anchor_x="center") elif self.state == "GameOn": self.shape_list = arcade.ShapeElementList() # updating scores on screen ouput1 = f"Score: {self.score_1}" ouput2 = f"Score: {self.score_2}" # drawing scores for both players arcade.draw_text(ouput1, 630, 160, arcade.color.WHITE, font_size=26) arcade.draw_text(ouput2, 630, 390, arcade.color.WHITE, font_size=26) # drawing for Player 1 arcade.draw_text("Player 1 ", 640, 540, arcade.color.WHITE, font_size=30) arcade.draw_lrwh_rectangle_textured(640, 440, 100, 80, display) arcade.draw_rectangle_outline(700, 490, 178, 200, arcade.color.GREEN, 4) # drawing for Player 2 arcade.draw_rectangle_outline(700, 260, 178, 210, arcade.color.GREEN, 4) arcade.draw_text("Player 2", 640, 310, arcade.color.WHITE, font_size=30) arcade.draw_lrwh_rectangle_textured(640, 200, 100, 100, circle) # drawing turn arcade.draw_rectangle_outline(700, 70, 178, 115, arcade.color.GREEN, 4) arcade.draw_text("TURN", 655, 90, arcade.color.BABY_BLUE, font_size=25) #displaying turn of player if self.turn == "Human": arcade.draw_text("Player '2'", 645, 40, arcade.color.RASPBERRY, font_size=24) elif self.turn == "bot": arcade.draw_text("Player '1'", 645, 40, arcade.color.RAJAH, font_size=24) #drawing lines for i in range(0, 600, 60): arcade.draw_line(0, i, 600, i, arcade.color.WHITE, 2) for i in range(0, 660, 60): arcade.draw_line(i, 0, i, 600, arcade.color.WHITE, 2) #checking where to have snails and their splashes x = 0 y = 540 for i in range(10): for j in range(10): if self.board[i][j] == 1: arcade.draw_lrwh_rectangle_textured( x, y, 60, 60, splash1) elif self.board[i][j] == 2: arcade.draw_lrwh_rectangle_textured( x, y, 60, 60, splash2) elif self.board[i][j] == 10: arcade.draw_lrwh_rectangle_textured( x, y, 60, 60, cross) elif self.board[i][j] == 20: arcade.draw_lrwh_rectangle_textured( x, y, 60, 60, circle) x = x+60 x = 0 y = y-60 #win condition if self.score_1 > 50 or self.score_2 > 50: self.state="win" #changing game state elif self.state == "win": if self.score_1 > self.score_2 : arcade.draw_text("Player '2' WON", 400, 300, arcade.color.RAJAH, font_size=40, anchor_x="center") elif self.score_1 < self.score_2 : arcade.draw_text("Player '1' WON", 400, 300, arcade.color.RAJAH, font_size=40, anchor_x="center") else: arcade.draw_text("DRAW", 400, 300, arcade.color.RAJAH, font_size=40, anchor_x="center")
left_pressed = False right_pressed = False up_pressed = False down_pressed = False collision = False shoot = False player_x = 250 player_y = 100 texture_spaceship = arcade.load_texture("spaceship2 (1).jpg") texture_background = arcade.load_texture("TWGty9.jpg") texture_gameover = arcade.load_texture("background.png") texture_ALien = arcade.load_texture("ALIEN2.png") ALIEN = arcade.ShapeElementList() texture_ALien_x_positions = [] texture_ALien_y_positions = [] for _ in range(20): x = random.randrange(0, WIDTH) y = random.randrange(HEIGHT, HEIGHT * 2) texture_ALien_x_positions.append(x) texture_ALien_y_positions.append(y) def setup(): arcade.open_window(WIDTH, HEIGHT, "My Arcade Game") arcade.draw_texture_rectangle(320, 240, 640, 480, texture_background, 0)
def on_draw(self): """ Render the screen. """ # This command has to happen before we start drawing arcade.start_render() self._frames += 1 # arcade.draw_text("Test", 50, 50) if self.box.field is not None and self.box.field.equation != self.box.field.nofield: self.draw_field() if self.left_mouse_down: arcade.draw_line(self.mouse_x, self.mouse_y, self.mouse_dx, self.mouse_dy, arcade.color.WHITE, 1) # draw avg impuls vector start = self.box.box_sizes / 2 avg_impuls = self.box.avg_momentum() end = start + avg_impuls arcade.draw_line(*start[:2], *end[:2], color=arcade.color.WHITE, line_width=1) self.arrow_list = None self.arrow_list = arcade.ShapeElementList() # if self.box.trail > 0: self.trail_list = None self.trail_list = arcade.ShapeElementList() while self.box.delete_particles: ball = self.box.delete_particles.pop() ball.object.kill() while self.box.merged_particles: ball = self.box.merged_particles.pop() ball.object.kill() # +D_SPRITE_RADIUS ball.object = arcade.SpriteCircle( int(ball.radius) + D_SPRITE_RADIUS, ball.color, True) self.ball_list.append(ball.object) for _, ball in enumerate(self.box.particles): #arcade.draw_circle_filled(ball.position[0], ball.position[1], ball.radius, ball.color) end = ball.position + ball.speed # arcade.draw_line(ball.position[0], ball.position[1], end[0], end[1], arcade.color.GRAY_ASPARAGUS, 2) arrow = arcade.create_line(ball.position[0], ball.position[1], end[0], end[1], arcade.color.GRAY_ASPARAGUS, 2) self.arrow_list.append(arrow) if ball.positions: positions = [(p[0], p[1]) for p in ball.positions] trail = arcade.create_line_strip(positions, arcade.color.GRAY, 1) self.trail_list.append(trail) output = "" if ball.charge < 0: output = "-" elif ball.charge > 0: output = "+" if ball.charge != 0 and len( output) > 0 and self.box.interaction != 0: arcade.draw_text(output, ball.position[0] + 5, ball.position[1] - 10, arcade.color.WHITE, 20, font_name="Calibri Bold") # output = str(i) # arcade.draw_text(output, ball.position[0]-0, ball.position[1]+0, arcade.color.WHITE, 8, font_name="Calibri Bold") ball.object.center_x = ball.position[0] ball.object.center_y = ball.position[1] if self.box.dimensions > DSIZE: ball.object.scale = ball.position[DSIZE] / self.box.box_sizes[ DSIZE] if self.box.dimensions > DALPHA: ball.object.alpha = 255 * (ball.position[DALPHA] / self.box.box_sizes[DALPHA]) % 255 # draw springs for _, spring in enumerate(self.box.springs): v = MAXCOLOR + 1 / ((spring.dlength() / 10000) - INVMAXCOLOR) color = self.getcolor(v, 0, 255) if self.box.dimensions > DALPHA: pos = (spring.p1.position[DALPHA] + spring.p2.position[DALPHA]) / 2 alpha = 255 * (pos / self.box.box_sizes[DALPHA]) % 255 color.append(alpha) arcade.draw_line(*spring.p1.position[:2], *spring.p2.position[:2], color=color, line_width=1) # dpos = self.box.displacement(spring.p1.position, spring.p2.position) # # start = spring.p1.position # # end = spring.p1.position + dpos # start = self.box.center # end = self.box.center + dpos # arcade.draw_line(*start[:2], *end[:2], color=(255,0,0), line_width=2) # dpos = self.box._displacement(spring.p1.position, spring.p2.position) # # start = spring.p1.position # # end = spring.p1.position + dpos # start = self.box.center # end = self.box.center + dpos # arcade.draw_line(*start[:2], *end[:2], color=(0,255,0), line_width=2) # draw rods for _, rod in enumerate(self.box.rods): arcade.draw_line(*rod.p1.position[:2], *rod.p2.position[:2], color=arcade.color.GRAY, line_width=2) self.arrow_list.draw() self.ball_list.draw() self.trail_list.draw() if self._draw_planes: self.plane_list.draw() self.hole_list.draw() #self.sprite_list.draw_hit_boxes((255,255,255), 2) if self.text: # Put the text on the screen. charge = sum(p.charge for p in self.box.particles) output = f"Ticks: {self.box.ticks}, Dimensions: {self.box.dimensions}, Balls: {len(self.box.particles)}, Charge: {charge}" arcade.draw_text(output, 10, 20, arcade.color.WHITE, 14) if self._frames < TEXT_REFRESH or self._frames % TEXT_REFRESH == 0: KE = self.box.energy["KE"] self._output["KE"] = f"Kinetic energy: {KE:.2f}" PE = self.box.energy["PE"] self._output["PE"] = f"Potential Energy: {PE:.2f}" SE = self.box.energy["SE"] self._output["SE"] = f"Spring Energy: {SE:.2f}" TE = KE + PE + SE self._output["TE"] = f"Total Energy: {TE:.2f}" try: arcade.draw_text(self._output["KE"], 10, 50, arcade.color.WHITE, 14) arcade.draw_text(self._output["PE"], 10, 80, arcade.color.WHITE, 14) arcade.draw_text(self._output["SE"], 10, 120, arcade.color.WHITE, 14) arcade.draw_text(self._output["TE"], 10, 150, arcade.color.WHITE, 14) # arcade.draw_text(self._output["R"], 10, 180, arcade.color.WHITE, 14) except KeyError: pass # output = "Avg Impuls: {}".format(self.box.avg_momentum()) # arcade.draw_text(output, 10, 80, arcade.color.WHITE, 14) # P = self.box.pressure() # output = "pressure: {:}".format(P) # arcade.draw_text(output, 10, 110, arcade.color.WHITE, 14) # PV = self.box.pressure() * self.box.volume() # output = "PV: {:.2f}".format(PV) # arcade.draw_text(output, 10, 150, arcade.color.WHITE, 14) # try: # output = "PV/nE: {}".format(PV/(E*len(self.box.particles))) # arcade.draw_text(output, 10, 180, arcade.color.WHITE, 14) # except: # raise # output = "Avg position: {}".format(self.box.avg_position()) # arcade.draw_text(output, 10, 110, arcade.color.WHITE, 14) #play sound if self.bounced and not self.quiet: arcade.play_sound(self.sound, 0.1)
def update_grid_cell_list(self): self.grid_cell_list = arcade.ShapeElementList() for grid_pos, cell in self.grid_map.items(): current_cell = cell.create_cell_poly() self.grid_cell_list.append(current_cell)
def setup(self): self.map_width = len(self.world_map) self.map_height = 0 for row in self.world_map: self.map_height = max(self.map_height, len(row)) ''' self.world_map = np.array([ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 8, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0] ]) ''' '''self.point_list = [] for y in range(len(self.world_map)): for x in range(len(self.world_map[y])): if self.world_map[x][y] != 0: point = [x, y] while True: try: self.point_list[self.world_map[x][y]].append(point) break except IndexError: self.point_list.append([])''' # initialize and declare position variables self.posX = 22 self.posY = 12 # initialize and declare the look-direction variables self.dirX = -1.0 self.dirY = 0.0 # initialize and declare the self.planeX = 0 self.planeY = 1 self.drawStart = [] self.drawEnd = [] # initialize and declare movement boolean flags to false self.moveForward = False self.moveBackward = False self.strafeLeft = False self.strafeRight = False self.rotateLeft = False self.rotateRight = False # initialize and declare the game time to 0 self.time = 0 # start with the default target FPS self.target_fps = TARGET_FPS # initialize an empty ShapeElementList to store the line objects in self.shape_list = arcade.ShapeElementList() self.color_list = [ arcade.color.RED, arcade.color.GREEN, arcade.color.BLUE, arcade.color.WHITE, arcade.color.YELLOW, arcade.color.PURPLE, arcade.color.ORANGE, arcade.color.PINK ] self.dark_color_list = [ arcade.color.DARK_RED, arcade.color.DARK_GREEN, arcade.color.DARK_BLUE, arcade.color.GRAY, arcade.color.DARK_YELLOW, arcade.color.DARK_PASTEL_PURPLE, arcade.color.DARK_ORANGE, arcade.color.DARK_PINK ] self.render_resolution = RENDER_RESOLUTION self.texture = 'bricks.png' self.alt_texture = 'darker_bricks.png' self.xy_square = arcade.load_texture('bricks.png') self.set_exclusive_mouse(exclusive=True) self.set_exclusive_keyboard(exclusive=True)
def on_mouse_press(self, x, y, button, modifiers): # calculates the square on the board you've pressed square_location = [ int((x - 132.5) // 75), int(8 - ((y - 62.5) // 75)) ] #[board_x, board_y] white_small_board = [ int((x - 937.5) // 75), int(2 - ((y - 87.5) // 75)) ] black_small_board = [ int((x - 937.5) // 75), int(2 - ((y - 487.7) // 75)) ] if not self.promotion_prompt: #if there's no prompt #if clicking on the main board if 0 <= square_location[0] <= 8 and 0 <= square_location[1] <= 8: #if there is a piece on tile if self.board_pieces_location[square_location[1]][ square_location[0]] != 0: #if you already have a piece selected if self.pieces_selected: if square_location in self.possible_moves[0]: #enemy piece removed from board and put into your dictionary taken_piece = self.board_pieces_location[ square_location[1]][square_location[0]] if taken_piece.promoted: self.all_pieces.remove(taken_piece.sprite) taken_piece = taken_piece.demote() self.all_pieces.append(taken_piece.sprite) #enemy piece put outside the board taken_piece.taken(self.white_captured_location, self.black_captured_location) #adding the enemy piece to your captives dictionary if self.turn == "white": self.white_captives[ taken_piece.piece_type].append(taken_piece) else: self.black_captives[ taken_piece.piece_type].append(taken_piece) #reset the tile self.board_pieces_location[square_location[1]][ square_location[0]] = 0 #placing the piece self.capture_done = True self.place_and_check_promotion(square_location) #if you don't have a piece selected else: #checks if you're using the right pieces self.select_piece(square_location) #if tile is empty else: #if you have a piece selected if self.pieces_selected and square_location in self.possible_moves[ 0]: if self.selected_piece.captured: self.selected_piece.just_placed = True self.selected_piece.captured = False if self.turn == "white": self.white_captives[ self.selected_piece.piece_type].pop() else: self.black_captives[ self.selected_piece.piece_type].pop() self.place_and_check_promotion(square_location) self.selected_piece.just_placed = False #clicking on the smaller board else: if not self.pieces_selected: if self.turn == "white": if 0 <= white_small_board[ 0] <= 2 and 0 <= white_small_board[1] <= 2: if self.white_captured_location[white_small_board[ 1]][white_small_board[0]] != 0: self.selected_piece = self.white_captured_location[ white_small_board[1]][ white_small_board[0]].pop() if len(self.white_captured_location[ white_small_board[1]]) == 0: self.white_captured_location[ white_small_board[1]][ white_small_board[0]] = 0 self.possible_moves = self.selected_piece.highlight_moves( self.highlight, self.board_pieces_location, self.covered_squares, self.king_checked, self.checking_pieces) self.prev_position[1] = white_small_board self.pieces_selected = True else: if 0 <= black_small_board[ 0] <= 2 and 0 <= black_small_board[1] <= 2: if self.black_captured_location[black_small_board[ 1]][black_small_board[0]] != 0: self.selected_piece = self.black_captured_location[ black_small_board[1]][ black_small_board[0]].pop() if len(self.black_captured_location[ black_small_board[1]]) == 0: self.black_captured_location[ black_small_board[1]][ black_small_board[0]] = 0 self.possible_moves = self.selected_piece.highlight_moves( self.highlight, self.board_pieces_location, self.covered_squares, self.king_checked, self.checking_pieces) self.prev_position[2] = black_small_board self.pieces_selected = True #if you have a piece selected else: if self.turn == "white": if white_small_board == self.prev_position[1]: self.white_captured_location[white_small_board[1]][ white_small_board[0]].append( self.selected_piece) self.selected_piece.sprite.set_position( self.white_coordinates[white_small_board[1]][ white_small_board[0]][0], self.white_coordinates[white_small_board[1]][ white_small_board[0]][1]) self.selected_piece.pos = self.white_coordinates[ white_small_board[1]][white_small_board[0]] self.pieces_selected = False #if you're putting it back into place, don't switch turns if white_small_board != self.prev_position[1]: self.switch_turns() self.highlight = arcade.ShapeElementList() else: if black_small_board == self.prev_position[2]: self.black_captured_location[black_small_board[1]][ black_small_board[0]].append( self.selected_piece) self.selected_piece.sprite.set_position( self.black_coordinates[black_small_board[1]][ black_small_board[0]][0], self.black_coordinates[black_small_board[1]][ black_small_board[0]][1]) self.selected_piece.pos = self.black_coordinates[ black_small_board[1]][black_small_board[0]] self.pieces_selected = False #if you're putting it back into place, don't switch turns if black_small_board != self.prev_position[2]: self.switch_turns() self.highlight = arcade.ShapeElementList() else: #if there is a prompt self.checked_for_promotion = True if 385 <= x <= 455 and 345 <= y <= 375: #yes is picked #promote self.promote() self.highlight = arcade.ShapeElementList() self.promotion_prompt = False self.switch_turns() elif 485 <= x <= 555 and 345 <= y <= 375: #no is picked self.place(self.prev_position[0]) self.highlight = arcade.ShapeElementList() self.promotion_prompt = False self.switch_turns()
""" 1. Use a loop to generate a lot of rain. """ import random import arcade WIDTH = 640 HEIGHT = 480 rain = arcade.ShapeElementList() # first set up empty lists rain_x_positions = [] rain_y_positions = [] tunnel_x_positions = [] tunnel_y_positions = [] for _ in range(0,100,30): x = random.randrange(WIDTH + 50) y = random.randrange(-50,HEIGHT) tunnel_x_positions.append(x) tunnel_y_positions.append(y) # loop 100 times for _ in range(0,100,30): # generate random x and y values x = random.randrange(WIDTH+50) y = random.randrange(HEIGHT, HEIGHT+50)
def __create_shapes__(self): self.all_shapes = arcade.ShapeElementList() bg_rect = arcade.create_rectangle_filled(0, 0, 150, 150, arcade.color.GREEN) self.all_shapes.append(bg_rect)