Пример #1
0
    def tick(self, dt):
        if self.engine.keepRunning == True:
            self.keyboard.capture()
            
            if self.toggle >= 0:
                self.toggle -= dt

            if self.toggle < 0:
                self.toggle = 0.1
                for entity in self.engine.selectionMgr.selectedEnts:
                    if  self.keyboard.isKeyDown(OIS.KC_UP):
                        entity.desiredSpeed = utils.clamp(entity.desiredSpeed + entity.deltaSpeed, 0, entity.maxSpeed)
                        print "Speeding UP", entity.desiredSpeed
                    if  self.keyboard.isKeyDown(OIS.KC_DOWN):
                        entity.desiredSpeed = utils.clamp(entity.desiredSpeed - entity.deltaSpeed, 0, entity.maxSpeed)
                        print "Slowing DOWN", entity.desiredSpeed
                    if  self.keyboard.isKeyDown(OIS.KC_LEFT):
                        entity.desiredHeading += entity.deltaYaw
                        entity.desiredHeading = utils.fixAngle(entity.desiredHeading)
                        print "Turn left", ogre.Radian(entity.desiredHeading).valueDegrees()
                    if  self.keyboard.isKeyDown(OIS.KC_RIGHT):
                        entity.desiredHeading -= entity.deltaYaw
                        entity.desiredHeading = utils.fixAngle(entity.desiredHeading)
                        print "Turn right", ogre.Radian(entity.desiredHeading).valueDegrees()
                    if self.keyboard.isKeyDown(OIS.KC_SPACE):
                        entity.desiredSpeed = 0
Пример #2
0
    def tick(self, dt):
    	# Update the toggle timer.
        if self.toggle >= 0:
            self.toggle -= dt

        import utils
        entList = self.selMgr.getSelected()
        if entList:
            for selectedEnt in entList:
                #change desired speed and current direction
                #------------------------------------------
                # Speed Up
                if  self.toggle < 0 and self.keyboard.isKeyDown(OIS.KC_UP):
                    selectedEnt.desiredSpeed = utils.clamp(selectedEnt.desiredSpeed + selectedEnt.deltaSpeed, 0, selectedEnt.maxSpeed)
                    print "Speeding UP", selectedEnt.desiredSpeed

                # Slow down
                if  self.toggle < 0 and self.keyboard.isKeyDown(OIS.KC_DOWN):
                    selectedEnt.desiredSpeed = utils.clamp(selectedEnt.desiredSpeed - selectedEnt.deltaSpeed, 0, selectedEnt.maxSpeed)
                    print "Slowing down", selectedEnt.desiredSpeed

                # Turn Left.
                if  self.toggle < 0 and self.keyboard.isKeyDown(OIS.KC_LEFT):
                    selectedEnt.desiredHeading += selectedEnt.deltaYaw
                    selectedEnt.desiredHeading = utils.fixAngle(selectedEnt.desiredHeading)
                    print "Turn left", selectedEnt.desiredHeading

                # Turn Right.
                if  self.toggle < 0 and self.keyboard.isKeyDown(OIS.KC_RIGHT):
                    selectedEnt.desiredHeading -= selectedEnt.deltaYaw
                    selectedEnt.desiredHeading = utils.fixAngle(selectedEnt.desiredHeading)
                    print "Turn right", selectedEnt.desiredHeading
            if self.toggle < 0:
                toggle = 0.2
        pass
Пример #3
0
    def tick(self, dtime):
        self.keyboard.capture()
        selectedEnt2 = self.ent.engine.selectionMgr.selectedEnts[1]

        if self.toggle >= 0: 
            self.toggle -= dtime

        if self.toggle < 0 and self.keyboard.isKeyDown(OIS.KC_W):
            self.toggle = 0.15
            selectedEnt2.desiredSpeed = utils.clamp(selectedEnt2.desiredSpeed + selectedEnt2.deltaSpeed, 0, selectedEnt2.maxSpeed)

            # Slower
        if self.toggle < 0 and self.keyboard.isKeyDown(OIS.KC_S):
            self.toggle = 0.15
            selectedEnt2.desiredSpeed = utils.clamp(selectedEnt2.desiredSpeed - selectedEnt2.deltaSpeed/5.5, 0, selectedEnt2.maxSpeed)

            # turn left
        if self.toggle < 0 and self.keyboard.isKeyDown(OIS.KC_A):
            self.toggle = 0.15
            selectedEnt2.desiredHeading += selectedEnt2.deltaYaw
                #print "Control: ", str(selectedEnt), str(selectedEnt.desiredHeading)

            # turn right
        if self.toggle < 0 and self.keyboard.isKeyDown(OIS.KC_D):
            self.toggle = 0.15
            selectedEnt2.desiredHeading -= selectedEnt2.deltaYaw
                #print "Control: ", str(selectedEnt), str(selectedEnt.desiredHeading)
            
       	selectedEnt2.desiredHeading = utils.fixAngle(selectedEnt2.desiredHeading)
Пример #4
0
    def tick(self, dtime):
        self.keyboard.capture()
        selectedEnt2 = self.ent.engine.selectionMgr.selectedEnts[1]

        if self.toggle >= 0:
            self.toggle -= dtime

        if self.toggle < 0 and self.keyboard.isKeyDown(OIS.KC_W):
            self.toggle = 0.15
            selectedEnt2.desiredSpeed = utils.clamp(
                selectedEnt2.desiredSpeed + selectedEnt2.deltaSpeed, 0,
                selectedEnt2.maxSpeed)

            # Slower
        if self.toggle < 0 and self.keyboard.isKeyDown(OIS.KC_S):
            self.toggle = 0.15
            selectedEnt2.desiredSpeed = utils.clamp(
                selectedEnt2.desiredSpeed - selectedEnt2.deltaSpeed / 5.5, 0,
                selectedEnt2.maxSpeed)

            # turn left
        if self.toggle < 0 and self.keyboard.isKeyDown(OIS.KC_A):
            self.toggle = 0.15
            selectedEnt2.desiredHeading += selectedEnt2.deltaYaw
            #print "Control: ", str(selectedEnt), str(selectedEnt.desiredHeading)

            # turn right
        if self.toggle < 0 and self.keyboard.isKeyDown(OIS.KC_D):
            self.toggle = 0.15
            selectedEnt2.desiredHeading -= selectedEnt2.deltaYaw
            #print "Control: ", str(selectedEnt), str(selectedEnt.desiredHeading)

        selectedEnt2.desiredHeading = utils.fixAngle(
            selectedEnt2.desiredHeading)
Пример #5
0
 def tick(self, dt):
     diff = self.target.ent.pos - self.ent.pos
     relativeVel = self.target.ent.vel - self.ent.vel
     timeToClose = diff.length()/(relativeVel.length() + 1)
     aimLocation = self.target.ent.pos + self.target.ent.vel * timeToClose
     diff = aimLocation - self.ent.pos
     self.ent.desiredHeading = utils.fixAngle(- math.atan2(diff.z, diff.x))
     if self.done():
         self.ent.desiredSpeed = 0
     else:
         self.ent.desiredSpeed   = self.ent.maxSpeed        
Пример #6
0
 def tick(self, dt):
     diff = self.target.ent.pos - self.ent.pos
     relativeVel = self.target.ent.vel - self.ent.vel
     timeToClose = diff.length() / (relativeVel.length() + 1)
     aimLocation = self.target.ent.pos + self.target.ent.vel * timeToClose
     diff = aimLocation - self.ent.pos
     self.ent.desiredHeading = utils.fixAngle(-math.atan2(diff.z, diff.x))
     if self.done():
         self.ent.desiredSpeed = 0
     else:
         self.ent.desiredSpeed = self.ent.maxSpeed
    def tick(self, dtime):
        ''' Updates Position, Yaw, Pitch, and Roll. '''
        # Position ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
        timeScaledAcceleration = self.ent.acceleration * dtime
        self.ent.speed += utils.clamp( self.ent.desiredSpeed - self.ent.speed, -timeScaledAcceleration, timeScaledAcceleration)
        self.ent.vel.y = self.ent.speed * math.sin( math.radians( self.ent.pitch ) )
        ## xz = self.ent.speed * math.cos( math.radians( self.ent.pitch ) )
        self.ent.vel.x = self.ent.speed * math.cos( math.radians( self.ent.yaw ) )
        self.ent.vel.z = self.ent.speed * -math.sin( math.radians( self.ent.yaw ) )
        self.ent.pos = self.ent.pos + ( self.ent.vel * dtime )

        # Yaw ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
        timeScaledYaw = self.ent.yawRate * dtime
        angleDiff = utils.diffAngle(self.ent.desiredYaw, self.ent.yaw)
        self.ent.deltaYaw = utils.clamp(angleDiff, -timeScaledYaw, timeScaledYaw)
        ## print '---' + self.ent.uiname + '---'
        ## print "angleDiff: %f, timeScaledYaw: %f,  deltaYaw: %f " % (angleDiff, timeScaledYaw, self.ent.deltaYaw )
        ## print "yaw: %f, desiredYaw: %f, yawRate: %f" % (self.ent.yaw, self.ent.desiredYaw, self.ent.yawRate)
        self.ent.yaw = utils.fixAngle( self.ent.yaw + self.ent.deltaYaw)
        # Pitch ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
        timeScaledPitch = self.ent.pitchRate * dtime
        angleDiff = utils.diffAngle(self.ent.desiredPitch, self.ent.pitch)
        self.ent.deltaPitch = utils.clamp(angleDiff, -timeScaledPitch, timeScaledPitch)
        ## print "angleDiff: %f, timeScaledPitch: %f,  deltaPitch: %f " % (angleDiff, timeScaledPitch, self.ent.deltaPitch )
        ## print "pitch: %f, desiredPitch: %f, pitchRate: %f" % (self.ent.pitch, self.ent.desiredPitch, self.ent.pitchRate)
        self.ent.pitch = utils.fixAngle( self.ent.pitch + self.ent.deltaPitch)
        # Roll ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
        if dtime > 0.001:
            self.ent.desiredRoll = -self.ent.deltaYaw / dtime * 0.75
        timeScaledRoll = self.ent.rollRate * dtime
        angleDiff = utils.diffAngle(self.ent.desiredRoll, self.ent.roll)
        self.ent.deltaRoll = utils.clamp(angleDiff, -timeScaledRoll, timeScaledRoll)
        ## print "angleDiff: %f, timeScaledRoll: %f,  dRoll: %f " % (angleDiff, timeScaledRoll, self.ent.deltaRoll )
        ## print "roll: %f, desiredRoll: %f, rollRate: %f" % (self.ent.roll, self.ent.desiredRoll, self.ent.rollRate)
        ## print "---"
        self.ent.roll = utils.fixAngle( self.ent.roll + self.ent.deltaRoll)
        
# Physics -------------------------------------------------------------------- #
Пример #8
0
    def frameStarted(self, frameEvent):
        # If the render window has been closed, end the program.
        if(self.renderWindow.isClosed()):
            return False
 
        # Capture and update each input device.
        self.Keyboard.capture()
        self.Mouse.capture()
 
        # Get the current mouse state.
        currMouse = self.Mouse.getMouseState()
 
        # Use the Left mouse button to turn Light1 on and off.         
        if currMouse.buttonDown(OIS.MB_Left) and not self.mouseDown:
            light = self.sceneManager.getLight('Light1')
            light.visible = not light.visible
 
        # Update the mouseDown boolean.            
        self.mouseDown = currMouse.buttonDown(OIS.MB_Left)
 
        # Update the toggle timer.
        if self.toggle >= 0:
            self.toggle -= frameEvent.timeSinceLastFrame
 
        # Handle Tab selection
        if self.toggle < 0 and self.Keyboard.isKeyDown(OIS.KC_TAB):
            # Update the toggle timer.
            self.toggle = 0.1
            ent = self.entityMgr.selectedEnt
            ent.node.showBoundingBox(False)
            ent = self.entityMgr.selectNextEnt()

            print "FrameListener: Selected: ", str(ent)
            ent.node.showBoundingBox(True)
 
        # Move the camera using keyboard input.
        transVector = ogre.Vector3(0, 0, 0)
        # Move Forward.
        if self.Keyboard.isKeyDown(OIS.KC_W):
           transVector.z -= self.move
        # Move Backward.
        if self.Keyboard.isKeyDown(OIS.KC_S):
            transVector.z += self.move
        # Strafe Left.
        if self.Keyboard.isKeyDown(OIS.KC_A):
            transVector.x -= self.move
        # Strafe Right.
        if  self.Keyboard.isKeyDown(OIS.KC_D):
           transVector.x += self.move
        # Move Up.        
        if self.Keyboard.isKeyDown(OIS.KC_PGUP):
            transVector.y += self.move
        # Move Down.
        if self.Keyboard.isKeyDown(OIS.KC_PGDOWN):
            transVector.y -= self.move

#--------------------------------------------------------------------------------------
        
        #print str(self.selectedEntIndex), selectedEnt.id
        import utils
        selectedEnt = self.entityMgr.selectedEnt
        # Speed Up
        if  self.toggle < 0 and self.Keyboard.isKeyDown(OIS.KC_UP):
            self.toggle = 0.1
            selectedEnt.desiredSpeed = utils.clamp(selectedEnt.desiredSpeed + selectedEnt.deltaSpeed, 0, selectedEnt.maxSpeed)
            print "Speeding UP", selectedEnt.desiredSpeed

        # Slow down
        if  self.toggle < 0 and self.Keyboard.isKeyDown(OIS.KC_DOWN):
            self.toggle = 0.1
            selectedEnt.desiredSpeed = utils.clamp(selectedEnt.desiredSpeed - selectedEnt.deltaSpeed, 0, selectedEnt.maxSpeed)
            print "Slowing down", selectedEnt.desiredSpeed


        # Turn Left.
        if  self.toggle < 0 and self.Keyboard.isKeyDown(OIS.KC_LEFT):
            self.toggle = 0.1
            selectedEnt.desiredHeading += selectedEnt.deltaYaw
            selectedEnt.desiredHeading = utils.fixAngle(selectedEnt.desiredHeading)
            print "Turn left", selectedEnt.desiredHeading

            
        # Turn Right.
        if  self.toggle < 0 and self.Keyboard.isKeyDown(OIS.KC_RIGHT):
            self.toggle = 0.1
            selectedEnt.desiredHeading -= selectedEnt.deltaYaw
            selectedEnt.desiredHeading = utils.fixAngle(selectedEnt.desiredHeading)
            print "Turn right", selectedEnt.desiredHeading

        #print self.selectedEnt.uiname, selectedEnt.id, str(selectedEnt.vel)

 #--------------------------------------------------------------------------------------

        # Translate the camera based on time.
        self.camNode.translate(self.camNode.orientation
                              * transVector
                              * frameEvent.timeSinceLastFrame)
 
        # Rotate the camera when the Right mouse button is down.
        if currMouse.buttonDown(OIS.MB_Right):
           self.camNode.yaw(ogre.Degree(-self.rotate 
                            * currMouse.X.rel).valueRadians())
           self.camNode.getChild(0).pitch(ogre.Degree(-self.rotate
                                          * currMouse.Y.rel).valueRadians())
 
        # If the escape key is pressed end the program.
        return not self.Keyboard.isKeyDown(OIS.KC_ESCAPE)
 def Pitch(self, amount):
     ''' Pitches the Camera Pitch Node clamped by Min and Max '''
     self.camPitch = utils.fixAngle( self.camPitch + self.pitchSpeed * amount )
     self.camPitch = utils.clamp( self.camPitch, self.pitchMin, self.pitchMax )
     self.camPitchNode.resetOrientation()
     self.camPitchNode.pitch(ogre.Degree(self.camPitch).valueRadians())
 def Yaw(self, amount):
     ''' Yaws the Camera Yaw Node clamped by Min and Max '''
     self.camYaw = utils.fixAngle( self.camYaw + self.yawSpeed * amount )
     self.camYawNode.resetOrientation()
     self.camYawNode.yaw(ogre.Degree(self.camYaw).valueRadians())
Пример #11
0
 def init(self):
     diff = self.target.location - self.ent.pos
     self.ent.desiredHeading = utils.fixAngle(- math.atan2(diff.z, diff.x))
     self.ent.desiredSpeed   = self.ent.maxSpeed
Пример #12
0
 def init(self):
     diff = self.target.location - self.ent.pos
     self.ent.desiredHeading = utils.fixAngle(-math.atan2(diff.z, diff.x))
     self.ent.desiredSpeed = self.ent.maxSpeed
Пример #13
0
    def tick(self, dtime):

	if (self.ent.mesh == "sphere.mesh"):
            self.ent.vel.z = -math.cos(self.ent.heading)*self.ent.speed
            self.ent.vel.x = -math.sin(self.ent.heading)*self.ent.speed
            if self.ent.pitch != 0:
                self.ent.vel.y = self.ent.speed*math.tan(-self.ent.pitch)
            else:
                self.ent.vel.y = 0
             
            self.ent.pos = self.ent.pos + (self.ent.vel * dtime)
            squaredDistance = (self.ent.pos - self.ent.initialPos).squaredLength()
            if  squaredDistance > self.ent.distance**2:
                self.ent.isGone = True

            if self.ent.pos.y <= 0:
                self.ent.isGone = True
 
        elif self.ent.mesh == "ninja.mesh":
            #------------position--------------------------------
            self.ent.vel.z = -math.cos(self.ent.heading) * self.ent.speed
            self.ent.vel.x = -math.sin(self.ent.heading) * self.ent.speed
            self.ent.vel.y = 0
            self.ent.pos = self.ent.pos + (self.ent.vel * dtime)
            self.ent.heading = utils.fixAngle(self.ent.heading)

            if self.ent.speed != 0:
                self.ent.move = True
            else:
                self.ent.move = False
                self.ent.speed = 0

        elif (self.ent.mesh == "robot.mesh"):
 
            self.ent.move = False
            self.ent.speed = 0
            self.ent.lockOn = False

            if not self.ent.engine.gfxMgr.game3:
                self.game1(dtime)
            else:
                self.game1(dtime)
                self.game3(dtime)

            if self.ent.lockOn:
                self.ent.pos = self.ent.pos + self.ent.vel*dtime

            # update heading 
            if abs(self.ent.desiredHeading - self.ent.heading) >= 0.01:
                self.ent.heading = utils.fixAngle(self.ent.heading)
                timeScaledRotation = self.ent.turningRate * dtime
                angleDiff = utils.diffAngle(self.ent.desiredHeading, self.ent.heading)
                dheading = utils.clamp(angleDiff, -timeScaledRotation, timeScaledRotation)
                self.ent.heading += dheading
            else:
                self.ent.causion = False	


        elif self.ent.mesh == "shield.mesh":
            #-------------------------Bobbing-------------#
            if self.ent.pos.y < self.ent.bobMax and self.ent.bobReset == False:
                self.ent.pos.y += dtime*12
            elif self.ent.bobReset == True:
                self.ent.pos.y -= dtime*12

            if self.ent.pos.y >= self.ent.bobMax:
                self.ent.bobReset = True
            elif self.ent.pos.y <= self.ent.bobMin:
                self.ent.bobReset = False

            self.ent.heading += dtime