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))