def _update_position(self): """Updates the vertex list""" if not self._visible: self._vertex_list.vertices[:] = [0, 0, 0, 0, 0, 0, 0, 0] return img = self._texture if self.transform_anchor_x == self.transform_anchor_y == 0: if self._rotation: x1 = -self._image_anchor_x * self._scale * self._scale_x y1 = -self._image_anchor_y * self._scale * self._scale_y x2 = x1 + img.width*self._scale*self._scale_x y2 = y1 + img.height*self._scale*self._scale_y x = self._x y = self._y r = -math.radians(self._rotation) cr = math.cos(r) sr = math.sin(r) ax = int(x1*cr - y1*sr + x) ay = int(x1*sr + y1*cr + y) bx = int(x2*cr - y1*sr + x) by = int(x2*sr + y1*cr + y) cx = int(x2*cr - y2*sr + x) cy = int(x2*sr + y2*cr + y) dx = int(x1*cr - y2*sr + x) dy = int(x1*sr + y2*cr + y) self._vertex_list.vertices[:] = [ax, ay, bx, by, cx, cy, dx, dy] elif self._scale != 1.0 or self._scale_x != 1.0 or self._scale_y != 1.0: x1 = int(self._x - self._image_anchor_x*self._scale*self._scale_x) y1 = int(self._y - self._image_anchor_y*self._scale*self._scale_y) x2 = int(x1 + img.width*self._scale*self._scale_x) y2 = int(y1 + img.height*self._scale*self._scale_y) self._vertex_list.vertices[:] = [x1, y1, x2, y1, x2, y2, x1, y2] else: x1 = int(self._x - self._image_anchor_x) y1 = int(self._y - self._image_anchor_y) x2 = x1 + img.width y2 = y1 + img.height self._vertex_list.vertices[:] = [x1, y1, x2, y1, x2, y2, x1, y2] else: x1 = int(-self._image_anchor_x) y1 = int(-self._image_anchor_y) x2 = x1 + img.width y2 = y1 + img.height m = self.get_local_transform() p1 = m * euclid.Point2(x1, y1) p2 = m * euclid.Point2(x2, y1) p3 = m * euclid.Point2(x2, y2) p4 = m * euclid.Point2(x1, y2) self._vertex_list.vertices[:] = [ int(p1.x), int(p1.y), int(p2.x), int(p2.y), int(p3.x), int(p3.y), int(p4.x), int(p4.y)]
def generate_control_points(self): if self.editable_skeleton: skinpos = euclid.Point2(*self.editable_skin.position) for cp in self.editable_skeleton.get_control_points(): if isinstance(cp, Skeleton): self.add(SkeletonControl(cp, skinpos)) else: self.add(BoneControl(cp, skinpos))
def point_to_local(self, p): '''returns an euclid.Vector2 converted to local space :rtype: euclid.Vector2 ''' v = euclid.Point2(p[0], p[1]) matrix = self.get_world_inverse() return matrix * v
def update(self, dt): if self.planet is not None: super(Player, self).update(dt) gx = 20 * math.cos(self.angle) gy = 20 * math.sin(self.angle) self.particles.gravity = eu.Point2(gx, -gy) else: self.position += self.direction * dt
def point_to_world(self, p): '''returns an euclid.Vector2 converted to world space :rtype: euclid.Vector2 ''' v = euclid.Point2(p[0], p[1]) matrix = self.get_world_transform() return matrix * v
def __init__(self, label, size, rotation, translation): self.size = size self.label = label self.children = [] self.matrix = euclid.Matrix3.new_translate(*translation) * \ euclid.Matrix3.new_rotate(math.radians(rotation)) self.parent_matrix = euclid.Matrix3.new_identity() self.translation = euclid.Point2(*translation) self.rotation = math.radians(rotation)
def test_add(self): a = (3.0, 7.0) b = (1.0, 2.0) va = eu.Vector2(*a) vb = eu.Vector2(*b) self.assertTrue(isinstance(va + vb, eu.Vector2)) self.assertEqual(repr(va + vb), 'Vector2(%.2f, %.2f)' % (4.0, 9.0)) c = (11.0, 17.0) pc = eu.Point2(*c) d = (13.0, 23.0) pd = eu.Point2(*d) self.assertTrue(isinstance(va + pc, eu.Point2)) self.assertTrue(isinstance(pc + pd, eu.Vector2)) self.assertTrue(isinstance(va + b, eu.Vector2)) self.assertEqual(va + vb, va + b)
def on_dragged(self, dx, dy): super(BoneControl, self).on_dragged(dx, dy) def angle_between(v1, v2): v1 = v1.normalized() v2 = v2.normalized() a1 = v2a(*v1) a2 = v2a(*v2) return a2 - a1 o = self.bone.get_start() e = self.bone.get_end() ne = euclid.Point2(self.x + dx - self.delta[0], self.y + dy - self.delta[1]) v1 = euclid.Point2(*(e - o)) v2 = euclid.Point2(*(ne - o)) alpha = angle_between(v1, v2) self.bone.rotate(alpha)
def __init__(self): super(Pipes, self).__init__() self.winow_width, self.window_height = director.get_window_size() self.image = pyglet.resource.image('pipe.png') self.speedX = -100 self.pos = eu.Point2(self.winow_width + self.image.width, self.window_height / 2) self.update_collision_box()
def point_to_local(self, p): """returns an :class:`.euclid.Vector2` converted to local space. Arguments: p (Vector2): Vector to convert. Returns: Vector2: ``p`` vector converted to local coordinates. """ v = euclid.Point2(p[0], p[1]) matrix = self.get_world_inverse() return matrix * v
def point_to_world(self, p): """Returns an :class:`.euclid.Vector2` converted to world space. Arguments: p (Vector2): Vector to convert Returns: Vector2: ``p`` vector converted to world coordinates. """ v = euclid.Point2(p[0], p[1]) matrix = self.get_world_transform() return matrix * v
def __init__(self): super(Bird, self).__init__() width, height = director.get_window_size() self.image = pyglet.resource.image('bird1.png') self.top_of_screen = height self.gravity = -300 self.speedY = 0.0 self.pos = eu.Point2(width / 2 - 30, height / 2) self.radius = 2 self.update_collision_box()
def generate_control_points(self): skinpos = euclid.Point2(*self.skin.position) for cp in self.skeleton.get_control_points(): if isinstance(cp, Skeleton): self.add(SkeletonControl(cp, skinpos), z=3) else: self.add(BoneControl(cp, skinpos), z=4) bones = self.skeleton.visit_children(lambda bone: (bone.label, bone)) bones = dict(bones) for bone in bones.values(): self.add(BonePositionControl(bone, skinpos), z=2) for idx, name in self.skin.get_control_points(): self.add(SkinControl(self.skin, idx, bones[name], skinpos), z=5)
def test_swizzle_get(self): xy = (1.0, 2.0) v2 = eu.Point2(*xy) self.assertEqual(v2.x, xy[0]) self.assertEqual(v2.y, xy[1]) self.assertEqual(v2.xy, xy) self.assertEqual(v2.yx, (xy[1], xy[0])) exception = None try: v2.z == 11.0 except Exception as a: exception = a assert isinstance(exception, AttributeError)
def set_end_pos(self, position): position = self.get_world_inverse() * euclid.Point2(position[0], position[1]) if self.end_square is None: self.end_square = cocos.layer.ColorLayer( 200, 0, 0, 255, g_grid_size * g_player_size, g_grid_size * g_player_size) self.add(self.end_square) # align to grid aligned_pos = self.world_to_aligned_world(position) if aligned_pos != self.end_square.position: self.end_square.position = aligned_pos self.update_path()
class Trail(particle_systems.Explosion): # customise an Explosion particle system to emit sparks angle = 180 angle_var = 5 speed = 250 speed_var = 50 gravity = euclid.Point2(0, 0) duration = 1. start_color = particle.Color(1, 1, 1, .5) start_color_var = particle.Color(0, 0, 0, 0.0) end_color = particle.Color(1.0, 1.0, 1.0, 0.0) end_color_var = particle.Color(0, 0, 0, 0) emission_rate = 20 size = 10 size_var = 5
def blit_image(self, matrix, position, scale, image): x, y = image.width*scale, image.height*scale #dx = self.x + position[0] #dy = self.y + position[1] dx, dy = position glEnable(image.target) glBindTexture(image.target, image.id) glPushAttrib(GL_COLOR_BUFFER_BIT) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) # blit img points = [ (-dx, -dy), (x-dx, -dy), (x-dx, y-dy), (-dx, y-dy) ] a,b,_,c,d,_,e,f,_,g,h,_ = image.texture.tex_coords textures = [ a,b,c,d,e,f,g,h ] np = [ matrix*euclid.Point2(*p) for p in points ] glColor4ub(255,255,255,self.alpha) glBegin(GL_QUADS) glTexCoord2f(a,b) glVertex2f(*np[0]) glTexCoord2f(c,d) glVertex2f(*np[1]) glTexCoord2f(e,f) glVertex2f(*np[2]) glTexCoord2f(g,h) glVertex2f(*np[3]) glEnd() glColor4ub(255,255,255,255) #pyglet.graphics.draw(4, GL_QUADS, # ("v2f", new_points), # ("t2f", textures), # ("c4B", [255,255,255,self.alpha]*4), # ) glPopAttrib() glDisable(image.target)
class ActorExplosion(ps.ParticleSystem): total_particles = 400 duration = 0.1 gravity = eu.Point2(0, 0) angle = 90.0 angle_var = 360.0 speed = 40.0 speed_var = 20.0 life = 3.0 life_var = 1.5 emission_rate = total_particles / duration start_color_var = ps.Color(0.0, 0.0, 0.0, 0.2) end_color = ps.Color(0.0, 0.0, 0.0, 1.0) end_color_var = ps.Color(0.0, 0.0, 0.0, 0.0) size = 15.0 size_var = 10.0 blend_additive = True def __init__(self, pos, particles): super(ActorExplosion, self).__init__() self.position = pos self.start_color = particles.start_color
def get_start(self): return self.parent_matrix * self.matrix * euclid.Point2(0, 0)
def get_end(self): return self.parent_matrix * self.matrix * euclid.Point2(0, -self.size)
def toggle_grid_obstacle(self, position): position = self.get_world_inverse() * euclid.Point2(position[0], position[1]) # Toggle this obstacle self.set_grid_obstructed(position, not self.get_grid_obstacle(position))
def __init__(self, bone, delta): super(BoneControl, self).__init__(7, (255, 0, 0, 255)) self.bone = bone self.position = bone.get_end() + euclid.Point2(*delta) self.delta = delta
def move_from_left_corner_to_out_of_screen(self, sprite): destination = eu.Point2(-sprite.width, 0) action_move = MoveTo(destination, self.get_time() * 3) # sprite.do(sequence(action_move, CallFunc(self.keep_going()))) sprite.do(action_move)
def move_from_corner_right_to_center(self, sprite): destination = eu.Point2(0, 0) action_move = MoveTo(destination, self.get_time() * 3) sprite.do(action_move)
def switch(self): new_dir = eu.Vector2(self.y - self.planet.y, self.planet.x - self.x) self.direction = new_dir.normalized() * self.linear_speed self.planet = None self.particles.gravity = eu.Point2(-self.direction.x, -self.direction.y)