mirror of
https://github.com/Sneed-Group/Poodletooth-iLand
synced 2024-12-23 11:42:39 -06:00
1224 lines
49 KiB
Python
1224 lines
49 KiB
Python
from panda3d.core import *
|
|
from direct.distributed.ClockDelta import *
|
|
from direct.interval.IntervalGlobal import *
|
|
from direct.gui.DirectGui import *
|
|
from direct.fsm import FSM
|
|
from direct.distributed import DistributedSmoothNode
|
|
from direct.interval.IntervalGlobal import *
|
|
from toontown.toonbase.PythonUtil import clampScalar
|
|
from otp.otpbase import OTPGlobals
|
|
from otp.avatar import ShadowCaster
|
|
from toontown.racing import Kart
|
|
from toontown.racing.KartDNA import *
|
|
from toontown.toonbase import ToontownGlobals
|
|
from toontown.toonbase import TTLocalizer
|
|
from toontown.effects.Drift import Drift
|
|
from toontown.effects.Sparks import Sparks
|
|
from direct.interval.ProjectileInterval import *
|
|
from toontown.battle.BattleProps import *
|
|
import random
|
|
from direct.showbase.PythonUtil import randFloat
|
|
from direct.task.Task import Task
|
|
from otp.nametag import NametagGlobals
|
|
import math
|
|
iceTurnFactor = 0.25
|
|
iceAccelFactor = 0.4
|
|
|
|
class DistributedVehicle(DistributedSmoothNode.DistributedSmoothNode, Kart.Kart, FSM.FSM):
|
|
notify = DirectNotifyGlobal.directNotify.newCategory('DistributedVehicle')
|
|
cheatFactor = 1.0
|
|
proRacer = 0
|
|
physicsCalculationsPerSecond = 60
|
|
maxPhysicsDt = 1.0
|
|
physicsDt = 1.0 / float(physicsCalculationsPerSecond)
|
|
maxPhysicsFrames = maxPhysicsDt * physicsCalculationsPerSecond
|
|
maxSpeed = 200 * cheatFactor
|
|
turnRatio = 1.0 / 0.025 * math.sqrt(cheatFactor)
|
|
accelerationMult = 35
|
|
accelerationBase = 20
|
|
if proRacer:
|
|
accelerationMult = 35
|
|
accelerationBase = 30
|
|
surfaceModifiers = {'asphalt': {'shake': 0.1,
|
|
'driftMin': 65,
|
|
'windResistance': 0.2,
|
|
'particleColor': Vec4(0.7, 0.7, 0.7, 1.0)},
|
|
'gravel': {'shake': 0.2,
|
|
'driftMin': 65,
|
|
'windResistance': 0.2,
|
|
'particleColor': Vec4(0.53, 0.53, 0.53, 1.0)},
|
|
'dirt': {'shake': 0.4,
|
|
'driftMin': 35,
|
|
'windResistance': 0.3,
|
|
'particleColor': Vec4(1.0, 1.0, 1.0, 1.0)},
|
|
'grass': {'shake': 0.8,
|
|
'driftMin': 15,
|
|
'windResistance': 0.4,
|
|
'particleColor': Vec4(0.8, 0.42, 0.8, 1.0)},
|
|
'ice': {'shake': 0.0,
|
|
'driftMin': 0,
|
|
'windResistance': 0.01,
|
|
'particleColor': Vec4(1.0, 1.0, 1.0, 1.0)},
|
|
'': {'shake': 0,
|
|
'driftMin': 1,
|
|
'windResistance': 0.2,
|
|
'particleColor': Vec4(1.0, 1.0, 1.0, 1.0)}}
|
|
SFX_BaseDir = 'phase_6/audio/sfx/'
|
|
SFX_WallHits = [SFX_BaseDir + 'KART_Hitting_Wood_Fence.ogg',
|
|
SFX_BaseDir + 'KART_Hitting_Wood_Fence_1.ogg',
|
|
SFX_BaseDir + 'KART_Hitting_Metal_Fence.ogg',
|
|
SFX_BaseDir + 'KART_Hitting_Wall.ogg']
|
|
SFX_SkidLoop_Grass = SFX_BaseDir + 'KART_Skidding_On_Grass.ogg'
|
|
SFX_SkidLoop_Asphalt = SFX_BaseDir + 'KART_Skidding_On_Asphalt.ogg'
|
|
SFX_TurboStart = SFX_BaseDir + 'KART_turboStart.ogg'
|
|
SFX_TurboLoop = SFX_BaseDir + 'KART_turboLoop.ogg'
|
|
AvId2kart = {}
|
|
|
|
@classmethod
|
|
def getKartFromAvId(cls, avId):
|
|
return cls.AvId2kart.get(avId)
|
|
|
|
def __init__(self, cr):
|
|
DistributedSmoothNode.DistributedSmoothNode.__init__(self, cr)
|
|
FSM.FSM.__init__(self, 'DistributedVehicle')
|
|
Kart.Kart.__init__(self)
|
|
if base.config.GetBool('want-racer', 0) == 1:
|
|
DistributedVehicle.proRacer = 1
|
|
DistributedVehicle.accelerationMult = 35
|
|
DistributedVehicle.accelerationBase = 30
|
|
self.speedometer = None
|
|
self.speedGauge = None
|
|
self.leanAmount = 0
|
|
self.leftHeld = 0
|
|
self.stopped = False
|
|
self.rightHeld = 0
|
|
self.canRace = False
|
|
self.groundType = 'gravel'
|
|
self.offGround = 0
|
|
self.turbo = False
|
|
self.ownerId = 0
|
|
self.cameraTrack = None
|
|
self.curSpeed = 0
|
|
self.acceleration = 0
|
|
self.imHitMult = 1
|
|
self.skidding = False
|
|
self.hittingWall = 0
|
|
base.kart = self
|
|
self.wipeOut = None
|
|
self.gagMovie = None
|
|
self.spinAnim = None
|
|
self.wrongWay = False
|
|
self.wallCollideTrack = None
|
|
self.wheelMaxTurn = 1.0
|
|
self.wheelMinTurn = 0.15
|
|
self.speedMaxTurn = 90
|
|
self.speedMinTurn = 300
|
|
self.wheelTurnTime = 0.6
|
|
self.wheelReturnTime = 0.3
|
|
self.wheelFightTime = 0.2
|
|
self.wheelPosition = 0.0
|
|
self.outPutCounter = 0
|
|
self.proCameraHeading = 0
|
|
self.proCameraDummyNode = None
|
|
self.cameraArmNode = None
|
|
self.armSwingSpeedPerp = 0.2
|
|
self.armSwingSpeedPara = 0.7
|
|
self.cameraTightener = 3.0
|
|
self.cameraArmBase = 0
|
|
self.cameraArmExtend = 20
|
|
self.pieCount = 0
|
|
self.numPieChunks = 6
|
|
self.pieSlideSpeed = []
|
|
for piece in xrange(self.numPieChunks):
|
|
self.pieSlideSpeed.append(randFloat(0.0, 0.2))
|
|
|
|
self.wantSmoke = ConfigVariableBool('want-kart-smoke', 1).getValue()
|
|
self.wantSparks = ConfigVariableBool('want-kart-sparks', 1).getValue()
|
|
self.__loadTextures()
|
|
return
|
|
|
|
def __loadTextures(self):
|
|
self.pieSplatter = loader.loadModel('phase_6/models/karting/pie_splat_1.bam')
|
|
|
|
def announceGenerate(self):
|
|
DistributedSmoothNode.DistributedSmoothNode.announceGenerate(self)
|
|
self.generateKart()
|
|
self.name = self.uniqueName('vehicle')
|
|
self.posHprBroadcastName = self.uniqueName('vehicleBroadcast')
|
|
self.LODnode.forceSwitch(self.LODnode.getHighestSwitch())
|
|
self.cameraNode = NodePath('cameraNode')
|
|
self.cameraNode.reparentTo(self)
|
|
if self.proRacer:
|
|
self.cameraArmNode = render.attachNewNode('cameraArm')
|
|
self.cameraArmNode.reparentTo(self)
|
|
self.cameraNode.reparentTo(self.cameraArmNode)
|
|
self.proCameraDummyNode = render.attachNewNode('proCameraDummy')
|
|
self.proCameraDummyNode.reparentTo(render)
|
|
self.localVehicle = False
|
|
if hasattr(base, 'localAvatar'):
|
|
self.localVehicle = self.ownerId == base.localAvatar.doId
|
|
if self.localVehicle:
|
|
self.setupPhysics()
|
|
self.setupParticles()
|
|
self.__enableCollisions()
|
|
self.forward = NodePath('forward')
|
|
self.forward.setPos(0, 1, 0)
|
|
self.wallHitsSfx = []
|
|
for wallHit in self.SFX_WallHits:
|
|
self.wallHitsSfx.append(base.loadSfx(wallHit))
|
|
|
|
self.skidLoopAsphaltSfx = base.loadSfx(self.SFX_SkidLoop_Asphalt)
|
|
self.skidLoopAsphaltSfx.setLoop()
|
|
self.skidLoopGrassSfx = base.loadSfx(self.SFX_SkidLoop_Grass)
|
|
self.skidLoopGrassSfx.setLoop()
|
|
self.turboStartSfx = base.loadSfx(self.SFX_TurboStart)
|
|
self.turboLoopSfx = base.loadSfx(self.SFX_TurboLoop)
|
|
self.turboLoopSfx.setLoop()
|
|
self.forward.reparentTo(self.geom[0])
|
|
self.anvil = globalPropPool.getProp('anvil')
|
|
self.anvil.setScale(5)
|
|
self.anvil.reparentTo(hidden)
|
|
self.anvil.setColor(1, 1, 1, 1)
|
|
self.anvil.setTransparency(1)
|
|
self.reparentTo(render)
|
|
|
|
def setupPhysics(self):
|
|
self.__setupCollisions()
|
|
self.physicsMgr = PhysicsManager()
|
|
self.physicsEpoch = globalClock.getFrameTime()
|
|
self.lastPhysicsFrame = 0
|
|
integrator = LinearEulerIntegrator()
|
|
self.physicsMgr.attachLinearIntegrator(integrator)
|
|
fn = ForceNode('windResistance')
|
|
fnp = NodePath(fn)
|
|
fnp.reparentTo(render)
|
|
windResistance = LinearFrictionForce(0.2)
|
|
fn.addForce(windResistance)
|
|
self.physicsMgr.addLinearForce(windResistance)
|
|
self.windResistance = windResistance
|
|
fn = ForceNode('engine')
|
|
fnp = NodePath(fn)
|
|
fnp.reparentTo(self)
|
|
engine = LinearVectorForce(0, 0, 0)
|
|
fn.addForce(engine)
|
|
self.physicsMgr.addLinearForce(engine)
|
|
self.engine = engine
|
|
|
|
def disable(self):
|
|
if self.ownerId not in DistributedVehicle.AvId2kart:
|
|
return
|
|
|
|
DistributedVehicle.AvId2kart.pop(self.ownerId)
|
|
self.finishMovies()
|
|
self.request('Off')
|
|
self.stopSkid()
|
|
self.stopSmooth()
|
|
if self.localVehicle:
|
|
self.__disableCollisions()
|
|
self.__undoCollisions()
|
|
self.physicsMgr.clearLinearForces()
|
|
self.detachNode()
|
|
DistributedSmoothNode.DistributedSmoothNode.disable(self)
|
|
taskMgr.remove('slidePies')
|
|
|
|
def delete(self):
|
|
self.stopSmooth()
|
|
Kart.Kart.delete(self)
|
|
DistributedSmoothNode.DistributedSmoothNode.delete(self)
|
|
if self.localVehicle:
|
|
self.ignoreAll()
|
|
if hasattr(self, 'piePieces'):
|
|
for piece in self.piePieces:
|
|
del piece
|
|
|
|
def getVelocity(self):
|
|
return self.actorNode.getPhysicsObject().getVelocity()
|
|
|
|
def __updateWallCollision(self, entry = None):
|
|
vol = self.curSpeed / 160
|
|
for wallHit in self.wallHitsSfx:
|
|
wallHit.setVolume(vol)
|
|
|
|
def __wallCollisionStart(self, entry):
|
|
self.entry = entry
|
|
self.__wallCollisionStop()
|
|
self.hittingWall = 1
|
|
hitToPlay = random.randrange(0, len(self.wallHitsSfx))
|
|
self.wallCollideTrack = Parallel(Func(self.wallHitsSfx[hitToPlay].play))
|
|
self.__updateWallCollision()
|
|
self.wallCollideTrack.start()
|
|
curSpeed = self.actorNode.getPhysicsObject().getVelocity().length()
|
|
if self.wantSparks and curSpeed > 10:
|
|
if entry.getSurfaceNormal(self)[0] < 0:
|
|
self.fireSparkParticles('right')
|
|
else:
|
|
self.fireSparkParticles('left')
|
|
|
|
def __wallCollisionStop(self, entry = None):
|
|
self.hittingWall = 0
|
|
if self.wallCollideTrack:
|
|
self.wallCollideTrack.pause()
|
|
|
|
def __setupCollisions(self):
|
|
self.cWallTrav = CollisionTraverser('KartWall')
|
|
self.cWallTrav.setRespectPrevTransform(True)
|
|
self.collisionNode = CollisionNode(self.uniqueName('vehicle'))
|
|
self.collisionNode.setFromCollideMask(OTPGlobals.WallBitmask)
|
|
self.collisionNode.setIntoCollideMask(ToontownGlobals.PieBitmask)
|
|
cs = CollisionSphere(0, 0, 4, 4)
|
|
self.collisionNode.addSolid(cs)
|
|
self.collisionNodePath = NodePath(self.collisionNode)
|
|
self.wallHandler = PhysicsCollisionHandler()
|
|
self.wallHandler.setStaticFrictionCoef(0.0)
|
|
self.wallHandler.setDynamicFrictionCoef(0.1)
|
|
self.wallHandler.addCollider(self.collisionNodePath, self)
|
|
self.wallHandler.setInPattern('enterWallCollision')
|
|
self.wallHandler.setOutPattern('exitWallCollision')
|
|
self.cWallTrav.addCollider(self.collisionNodePath, self.wallHandler)
|
|
self.accept('enterWallCollision', self.__wallCollisionStart)
|
|
self.accept('exitWallCollision', self.__wallCollisionStop)
|
|
cRay = CollisionRay(0.0, 0.0, 40000.0, 0.0, 0.0, -1.0)
|
|
cRayNode = CollisionNode(self.uniqueName('vehicle-FloorRay'))
|
|
cRayNode.addSolid(cRay)
|
|
cRayNode.setFromCollideMask(OTPGlobals.FloorBitmask)
|
|
cRayNode.setIntoCollideMask(BitMask32.allOff())
|
|
self.cRayNodePath = self.attachNewNode(cRayNode)
|
|
self.lifter = CollisionHandlerGravity()
|
|
self.lifter.setGravity(32.174 * 3.0)
|
|
self.lifter.addInPattern('floorCollision')
|
|
self.lifter.addAgainPattern('floorCollision')
|
|
self.lifter.setOffset(OTPGlobals.FloorOffset)
|
|
self.lifter.setReach(40.0)
|
|
self.lifter.addCollider(self.cRayNodePath, self)
|
|
base.cTrav.addCollider(self.cRayNodePath, self.lifter)
|
|
self.accept('floorCollision', self.__groundCollision)
|
|
self.accept('imIn-banana', self.hitBanana)
|
|
base.localAvatar.collisionsOff()
|
|
|
|
def __undoCollisions(self):
|
|
base.cTrav.removeCollider(self.cRayNodePath)
|
|
base.localAvatar.collisionsOn()
|
|
|
|
def __groundCollision(self, entry):
|
|
ground = entry.getIntoNodePath()
|
|
if ground.getNetTag('surface') == '':
|
|
return
|
|
self.groundType = ground.getNetTag('surface')
|
|
|
|
def __enableCollisions(self):
|
|
self.cQueue = []
|
|
self.cRays = NodePath('stickVehicleToFloor')
|
|
self.cRays.reparentTo(self.geom[0])
|
|
for wheelNode in self.wheelBases:
|
|
rayNode = CollisionNode(wheelNode.getName())
|
|
x = wheelNode.getX()
|
|
y = wheelNode.getY()
|
|
ray = CollisionRay(x, y, 40000.0, 0.0, 0.0, -1.0)
|
|
rayNode.addSolid(ray)
|
|
rayNode.setFromCollideMask(OTPGlobals.FloorBitmask)
|
|
rayNode.setIntoCollideMask(BitMask32.allOff())
|
|
rayNodePath = self.cRays.attachNewNode(rayNode)
|
|
cQueue = CollisionHandlerQueue()
|
|
self.cWallTrav.addCollider(rayNodePath, cQueue)
|
|
self.cQueue.append(cQueue)
|
|
|
|
self.collisionNodePath.reparentTo(self)
|
|
|
|
def setupLapCollisions(self):
|
|
self.lapBit = BitMask32(32768)
|
|
self.lapHandler = CollisionHandlerEvent()
|
|
self.lapHandler.addInPattern('imIn-%in')
|
|
self.cSphere = CollisionSphere(0, 0, 0, 3)
|
|
self.lapNode = CollisionNode('lapChecker')
|
|
self.lapNode.addSolid(self.cSphere)
|
|
self.lapNode.setIntoCollideMask(BitMask32.allOff())
|
|
self.lapNode.setFromCollideMask(self.lapBit)
|
|
self.lapNodePath = NodePath(self.lapNode)
|
|
self.lapNodePath.reparentTo(self)
|
|
self.cWallTrav.addCollider(self.lapNodePath, self.lapHandler)
|
|
|
|
def __disableCollisions(self):
|
|
self.ignore('imIn-startLine')
|
|
self.ignore('imIn-quarterLine')
|
|
self.ignore('imIn-midLine')
|
|
|
|
def __handleCollisionSphereEnter(self, collEntry = None):
|
|
self.d_requestControl()
|
|
|
|
def setupParticles(self):
|
|
if self.wantSmoke:
|
|
self.setupDriftParticles()
|
|
if self.wantSparks:
|
|
self.setupSparkParticles()
|
|
|
|
def updateParticles(self, leanAmount):
|
|
if self.wantSmoke:
|
|
self.updateDriftParticles(leanAmount)
|
|
|
|
def cleanupParticles(self):
|
|
if self.wantSmoke:
|
|
self.cleanupDriftParticles()
|
|
if self.wantSparks:
|
|
self.cleanupSparkParticles()
|
|
|
|
def setupDriftParticles(self):
|
|
smokeMount = self.geom[0].attachNewNode('Smoke Effect')
|
|
backLeft = smokeMount.attachNewNode('Back Left Smokemount')
|
|
backLeft.setPos(self.geom[0].find('**/' + self.wheelData[self.LRWHEEL]['node']).getPos() + Vec3(-0.25, -1.0, -0.5))
|
|
backRight = smokeMount.attachNewNode('Back Right Smokemount')
|
|
backRight.setPos(self.geom[0].find('**/' + self.wheelData[self.RRWHEEL]['node']).getPos() + Vec3(0.25, -1.0, -0.5))
|
|
driftEffects = (Drift(backLeft, backLeft), Drift(backRight, backRight))
|
|
for x in driftEffects:
|
|
x.start()
|
|
|
|
self.drifts = driftEffects
|
|
self.driftSeq = Sequence(Func(backLeft.show), Func(backRight.show), Wait(1000000), Func(self.drifts[0].effect.getParticlesNamed('particles-1').getRenderer().setColor, Vec4(1.0, 1.0, 1.0, 1.0)), Func(self.drifts[1].effect.getParticlesNamed('particles-1').getRenderer().setColor, Vec4(1.0, 1.0, 1.0, 1.0)), Func(backLeft.hide), Func(backRight.hide))
|
|
self.driftSeqStarted = False
|
|
self.driftParticleForces = [ x.effect.getParticlesNamed('particles-1').getLinearForce(0) for x in self.drifts ]
|
|
self.smokeMount = smokeMount
|
|
backLeft.hide()
|
|
backRight.hide()
|
|
|
|
def updateDriftParticles(self, leanAmount):
|
|
for x in self.driftParticleForces:
|
|
x.setAmplitude(leanAmount * 30)
|
|
|
|
if self.skidding and not self.driftSeqStarted:
|
|
self.driftSeqStarted = True
|
|
self.driftSeq.start()
|
|
elif not self.skidding and self.driftSeqStarted:
|
|
self.driftSeqStarted = False
|
|
self.driftSeq.finish()
|
|
|
|
def cleanupDriftParticles(self):
|
|
self.driftSeq.finish()
|
|
for x in self.drifts:
|
|
x.destroy()
|
|
|
|
self.smokeMount.removeNode()
|
|
del self.driftSeq
|
|
del self.driftParticleForces
|
|
del self.drifts
|
|
del self.smokeMount
|
|
|
|
def setupSparkParticles(self):
|
|
bodyType = self.kartDNA[KartDNA.bodyType]
|
|
endPts = KartDict[bodyType][7]
|
|
self.sparkMount = self.geom[0].attachNewNode('Spark Effect')
|
|
left = self.sparkMount.attachNewNode('Left Sparkmount')
|
|
left.setPos((self.geom[0].find('**/' + self.wheelData[self.LFWHEEL]['node']).getPos() + self.geom[0].find('**/' + self.wheelData[self.LRWHEEL]['node']).getPos()) / 2.0 + Vec3(0.0, -1.0, 1.0))
|
|
left.setScale(0.5)
|
|
right = self.sparkMount.attachNewNode('Right Sparkmount')
|
|
right.setPos((self.geom[0].find('**/' + self.wheelData[self.RFWHEEL]['node']).getPos() + self.geom[0].find('**/' + self.wheelData[self.RRWHEEL]['node']).getPos()) / 2.0 + Vec3(0.0, -1.0, 1.0))
|
|
right.setScale(0.5)
|
|
self.sparks = (Sparks(right, self.sparkMount), Sparks(left, self.sparkMount))
|
|
self.sparks[0].effect.getParticlesNamed('particles-1').getEmitter().setEndpoint1(endPts[0])
|
|
self.sparks[0].effect.getParticlesNamed('particles-1').getEmitter().setEndpoint2(endPts[1])
|
|
self.sparks[0].effect.getParticlesNamed('particles-1').getLinearForce(0).setAmplitude(-50)
|
|
self.sparks[1].effect.getParticlesNamed('particles-1').getEmitter().setEndpoint1(Point3(-endPts[0][0], endPts[0][1], endPts[0][2]))
|
|
self.sparks[1].effect.getParticlesNamed('particles-1').getEmitter().setEndpoint2(Point3(-endPts[1][0], endPts[1][1], endPts[1][2]))
|
|
self.sparks[1].effect.getParticlesNamed('particles-1').getLinearForce(0).setAmplitude(50)
|
|
|
|
def fireSparkParticles(self, side):
|
|
spark = self.sparks[{'right': 0,
|
|
'left': 1}[side]]
|
|
if not spark.effect.isEnabled():
|
|
spark.effect.getParticlesNamed('particles-1').setBirthRate(0.02)
|
|
spark.start()
|
|
taskMgr.doMethodLater(0.25, self.stopSparkParticles, 'sparkTimer-' + side, extraArgs=[side])
|
|
|
|
def stopSparkParticles(self, side = None):
|
|
sides = {0: 'right',
|
|
1: 'left'}
|
|
if side == None:
|
|
for x in sides.keys():
|
|
self.sparks[x].effect.getParticlesNamed('particles-1').setBirthRate(1000)
|
|
taskMgr.doMethodLater(0.75, self.sparks[x].stop, 'stopSparks-' + sides[x], extraArgs=[])
|
|
|
|
else:
|
|
spark = self.sparks[{'right': 0,
|
|
'left': 1}[side]]
|
|
spark.effect.getParticlesNamed('particles-1').setBirthRate(1000)
|
|
taskMgr.doMethodLater(0.75, spark.stop, 'stopSparks-' + side, extraArgs=[])
|
|
return
|
|
|
|
def cleanupSparkParticles(self):
|
|
taskMgr.remove('sparkTimer-left')
|
|
taskMgr.remove('sparkTimer-right')
|
|
taskMgr.remove('stopSparks-left')
|
|
taskMgr.remove('stopSparks-right')
|
|
for x in self.sparks:
|
|
x.destroy()
|
|
|
|
self.sparkMount.removeNode()
|
|
del self.sparks
|
|
del self.sparkMount
|
|
|
|
def setState(self, state, avId):
|
|
self.notify.debug('SetState received: %s avId: %s' % (state, avId))
|
|
if state == 'C':
|
|
self.demand('Controlled', avId)
|
|
elif state == 'P':
|
|
self.demand('Parked')
|
|
else:
|
|
self.notify.error('Invalid state from AI: %s' % state)
|
|
|
|
def d_requestControl(self):
|
|
self.sendUpdate('requestControl')
|
|
|
|
def d_requestParked(self):
|
|
self.sendUpdate('requestParked')
|
|
|
|
def enterOff(self):
|
|
pass
|
|
|
|
def exitOff(self):
|
|
pass
|
|
|
|
def enterParked(self):
|
|
pass
|
|
|
|
def exitParked(self):
|
|
pass
|
|
|
|
def enterControlled(self, avId):
|
|
self.avId = avId
|
|
self.toon = base.cr.doId2do.get(avId, None)
|
|
if self.toon:
|
|
self.toon.stopSmooth()
|
|
self.toon.stopPosHprBroadcast()
|
|
for feet in self.toon.getPieces(('legs', 'feet')):
|
|
feet.hide()
|
|
|
|
self.toon.reparentTo(self.toonSeat)
|
|
self.toon.dropShadow.hide()
|
|
self.notify.debug('setting pos of toon%s' % self.toon.doId)
|
|
self.toon.setPosHpr(0, 0, 0, 0, 0, 0)
|
|
self.toon.loop('sit')
|
|
if self.toon.doId == localAvatar.doId:
|
|
self.notify.debug('calling send currentPosition')
|
|
self.toon.sendCurrentPosition()
|
|
self.doHeadScale(self.toon, 1.75)
|
|
self.toon.setShear(0, 0, 0)
|
|
NametagGlobals.setOnscreenChatForced(1)
|
|
if self.localVehicle:
|
|
camera.reparentTo(self.cameraNode)
|
|
camera.setPosHpr(0, -33, 16, 0, -10, 0)
|
|
self.physicsMgr.attachPhysicalNode(self.node())
|
|
self.__enableControlInterface()
|
|
self.__createPieWindshield()
|
|
self.startPosHprBroadcast()
|
|
self.engineSfxTrack = self.generateEngineStartTrack()
|
|
self.engineSfxTrack.start()
|
|
else:
|
|
self.startSmooth()
|
|
taskName = 'updateNonlocalVehicle-%s' % avId
|
|
self.updateNonLocalTask = taskMgr.add(self.__updateNonlocalVehicle, taskName)
|
|
return
|
|
|
|
def exitControlled(self):
|
|
if self.localVehicle:
|
|
self.stopPosHprBroadcast()
|
|
self.__disableControlInterface()
|
|
self.physicsMgr.removePhysicalNode(self.node())
|
|
self.cleanupParticles()
|
|
camera.reparentTo(localAvatar)
|
|
camera.setPos(localAvatar.cameraPositions[0][0])
|
|
camera.setHpr(0, 0, 0)
|
|
self.engineSfxTrack.finish()
|
|
self.engineSfxTrack = self.generateEngineStopTrack()
|
|
else:
|
|
self.stopSmooth()
|
|
taskMgr.remove(self.updateNonLocalTask)
|
|
if self.toon and not self.toon.isDisabled() and not self.toon.isEmpty():
|
|
self.toon.dropShadow.show()
|
|
self.doHeadScale(self.toon, None)
|
|
self.toon.setPosHpr(self.geom[0], 0, 8, 0, 0, 0, 0)
|
|
for feet in self.toon.getPieces(('legs', 'feet')):
|
|
feet.show()
|
|
|
|
self.toon.reparentTo(render)
|
|
self.toon.loop('neutral')
|
|
self.toon.startSmooth()
|
|
NametagGlobals.setOnscreenChatForced(0)
|
|
base.camLens.setMinFov(settings['fov']/(4./3.))
|
|
|
|
def doHeadScale(self, model, scale):
|
|
if scale == None:
|
|
scale = ToontownGlobals.toonHeadScales[model.style.getAnimal()]
|
|
base.localAvatar.clearCheesyEffect()
|
|
for hi in xrange(model.headParts.getNumPaths()):
|
|
head = model.headParts[hi]
|
|
head.setScale(scale)
|
|
|
|
return
|
|
|
|
def __createPieWindshield(self):
|
|
self.piePieces = []
|
|
for piece in xrange(self.numPieChunks):
|
|
self.piePieces.append(DirectLabel(relief=None, pos=(0.0, 0.0, 0.0), image=self.pieSplatter, image_scale=(0.5, 0.5, 0.5), text=' ', text_scale=0.18, text_fg=(1, 0, 1, 1), text_pos=(-0.0, 0.0, 0), text_font=ToontownGlobals.getSignFont(), textMayChange=1))
|
|
self.piePieces[piece].hide()
|
|
|
|
return
|
|
|
|
def showPieces(self):
|
|
xRange = 0.3
|
|
for piece in self.piePieces:
|
|
piece.setPos(randFloat(-xRange, xRange), randFloat(-0.1, 3.5), randFloat(-0.9, 0.9))
|
|
piece.setScale(randFloat(1.1, 2.0), 1, randFloat(1.1, 2.0))
|
|
piece.show()
|
|
xRange += 2.5 / self.numPieChunks
|
|
|
|
for piece in xrange(self.numPieChunks):
|
|
self.pieSlideSpeed[piece] = randFloat(0.0, 0.2)
|
|
|
|
def splatPie(self):
|
|
self.showPieces()
|
|
if self.pieCount == 0:
|
|
self.pieCount = 15
|
|
taskMgr.doMethodLater(1, self.__countPies, ' ', extraArgs=[])
|
|
taskMgr.add(self.__slidePies, 'slidePies', priority=25)
|
|
else:
|
|
self.pieCount = 15
|
|
|
|
def __countPies(self):
|
|
if self.pieCount > 0:
|
|
taskMgr.doMethodLater(1, self.__countPies, ' ', extraArgs=[])
|
|
self.pieCount -= 1
|
|
else:
|
|
for piece in self.piePieces:
|
|
piece.hide()
|
|
|
|
def __slidePies(self, optional = None):
|
|
dt = globalClock.getDt()
|
|
for piece in xrange(self.numPieChunks):
|
|
self.pieSlideSpeed[piece] += randFloat(0.0, 0.25 * dt)
|
|
pieSpeed = self.pieSlideSpeed[piece] * dt
|
|
self.piePieces[piece].setPos(self.piePieces[piece].getPos()[0], self.piePieces[piece].getPos()[1] - pieSpeed, self.piePieces[piece].getPos()[2] - pieSpeed)
|
|
|
|
if self.pieCount == 0:
|
|
return Task.done
|
|
else:
|
|
return Task.cont
|
|
|
|
def __enableControlInterface(self):
|
|
if self.canRace:
|
|
self.enableControls()
|
|
taskMgr.remove('watchVehicleControls')
|
|
taskMgr.add(self.__watchControls, 'watchVehicleControls', priority=25)
|
|
if not self.speedometer:
|
|
cm = CardMaker('speed')
|
|
cm.setFrame(-0.5, 0.5, -0.5, 0.5)
|
|
self.speedometerImages = base.a2dBottomRight.attachNewNode('SpeedometerImages')
|
|
self.speedometerImages.setTransparency(True)
|
|
self.speedometerImages.setPos(-0.1, 0.0, 0.03)
|
|
self.speedometerImages.setScale(0.75)
|
|
m = loader.loadModel('phase_6/models/karting/speedometer')
|
|
if self.getBodyColor() == InvalidEntry:
|
|
bodyColor = getDefaultColor()
|
|
else:
|
|
bodyColor = getAccessory(self.getBodyColor())
|
|
if self.getAccessoryColor() == InvalidEntry:
|
|
accColor = getDefaultColor()
|
|
else:
|
|
accColor = getAccessory(self.getAccessoryColor())
|
|
self.speedometerImages.attachNewNode(m.find('**/*gauge').node()).setColorScale(1, 1, 1, 1)
|
|
self.speedGauge = self.speedometerImages.attachNewNode(m.find('**/*spin').node())
|
|
self.speedGauge.setColor(1, 1, 1, 1)
|
|
c = (Vec4(1, 1, 1, 1) + accColor) / 2.0
|
|
c.setW(1.0)
|
|
self.speedometerImages.attachNewNode(m.find('**/*face').node()).setColorScale(c)
|
|
c = (Vec4(2, 2, 2, 2) - accColor) / 2.0
|
|
c = (bodyColor + Vec4(1, 1, 1, 1)) / 2.0
|
|
c.setW(1.0)
|
|
self.speedometerImages.attachNewNode(m.find('**/*tics').node()).setColorScale(c)
|
|
c = (bodyColor + Vec4(1, 1, 1, 1)) / 2.0
|
|
c.setW(1.0)
|
|
self.speedometerImages.attachNewNode(m.find('**/*ring').node()).setColorScale(c)
|
|
self.speedometer = DirectLabel(relief=None, pos=(-0.1, 0.0, 0.03), text=str(0), text_scale=0.18, text_fg=bodyColor, text_pos=(-0.04, 0.02, 0), text_font=ToontownGlobals.getSignFont())
|
|
self.speedometer.reparentTo(base.a2dBottomRight)
|
|
else:
|
|
self.showSpeedometer()
|
|
self.arrowVert = 0
|
|
self.arrowHorz = 0
|
|
return
|
|
|
|
def showSpeedometer(self):
|
|
if self.speedometer:
|
|
self.speedometer.show()
|
|
self.speedometerImages.show()
|
|
|
|
def hideSpeedometer(self):
|
|
if self.speedometer:
|
|
self.speedometer.hide()
|
|
self.speedometerImages.hide()
|
|
|
|
def __disableControlInterface(self):
|
|
self.hideSpeedometer()
|
|
self.disableControls()
|
|
self.stopSmooth()
|
|
taskMgr.remove('watchVehicleControls')
|
|
|
|
def __deleteControlInterface(self):
|
|
if self.speedometer:
|
|
self.speedometer.destroy()
|
|
self.speedometer = None
|
|
self.speedGauge = None
|
|
self.speedometerImages.removeNode()
|
|
self.speedometerImages = None
|
|
return
|
|
|
|
def setTurbo(self, setting):
|
|
self.turbo = setting
|
|
if self.turbo:
|
|
self.turboLoopSfx.play()
|
|
else:
|
|
self.turboLoopSfx.stop()
|
|
|
|
def interruptTurbo(self):
|
|
self.__stopTurbo()
|
|
if self.cameraTrack:
|
|
self.cameraTrack.finish()
|
|
self.cameraTrack = None
|
|
return
|
|
|
|
def startTurbo(self):
|
|
newCameraPos = Point3(0, -25, 16)
|
|
newCameraFov = 70
|
|
turboDuration = 3
|
|
startFov = settings['fov']/(4./3.)
|
|
if self.cameraTrack:
|
|
self.cameraTrack.pause()
|
|
cameraZoomIn = Parallel(LerpPosInterval(camera, 2, newCameraPos), LerpFunc(base.camLens.setMinFov, fromData=startFov, toData=newCameraFov, duration=2))
|
|
cameraToNormal = Parallel(LerpPosInterval(camera, 1, Point3(0, -33, 16), newCameraPos), LerpFunc(base.camLens.setMinFov, fromData=newCameraFov, toData=startFov, duration=1))
|
|
self.cameraTrack = Sequence(Func(self.turboStartSfx.play), cameraZoomIn, Func(lambda : self.setTurbo(True)), Wait(turboDuration), Func(self.__stopTurbo), cameraToNormal)
|
|
self.cameraTrack.start()
|
|
|
|
def __stopTurbo(self, task = None):
|
|
self.setTurbo(False)
|
|
|
|
def __controlPressed(self):
|
|
self.__throwGag()
|
|
|
|
def __controlReleased(self):
|
|
pass
|
|
|
|
def __upArrow(self, pressed):
|
|
if pressed:
|
|
self.arrowVert = 1
|
|
elif self.arrowVert > 0:
|
|
self.arrowVert = 0
|
|
|
|
def __downArrow(self, pressed):
|
|
if pressed:
|
|
self.arrowVert = -1
|
|
elif self.arrowVert < 0:
|
|
self.arrowVert = 0
|
|
|
|
def __rightArrow(self, pressed):
|
|
if pressed:
|
|
self.arrowHorz = 1
|
|
self.rightHeld += 1
|
|
elif self.arrowHorz > 0:
|
|
self.arrowHorz = 0
|
|
self.rightHeld = 0
|
|
|
|
def __leftArrow(self, pressed):
|
|
if pressed:
|
|
self.arrowHorz = -1
|
|
self.leftHeld += 1
|
|
elif self.arrowHorz < 0:
|
|
self.arrowHorz = 0
|
|
self.leftHeld = 0
|
|
|
|
def __updateNonlocalVehicle(self, task = None):
|
|
self.curSpeed = self.smoother.getSmoothForwardVelocity()
|
|
rotSpeed = -1 * self.smoother.getSmoothRotationalVelocity()
|
|
self.leanAmount = self.curSpeed * rotSpeed / 500.0
|
|
self.leanAmount = clampScalar(self.leanAmount, -10, 10)
|
|
self.__animate()
|
|
return Task.cont
|
|
|
|
def __animate(self):
|
|
speed = self.curSpeed
|
|
self.spinWheels(speed / 10)
|
|
enginePitch = clampScalar(speed / 120.0, 0.5, 15)
|
|
self.kartLoopSfx.setPlayRate(enginePitch)
|
|
if not self.localVehicle:
|
|
dist = (self.getPos() - localAvatar.getPos()).length()
|
|
if self.localVehicle:
|
|
if self.lifter.isOnGround():
|
|
if self.offGround > 10:
|
|
kart = self.geom[0].find('**/main*')
|
|
bumpDown1 = kart.posInterval(0.1, Vec3(0, 0, -1))
|
|
bumpUp1 = kart.posInterval(0.15, Vec3(0, 0, 0))
|
|
bumpDown2 = kart.posInterval(0.5, Vec3(0, 0, -.4))
|
|
bumpUp2 = kart.posInterval(0.7, Vec3(0, 0, 0))
|
|
bumpSeq = Sequence(bumpDown1, bumpUp1, bumpDown2, bumpUp2)
|
|
bumpSeq.start()
|
|
self.offGround = 0
|
|
else:
|
|
self.offGround += 1
|
|
if self.offGround == 0:
|
|
modifier = self.surfaceModifiers[self.groundType]['shake'] * (speed / 50.0)
|
|
else:
|
|
modifier = 1
|
|
roll = self.leanAmount * 1.5
|
|
roll += (random.random() * 2 - 1) * modifier
|
|
pitch = self.acceleration * -.005
|
|
pitch += (random.random() * 2 - 1) * modifier
|
|
self.rollSuspension(roll)
|
|
self.pitchSuspension(pitch)
|
|
return Task.cont
|
|
|
|
def __clampPosition(self):
|
|
retVal = False
|
|
if self.getX() < -3276:
|
|
self.notify.debug('clamping X %d' % self.getX())
|
|
self.setX(-3276)
|
|
retVal = True
|
|
if self.getX() > 3276:
|
|
self.notify.debug('clamping X %d' % self.getX())
|
|
self.setX(3276)
|
|
retVal = True
|
|
if self.getY() < -3276:
|
|
self.notify.debug('clamping Y %d' % self.getY())
|
|
self.setY(-3276)
|
|
retVal = True
|
|
if self.getY() > 3276:
|
|
self.notify.debug('clamping Y %d' % self.getY())
|
|
self.setY(3276)
|
|
retVal = True
|
|
if self.getZ() < -3276:
|
|
self.notify.debug('clamping Z %d' % self.getZ())
|
|
self.setZ(-3276)
|
|
retVal = True
|
|
if self.getZ() > 3276:
|
|
self.notify.debug('clamping Z %d' % self.getZ())
|
|
self.setZ(3276)
|
|
retVal = True
|
|
return retVal
|
|
|
|
def amIClampingPosition(self):
|
|
return self.getX() == -3276 or self.getX() == 3276 or self.getY() == -3276 or self.getY() == 3276 or self.getZ() == -3276 or self.getZ() == 3276
|
|
|
|
def __computeTurnRatio(self, speed):
|
|
effectiveSpeed = speed
|
|
if effectiveSpeed > self.speedMinTurn:
|
|
effectiveSpeed = self.speedMinTurn
|
|
if effectiveSpeed < self.speedMaxTurn:
|
|
turnRatio = 1.0 * effectiveSpeed
|
|
elif effectiveSpeed >= self.speedMaxTurn:
|
|
turnRatio = 1.0 * (effectiveSpeed * (self.speedMaxTurn / speed))
|
|
|
|
def __updateWheelPos(self, dt, curSpeed):
|
|
ratioIntoMax = (curSpeed - self.speedMinTurn) / (self.speedMaxTurn - self.speedMinTurn)
|
|
if ratioIntoMax > 1.0:
|
|
ratioIntoMax = 1.0
|
|
if ratioIntoMax < 0.0:
|
|
ratioIntoMax = 0.0
|
|
maxWheelDeflection = self.wheelMaxTurn * ratioIntoMax + self.wheelMinTurn * (1.0 - ratioIntoMax)
|
|
if self.wheelPosition * self.arrowHorz > 0:
|
|
self.wheelPosition += self.arrowHorz * dt / self.wheelTurnTime
|
|
else:
|
|
self.wheelPosition += self.arrowHorz * dt / self.wheelFightTime
|
|
if not self.arrowHorz:
|
|
if self.wheelPosition > 0:
|
|
self.wheelPosition -= dt / self.wheelReturnTime
|
|
if self.wheelPosition < 0:
|
|
self.wheelPosition = 0
|
|
else:
|
|
self.wheelPosition += dt / self.wheelReturnTime
|
|
if self.wheelPosition > 0:
|
|
self.wheelPosition = 0
|
|
if abs(self.wheelPosition) >= maxWheelDeflection:
|
|
if self.wheelPosition > 0:
|
|
self.wheelPosition = maxWheelDeflection
|
|
else:
|
|
self.wheelPosition = -maxWheelDeflection
|
|
|
|
def __watchControls(self, task):
|
|
dt = globalClock.getDt()
|
|
curVelocity = self.actorNode.getPhysicsObject().getVelocity()
|
|
curSpeed = curVelocity.length()
|
|
fvec = self.forward.getPos(render) - self.getPos(render)
|
|
fvec.normalize()
|
|
dotProduct = curVelocity.dot(fvec)
|
|
goingBack = -1
|
|
if dotProduct < 0:
|
|
goingBack = 1
|
|
if self.proRacer:
|
|
self.__computeTurnRatio(curSpeed)
|
|
self.__updateWheelPos(dt, curSpeed)
|
|
newHForTurning = self.getH()
|
|
if self.proRacer or not self.stopped and self.arrowHorz and curSpeed > 1:
|
|
if self.proRacer:
|
|
turnHelp = 0
|
|
if self.hittingWall or goingBack == 1:
|
|
turnHelp = self.arrowHorz
|
|
effectiveSpeed = curSpeed
|
|
if effectiveSpeed > self.speedMinTurn:
|
|
effectiveSpeed = self.speedMinTurn
|
|
rotation = -goingBack * (self.wheelPosition * dt * self.turnRatio * -1.8 * curSpeed / 100 + turnHelp * dt * self.turnRatio * -1.2)
|
|
self.outPutCounter += 1
|
|
if self.outPutCounter > 5:
|
|
self.outPutCounter = 0
|
|
else:
|
|
rotation = self.arrowHorz * dt * self.turnRatio * -1.2
|
|
oldH = self.getH()
|
|
newH = (oldH + rotation) % 360
|
|
self.setH(newH)
|
|
newHForTurning = newH
|
|
if self.groundType == 'ice':
|
|
newHForTurning = (oldH + rotation * iceTurnFactor) % 360
|
|
pitch = -self.getP() + 5
|
|
accelBase = self.accelerationBase
|
|
pitch += accelBase
|
|
pitch = clampScalar(pitch, accelBase - 5, accelBase + 5)
|
|
self.accelerationMult = pitch * 2
|
|
if self.groundType == 'ice':
|
|
self.accelerationMult *= iceAccelFactor
|
|
if self.stopped:
|
|
self.acceleration = 0
|
|
else:
|
|
self.acceleration = self.arrowVert * self.accelerationMult * self.cheatFactor
|
|
if self.proRacer:
|
|
if self.skidding:
|
|
self.acceleration = self.arrowVert * self.accelerationMult * self.cheatFactor * 0.5
|
|
if self.turbo:
|
|
self.acceleration += self.accelerationMult * 1.5
|
|
self.engine.setVector(Vec3(0, self.acceleration, 0))
|
|
if self.groundType == 'ice':
|
|
rotMat = Mat3.rotateMatNormaxis(newHForTurning, Vec3.up())
|
|
else:
|
|
rotMat = Mat3.rotateMatNormaxis(self.getH(), Vec3.up())
|
|
curHeading = rotMat.xform(Vec3.forward())
|
|
push = (3 - self.getP()) * 0.02
|
|
curHeading.setZ(curHeading.getZ() - min(0.2, max(-.2, push)))
|
|
onScreenDebug.append('vehicle curHeading = %s\n' % curHeading.pPrintValues())
|
|
onScreenDebug.append('vehicle H = %s newHForTurning=%f\n' % (self.getH(), newHForTurning))
|
|
windResistance = self.surfaceModifiers[self.groundType]['windResistance']
|
|
self.windResistance.setCoef(windResistance)
|
|
physicsFrame = int((globalClock.getFrameTime() - self.physicsEpoch) * self.physicsCalculationsPerSecond)
|
|
numFrames = min(physicsFrame - self.lastPhysicsFrame, self.maxPhysicsFrames)
|
|
self.lastPhysicsFrame = physicsFrame
|
|
leanIncrement = self.arrowHorz * self.physicsDt * self.turnRatio
|
|
if self.stopped:
|
|
leanIncrement = 0
|
|
driftMin = self.surfaceModifiers[self.groundType]['driftMin']
|
|
if self.proRacer:
|
|
driftMin = self.surfaceModifiers[self.groundType]['driftMin'] * 0.2
|
|
if self.skidding:
|
|
driftMin = self.surfaceModifiers[self.groundType]['driftMin']
|
|
for i in xrange(int(numFrames)):
|
|
self.physicsMgr.doPhysics(self.physicsDt)
|
|
curVelocity = self.actorNode.getPhysicsObject().getVelocity()
|
|
idealVelocity = curHeading * curSpeed
|
|
curVelocity *= self.imHitMult
|
|
driftVal = abs(self.leanAmount) * 16 / self.cheatFactor + 15 / self.cheatFactor
|
|
curVelocity = Vec3((curVelocity * driftVal + idealVelocity) / (driftVal + 1))
|
|
curSpeed = curVelocity.length()
|
|
curVelocity.normalize()
|
|
curVelocity *= min(curSpeed, 600)
|
|
self.actorNode.getPhysicsObject().setVelocity(curVelocity)
|
|
curSpeed = curVelocity.length()
|
|
speedFactor = min(curSpeed, 150) / 162.0
|
|
self.leanAmount = (self.leanAmount + leanIncrement) * speedFactor
|
|
self.leanAmount = clampScalar(self.leanAmount, -10, 10)
|
|
|
|
self.cWallTrav.traverse(render)
|
|
self.curSpeed = curSpeed
|
|
if self.proRacer:
|
|
self.turnWheels(self.wheelPosition * -45)
|
|
else:
|
|
self.turnWheels(self.arrowHorz * -10)
|
|
self.__animate()
|
|
if self.proRacer:
|
|
speedProporation = 1.0
|
|
if curSpeed < self.speedMaxTurn:
|
|
speedProporation = 0.0
|
|
else:
|
|
speedProporation = (curSpeed - self.speedMaxTurn) / self.speedMinTurn
|
|
cameraDist = self.cameraArmBase + self.cameraArmExtend * speedProporation
|
|
cameraOffset = Point3(0, -cameraDist, 0)
|
|
self.cameraNode.setPos(cameraOffset)
|
|
behindPos = render.getRelativePoint(self, Point3(0, -30, 0))
|
|
self.proCameraDummyNode.setPos(render, behindPos)
|
|
self.proCameraDummyNode.lookAt(self)
|
|
self.cameraNode.lookAt(self)
|
|
dir1 = self.proCameraDummyNode.getH()
|
|
dir2 = self.proCameraHeading
|
|
if dir1 > 180:
|
|
dir1 -= 360
|
|
elif dir1 < -180:
|
|
dir1 += 360
|
|
if dir2 > 180:
|
|
dir2 -= 360
|
|
elif dir2 < -180:
|
|
dir2 += 360
|
|
self.proCameraHeading = dir2
|
|
dif = dir1 - dir2
|
|
if dif > 180:
|
|
dif -= 360
|
|
elif dif < -180:
|
|
dif += 360
|
|
speedDif = abs(dif)
|
|
if speedDif > 90:
|
|
speedDif = 90
|
|
cameraTightener = 1.0
|
|
if curSpeed > self.speedMinTurn:
|
|
cameraTightener = self.cameraTightener
|
|
else:
|
|
cameraTightener = 1.0 + curSpeed / self.speedMinTurn * (self.cameraTightener - 1.0)
|
|
swingSpeedRatio = speedDif / 90
|
|
swingSpeed = self.armSwingSpeedPerp * swingSpeedRatio + self.armSwingSpeedPara * (1 - swingSpeedRatio)
|
|
self.proCameraHeading += dif * cameraTightener * (dt / swingSpeed)
|
|
self.cameraArmNode.setH(self.proCameraHeading - self.getH())
|
|
elif not self.stopped:
|
|
self.cameraNode.setH(self.leanAmount)
|
|
self.updateParticles(self.leanAmount)
|
|
if (self.leanAmount > 8 or self.leanAmount < -8) and self.offGround <= 0:
|
|
self.startSkid()
|
|
else:
|
|
self.stopSkid()
|
|
if self.speedometer:
|
|
self.speedometer['text'] = str(int(curSpeed / 3))
|
|
self.speedGauge.setR(min(110, max(0, curSpeed / 3 / 120 * 110)))
|
|
if not self.stopped:
|
|
self.stickCarToGround()
|
|
if self.__clampPosition():
|
|
self.notify.debug('did a clampPosition on %d' % self.doId)
|
|
return Task.cont
|
|
|
|
def enableControls(self):
|
|
self.canRace = True
|
|
self.accept('control', self.__controlPressed)
|
|
self.accept('control-up', self.__controlReleased)
|
|
self.accept('InputState-forward', self.__upArrow)
|
|
self.accept('InputState-reverse', self.__downArrow)
|
|
self.accept('InputState-turnLeft', self.__leftArrow)
|
|
self.accept('InputState-turnRight', self.__rightArrow)
|
|
|
|
def disableControls(self):
|
|
self.arrowVert = 0
|
|
self.arrowHorz = 0
|
|
self.ignore('control')
|
|
self.ignore('control-up')
|
|
self.ignore('tab')
|
|
self.ignore('InputState-forward')
|
|
self.ignore('InputState-reverse')
|
|
self.ignore('InputState-turnLeft')
|
|
self.ignore('InputState-turnRight')
|
|
|
|
def setInput(self, on):
|
|
if localAvatar.doId == self.ownerId:
|
|
if on:
|
|
self.enableControls()
|
|
else:
|
|
self.disableControls()
|
|
|
|
def shakeWheel(self, nWheel, floorNode):
|
|
groundType = floorNode.getNetTag('surface')
|
|
modifier = self.surfaceModifiers[groundType]['shake']
|
|
shakeFactor = (random.random() * 2 - 1) * modifier
|
|
shakeFactor *= self.curSpeed / 200
|
|
node = self.wheelCenters[nWheel].find('*Wheel')
|
|
node.setZ(shakeFactor)
|
|
|
|
def stickCarToGround(self):
|
|
posList = []
|
|
nWheels = len(self.wheelData)
|
|
for nWheel in xrange(nWheels):
|
|
cQueue = self.cQueue[nWheel]
|
|
cQueue.sortEntries()
|
|
if cQueue.getNumEntries() == 0:
|
|
return
|
|
entry = cQueue.getEntry(0)
|
|
self.shakeWheel(nWheel, entry.getIntoNodePath())
|
|
pos = entry.getSurfacePoint(render)
|
|
wheelPos = self.wheelBases[nWheel].getPos(render)
|
|
pos = wheelPos - pos
|
|
posList.append(pos)
|
|
cQueue.clearEntries()
|
|
|
|
rf = posList[0].getZ()
|
|
lf = posList[1].getZ()
|
|
rr = posList[2].getZ()
|
|
lr = posList[3].getZ()
|
|
right = (rf + rr) / 2
|
|
left = (lf + lr) / 2
|
|
rollVal = right - left
|
|
rollVal = clampScalar(rollVal, -1, 1)
|
|
curRoll = self.getR()
|
|
newRoll = curRoll + rollVal * 2.0
|
|
self.setR(newRoll)
|
|
if not self.stopped:
|
|
camera.setR(-newRoll)
|
|
front = (rf + lf) / 2
|
|
rear = (rr + lr) / 2
|
|
center = (front + rear) / 2
|
|
pitchVal = front - rear
|
|
pitchVal = clampScalar(pitchVal, -1, 1)
|
|
curPitch = self.getP()
|
|
newPitch = curPitch - pitchVal * 2.0
|
|
self.setP((newPitch + curPitch) / 2.0)
|
|
if self.proRacer:
|
|
self.cameraNode.setP(-newPitch)
|
|
elif not self.stopped:
|
|
self.cameraNode.setP(-newPitch)
|
|
|
|
def setBodyType(self, bodyType):
|
|
self.kartDNA[KartDNA.bodyType] = bodyType
|
|
|
|
def setBodyColor(self, bodyColor):
|
|
self.kartDNA[KartDNA.bodyColor] = bodyColor
|
|
|
|
def setAccessoryColor(self, accColor):
|
|
self.kartDNA[KartDNA.accColor] = accColor
|
|
|
|
def setEngineBlockType(self, ebType):
|
|
self.kartDNA[KartDNA.ebType] = ebType
|
|
|
|
def setSpoilerType(self, spType):
|
|
self.kartDNA[KartDNA.spType] = spType
|
|
|
|
def setFrontWheelWellType(self, fwwType):
|
|
self.kartDNA[KartDNA.fwwType] = fwwType
|
|
|
|
def setBackWheelWellType(self, bwwType):
|
|
self.kartDNA[KartDNA.bwwType] = bwwType
|
|
|
|
def setRimType(self, rimsType):
|
|
self.kartDNA[KartDNA.rimsType] = rimsType
|
|
|
|
def setDecalType(self, decalType):
|
|
self.kartDNA[KartDNA.decalType] = decalType
|
|
|
|
def setOwner(self, avId):
|
|
self.ownerId = avId
|
|
DistributedVehicle.AvId2kart[avId] = self
|
|
|
|
def stopCar(self, level):
|
|
self.imHitMult = level
|
|
self.__stopTurbo()
|
|
self.stopped = True
|
|
|
|
def startCar(self):
|
|
self.imHitMult = 1
|
|
self.stopped = False
|
|
|
|
def hideAnvil(self):
|
|
self.anvil.reparentTo(hidden)
|
|
self.anvil.setAlphaScale(1)
|
|
self.dropShadow.setScale(self.ShadowScale)
|
|
|
|
def spinCar(self, spin):
|
|
self.geom[0].setH(2 * spin)
|
|
|
|
def playSpin(self, timeStamp):
|
|
delta = -globalClockDelta.networkToLocalTime(timeStamp, globalClock.getFrameTime(), 16, 100) + globalClock.getFrameTime()
|
|
self.spinAnim = LerpFunc(self.spinCar, fromData=0, toData=360, duration=min(1 - delta, 0))
|
|
self.spinAnim.start()
|
|
|
|
def __throwGag(self):
|
|
base.race.shootGag()
|
|
|
|
def dropOnMe(self, timestamp):
|
|
self.anvil.setScale(7, 9, 7)
|
|
self.anvil.setPos(0, 0, 75)
|
|
self.anvil.reparentTo(self)
|
|
anvilDrop = ProjectileInterval(self.anvil, startPos=Point3(0, 0, 100), endPos=Point3(0, 0, 0), duration=1)
|
|
shadowScale = self.dropShadow.scaleInterval(1, self.ShadowScale * 2)
|
|
fadeOut = LerpFunc(self.anvil.setAlphaScale, fromData=1, toData=0, duration=0.5)
|
|
flattenMe = self.geom[0].scaleInterval(0.08, Vec3(1, 1, 0.1))
|
|
unFlatten = Sequence(self.geom[0].scaleInterval(0.2, Vec3(1, 1, 2)), self.geom[0].scaleInterval(0.1, 1))
|
|
anvilSquish = Parallel(Parallel(anvilDrop, shadowScale), Sequence(Wait(0.92), flattenMe))
|
|
anvilStretchFade = Sequence(Parallel(self.anvil.scaleInterval(0.2, Vec3(7, 9, 5)), Func(self.lookUp)), fadeOut)
|
|
self.gagMovie = Sequence(anvilSquish, Func(self.stopCar, 0.9), anvilStretchFade, Wait(0.5), Parallel(unFlatten, Func(self.lookNormal)), Func(self.startCar), Func(self.hideAnvil))
|
|
self.gagMovie.start()
|
|
|
|
def lookUp(self):
|
|
if self.toon and self.toon.headParts:
|
|
headParts = self.toon.headParts
|
|
for hi in xrange(headParts.getNumPaths()):
|
|
head = headParts[hi]
|
|
head.setP(90)
|
|
|
|
def lookNormal(self):
|
|
if self.toon and self.toon.headParts:
|
|
headParts = self.toon.headParts
|
|
for hi in xrange(headParts.getNumPaths()):
|
|
head = headParts[hi]
|
|
head.setP(0)
|
|
|
|
def flattenMe(self):
|
|
self.geom[0].setScale(3, 3, 0.1)
|
|
|
|
def unFlattenMe(self):
|
|
self.geom[0].setScale(2)
|
|
|
|
def startSkid(self):
|
|
if self.skidding == False:
|
|
self.skidding = True
|
|
self.skidLoopAsphaltSfx.play()
|
|
|
|
def stopSkid(self):
|
|
if self.skidding == True:
|
|
self.skidding = False
|
|
self.skidLoopAsphaltSfx.stop()
|
|
self.skidLoopGrassSfx.stop()
|
|
|
|
def updateSkid(self):
|
|
if self.skidding:
|
|
if self.groundType == 'grass':
|
|
self.skidLoopGrassSfx.setVolume(1)
|
|
self.skidLoopAsphaltSfx.setVolume(0)
|
|
else:
|
|
self.skidLoopGrassSfx.setVolume(0)
|
|
self.skidLoopAsphaltSfx.setVolume(1)
|
|
|
|
def dropOnHim(self, timestamp):
|
|
self.anvil.setScale(10, 13, 10)
|
|
self.anvil.setPos(0, 0, 75)
|
|
self.anvil.reparentTo(self)
|
|
anvilDrop = ProjectileInterval(self.anvil, startPos=Point3(0, 0, 100), endPos=Point3(0, 0, 0), duration=1)
|
|
shadowScale = self.dropShadow.scaleInterval(1, self.ShadowScale * 4)
|
|
fadeOut = LerpFunc(self.anvil.setAlphaScale, fromData=1, toData=0, duration=0.5)
|
|
flattenMe = self.geom[0].scaleInterval(0.08, Vec3(1, 1, 0.1))
|
|
unFlatten = Sequence(self.geom[0].scaleInterval(0.2, Vec3(1, 1, 2)), self.geom[0].scaleInterval(0.1, 1))
|
|
anvilSquish = Parallel(Parallel(anvilDrop, shadowScale), Sequence(Wait(0.92), flattenMe))
|
|
anvilStretchFade = Sequence(Parallel(self.anvil.scaleInterval(0.2, Vec3(10, 13, 4)), Func(self.lookUp)), fadeOut)
|
|
self.gagMovie = Sequence(anvilSquish, anvilStretchFade, Wait(0.5), Parallel(unFlatten, Func(self.lookNormal)), Func(self.hideAnvil))
|
|
self.gagMovie.start()
|
|
|
|
def hitBanana(self):
|
|
if self.wipeOut:
|
|
self.wipeOut.pause()
|
|
spinAnim = LerpFunc(self.spinCar, fromData=self.geom[0].getH(), toData=360, duration=1)
|
|
else:
|
|
spinAnim = LerpFunc(self.spinCar, fromData=0, toData=360, duration=1)
|
|
self.wipeOut = Sequence(Func(self.stopCar, 0.99), spinAnim, Func(self.startCar))
|
|
self.wipeOut.start()
|
|
|
|
def hitPie(self):
|
|
print 'yar, got Me with pi!'
|
|
self.splatPie()
|
|
if self.wipeOut:
|
|
self.wipeOut.pause()
|
|
spinAnim = LerpFunc(self.spinCar, fromData=self.geom[0].getH(), toData=1080, duration=0.5)
|
|
else:
|
|
spinAnim = LerpFunc(self.spinCar, fromData=0, toData=1080, duration=0.5)
|
|
self.wipeOut = Sequence(Func(self.stopCar, 0.99), spinAnim, Func(self.startCar))
|
|
self.wipeOut.start()
|
|
|
|
def finishMovies(self):
|
|
if self.gagMovie:
|
|
self.gagMovie.finish()
|
|
self.gagMovie = None
|
|
if self.wipeOut:
|
|
self.wipeOut.finish()
|
|
self.wipeOut = None
|
|
if self.spinAnim:
|
|
self.spinAnim.finish()
|
|
self.spinAnim = None
|
|
return
|