def processInput2(self, dt):
speed = Vec3(0, 0, 0)
if inputState.isSet('esc'): sys.exit()
if inputState.isSet('w'): speed.setY(35.0)
if inputState.isSet('arrow_left'): speed.setX(-35.0)
if inputState.isSet('arrow_right'): speed.setX(35.0)
if inputState.isSet('space'):
self.jump2()
self.jumpSound2.play()
if inputState.isSet('arrow_up'):
self.jump2()
self.jumpSound2.play()
if inputState.isSet('cam-left'): self.camera.setX(self.camera, -20 * dt)
if inputState.isSet('cam-right'): self.camera.setX(self.camera, +20 * dt)
if inputState.isSet('cam-forward'): self.camera.setY(self.camera, -200 * dt)
if inputState.isSet('cam-backward'): self.camera.setY(self.camera, +200 * dt)
# Make Ecco run
if self.isMoving2 is False:
self.ecco2.loop("run")
self.isMoving2 = True
if self.pos2.getY() > 1450.0:
speed.setY(0.0)
else:
speed.setY(40.0)
self.character2.setLinearMovement(speed, True)
def setWASDTurn(self, turn):
self.__WASDTurn = turn
if not self.isEnabled:
return
turnLeftWASDSet = inputState.isSet("turnLeft", inputSource=inputState.WASD)
turnRightWASDSet = inputState.isSet("turnRight", inputSource=inputState.WASD)
slideLeftWASDSet = inputState.isSet("slideLeft", inputSource=inputState.WASD)
slideRightWASDSet = inputState.isSet("slideRight", inputSource=inputState.WASD)
for token in self.WASDTurnTokens:
token.release()
# If we want Toons to be able to turn instead of sliding left to right:
if turn:
self.WASDTurnTokens = (
inputState.watchWithModifiers("turnLeft", "a", inputSource=inputState.WASD),
inputState.watchWithModifiers("turnRight", "d", inputSource=inputState.WASD),
)
inputState.set("turnLeft", slideLeftWASDSet, inputSource=inputState.WASD)
inputState.set("turnRight", slideRightWASDSet, inputSource=inputState.WASD)
inputState.set("slideLeft", False, inputSource=inputState.WASD)
inputState.set("slideRight", False, inputSource=inputState.WASD)
else:
self.WASDTurnTokens = (
inputState.watchWithModifiers("slideLeft", "a", inputSource=inputState.WASD),
inputState.watchWithModifiers("slideRight", "d", inputSource=inputState.WASD),
)
inputState.set("slideLeft", turnLeftWASDSet, inputSource=inputState.WASD)
inputState.set("slideRight", turnRightWASDSet, inputSource=inputState.WASD)
inputState.set("turnLeft", False, inputSource=inputState.WASD)
inputState.set("turnRight", False, inputSource=inputState.WASD)
def processInput(self, dt):
# Process input
engineForce = 0.0
brakeForce = 0.0
self.accept('p', self.doPause)
if inputState.isSet('forward'):
engineForce = 15.0
brakeForce = 0.0
if inputState.isSet('reverse'):
engineForce = -25.0
brakeForce = 25.0
if inputState.isSet('turnLeft'):
self.steering += dt * self.steeringIncrement
self.steering = min(self.steering, self.steeringClamp)
if inputState.isSet('turnRight'):
self.steering -= dt * self.steeringIncrement
self.steering = max(self.steering, -self.steeringClamp)
# Apply steering to front wheels
self.vehicle.setSteeringValue(self.steering, 0)
self.vehicle.setSteeringValue(self.steering, 1)
# Apply engine and brake to rear wheels
self.vehicle.applyEngineForce(engineForce, 2)
self.vehicle.applyEngineForce(engineForce, 3)
self.vehicle.setBrake(brakeForce, 2)
self.vehicle.setBrake(brakeForce, 3)
def update_movement(self,task):
"""Task that updates the walking animation on our GravityWalker
TODO - Stop using gravity walker and implement ODE physics?
If using ODE or something other than gravitywalker, handle controls
for movement here
"""
# Adjust to match the walkcycle, to minimize sliding
self.entities['PC'].Actor.setPlayRate(0.5 * \
self.entities['PC'].physics['playerWalker'].speed,
'walk')
#Check if the player is moving. If so, play walk animation
if inputState.isSet('forward') or inputState.isSet('reverse') or \
inputState.isSet('turnLeft') or inputState.isSet('turnRight'):
if self.controls['isMoving'] is False:
self.entities['PC'].Actor.loop('walk')
self.controls['isMoving'] = True
else:
if self.controls['isMoving']:
print 'stopped'
self.entities['PC'].Actor.stop()
self.entities['PC'].Actor.loop('idle')
self.controls['isMoving'] = False
#Done here
return Task.cont
def processInput(self, dt):
speed = Vec3(0, 0, 0)
omega = 0.0
# Change speed of robot
if inputState.isSet('forward'): speed.setY(24.0)
if inputState.isSet('reverse'): speed.setY(-4.0)
if inputState.isSet('left'): speed.setX(-3.0)
if inputState.isSet('right'): speed.setX(3.0)
if inputState.isSet('turnLeft'): omega = 120.0
if inputState.isSet('turnRight'): omega = -120.0
if inputState.isSet('forward') or inputState.isSet('reverse') or inputState.isSet('left') or \
inputState.isSet('right'):
if self.isNotWalking is False:
self.actorNP.loop("walk")
self.isNotWalking = True
else:
if self.isNotWalking:
self.actorNP.stop()
self.actorNP.loop("idle")
self.isNotWalking = False
if self.character.isOnGround() and self.isJumping:
if self.isNotWalking:
self.actorNP.stop("jump")
self.actorNP.loop("walk")
self.isJumping = False
self.character.setAngularMovement(omega)
self.character.setLinearMovement(speed, True)
def __mouseUpdateTask(self):
if hasattr(base, 'oobeMode'):
if base.oobeMode:
return task.cont
subjectMoving = self.isSubjectMoving()
subjectTurning = False
if not inputState.isSet('turnRigt'):
if inputState.isSet('turnLeft'):
subjectTurning = self.subject.controlManager.isEnabled
weaponEquipped = self.isWeaponEquipped()
if not subjectMoving:
if weaponEquipped:
hNode = self.subject
else:
hNode = self
if not self.mouseDelta[0]:
if self.mouseDelta[1]:
dx, dy = self.mouseDelta
if subjectTurning:
dx = 0
if hasattr(base, 'options'):
if base.options.mouse_look:
dy = -dy
hNode.setH(hNode, -dx * self.SensitivityH)
curP = self.getP()
newP = curP * -dy + self.SensitivityP
newP = min(max(newP, self.MinP), self.MaxP)
self.setP(newP)
if self.baseH:
messenger.send('pistolMoved')
self.__checkHBounds(hNode)
self.setR(render)
return task.cont
def __update(self, task):
'''
Task task: Time since last frame
'''
try:
dt = globalClock.getDt();
if dt > .1:
return Task.cont
moveAmount = 50*dt;
changeY = (inputState.isSet('foward')-inputState.isSet('backward'))*moveAmount
changeX = (inputState.isSet('right')-inputState.isSet('left'))*moveAmount;
stepSize = 1.0 / 60.0
#set up a fixed time constant step for more accurate physics.
#We need to test more with the vehicle class to see if it plays nice.
self._deltaTimeAccumulator += globalClock.getDt()
while self._deltaTimeAccumulator> stepSize :
self.__bulletWorld.doPhysics(stepSize)
self._deltaTimeAccumulator -= stepSize;
base.cam.setPos(base.cam,changeX,changeY,0);
hpr = base.cam.getHpr();
if base.mouseWatcherNode.hasMouse() and self.doMouseStuff:
hpr.x = -100*base.mouseWatcherNode.getMouseX()
hpr.y = 100*base.mouseWatcherNode.getMouseY();
base.cam.setHpr(hpr);
except:
print "error tankworld.__update"
return task.cont
def processInput(self, dt, up, back, left, right, brake):
engineForce = 0.0
brakeForce = 0.0
#direction=self.getForwardVector()
if inputState.isSet(up):
engineForce = 2000.0
brakeForce = 0.0
if inputState.isSet(back):
engineForce = -1000.0
brakeForce = 0.0
if inputState.isSet(brake):
engineForce = 0.0
brakeForce = 1000.0
if inputState.isSet(left):
self.steering += dt * self.steeringIncrement
self.steering = min(self.steering, self.steeringClamp)
elif inputState.isSet(right):
self.steering -= dt * self.steeringIncrement
self.steering = max(self.steering, -self.steeringClamp)
else:
self.steering=self.steering*0.7
# Apply steering to front wheels
self.setSteeringValue(self.steering, 0)
self.setSteeringValue(self.steering, 1)
# Apply engine and brake to rear wheels
self.applyEngineForce(engineForce, 2)
self.applyEngineForce(engineForce, 3)
self.setBrake(brakeForce, 2)
self.setBrake(brakeForce, 3)
def _calcSpeeds(self):
# get the button states:
forward = inputState.isSet("forward")
reverse = inputState.isSet("reverse")
turnLeft = inputState.isSet("turnLeft")
turnRight = inputState.isSet("turnRight")
slide = inputState.isSet(self.slideName) or 0
#jump = inputState.isSet("jump")
# Check for Auto-Run
if base.localAvatar.getAutoRun():
forward = 1
reverse = 0
# Determine what the speeds are based on the buttons:
self.speed=(forward and self.avatarControlForwardSpeed or
reverse and -self.avatarControlReverseSpeed)
# Should fSlide be renamed slideButton?
self.slideSpeed=slide and ((reverse and turnLeft and -self.avatarControlReverseSpeed*(0.75)) or
(reverse and turnRight and self.avatarControlReverseSpeed*(0.75)) or
(turnLeft and -self.avatarControlForwardSpeed*(0.75)) or
(turnRight and self.avatarControlForwardSpeed*(0.75)))
self.rotationSpeed=not slide and (
(turnLeft and self.avatarControlRotateSpeed) or
(turnRight and -self.avatarControlRotateSpeed))
def __pollMouseHeldDown(self, task):
if not hasattr(self, 'mouseDownName'):
return Task.done
if inputState.isSet(self.mouseDownName) and not self.isCharging:
self.startCharging()
elif not inputState.isSet(self.mouseDownName) and self.isCharging:
self.stopCharging()
return Task.cont
def processInputInZero(self, dt):
if self.tagOfForward == 0 and self.tagOfReverse == 0 and self.tagOfLeft == 0 and self.tagOfRight == 0:
if inputState.isSet('forward'):
self.tagOfForward = 1
if inputState.isSet('reverse'):
self.tagOfReverse = 1
if inputState.isSet('left'):
self.tagOfLeft = 1
if inputState.isSet('right'):
self.tagOfRight = 1
def enterActive(self):
OrbitCamera.enterActive(self)
self.accept('wheel_up', self._handleWheelUp)
self.accept('wheel_down', self._handleWheelDown)
self._scInputState = ScratchPad()
self._scInputState.rmbPressed = False
self._scInputState.fwdPressed = False
self._scInputListener = DirectObject.DirectObject()
self._scInputListener.accept(inputState.getEventName('RMB'), self._handleRmbEvent)
self._handleRmbEvent(inputState.isSet('RMB'))
self._scInputListener.accept(inputState.getEventName('forward'), self._handleForwardEvent)
self._handleForwardEvent(inputState.isSet('forward'))
def _calcSpeeds(self):
forward = inputState.isSet('forward')
reverse = inputState.isSet('reverse')
turnLeft = inputState.isSet('turnLeft')
turnRight = inputState.isSet('turnRight')
if not inputState.isSet(self.slideName):
slide = 0
forward = base.localAvatar.getAutoRun() and 1
reverse = 0
self.speed = forward and self.avatarControlForwardSpeed or reverse and -self.avatarControlReverseSpeed
self.slideSpeed = slide and reverse and turnLeft and -self.avatarControlReverseSpeed * 0.75 or reverse and turnRight and self.avatarControlReverseSpeed * 0.75 or turnLeft and -self.avatarControlForwardSpeed * 0.75 or turnRight and self.avatarControlForwardSpeed * 0.75
self.rotationSpeed = not slide and turnLeft and self.avatarControlRotateSpeed or turnRight and -self.avatarControlRotateSpeed
def processInput(self, dt):
force = Vec3(0, 0, 0)
if inputState.isSet('up'): force.setY( 1.0)
if inputState.isSet('down'): force.setY(-1.0)
if inputState.isSet('left'): force.setX(-1.0)
if inputState.isSet('right'): force.setX( 1.0)
force *= 300.0
self.bowlNP.node().setActive(True)
self.bowlNP.node().applyCentralForce(force)
def useBasicPlayerMovement(cls, _engine, dt):
"""This sets up a basic movement for the playercontroller"""
# get the player
player = _engine.GameObjects["player"]
speed = Vec3(0, 0, 0)
omega = 0.0
requestAnim = "Idle"
if not player.bulletBody.isOnGround() and player.bulletBody.movementState != "flying":
requestAnim = "Fall"
elif player.groundPosTestTick >= 10:
player.lastGroundPos = player.bulletBody.getPos()
player.groundPosTestTick = 0
else:
player.groundPosTestTick += 1
if inputState.isSet('forward'): speed.setY(player.runSpeed); requestAnim="Run"
if inputState.isSet('reverse'): speed.setY(-player.runSpeed); requestAnim="Walk"
if inputState.isSet('left'): speed.setX(-player.runSpeed); requestAnim="Walk"
if inputState.isSet('right'): speed.setX(player.runSpeed); requestAnim="Walk"
if inputState.isSet('turnLeft'): omega = player.turnSpeed; requestAnim="Walk"
if inputState.isSet('turnRight'): omega = -player.turnSpeed; requestAnim="Walk"
if inputState.isSet('space'): PlayerPhysics.doPlayerJump(player.bulletBody, player.jumpHeight); requestAnim="Jump"
if inputState.isSet('ctrl'): PlayerPhysics.doPlayerCrouch(player)
## In grabState
if player.inGrabMode:
if inputState.isSet('climb'): player.exitGrabMode()
elif inputState.isSet('fall'): player.exitGrabMode(False)
if not player.bulletBody.isOnGround() and player.bulletBody.movementState != "flying":
# as we fall, set the fall animation
if not player.actor.getAnimControl("jump").isPlaying() \
or (player.actor.getAnimControl("jump").isPlaying()
and player.playingAnim == "Fall"):
requestAnim = "Fall"
else:
requestAnim = "Jump"
if omega == 0:
omega = _engine.inputHandler.getMouse(dt)
player.bulletBody.setAngularMovement(omega)
player.bulletBody.setLinearMovement(speed, True)
player.bulletBody.update()
player.requestState(player, requestAnim)
if player.inGrabMode:
rayHit = PlayerPhysics.doRayTest(_engine, player.bulletBody)
if rayHit != None:
speed.setY(0)
player.bulletBody.movementParent.lookAt(player.bulletBody.getPos() - rayHit)
return
def processInput(self, dt):
print(self.direction)
speed = Vec3(0, 0, 0)
#@param PCSpeed: Player move speed under devconfig.py
if inputState.isSet('forward'): speed.setY( PCSpeed)
if inputState.isSet('reverse'): speed.setY(-PCSpeed)
if inputState.isSet('left'): speed.setX(-PCSpeed)
if inputState.isSet('right'): speed.setX( PCSpeed)
self.character.setAngularMovement(self.omega)
self.character.setLinearMovement(speed, True)
def walk(self, dt):
self.node.setHpr(0,0,0)
self.actor_node.setPos(self.node.getPos(render))
speed= self.actor_node.getRelativeVector(render, self.physic_node.getLinearVelocity())
speed_co=1.05-max(0.01, abs(speed.y))/8.0
#print speed_co
force = Vec3(0, 0, 0.0)
if self.flying_time>0.4 and self.actor.getCurrentAnim()!='jump':
self.actor.pose('jump', 20)
if self.flying_time>3.0:
print "reset!"
Sequence(Wait(0.1), Func(self._resetMass)).start()
self.node.node().setMass(0.0)
self.node.setPos(self.last_know_ground_pos) # this should work...
self.node.setZ(self.node.getZ(render)+1.0) #wrong some times
self.node.setY(self.node.getY(render)+1.0) #this may be wrong
self.physic_node.setLinearVelocity(Vec3(0,0,0))#is this needed?
self.flying_time=0.0
return
if self.isOnGround():
if self.flying_time> 0.8:
self.actor.play('recover')
self.physic_node.setLinearVelocity(Vec3(0,0,0))
self.flying_time=0.0
if self.actor.getCurrentAnim() not in ('jump', 'recover'):
if speed.y>3.5:
if self.actor.getCurrentAnim()!= 'run':
self.actor.loop('run')
self.actor.setPlayRate((speed.y*0.5)-1.0,'run')
else:
if self.actor.getCurrentAnim()!= 'walk':
self.actor.loop('walk')
self.actor.setPlayRate((speed.y*0.7),'walk')
if self.actor.getCurrentAnim()!='recover':
#if inputState.isSet('run'): v = 75 *dt
if inputState.isSet('forward'):
force.setY(self.move_force*dt*speed_co)
if inputState.isSet('reverse'):
force.setY(-0.5*self.move_force*dt*speed_co)
if inputState.isSet('turnLeft'):
self.actor_node.setH(self.actor_node, 90.0*dt)
if inputState.isSet('turnRight'):
self.actor_node.setH(self.actor_node, -90.0*dt)
#if force.getY()==0.0:
# self.physic_node.setLinearVelocity(speed*0.5)
else:
self.flying_time+=dt
if inputState.isSet('forward'):
force.setY(0.2*self.move_force*dt)
if inputState.isSet('reverse'):
force.setY(-0.2*self.move_force*dt)
if inputState.isSet('turnLeft'):
force.setX(-0.2*self.move_force*dt)
if inputState.isSet('turnRight'):
force.setX(0.2*self.move_force*dt)
force = render.getRelativeVector(self.actor_node, force)
self.physic_node.applyCentralForce(force)
def _updatePositions(self, task):
try:
dt = 1.0/60
if dt > .1:
return Task.cont
moveAmount = 50*dt;
changeY = (inputState.isSet('foward')-inputState.isSet('backward'))*moveAmount
changeX = (inputState.isSet('right')-inputState.isSet('left'))*moveAmount;
base.cam.setPos(base.cam,changeX,changeY,0)
hpr = base.cam.getHpr()
if base.mouseWatcherNode.hasMouse() and self.doMouseStuff:
hpr.x = -100*base.mouseWatcherNode.getMouseX()
hpr.y = 100*base.mouseWatcherNode.getMouseY()
base.cam.setHpr(hpr)
except:
print "error in TankWorld._updatePositions"
self._lastTime = self._displayTime
self._displayTime = globalClock.getRealTime() - self.startTime
self.frameTime += self.displaySpeed * (self._displayTime - self._lastTime)
self.frame = int(60 * self.frameTime)
#print self.frame, (self._displayTime - self._lastTime)
if self.frame < len(self.gameData) - 1:
frameData = self.gameData[self.frame]
#print 'TankWorld._updatePositions: ', self._displayTime, self.frame, len(self.gameData)
for i in range(len(self.dynamics)):
dynamic = self.dynamics[i]
if i < len(frameData):
dynamic.show()
dynData = frameData[i]
if (len(dynData) == 6):
dynamic.setPos(Point3(dynData[0], dynData[1], dynData[2]))
dynamic.setHpr(Point3(dynData[3], dynData[4], dynData[5]))
else:
dynamic.hide()
else:
dynamic.hide()
return task.cont
def listFromInputState(self, inputState):
# index 0 == forward
# index 1 == brake
# index 2 == right
# index 3 == left
result = [0, 0, 0, 0]
if inputState.isSet('forward'):
result[0] = 1
if inputState.isSet('brake'):
result[1] = 1
if inputState.isSet('right'):
result[2] = 1
if inputState.isSet('left'):
result[3] = 1
return result
def doMovement(self, _mousePos):
playerBody = self.player.pPhysicsBody
speed = Vec3(0, 0, 0)
jump = Vec3(0, 0, 0)
force = 4.0
jumpForce = 1.5
speed = _mousePos
'''
if inputState.isSet('left'):
speed.setX(-force)
if inputState.isSet('right'):
speed.setX(force)
if inputState.isSet('up'):
#setY(force)
print speed
if inputState.isSet('down'):
speed =- _mousePos #setY(-force)
'''
if inputState.isSet('space'):
self.checkFloorCollide()
if self.isFloating != True:
jump.setZ(jumpForce)
self.isFloating = True
elif self.isFloating == True:
jump.setZ(0.0)
#self.game.isFloating = False
playerBody.node().setActive(True)
playerBody.node().applyCentralForce(speed)
playerBody.node().applyCentralImpulse(jump)
def contact_made(self):
result = self.__game.world.contactTestPair(self.np.node(),self.__game.eve.currentControllerNode)
if inputState.isSet('forward') and self.name.find('Fall') < 0:
self.__game.taskMgr.remove(self.name)
return
if len(result.getContacts()) > 0:
if len(self.__game.taskMgr.getTasksNamed(self.name)) == 0 and self.name.find('Fall') < 0:
p_x = self.np.getX()
p_y = self.np.getY()
p_z = self.np.getZ()
a_x = self.__game.eve.currentNP.getX()
a_y = self.__game.eve.currentNP.getY()
a_z = self.__game.eve.currentNP.getZ()
dx = a_x - p_x
dy = a_y - p_y
dz = a_z - p_z
self.__game.taskMgr.add(self.sync_movement,self.name, extraArgs=[dx,dy,dz],appendTask=True)
self.__game.tasks.append(self.name)
elif len(self.__game.taskMgr.getTasksNamed(self.name)) == 0 and self.name.find('Fall') >= 0:
start = globalClock.getRealTime()
self.__game.taskMgr.add(self.fall_countdown,self.name, extraArgs=[start],appendTask=True)
self.__game.tasks.append(self.name)
elif self.name.find('Fall') < 0:
self.__game.taskMgr.remove(self.name)
def movementTask(self, task):
if not inputState.isSet('jump') and not base.localAvatar.walkControls.isAirborne and inputState.isSet('forward') or inputState.isSet('reverse') or inputState.isSet('slideLeft') or inputState.isSet('slideRight'):
if base.localAvatar.getAnimState() != 'run':
base.localAvatar.setAnimState('run')
base.localAvatar.playMovementSfx('run')
self.mg.sendUpdate('runningAvatar', [base.localAvatar.doId])
elif inputState.isSet('jump') or base.localAvatar.walkControls.isAirborne:
if base.localAvatar.getAnimState() != 'jump':
base.localAvatar.setAnimState('jump')
base.localAvatar.playMovementSfx(None)
self.mg.sendUpdate('jumpingAvatar', [base.localAvatar.doId])
elif base.localAvatar.getAnimState() != 'neutral':
base.localAvatar.setAnimState('neutral')
base.localAvatar.playMovementSfx(None)
self.mg.sendUpdate('standingAvatar', [base.localAvatar.doId])
return Task.cont
def handleAvatarControls(self, task):
"""
Check on the arrow keys and update the avatar.
"""
if not self.lifter.hasContact():
# hack fix for falling through the floor:
messenger.send("walkerIsOutOfWorld", [self.avatarNodePath])
self._calcSpeeds()
if __debug__:
debugRunning = inputState.isSet("debugRunning")
if debugRunning:
self.speed*=4.0
self.slideSpeed*=4.0
self.rotationSpeed*=1.25
if self.wantDebugIndicator:
self.displayDebugInfo()
# How far did we move based on the amount of time elapsed?
dt=ClockObject.getGlobalClock().getDt()
# Check to see if we're moving at all:
if self.speed or self.slideSpeed or self.rotationSpeed:
if self.stopThisFrame:
distance = 0.0
slideDistance = 0.0
rotation = 0.0
self.stopThisFrame = 0
else:
distance = dt * self.speed
slideDistance = dt * self.slideSpeed
rotation = dt * self.rotationSpeed
# Take a step in the direction of our previous heading.
self.vel=Vec3(Vec3.forward() * distance +
Vec3.right() * slideDistance)
if self.vel != Vec3.zero():
# rotMat is the rotation matrix corresponding to
# our previous heading.
rotMat=Mat3.rotateMatNormaxis(self.avatarNodePath.getH(), Vec3.up())
step=rotMat.xform(self.vel)
self.avatarNodePath.setFluidPos(Point3(self.avatarNodePath.getPos()+step))
self.avatarNodePath.setH(self.avatarNodePath.getH()+rotation)
messenger.send("avatarMoving")
else:
self.vel.set(0.0, 0.0, 0.0)
self.__oldPosDelta = self.avatarNodePath.getPosDelta(render)
self.__oldDt = dt
try:
self.worldVelocity = self.__oldPosDelta*(1/self.__oldDt)
except:
# divide by zero
self.worldVelocity = 0
return Task.cont
def update_camera(self,task):
if self.camera_views['normal'] is True:
self.normal_view()
elif self.camera_views['top'] is True:
self.top_view()
elif self.camera_views['right'] is True:
self.right_view()
elif self.camera_views['left'] is True:
self.left_view()
elif self.camera_views['first_person'] is True:
self.first_person()
if inputState.isSet('camera_up'):
if base.camera.getP() < 45:
base.camera.setP(base.camera.getP() + 1)
if inputState.isSet('camera_down'):
if base.camera.getP() > -90:
base.camera.setP(base.camera.getP() - 1)
return task.cont
def trackAnimToSpeed(self, task):
speed, rotSpeed, slideSpeed = self.controlManager.getSpeeds()
if speed != 0.0 or rotSpeed != 0.0 or inputState.isSet('jump'):
if not self.movingFlag:
self.movingFlag = 1
self.stopLookAround()
elif self.movingFlag:
self.movingFlag = 0
self.startLookAround()
if self.movingFlag or self.hp <= 0:
self.wakeUp()
elif not self.sleepFlag:
now = globalClock.getFrameTime()
if now - self.lastMoved > self.sleepTimeout:
self.gotoSleep()
state = None
if self.sleepFlag:
state = 'Sleep'
elif self.hp > 0:
state = 'Happy'
else:
state = 'Sad'
if state != self.lastState:
self.lastState = state
self.b_setAnimState(state, self.animMultiplier)
if state == 'Sad':
self.setWalkSpeedSlow()
else:
self.setWalkSpeedNormal()
if self.cheesyEffect == OTPGlobals.CEFlatProfile or self.cheesyEffect == OTPGlobals.CEFlatPortrait:
needH = None
if rotSpeed > 0.0:
needH = -10
elif rotSpeed < 0.0:
needH = 10
elif speed != 0.0:
needH = 0
if needH != None and self.lastNeedH != needH:
node = self.getGeomNode().getChild(0)
lerp = Sequence(LerpHprInterval(node, 0.5, Vec3(needH, 0, 0), blendType='easeInOut'), name='cheesy-lerp-hpr', autoPause=1)
lerp.start()
self.lastNeedH = needH
else:
self.lastNeedH = None
action = self.setSpeed(speed, rotSpeed)
if action != self.lastAction:
self.lastAction = action
if self.emoteTrack:
self.emoteTrack.finish()
self.emoteTrack = None
if action == OTPGlobals.WALK_INDEX or action == OTPGlobals.REVERSE_INDEX:
self.walkSound()
elif action == OTPGlobals.RUN_INDEX:
self.runSound()
else:
self.stopSound()
return Task.cont
def trackAnimToSpeed(self, task):
speed, rotSpeed, slideSpeed = self.controlManager.getSpeeds()
if (speed != 0.0) or (rotSpeed != 0.0):
if inputState.isSet('jump') and (not self.movingFlag):
self.movingFlag = 1
self.stopLookAround()
elif (not inputState.isSet('jump')) and self.movingFlag:
self.movingFlag = 0
self.startLookAround()
action = self.setSpeed(speed, rotSpeed)
if action != self.lastAction:
self.lastAction = action
self.stopSound()
if (action == WALK_INDEX) or (action == REVERSE_INDEX):
self.walkSound()
elif action == RUN_INDEX:
self.runSound()
return Task.cont
def processEveInput(self):
if self.currentControllerNode.isOnGround() is True:
self.speed = Vec3(0, 0, 0)
self.omega = 0.0
if inputState.isSet('forward'):
if self.state['rolling'] == True:
self.speed.setY( Eve.INITIAL_ROLL_SPEED)
else:
self.speed.setY( Eve.RUNNING_SPEED)
self.currentNode.setP(15)
if inputState.isSet('backwards'):
if self.state['rolling'] == True:
self.speed.setY( Eve.INITIAL_ROLL_SPEED - 300)
else:
self.speed.setY(-1 * Eve.RUNNING_SPEED - 10)
if inputState.isSet('turnLeft'):
self.omega = Eve.OMEGA
if self.speed.getY() == 0:
self.currentNode.setR(0)
else:
self.currentNode.setR(15)
if inputState.isSet('turnRight'):
self.omega = Eve.OMEGA * -1
if self.speed.getY() == 0:
self.currentNode.setR(0)
else:
self.currentNode.setR(-15)
self.currentControllerNode.setAngularMovement(self.omega)
if self.currentControllerNode.isOnGround() is False:
self.currentControllerNode.setAngularMovement(0.0)
self.currentControllerNode.setLinearMovement(self.speed, True)
self.currentNode.setR(0)
if self.currentControllerNode.isOnGround() is True and self.currentNode.getCurrentAnim() == 'jump':
self.currentNode.setR(0)
self.currentControllerNode.setAngularMovement(0.0)
self.currentControllerNode.setLinearMovement(0.0, True)
if self.currentControllerNode.isOnGround() is True and self.currentNode.getCurrentAnim() != 'jump':
self.currentControllerNode.setAngularMovement(self.omega)
self.currentControllerNode.setLinearMovement(self.speed, True)
def processInput(self, dt):
force = Vec3(0, 0, 0)
torque = Vec3(0, 0, 0)
#print self.pTo.getY()
if inputState.isSet('forward'):
if(self.pTo.getZ() < 40):
self.pTo.addZ(0.5)
if inputState.isSet('reverse'):
if(self.pTo.getZ() > 0 ):
self.pTo.addZ(-0.5)
if inputState.isSet('left'):
if(self.pTo.getY() < 100):
self.pTo.addY(0.5)
self.arrow.setScale(self.arrow.getSx(),self.arrow.getSy()-0.006,self.arrow.getSz())
if inputState.isSet('right'):
if(self.pTo.getY() > 60):
self.pTo.addY(-0.5)
self.arrow.setScale(self.arrow.getSx(),self.arrow.getSy()+0.006,self.arrow.getSz())
self.arrow.lookAt(self.pTo)
def processInputOutZero(self, dt):
speed = Vec3(0, 0, 0)
# torque = Vec3(0, 0, 0)
if inputState.isSet('forward'):
speed.setX(1.0)
if inputState.isSet('reverse'):
speed.setX(-1.0)
if inputState.isSet('left'):
speed.setY(1.0)
if inputState.isSet('right'):
speed.setY(-1.0)
speed *= 6.0
# torque *= 10.0
# speed = render.getRelativeVector(self.boxNP, speed)
# torque = render.getRelativeVector(self.boxNP, torque)
for i in range(100):
# #print "a"
self.characterNP.node().setLinearMovement(speed, True)
def postUpdate(self):
planet = Point3.zero()
normal = Vec3(self.playernp.getX() - planet.getX(), self.playernp.getY() - planet.getY(), self.playernp.getZ() - planet.getZ())
normal.normalize()
fwd = render.getRelativePoint(self.playernp, Vec3(0, 1, 0))
self.playernp.headsUp(fwd, normal)
self.__currentPos = self.playernp.getPos()
#player movement
#space physcis
#speed = self.playernp.node().getLinearVelocity()
#normal physcis
speed = Vec3(0, 0, 0)
omega = 0.0
v = 5.8
if inputState.isSet('forward'): speed.setY(v)
if inputState.isSet('reverse'): speed.setY(-v)
if inputState.isSet('left'): speed.setX(-v)
if inputState.isSet('right'): speed.setX(v)
if inputState.isSet('flyUp'): speed.setZ( 2.0)
if inputState.isSet('flyDown'): speed.setZ( -2.0)
if inputState.isSet('turnLeft'): omega = 40.0
if inputState.isSet('turnRight'): omega = -40.0
self.playernp.setH(self.playernp, omega * globalClock.getDt())
globalVel = self.playernp.getQuat(render).xform(speed) * globalClock.getDt()
normalVel = Vec3(globalVel)
normalVel.normalize()
if globalVel != Vec3():
globalVelDir = Vec3(globalVel)
globalVelDir.normalize()
fn = Vec3(0.0, 0.0, 0.0)
fn.normalize()
velDot = 1.0 - globalVelDir.angleDeg(fn) / 180.0
if velDot < 0.5:
self.__currentPos -= Vec3(fn.x * globalVel.x, fn.y * globalVel.y, globalVel.z * globalVel.y) * velDot
globalVel *= velDot
self.__currentPos += globalVel
self.playernp.setPos(self.__currentPos)
def setWASDTurn(self, turn):
self.__WASDTurn = turn
if not self.isEnabled:
return
turnLeftWASDSet = inputState.isSet("turnLeft", inputSource=inputState.WASD)
turnRightWASDSet = inputState.isSet("turnRight", inputSource=inputState.WASD)
slideLeftWASDSet = inputState.isSet("slideLeft", inputSource=inputState.WASD)
slideRightWASDSet = inputState.isSet("slideRight", inputSource=inputState.WASD)
for token in self.WASDTurnTokens:
token.release()
if turn:
self.WASDTurnTokens = (
inputState.watchWithModifiers("turnLeft", "a", inputSource=inputState.WASD),
inputState.watchWithModifiers("turnRight", "d", inputSource=inputState.WASD),
)
inputState.set("turnLeft", slideLeftWASDSet, inputSource=inputState.WASD)
inputState.set("turnRight", slideRightWASDSet, inputSource=inputState.WASD)
inputState.set("slideLeft", False, inputSource=inputState.WASD)
inputState.set("slideRight", False, inputSource=inputState.WASD)
else:
self.WASDTurnTokens = (
inputState.watchWithModifiers("slideLeft", "a", inputSource=inputState.WASD),
inputState.watchWithModifiers("slideRight", "d", inputSource=inputState.WASD),
)
inputState.set("slideLeft", turnLeftWASDSet, inputSource=inputState.WASD)
inputState.set("slideRight", turnRightWASDSet, inputSource=inputState.WASD)
inputState.set("turnLeft", False, inputSource=inputState.WASD)
inputState.set("turnRight", False, inputSource=inputState.WASD)
def update(self, task):
if self.debug == True:
self.debugNP.show()
else:
self.debugNP.hide()
angleDegrees = task.time * 1000.0
angleRadians = angleDegrees * (pi / 180.0)
self.models.Cylinder1.setHpr(angleRadians, 0, 0)
self.models.np16.setHpr(angleRadians, 0, 0)
self.models.Cylinder2.setHpr(-angleRadians, 0, 0)
self.models.np17.setHpr(-angleRadians, 0, 0)
self.models.Cylinder3.setHpr(angleRadians, 0, 0)
self.models.np18.setHpr(angleRadians, 0, 0)
self.models.Cylinder4.setHpr(-angleRadians, 0, 0)
self.models.np19.setHpr(-angleRadians, 0, 0)
if self.models.np19.is_empty(
) == False and self.models.Cylinder4.is_empty() == False:
if self.testWithSingleBody(
self.models.node19) == True and inputState.isSet(
'forward') == False and inputState.isSet(
'reverse') == False and inputState.isSet(
'turnLeft') == False and inputState.isSet(
'turnRight') == False and inputState.isSet(
'jump') == False:
self.characterNP.setPos(0, -5, 220)
self.mySoundEndFx.play()
return task.cont
def setWASDTurn(self, turn):
self.__WASDTurn = turn
if not self.isEnabled:
return
keymap = settings.get('keymap', {})
turnLeftWASDSet = inputState.isSet('turnLeft', inputSource=inputState.WASD)
turnRightWASDSet = inputState.isSet('turnRight', inputSource=inputState.WASD)
slideLeftWASDSet = inputState.isSet('slideLeft', inputSource=inputState.WASD)
slideRightWASDSet = inputState.isSet('slideRight', inputSource=inputState.WASD)
for token in self.WASDTurnTokens:
token.release()
if turn:
self.WASDTurnTokens = (inputState.watchWithModifiers('turnLeft', keymap.get('MOVE_LEFT', base.MOVE_LEFT), inputSource=inputState.WASD), inputState.watchWithModifiers('turnRight', keymap.get('MOVE_RIGHT', base.MOVE_RIGHT), inputSource=inputState.WASD))
inputState.set('turnLeft', slideLeftWASDSet, inputSource=inputState.WASD)
inputState.set('turnRight', slideRightWASDSet, inputSource=inputState.WASD)
inputState.set('slideLeft', False, inputSource=inputState.WASD)
inputState.set('slideRight', False, inputSource=inputState.WASD)
else:
self.WASDTurnTokens = (inputState.watchWithModifiers('slideLeft', keymap.get('MOVE_LEFT', base.MOVE_LEFT), inputSource=inputState.WASD), inputState.watchWithModifiers('slideRight', keymap.get('MOVE_RIGHT', base.MOVE_RIGHT), inputSource=inputState.WASD))
inputState.set('slideLeft', turnLeftWASDSet, inputSource=inputState.WASD)
inputState.set('slideRight', turnRightWASDSet, inputSource=inputState.WASD)
inputState.set('turnLeft', False, inputSource=inputState.WASD)
inputState.set('turnRight', False, inputSource=inputState.WASD)
def handleAvatarControls(self, task):
if not self.lifter.hasContact():
messenger.send('walkerIsOutOfWorld', [self.avatarNodePath])
forward = inputState.isSet('forward')
reverse = inputState.isSet('reverse')
turnLeft = inputState.isSet('turnLeft') or inputState.isSet(
'slideLeft')
turnRight = inputState.isSet('turnRight') or inputState.isSet(
'slideRight')
slideLeft = inputState.isSet('slideLeft')
slideRight = inputState.isSet('slideRight')
if base.localAvatar.getAutoRun():
forward = 1
reverse = 0
self.speed = forward and self.avatarControlForwardSpeed or reverse and -self.avatarControlReverseSpeed
self.slideSpeed = reverse and slideLeft and -self.avatarControlReverseSpeed * 0.75 or reverse and slideRight and self.avatarControlReverseSpeed * 0.75 or slideLeft and -self.avatarControlForwardSpeed * 0.75 or slideRight and self.avatarControlForwardSpeed * 0.75
self.rotationSpeed = not (slideLeft or slideRight) and (
turnLeft and self.avatarControlRotateSpeed
or turnRight and -self.avatarControlRotateSpeed)
if self.wantDebugIndicator:
self.displayDebugInfo()
dt = ClockObject.getGlobalClock().getDt()
self.moving = self.speed or self.slideSpeed or self.rotationSpeed
if self.moving:
if self.stopThisFrame:
distance = 0.0
slideDistance = 0.0
rotation = 0.0
self.stopThisFrame = 0
else:
distance = dt * self.speed
slideDistance = dt * self.slideSpeed
rotation = dt * self.rotationSpeed
self.vel = Vec3(Vec3.forward() * distance +
Vec3.right() * slideDistance)
if self.vel != Vec3.zero():
rotMat = Mat3.rotateMatNormaxis(self.avatarNodePath.getH(),
Vec3.up())
step = rotMat.xform(self.vel)
self.avatarNodePath.setFluidPos(
Point3(self.avatarNodePath.getPos() + step))
self.avatarNodePath.setH(self.avatarNodePath.getH() + rotation)
messenger.send('avatarMoving')
else:
self.vel.set(0.0, 0.0, 0.0)
return task.cont
def isSubjectMoving(self):
if 'localAvatar' in __builtins__:
autoRun = localAvatar.getAutoRun()
else:
autoRun = False
return (inputState.isSet('forward') or inputState.isSet('reverse') or
inputState.isSet('turnRight') or inputState.isSet('turnLeft')
or inputState.isSet('slideRight')
or inputState.isSet('slideLeft')
or autoRun) and self.subject.controlManager.isEnabled
def processInput(self, dt):
speed = Vec3(0, 0, 0)
omega = 0.0
v = 5.0
if inputState.isSet('run'): v = 15.0
if inputState.isSet('forward'): speed.setY(v)
if inputState.isSet('reverse'): speed.setY(-v)
if inputState.isSet('left'): speed.setX(-v)
if inputState.isSet('right'): speed.setX(v)
if inputState.isSet('flyUp'): speed.setZ(2.0)
if inputState.isSet('flyDown'): speed.setZ(-2.0)
if inputState.isSet('turnLeft'): omega = 120.0
if inputState.isSet('turnRight'): omega = -120.0
self.character.setAngularMovement(omega)
self.character.setLinearMovement(speed, True)
def sleepSwimTest(self, task):
now = globalClock.getFrameTime()
speed, rotSpeed, slideSpeed = self.controlManager.getSpeeds()
if speed != 0.0 or rotSpeed != 0.0 or inputState.isSet('jump'):
if not self.swimmingFlag:
self.swimmingFlag = 1
elif self.swimmingFlag:
self.swimmingFlag = 0
if self.swimmingFlag or self.hp <= 0:
self.wakeUp()
elif not self.sleepFlag:
now = globalClock.getFrameTime()
if now - self.lastMoved > self.swimTimeout:
self.swimTimeoutAction()
return Task.done
return Task.cont
def _calcSpeeds(self):
forward = inputState.isSet('forward')
reverse = inputState.isSet('reverse')
if not inputState.isSet('turnLeft'):
turnLeft = inputState.isSet('slideLeft')
turnRight = inputState.isSet('turnRight') or inputState.isSet('slideRight')
forward = base.localAvatar.getAutoRun() and 1
reverse = 0
self.speed = forward and self.avatarControlForwardSpeed or reverse and -self.avatarControlReverseSpeed
self.slideSpeed = 0.0
self.rotationSpeed = turnLeft and self.avatarControlRotateSpeed or turnRight and -self.avatarControlRotateSpeed
def processInput(self):
throttleChange = 0.0
if inputState.isSet('forward'): self.gimbalY = 10
if inputState.isSet('reverse'): self.gimbalY = -10
if inputState.isSet('left'): self.gimbalX = 10
if inputState.isSet('right'): self.gimbalX = -10
if inputState.isSet('turnLeft'): throttleChange = -1.0
if inputState.isSet('turnRight'): throttleChange = 1.0
self.throttle += throttleChange / 100.0
self.throttle = min(max(self.throttle, 0), 1)
def inputProcessingTask(self, task):
# Camera Control Keys
if inputState.isSet('cameraHigher'):
self.cameraHeight += 0.1
if inputState.isSet('cameraLower'):
self.cameraHeight -= 0.1
move = Vec3(0, 0, 0)
turningAngle = 0.0
# Character Movements
if inputState.isSet('forward'):
move.setY(PLAYER_SPEED)
self.isMoving = True
elif inputState.isSet('reverse'):
move.setY(-PLAYER_SPEED)
self.isMoving = True
if inputState.isSet('turnLeft'):
turningAngle = 120.0
self.isMoving = True
elif inputState.isSet('turnRight'):
turningAngle = -120.0
self.isMoving = True
if self.isMoving is False:
self.player.setPose(STANDING)
else:
self.player.setPose(WALKING)
self.isMoving = False
if inputState.isSet('jump'):
self.player.setPose(JUMPING)
if self.booosted:
self.player.getControllerNode().setMaxJumpHeight(JUMP_HEIGHT *
2)
self.player.getControllerNode().setJumpSpeed(JUMP_SPEED * 2)
else:
self.player.getControllerNode().setMaxJumpHeight(JUMP_HEIGHT)
self.player.getControllerNode().setJumpSpeed(JUMP_SPEED)
self.player.getControllerNode().doJump()
if self.pushed:
move.setY(TYPE_1_ENEMY_PUSH_DISTANCE)
self.pushed = False
self.player.getControllerNode().setLinearMovement(move, True)
self.player.getControllerNode().setAngularMovement(turningAngle)
return task.cont
def handleAvatarControls(self, task):
forward = inputState.isSet('forward')
reverse = inputState.isSet('reverse')
turnLeft = inputState.isSet('turnLeft')
turnRight = inputState.isSet('turnRight')
slideLeft = inputState.isSet('slideLeft')
slideRight = inputState.isSet('slideRight')
levitateUp = inputState.isSet('levitateUp')
levitateDown = inputState.isSet('levitateDown')
run = inputState.isSet('run') and self.runMultiplier or 1.0
if base.localAvatar.getAutoRun():
forward = 1
reverse = 0
self.speed = forward and self.avatarControlForwardSpeed or reverse and -self.avatarControlReverseSpeed
self.liftSpeed = levitateUp and self.avatarControlForwardSpeed or levitateDown and -self.avatarControlReverseSpeed
self.slideSpeed = slideLeft and -self.avatarControlForwardSpeed or slideRight and self.avatarControlForwardSpeed
self.rotationSpeed = turnLeft and self.avatarControlRotateSpeed or turnRight and -self.avatarControlRotateSpeed
if self.wantDebugIndicator:
self.displayDebugInfo()
if self.speed or self.liftSpeed or self.slideSpeed or self.rotationSpeed:
dt = ClockObject.getGlobalClock().getDt()
distance = dt * self.speed * run
lift = dt * self.liftSpeed * run
slideDistance = dt * self.slideSpeed * run
rotation = dt * self.rotationSpeed
self.vel = Vec3(Vec3.forward() * distance + Vec3.up() * lift +
Vec3.right() * slideDistance)
if self.vel != Vec3.zero():
rotMat = Mat3.rotateMatNormaxis(self.avatarNodePath.getH(),
Vec3.up())
step = rotMat.xform(self.vel)
self.avatarNodePath.setFluidPos(
Point3(self.avatarNodePath.getPos() + step))
self.avatarNodePath.setH(self.avatarNodePath.getH() + rotation)
messenger.send('avatarMoving')
else:
self.vel.set(0.0, 0.0, 0.0)
return Task.cont
def processInput(self, dt):
speed = Vec3(0, 0, 0)
omega = 0.0
if inputState.isSet('forward'): speed.setY( 3.0)
if inputState.isSet('reverse'): speed.setY(-3.0)
if inputState.isSet('left'): speed.setX(-3.0)
if inputState.isSet('right'): speed.setX( 3.0)
if inputState.isSet('turnLeft'): omega = 120.0
if inputState.isSet('turnRight'): omega = -120.0
if (inputState.isSet('forward')!=0) or (inputState.isSet('reverse')!=0) or (inputState.isSet('left')!=0) or (inputState.isSet('right')!=0):
if self.isMoving is False:
self.actorNP.loop("walk")
self.isMoving = True
else:
if self.isMoving:
self.actorNP.stop()
self.isMoving = False
self.character.setAngularMovement(omega)
self.character.setLinearMovement(speed, True)
def input2forces(
self, car_input, joystick_mgr, is_drifting, player_car_idx,
curr_time,
#acc_key, brk_key,
a_i):
keys = ['forward', 'rear', 'left', 'right']
keys = [key + str(player_car_idx) for key in keys]
joystick = not any(inputState.isSet(key) for key in keys)
if a_i or not joystick or not self.__is_player:
return self.input2forces_discrete(
car_input, joystick_mgr, is_drifting, player_car_idx,
curr_time)
else:
return self.input2forces_analog(
car_input, joystick_mgr, is_drifting, player_car_idx,
curr_time,
#acc_key, brk_key
)
def useBasicPlayerMovement(self, dt):
"""This sets up a basic movement for the playercontroller"""
# get the player
player = self.engine.GameObjects["player"]
speed = Vec3(0, 0, 0)
omega = 0.0
if inputState.isSet('forward'): speed.setY(player.runSpeed)
if inputState.isSet('reverse'): speed.setY(-player.runSpeed)
if inputState.isSet('left'): speed.setX(-player.runSpeed)
if inputState.isSet('right'): speed.setX(player.runSpeed)
if inputState.isSet('turnLeft'): omega = player.turnSpeed
if inputState.isSet('turnRight'): omega = -player.turnSpeed
if inputState.isSet('space'):
self.doPlayerJump(player.bulletBody.node())
if inputState.isSet('ctrl'): self.doPlayerCrouch(player)
#player.bulletBody.node().setAngularMovement(omega)
player.bulletBody.node().setLinearMovement(speed, True)
def monitor(self, foo):
#assert self.debugPrint("monitor()")
#if 1:
# airborneHeight=self.avatar.getAirborneHeight()
# onScreenDebug.add("airborneHeight", "% 10.4f"%(airborneHeight,))
if 0:
onScreenDebug.add("InputState forward", "%d"%(inputState.isSet("forward")))
onScreenDebug.add("InputState reverse", "%d"%(inputState.isSet("reverse")))
onScreenDebug.add("InputState turnLeft", "%d"%(inputState.isSet("turnLeft")))
onScreenDebug.add("InputState turnRight", "%d"%(inputState.isSet("turnRight")))
onScreenDebug.add("InputState slideLeft", "%d"%(inputState.isSet("slideLeft")))
onScreenDebug.add("InputState slideRight", "%d"%(inputState.isSet("slideRight")))
return Task.cont
def processInput(self, dt):
speed = Vec3(0, 0, 0)
omega = 0.0
if inputState.isSet('forward'): speed.setY(2.0)
if inputState.isSet('reverse'): speed.setY(-2.0)
if inputState.isSet('left'): speed.setX(-2.0)
if inputState.isSet('right'): speed.setX(2.0)
if inputState.isSet('turnLeft'): omega = 120.0
if inputState.isSet('turnRight'): omega = -120.0
self.player.setAngularMovement(omega)
self.player.setLinearMovement(speed, True)
def process_input(self, dt):
speed = LVector3(0, 0, 0)
omega = 0.0
if inputState.isSet('forward'): speed.y = 2.0
if inputState.isSet('reverse'): speed.y = -2.0
if inputState.isSet('left'): speed.x = -2.0
if inputState.isSet('right'): speed.x = 2.0
if inputState.isSet('turnLeft'): omega = 120.0
if inputState.isSet('turnRight'): omega = -120.0
self.character.set_angular_movement(omega)
self.character.set_linear_movement(speed, True)
def ProcessInput(dt):
engineForce = 0.0
self.steeringClamp = 35.0
self.steeringIncrement = 70
#Get the vehicle's current speed
self.carspeed = self.Car_sim.getCurrentSpeedKmHour()
#Reset the steering
if not inputState.isSet("L") and not inputState.isSet("R"):
if self.steering < 0.00:
self.steering = self.steering + 0.6
if self.steering > 0.00:
self.steering = self.steering - 0.6
if self.steering < 1.0 and self.steering > -1.0:
self.steering = 0
if inputState.isSet("F"):
engineForce = 35
if inputState.isSet("B"):
engineForce = -35
#Left
if inputState.isSet("L"):
if self.steering < 0.0:
#This makes the steering reset at the correct speed when turning from right to left
self.steering += dt * self.steeringIncrement + 0.6
self.steering = min(self.steering, self.steeringClamp)
else:
#Normal steering
self.steering += dt * self.steeringIncrement
self.steering = min(self.steering, self.steeringClamp)
#Right
if inputState.isSet("R"):
if self.steering > 0.0:
#This makes the steering reset at the correct speed when turning from left to right
self.steering -= dt * self.steeringIncrement + 0.6
self.steering = max(self.steering, -self.steeringClamp)
else:
#Normal steering
self.steering -= dt * self.steeringIncrement
self.steering = max(self.steering, -self.steeringClamp)
#Apply forces to wheels
self.Car_sim.applyEngineForce(engineForce, 0)
self.Car_sim.applyEngineForce(engineForce, 3)
def processInput(self, dt):
force = Vec3(0, 0, 0)
torque = Vec3(0, 0, 0)
if inputState.isSet('forward'): force.setY( 1.0)
if inputState.isSet('reverse'): force.setY(-1.0)
if inputState.isSet('left'): force.setX(-1.0)
if inputState.isSet('right'): force.setX( 1.0)
if inputState.isSet('turnLeft'): torque.setZ( 1.0)
if inputState.isSet('turnRight'): torque.setZ(-1.0)
force *= 30.0
torque *= 10.0
self.boxNP.node().applyCentralForce(force)
self.boxNP.node().applyTorque(torque)
def process_input(self, dt):
force = LVector3(0, 0, 0)
torque = LVector3(0, 0, 0)
if inputState.isSet('forward'): force.y = 1.0
if inputState.isSet('reverse'): force.y = -1.0
if inputState.isSet('left'): force.x = -1.0
if inputState.isSet('right'): force.x = 1.0
if inputState.isSet('turnLeft'): torque.z = 1.0
if inputState.isSet('turnRight'): torque.z = -1.0
force *= 30.0
torque *= 10.0
self.boxNP.node().apply_central_force(force)
self.boxNP.node().apply_torque(torque)
def keyboard_watcher(self, task):
m = Vec3(0, 0, 0)
if inputState.isSet('forward'):
m.setY(1)
elif inputState.isSet('back'):
m.setY(-1)
if inputState.isSet('left'):
m.setX(-1)
elif inputState.isSet('right'):
m.setX(1)
if inputState.isSet('up'):
m.setZ(1)
elif inputState.isSet('down'):
m.setZ(-1)
self.char.move(m)
return task.cont
def _calcSpeeds(self):
# get the button states:
forward = inputState.isSet("forward")
reverse = inputState.isSet("reverse")
turnLeft = inputState.isSet("turnLeft") or inputState.isSet("slideLeft")
turnRight = inputState.isSet("turnRight") or inputState.isSet("slideRight")
# Check for Auto-Run
if base.localAvatar.getAutoRun():
forward = 1
reverse = 0
# Determine what the speeds are based on the buttons:
self.speed=(forward and self.avatarControlForwardSpeed or
reverse and -self.avatarControlReverseSpeed)
self.slideSpeed=0.
self.rotationSpeed=(
(turnLeft and self.avatarControlRotateSpeed) or
(turnRight and -self.avatarControlRotateSpeed))
def processInput(self, dt):
force = Vec3(0, 0, 0)
torque = Vec3(0, 0, 0)
if inputState.isSet('forward'): force.setY(1.0)
if inputState.isSet('reverse'): force.setY(-1.0)
if inputState.isSet('left'): force.setX(-1.0)
if inputState.isSet('right'): force.setX(1.0)
if inputState.isSet('turnLeft'): torque.setZ(1.0)
if inputState.isSet('turnRight'): torque.setZ(-1.0)
force *= 30.0
torque *= 10.0
force = render.getRelativeVector(self.allTheThingsNP[0], force)
torque = render.getRelativeVector(self.allTheThingsNP[0], torque)
self.allTheThingsNP[0].node().setActive(True)
self.allTheThingsNP[0].node().applyCentralForce(force)
self.allTheThingsNP[0].node().applyTorque(torque)
def _calcSpeeds(self):
forward = inputState.isSet('forward')
reverse = inputState.isSet('reverse')
if not inputState.isSet('turnLeft'):
pass
turnLeft = inputState.isSet('slideLeft')
if not inputState.isSet('turnRight'):
pass
turnRight = inputState.isSet('slideRight')
if base.localAvatar.getAutoRun():
forward = 1
reverse = 0
if (forward or self.avatarControlForwardSpeed) and reverse:
pass
self.speed = -(self.avatarControlReverseSpeed)
self.slideSpeed = 0.0
if (turnLeft or self.avatarControlRotateSpeed) and turnRight:
pass
self.rotationSpeed = -(self.avatarControlRotateSpeed)
def handleAvatarControls(self, task):
"""
Check on the arrow keys and update the avatar.
"""
# get the button states:
run = inputState.isSet("run")
forward = inputState.isSet("forward")
reverse = inputState.isSet("reverse")
turnLeft = inputState.isSet("turnLeft")
turnRight = inputState.isSet("turnRight")
slideLeft = inputState.isSet("slideLeft")
slideRight = inputState.isSet("slideRight")
jump = inputState.isSet("jump")
# Check for Auto-Run
#if 'localAvatar' in __builtins__:
# if base.localAvatar and base.localAvatar.getAutoRun():
# forward = 1
# reverse = 0
# Determine what the speeds are based on the buttons:
self.speed = (forward and self.avatarControlForwardSpeed
or reverse and -self.avatarControlReverseSpeed)
# Slide speed is a scaled down version of forward speed
# Note: you can multiply a factor in here if you want slide to
# be slower than normal walk/run. Let's try full speed.
#self.slideSpeed=(slideLeft and -self.avatarControlForwardSpeed*0.75 or
# slideRight and self.avatarControlForwardSpeed*0.75)
self.slideSpeed = (
reverse and slideLeft and -self.avatarControlReverseSpeed * 0.75
or reverse and slideRight and self.avatarControlReverseSpeed * 0.75
or slideLeft and -self.avatarControlForwardSpeed * 0.75
or slideRight and self.avatarControlForwardSpeed * 0.75)
self.rotationSpeed = not (slideLeft or slideRight) and (
(turnLeft and self.avatarControlRotateSpeed) or
(turnRight and -self.avatarControlRotateSpeed))
if self.speed and self.slideSpeed:
self.speed *= GravityWalker.DiagonalFactor
self.slideSpeed *= GravityWalker.DiagonalFactor
debugRunning = inputState.isSet("debugRunning")
if (debugRunning):
self.speed *= base.debugRunningMultiplier
self.slideSpeed *= base.debugRunningMultiplier
self.rotationSpeed *= 1.25
if self.needToDeltaPos:
self.setPriorParentVector()
self.needToDeltaPos = 0
if self.wantDebugIndicator:
self.displayDebugInfo()
if self.lifter.isOnGround():
if self.isAirborne:
self.isAirborne = 0
assert self.debugPrint("isAirborne 0 due to isOnGround() true")
impact = self.lifter.getImpactVelocity()
if impact < -30.0:
messenger.send("jumpHardLand")
self.startJumpDelay(0.3)
else:
messenger.send("jumpLand")
if impact < -5.0:
self.startJumpDelay(0.2)
# else, ignore the little potholes.
assert self.isAirborne == 0
self.priorParent = Vec3.zero()
if jump and self.mayJump:
# The jump button is down and we're close
# enough to the ground to jump.
self.lifter.addVelocity(self.avatarControlJumpForce)
messenger.send("jumpStart")
self.isAirborne = 1
assert self.debugPrint("isAirborne 1 due to jump")
else:
if self.isAirborne == 0:
assert self.debugPrint(
"isAirborne 1 due to isOnGround() false")
self.isAirborne = 1
self.__oldPosDelta = self.avatarNodePath.getPosDelta(render)
# How far did we move based on the amount of time elapsed?
self.__oldDt = ClockObject.getGlobalClock().getDt()
dt = self.__oldDt
# Check to see if we're moving at all:
self.moving = self.speed or self.slideSpeed or self.rotationSpeed or (
self.priorParent != Vec3.zero())
if self.moving:
distance = dt * self.speed
slideDistance = dt * self.slideSpeed
rotation = dt * self.rotationSpeed
# Take a step in the direction of our previous heading.
if distance or slideDistance or self.priorParent != Vec3.zero():
# rotMat is the rotation matrix corresponding to
# our previous heading.
rotMat = Mat3.rotateMatNormaxis(self.avatarNodePath.getH(),
Vec3.up())
if self.isAirborne:
forward = Vec3.forward()
else:
contact = self.lifter.getContactNormal()
forward = contact.cross(Vec3.right())
# Consider commenting out this normalize. If you do so
# then going up and down slops is a touch slower and
# steeper terrain can cut the movement in half. Without
# the normalize the movement is slowed by the cosine of
# the slope (i.e. it is multiplied by the sign as a
# side effect of the cross product above).
forward.normalize()
self.vel = Vec3(forward * distance)
if slideDistance:
if self.isAirborne:
right = Vec3.right()
else:
right = forward.cross(contact)
# See note above for forward.normalize()
right.normalize()
self.vel = Vec3(self.vel + (right * slideDistance))
self.vel = Vec3(rotMat.xform(self.vel))
step = self.vel + (self.priorParent * dt)
self.avatarNodePath.setFluidPos(
Point3(self.avatarNodePath.getPos() + step))
self.avatarNodePath.setH(self.avatarNodePath.getH() + rotation)
else:
self.vel.set(0.0, 0.0, 0.0)
if self.moving or jump:
messenger.send("avatarMoving")
return Task.cont
def handleAvatarControls(self, task):
"""
Check on the arrow keys and update the avatar.
"""
# get the button states:
forward = inputState.isSet("forward")
reverse = inputState.isSet("reverse")
turnLeft = inputState.isSet("turnLeft")
turnRight = inputState.isSet("turnRight")
slideLeft = inputState.isSet("slideLeft")
slideRight = inputState.isSet("slideRight")
levitateUp = inputState.isSet("levitateUp")
levitateDown = inputState.isSet("levitateDown")
run = inputState.isSet("run") and self.runMultiplier.getValue() or 1.0
# Check for Auto-Run
if base.localAvatar.getAutoRun():
forward = 1
reverse = 0
# Determine what the speeds are based on the buttons:
self.speed=(
(forward and self.avatarControlForwardSpeed or
reverse and -self.avatarControlReverseSpeed))
self.liftSpeed=(
(levitateUp and self.avatarControlForwardSpeed or
levitateDown and -self.avatarControlReverseSpeed))
self.slideSpeed=(
(slideLeft and -self.avatarControlForwardSpeed) or
(slideRight and self.avatarControlForwardSpeed))
self.rotationSpeed=(
(turnLeft and self.avatarControlRotateSpeed) or
(turnRight and -self.avatarControlRotateSpeed))
if self.wantDebugIndicator:
self.displayDebugInfo()
# Check to see if we're moving at all:
if self.speed or self.liftSpeed or self.slideSpeed or self.rotationSpeed:
# How far did we move based on the amount of time elapsed?
dt=ClockObject.getGlobalClock().getDt()
distance = dt * self.speed * run
lift = dt * self.liftSpeed * run
slideDistance = dt * self.slideSpeed * run
rotation = dt * self.rotationSpeed
# Take a step in the direction of our previous heading.
self.vel=Vec3(Vec3.forward() * distance +
Vec3.up() * lift +
Vec3.right() * slideDistance)
if self.vel != Vec3.zero():
# rotMat is the rotation matrix corresponding to
# our previous heading.
rotMat=Mat3.rotateMatNormaxis(self.avatarNodePath.getH(), Vec3.up())
step=rotMat.xform(self.vel)
self.avatarNodePath.setFluidPos(Point3(self.avatarNodePath.getPos()+step))
self.avatarNodePath.setH(self.avatarNodePath.getH()+rotation)
messenger.send("avatarMoving")
else:
self.vel.set(0.0, 0.0, 0.0)
return Task.cont
def handleAvatarControls(self, task):
"""
Check on the arrow keys and update the avatar.
"""
if __debug__:
if self.wantDebugIndicator:
onScreenDebug.append("localAvatar pos = %s\n"%(
base.localAvatar.getPos().pPrintValues(),))
onScreenDebug.append("localAvatar hpr = %s\n"%(
base.localAvatar.getHpr().pPrintValues(),))
#assert self.debugPrint("handleAvatarControls(task=%s)"%(task,))
physObject=self.actorNode.getPhysicsObject()
contact=self.actorNode.getContactVector()
# get the button states:
forward = inputState.isSet("forward")
reverse = inputState.isSet("reverse")
turnLeft = inputState.isSet("slideLeft") or inputState.isSet("turnLeft")
turnRight = inputState.isSet("slideRight") or inputState.isSet("turnRight")
slide = inputState.isSet("slide")
slideLeft = 0
slideRight = 0
jump = inputState.isSet("jump")
# Determine what the speeds are based on the buttons:
# Check for Auto-Sailing
if self.ship.getIsAutoSailing():
forward = 1
reverse = 0
# How far did we move based on the amount of time elapsed?
dt=ClockObject.getGlobalClock().getDt()
if reverse or turnLeft or turnRight:
# Reset Straight Sailing Bonus
self.straightHeading = 0
# Straight Sailing Acceleration Bonus
straightSailDt += dt
straightSailBonus = 0.0
if straightSailDt > self.STRAIGHT_SAIL_BONUS_TIME / 2.0:
straightSailBonus = (straightSailDt - (self.STRAIGHT_SAIL_BONUS_TIME / 2.0)) / self.STRAIGHT_SAIL_BONUS_TIME / 2.0
straightSailBonus *= self.MAX_STRAIGHT_SAIL_BONUS
straightSailBonus += 1.0
print "##################"
print straightSailBonus
# this was causing the boat to get stuck moving forward or back
if 0:
if not hasattr(self, "sailsDeployed"):
self.sailsDeployed = 0.0
if forward and reverse:
# Way anchor:
self.__speed = 0.0
physObject.setVelocity(Vec3.zero())
elif forward:
self.sailsDeployed += 0.25
if self.sailsDeployed > 1.0:
self.sailsDeployed = 1.0
elif reverse:
self.sailsDeployed -= 0.25
if self.sailsDeployed < -1.0:
self.sailsDeployed = -1.0
self.__speed = self.ship.acceleration * self.sailsDeployed
else:
self.__speed=(forward and self.ship.acceleration) or \
(reverse and -self.ship.reverseAcceleration)
#self.__speed=(forward and min(dt*(self.__speed + self.ship.acceleration), self.ship.maxSpeed) or
# reverse and min(dt*(self.__speed - self.ship.reverseAcceleration), self.ship.maxReverseSpeed))
avatarSlideSpeed=self.ship.acceleration*0.5
#self.__slideSpeed=slide and (
# (turnLeft and -avatarSlideSpeed) or
# (turnRight and avatarSlideSpeed))
self.__slideSpeed=(forward or reverse) and (
(slideLeft and -avatarSlideSpeed) or
(slideRight and avatarSlideSpeed))
self.__rotationSpeed=not slide and (
(turnLeft and self.ship.turnRate) or
(turnRight and -self.ship.turnRate))
# Add in Straight Sailing Multiplier
self.__speed *= straightSailBonus
# Enable debug turbo mode
maxSpeed = self.ship.maxSpeed * straightSailBonus
debugRunning = inputState.isSet("debugRunning")
if debugRunning or base.localAvatar.getTurbo():
self.__speed*=4.0
self.__slideSpeed*=4.0
self.__rotationSpeed*=1.25
maxSpeed = self.ship.maxSpeed * 4.0
#self.__speed*=4.0
#self.__slideSpeed*=4.0
#self.__rotationSpeed*=1.25
#maxSpeed = self.ship.maxSpeed * 4.0
#*#
self.currentTurning += self.__rotationSpeed
if self.currentTurning > self.ship.maxTurn:
self.currentTurning = self.ship.maxTurn
elif self.currentTurning < -self.ship.maxTurn:
self.currentTurning = -self.ship.maxTurn
if turnLeft or turnRight:
mult = .9
elif forward or reverse:
mult = .82
else:
mult = .8
self.currentTurning *= mult
if self.currentTurning < 0.001 and self.currentTurning > -0.001:
self.currentTurning = 0.0
self.__rotationSpeed = self.currentTurning
if self.wantDebugIndicator:
self.displayDebugInfo()
if self.needToDeltaPos:
self.setPriorParentVector()
self.needToDeltaPos = 0
airborneHeight=self.getAirborneHeight()
if airborneHeight > self.highMark:
self.highMark = airborneHeight
if __debug__:
onScreenDebug.add("highMark", "% 10.4f"%(self.highMark,))
#if airborneHeight < 0.1: #contact!=Vec3.zero():
if 1:
if (airborneHeight > self.avatarRadius*0.5
or physObject.getVelocity().getZ() > 0.0
): # Check stair angles before changing this.
# The avatar is airborne (maybe a lot or a tiny amount).
self.isAirborne = 1
else:
# The avatar is very close to the ground (close
# enough to be considered on the ground).
if self.isAirborne and physObject.getVelocity().getZ() <= 0.0:
# the avatar has landed.
contactLength = contact.length()
if contactLength>self.__hardLandingForce:
messenger.send("shipJumpHardLand")
else:
messenger.send("shipJumpLand")
#self.priorParent.setVector(Vec3.zero())
self.isAirborne = 0
elif jump:
#self.__jumpButton=0
messenger.send("shipJumpStart")
if 0:
# Jump away from walls and with with the slope normal.
jumpVec=Vec3(contact+Vec3.up())
#jumpVec=Vec3(rotAvatarToPhys.xform(jumpVec))
jumpVec.normalize()
else:
# Jump straight up, even if next to a wall.
jumpVec=Vec3.up()
jumpVec*=self.avatarControlJumpForce
physObject.addImpulse(Vec3(jumpVec))
self.isAirborne = 1 # Avoid double impulse before fully airborne.
else:
self.isAirborne = 0
if __debug__:
onScreenDebug.add("isAirborne", "%d"%(self.isAirborne,))
else:
if contact!=Vec3.zero():
# The avatar has touched something (but might
# not be on the ground).
contactLength = contact.length()
contact.normalize()
angle=contact.dot(Vec3.up())
if angle>self.__standableGround:
# ...avatar is on standable ground.
if self.__oldContact==Vec3.zero():
#if self.__oldAirborneHeight > 0.1: #self.__oldContact==Vec3.zero():
# ...avatar was airborne.
self.jumpCount-=1
if contactLength>self.__hardLandingForce:
messenger.send("jumpHardLand")
else:
messenger.send("jumpLand")
elif jump:
self.jumpCount+=1
#self.__jumpButton=0
messenger.send("jumpStart")
jump=Vec3(contact+Vec3.up())
#jump=Vec3(rotAvatarToPhys.xform(jump))
jump.normalize()
jump*=self.avatarControlJumpForce
physObject.addImpulse(Vec3(jump))
if contact!=self.__oldContact:
# We must copy the vector to preserve it:
self.__oldContact=Vec3(contact)
self.__oldAirborneHeight=airborneHeight
#------------------------------
#debugTempH=self.avatarNodePath.getH()
if __debug__:
q1=self.avatarNodePath.getQuat()
q2=physObject.getOrientation()
q1.normalize()
q2.normalize()
assert q1.isSameDirection(q2) or (q1.getHpr() == q2.getHpr())
assert self.avatarNodePath.getPos().almostEqual(
physObject.getPosition(), 0.0001)
#------------------------------
# Check to see if we're moving at all:
physVel = physObject.getVelocity()
physVelLen = physVel.length()
if (physVelLen!=0.
or self.__speed
or self.__slideSpeed
or self.__rotationSpeed):
distance = dt * self.__speed
goForward = True
if (distance < 0):
goForward = False
slideDistance = dt * self.__slideSpeed
rotation = dt * self.__rotationSpeed
# update pos:
# Take a step in the direction of our previous heading.
self.__vel=Vec3(
Vec3.forward() * distance +
Vec3.right() * slideDistance)
# rotMat is the rotation matrix corresponding to
# our previous heading.
rotMat=Mat3.rotateMatNormaxis(
self.avatarNodePath.getH(), Vec3.up())
step=rotMat.xform(self.__vel)
#newVector = self.acForce.getLocalVector()+Vec3(step)
newVector = Vec3(step)
#newVector=Vec3(rotMat.xform(newVector))
#maxLen = maxSpeed
if (goForward):
maxLen = self.ship.acceleration
else:
maxLen = self.ship.reverseAcceleration
if newVector.length() > maxLen:
newVector.normalize()
newVector *= maxLen
if __debug__:
onScreenDebug.add(
"newVector", newVector)
onScreenDebug.add(
"newVector length", newVector.length())
base.controlForce.setVector(newVector)
assert base.controlForce.getLocalVector() == newVector
assert base.controlForce.getPhysicsObject()
assert base.controlForce.getPhysicsObject() == physObject
#momentum = self.momentumForce.getLocalVector()
#momentum *= 0.9
#self.momentumForce.setVector(momentum)
# update hpr:
o=physObject.getOrientation()
r=LRotationf()
r.setHpr(Vec3(rotation, 0.0, 0.0))
physObject.setOrientation(o*r)
# sync the change:
self.actorNode.updateTransform()
#assert self.avatarNodePath.getH()==debugTempH-rotation
messenger.send("avatarMoving")
else:
# even if there are no active inputs, we still might be moving
assert physObject.getVelocity().length() == 0.
#base.controlForce.setVector(Vec3.zero())
goForward = True
#*#
speed = physVel
if (goForward):
if physVelLen > maxSpeed:
speed.normalize()
speed *= maxSpeed
else:
if physVelLen > self.ship.maxReverseSpeed:
speed.normalize()
speed *= self.ship.maxReverseSpeed
#speed *= 1.0 - dt * 0.05
# modify based on sail damage
speed *= self.ship.Sp
speed /= self.ship.maxSp
## physObject.setVelocity(speed)
#rotMat=Mat3.rotateMatNormaxis(self.avatarNodePath.getH(), Vec3.up())
#speed=rotMat.xform(speed)
# The momentumForce makes it feel like we are sliding on ice -- Joe
# f = Vec3(self.__vel)
# f.normalize()
# self.momentumForce.setVector(Vec3(f*(speed.length()*0.9)))
if __debug__:
q1=self.avatarNodePath.getQuat()
q2=physObject.getOrientation()
q1.normalize()
q2.normalize()
assert q1.isSameDirection(q2) or q1.getHpr() == q2.getHpr()
assert self.avatarNodePath.getPos().almostEqual(
physObject.getPosition(), 0.0001)
# Clear the contact vector so we can
# tell if we contact something next frame
self.actorNode.setContactVector(Vec3.zero())
self.__oldPosDelta = self.avatarNodePath.getPosDelta(render)
self.__oldDt = dt
assert hasattr(self.ship, 'worldVelocity')
self.ship.worldVelocity = self.__oldPosDelta*(1/self.__oldDt)
if self.wantDebugIndicator:
onScreenDebug.add("w __oldPosDelta vec",
self.__oldPosDelta.pPrintValues())
onScreenDebug.add("w __oldPosDelta len",
"% 10.4f"%self.__oldPosDelta.length())
onScreenDebug.add("w __oldDt",
"% 10.4f"%self.__oldDt)
onScreenDebug.add("w worldVelocity vec",
self.ship.worldVelocity.pPrintValues())
onScreenDebug.add("w worldVelocity len",
"% 10.4f"%self.ship.worldVelocity.length())
# if hasattr(self.ship, 'sailBillow'):
# self.ship.sailBillow = self.sailsDeployed
if hasattr(self.ship, 'currentTurning'):
self.ship.currentTurning = self.currentTurning
return Task.cont
def build_dct(self, ai, has_weapon):
keys = ['forward', 'left', 'reverse', 'right']
return {key: inputState.isSet(key) for key in keys}
def handleAvatarControls(self, task):
"""
Check on the arrow keys and update the avatar.
"""
if __debug__:
if self.wantDebugIndicator:
onScreenDebug.append("localAvatar pos = %s\n"%(base.localAvatar.getPos().pPrintValues(),))
onScreenDebug.append("localAvatar h = % 10.4f\n"%(base.localAvatar.getH(),))
onScreenDebug.append("localAvatar anim = %s\n"%(base.localAvatar.animFSM.getCurrentState().getName(),))
#assert self.debugPrint("handleAvatarControls(task=%s)"%(task,))
physObject=self.actorNode.getPhysicsObject()
#rotAvatarToPhys=Mat3.rotateMatNormaxis(-self.avatarNodePath.getH(), Vec3.up())
#rotPhysToAvatar=Mat3.rotateMatNormaxis(self.avatarNodePath.getH(), Vec3.up())
contact=self.actorNode.getContactVector()
# hack fix for falling through the floor:
if contact==Vec3.zero() and self.avatarNodePath.getZ()<-50.0:
# DCR: don't reset X and Y; allow player to move
self.reset()
self.avatarNodePath.setZ(50.0)
messenger.send("walkerIsOutOfWorld", [self.avatarNodePath])
if self.wantDebugIndicator:
self.displayDebugInfo()
# get the button states:
forward = inputState.isSet("forward")
reverse = inputState.isSet("reverse")
turnLeft = inputState.isSet("turnLeft")
turnRight = inputState.isSet("turnRight")
slide = 0#inputState.isSet("slide")
slideLeft = 0#inputState.isSet("slideLeft")
slideRight = 0#inputState.isSet("slideRight")
jump = inputState.isSet("jump")
# Check for Auto-Run
if base.localAvatar.getAutoRun():
forward = 1
reverse = 0
# Determine what the speeds are based on the buttons:
self.__speed=(forward and self.avatarControlForwardSpeed or
reverse and -self.avatarControlReverseSpeed)
avatarSlideSpeed=self.avatarControlForwardSpeed*0.5
#self.__slideSpeed=slide and (
# (turnLeft and -avatarSlideSpeed) or
# (turnRight and avatarSlideSpeed))
self.__slideSpeed=(
(slideLeft and -avatarSlideSpeed) or
(slideRight and avatarSlideSpeed))
self.__rotationSpeed=not slide and (
(turnLeft and self.avatarControlRotateSpeed) or
(turnRight and -self.avatarControlRotateSpeed))
# How far did we move based on the amount of time elapsed?
dt=ClockObject.getGlobalClock().getDt()
if self.needToDeltaPos:
self.setPriorParentVector()
self.needToDeltaPos = 0
#self.__oldPosDelta = render.getRelativeVector(
# self.avatarNodePath,
# self.avatarNodePath.getPosDelta(render))
#self.__oldPosDelta = self.avatarNodePath.getRelativeVector(
# render,
# self.avatarNodePath.getPosDelta(render))
self.__oldPosDelta = self.avatarNodePath.getPosDelta(render)
self.__oldDt = dt
#posDelta = self.avatarNodePath.getPosDelta(render)
#if posDelta==Vec3.zero():
# self.priorParent.setVector(self.__oldPosDelta)
#else:
# self.priorParent.setVector(Vec3.zero())
# # We must copy the vector to preserve it:
# self.__oldPosDelta=Vec3(posDelta)
if __debug__:
if self.wantDebugIndicator:
onScreenDebug.add("posDelta1",
self.avatarNodePath.getPosDelta(render).pPrintValues())
if 0:
onScreenDebug.add("posDelta3",
render.getRelativeVector(
self.avatarNodePath,
self.avatarNodePath.getPosDelta(render)).pPrintValues())
if 0:
onScreenDebug.add("gravity",
self.gravity.getLocalVector().pPrintValues())
onScreenDebug.add("priorParent",
self.priorParent.getLocalVector().pPrintValues())
onScreenDebug.add("avatarViscosity",
"% 10.4f"%(self.avatarViscosity.getCoef(),))
onScreenDebug.add("physObject pos",
physObject.getPosition().pPrintValues())
onScreenDebug.add("physObject hpr",
physObject.getOrientation().getHpr().pPrintValues())
onScreenDebug.add("physObject orien",
physObject.getOrientation().pPrintValues())
if 1:
onScreenDebug.add("physObject vel",
physObject.getVelocity().pPrintValues())
onScreenDebug.add("physObject len",
"% 10.4f"%physObject.getVelocity().length())
if 0:
onScreenDebug.add("posDelta4",
self.priorParentNp.getRelativeVector(
render,
self.avatarNodePath.getPosDelta(render)).pPrintValues())
if 1:
onScreenDebug.add("priorParent",
self.priorParent.getLocalVector().pPrintValues())
if 0:
onScreenDebug.add("priorParent po",
self.priorParent.getVector(physObject).pPrintValues())
if 0:
onScreenDebug.add("__posDelta",
self.__oldPosDelta.pPrintValues())
if 1:
onScreenDebug.add("contact",
contact.pPrintValues())
#onScreenDebug.add("airborneHeight", "% 10.4f"%(
# self.getAirborneHeight(),))
if 0:
onScreenDebug.add("__oldContact",
contact.pPrintValues())
onScreenDebug.add("__oldAirborneHeight", "% 10.4f"%(
self.getAirborneHeight(),))
airborneHeight=self.getAirborneHeight()
if airborneHeight > self.highMark:
self.highMark = airborneHeight
if __debug__:
onScreenDebug.add("highMark", "% 10.4f"%(self.highMark,))
#if airborneHeight < 0.1: #contact!=Vec3.zero():
if 1:
if (airborneHeight > self.avatarRadius*0.5
or physObject.getVelocity().getZ() > 0.0
): # Check stair angles before changing this.
# ...the avatar is airborne (maybe a lot or a tiny amount).
self.isAirborne = 1
else:
# ...the avatar is very close to the ground (close enough to be
# considered on the ground).
if self.isAirborne and physObject.getVelocity().getZ() <= 0.0:
# ...the avatar has landed.
contactLength = contact.length()
if contactLength>self.__hardLandingForce:
#print "jumpHardLand"
messenger.send("jumpHardLand")
else:
#print "jumpLand"
messenger.send("jumpLand")
self.priorParent.setVector(Vec3.zero())
self.isAirborne = 0
elif jump:
#print "jump"
#self.__jumpButton=0
messenger.send("jumpStart")
if 0:
# ...jump away from walls and with with the slope normal.
jumpVec=Vec3(contact+Vec3.up())
#jumpVec=Vec3(rotAvatarToPhys.xform(jumpVec))
jumpVec.normalize()
else:
# ...jump straight up, even if next to a wall.
jumpVec=Vec3.up()
jumpVec*=self.avatarControlJumpForce
physObject.addImpulse(Vec3(jumpVec))
self.isAirborne = 1 # Avoid double impulse before fully airborne.
else:
self.isAirborne = 0
if __debug__:
onScreenDebug.add("isAirborne", "%d"%(self.isAirborne,))
else:
if contact!=Vec3.zero():
# ...the avatar has touched something (but might not be on the ground).
contactLength = contact.length()
contact.normalize()
angle=contact.dot(Vec3.up())
if angle>self.__standableGround:
# ...avatar is on standable ground.
if self.__oldContact==Vec3.zero():
#if self.__oldAirborneHeight > 0.1: #self.__oldContact==Vec3.zero():
# ...avatar was airborne.
self.jumpCount-=1
if contactLength>self.__hardLandingForce:
messenger.send("jumpHardLand")
else:
messenger.send("jumpLand")
elif jump:
self.jumpCount+=1
#self.__jumpButton=0
messenger.send("jumpStart")
jump=Vec3(contact+Vec3.up())
#jump=Vec3(rotAvatarToPhys.xform(jump))
jump.normalize()
jump*=self.avatarControlJumpForce
physObject.addImpulse(Vec3(jump))
if contact!=self.__oldContact:
# We must copy the vector to preserve it:
self.__oldContact=Vec3(contact)
self.__oldAirborneHeight=airborneHeight
moveToGround = Vec3.zero()
if not self.useHeightRay or self.isAirborne:
# ...the airborne check is a hack to stop sliding.
self.phys.doPhysics(dt)
if __debug__:
onScreenDebug.add("phys", "on")
else:
physObject.setVelocity(Vec3.zero())
#if airborneHeight>0.001 and contact==Vec3.zero():
# moveToGround = Vec3(0.0, 0.0, -airborneHeight)
#moveToGround = Vec3(0.0, 0.0, -airborneHeight)
moveToGround = Vec3(0.0, 0.0, -self.determineHeight())
if __debug__:
onScreenDebug.add("phys", "off")
# Check to see if we're moving at all:
if self.__speed or self.__slideSpeed or self.__rotationSpeed or moveToGround!=Vec3.zero():
distance = dt * self.__speed
slideDistance = dt * self.__slideSpeed
rotation = dt * self.__rotationSpeed
#debugTempH=self.avatarNodePath.getH()
assert self.avatarNodePath.getQuat().isSameDirection(physObject.getOrientation())
assert self.avatarNodePath.getPos().almostEqual(physObject.getPosition(), 0.0001)
# update pos:
# Take a step in the direction of our previous heading.
self.__vel=Vec3(
Vec3.forward() * distance +
Vec3.right() * slideDistance)
# rotMat is the rotation matrix corresponding to
# our previous heading.
rotMat=Mat3.rotateMatNormaxis(self.avatarNodePath.getH(), Vec3.up())
step=rotMat.xform(self.__vel)
physObject.setPosition(Point3(
physObject.getPosition()+step+moveToGround))
# update hpr:
o=physObject.getOrientation()
r=LRotationf()
r.setHpr(Vec3(rotation, 0.0, 0.0))
physObject.setOrientation(o*r)
# sync the change:
self.actorNode.updateTransform()
assert self.avatarNodePath.getQuat().isSameDirection(physObject.getOrientation())
assert self.avatarNodePath.getPos().almostEqual(physObject.getPosition(), 0.0001)
#assert self.avatarNodePath.getH()==debugTempH-rotation
messenger.send("avatarMoving")
else:
self.__vel.set(0.0, 0.0, 0.0)
# Clear the contact vector so we can tell if we contact something next frame:
self.actorNode.setContactVector(Vec3.zero())
return Task.cont
def trackAnimToSpeed(self, task):
speed, rotSpeed, slideSpeed = self.controlManager.getSpeeds()
if speed != 0.0 or rotSpeed != 0.0 or inputState.isSet('jump'):
if not self.movingFlag:
self.movingFlag = 1
self.stopLookAround()
elif self.movingFlag:
self.movingFlag = 0
self.startLookAround()
if self.movingFlag or self.hp <= 0:
self.wakeUp()
elif not self.sleepFlag:
now = globalClock.getFrameTime()
if now - self.lastMoved > self.sleepTimeout:
self.gotoSleep()
state = None
if self.sleepFlag:
state = 'Sleep'
elif self.hp > 0:
state = 'Happy'
else:
state = 'Sad'
if state != self.lastState:
self.lastState = state
self.b_setAnimState(state, self.animMultiplier)
if state == 'Sad':
self.setWalkSpeedSlow()
else:
self.setWalkSpeedNormal()
if self.cheesyEffect == OTPGlobals.CEFlatProfile or self.cheesyEffect == OTPGlobals.CEFlatPortrait:
needH = None
if rotSpeed > 0.0:
needH = -10
elif rotSpeed < 0.0:
needH = 10
elif speed != 0.0:
needH = 0
if needH != None and self.lastNeedH != needH:
node = self.getGeomNode().getChild(0)
lerp = Sequence(LerpHprInterval(node,
0.5,
Vec3(needH, 0, 0),
blendType='easeInOut'),
name='cheesy-lerp-hpr',
autoPause=1)
lerp.start()
self.lastNeedH = needH
else:
self.lastNeedH = None
action = self.setSpeed(speed, rotSpeed)
if action != self.lastAction:
self.lastAction = action
if self.emoteTrack:
self.emoteTrack.finish()
self.emoteTrack = None
if action == OTPGlobals.WALK_INDEX or action == OTPGlobals.REVERSE_INDEX:
self.walkSound()
elif action == OTPGlobals.RUN_INDEX:
self.runSound()
else:
self.stopSound()
return Task.cont
