def __init__(self, surface, pos, vel, gravity, container, color='red'): """ surface : Surface : The Surface to draw on. pos : (x,y) : tuple\list x,y position at time of creation. vel : (x,y) : tuple\list x,y velocity at time of creation. gravity : (x,y) : tuple\list x,y gravity effecting the particle. container : list : The passed in list that contains all the particles to draw. Used so particles can be deleted. color : str : String color value, default 'red'. """ self.surface = surface self.pos = Vec2d(pos) vel = [vel[0]+random.uniform(-3,3), vel[1]+random.uniform(-3,3)] self.vel = Vec2d(vel) # Clamp any huge velocities: if self.vel.length > 10: self.vel.length = 10 self.gravity = Vec2d(gravity) self.container = container self.color = Color(color) self.radius = random.randint(4,16) self.connectDist = self.radius * 4 self.surfSize = surface.get_size() self.drag = .9 # This is updated each frame with a list of all other particles connected # to, which helps to define if lines should be drawn. self.connections = []
def updatePosition(self, add_to_trail=False): if USE_WEBCAM: self.position = Vec2d(webcam.findPlayer(self)) self.surface_position = (int(self.position.x - PLAYER_RADIUS), int(self.position.y - PLAYER_RADIUS)) self.surface.fill(CLEAR_COLOR) pygame.draw.circle(self.surface, GAME_BACKGROUNG_COLOR, (PLAYER_RADIUS, PLAYER_RADIUS), PLAYER_RADIUS) circle_color = self.temp_color if self.temp_color else self.color.value pygame.draw.circle(self.surface, circle_color, (PLAYER_RADIUS, PLAYER_RADIUS), PLAYER_RADIUS, PLAYER_BORDER_WIDTH) distance_from_last_point = 0 if self.last_position is not None: delta = self.position - self.last_position distance_from_last_point = delta.get_length() if self.creating_hole: self.hole_length_remaining -= distance_from_last_point if self.hole_length_remaining <= 0: self.creating_hole = False self.resetTimeToNextHole() distance_from_last_point = 0 if add_to_trail: self.trail.addPoint(Vec2d(self.position), self.creating_hole, distance_from_last_point) self.last_position = Vec2d(self.position)
def render(self): # for smooth rendering # draw ships for ship in self.ships: ship.sprite.position = ship.position * 8 + Vec2d(4, 4) ship.sprite.draw() gl.glColor3f(1, 1, 0) # draw explosions TODO: Animate! for explosion in self.explosions: gl.glPointSize(8.0) pyglet.graphics.draw( 1, pyglet.gl.GL_POINTS, ('v2i', (explosion.x * 8 + 4, explosion.y * 8 + 4)) ) laser_points = [] # draw laser lines for shot in self.shots: startpos = shot.owner.position * 8 + Vec2d(4, 4) laser_points.append(startpos.x) laser_points.append(startpos.y) laser_points.append(shot.position.x * 8 + 4) laser_points.append(shot.position.y * 8 + 4) gl.glColor3f(1, 0, 0) pyglet.graphics.draw( len(self.shots) * 2, pyglet.gl.GL_LINES, ('v2i', laser_points) )
def __init__(self, lvlMgr, type=0, pos=Vec2d(0, 0)): self.lvlMgr = lvlMgr self.entType = 1 #This is a projectile self.type = type #0, 1, 2 = Rocket, Grenade, Homing self.pos = pos self.width = 16 #TEMP values based off type of projectile self.height = 19 #TEMP self.originPoint = Vec2d(self.width / 2, self.height) self.lifespan = 200 #Time until it just times out self.toRemove = False #Physics handler component self.physComp = PhysComp(self, self.width, self.height) #Rendering handler component if self.type == 0: self.drawComp = DrawComp(self, "projectile1.png", self.width, self.height) elif self.type == 1: self.drawComp = DrawComp(self, "projectile2.png", self.width, self.height) elif self.type == 2: self.drawComp = DrawComp(self, "projectile3.png", self.width, self.height) #Spawn the projectile self.physComp.setPos(self.pos)
def tick(self, time, global_robots): movement = Vec2d(0, 0) if self.target is not None: self.speed = 1 if self.position.get_distance(self.target) < 10: self.seek_target = False self.direction = Vec2d(0, 0) self.target = None else: self.seek_target = True self.direction = (self.target - self.position).normalized() robots = filter(lambda x: id(x) != id(self), global_robots) self.local_robots = map(self.transform_to_local, robots) collisions = [ i for i in self.local_robots if -20 < i.position.x < 20 and 0 < i.position.y < 120 ] if collisions: self.collision = True self.speed = 0.5 closest = min(collisions, key=lambda x: x.position.length) if closest.position.x > 0: self.direction.rotate(20) else: self.direction.rotate(-20) else: self.collision = False movement += self.direction self.position += time * (movement * self.speed) * 0.1
def draw_explosion(obj, _, t): if obj['id'] not in explosions: x = obj['x'] y = obj['y'] dx = obj['dx'] dy = obj['dy'] lines = [] for line in xrange(0, 5 + random.randint(0, 5)): lines.append(( Vec2d(x, y), Vec2d(dx + random.random() - 0.5, dy + random.random() - 0.5) * 0.7, 2 * pi * random.random(), # rotation (random.random() - 0.5) * 0.1, # rotation speed random.random() * 6, -random.random() * 6, t # start time )) explosions[obj['id']] = { 'start': t, 'lines': lines, } for startpos, vel, r, dr, a, b, t0 in explosions[obj['id']]['lines']: dt = t - t0 line = Vec2d(cos(r + dr * dt), sin(r + dr * dt)) pos = startpos + vel * dt for piece in a, b: pygame.draw.line(screen, (194, 205, 0), screen_coord(pos), screen_coord(pos + piece * line))
def action(self): self.move_counter += 1 if self.next_target: # intensify forward firepower possible = [ self.next_target + Vec2d(1, 0), self.next_target + Vec2d(-1, 0), self.next_target + Vec2d(0, 1), self.next_target + Vec2d(0, -1) ] # TODO: expose in_range for later use possible = [p for p in possible if self.in_range(p)] self.next_target = None # we always want to check if we killed if not possible: return random.choice(list(Move)) return Shot(random.choice(possible), self) # No targets? Scan for them. And spin in circles. if self.move_counter < self.diameter: return Scan.SCAN else: self.move_counter = 0 d = self.movement_queue[0] self.movement_queue.remove(d) self.movement_queue.append(d) return d
def __init__(self, owner, width, height): self.owner = owner self.pos = Vec2d(0,0) self.vel = Vec2d(0,0) self.force = Vec2d(0,0) self.width = width self.height = height
def testSub(): a = Vec2d(x=3, y=3) b = Vec2d(x=1, y=1) c = a - b assert c.x == 2 assert c.y == 2 assert isinstance(c, Vec2d)
def __init__(self, pos, mass, scale): # Call the parent class (Sprite) constructor super().__init__() # Position vector self.pos = pos # Velocity vector, y-value is set to 150 self.vel = Vec2d(0, 150) # Object mass self.mass = mass # Momentum vector self.mom = self.vel * self.mass # Force vector, y-value is a random integer from 50 to 500 self.force = Vec2d(0, random.randrange(50, 250)) # Image scale self.scale = scale # Image filename self.filename = "" # Load the image of the asparagus and draw the image self.set_image() # Fetch the rectangle object that has the dimensions of the image self.rect = self.image.get_rect()
def __init__(self, pos, mass, scale): # Call the parent class (Sprite) constructor super().__init__() # Position vector self.pos = pos # Velocity vector, y-value is set to 100 self.vel = Vec2d(0, 100) # Object mass self.mass = mass # Momentum vector self.mom = self.vel * self.mass # No force, asparagi moves with constant velocity self.force = Vec2d(0, 0) # Image scale self.scale = scale # Image filename self.filename = "" # Load the image of the asparagus and draw the image self.set_image() # Fetch the rectangle object that has the dimensions of the image self.rect = self.image.get_rect()
def integrator(): pos = pos_at_t0 ang = ang_at_t0 vel = vel_at_t0 if dt > 1000: print 'Bailing out from integration -- too far ahead' return pos, ang for i in xrange(dt): if engine_on: vel += 0.001 * Vec2d(cos(ang), sin(ang)) damp = 0.999 vel *= damp pos += vel ang += dang def bind(value, length): return (length * 1.5 + value % length) % length - length / 2 bound_pos = Vec2d(bind(pos[0], game.board_width), bind(pos[1], game.board_height)) return bound_pos, ang
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) shots = [] for i in range(30): x, y = Vec2d(0, 5).rotated(12 * i) shots.append(Vec2d(int(x), int(y))) self.shots = deque(shots) self.shots.rotate(random.randint(-12, 12))
def reset_pos(self, screen_width): # Reset sprite's position self.rect.y = random.randrange(-300, -40) self.rect.x = random.randrange(0, screen_width - 10) # Reset the object's position and momentum self.pos = Vec2d(self.rect.x, self.rect.y) self.vel = Vec2d(0, random.randrange(150, 200)) self.mom = Vec2d(0, 0)
def line(self, color, start, end, thickness): if thickness != 1: return pygame.draw.line(self.screen, color, start + Vec2d(self.offset, 0), end + Vec2d(self.offset, 0), thickness) else: return pygame.draw.aaline(self.screen, color, start + Vec2d(self.offset, 0), end + Vec2D(self.offset, 0))
def make_polygon(radius, n, angle=0, factor=1, axis=Vec2d(1,0)): axis = axis.normalized() vec = Vec2d(0, -radius).rotated(180/n+angle) p = [] for i in range(n): v = vec.rotated(360*i/n) v += v.dot(axis)*(factor-1)*axis p.append(v) return p
def _velocity_and_direction(ship): if ship.direction == Move.UP: return Vec2d(0, 1), 0 elif ship.direction == Move.DOWN: return Vec2d(0, -1), 180 elif ship.direction == Move.RIGHT: return Vec2d(1, 0), 90 elif ship.direction == Move.LEFT: return Vec2d(-1, 0), -90
def setEndpoints(self): x1 = self.center.x + self.length * math.cos(self.angle) x2 = self.center.x - self.length * math.cos(self.angle) y1 = self.center.y + self.length * math.sin(self.angle) y2 = self.center.y - self.length * math.sin(self.angle) self.end1 = Vec2d(x1, y1) self.end2 = Vec2d(x2, y2) dx = x2 - x1 dy = y2 - y1 self.normal = Vec2d(dy, -dx).normalized()
def __init__(self, center, angle, length, thickness): Matter.__init__(self, 2000000, center, Vec2d(0, 0)) self.angle = math.radians(angle) self.thickness = thickness self.length = length self.color = WHITE self.end1 = Vec2d(0, 0) self.end2 = Vec2d(0, 0) self.normal = Vec2d(0, 0) self.setEndpoints()
def calculateCOMVel(planets): if (len(planets) == 0): return Vec2d(0, 0) else: totalMass = 0 massVel = Vec2d(0, 0) for planet in planets: totalMass += planet.mass massVel += planet.mass * planet.vel return massVel / totalMass
def calculateCOM(planets): if (len(planets) == 0): return Vec2d(0, 0) else: totalMass = 0 massPos = Vec2d(0, 0) for planet in planets: totalMass += planet.mass massPos += planet.mass * planet.center return massPos / totalMass
def _randomize_players_positions_and_direction_vectors(self): for player in self.players: MARGIN_FACTOR = 5 WIDTH_MARGIN = GAME_WIDTH / MARGIN_FACTOR HIGHT_MARGIN = GAME_HIGHT / MARGIN_FACTOR x = random.randrange(WIDTH_MARGIN, GAME_WIDTH - WIDTH_MARGIN) y = random.randrange(HIGHT_MARGIN, GAME_HIGHT - HIGHT_MARGIN) direction_vector = Vec2d(1, 0) direction_vector.rotate(random.randrange(0, 360)) player._set_position_and_direction_vector(Vec2d(x, y), direction_vector)
def __init__(self, scr, net): self.scr = scr self.sizex, self.sizey = 10, 10 self.map = [[0 for ii in range(4)] for i in range(4)] self.players = [ (Vec2d(10, 10)), (Vec2d(15, 15)), (Vec2d(5, 5)), (Vec2d(120, 120)) ] self.net = net self.net.subscribeChanges(self.netChanges)
def __init__(self, pos, normal, color, mass=1e99, vel=Vec2d(0, 0)): self.pos = pos.copy() self.normal = normal.normalized() # makes a copy automatically self.pos = pos.copy() self.vel = vel.copy() self.mass = mass self.mom = self.vel * self.mass self.color = color self.force = Vec2d(0, 0) self.type = "wall"
def testRotate(): a = Vec2d(x=1, y=0) b = a.rotate(radians(90)) assert areVecEqual(b, Vec2d(0, -1)) c = b.rotate(radians(90)) assert areVecEqual(c, Vec2d(x=-1, y=0)) d = c.rotate(radians(90)) assert areVecEqual(d, Vec2d(x=0, y=1)) e = d.rotate(radians(90)) assert areVecEqual(a, e)
def __init__(self, game): self.game = game self.arrow_positions = ( (Vec2d(149, 224), self.handleNewGame), (Vec2d(154, 125), self.handleContinue), ) self.arrow_position = 0 self.title_pos = Vec2d(46, 364) self.lem_pos = Vec2d(506, 0)
def fling(self, target): if target is None: target = Vec2d(self.fling_object.location) else: target = Vec2d(target) force = (target - self.fling_object.location)/config.object.force_division_factor if force.length >= config.object.max_force: force.length = config.object.max_force self.fling_object.fling(force) music.play_whip() self.fling_object = None
def tallJump(self): if self.amountMoved < self.moveLimit: if not self.falling: self.falling = True self.physComp.setVel(Vec2d(0,0)) if self.direction == Globals.LEFT: self.physComp.addForce(Vec2d(-2000,-12000)) self.amountMoved += 1 else: self.physComp.addForce(Vec2d(2000,-12000)) self.amountMoved += 1
def playerCollidesWithOtherPlayer(self, player, other_player): player_mask = pygame.mask.from_surface(player.surface) other_player_mask = pygame.mask.from_surface(other_player.surface) other_player_offset = Vec2d(other_player.surface_position) - Vec2d(player.surface_position) overlap_point = player_mask.overlap(other_player_mask, other_player_offset) if overlap_point is None: return False else: return True
def playerCollidesWithBonus(self, player, bonus): bonus_mask = pygame.mask.from_surface(bonus.surface) player_mask = pygame.mask.from_surface(player.surface) bonus_offset = Vec2d(bonus.position) - Vec2d(player.surface_position) overlap_point = player_mask.overlap(bonus_mask, bonus_offset) if overlap_point is None: return False else: return True
def intersects_side(self, ax, ay, bx, by): VIEWLENGTH = 1 p = Vec2d(ax, ay) r = Vec2d(bx-ax, by-ay) q = Vec2d(self.x, self.y) s = Vec2d(VIEWLENGTH*math.sin(self.angle), VIEWLENGTH*math.cos(self.angle)) #make_dot(self.canvas, p) #make_dot(self.canvas, q) #make_dot(self.canvas, r) #make_dot(self.canvas, s) # note: division by zero if parallel: r x s = 0 denom = Vec2d.cross(r, s) if denom == 0: return None t = Vec2d.cross((q - p), s) / denom u = Vec2d.cross((q - p), r) / denom if u < 0: return None if 0 < t < 1: result = p + t*r return result, u
def __init__(self, x=0, y=0, angle=0): Vec2d.__init__(self, x, y) self._angle = angle
def __init__(self, x=0, y=-500): Vec2d.__init__(self, x, y) self.accDif = 0 self.lockCoef = 0
def __init__(self, x=0, y=0, maxrps=21): Vec2d.__init__(self, x, y) self._rps = 0 self.maxrps = maxrps