コード例 #1
0
ファイル: game.py プロジェクト: andrewrk/MonsterMechanics
    def __init__(self, width=853, height=480, show_fps=False):
        self.size = v(width, height)
        self.show_fps = show_fps

        self.next_group_num = 0

        self.controls = {
            key.LEFT: Control.MoveLeft,
            key.RIGHT: Control.MoveRight,
            key.UP: Control.MoveUp,
            key.DOWN: Control.MoveDown,
            key.SPACE: Control.Attack,

            key._1: Control.Rotate1,
            key._2: Control.Rotate2,
            key._3: Control.Rotate3,
            key._4: Control.Rotate4,
            key._5: Control.Rotate5,
            key._6: Control.Rotate6,
        }

        self.control_state = [False] * (len(dir(Control)) - 2)
        self.scroll = v(0,0)
        self.filename = None
        self.enemy = None
        self.enemy_number = 1
        self.level = 1
        self.own_enemies = False
        self.camera = None
        self.message = None

        self.timers = []
コード例 #2
0
ファイル: threed.py プロジェクト: viron11111/software-common
 def __init__(self, world, space, pos, color, capsules, radius, mass=2, fixed=False, orientation=v(1, 0, 0, 0)):
     "capsules is a list of (start, end) points"
     
     self.capsules = capsules
     
     self.body = ode.Body(world)
     self.body.setPosition(pos)
     self.body.setQuaternion(orientation)
     m = ode.Mass()
     # computing MOI assuming sphere with .5 m radius
     m.setSphere(mass/(4/3*math.pi*.5**3), .5) # setSphereTotal is broken
     self.body.setMass(m)
     
     self.geoms = []
     self.geoms2 = []
     for start, end in capsules:
         self.geoms.append(ode.GeomTransform(space))
         x = ode.GeomCapsule(None, radius, (end-start).mag())
         self.geoms2.append(x)
         self.geoms[-1].setGeom(x)
         self.geoms[-1].setBody(self.body)
         x.setPosition((start+end)/2 + v(random.gauss(0, .01), random.gauss(0, .01), random.gauss(0, .01)))
         a = (end - start).unit()
         b = v(0, 0, 1)
         x.setQuaternion(vector.axisangle_to_quat((a%b).unit(), -math.acos(a*b)))
     
     self.color = color
     self.radius = radius
     
     if fixed:
         self.joint = ode.FixedJoint(world)
         self.joint.attach(self.body, None)
         self.joint.setFixed()
コード例 #3
0
 def __init__(self, world, jointdef, body1, body2):
     self.jointdef = jointdef
     self.world = world
     self.joint = self.make_joint(jointdef)
     self.body1 = body1
     self.body2 = body2
     self.b1_anchor = v(*self.jointdef.localAnchor1) / body1.scale
     self.b2_anchor = v(*self.jointdef.localAnchor2) / body2.scale
コード例 #4
0
ファイル: geom.py プロジェクト: andrewrk/MonsterMechanics
    def union(self, ano):
        l, t = self.tl
        al, at = ano.tl

        r, b = self.br
        ar, ab = ano.br

        return Rect(v(min(l, al), max(t, at)), v(max(r, ar), min(b, ab)))
コード例 #5
0
ファイル: hud.py プロジェクト: andrewrk/MonsterMechanics
 def draw_level(self, pos):
     p = pos
     for i in range(self.part.level):
         self.star.blit(*p)
         p += v(self.star.width, 0)
     if self.part.can_upgrade():
         p = pos + v(self.healthbar_empty.width - self.upgrade_button.width, 0)
         self.upgrade_button.blit(*p)
         self.upgrade_button_rect = Rect(p + v(0, self.upgrade_button.height), p + v(self.upgrade_button.width, 0))
コード例 #6
0
ファイル: hud.py プロジェクト: andrewrk/MonsterMechanics
    def __init__(self, world, monster, camera):
        self.world = world
        self.monster = monster
        self.camera = camera
        self.icons = {}
        self.init_icons()
        self.scroll_y = 0
        self.mousedown = False
        self.parthud = None

        self.mutagen_count = Digits(v(20, 410), anchor=Digits.ANCHOR_LEFT)
        self.cost_display = Digits(v(200, 410), anchor=Digits.ANCHOR_LEFT)
        self.cost_value = None
コード例 #7
0
ファイル: monster.py プロジェクト: andrewrk/MonsterMechanics
 def get_bounds(self):
     ang = self.sprite.rotation * math.pi / 180
     bounds = None
     basepos = v(*self.sprite.position)
     for s in self.get_shapes():
         center = v(*s.center)
         center = center.rotated(ang) + basepos
         diag = v(-s.radius, s.radius)
         sbounds = Rect(center + diag, center - diag)
         if bounds is None:
             bounds = sbounds
         else:
             bounds = bounds.union(sbounds)
     return bounds
コード例 #8
0
ファイル: actor.py プロジェクト: italomaia/turtle-linux
 def __init__(self, world, pos=(0,0), radius=50, bearing=0, image_file=None, name=None, **kwargs):
     self.world = world
     self.pos = v(pos)
     self.old_pos = v(pos)
     self.radius = radius
     self.bearing = bearing
     self.old_bearing = bearing
     self.image_file = image_file
     self.image = squirtle.SVG(data.file_path(image_file), anchor_x='center', anchor_y='center')
     self.dead = False
     self.impulse = v((0,0))
     self.name = name
     # do not use
     self.scale = 0.0
     self.z = 0
コード例 #9
0
ファイル: hud.py プロジェクト: andrewrk/MonsterMechanics
    def load(cls):
        PartHud.load()
        Digits.load()
        imgs = {}
        for icon in ICONS:
            img = pyglet.resource.image(icon.sprite)
            img.anchor_x = 90 - ICON_HALF
            img.anchor_y = ICON_HALF
            imgs[icon.name] = img

        cls.mutagen_label = pyglet.sprite.Sprite(pyglet.resource.image("ui/mutagen.png"))
        cls.cost_label = pyglet.sprite.Sprite(pyglet.resource.image("ui/cost.png"))
        cls.mutagen_label.position = v(20, 440)
        cls.cost_label.position = v(200, 443)
        cls.images = imgs
コード例 #10
0
ファイル: actor.py プロジェクト: italomaia/turtle-linux
    def tick(self):
        # objects by default continue to move in a straight line (see Newton)
        delta = self.pos - self.old_pos
        self.old_pos = self.pos
        dtheta = self.bearing - self.old_bearing
        self.old_bearing = self.bearing
        self.bearing += dtheta * ANGULAR_DRAG
        real_old_pos = self.old_pos
        
        # add drag forces to delta
        drag = delta * -delta.length * self.radius * self.world.drag
        delta += drag
        
        # add other accumulated forces to delta
        delta += self.impulse
        self.impulse = v((0,0))
        
        if not self.collides:

            self.pos += delta
        
        else:
        
            steps = 1 + int(1.05 * delta.length / self.radius)
            sub_delta = delta / steps
            
            for ii in xrange(steps):
            
                self.pos += sub_delta
                
                original_pos = self.pos
                check_collisions = True
                tries = 0
                while check_collisions:
                
                    check_collisions = False
                    tries += 1
                    if tries > 200:
                        # this is a problem, so rather than take the game down, we do something which just
                        # looks bad
                        self.pos = original_pos
                        return

                    for wall in self.world.static.overlaps(self):
                        cp = wall.closest_point(self.pos)
                        approach = (self.pos - cp)
                        if approach.length < self.radius - EPSILON:
                            self.pos = cp + approach.normalised() * self.radius
                            check_collisions = True

                # now, the actor is definitely in a safe place
                # work backwards to work out its eventual reflection and update old_pos to make it bounce
                
                displacement = self.pos - original_pos
                if displacement.length > 0:
                    mirror_point = original_pos + displacement * 0.5
                    mirror_line = Line(displacement.normalised(), mirror_point * displacement.normalised())
                    self.old_pos = mirror_line.reflect(self.old_pos)
                    sub_delta = mirror_line.parallel_through_origin.reflect(sub_delta)
                    self.old_pos = self.pos + (self.old_pos - self.pos) * ELASTICITY
コード例 #11
0
    def __init__(self,
                 world,
                 space,
                 pos,
                 color,
                 capsules,
                 radius,
                 mass=2,
                 fixed=False,
                 orientation=v(1, 0, 0, 0)):
        "capsules is a list of (start, end) points"

        self.capsules = capsules

        self.body = ode.Body(world)
        self.body.setPosition(pos)
        self.body.setQuaternion(orientation)
        m = ode.Mass()
        # computing MOI assuming sphere with .5 m radius
        m.setSphere(mass / (4 / 3 * math.pi * .5**3),
                    .5)  # setSphereTotal is broken
        self.body.setMass(m)

        self.geoms = []
        self.geoms2 = []
        for start, end in capsules:
            self.geoms.append(ode.GeomTransform(space))
            x = ode.GeomCapsule(None, radius, (end - start).mag())
            self.geoms2.append(x)
            self.geoms[-1].setGeom(x)
            self.geoms[-1].setBody(self.body)
            x.setPosition((start + end) / 2 + v(random.gauss(
                0, .01), random.gauss(0, .01), random.gauss(0, .01)))
            a = (end - start).unit()
            b = v(0, 0, 1)
            x.setQuaternion(
                vector.axisangle_to_quat((a % b).unit(), -math.acos(a * b)))

        self.color = color
        self.radius = radius

        if fixed:
            self.joint = ode.FixedJoint(world)
            self.joint.attach(self.body, None)
            self.joint.setFixed()
コード例 #12
0
 def make_projectile(self, world, pos, bearing):
     p = Projectile(world,
                    pos=pos,
                    radius=self.projectile_radius,
                    bearing=bearing,
                    image_file=self.projectile_image)
     d = (random.random() - 0.5) * self.scatter
     p.apply_impulse(v((self.muzzle_velocity, d)).rotated(bearing))
     p.force = self.projectile_force
     return p
コード例 #13
0
ファイル: hud.py プロジェクト: andrewrk/MonsterMechanics
    def draw(self, camera):
        frac = min(1, float(self.part.health) / self.part.get_max_health())

        pos = self.part.get_position() + v(0, self.part.get_base_shape().radius)
        pos = camera.world_to_screen(pos)
        pos = v(int(pos.x + 0.5), int(pos.y + 0.5))

        gl.glEnable(gl.GL_BLEND)
        gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
        w = self.healthbar_empty.width
        h = self.healthbar_empty.height

        p = pos - v(w / 2, 0)
        self.healthbar_empty.blit(*p)

        fillw = frac * w
        fill = self.healthbar_full.get_region(0, 0, fillw, h)
        fill.blit(*p)
        if hasattr(self.part, "level"):
            self.draw_level(p + v(0, 20))
コード例 #14
0
ファイル: actor.py プロジェクト: andrewrk/MonsterMechanics
def load_resource(resource_file):
    with pyglet.resource.file('components/%s.json' % resource_file) as f:
        definition = json.loads(f.read())

    # load the associated image
    img = pyglet.resource.image(definition['name'])
    # <mauve> [offset is] the amount you have to translate the image
    # <mauve> So -1 * the position of the centre in the image
    # also we have to flip the y axis because this is pyglet
    img.anchor_x = -definition['offset'][0]
    img.anchor_y = img.height + definition['offset'][1]
    definition['img'] = img

    offset = v(definition['offset'])
    circles = [Circle(v(0, 0), definition['radius'])]
    for p in definition.get('points', []):
        centre = v(p['offset']) + offset
        circles.append(Circle(v(centre.x, -centre.y), p['radius']))
    definition['shapes'] = circles 
    return definition
コード例 #15
0
ファイル: enemy.py プロジェクト: italomaia/turtle-linux
 def flock(self, sense_radius=500, target_sep=100, effect=1):
     flock_vector = v((0,0))
     for other in self.neighbours(sense_radius):
         if self.__class__ == other.__class__ and self.sees(other, sight_radius=sense_radius):
             relative_pos = other.pos - self.pos
             d = relative_pos.length
             if d:
                 sgn = 1 if d > target_sep else -1
                 flock_vector += (relative_pos.normalised() * sgn)
     if flock_vector.length > 0:
         self.apply_impulse(flock_vector.normalised() * effect)
コード例 #16
0
ファイル: threed.py プロジェクト: viron11111/software-common
 def draw(self):
     glBegin(GL_LINES)
     for x in xrange(-10, 10+1):
         for y in xrange(-10, 10+1):
             pos = v(x, y, 0)
             vel = self.func(pos)
             glColor3d(1, 0, 0)
             glVertex3f(*pos-vel/2)
             glColor3d(1, 1, 0)
             glVertex3f(*pos+vel/2)
     glEnd()
コード例 #17
0
ファイル: enemy.py プロジェクト: italomaia/turtle-linux
 def flock(self, sense_radius=500, target_sep=100, effect=1):
     flock_vector = v((0, 0))
     for other in self.neighbours(sense_radius):
         if self.__class__ == other.__class__ and self.sees(
                 other, sight_radius=sense_radius):
             relative_pos = other.pos - self.pos
             d = relative_pos.length
             if d:
                 sgn = 1 if d > target_sep else -1
                 flock_vector += (relative_pos.normalised() * sgn)
     if flock_vector.length > 0:
         self.apply_impulse(flock_vector.normalised() * effect)
コード例 #18
0
    def init(self, world, pos=v(0, -10, 2)):
        self.world = world
        self.pos = pos

        self.display_flags = pygame.DOUBLEBUF | pygame.OPENGL | pygame.RESIZABLE
        self.display = pygame.display.set_mode((640, 480), self.display_flags)
        self.clock = pygame.time.Clock()

        self.pitch = self.yaw = 0
        self.grabbed = False

        self.fovy = 100
コード例 #19
0
ファイル: threed.py プロジェクト: viron11111/software-common
 def init(self, world, pos=v(0, -10, 2)):
     self.world = world
     self.pos = pos
     
     self.display_flags = pygame.DOUBLEBUF|pygame.OPENGL|pygame.RESIZABLE
     self.display = pygame.display.set_mode((640, 480), self.display_flags)
     self.clock = pygame.time.Clock()
     
     self.pitch = self.yaw = 0
     self.grabbed = False
     
     self.fovy = 100
コード例 #20
0
 def update_velocity(self):
     #doesn't actually speed things up
     #if (self.dest != self.last_dest):
     direction = (self.dest - self.pos)
     if direction.length2 > self.speed**2:
         #avoid scaled_to here - we can do better
         old_length = direction.length
         scale_factor = self.speed / old_length
         direction = v(
             (direction[0] * scale_factor, direction[1] * scale_factor))
     self.vel = direction
     return self.vel
コード例 #21
0
ファイル: game.py プロジェクト: andrewrk/MonsterMechanics
    def start(self):
        Monster.load_all()
        self.window = pyglet.window.Window(width=self.size.x, height=self.size.y, caption=name)
        self.camera = Camera(v(self.size.x, self.size.y) * 0.5, self.size.x, self.size.y)

        Background.load()
        self.background = Background(self.window)

        self.world = World()
        self.monster = Monster.create_initial(self.world, v(400, 80))
        self.monster.add_death_listener(self.show_game_over)
        self.world.add_monster(self.monster)
        self.auto_monster()

        if self.filename is not None:
            self.world.add_monster(Monster.enemy_from_json(self.world, self.filename))
            self.show_message('fight', 2)
        else:
            self.set_timer(self.spawn_next_enemy, 1.5)
            self.show_message('get-ready')

        Shelf.load()
        self.hud = Shelf(self.world, self.monster, self.camera)

        self.fps_display = pyglet.clock.ClockDisplay()

        pyglet.clock.schedule_interval(self.update, 1/target_fps)
        self.window.set_handlers(
            on_draw=self.on_draw,
            on_key_press=self.on_key_press,
            on_key_release=self.on_key_release,
            on_mouse_press=self.hud.on_mouse_press,
            on_mouse_release=self.hud.on_mouse_release,
            on_mouse_motion=self.hud.on_mouse_motion,
            on_mouse_drag=self.hud.on_mouse_drag,
            on_mouse_scroll=self.hud.on_mouse_scroll,
        )

        pyglet.app.run()
コード例 #22
0
 def update_velocity(self):
     direction = self.dest - self.pos
     if self.vel is None or self.vel.is_zero:
         if direction.length2 > self.speed**2:
             #avoid scaled_to here - we can do better
             old_length = direction.length
             scale_factor = self.speed / old_length
             direction = v(
                 (direction[0] * scale_factor, direction[1] * scale_factor))
         self.vel = direction
     else:
         tturn = self.vel.signed_angle_to(direction)
         if abs(tturn) <= self.turn_rate:
             if direction.length2 > self.speed**2:
                 #avoid scaled_to here - we can do better
                 old_length = direction.length
                 scale_factor = self.speed / old_length
                 direction = v((direction[0] * scale_factor,
                                direction[1] * scale_factor))
             self.vel = direction
         else:
             self.vel = self.vel.rotated(cmp(tturn, 0) * self.turn_rate)
     return self.vel
コード例 #23
0
ファイル: monster.py プロジェクト: andrewrk/MonsterMechanics
    def kill(self):
        for p, j in self._joints:
            p.kill()
        if self._parent is not None:
            self._parent._joints = [(p, j) for p, j in self._parent._joints if p is not self]

        for p, radius in self.get_shapes():
            for i in range(int(radius * radius / 100.0)):
                off = v(random.gauss(0, radius * 0.5), random.gauss(0, radius * 0.5))
                self.world.spawn(Blood(self.get_position() + p + off, name=''))

        self.world.destroy(self)
        self.monster.remove_part(self)
        if self._parent is None:
            self.monster.kill()
コード例 #24
0
ファイル: monster.py プロジェクト: andrewrk/MonsterMechanics
 def update(self, dt):
     if self.controller:
         self.controller.update(dt)
     if self.moving in [LEFT, RIGHT]:
         self.phase += self.moving * dt * 2
         for p in self.parts:
             if not isinstance(p, Leg):
                 continue
             ppos = p.get_position()
             step = math.sin(ppos.x / 50.0 + self.phase)
             f = step * 0.5 + 0.5
             p.set_position(ppos + v(self.moving * 200 * f * dt, 10 * f * dt))
             rot = p.body.get_rotation()
             p.body.set_rotation(rot + self.moving * step * dt) 
     self.moving = 0
コード例 #25
0
ファイル: hud.py プロジェクト: andrewrk/MonsterMechanics
 def on_mouse_press(self, x, y, button, modifiers):
     self.draggedicon = self.icon_for_point(x, y)
     if self.parthud:
         s = v(x, y)
         if self.parthud.upgrade_button_rect and self.parthud.upgrade_button_rect.contains(s):
             self.parthud.part.upgrade()
         else:
             wpos = self.camera.screen_to_world(s)
             for m in self.world.monsters:
                 part = m.colliding_point(wpos)
                 if part and part is self.parthud.part:
                     break
             else:
                 self.parthud = None
     self.mousedown = True
コード例 #26
0
ファイル: hud.py プロジェクト: andrewrk/MonsterMechanics
    def on_mouse_motion(self, x, y, dx, dy):
        icon = self.icon_for_point(x, y)
        if icon:
            self.cost_value = self.icons[icon].cost
        else:
            self.cost_value = None
        if self.parthud:
            s = v(x, y)
            if self.parthud.upgrade_button_rect and self.parthud.upgrade_button_rect.contains(s):
                self.cost_value = self.parthud.part.upgrade_cost()
            if self.parthud.locked:
                return
        wpos = self.camera.screen_to_world(v(x, y))
        for m in self.world.monsters:
            part = m.colliding_point(wpos)
            if part:
                break
        else:
            if self.parthud and not self.parthud.locked:
                self.parthud = None
            return

        if self.parthud is None or part is not self.parthud.part:
            self.parthud = PartHud(part)
コード例 #27
0
ファイル: actor.py プロジェクト: italomaia/turtle-linux
 def __init__(self,
              world,
              pos=(0, 0),
              radius=50,
              bearing=0,
              image_file=None,
              name=None,
              **kwargs):
     self.world = world
     self.pos = v(pos)
     self.old_pos = v(pos)
     self.radius = radius
     self.bearing = bearing
     self.old_bearing = bearing
     self.image_file = image_file
     self.image = squirtle.SVG(data.file_path(image_file),
                               anchor_x='center',
                               anchor_y='center')
     self.dead = False
     self.impulse = v((0, 0))
     self.name = name
     # do not use
     self.scale = 0.0
     self.z = 0
コード例 #28
0
ファイル: hud.py プロジェクト: andrewrk/MonsterMechanics
 def on_mouse_release(self, x, y, button, modifiers):
     if self.draggedpart:
         wpos = self.camera.screen_to_world(v(x, y))
         self.draggedpart.set_position(wpos)
         try:
             self.monster.attach_and_grow(self.draggedpart)
         except ValueError:
             pass
         else:
             self.monster.spend_mutagen(self.draggedpart.cost)
     elif self.parthud:
         self.parthud.locked = True
     self.draggedpart = None
     self.draggedicon = None
     self.mousedown = False
コード例 #29
0
ファイル: threed.py プロジェクト: viron11111/software-common
 def draw(self):
     q = gluNewQuadric()
     glColor3f(*self.color)
     with GLMatrix:
         rotate_to_body(self.body)
         for start, end in self.capsules:
             with GLMatrix:
                 glTranslate(*start)
                 gluSphere(q, self.radius, 30, 15)
             with GLMatrix:
                 glTranslate(*end)
                 gluSphere(q, self.radius, 30, 15)
             with GLMatrix:
                 glTranslate(*start)
                 a = (end - start).unit()
                 b = v(0, 0, 1)
                 glRotate(-math.degrees(math.acos(a*b)), *(a%b).unit())
                 gluCylinder(q, self.radius, self.radius, (end - start).mag(), 10, 1)
コード例 #30
0
ファイル: hud.py プロジェクト: andrewrk/MonsterMechanics
    def on_mouse_drag(self, x, y, dx, dy, button, modifiers):
        if x > (853 - ICON_HEIGHT - MARGIN) and not self.draggedpart:
            self.scroll_y += dy

        wpos = self.camera.screen_to_world(v(x, y))
        if self.draggedicon and x < (853 - ICON_HEIGHT - MARGIN):
            self.draggedpart = self.create_virtual_part(self.draggedicon, wpos)
            self.draggedicon = None

        if self.draggedpart:
            self.draggedpart.set_position(wpos)
            attachment = self.monster.attachment_point(self.draggedpart)
            if attachment is not None:
                self.draggedpart.position_to_joint(attachment[1] - attachment[2])
                self.draggedpart.set_position(attachment[1])
                self.draggedpart.set_style(STYLE_VALID)
            else:
                self.draggedpart.set_style(STYLE_INVALID)
コード例 #31
0
 def draw(self):
     q = gluNewQuadric()
     glColor3f(*self.color)
     with GLMatrix:
         rotate_to_body(self.body)
         for start, end in self.capsules:
             with GLMatrix:
                 glTranslate(*start)
                 gluSphere(q, self.radius, 30, 15)
             with GLMatrix:
                 glTranslate(*end)
                 gluSphere(q, self.radius, 30, 15)
             with GLMatrix:
                 glTranslate(*start)
                 a = (end - start).unit()
                 b = v(0, 0, 1)
                 glRotate(-math.degrees(math.acos(a * b)), *(a % b).unit())
                 gluCylinder(q, self.radius, self.radius,
                             (end - start).mag(), 10, 1)
コード例 #32
0
ファイル: actor.py プロジェクト: andrewrk/MonsterMechanics
 def create_body(self, world):
     """Create the physics body for the part"""
     #print "Spawning", self.__class__.__name__, self.name + self.type
     self.body = world.create_body(self.get_shapes(), collision_class=self.name + self.type)
     self.body.set_position(v(*self.sprite.position))
コード例 #33
0
def random_point_on_circle(centre, radius):
    from vector import Vector as v
    import random
    return centre + v((radius, 0)).rotated(random.random() * 360)
コード例 #34
0
from vehicle import Vehicle
from vector import Vector as v
from world import World, Path
from gui import GUI

from PyQt5 import QtGui, QtCore, QtWidgets

if __name__ == "__main__":

    app = QtWidgets.QApplication(sys.argv)
    dw = QtWidgets.QDesktopWidget()

    w = dw.width() * 0.9
    h = dw.height() * 0.8

    v0 = v(0, 0)
    vel = v(10, 10)
    v1 = v(20, 20)
    paths = []

    vehicleCount = 8

    path1 = Path([
        v(100, 100),
        v(200, 100),
        v(300, 100),
        v(400, 100),
        v(500, 100),
        v(500, 200),
        v(500, 300),
        v(500, 400),
コード例 #35
0
 def map_centre(self):
     return v((self.w / 2, self.h / 2))
コード例 #36
0
ファイル: actor.py プロジェクト: italomaia/turtle-linux
 def int_point(pt):
     return v((pt.x // 1.0, pt.y // 1.0))
コード例 #37
0
ファイル: enemy.py プロジェクト: italomaia/turtle-linux
 def bumble(self):
     self.apply_impulse(v((random.gauss(0, 1), random.gauss(0, 1))))
コード例 #38
0
ファイル: garden.py プロジェクト: italomaia/turtle-linux
 def initial_setup(self):
     self.game.add_plant_at(plant.Cherry, self.game.map_centre)
     self.game.add_plant_at(plant.Daisy, self.game.map_centre + v((200, 0)))
     self.game.add_plant_at(plant.Bluebell, self.game.map_centre - v((200, 0)))
コード例 #39
0
ファイル: threed.py プロジェクト: viron11111/software-common
 def step(self):
     dt = self.clock.tick()/1000
     
     for event in pygame.event.get():
         if event.type == pygame.MOUSEMOTION:
             if self.grabbed:
                 self.yaw += event.rel[0]/100
                 
                 self.pitch += -event.rel[1]/100
                 # caps it to a quarter turn up or down
                 self.pitch = min(max(self.pitch, -math.pi/2), math.pi/2)
         
         elif event.type == pygame.KEYDOWN:
             if event.key == pygame.K_TAB:
                 self.grabbed = not self.grabbed
                 pygame.event.set_grab(self.grabbed)
                 pygame.mouse.set_visible(not self.grabbed)
             
             elif event.key == pygame.K_q:
                 sys.exit()
         
         elif event.type == pygame.QUIT:
             sys.exit()
         
         elif event.type == pygame.VIDEORESIZE:
             self.display = pygame.display.set_mode(event.size, self.display_flags)
             glViewport(0, 0, self.display.get_width(), self.display.get_height())
     
     rot_matrix = euler_matrix(self.yaw, self.pitch, 0)
     
     forward  = rotate_vec(v(1,0,0), rot_matrix)
     left     = rotate_vec(v(0,1,0), rot_matrix)
     local_up = rotate_vec(v(0,0,1), rot_matrix)
     
     keys = pygame.key.get_pressed()
     
     speed = 50 if keys[pygame.K_LSHIFT] else 5
     speed *= (.1 if keys[pygame.K_LCTRL] else 1)
     
     if keys[pygame.K_w]: self.pos += forward*dt*speed
     if keys[pygame.K_s]: self.pos += -forward*dt*speed
     if keys[pygame.K_a]: self.pos += left*dt*speed
     if keys[pygame.K_d]: self.pos += -left*dt*speed
     if keys[pygame.K_SPACE]: self.pos += v(0, 0, 1)*dt*speed
     if keys[pygame.K_c]: self.pos += v(0, 0, -1)*dt*speed
     
     glMatrixMode(GL_PROJECTION)
     glLoadIdentity()
     perspective(self.fovy, self.display.get_width()/self.display.get_height(), 0.1)
     
     glMatrixMode(GL_MODELVIEW)
     glLoadIdentity()
     # rotates into the FLU coordinate system
     glMultMatrixf([
         [ 0., 0.,-1., 0.],
         [-1., 0., 0., 0.],
         [ 0., 1., 0., 0.],
         [ 0., 0., 0., 1.]
     ])
     # after that, +x is forward, +y is left, and +z is up
     
     glMultMatrixf(rot_matrix.T)
     
     glTranslate(*-self.pos)
     pos = self.pos
     
     self.world.draw()
     
     glDisable(GL_LIGHTING)
     glDisable(GL_DEPTH_TEST)
     with GLMatrix:
         glTranslate(*self.pos + forward + left - local_up)
         glBegin(GL_LINES)
         for i in xrange(3):
             glColor3f(*(j==i for j in xrange(3)))
             glVertex3f(0, 0, 0)
             glVertex3f(*(.1*(j==i) for j in xrange(3)))
         glEnd()
     glEnable(GL_DEPTH_TEST)
     glEnable(GL_LIGHTING)
     
     pygame.display.flip()
コード例 #40
0
ファイル: effects.py プロジェクト: italomaia/turtle-linux
 def __init__(self, world, pos):
     super(SmokePuff, self).__init__(world,
                                     pos=pos,
                                     radius=10,
                                     image_file="images/all/star.svgz")
     self.apply_impulse(v((random.gauss(0, 2), random.gauss(0, 2))))
コード例 #41
0
ファイル: enemy.py プロジェクト: italomaia/turtle-linux
 def accelerate(self):
     self.apply_impulse(v((self.thrust, 0)).rotated(self.bearing))
コード例 #42
0
ファイル: garden.py プロジェクト: italomaia/turtle-linux
 def initial_setup(self):
     self.game.add_plant_at(plant.Rose, v((0.2 * self.game.w, 0.5 * self.game.h)), True)
     self.game.add_plant_at(plant.Apple, v((0.8 * self.game.w, 0.5 * self.game.h)), True)
     self.game.add_creature_at(creatures.Ladybird, v((0.3 * self.game.w, 0.5 * self.game.h)))
     self.game.add_creature_at(creatures.Dragonfly, v((0.7 * self.game.w, 0.5 * self.game.h)))
コード例 #43
0
ファイル: actor.py プロジェクト: italomaia/turtle-linux
    def tick(self):

        for c in self.colliders():
            if c.mass > 0:
                rpn = (c.pos - self.pos).normalised()
                c.apply_impulse(rpn * self.mass)
                self.apply_impulse(-rpn * c.mass)

        self.bearing += self.rotation
        if self.thrust or self.lift:
            dir = v((self.thrust, self.lift)).rotated(self.bearing)
            self.apply_impulse(dir)
            if self.engine_fx_cooldown <= 0:
                self.world.new_active.add(
                    effects.SmokePuff(self.world, self.pos))
                self.engine_fx_cooldown = SMOKEPUFF_RATE
            else:
                self.engine_fx_cooldown -= 1

        old_pos = v(
            self.pos
        )  #Need to store this, because we may mess with it to do bouncing, etc.

        super(Player, self).tick()

        def candidate_key(pt):
            v1 = self.pipe[-1] - pt
            v2 = self.pipe[-1] - old_pos
            return v1.angle_to(v2)  #, v1.length

        def int_point(pt):
            return v((pt.x // 1.0, pt.y // 1.0))

        hooked = False
        unhooked = []
        swept_angle = 0
        while True:
            candidates = []
            for wall in self.world.static.in_tri(self.pipe[-1], old_pos,
                                                 self.pos):
                pt = int_point(wall.start)  # why does this work?
                if pt not in unhooked and pt.in_tri(self.pipe[-1], old_pos,
                                                    self.pos):
                    angle = candidate_key(pt)
                    if angle > swept_angle:
                        candidates.append((angle, pt))
            if not hooked and len(self.pipe) > 1 and self.pipe[-1].in_tri(
                    self.pipe[-2], old_pos, self.pos):
                unhook_angle = (self.pipe[-1] -
                                old_pos).angle_to(self.pipe[-2] -
                                                  self.pipe[-1])
            else:
                unhook_angle = None
            if not candidates and unhook_angle is None:
                break
            if unhook_angle is not None and (not candidates or
                                             unhook_angle < min(candidates)):
                swept_angle = (self.pipe[-2] -
                               old_pos).angle_to(self.pipe[-2] - self.pipe[-1])
                self.pinned_length -= (self.pipe[-2] - self.pipe[-1]).length
                unhooked.append(self.pipe.pop())
            else:
                angle, pivot = min(candidates)
                swept_angle = angle
                self.pipe.append(pivot)
                self.pinned_length += (self.pipe[-2] - self.pipe[-1]).length
                hooked = True

        pipe_vector = self.pos - self.pipe[-1]
        if pipe_vector.length > self.pipe_length - self.pinned_length:
            sf = (self.pipe_length - self.pinned_length) / pipe_vector.length
            self.pos = (1 - sf) * self.pipe[-1] + self.pos * sf
        self.pipe_used = min(pipe_vector.length + self.pinned_length,
                             self.pipe_length)

        if self.firing and self.cooldown > SHOT_COOLDOWN:
            self.cooldown = 0
            p = self.weapon.make_projectile(self.world,
                                            pos=self.pos,
                                            bearing=self.bearing + 90)
            p.apply_impulse(self.pos - self.old_pos)
            self.world.new_active.add(p)
            self.world.dispatch_event('on_shoot')
        self.cooldown += 1
        if not self.firing:
            self.cooldown = SHOT_COOLDOWN
        self.oxygen.contained -= 1
        for c in self.colliders():
            if isinstance(c, swag.Swag):
                self.world.dispatch_event('on_get_swag', c)
                if c.goal:
                    self.world.dispatch_event('on_finish_level')
                c.dead = True
コード例 #44
0
ファイル: actor.py プロジェクト: andrewrk/MonsterMechanics
 def get_position(self):
     if self.body:
         return self.body.get_position()
     else:
         return v(*self.sprite.position)
コード例 #45
0
ファイル: test.py プロジェクト: yoyojn/UD953
from line import Line as l
from plane import Plane as p
from linsys import LinearSystem as linSys


# Test for Lines
def checkLine(line1, line2):
    if line1.is_equal(line2):
        print "They are equal"
    elif line1.is_parallel(line2):
        print "They are parallel"
    else:
        print line1.intersection(line2)


a = l(v([4.046, 2.836]), 1.21)
b = l(v([10.115, 7.09]), 3.025)
checkLine(a, b)

c = l(v([7.204, 3.182]), 8.68)
d = l(v([8.172, 4.114]), 9.883)
checkLine(c, d)

e = l(v([1.182, 5.562]), 6.744)
f = l(v([1.773, 8.343]), 9.525)
checkLine(e, f)


# Test for ps
def checkp(p1, p2):
    if p1.is_equal(p2):
コード例 #46
0
    def step(self):
        dt = self.clock.tick() / 1000

        for event in pygame.event.get():
            if event.type == pygame.MOUSEMOTION:
                if self.grabbed:
                    self.yaw += event.rel[0] / 100

                    self.pitch += -event.rel[1] / 100
                    # caps it to a quarter turn up or down
                    self.pitch = min(max(self.pitch, -math.pi / 2),
                                     math.pi / 2)

            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_TAB:
                    self.grabbed = not self.grabbed
                    pygame.event.set_grab(self.grabbed)
                    pygame.mouse.set_visible(not self.grabbed)

                elif event.key == pygame.K_q:
                    sys.exit()

            elif event.type == pygame.QUIT:
                sys.exit()

            elif event.type == pygame.VIDEORESIZE:
                self.display = pygame.display.set_mode(event.size,
                                                       self.display_flags)
                glViewport(0, 0, self.display.get_width(),
                           self.display.get_height())

        rot_matrix = euler_matrix(self.yaw, self.pitch, 0)

        forward = rotate_vec(v(1, 0, 0), rot_matrix)
        left = rotate_vec(v(0, 1, 0), rot_matrix)
        local_up = rotate_vec(v(0, 0, 1), rot_matrix)

        keys = pygame.key.get_pressed()

        speed = 50 if keys[pygame.K_LSHIFT] else 5
        speed *= (.1 if keys[pygame.K_LCTRL] else 1)

        if keys[pygame.K_w]: self.pos += forward * dt * speed
        if keys[pygame.K_s]: self.pos += -forward * dt * speed
        if keys[pygame.K_a]: self.pos += left * dt * speed
        if keys[pygame.K_d]: self.pos += -left * dt * speed
        if keys[pygame.K_SPACE]: self.pos += v(0, 0, 1) * dt * speed
        if keys[pygame.K_c]: self.pos += v(0, 0, -1) * dt * speed

        glMatrixMode(GL_PROJECTION)
        glLoadIdentity()
        perspective(self.fovy,
                    self.display.get_width() / self.display.get_height(), 0.1)

        glMatrixMode(GL_MODELVIEW)
        glLoadIdentity()
        # rotates into the FLU coordinate system
        glMultMatrixf([[0., 0., -1., 0.], [-1., 0., 0., 0.], [0., 1., 0., 0.],
                       [0., 0., 0., 1.]])
        # after that, +x is forward, +y is left, and +z is up

        glMultMatrixf(rot_matrix.T)

        glTranslate(*-self.pos)
        pos = self.pos

        self.world.draw()

        glDisable(GL_LIGHTING)
        glDisable(GL_DEPTH_TEST)
        with GLMatrix:
            glTranslate(*self.pos + forward + left - local_up)
            glBegin(GL_LINES)
            for i in xrange(3):
                glColor3f(*(j == i for j in xrange(3)))
                glVertex3f(0, 0, 0)
                glVertex3f(*(.1 * (j == i) for j in xrange(3)))
            glEnd()
        glEnable(GL_DEPTH_TEST)
        glEnable(GL_LIGHTING)

        pygame.display.flip()
コード例 #47
0
 def somewhere(self):
     return v((distribute_outwards(random.random()) * self.w,
               distribute_outwards(random.random()) * self.h))
コード例 #48
0
ファイル: enemy.py プロジェクト: italomaia/turtle-linux
 def accelerate(self):
     self.apply_impulse(v((self.thrust,0)).rotated(self.bearing))
コード例 #49
0
ファイル: actor.py プロジェクト: italomaia/turtle-linux
    def tick(self):
        # objects by default continue to move in a straight line (see Newton)
        delta = self.pos - self.old_pos
        self.old_pos = self.pos
        dtheta = self.bearing - self.old_bearing
        self.old_bearing = self.bearing
        self.bearing += dtheta * ANGULAR_DRAG
        real_old_pos = self.old_pos

        # add drag forces to delta
        drag = delta * -delta.length * self.radius * self.world.drag
        delta += drag

        # add other accumulated forces to delta
        delta += self.impulse
        self.impulse = v((0, 0))

        if not self.collides:

            self.pos += delta

        else:

            steps = 1 + int(1.05 * delta.length / self.radius)
            sub_delta = delta / steps

            for ii in xrange(steps):

                self.pos += sub_delta

                original_pos = self.pos
                check_collisions = True
                tries = 0
                while check_collisions:

                    check_collisions = False
                    tries += 1
                    if tries > 200:
                        # this is a problem, so rather than take the game down, we do something which just
                        # looks bad
                        self.pos = original_pos
                        return

                    for wall in self.world.static.overlaps(self):
                        cp = wall.closest_point(self.pos)
                        approach = (self.pos - cp)
                        if approach.length < self.radius - EPSILON:
                            self.pos = cp + approach.normalised() * self.radius
                            check_collisions = True

                # now, the actor is definitely in a safe place
                # work backwards to work out its eventual reflection and update old_pos to make it bounce

                displacement = self.pos - original_pos
                if displacement.length > 0:
                    mirror_point = original_pos + displacement * 0.5
                    mirror_line = Line(
                        displacement.normalised(),
                        mirror_point * displacement.normalised())
                    self.old_pos = mirror_line.reflect(self.old_pos)
                    sub_delta = mirror_line.parallel_through_origin.reflect(
                        sub_delta)
                    self.old_pos = self.pos + (self.old_pos -
                                               self.pos) * ELASTICITY
コード例 #50
0
ファイル: garden.py プロジェクト: italomaia/turtle-linux
 def good_creature_arrival_location(self):
     return v((self.game.w * (0.2 + 0.6*random.random()), -200))
コード例 #51
0
ファイル: garden.py プロジェクト: italomaia/turtle-linux
 def initial_setup(self):
     self.game.add_plant_at(plant.Orange, v((80, self.game.h/2)), True)
     self.game.add_plant_at(plant.Orange, v((self.game.w - 80, self.game.h/2)), True)
コード例 #52
0
 def inv_camera_transform(self, screen_loc):
     return (v(screen_loc) - (self.window.width * 0.5, self.window.height * 0.2)).rotated(self.camera_bearing) / (self.camera_scale * self.camera_zoom) + self.camera_pos
コード例 #53
0
ファイル: mockup2.py プロジェクト: italomaia/turtle-linux
 def on_mouse_release(self, x, y, buttons, mods):
     self.g.plants.add(Plant(v((x, y))))
コード例 #54
0
 def hit(self, victim):
     self.dead = True
     # check this next line - I think crazy stuff might happen if a projectile hits an enemy just
     # after it's bounced off a wall
     victim.apply_impulse(v((self.force, 0)).rotated(self.bearing))
     victim.stun(STUN_FRAMES)
コード例 #55
0
ファイル: garden.py プロジェクト: italomaia/turtle-linux
 def initial_setup(self):
     self.game.add_plant_at(plant.Rose, self.game.map_centre + v((-150, 0)), True)
     self.game.add_plant_at(plant.Rose, self.game.map_centre + v((150, 0)), True)
     self.game.add_creature_at(creatures.Ladybird, self.game.map_centre)