import math import random from direct.showbase.PythonUtil import * from direct.showbase.DirectObject import DirectObject from direct.task import Task from pandac.PandaModules import * from direct.fsm import FSM from direct.distributed import DistributedSmoothNode from otp.avatar import ShadowCaster from otp.otpbase import OTPGlobals from toontown.racing.FlyingGag import FlyingGag from toontown.battle import MovieUtil class Piejectile(DirectObject, FlyingGag): physicsCalculationsPerSecond = 60 maxPhysicsDt = 1.0 physicsDt = 1.0 / float(physicsCalculationsPerSecond) maxPhysicsFrames = maxPhysicsDt * physicsCalculationsPerSecond def __init__(self, sourceId, targetId, type, name): FlyingGag.__init__(self, 'flyingGag', base.race.pie) self.billboard = False self.race = base.race self.scale = 1 self.imHitMult = 1 self.wallCollideTrack = None self.curSpeed = 0 self.acceleration = 0 self.count = 0 self.name = name self.physicsObj = None self.ownerId = sourceId self.targetId = targetId self.ownerAv = None self.ownerKart = None self.hasTarget = 0 self.deleting = 0 self.d2t = 0 self.lastD2t = 0 self.startTime = globalClock.getFrameTime() self.timeRatio = 0 self.maxTime = 8 self.rotH = randFloat(-360, 360) self.rotP = randFloat(-90, 90) self.rotR = randFloat(-90, 90) print 'generating Pie %s' % self.name self.ownerKart = base.cr.doId2do.get(base.race.kartMap.get(sourceId, None), None) if targetId != 0: self.targetKart = base.cr.doId2do.get(base.race.kartMap.get(targetId, None), None) self.hasTarget = 1 if self.ownerId == localAvatar.doId: startPos = self.ownerKart.getPos(render) else: startPos = self.ownerKart.getPos(render) self.setPos(startPos[0], startPos[1], startPos[2]) self.__setupCollisions() self.setupPhysics() self.__enableCollisions() self.forward = NodePath('forward') self.forward.setPos(0, 1, 0) self.splatTaskName = 'splatTask %s' % self.name if self.hasTarget: self.splatTask = taskMgr.doMethodLater(self.maxTime, self.splat, self.splatTaskName) else: self.splatTask = taskMgr.doMethodLater(self.maxTime / 2.5, self.splat, self.splatTaskName) self.reparentTo(render) return def delete(self): print 'removing piejectile' taskMgr.remove(self.taskName) self.__undoCollisions() self.physicsMgr.clearLinearForces() FlyingGag.delete(self) self.deleting = 1 self.ignoreAll() def remove(self): self.delete() def setAvId(self, avId): self.avId = avId def setRace(self, doId): self.race = base.cr.doId2do.get(doId) def setOwnerId(self, ownerId): self.ownerId = ownerId def setType(self, type): self.type = type def setPos(self, x, y, z): DistributedSmoothNode.DistributedSmoothNode.setPos(self, x, y, z) def getVelocity(self): return self.actorNode.getPhysicsObject().getVelocity() def setupPhysics(self): 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, 3) fn.addForce(engine) self.physicsMgr.addLinearForce(engine) self.engine = engine self.physicsMgr.attachPhysicalNode(self.node()) self.physicsObj = self.actorNode.getPhysicsObject() ownerAv = base.cr.doId2do[self.ownerId] ownerVel = self.ownerKart.getVelocity() ownerSpeed = ownerVel.length() rotMat = Mat3.rotateMatNormaxis(self.ownerKart.getH(), Vec3.up()) ownerHeading = rotMat.xform(Vec3.forward()) throwSpeed = 50 throwVel = ownerHeading * throwSpeed throwVelCast = Vec3(throwVel[0], throwVel[1], throwVel[2] + 50) self.actorNode.getPhysicsObject().setVelocity(self.ownerKart.getVelocity() + throwVelCast) lookPoint = render.getRelativePoint(self.ownerKart, Point3(0, 10, 0)) self.lookAt(lookPoint) self.taskName = 'updatePhysics%s' % self.name taskMgr.add(self.__updatePhysics, self.taskName, priority=25) def checkTargetDistance(self): if self.hasTarget: return self.getDistance(self.targetKart) else: return 0 def splatTarget(self): if self.targetId == base.localAvatar.getDoId() and base.race.localKart: base.race.localKart.splatPie() self.race.effectManager.addSplatEffect(spawner=self.targetKart, parent=self.targetKart) taskMgr.remove(self.splatTaskName) self.removeNode() self.remove() def splat(self, optional = None): self.race.effectManager.addSplatEffect(spawner=self) taskMgr.remove(self.splatTaskName) self.removeNode() self.remove() def __updatePhysics(self, task): if self.deleting: return Task.done self.timeRatio = (globalClock.getFrameTime() - self.startTime) / self.maxTime self.windResistance.setCoef(0.2 + 0.8 * self.timeRatio) if base.cr.doId2do.get(self.targetId) == None: self.hasTarget = 0 self.lastD2t = self.d2t self.d2t = self.checkTargetDistance() if self.hasTarget: targetDistance = self.d2t distMax = 100 if self.d2t > distMax: targetDistance = distMax targetVel = self.targetKart.getVelocity() targetPos = self.targetKart.getPos() targetAim = Point3(targetPos[0] + targetVel[0] * (targetDistance / distMax), targetPos[1] + targetVel[1] * (targetDistance / distMax), targetPos[2] + targetVel[2] * (targetDistance / distMax)) self.lookAt(targetPos) if self.d2t < 7 and self.hasTarget: self.splatTarget() return Task.done self.count += 1 dt = globalClock.getDt() physicsFrame = int((globalClock.getFrameTime() - self.physicsEpoch) * self.physicsCalculationsPerSecond) numFrames = min(physicsFrame - self.lastPhysicsFrame, self.maxPhysicsFrames) self.lastPhysicsFrame = physicsFrame if self.hasTarget: targetVel = self.targetKart.getVelocity() targetSpeed = targetVel.length() if self.d2t - 10 * self.physicsDt > self.lastD2t: self.engine.setVector(Vec3(0, 150 + 150 * self.timeRatio + targetSpeed * (1.0 + 1.0 * self.timeRatio) + self.d2t * (1.0 + 1.0 * self.timeRatio), 12)) else: self.engine.setVector(Vec3(0, 10 + 10 * self.timeRatio + targetSpeed * (0.5 + 0.5 * self.timeRatio) + self.d2t * (0.5 + 0.5 * self.timeRatio), 12)) else: self.engine.setVector(Vec3(0, 100, 3)) for i in xrange(int(numFrames)): pitch = self.gagNode.getP() self.gagNode.setP(pitch + self.rotH * self.physicsDt) roll = self.gagNode.getR() self.gagNode.setR(roll + self.rotP * self.physicsDt) heading = self.gagNode.getH() self.gagNode.setH(heading + self.rotR * self.physicsDt) self.physicsMgr.doPhysics(self.physicsDt) if self.count % 60 == 0: pass return Task.cont def __setupCollisions(self): self.cWallTrav = CollisionTraverser('ProjectileWall') self.cWallTrav.setRespectPrevTransform(True) self.collisionNode = CollisionNode(self.name) self.collisionNode.setFromCollideMask(OTPGlobals.WallBitmask) self.collisionNode.setIntoCollideMask(BitMask32.allOff()) cs = CollisionSphere(0, 0, 0, 7) self.collisionNode.addSolid(cs) sC = self.attachNewNode(self.collisionNode) self.collisionNodePath = NodePath(self.collisionNode) self.wallHandler = CollisionHandlerPusher() base.cTrav.addCollider(sC, self.wallHandler) self.wallHandler.addCollider(self.collisionNodePath, self) cRay = CollisionRay(0.0, 0.0, 40000.0, 0.0, 0.0, -1.0) pieFloorRayName = 'pieFloorRay%s' % self.name cRayNode = CollisionNode(pieFloorRayName) 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.setOffset(OTPGlobals.FloorOffset) self.lifter.setReach(40.0) self.lifter.addCollider(self.cRayNodePath, self) base.cTrav.addCollider(self.cRayNodePath, self.lifter) def __undoCollisions(self): base.cTrav.removeCollider(self.cRayNodePath) def __enableCollisions(self): self.cQueue = [] self.cRays = NodePath('stickProjectileToFloor') self.cRays.reparentTo(self.gag) x = self.gag.getX() y = self.gag.getY() rayNode = CollisionNode('floorcast') 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)