from pandac.PandaModules import * from direct.distributed.ClockDelta import * from direct.interval.IntervalGlobal import * from direct.gui.DirectGui import * from pandac.PandaModules 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 toontown.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): 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.setForceOnscreenChat(True) 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.setForceOnscreenChat(False) base.camLens.setMinFov(ToontownGlobals.DefaultCameraFov/(4./3.)) return 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 = ToontownGlobals.DefaultCameraFov/(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