def nuklearSfmlDrawRectFilled(self,cmd,window):
p=pynk.ffi.cast("struct nk_command_rect_filled*",cmd)
rectangle=sf.RectangleShape()
rectangle.fill_color=sf.Color(p.color.r, p.color.g, p.color.b, p.color.a)
rectangle.size=sf.Vector2(p.w, p.h)
rectangle.position=sf.Vector2(p.x, p.y)
window.draw(rectangle)
def calculateCorners(self):
self.theta = -self.rect.rotation * math.pi / 180.0
self.top_left_corner_x = self.rect.position.x - self.rect.size.x / 2.0 * math.cos(
self.theta) - self.rect.size.y / 2.0 * math.sin(self.theta)
self.top_left_corner_y = self.rect.position.y + self.rect.size.x / 2.0 * math.sin(
self.theta) - self.rect.size.y / 2.0 * math.cos(self.theta)
self.top_right_corner_x = self.rect.position.x + self.rect.size.x / 2.0 * math.cos(
self.theta) - self.rect.size.y / 2.0 * math.sin(self.theta)
self.top_right_corner_y = self.rect.position.y - self.rect.size.x / 2.0 * math.sin(
self.theta) - self.rect.size.y / 2.0 * math.cos(self.theta)
self.bot_right_corner_x = self.rect.position.x + self.rect.size.x / 2.0 * math.cos(
self.theta) + self.rect.size.y / 2.0 * math.sin(self.theta)
self.bot_right_corner_y = self.rect.position.y - self.rect.size.x / 2.0 * math.sin(
self.theta) + self.rect.size.y / 2.0 * math.cos(self.theta)
#self.bot_left_corner_x = self.rect.position.x - self.rect.size.x / 2.0 * math.cos(self.theta) + self.rect.size.y / 2.0 * math.sin(self.theta)
#self.bot_left_corner_y = self.rect.position.y + self.rect.size.x / 2.0 * math.sin(self.theta) + self.rect.size.y / 2.0 * math.cos(self.theta)
self.corners = [
sf.Vector2(self.top_left_corner_x, self.top_left_corner_y),
sf.Vector2(self.top_right_corner_x, self.top_right_corner_y),
sf.Vector2(self.bot_right_corner_x, self.bot_right_corner_y)
] # sf.Vector2(self.bot_left_corner_x, self.bot_left_corner_y)]
def set_icon(self, icon):
rect = self.atlas.get_rect(icon)
self.vertex(0).tex_coords = sf.Vector2(rect.left, rect.top)
self.vertex(1).tex_coords = sf.Vector2(rect.right, rect.top)
self.vertex(2).tex_coords = sf.Vector2(rect.right, rect.bottom)
self.vertex(3).tex_coords = sf.Vector2(rect.left, rect.bottom)
def checkNavKeys(w, tDelta, mPos):
if KeyPressed(Key.HOME):
r = w.view.rotation
if r > 180: r -= 360
w.view.rotate(-r * tDelta * 8)
z = 1.0 - w.view.size.y
w.view.zoom(ZOOMSTEP / (ZOOMSTEP - tDelta * z * 8))
dx, dy = (sf.Vector2(.5, .5) - w.view.center) * tDelta * 8
w.view.move(dx, dy)
if KeyPressed(Key.Q): rotateViewAroundPoint(w, -90 * tDelta, mPos)
if KeyPressed(Key.E): rotateViewAroundPoint(w, 90 * tDelta, mPos)
if KeyPressed(Key.PAGE_UP):
zoomViewOnPoint(w, (ZOOMSTEP - tDelta) / ZOOMSTEP, mPos)
if KeyPressed(Key.PAGE_DOWN):
zoomViewOnPoint(w, ZOOMSTEP / (ZOOMSTEP - tDelta), mPos)
dx, dy = 0, 0
if KeyPressed(Key.A): dx = -1
if KeyPressed(Key.D): dx = 1
if KeyPressed(Key.W): dy = -1
if KeyPressed(Key.S): dy = 1
if dx or dy:
scale = min(list(w.view.size))
d = dx, dy
r = [(0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1), (-1, 0),
(-1, 1)].index(d)
r = r * 45 - w.view.rotation
a = r * deg2rad
v = sf.Vector2(sin(a), cos(a))
w.view.center += v * scale * tDelta / 4.0
def _rem_varray(self, x, y):
vert_id = (x + y * self._width) * 4
self._varray[vert_id].position = sf.Vector2(x * self._tile_width, y * self._tile_height)
self._varray[vert_id + 1].position = sf.Vector2(x * self._tile_width, y * self._tile_height)
self._varray[vert_id + 2].position = sf.Vector2(x * self._tile_width, y * self._tile_height)
self._varray[vert_id + 3].position = sf.Vector2(x * self._tile_width, y * self._tile_height)
def nuklearSfmlDrawRectOutline(self,cmd,window):
p=pynk.ffi.cast("struct nk_command_rect*",cmd)
rect=sf.RectangleShape()
rect.size=sf.Vector2(p.w, p.h)
rect.position=sf.Vector2(p.x, p.y)
rect.outline_thickness=p.line_thickness
rect.fill_color=sf.Color(0,0,0,0)
rect.outline_color=sf.Color(p.color.r, p.color.g, p.color.b, p.color.a)
window.draw(rect)
def set_position(self, pos):
rect = sf.Rectangle(
sf.Vector2(pos.x * self.atlas.size.x, pos.y * self.atlas.size.y),
self.atlas.size)
self.vertex(0).position = sf.Vector2(rect.left, rect.top)
self.vertex(1).position = sf.Vector2(rect.right, rect.top)
self.vertex(2).position = sf.Vector2(rect.right, rect.bottom)
self.vertex(3).position = sf.Vector2(rect.left, rect.bottom)
def open(self):
pos = self.position.__copy__() + sf.Vector2(self.style.padding[3],
self.style.padding[0])
for i, btn in enumerate(self._buttons):
pos += sf.Vector2(0, btn.style.margin[0])
btn.position = pos
btn.position += sf.Vector2(btn.style.margin[3], 0)
pos += sf.Vector2(0, btn.style.bounds.y)
super().open()
def nuklearSfmlDrawTriangleFilled(self,cmd,window):
p=pynk.ffi.cast("struct nk_command_triangle_filled*",cmd)
convex=sf.ConvexShape()
convex.point_count=3
convex.set_point(0,sf.Vector2(p.a.x, p.a.y))
convex.set_point(1, sf.Vector2(p.b.x, p.b.y))
convex.set_point(2, sf.Vector2(p.c.x, p.c.y))
convex.fill_color=sf.Color(p.color.r, p.color.g, p.color.b, p.color.a)
window.draw(convex)
def calculateAxis(self):
self.AB_axis = sf.Vector2(
self.top_right_corner_x - self.top_left_corner_x,
self.top_right_corner_y - self.top_left_corner_y)
self.BC_axis = sf.Vector2(
self.bot_right_corner_x - self.top_right_corner_x,
self.bot_right_corner_y - self.top_right_corner_y)
self.axis = [self.AB_axis, self.BC_axis]
def nuklearSfmlDrawLine(self,cmd,window):
p=pynk.ffi.cast("struct nk_command_line*",cmd)
rect=sf.RectangleShape()
rect.size=sf.Vector2(p.line_thickness, abs(p.begin.y-p.end.y))
rect.position=sf.Vector2(p.begin.x, p.begin.y)
rect.outline_thickness=p.line_thickness
rect.fill_color=sf.Color(p.color.r, p.color.g, p.color.b, p.color.a)
rect.outline_color=sf.Color(p.color.r, p.color.g, p.color.b, p.color.a)
window.draw(rect)
def __init__(self, position, fill_color):
super().__init__()
self.growing = True
self.sprite = sf.CircleShape(33)
self.sprite.fill_color = sf.Color(fill_color.r, fill_color.g,
fill_color.b, 50)
self.sprite.position = position - sf.Vector2(0, 5)
self.sprite2 = sf.CircleShape(50)
self.sprite2.fill_color = sf.Color(fill_color.r, fill_color.g,
fill_color.b, 190)
self.sprite2.position = position - sf.Vector2(0, 5)
def isPointInside(self, m):
AM_axis = sf.Vector2(m.x - self.top_left_corner_x,
m.y - self.top_left_corner_y)
BM_axis = sf.Vector2(m.x - self.top_right_corner_x,
m.y - self.top_right_corner_y)
AB_AM_dot = self.AB_axis.x * AM_axis.x + self.AB_axis.y * AM_axis.y
BC_BM_dot = self.BC_axis.x * BM_axis.x + self.BC_axis.y * BM_axis.y
if 0 <= AB_AM_dot and AB_AM_dot <= self.AB_axis.x**2 + self.AB_axis.y**2 and 0 <= BC_BM_dot and BC_BM_dot <= self.BC_axis.x**2 + self.BC_axis.y**2:
return True
return False
def __init__(self, name, render_order):
super().__init__()
self.name = name
self.render_order = render_order
self.reference = None
self.state = CameraState()
self.frames_delay = 15
self.base_pos = sf.Vector2(0, 0)
self.base_size = sf.Vector2(0, 0)
self.vp_base_pos = sf.Vector2(0, 0)
self.vp_base_size = sf.Vector2(1, 1)
self.offset = sf.Vector2(0, 0)
self.visible: bool = True
self._scene = []
def update(self):
if self.shape.size.x/2 > self.limit:
self.end()
elif self.shape.size.x/2 <= self.limit:
self.shape.size += sf.Vector2(self.speed, self.speed)
self.shape.rotate(self.speed*2)
self.shape.origin = (self.shape.size.x/2, self.shape.size.y/2)
def __init__(self, path: str):
self.name = os.path.basename(path)
self.path = path
self.root = ElementTree.parse(
find_resource(os.path.join(os.path.dirname(self.path),
self.name))).getroot()
self._size: sf.Vector2 = sf.Vector2(int(self.root.get('width')),
int(self.root.get('height')))
self._tile_size: sf.Vector2 = sf.Vector2(
int(self.root.get('tilewidth')), int(self.root.get('tileheight')))
self.tilesets: List[MapTileset] = []
self.layers: Dict[str, TileLayer] = {}
self.objectgroups: Dict[str, ObjectGroup] = {}
self._collisions = []
def ex(self, point):
r = math.sqrt(pow(point.x, 2) + pow(point.y, 2))
theta = math.atan2(point.x, point.y)
p0 = math.sin(theta + r)
p1 = math.cos(theta - r)
return sf.Vector2(r * (pow(p0, 3) + pow(p1, 3)),
r * (pow(p0, 3) - pow(p1, 3)))
def disc(self, point):
r = math.sqrt(pow(point.x, 2) + pow(point.y, 2))
theta = math.atan2(point.x, point.y)
return sf.Vector2(
theta / 3.1415 * math.sin(3.1415 * r) *
self.ifs_general.boundedFunctionScale, theta / 3.1415 *
math.cos(3.1415 * r) * self.ifs_general.boundedFunctionScale)
def _calc_point(self, index: int):
pi = 3.141592654
angle = index * 2 * pi / self.point_count - pi / 2
x = math.cos(angle) * self._radius.x
y = math.sin(angle) * self._radius.y
return sf.Vector2(self._radius.x + x, self._radius.y + y)
def get_tile_tex_coord(self, id: int):
if id < self.tile_count:
tx = (id % self.columns) * self.tile_width
ty = (id // self.columns) * self.tile_height
return sf.Vector2(tx, ty)
else:
raise IndexError(f'Tile id {id} not found in tileset {self.name}.')
def __init__(self, name: str, data, gridsize: int = 16):
super().__init__()
self.data = data
self.name = name
self._anim_state = "idle"
self.anims: Dict[str, Anim] = self.data.anims
self.anim_player: AnimPlayer = AnimPlayer(self.anims[self._anim_state])
self.animate = False if self.anims is None else True
self.sprite = sf.Sprite(self.data.texture)
self.sprite.texture_rectangle = self.anims[
self.anim_state].frames[0].rectangle
self.sprite.origin = self.anims[self.anim_state].frames[0].origin
self.direction = sf.Vector2(1, 1)
self.gx = self.sprite.position.x
self.gy = self.sprite.position.y
self.rx = 0
self.ry = 0
self.collision_box = self.global_bounds
self.collision_box_shape = sf.RectangleShape(
(self.collision_box.width, self.collision_box.height))
self.collision_box_shape.position = (self.collision_box.left,
self.collision_box.top)
self.collision_box_shape.fill_color = sf.Color(200, 0, 0, 150)
self.gridsize = gridsize
def moveXModulo(vin, x, mod):
xin = vin.x
yin = vin.y
newX = abs((xin + x) % mod)
return sf.Vector2(newX, yin)
def nuklearSfmlDrawCircleFilled(self,cmd,window):
p=pynk.ffi.cast("struct nk_command_circle_filled*",cmd)
circle=sf.CircleShape()
circle.radius=p.h/2
circle.position=sf.Vector2(p.x, p.y)
circle.fill_color=sf.Color(p.color.r, p.color.g, p.color.b, p.color.a)
window.draw(circle)
def add_icon(self, name):
x, y, path = name.split(':')
pos = sf.Vector2(int(x), int(y))
rect = sf.Rectangle(
sf.Vector2(pos.x * self.size.x, pos.y * self.size.y), self.size)
tex = self.tex_pool.get(path)
spr = sf.Sprite(tex, rect)
spr.position = self.get_pos(self.next_id)
self.render.draw(spr)
icon = self.next_id
self.next_id += 1
return icon
def build_cell(self, dist):
cell_size = self.size / 2
is_leaf = cell_size.x <= 2 or cell_size.y <= 2
if is_leaf:
cell_origin = sf.Vector2(self.origin.x + (-1 if dist.x < 0 else 0) * cell_size.x,
self.origin.y + (-1 if dist.y < 0 else 0) * cell_size.y)
else:
cell_origin = sf.Vector2(self.origin.x + (-1 if dist.x < 0 else 1) * cell_size.x // 2,
self.origin.y + (-1 if dist.y < 0 else 1) * cell_size.y // 2)
cell = ChunkTree(origin=cell_origin,
size=cell_size,
loader=self.loader,
is_leaf=is_leaf)
return cell
def diamond(self, point):
r = math.sqrt(pow(point.x, 2) + pow(point.y, 2))
theta = math.atan2(point.x, point.y)
return sf.Vector2(
math.sin(theta) * math.cos(r) *
self.ifs_general.boundedFunctionScale,
math.cos(theta) * math.sin(r) *
self.ifs_general.boundedFunctionScale)
def init(self):
if not self.loaded:
self.loader = ChunkLoader(level_id=self.id,
save_file=self.save_file)
self.chunks = ChunkTree(origin=sf.Vector2(0, 0),
size=self.size,
loader=self.loader)
self.loaded = True
def __init__(self, name, save_file):
"""
Creates an empty world
"""
self.id = None
self.save_file = save_file
self.name = name
self.size = sf.Vector2(16, 16)
self.regions = dict()
def julia(self, point):
omega = int(random.random() + 0.5) * 3.1415
sqrtr = math.sqrt(math.sqrt(point.x**2 + point.y**2))
theta = math.atan2(point.x, point.y)
return sf.Vector2(
sqrtr * math.cos(theta / 2 + omega) *
self.ifs_general.boundedFunctionScale,
sqrtr * math.sin(theta / 2 + omega) *
self.ifs_general.boundedFunctionScale)
def update(self):
if self.shapes[0].size.x == 0:
self.end()
elif self.shapes[0].size.x > self.speed:
self.shapes[0].size -= sf.Vector2(self.speed, self.speed)
self.shapes[0].rotate(self.speed*2)
else:
self.shapes[0].size = (0, 0)
self.shapes[0].origin = (self.shapes[0].size.x/2, self.shapes[0].size.y/2)
