def create_grid(self, step): self.grid_step = step self.grid_box = sf.RectangleShape((1000, 700)) self.grid_box.position = self.GRID_POS self.grid_box.outline_color = sf.Color(150, 150, 150) self.grid_box.outline_thickness = 2 self.horizontal_lines_nb = int(self.grid_box.size.y // step) self.horizontal_lines = sf.VertexArray(sf.PrimitiveType.LINES, 2 * self.horizontal_lines_nb) for y, i in zip(range(self.horizontal_lines_nb), range(0, 2 * self.horizontal_lines_nb, 2)): self.horizontal_lines[i].position = self.GRID_POS + (0, step * y) self.horizontal_lines[i + 1].position = self.GRID_POS + (self.grid_box.size.x, step * y) self.horizontal_lines[i].color = sf.Color(180, 180, 180) self.horizontal_lines[i + 1].color = sf.Color(180, 180, 180) self.vertical_lines_nb = int(self.grid_box.size.x // step) self.vertical_lines = sf.VertexArray(sf.PrimitiveType.LINES, 2 * self.vertical_lines_nb) for x, i in zip(range(self.vertical_lines_nb), range(0, 2 * self.vertical_lines_nb, 2)): self.vertical_lines[i].position = self.GRID_POS + (step * x, 0) self.vertical_lines[i + 1].position = self.GRID_POS + (step * x, self.grid_box.size.y) self.vertical_lines[i].color = sf.Color(180, 180, 180) self.vertical_lines[i + 1].color = sf.Color(180, 180, 180) self.grid = [] for j in range(self.horizontal_lines_nb + 1): self.grid.append([]) for i in range(self.vertical_lines_nb + 1): self.grid[j].append(0)
def __init__(self, step_number=1000, connect=True): self._connect = connect self._basic_bezier_points = [] self._draw_bezier_nodes = [] self._draw_bezier_points = sf.VertexArray(sf.PrimitiveType.POINTS) self._state = self.POINT_COLLECTING self._step_number = step_number self._basic_point_connections = sf.VertexArray(sf.PrimitiveType.LINES_STRIP)
def __init__(self, window): self.window = window sf.Drawable.__init__(self) self.vertArray = sf.VertexArray(sf.PrimitiveType.LINES, 8) for i in range(4): self.vertArray[2 * i].color = sf.Color.RED self.vertArray[2 * i + 1].color = sf.Color.TRANSPARENT
def __init__(self, *args: Union[Tuple[float, float], sf.Vector2]): super().__init__() self._points = [] self._position = sf.Vector2(0, 0) self._vertexarray = sf.VertexArray(sf.PrimitiveType.LINES_STRIP) self._color = sf.Color.WHITE for arg in args: self._points.append(to_Vector2(arg)) self.update()
def draw(self, target, states): target.draw(self.sprite) if debug_mode: if self.usable: lines = sf.VertexArray( len(self.x_usable) - 1, sf.PrimitiveType.POINTS) #lines = [] for x, y in zip(self.x_usable, self.y_usable): lines.append(sf.Vertex([x, y], sf.Color.RED)) window.draw(lines)
def _calc_triangle(self, level, top, left, right): if level == 0: triangle = sf.VertexArray(sf.PrimitiveType.LINES_STRIP) triangle.append(sf.Vertex(top, sf.Color.BLACK)) triangle.append(sf.Vertex(left, sf.Color.BLACK)) triangle.append(sf.Vertex(right, sf.Color.BLACK)) triangle.append(sf.Vertex(top, sf.Color.BLACK)) self._triangles.append(triangle) else: left_mid = self._mid_point(top, left) right_mid = self._mid_point(top, right) top_mid = self._mid_point(left, right) self._calc_triangle(level - 1, top, left_mid, right_mid) self._calc_triangle(level - 1, left_mid, left, top_mid) self._calc_triangle(level - 1, right_mid, top_mid, right)
def __init__(self, name, texture, layer_width, layer_height, tile_width, tile_height, properties): super().__init__() self.name = name self._tiles = [[None for x in range(layer_width)] for y in range(layer_height)] self._texture = texture self._width = layer_width self._height = layer_height self._tile_width = tile_width self._tile_height = tile_height self._tiles_per_row = self._texture.width / self._tile_width self._properties = properties self._collision = properties.get("collision", False) self._varray = sf.VertexArray( sf.PrimitiveType.QUADS, layer_width*layer_height*4 )
def __init__(self, tiles): super().__init__() self.m_tileset = sf.Texture.from_file("game/assets/spritesheet.png") self.m_vertices = sf.VertexArray(sf.PrimitiveType.QUADS, tiles.size * 4) for i in range(tiles.shape[1]): for j in range(tiles.shape[0]): # get the current tile number id = tiles[j, i] # find its position in the tileset texture tu = int(id % (self.m_tileset.width / pz.TILE_SIZE)) tv = int(id / (self.m_tileset.width / pz.TILE_SIZE)) # get a pointer to the current tile's quad index = (i + j * tiles.shape[1]) * 4 # define its 4 corners self.m_vertices[index + 0].position = (i * pz.TILE_SIZE, j * pz.TILE_SIZE) self.m_vertices[index + 1].position = ((i + 1) * pz.TILE_SIZE, j * pz.TILE_SIZE) self.m_vertices[index + 2].position = ((i + 1) * pz.TILE_SIZE, (j + 1) * pz.TILE_SIZE) self.m_vertices[index + 3].position = (i * pz.TILE_SIZE, (j + 1) * pz.TILE_SIZE) # define its 4 texture coordinates self.m_vertices[index + 0].tex_coords = (tu * pz.TILE_SIZE, tv * pz.TILE_SIZE) self.m_vertices[index + 1].tex_coords = ((tu + 1) * pz.TILE_SIZE, tv * pz.TILE_SIZE) self.m_vertices[index + 2].tex_coords = ((tu + 1) * pz.TILE_SIZE, (tv + 1) * pz.TILE_SIZE) self.m_vertices[index + 3].tex_coords = (tu * pz.TILE_SIZE, (tv + 1) * pz.TILE_SIZE)
def __init__(self, n): super(KochSnowflake, self).__init__() self._koch = sf.VertexArray(sf.PrimitiveType.LINES_STRIP) angles = [math.radians(60 * x) for x in range(6)] sines = [math.sin(x) for x in angles] cosin = [math.cos(x) for x in angles] def L(angle, *_): return (angle + 1) % 6 def R(angle, *_): return (angle + 4) % 6 def F(angle, coords, jump): coords.append((coords[-1][0] + jump * cosin[angle], coords[-1][1] + jump * sines[angle])) return angle decode = dict(L=L, R=R, F=F) def grow(steps, length=500, startPos=(80, 480)): pathcodes = "FRFRF" for i in xrange(steps): pathcodes = pathcodes.replace("F", "FLFRFLF") jump = float(length) / (3**steps) coords = [startPos] angle = 0 for move in pathcodes: angle = decode[move](angle, coords, jump) return coords showflake = grow(n) for coord in showflake: self._koch.append( sf.Vertex((int(coord[0]), int(coord[1])), sf.Color.BLACK))
def __init__(self, grid_step): self.grid_step = grid_step self.directions = 4 # creating a grid self.create_grid(self.grid_step) self.create_grid_elements() self.walls_list = [] self.deleted_walls = False # path line self.path = sf.VertexArray(sf.PrimitiveType.LINES_STRIP, 0) # path outline, just to make the line look thicker self.path_outline1 = sf.VertexArray(sf.PrimitiveType.LINES_STRIP, 0) self.path_outline2 = sf.VertexArray(sf.PrimitiveType.LINES_STRIP, 0) # GUI self.search_button = self.new_button( 'Search', (self.GRID_POS.x + self.grid_box.size.x + 75, self.GRID_POS.y + 25), sf.Color(50, 200, 50) ) self.reset_button = self.new_button( 'Reset', (self.GRID_POS.x + self.grid_box.size.x + 75, self.GRID_POS.y + 125), sf.Color(200, 50, 50) ) self.dezoom_button = self.new_button( ' -', (self.GRID_POS.x + self.grid_box.size.x + 72, self.GRID_POS.y + 225), sf.Color(160, 160, 160), size="small" ) self.zoom_button = self.new_button( ' +', (self.GRID_POS.x + self.grid_box.size.x + 72 + 105, self.GRID_POS.y + 225), sf.Color(160, 160, 160), size="small" ) self.directions_text = sf.Text('Directions :') self.directions_text.font = self.FONT self.directions_text.color = sf.Color.BLACK self.directions_text.character_size = 25 self.directions_text.origin = (0, -self.directions_text.character_size/2) self.directions_text.position = (self.GRID_POS.x + self.grid_box.size.x + 72, self.GRID_POS.y + 375) self.direction4_button = self.new_button( ' 4', (self.GRID_POS.x + self.grid_box.size.x + 72, self.GRID_POS.y + 425), sf.Color(160, 160, 160), size="small" ) self.direction8_button = self.new_button( ' 8', (self.GRID_POS.x + self.grid_box.size.x + 72 + 105, self.GRID_POS.y + 425), sf.Color(160, 160, 160), size="small" ) self.fps_text = sf.Text('fps:') self.fps_text.font = self.FONT self.fps_text.color = sf.Color.BLACK self.fps_text.character_size = 20 self.fps_text.origin = (0, -self.fps_text.character_size / 2) self.fps_text.position = (0, 0) self.fps_history = [] # used to compute average FPS self.message = sf.Text('') self.message.font = self.FONT self.message.color = sf.Color.BLACK self.message.character_size = 25 self.message.origin = (0, -self.message.character_size / 2) self.message.position = (350, 10) self.author = sf.Text('Modar NASSER (c) 2020') self.author.font = self.FONT self.author.color = sf.Color.BLACK self.author.character_size = 20 self.author.origin = (self.author.global_bounds.width, self.author.character_size/2) self.fps_clock = sf.Clock() # used to get real fps self.astar_clock = sf.Clock() # used to get how much time the agorithm takes self.current_state = self.START_POS_STATE self.window = sf.RenderWindow(sf.VideoMode(1422, 800), "A* algorithm simulator") self.window.framerate_limit = 100 self.icon = sf.Image.from_file(pyInstallerPath('assets/icon64.png')) self.window.set_icon(64, 64, sf.Image.from_file(pyInstallerPath('assets/icon64.png')).pixels.tobytes()) self.author.position = (self.window.size.x-5, self.window.size.y-5)
def __init__(self): Effect.__init__(self, 'storm + blink') self.points = sf.VertexArray()
def generate_texture(self, width: int, height: int) -> sf.Texture: w = width // self._tile_size.x * self._tile_size.x h = height // self._tile_size.y * self._tile_size.y if (w, h) in self._render_textures: return self._render_textures[(w, h)].texture self.corners['top_left'].position = (0, 0) self.corners['top_right'].position = (w - self._tile_size.x, 0) self.corners['bot_left'].position = (0, h - self._tile_size.y) self.corners['bot_right'].position = (w - self._tile_size.x, h - self._tile_size.y) horizontal_size = ( (w - 2 * self._tile_size.x) // self._tile_size.x) * 4 vertical_size = ((h - 2 * self._tile_size.y) // self._tile_size.y) * 4 fill_size = (((w - 2 * self._tile_size.x) // self._tile_size.x) * (h - 2 * self._tile_size.y) // self._tile_size.y) * 4 sizes = { 'top': horizontal_size, 'right': vertical_size, 'bot': horizontal_size, 'left': vertical_size, 'center': fill_size } offset = { 'top': sf.Vector2(self._tile_size.x, 0), 'right': sf.Vector2(w - self._tile_size.x, self._tile_size.y), 'bot': sf.Vector2(self._tile_size.x, h - self._tile_size.y), 'left': sf.Vector2(0, self._tile_size.y), 'center': self._tile_size, } increment = { 'top': sf.Vector2(self._tile_size.x / 4, 0), 'right': sf.Vector2(0, self._tile_size.y / 4), 'bot': sf.Vector2(self._tile_size.x / 4, 0), 'left': sf.Vector2(0, self._tile_size.y / 4), 'center': sf.Vector2(self._tile_size.x / 4, self._tile_size.y / 4) } vertices = [] for side in self.tex_coords: vert = sf.VertexArray(sf.PrimitiveType.QUADS) vert.resize(sizes[side]) for i in range(0, sizes[side], 4): for j in range(4): vert[i + j].tex_coords = self.tex_coords[side][j] if side == 'center': center_offset = sf.Vector2( (increment[side].x * i) % (w - 2 * self._tile_size.x), (increment[side].y * i) // (w - 2 * self._tile_size.x) * self._tile_size.y) vert[i + j].position = self.vertex_pos[j] + offset[ side] + center_offset else: vert[i + j].position = self.vertex_pos[j] + offset[ side] + increment[side] * i vertices.append(vert) render_texture = sf.RenderTexture(w, h) render_texture.clear(sf.Color.TRANSPARENT) render_texture.draw(self.corners['top_left']) render_texture.draw(self.corners['top_right']) render_texture.draw(self.corners['bot_left']) render_texture.draw(self.corners['bot_right']) for vert in vertices: render_texture.draw(vert, sf.RenderStates(texture=self._texture)) render_texture.display() self._render_textures[(w, h)] = render_texture return render_texture.texture
def __init__(self, tilelayer, x: int, y: int, gid: int): super().__init__() self._map = tilelayer.map self._tileset: Optional[MapTileset] = None self._gid = gid self._id = gid self._transformations = TileTransformation.get_transformations( self._gid) for tr in self._transformations: self._gid -= tr for tileset in self._map.tilesets: if tileset.first_gid <= self._gid <= tileset.last_gid: self._id = self._gid - tileset.first_gid self._tileset = tileset break self._x = x * self._tileset.tile_width self._y = y * self._tileset.tile_height self._tx = (self._id % self._tileset.columns) * self._tileset.tile_width self._ty = (self._id // self._tileset.columns) * self._tileset.tile_height self._sprite: sf.VertexArray = sf.VertexArray(sf.PrimitiveType.QUADS) self._sprite.resize(4) self._sprite[0].position = self.position self._sprite[1].position = self.position + sf.Vector2( self._tileset.tile_width, 0) self._sprite[2].position = self.position + sf.Vector2( self._tileset.tile_width, self._tileset.tile_height) self._sprite[3].position = self.position + sf.Vector2( 0, self._tileset.tile_height) tex_coords = self._calculate_tex_coo(self._tx, self._ty) self._sprite[0].tex_coords = tex_coords[0] self._sprite[1].tex_coords = tex_coords[1] self._sprite[2].tex_coords = tex_coords[2] self._sprite[3].tex_coords = tex_coords[3] self._frames = [] self._anim_data = [] self._anim_index = 0 if self.id in self._tileset.animations: self._anim_data = self.tileset.animations[self.id] for frame in self._anim_data: vert = sf.VertexArray(sf.PrimitiveType.QUADS) vert.resize(4) tx = (frame['id'] % self._tileset.columns) * self._tileset.tile_width ty = (frame['id'] // self._tileset.columns) * self._tileset.tile_height vert[0].position = self.position vert[1].position = self.position + sf.Vector2( self._tileset.tile_width, 0) vert[2].position = self.position + sf.Vector2( self._tileset.tile_width, self._tileset.tile_height) vert[3].position = self.position + sf.Vector2( 0, self._tileset.tile_height) tex_coords = self._calculate_tex_coo(tx, ty) vert[0].tex_coords = tex_coords[0] vert[1].tex_coords = tex_coords[1] vert[2].tex_coords = tex_coords[2] vert[3].tex_coords = tex_coords[3] self._frames.append(vert) self._clock = sf.Clock()
def __init__(self, size, atlas): sf.Drawable.__init__(self) self.vertices = sf.VertexArray() self.transform = sf.Transform() self.size = size self.atlas = atlas
def _clear_bezier_points(self): self._draw_bezier_points = sf.VertexArray(sf.PrimitiveType.POINTS)
def _clear_basic_points(self): self._basic_bezier_points = [] self._draw_bezier_nodes = [] self._basic_point_connections = sf.VertexArray(sf.PrimitiveType.LINES_STRIP)
def parse(self): self._render_texture.clear(sf.Color.TRANSPARENT) pts_vertexarray = sf.VertexArray(sf.PrimitiveType.POINTS) rect_vertexarray = sf.VertexArray(sf.PrimitiveType.QUADS) for object_elmnt in self.xml.findall('object'): x = float(object_elmnt.get('x')) y = float(object_elmnt.get('y')) width = float( object_elmnt.get('width')) if object_elmnt.get('width') else 0 height = float(object_elmnt.get('height')) if object_elmnt.get( 'height') else 0 if not list(object_elmnt): self.rectangles.append(Rect((x, y), (width, height))) else: child = list(object_elmnt)[0] if child.tag == "ellipse": ellipse = EllipseShape((width / 2, height / 2)) ellipse.position = (x, y) ellipse.fill_color = self.color self._render_texture.draw(ellipse) elif child.tag == "point": self.points.append(sf.Vector2(x, y)) elif child.tag == "polyline": points = [] for strpt in child.get('points').split(): points.append( sf.Vector2(float(strpt.split(',')[0]), float(strpt.split(',')[1]))) line = LineShape(*points) line.position = (x, y) line.color = self.color self._render_texture.draw(line) elif child.tag == "polygon": points = [] for strpt in child.get('points').split(): points.append( sf.Vector2(float(strpt.split(',')[0]), float(strpt.split(',')[1]))) polygone = sf.ConvexShape(len(points)) for i, p in enumerate(points): polygone.set_point(i, p) polygone.position = (x, y) polygone.fill_color = self.color self.polygons.append(polygone) self._render_texture.draw(polygone) rect_vertexarray.resize(4 * len(self.rectangles)) for index in range(0, len(self.rectangles) * 4, 4): rect_vertexarray[index + 0].position = self.rectangles[index // 4].topleft rect_vertexarray[index + 1].position = self.rectangles[index // 4].topright rect_vertexarray[index + 2].position = self.rectangles[index // 4].bottomright rect_vertexarray[index + 3].position = self.rectangles[index // 4].bottomleft for i in range(4): rect_vertexarray[index + i].color = self.color pts_vertexarray.resize(len(self.points)) for index in range(len(self.points)): pts_vertexarray[index].position = self.points[index] pts_vertexarray[index].color = self.color self._render_texture.draw(rect_vertexarray) self._render_texture.draw(pts_vertexarray) self._render_texture.display() self.sprite.texture = self._render_texture.texture
def __init__(self, a, b, color): super(Line, self).__init__() self._rep = sf.VertexArray(sf.PrimitiveType.LINES_STRIP) self._rep.append(sf.Vertex(a, color)) self._rep.append(sf.Vertex(b, color))