def solution(t):
t.insert(s, dlam)
# t[s:s] = dlam
x = V.zero(n)
for sol_i in range(n):
x = V.add(x, V.mul_scalar(M.column(c, sol_i), t[sol_i], p), p)
return x
def sees(self, o):
points = get_line_points(Vector(self.x, self.y), Vector(o.x, o.y))
for point in points:
# TODO access tiles, not grid
if self.zone._grid[point.y][point.x] == '#':
return False
return True
def wiedemann2(les: LinearEquationSystem):
a, b, p, n = les.a, M.t(les.b)[0], les.p, les.n
a_powers = [M.unit(n, n)]
for i in range(1, 2 * n):
a_powers.append(M.mul(a_powers[-1], a, p))
aib = [M.mul_vec(ai, b, p) for ai in a_powers]
k = 0
gs = [[1]]
uk1 = [0, 1] + ([0] * (n - 2))
while Poly.deg(gs[k]) < n and k < n:
seq = []
for i in range(2 * n - Poly.deg(gs[k])):
gab = M.mul_vec(fa(gs[k], a, p), aib[i], p)
ugab = V.mul_sum(uk1, gab, p)
seq.append(ugab)
assert len(seq)
f = berlekamp(seq, p)
gs.append(Poly.mul(f, gs[k], p))
k += 1
uk1 = ([0] * k) + [1] + ([0] * (n - k - 1))
print('k =', k)
g = gs[-1]
x = V.zero(n)
for i in range(Poly.deg(g)):
x = V.add(x, V.mul_scalar(aib[i], -g[i], p), p)
return x
def physicsStep(self, entity):
force = Vector()
if not isinstance(self.root, Sprite):
stack = [self.root]
while len(stack) > 0:
curr = stack.pop()
d = curr.size/Vector.Distance(curr.center_of_mass, entity.pos)
if d < THETA:
force += QuadTree.calc_force(curr.center_of_mass,
entity.pos,
curr.total_mass,
entity.mass)
else:
for c in curr.children.values():
if c is None or c is entity:
continue
elif isinstance(c, Sprite):
force += QuadTree.calc_force(c.pos, entity.pos,
c.mass, entity.mass)
else:
stack.append(c)
entity.pos = entity.pos + entity.vel * DT
entity.vel = entity.vel + (force / entity.mass) * DT
if Vector.Length(entity.vel) > SPEED_LIMIT:
entity.vel *= OVERSPEED_DAMP
else:
entity.vel *= NORMAL_DAMP
def getSafeZones(self):
zones = []
zones.append(SafeZone(Vector(.25, .25), .1))
zones.append(SafeZone(Vector(.25, .75), .1))
zones.append(SafeZone(Vector(.75, .25), .1))
zones.append(SafeZone(Vector(.75, .75), .1))
return zones
def process_cand_inner(w, xi, n, rangebits):
with open('./debug.txt', 'a') as f:
for item in xi:
f.write(str(item) + '\n')
start = time()
w_vec = Vector(w)
xi_vec = Vector(xi)
value = xi_vec.inner_product(w_vec)
# rp = run_test_rangeproof(value, rangebits)
print("Starting range proof prover: Generating proof")
prf, negetive, rp = range_prover(value, rangebits)
V = rp.V
gamma = rp.gamma
print("Lenght of Range Proof is :", len(prf))
#with open('./result.txt', 'a') as f:
# f.write("Lenght of Range Proof is : " + str(len(prf)) + '\n')
print("Starting Inner Product proof generation: Generating proof")
prf2 = inner_product_prover(w, xi, n, V, gamma)
final_pc, pc2, a, b, L, R, comm1 = prf2
len2 = len(a) + len(b) + len(L) * len(L[0]) + len(R) * len(R[0]) + len(
comm1) + len(final_pc) + len(pc2) + len(final_pc) + len(pc2)
print("Generated Inner Product proof: len " + str(len2))
#with open('./result.txt', 'a') as f:
# f.write("Generated Inner Product proof: len " + str(len2) + '\n')
print("\n\n")
print("Proof Generation complete: It's total length is " +
str(len(prf) + len2))
range_verifier(prf, negetive, V, rangebits)
end = time()
print("Proof Time is : ", end - start)
return inner_product_verifier(n, V, prf2)
class PlatformerSettings:
BG_COLOR = Color('black')
PPU = 100
BLOB_SIZE = 1
PLATFORM_HEIGHT = 0.2
PLATFORM_COLOR = Color('grey')
GRAVITY = Vector(0, 5)
RUN_SPEED = 2
JUMP_SPEED = 3
SOUND_RADIUS = 2
SCROLL_MARGIN = 2
JUMP_TIME = 0.5
LEFT_KEYS = {pygame.K_LEFT, pygame.K_a}
RIGHT_KEYS = {pygame.K_RIGHT, pygame.K_d}
JUMP_KEYS = {pygame.K_UP, pygame.K_w, pygame.K_SPACE}
TEXT_BGCOLOR = Color('black')
TEXT_STYLE = {
"text": {
"margin": Vector(10, 5),
},
"paragraph": {
"spacing": 10,
},
"font": {
"family": 'Monospace',
"size": 24,
"color": Color('white'),
}
}
OVERLAY_COLOR = Color(255, 255, 255, 127)
def method_jacobi_rotations(a, eps):
n_iter = 0
a_k = copy.copy(a)
v = Matrix(a.size, single=True)
while True:
i_max, j_max = find_max(a_k)
fi = 0.5 * math.atan(2 * a_k[i_max][j_max] /
(a_k[i_max][i_max] - a_k[j_max][j_max]))
u = Matrix(a.size, single=True)
u[i_max][i_max] = math.cos(fi)
u[i_max][j_max] = -math.sin(fi)
u[j_max][i_max] = math.sin(fi)
u[j_max][j_max] = math.cos(fi)
u_t = copy.copy(u)
u_t.transpose()
a_k = u_t * a_k * u
v = v * u
n_iter += 1
if t(a_k) < eps:
eigenvalue = Vector(a_k.size)
eigenvalue.vector = [a_k[i][i] for i in range(0, a_k.size)]
print('Итераций: ', n_iter)
return eigenvalue, v
def init_moves(self):
self._moves = [
PeaceMove(self, self.dir * Vector(1, 0)),
CaptureMove(self, self.dir * Vector(1, 1)),
CaptureMove(self, self.dir * Vector(1, -1)),
FirstMove(self, self.dir * Vector(1, 0), steps=2)
]
def test(eigenvalue, v_matrix, matrix):
print('Проверка')
vectors = []
for vector in zip(*v_matrix.matrix):
v = Vector(v_matrix.size)
v.vector = vector
vectors.append(v)
for i in range(0, len(vectors) - 1):
print('v_{0}: '.format(i + 1), end='')
vectors[i].print_vector()
print('v_{0}: '.format(len(vectors)), end='')
v.print_vector()
print('(v_{0}, v_{1}): '.format(i + 1, len(vectors)), end='')
res = sum([vectors[i][j] * v[j] for j in range(0, v.size)])
print('{0:8.20f}'.format(res))
print()
print('Проверка A * x = a_k * x')
for i in range(0, len(vectors)):
print('a_k = ', eigenvalue[i])
print('x = ', end='')
vectors[i].print_vector()
print('A * x = ', end='')
(matrix * vectors[i]).print_vector()
print('a_k * x = ', end='')
(vectors[i] * eigenvalue[i]).print_vector()
print('-------------------------------------------------------------')
def solve2():
with open('./mace.json') as f:
mace = json.load(f)
mace = {Vector(x, y) for x, y in mace}
graph = SetGraph(mace)
queue = PriorityQueue()
queue.put((0, Vector(16, 16)))
max_distance = 0
visited = set()
while not queue.empty():
distance, pos = queue.get()
max_distance = max(max_distance, distance)
visited.add(Vector(*pos))
for n in graph.neighbors(pos):
if n not in visited:
queue.put((distance + 1, n))
print(max_distance)
canvas = ThisCanvas()
for vec in mace:
canvas.set(vec, 0)
for vec in visited:
canvas.set(vec, 2)
arcade.run()
def __init__(self, type, x, y, w, h, color, speed, hp, points, useOutline=False):
self.type = type
self.pos = Vector(x,y)
self.size = Vector(w,h)
self.color = color
try:
self.spr = sf.Sprite(Game.images[type])
except:
self.spr = None
self.base_speed = speed
self.stuck = False #if caught on quicksand
self.hp = hp
self.max_hp = hp
self.show_life_bar = True
self.ID = BaseEntity.getIDfor(self)
self.point_value = points
self.last_moved_dir = Vector(0,0)
self.considers_game_speed = False
self.maxbar = sf.RectangleShape((self.size.x, 5))
self.maxbar.fill_color = sf.Color.BLACK
self.curbar = sf.RectangleShape((self.size.x * self.hp/self.max_hp, 5))
self.curbar.fill_color = sf.Color.RED
self.shaders = [None]
if self.spr != None and useOutline:
self.shaders[0] = sf.Shader.from_file(fragment="scripts/outline.frag")
self.shaders[0].set_currenttexturetype_parameter("texture")
self.shaders[0].set_2float_parameter("stepSize", 5.0/self.spr.texture.width, 5.0/self.spr.texture.height)
self.shaders[0].set_color_parameter("outlineColor", self.color)
def gaussian(les: LinearEquationSystem):
a, b = copy.deepcopy(les.a), copy.deepcopy(les.b)
n, m, p = les.n, les.m, les.p
for col in range(m):
row_replaced = find_nonzero(a, col)
if row_replaced == -1:
continue
if row_replaced != col:
a[col], a[row_replaced] = a[row_replaced], a[col]
b[col], b[row_replaced] = b[row_replaced], b[col]
for row in range(col + 1, n):
if a[row][col] != 0:
scalar = get_inverse(a[row][col], p) * a[col][col] % p
a[row] = V.mul_scalar(a[row], scalar, p)
a[row] = V.minus(a[row], a[col], p)
brow = b[row][0]
b[row] = [(brow * scalar - b[col][0]) % p]
assert a[row][col] == 0
func = all_solutions(a[-1][n - 1:], b[-1][0], p)
def solution(t):
x = [0] * m
x[n - 1:] = func(t)
for row in range(n - 1, -1, -1):
xcol = b[row][0]
for col in range(m - 1, row, -1):
xcol = (xcol - a[row][col] * x[col]) % p
xcol = xcol * get_inverse(a[row][row], p) % p
x[row] = xcol
return x
return solution, m - n
def get_child_pos(card, pos, size):
quarter_size = size/4
if card == Card.NORTHWEST:
return Vector(pos.x - quarter_size, pos.y - quarter_size)
elif card == Card.NORTHEAST:
return Vector(pos.x + quarter_size, pos.y - quarter_size)
elif card == Card.SOUTHWEST:
return Vector(pos.x - quarter_size, pos.y + quarter_size)
else: # Card.SOUTHEAST
return Vector(pos.x + quarter_size, pos.y + quarter_size)
def __init__(self, parent=None, size=0, pos=Vector(0, 0)):
self.children = {Card.NORTHWEST: None,
Card.NORTHEAST: None,
Card.SOUTHWEST: None,
Card.SOUTHEAST: None}
self.parent = parent
self.size = size
self.pos = pos
self.total_mass = 0
self.center_of_mass = Vector(0, 0)
def play(window: Tk, text: StringVar, score: StringVar, comp: IntcodeComp, grid: Grid[Block], cycles: int = 0) -> None:
"""
Plays a frame of the Block Game in the Intcode VM
:param window: Game window
:param text: Grid text
:param score: Score label
:param comp: Intcode VM running the game
:param grid: Game grid
:param cycles: Empty cycles ran
"""
# Check if there is anything new to display
if len(comp.output_buffer) == 0:
# If nothing new has been available to display for five frames, assume Game over
if cycles == 5:
# Print score and return
print(score.get())
return
else:
# Wait until next frame, and increment inactivity counter
window.after(33, lambda: play(window, text, score, comp, grid, cycles + 1))
# Position of the paddle and ball
paddle: Vector = Vector(0, 0)
ball: Vector = Vector(0, 0)
# Pop out all the info in the output buffer
while len(comp.output_buffer) >= 3:
# Get position to write to
pos: Vector = Vector(comp.next_output(), comp.next_output())
# If score position, update score
if pos == score_pos:
score.set(comp.next_output())
else:
# Else get block type, and keep track if it's the paddle or ball
block: Block = Block(comp.next_output())
if block == Block.PADDLE:
paddle = pos
elif block == Block.BALL:
ball = pos
# Update the grid
grid[pos] = block
# Update the game label
text.set(str(grid))
# Input the new position of the paddle
if ball.x != paddle.x:
comp.add_input(-1 if ball.x < paddle.x else 1)
else:
comp.add_input(0)
# Schedule the next update
window.after(33, lambda: play(window, text, score, comp, grid))
def collide_body_static_body(b, sb):
delta = b.pos - sb.pos
d = Vector.Length(delta)
mtd = delta * ((b.rad + sb.rad)-d)/d
b.pos = b.pos + mtd
vn = Vector.Dot(b.vel, Vector.Normalize(mtd))
if vn > 0:
return
i = -(1 + RESTITUTION) * vn
b.vel += Vector.Normalize(mtd) * i
def to_str_square(self, x, y, size=Vector(3, 3)):
col = "#" * bool(0 == (x + y - 1) % 2) + " " * bool(1 ==
(x + y - 1) % 2)
result = [col] * size.y * size.x
fig_index = self.squares[x][y]
if (fig_index != -1):
fig = self.figures[fig_index]
fig_pos = Vector(size.x // 2, size.y // 2)
result[fig_pos.x * size.y + fig_pos.y] = fig.image
return [
"".join(result[k:k + size.y])
for k in range(0, len(result), size.y)
]
def std_figures(): #will just be referenced if saved as an array
return [
Figure(std_names[k], std_pos[k][0], std_movements[std_names[k]], 0,
None, std_images[std_names[k]][0]) for k in range(8)
] + [
Figure("Pawn", Vector(1, y), pawn_move, 0, None, "°") for y in range(8)
] + [
Figure(std_names[k], std_pos[k][1], std_movements[std_names[k]], 1,
None, std_images[std_names[k]][1]) for k in range(8)
] + [
Figure("Pawn", Vector(6, y), std_movements["Pawn"], 1, None, "^")
for y in range(8)
]
def quadratures_method(points, h, lambda_exp, k_exp, g_exp):
x = sympy.Symbol('x')
t = sympy.Symbol('t')
k = sympy.lambdify([x, t], parse_expr(k_exp))
g = sympy.lambdify(x, parse_expr(g_exp))
lambda_ = float(parse_expr(lambda_exp))
A = get_matrix_system(points, h, lambda_, k)
G = Vector(len(points))
G.vector = get_values(points, g)
return lu_solve(A, G).vector
def equation_moves(figure, squares, X, equation):
result = []
try:
size = Vector(len(squares), len(squares[0]))
except:
size = Vector(8, 8)
for x in X:
for y in X:
added = figure.pos.add(Vector(x, y))
if (equation(x, y) and added.in_ranges([0, size.x], [0, size.y])
and squares[added.x][added.y] != figure.color):
result += [Move(figure, figure.pos, added)]
return result
def createBullet(self):
start_point = self.nose().copy()
direction = self.rotation
unit_vector_for_direction = Vector.unit_vector(direction)
# The bullet will always fire straight, but if the ship is going fast the bullets should still outrun it.
# To do this, we project the ships speed along the unit vector in the direction the bullet will be travelling.
# Then we add the base bullet speed. This should only have noticable effect when travelling quickly and firing forwards.
# TODO: Fix this. Currently when travelling at a high speed vertically and firing horizontally, the bullets can
# sometimes fly backwards. Something about the projection is off, possibly even the idea.
bullet_speed = self.speed.dot_product(
unit_vector_for_direction) + self.bullet_speed
speed = Vector.dir_mag(direction, bullet_speed)
return Bullet(start_point, speed)
def __init__(self,
m00=0,
m01=0,
m02=0,
m10=0,
m11=0,
m12=0,
m20=0,
m21=0,
m22=0):
#this may need some checking for row vs column major. stuff confuses me
self.vectors.append(Vector(m00, m10, m20))
self.vectors.append(Vector(m01, m11, m21))
self.vectors.append(Vector(m02, m12, m22))
def get_poly_1_deg(points, values):
sum_points = sum(points)
sum_points_2 = sum([point**2 for point in points])
sum_values = sum(values)
sum_v_p = sum([values[i] * points[i] for i in range(0, len(points))])
a = Matrix(2)
a.matrix = [[len(points), sum_points], [sum_points, sum_points_2]]
b = Vector(2)
b.vector = [sum_values, sum_v_p]
l, u, p = lup(a)
coefficients = lup_solve(l, u, p, b).vector
return parse_expr(f'{coefficients[0]} + {coefficients[1]} * x')
def rob_controller():
robot.start()
ship = {
Vector(0, 0): 1 # Part 2
}
while not robot.finished():
robot.put(ship.get(robot.pos, 0))
color = robot.get()
turn = robot.get()
# Painting
canvas.new_paintings.append((robot.pos, COLORS[color]))
ship[robot.pos] = color
# Turn
if turn == 0:
robot.turn_left()
elif turn == 1:
robot.turn_right()
robot.move()
sleep(canvas.delay)
print(len(ship))
canvas.draw_sprites = False
def __init__(self, pos=Vector(0, 0), rot=0.0):
"""Creates a new Ship
Args:
pos: the position of the ship
rot: the rotation of the ship
Returns:
a new Ship instance
"""
# Get the initial direction of the ship using the rotation
direction = Vector(cos(radians(rot)), sin(radians(rot)))
# Initially, the ship isn't moving
self._movement = Vector.zero()
# Initialize bullet list
self.bullets = []
self._last_shoot = self._shoot_delay
self._last_teleport = self._teleport_delay
self.teleport_up = True
self.effect_player = EffectPlayer.instance()
Entity.__init__(self, (20, 0, -30, 20, -30, -20), direction,
lin_speed=1.0, rot_speed=2.0, pos=pos, rot=rot,
scale=0.5)
def process_event(self, event):
# Mouse
if event.type == MOUSEBUTTONDOWN:
coordinates = lambda p: Vector((p[0] - 100) / 600.,
(p[1] - 100) / 400., 0)
if self.dcel:
face = self.dcel.find_face(coordinates(event.pos))
if face:
self.selected = self.dcel.edges.index(face.edge)
# Keyboard
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
self.stop()
elif event.key == K_SPACE:
e = self.dcel.edges[self.selected]
if event.mod & KMOD_SHIFT > 0:
self.selected = self.dcel.edges.index(e.next)
else:
self.selected = self.dcel.edges.index(e.prev)
elif event.key == K_f:
self.dcel.edges[self.selected].flip()
# Varios
elif event.type == QUIT:
self.stop()
elif event.type == VIDEORESIZE:
self.resize(event.w, event.h)
def __init__(self,
size: Vector,
max_count: int,
reproduce_chance: float,
starting_point: Optional[Vector] = None,
quadratic: bool = False):
self.size = size
if starting_point is None:
starting_point = Vector(size.x // 2, size.y // 2)
elif not ((1 <= starting_point.x <= size.x) or
(1 <= starting_point.y <= size.y)):
raise IndexError(
'Starting point coordinate components must be less than or equal to the size of an image.'
)
self.starting_point = starting_point
# The maximum allowable value of squares count
if max_count is None:
max_count = (size.x * size.y) // 2
self.max_count = max_count
self.reproduce_chance = reproduce_chance
self.quadratic = quadratic
# Current squares count
self.count = 1
self.current_generation = 1
self.squares = [[None for y in range(self.size.y + 1)]
for x in range(self.size.x + 1)]
self.__not_reproduced_squares = deque()
def get_figure_by_pos(self, x, y):
sq = self.squares[x][y]
if (sq == -1):
raise ValueError("There is no figure on this square (" +
Vector(x, y).chess_notation() + ").")
else:
return self.figures[sq]
def to_str_fancy(self, size=Vector(3, 3), auto_print=True):
result = ""
result_arr = [[
self.to_str_square(x, y, size) for y in range(self.size.y)
] for x in range(self.size.x)]
result += " " + "".join([
" " * (size.y // 2 + 1) + "ABCDEFGH"[i] + " " * (size.y // 2)
for i in range(8)
]) + " \n"
x_sep = " +" + ("–" * size.y + "+") * self.size.y
for big_x in range(self.size.x):
result += x_sep + "\n"
for x in range(size.x):
if (x == size.x // 2):
result += str(big_x + 1) + " "
else:
result += " "
for big_y in range(self.size.y):
result += "|"
for y in range(size.y):
result += result_arr[big_x][big_y][x][y]
result += "|\n"
result += x_sep + "\n"
if (auto_print):
print(result)
return result
def make_asteroid():
# We don't want 70 < x < 130, or 40 < y < 60, so first we generate the values
# with the appropriate ranges, then bump them up if they're above the minimum.
# This creates a gap in the middle, and doesn't require re-generating.
x = random.randint(0, 140)
y = random.randint(0, 80)
#TODO: Make this actually avoid the ship(s), so we can simply add new asteroids to start a new level.
if x > 70:
x += 60
if y > 40:
y += 20
center = Point(x, y)
direction = random.random() * 2 * math.pi
abs_speed = random.random() / 50
speed = Vector.zero().add_in_direction(abs_speed, direction)
size = 8 + random.random() * 2
num_children = random.randint(2, 3)
return Asteroid(center = center, speed = speed, size = size, num_children = num_children)
def intersects(self, b):
#Rectangle collision detection (SAT Separating Axis Theorem)
for rect in [self, b]:
for i1 in range(len(rect.corners)):
i2 = (i1 + 1) % len(rect.corners)
p1 = rect.corners[i1]
p2 = rect.corners[i2]
normal = Vector(p2.y - p1.y, p1.x - p2.x)
minA = maxA = minB = maxB = None
for p in self.corners:
projected = normal.x * p.x + normal.y * p.y
if (minA == None or projected < minA):
minA = projected
if (maxA == None or projected > maxA):
maxA = projected
for p in b.corners:
projected = normal.x * p.x + normal.y * p.y
if (minB == None or projected < minB):
minB = projected
if (maxB == None or projected > maxB):
maxB = projected
if (maxA < minB or maxB < minA):
return False
return True
def move_dir(self):
dir = Vector(0,0)
if not self.valid(): return dir
dir.x = -self.action_value(InputMethod.MOVE_LEFT)
if dir.x == 0:
dir.x = self.action_value(InputMethod.MOVE_RIGHT)
dir.y = -self.action_value(InputMethod.MOVE_UP)
if dir.y == 0:
dir.y = self.action_value(InputMethod.MOVE_DOWN)
if dir.squaredLen() > 1:
dir.normalize()
return dir
def targeting_dir(self):
if self.targeting_type == InputMethod.AUTO_TARGETING:
return None
elif self.targeting_type == InputMethod.POINT_TARGETING:
mouse = sf.Mouse.get_position(Game.window)
dir = Vector(mouse.x, mouse.y) - self.player.center()
dir.normalize()
return dir
elif self.targeting_type == InputMethod.DIRECTIONAL_TARGETING:
dir = Vector(0.0, 0.0)
dir.x += self.targeting_bindings['right'].value(self.id)
dir.x -= self.targeting_bindings['left'].value(self.id)
dir.y += self.targeting_bindings['down'].value(self.id)
dir.y -= self.targeting_bindings['up'].value(self.id)
dir.normalize()
return dir
return None
class BaseEntity:
entCount = 0
def getIDfor(ent):
BaseEntity.entCount += 1
return BaseEntity.entCount
def __init__(self, type, x, y, w, h, color, speed, hp, points, useOutline=False):
self.type = type
self.pos = Vector(x,y)
self.size = Vector(w,h)
self.color = color
try:
self.spr = sf.Sprite(Game.images[type])
except:
self.spr = None
self.base_speed = speed
self.stuck = False #if caught on quicksand
self.hp = hp
self.max_hp = hp
self.show_life_bar = True
self.ID = BaseEntity.getIDfor(self)
self.point_value = points
self.last_moved_dir = Vector(0,0)
self.considers_game_speed = False
self.maxbar = sf.RectangleShape((self.size.x, 5))
self.maxbar.fill_color = sf.Color.BLACK
self.curbar = sf.RectangleShape((self.size.x * self.hp/self.max_hp, 5))
self.curbar.fill_color = sf.Color.RED
self.shaders = [None]
if self.spr != None and useOutline:
self.shaders[0] = sf.Shader.from_file(fragment="scripts/outline.frag")
self.shaders[0].set_currenttexturetype_parameter("texture")
self.shaders[0].set_2float_parameter("stepSize", 5.0/self.spr.texture.width, 5.0/self.spr.texture.height)
self.shaders[0].set_color_parameter("outlineColor", self.color)
def draw(self, window):
self.drawEntity(window)
self.drawHPBar(window)
def drawEntity(self, window):
w = self.size.x;
h = self.size.y;
x = self.pos.x + w/2;
y = self.pos.y + h/2;
angle = self.last_moved_dir.x * math.pi/8
if self.type == 'warrig':
angle = 0.0
self.spr.position = (x, y) #sprite position
self.spr.origin = (self.spr.texture.width/2, self.spr.texture.height/2) #sprite origin
self.spr.ratio = (w/self.spr.texture.width, h/self.spr.texture.height) #scale factor
self.spr.rotation = math.degrees(angle) #rotation angle (in degrees?)
for shade in self.shaders:
window.draw(self.spr, sf.RenderStates(shader=shade))
def drawHPBar(self, window):
if self.show_life_bar:
#ctx.fillStyle = 'black'
#ctx.fillRect(self.pos.x, self.pos.y+self.size.y+1, self.size.x, 5)
self.maxbar.position = (self.pos.x, self.pos.y + self.size.y + 1)
window.draw(self.maxbar)
#ctx.fillStyle = 'red'
#ctx.fillRect(self.pos.x, self.pos.y+self.size.y+1, self.size.x*self.hp/self.max_hp, 5)
self.curbar.size = (self.size.x * self.hp/self.max_hp, 5)
self.curbar.position = (self.pos.x, self.pos.y + self.size.y + 1)
window.draw(self.curbar)
def checkCollision(self, ent):
notIntersects = self.pos.x > (ent.pos.x + ent.size.x)
notIntersects = notIntersects or (self.pos.x + self.size.x) < ent.pos.x
notIntersects = notIntersects or self.pos.y > (ent.pos.y + ent.size.y)
notIntersects = notIntersects or (self.pos.y + self.size.y) < ent.pos.y
return not notIntersects
def limitInRect(self, pos, size):
center = self.center()
moved = False
if center.x < pos.x:
self.pos.x = pos.x - self.size.x/2
moved = True
elif center.x > pos.x + size.x:
self.pos.x = pos.x + size.x - self.size.x/2
moved = True
if center.y > pos.y + size.y:
self.pos.y = pos.y + size.y - self.size.y/2
moved = True
#elif center.y < pos.y:
# self.pos.y = pos.y - self.size.y/2
# moved = True
return moved
def center(self):
return self.pos + self.size*0.5 #self.pos.add(self.size.scale(0.5))
def rect(self):
return sf.Rectangle(self.pos.toSFML(), self.size.toSFML())
def vertices(self):
r = self.rect()
vl = [ Vector(r.left, r.top),
Vector(r.right, r.top),
Vector(r.left, r.bottom),
Vector(r.right, r.bottom)]
return vl
def onDeath(self):
pass
def speed(self):
s = self.base_speed
if self.considers_game_speed:
s = s * (Game.states[-1].speed_level + 5)
return s * (1.0 - self.stuck*0.85) #0.85 is % of speed lost while stuck
def move(self, dir):
self.last_moved_dir = dir.copy()
self.pos = self.pos + dir*self.speed()
return self.limitInRect(Game.track_pos, Game.track_area)
def __repr__(self):
return self.__str__()
def __str__(self):
return "%s#%i" % (self.type, self.ID)