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)