def make_univer(n_particles=int(10e6)): max_v = 1 min_v = -1 particles = [Particle(r=Vector2d(random.uniform(-box_size // 2, box_size // 2), random.uniform(-box_size // 2, box_size // 2)), v=Vector2d(random.uniform(min_v, max_v), random.uniform(min_v, max_v)))] # global box_size i = 1 while True: # if i % (n_particles//100) == 0: # print('box:', i // (n_particles//100) + 1) tmp_par = Particle(r=Vector2d(random.uniform(-box_size // 2, box_size // 2), random.uniform(-box_size // 2, box_size // 2)), v=Vector2d(random.uniform(min_v, max_v), random.uniform(min_v, max_v))) flag = 1 # for particle1 in particles: # tmp_e = particle1.r - tmp_par.r # if abs(tmp_e) == 0: # continue # tmp_f = forces.base_force(particle1, tmp_par) # if (tmp_f.x*tmp_e.x + tmp_f.y*tmp_e.y) < 0: # flag = 0 if flag == 1: particles.append(tmp_par) i += 1 if i >= n_particles: break # print(i) return particles
def __init__(self, r, name='noname', v=Vector2d(0, 0), mass=1): self.r = r self.v = v self.name = name self.mass = mass self.force = Vector2d(0, 0) self.color = (1, 1, 1)
def _add_edges(self): for x, y in itertools.product(range(self.columns), range(self.rows)): node = Vector2d(x, y) right_neighbor = Vector2d((x + 1) % self.columns, y) top_neighbor = Vector2d(x, (y + 1) % self.rows) self._edges[node, right_neighbor] = Edges.State.unknown self._edges[right_neighbor, node] = Edges.State.unknown self._edges[node, top_neighbor] = Edges.State.unknown self._edges[top_neighbor, node] = Edges.State.unknown
def calculate_force(self, particle, node=None): if node is None: node = self.root force = Vector2d(0, 0) if len(node.particles) == 0: return force # if (node.type == 2) and (abs(node.particles[0].r - particle.r) != 0): if (node.type == 2) and (node.particles[0] != particle): tmp_f = forces.base_force(particle, node.particles[0]) # print(particle.name, node.name, node.depth, len(node.particles)) # if particle.name == constants.median: # tmp_brute_f = Vector2d() # for particle_brute in node.particles: # tmp_brute_f += forces.base_force(particle, particle_brute) # # len_error = (abs(tmp_f) - abs(tmp_brute_f)) / (abs(tmp_brute_f) + constants.epsilon) # print(len_error, '|', tmp_f, '|', tmp_brute_f) force += tmp_f cm = node.get_cm() if (node.type == 1) and (mac.mac(particle, node)): # print(particle.name, node.name) # print(particle.name, node.name, node.depth, len(node.particles)) tmp_f = forces.base_force( particle, Particle(r=cm, v=node.get_mv(), mass=node.mass, name='aprox')) a = 0.1 b = 0.8 tmp_color = ((b - a) * np.random.random() + a, (b - a) * np.random.random() + a, (b - a) * np.random.random() + a) self.save_particles += len(node.particles) - 1 for particle_color in node.particles: particle_color.color = tmp_color if particle.name == constants.median: tmp_brute_f = Vector2d() for particle_brute in node.particles: tmp_brute_f += forces.base_force(particle, particle_brute) len_error = (abs(tmp_f) - abs(tmp_brute_f)) / ( abs(tmp_brute_f) + constants.epsilon) print(len_error, '|', tmp_f, '|', abs(tmp_f), '|', tmp_brute_f, '|', abs(tmp_brute_f)) force += tmp_f if (node.type == 1) and not (mac.mac(particle, node)): for child in node.children: force += self.calculate_force(particle, child) return force
def make_net(n_particles=int(10e6)): particles = [] n_rows = int(math.sqrt(n_particles)) h = constants.box_size // n_rows for i in range(n_particles): particles.append( Particle(r=Vector2d(i % n_rows * h, i // n_rows * h), v=Vector2d())) # print(particles[-1].r) return particles, h
def getImpulse(m1,m2): vr = m1.getVelocity().copy() vr.sub(m2.getVelocity()) n = Vector2d.normal(m2.getPosition(),m1.getPosition()) impulse = n.copy() #m1.getPosition().display() #m2.getPosition().display() #impulse.display() s = Vector2d.dotProduct(vr,n)*(1 + 0.5) impulse.mulScalar(s) return impulse
def __init__(self, x, y, width, hieght, image, isPlayer=False): self.position = Vector2d(x, y) self.sprite = image self.velocity = Vector2d(0, 0) self.isPlayer = isPlayer self.width = width self.height = hieght self.radius = width / 2 self.mass = self.radius * ATOM_MASS_PER_PER_PIXEL self.isVisible = True self.font = pygame.font.Font('freesansbold.ttf', 10) self.colliding = False
def _handle_walls(self, walls): """Remove edges where there are walls.""" for w in walls: tile1 = w.position tile2 = None if w.orientation == Wall.Orientation.horizontal: tile2 = w.position - Vector2d(0, 1) if w.orientation == Wall.Orientation.vertical: tile2 = w.position - Vector2d(1, 0) tile1 = self.grid.normalize(tile1) tile2 = self.grid.normalize(tile2) self.edges[tile1, tile2] = Edges.State.absent
def apply_player_direction(self, delta): direction = Vector2d(0, 0) if self.moveDOWN: direction += Vector2d(0, PLAYER_ACCELERATION) if self.moveUP: direction += Vector2d(0, -PLAYER_ACCELERATION) if self.moveRIGHT: direction += Vector2d(PLAYER_ACCELERATION, 0) if self.moveLEFT: direction += Vector2d(-PLAYER_ACCELERATION, 0) self.playerAtom.velocity += direction
def make_hex_2(r, center): particles = [Particle(r=center, v=Vector2d(), name=0)] for i in range(r): tmp_par = [] for angle in [j * math.pi / 3 for j in range(6)]: tmp_par.append( Particle(r=center + Vector2d( (i + 1) * constants.a * math.sin(angle), (i + 1) * constants.a * math.cos(angle)), v=Vector2d(), name=len(particles))) for j, particle in enumerate(tmp_par[:-1]): particles.append(particle) # fig, ax1 = plt.subplots(figsize=(4, 4)) # x = [particle.r.x for particle in particles] # y = [particle.r.y for particle in particles] # ax1.scatter(x=x, y=y, marker='o', c='r', edgecolor='b') # ax1.set_title('Scatter: $x$ versus $y$') # ax1.set_xlabel('$x$') # ax1.set_ylabel('$y$') # plt.show() e_tmp = particle.r - tmp_par[j + 1].r e_tmp = e_tmp * (1 / abs(e_tmp)) for k in range(i): particles.append( Particle(r=particle.r - e_tmp * constants.a, v=Vector2d(), name=len(particles))) # fig, ax1 = plt.subplots(figsize=(4, 4)) # x = [particle.r.x for particle in particles] # y = [particle.r.y for particle in particles] # ax1.scatter(x=x, y=y, marker='o', c='r', edgecolor='b') # ax1.set_title('Scatter: $x$ versus $y$') # ax1.set_xlabel('$x$') # ax1.set_ylabel('$y$') # plt.show() particles.append(tmp_par[-1]) e_tmp = tmp_par[-1].r - tmp_par[0].r e_tmp = e_tmp * (1 / abs(e_tmp)) for k in range(i): particles.append( Particle(r=particle.r - e_tmp * constants.a, v=Vector2d(), name=len(particles))) return particles
def _setup_walls(self): for w in self.puzzle.walls: self.grid.add_widget(WallWidget(w)) # Double the walls on the board's borders if w.position.x == 0 and w.orientation == Wall.Orientation.vertical: w2 = Wall(Vector2d(w.position.x + self.columns, w.position.y), w.orientation) # noinspection PyTypeChecker self.grid.add_widget(WallWidget(w2)) if w.position.y == 0 and w.orientation == Wall.Orientation.horizontal: w2 = Wall(Vector2d(w.position.x, w.position.y + self.rows), w.orientation) # noinspection PyTypeChecker self.grid.add_widget(WallWidget(w2))
def step(self,step): for mobile in self.mobiles: mobile.applyStep(step) grav = self.gravity.copy() grav.mulScalar(mobile.getMass()) #grav.rotate(mobile.getAngle()) mobile.applyForce(step,grav) for mobile2 in self.mobiles: if mobile != mobile2: if mobile.isBound(mobile2.getPosition(),mobile2.getRadius()) == 1: n = Vector2d.normal(mobile2.getPosition(),mobile.getPosition()) vn = Vector2d.dotProduct(mobile.getVelocity(),n) if vn < 0: #mobile.getVelocity().display() #n.display() Mobile.solveCollide(mobile,mobile2) mobile.applyStep(step) mobile2.applyStep(step) for plane in self.planes: #d = plane.distancePoint(mobile.getPosition()) #vn = Vector2d.dotProduct(mobile.getVelocity(),plane.getNormal()) #if d < 0 and vn < 0: # plane.reflective(mobile) for submobile in mobile.getMobiles(): d = plane.distancePoint(submobile.getPhysicalPosition()) vn = Vector2d.dotProduct(submobile.getVelocity(),plane.getNormal()) if d < submobile.getRadius() and vn < 0: #ADDED CONDITION OVER PHYSICAL POINTS if submobile.getUpdatedPhysicalPoints().count > 0: ppcollide = 0 for point in submobile.getUpdatedPhysicalPoints(): if plane.distancePoint(point) < 0: self.groundcollider.collideEvent(point) n = plane.getNormal().copy() n.normalize() n.mulScalar(-plane.distancePoint(point)) #n.display() mobile.getPosition().add(n) mobile.updateMobiles() ppcollide = 1 if ppcollide == 1: plane.reflective(submobile) for submobile2 in mobile.getMobiles(): v = submobile2.getVelocity() v.set(0.0,v.getY()) mobile.angularVelocity = mobile.angularVelocity * 0.8
def make_univer(n_particles=int(10e6)): particles = [] # global box_size max_v = 1 min_v = -1 for i in range(n_particles): if i % (n_particles // 100) == 0: print(i // (n_particles // 100) + 1) particles.append( Particle(r=Vector2d(random.randint(-box_size // 2, box_size // 2), random.randint(-box_size // 2, box_size // 2)), v=Vector2d(random.randint(min_v, max_v), random.randint(min_v, max_v)))) return particles
def create_sphere2(radii, lengths, num_sumples=2000, mass=1): attempts = 100 # particles = [Particle(r=Vector3d(), mass=10)] particles = [] num = 100 for i in range(0, len(lengths) // num): cur_num_particles = 0 while True: u = np.random.uniform(0, 2 * np.pi) tmp_z = np.random.uniform(0, 1) mul = tmp_z**(1 / 3) # mul = (mul * lengths[i*num + num-1]) + (lengths[i*num + num-1] - lengths[i*num]) mul = lengths[i * num] + mul * (lengths[i * num + num - 1] - lengths[i * num]) r1 = radii[0] * mul r2 = radii[1] * mul tmp = [r1 * np.cos(u), r2 * np.sin(u)] if criterion(tmp, particles): [x, y] = [tmp[0], tmp[1]] particles.append(Particle(r=Vector2d(x, y), mass=mass)) cur_num_particles += 1 # if cur_num_particles % 1 == 0: # print(cur_num_particles) if cur_num_particles == num // 10: break return particles
def collides_with(self, entity): retVal = False if self.isVisible and entity.isVisible: myPosition = Vector2d( self.position.x - self.radius, self.position.y - self.radius) entityPosition = Vector2d( entity.position.x - entity.radius, entity.position.y - entity.radius) totalRadiuses = self.radius + entity.radius distance = myPosition - entityPosition if distance.length() < totalRadiuses: retVal = True self.colliding = True return retVal
def calculate_force(self, particle, node=None): if node is None: node = self.root force = Vector2d(0, 0) if len(node.particles) == 0: return force if (node.type == 2) and (node.particles[0] != particle): tmp_f = forces.base_force(particle, node.particles[0]) # print(particle.name, node.name, node.depth, len(node.particles)) force += tmp_f cm = node.get_cm() if (node.type == 1) and (mac.mac(particle, node)): # print(particle.name, node.name) # print(particle.name, node.name, node.depth, len(node.particles)) tmp_f = forces.base_force(particle, Particle(r=cm, v=node.get_mv(), mass=node.mass)) force += tmp_f if (node.type == 1) and not(mac.mac(particle, node)): for child in node.children: force += self.calculate_force(particle, child) return force
def run(self): """Run the solver. This might take some time.""" all_tiles = deque(n for n in self.grid) initial_state = Solver.State(self.tiles, self.edges) self._handle_simple_tiles(initial_state) work_stack = [Solver.WorkItem(initial_state, all_tiles)] while work_stack: item = work_stack.pop() state = item.state work = item.work investigate = self._forward_inference(state, work) if not investigate: continue # Pop next state from stack # Choose tile with least amount of possible orientations left minimum = None min_pos = Vector2d(0, 0) for node in self.grid: orientations = len(state.tiles[node].possible_orientations) if orientations >= 2 and (minimum is None or orientations < minimum): minimum = orientations min_pos = node assert minimum is not None for o in state.tiles[min_pos].possible_orientations: neighbors = deque(self.grid.neighbors(min_pos)) child_state = state.clone() child_state.tiles[min_pos].possible_orientations = [o] self._inspect_tile(min_pos, child_state) # apply this orientation to edges work_stack.append(Solver.WorkItem(child_state, neighbors)) print("Found {} solution(s)".format(len(self.solutions)))
def _inspect_tile(self, node, state): """Inspect a single tile/node and try to reduce the number of possible orientations left by trying one after another. """ tile = state.tiles[node] if len(tile.possible_orientations) <= 0: return len(tile.possible_orientations) tile.possible_orientations = [o for o in tile.possible_orientations if self._valid_orientation(node, o, state)] # noinspection PyTypeChecker for i, d in enumerate(Direction): collected_edges = [] for o in tile.possible_orientations: connectors = tile_connectors[tile.link][o] collected_edges.append(connectors[i]) # Reduce: check all edges are the same, either all True or all False if collected_edges and collected_edges.count(collected_edges[0]) == len(collected_edges): edge_state = collected_edges[0] else: continue child = node + d.vector child = Vector2d(child.x % self.columns, child.y % self.rows) # edge_state is either True or False if state.edges[node, child] is not Edges.State.unknown: assert ((edge_state is True and state.edges[node, child] is Edges.State.present) or (edge_state is False and state.edges[node, child] is Edges.State.absent)) state.edges[node, child] = Edges.State.present if edge_state is True else Edges.State.absent
def criterion(tmp, particles): tmp_particle = Particle(r=Vector2d(*tmp)) for particle in particles: # print((tmp_particle.r - particle.r).dot(forces.base_force(tmp_particle, particle))) # if (tmp_particle.r - particle.r).dot(forces.base_force(tmp_particle, particle)) > -0.3: if abs(tmp_particle.r - particle.r) < 1 * constants.a: return False return True
def main(): print("correct vector:") correct_vector = Vector2d(-6.9, 42) correct_vector.print_vector() print("length:", correct_vector.vector_length()) print() print("multiplied vector:") multiplied_vector1 = correct_vector.multiply_vector(5) multiplied_vector1.print_vector() print() print("vector multiplied by wrong factor:") multiplied_vector2 = correct_vector.multiply_vector('f') multiplied_vector2.print_vector() print() print("vector multiplied by nothing:") multiplied_vector2 = correct_vector.multiply_vector() multiplied_vector2.print_vector() print() print("wrong argument vector:") wrong_argument_vector = Vector2d(-6.9, 'f') wrong_argument_vector.print_vector() print(wrong_argument_vector.vector_length()) print print("not enough arguments vector:") not_enough_arguments_vector = Vector2d(65) not_enough_arguments_vector.print_vector() print(not_enough_arguments_vector.vector_length()) print() print("no arguments vector:") no_arguments_vector = Vector2d() no_arguments_vector.print_vector() print no_arguments_vector.vector_length() print() print("to much arguments vector:") to_much_arguments_vector = Vector2d(2, 3, 4) to_much_arguments_vector.print_vector() print(to_much_arguments_vector.vector_length()) print()
def read(read_path): particles = [] with open(read_path, 'r') as inputfile: s_tmp = inputfile.read() for el in s_tmp.split('\n')[2:]: if el != '': rx, ry, cr, cg, cb = el.split() particles.append(Particle(r=Vector2d(float(rx), float(ry)), name=len(particles))) return particles
def make_hex(k=10, l=10): # k количество рядов до середины # l количество в крайнем ряду particles = [] for i in range(k): for j in range(i + l): particles.append( Particle(r=Vector2d(constants.a * i * math.sqrt(3) / 2, constants.a * j - constants.a * 0.5 * i), v=Vector2d(), name=len(particles))) for i in range(k, 2 * k - 1): for j in range(l + k - 2 - (i - k)): particles.append( Particle(r=Vector2d( constants.a * i * math.sqrt(3) / 2, constants.a * j + constants.a * 0.5 * (i - 2 * k + 2)), v=Vector2d(), name=len(particles))) return particles
def run(self): """Execute the builder :return: The created puzzle :rtype: Puzzle """ self._source = Vector2d(self.columns // 2, self.rows // 2) grid = self._create_tree() walls = self._create_walls() rotated_tiles = self._rotate(grid) return Puzzle(grid, walls, self._source, rotated_tiles, self.wrap)
def isBound(self,point,radius): d = Vector2d.distance(self.position,point) if d < 0: d = -d d = d - radius - self.radius #print "distance: %f\n"%d #d = d - self.radius if d < 0: return 1 else: return 0
def _create_walls(self, percent=0.06, rsd=0.2): """Randomly place some walls The actual number of walls is drawn from a normal distribution. :param float percent: Mean percent of walls to be created :param float rsd: Relative standard deviation """ walls = set() # collect all possible walls for x, y in itertools.product(range(self.columns), range(self.rows)): if (self.wrap or y != 0) and not self._nodes[x, y].edges[Direction.down]: walls.add(Wall(Vector2d(x, y), Wall.Orientation.horizontal)) if (self.wrap or x != 0) and not self._nodes[x, y].edges[Direction.left]: walls.add(Wall(Vector2d(x, y), Wall.Orientation.vertical)) mean = len(walls) * percent count = clamp(int(random.gauss(mean, rsd * mean)), 0, len(walls)) walls = random.sample(walls, count) return walls
def get_and_plot_density(particles, radii, rotation, center, num=100): cm = Vector2d() particles_ = copy.deepcopy(particles) derotation = np.linalg.inv(rotation) for particle in particles_: particle.r.x -= center[0] particle.r.y -= center[1] tmp = np.dot(np.array([particle.r.x, particle.r.y]), derotation) particle.r = Vector2d(tmp[0], tmp[1]) cm += particle.r cm = cm * (1 / len(particles_)) for i in range(len(particles)): particles_[i].r.x *= 1 / radii[0] particles_[i].r.y *= 1 / radii[1] lengths = sorted([abs(particle.r) for particle in particles_]) density = [] l = [] # particles = sorted(particles, key=lambda particle: abs(particle.r - cm)) for i in range(len(lengths) // num): density.append(num * particles_[0].mass / (np.pi * (lengths[i * num + num - 1]**2 - lengths[i * num]**2))) # l.append(lengths[i*num] + 0.5*(lengths[i*num + num-1] - lengths[i*num])) l.append(lengths[i * num]) ig, ax1 = plt.subplots(figsize=(4, 4)) ax1.scatter(x=l, y=density, marker='o', c='r', edgecolor='b') ax1.set_title('Scatter: $x$ versus $y$') ax1.set_xlabel('$x$') ax1.set_ylabel('$y$') plt.show() return density, lengths
def example(cls): """A simple example puzzle""" grid = GridContainer(Grid(3, 3)) grid[0, 2] = Tile(LinkType.dead_end, Direction.down) grid[1, 2] = Tile(LinkType.t_intersection, Direction.right) grid[2, 2] = Tile(LinkType.corner, Direction.left) grid[0, 1] = Tile(LinkType.dead_end, Direction.down) grid[1, 1] = Tile(LinkType.t_intersection, Direction.down) grid[1, 1].entity = EntityType.source grid[2, 1] = Tile(LinkType.straight, Direction.right) grid[0, 0] = Tile(LinkType.dead_end, Direction.down) grid[1, 0] = Tile(LinkType.corner, Direction.up) grid[2, 0] = Tile(LinkType.dead_end, Direction.right) walls = { Wall(Vector2d(0, 2), Wall.Orientation.horizontal), Wall(Vector2d(2, 1), Wall.Orientation.vertical) } return Puzzle(grid, walls, source=Vector2d(1, 1), expected_moves=7, wrap=False)
def _valid_orientation(self, node, orientation, state): """Check if for a given node/tile, the given orientation is possible, i.e. compatible with the surrounding tiles. """ connectors = tile_connectors[state.tiles[node].link][orientation] for d in Direction: child = node + d.vector child = Vector2d(child.x % self.columns, child.y % self.rows) if state.edges[node, child] is Edges.State.unknown: continue elif ((connectors[d.index] is True and state.edges[node, child] is Edges.State.absent) or (connectors[d.index] is False and state.edges[node, child] is Edges.State.present)): return False return True
def applyStep(self,step): v = self.getVelocity() v.set(0.0,0.0) #self.angularVelocity = 0.0 for mobile in self.mobiles: vmobile = mobile.getVelocity().copy() v.add(vmobile) #vmobile = mobile.getVelocity() om = mobile.getPhysicalPosition().copy() om.sub(self.getPosition()) #om.display() vmobile.mulScalar(mobile.getMass()) if om.length() != 0.0 : av = Vector2d.vtangent(om,vmobile) / om.length() av = -av else : av = 0.0 if om.getX() < 0.0: av = -av if vmobile.getY() > 0.0: av = -av #print "ANGULAR VELOCITY AV=%f OM=%f MASS=%f"%(av,om.length(),mobile.getMass()) self.angularVelocity += av * 0.5 v.mulScalar(step) self.getPosition().add(v) #print "ANGULAR VELOCITY=%f"%(self.angularVelocity) self.angle += self.angularVelocity * step*0.001 #self.angularVelocity = self.angularVelocity / 2.0 self.updateMobiles() #print 'TOTO: %d %d'%(self.stablecount,self.stable) #print '%f - %f'%(self.angle,self.oldangle) #print '%d'%int(fabs(self.getPosition().getX()-self.oldposition.getX())) #print '%d - %f - %f'%(int(fabs(self.getPosition().getY()-self.oldposition.getY())),self.getPosition().getY(),self.oldposition.getY()) if int(self.angle) == int(self.oldangle) and int(fabs(self.getPosition().getX()-self.oldposition.getX())) < 1 and int(fabs(self.getPosition().getY()-self.oldposition.getY())) < 1 : self.stablecount += 1 if self.stablecount > 180: self.stable = 1 else : self.stablecount = 0 self.oldposition.set(self.getPosition().getX(),self.getPosition().getY()) self.oldangle = self.angle
def get_vertex(self, x, y=None): """Get a vertex from the polygon, if extant. :param x: x coordinate of the vertex, or optionally a list of coordinates. :keyword y: y coordinate of the vertex. XXX: this is currently very slow! """ if not isinstance(x, Vector2d): x = Vector2d(x, y) for v in self.vertices: if v == x: return v return None
def _create_tree(self): """Create the underlying tree. The algorithm starts with a source in the center and chooses an already visited tile at random to extend the tree to a random unvisited tile. """ self._nodes = GridContainer(Grid(self.columns, self.rows)) nodes = self._nodes # alias for x, y in itertools.product(range(self.columns), range(self.rows)): nodes[x, y] = Builder.Node() visited = GridContainer(Grid(self.columns, self.rows), False) visited[self._source] = True boundary = {self._source} while True: new_boundary = set() moves = [] # [(parent, child, direction), ...] FIXME namedtuple for parent in boundary: for direction in Direction: child = parent + direction.vector if self.wrap: child = Vector2d(child.x % self.columns, child.y % self.rows) if 0 <= child.x < self.columns and 0 <= child.y < self.rows and not visited[ child]: moves.append((parent, child, direction)) new_boundary.add(parent) if not moves: break weights = [] for p, _, d in moves: nodes[p].edges[d] = True link = nodes[p].to_tile().link nodes[p].edges[d] = False weights.append(self.difficulties[self.difficulty][link]) parent, child, direction = weighted_choice(moves, weights) new_boundary.add(child) visited[child] = True nodes[parent].edges[direction] = True nodes[child].edges[-direction] = True boundary = new_boundary # Transform nodes/edges into tiles with link type and orientation tiles = GridContainer(Grid(self.columns, self.rows)) for x, y in itertools.product(range(self.columns), range(self.rows)): tiles[x, y] = nodes[x, y].to_tile() tiles[self._source].entity = EntityType.source return tiles
def check_power(self): """Check which tile is connected to the power source""" power = GridContainer(Grid(self.columns, self.rows), False) work = {self.puzzle.source} while work: parent = work.pop() power[parent] = True for direction in Direction: proto_child = parent + direction.vector if not self.puzzle.wrap and not self.board.grid.valid( proto_child): continue child = Vector2d(proto_child.x % self.columns, proto_child.y % self.rows) # noinspection PyTypeChecker if (not power[child] and self._connected(parent, child, direction) and not self._blocking_wall(parent, proto_child)): work.add(child) for x, y in itertools.product(range(self.columns), range(self.rows)): self.board[x, y].powered = power[x, y]
def main(): from vector2d import Vector2d def f(t, x): return Vector2d(-1.9 * x[0] - 1.7 * x[1], x[0]) t = 0 dt = 0.05 x = Vector2d(20, 10) data1 = [] data2 = [] for i in range(300): t, x = Integrator.rk4(t, dt, x, f) # vel data1.append((t, x[0])) #pos data2.append((t, x[1])) from pylab import plot, show, legend p1, = plot([i for i, j in data1], [j for i, j in data1], 'k--') p2, = plot([i for i, j in data2], [j for i, j in data2], 'k-') legend([p1, p2], ["Velocity", "Position"]) show()
def follow(self,p1): target = p1.getPosition().copy() current = self.screenToWorld(self.screenw/2.0,self.screenh/2.0) distance = Vector2d.distance(target,current) target.sub(current) target.mulScalar(1.0/distance) p = self.screenToWorld(0,0) p2 = self.screenToWorld(self.screenw,self.screenh) x = target.getX() y = target.getY() currentp = self.position.copy() currentp.add(target) if p.getX() < 0.0 and target.getX() < 0.0 : x = 0.0 if p2.getX() > self.screenw and target.getX() > 0.0 : x = 0.0 if p.getY() < 0.0 and target.getY() < 0.0 : y = 0.0 if p2.getY() > self.screenh and target.getY() > 0.0 : y = 0.0 #p2.display() target.set(x,y) self.position.add(target)
def __init__(self, x, y, screen): Vector2d.__init__(self, x, y) self.screen = screen self.screenHalfWidth = screen.get_width() / 2 self.screenHalfHeight = screen.get_height() / 2 self.entity = None
def __init__(self, *args, **kwargs): Vector2d.__init__(self, *args, **kwargs) PointBase.__init__(self)
def distancePoint(self,point): return Vector2d.dotProduct(point,self.normal) + self.distance
def reflective(self,mobile): velocity = mobile.getVelocity() n = self.normal.copy() s = Vector2d.dotProduct(velocity,n) * (1 + 0.0) n.mulScalar(s) velocity.sub(n)
def _handle_boundary(self): """Initialize edges, depending on the 'wrapping' option of the game.""" for x in range(self.columns): self.edges[Vector2d(x, 0), Vector2d(x, self.rows - 1)] = Edges.State.absent for y in range(self.rows): self.edges[Vector2d(0, y), Vector2d(self.columns - 1, y)] = Edges.State.absent