def getPhysBody(self):
from panda3d.bullet import BulletRigidBodyNode, BulletBoxShape
from panda3d.core import TransformState
bnode = BulletRigidBodyNode('entity-phys')
bnode.setMass(self.mass)
bnode.setCcdMotionThreshold(1e-7)
bnode.setCcdSweptSphereRadius(0.5)
if self.solidType == self.SOLID_MESH:
convexHull = PhysicsUtils.makeBulletConvexHullFromCollisionSolids(
self.model.find("**/+CollisionNode").node())
bnode.addShape(convexHull)
elif self.solidType == self.SOLID_BBOX:
mins = Point3()
maxs = Point3()
self.calcTightBounds(mins, maxs)
extents = PhysicsUtils.extentsFromMinMax(mins, maxs)
tsCenter = TransformState.makePos(
PhysicsUtils.centerFromMinMax(mins, maxs))
shape = BulletBoxShape(extents)
bnode.addShape(shape, tsCenter)
return bnode
def announceGenerate(self):
DistributedEntity.announceGenerate(self)
self.addSound("press", "sound/buttons/blip1.wav")
self.addSound("denied", "sound/buttons/button2.wav")
self.addSound("access", "sound/buttons/button3.wav")
PhysicsUtils.makeBulletCollFromPandaColl(self.getModelNP())
for np in self.getModelNP().findAllMatches("**/trigger_*"):
btn = KeypadButton(self, np)
self.buttons.append(btn)
self.setEffect(LightingOriginEffect.make((0, 0.1, 0)))
def addAvatar(self, avatar, zoneId=None):
if zoneId is None:
if hasattr(avatar, 'getZoneId'):
zoneId = avatar.getZoneId()
else:
zoneId = avatar.zoneId
if not zoneId in self.avatars:
self.avatars[zoneId] = []
self.avatars[zoneId].append(avatar)
self.numAvatars += 1
if zoneId in self.battleZones:
print "Adding avatar to battle zone at {0}".format(zoneId)
avatar.battleZone = self.battleZones[zoneId]
avatar.addToPhysicsWorld(avatar.battleZone.physicsWorld)
if DO_SIMULATION:
# Setup simulation physics environment for each
# zone, we will pretend they are battle zones
if zoneId not in self.zonePhysics:
print "Making phys world in zone {0}".format(zoneId)
physicsWorld = BulletWorld()
# Panda units are in feet, so the gravity is 32 feet per second,
# not 9.8 meters per second.
physicsWorld.setGravity(Vec3(0, 0, -32.1740))
# Add the static collision world (worldspawn faces)
PhysicsUtils.attachBulletNodes(self.bspLoader.getResult(),
physicsWorld)
# Add objects that would be dynamic
# (Avatar capsules, weapon collisions, door collisions, etc)
dynObjects = 50 #random.randint(15, 50)
for i in xrange(dynObjects):
box = BulletCapsuleShape(0.5, 1.0, ZUp)
rbnode = BulletRigidBodyNode("testrb")
rbnode.setKinematic(True)
rbnode.setDeactivationEnabled(True)
rbnode.setDeactivationTime(5.0)
rbnode.addShape(box, TransformState.makePos((0, 0, 0)))
NodePath(rbnode).setPos(random.uniform(-100, 100),
random.uniform(-100, 100),
random.uniform(-50, 50))
physicsWorld.attach(rbnode)
self.zonePhysics[zoneId] = physicsWorld
def setAction(self, action):
BaseGagAI.setAction(self, action)
if action == self.StateThrow:
if not isinstance(self.avatar, BaseNPCAI):
self.takeAmmo(-1)
throwVector = PhysicsUtils.getThrowVector(
self.avatar.getViewOrigin(), self.traceVector,
self.avatar.getViewOrigin(), self.avatar,
self.avatar.getBattleZone().getPhysicsWorld())
endPos = CIGlobals.extrude(self.avatar.getViewOrigin(),
self.ThrowPower,
throwVector) - (0, 0, 90)
proj = WholeCreamPieProjectileAI(base.air)
proj.setProjectile(2.5, self.avatar.getViewOrigin(), endPos, 1.07,
globalClockDelta.getFrameNetworkTime())
proj.generateWithRequired(self.avatar.getBattleZone().zoneId)
proj.addHitCallback(self.onProjectileHit)
proj.addExclusion(self.avatar)
self.avatar.emitSound(SOUND_COMBAT,
self.avatar.getViewOrigin(),
duration=0.5)
self.throwTime = globalClock.getFrameTime()
def doJump(self):
self.emitSound(SOUND_COMBAT, self.getViewOrigin(), volume=3.0)
for av in self.air.avatars[self.getBattleZone().zoneId]:
if self.battleZone.getGameRules().canDamage(self, av, None):
result = False
if av.doId == ModGlobals.LocalAvatarID:
# Check if on ground
result = PhysicsUtils.rayTestClosestNotMe(
av,
av.getPos() + (0, 0, 0.1),
av.getPos() - (0, 0, 0.3), CIGlobals.FloorGroup,
self.battleZone.physicsWorld)
else:
if av.getActivity()[0] != ACT_JUMP:
result = True
av.onHitByVPJump()
if result:
# On ground, damage
dmgInfo = TakeDamageInfo(self, -1, 10, av.getPos(),
self.getPos())
av.takeDamage(dmgInfo)
if av.doId == ModGlobals.LocalAvatarID:
av.sendUpdateToAvatarId(av.doId, 'doVPJumpCameraShake',
[])
def announceGenerate(self):
DistributedTNT.announceGenerate(self)
self.stopSmooth()
self.startPosHprBroadcast()
pos = base.localAvatar.getPos(render)
# Make sure to start the TNT out in front of our capsule to prevent weird physics
extrude = base.localAvatar.getQuat(render).xform(
Vec3(0, 1.0 + 0.3925,
base.localAvatar.getHeight() / 2.0))
self.setPos(pos + extrude)
push = ((pos + (0, 0, base.localAvatar.getHeight() / 2.0)) -
camera.getPos(render)).length()
self.lookAt(render, PhysicsUtils.getHitPosFromCamera(push=push))
self.d_clearSmoothing()
self.d_broadcastPosHpr()
power = 50.0
bp = base.localAvatar.backpack
if bp:
gag = bp.getGagByID(GagGlobals.gagIdByName[GagGlobals.TNT])
if gag and gag.powerBar:
power = gag.powerBar.getPower()
self.toss(power)
def handleCameraFloorInteraction(self):
if self.__onLevelGround or not base.localAvatarReachable() or (
base.localAvatarReachable()
and base.localAvatar.battleControls):
return
self.putCameraFloorRayOnCamera()
pointA = render.getRelativePoint(camera.getParent(),
self.floorLineStart)
pointB = pointA + (Vec3.down() * 1000)
result = PhysicsUtils.rayTestClosestNotMe(base.localAvatar, pointA,
pointB, CIGlobals.FloorGroup)
if not result:
return
camObstrCollisionEntry = result
camHeightFromFloor = (camera.getRelativePoint(
render, camObstrCollisionEntry.getHitPos())).getZ()
heightOfFloorUnderCamera = (camera.getPos()[2] -
CIGlobals.FloorOffset) + camHeightFromFloor
self.cameraZOffset = camera.getPos()[2] + camHeightFromFloor
if self.cameraZOffset < 0:
self.cameraZOffset = self.cameraZOffset * 0.33333333329999998
camHeight = max(base.localAvatar.getHeight(), 3.0)
if self.cameraZOffset < -(camHeight * 0.5):
if self.cameraZOffset < -camHeight:
self.cameraZOffset = 0.0
else:
self.cameraZOffset = -(camHeight * 0.5)
if self.__floorDetected == 0:
self.__floorDetected = 1
self.popCameraToDest()
def load(self):
DistributedEntity.load(self)
self.powerUpSound = base.loadSfxOnNode("phase_14/audio/sfx/sewer_generator_windup.ogg", self.cEntity.getModelNp())
self.powerDownSound = base.loadSfxOnNode("phase_14/audio/sfx/sewer_generator_winddown.ogg", self.cEntity.getModelNp())
self.runSound = base.loadSfxOnNode("phase_14/audio/sfx/sewer_generator_hum.ogg", self.cEntity.getModelNp())
self.runSound.setLoop(True)
base.materialData.update(PhysicsUtils.makeBulletCollFromGeoms(self.cEntity.getModelNp()))
def fireLaser(self):
result = PhysicsUtils.rayTestClosestNotMe(
self, self.laserVec[0], self.laserVec[1],
CIGlobals.WorldGroup | CIGlobals.CharacterGroup,
self.getBattleZone().getPhysicsWorld())
traceEnd = self.laserVec[1]
if result:
traceEnd = result.getHitPos()
hitNode = NodePath(result.getNode())
avNP = hitNode.getParent()
for obj in base.air.avatars[self.getBattleZone().zoneId]:
if (CIGlobals.isAvatar(obj) and obj.getKey() == avNP.getKey()
and self.getBattleZone().getGameRules().canDamage(
self, obj, None)):
dmgInfo = TakeDamageInfo(self, -1, 10, traceEnd,
self.laserVec[0])
obj.takeDamage(dmgInfo)
break
self.getBattleZone().getTempEnts().makeLaser(self.laserVec[0],
traceEnd,
Vec4(1, 0, 0, 1), 1.0)
def __init__(self, baseChannel, stateServerChannel):
CogInvasionInternalRepository.__init__(
self,
baseChannel,
stateServerChannel, [
'resources/phase_3/etc/direct.dc',
'resources/phase_3/etc/toon.dc'
],
dcSuffix='AI')
self.notify.setInfo(True)
self.district = None
self.zoneAllocator = UniqueIdAllocator(ZoneUtil.DynamicZonesBegin,
ZoneUtil.DynamicZonesEnd)
self.zoneDataStore = AIZoneDataStore()
self.hoods = {}
self.dnaStoreMap = {}
self.dnaDataMap = {}
self.districtNameMgr = self.generateGlobalObject(
DO_ID_DISTRICT_NAME_MANAGER, 'DistrictNameManager')
self.holidayMgr = self.generateGlobalObject(DO_ID_HOLIDAY_MANAGER,
'HolidayManager')
self.uin = self.generateGlobalObject(DO_ID_UNIQUE_INTEREST_NOTIFIER,
'UniqueInterestNotifier')
self.csm = self.generateGlobalObject(DO_ID_CLIENT_SERVICES_MANAGER,
'ClientServicesManager')
self.statsMgr = self.generateGlobalObject(DO_ID_STATS_MANAGER,
'StatsManager')
# Anything that is a DistributedAvatarAI (Toons, Suits, etc).
# This is a per-zone list of avatars.
self.avatars = {}
self.numAvatars = 0
self.battleZones = {}
if DO_SIMULATION:
self.zonePhysics = {}
self.bspLoader = BSPLoader()
self.bspLoader.setAi(True)
self.bspLoader.setMaterialsFile("phase_14/etc/materials.txt")
#self.bspLoader.setTextureContentsFile("phase_14/etc/texturecontents.txt")
#self.bspLoader.setServerEntityDispatcher(self)
self.bspLoader.read(
"phase_14/etc/sewer_entrance_room_indoors/sewer_entrance_room_indoors.bsp"
)
PhysicsUtils.makeBulletCollFromGeoms(self.bspLoader.getResult(),
enableNow=False)
def __updateParticleParent(self):
if not CIGlobals.isNodePathOk(self.waterStreamParent):
return
time = globalClock.getFrameTime()
streamPos = self.waterStreamParent.getPos(render)
distance = self.sprayParticleDist
if self.isLocal():
camQuat = camera.getQuat(render)
pFrom = camera.getPos(render)
push = (streamPos - pFrom).length()
pFrom += camQuat.xform(Vec3.forward()) * push
pTo = pFrom + camQuat.xform(
Vec3.forward()) * (self.sprayParticleDist +
(pFrom - streamPos).length())
hitPos = Point3(pTo)
result = base.physicsWorld.rayTestClosest(pFrom, pTo,
CIGlobals.WorldGroup)
if result.hasHit():
node = result.getNode()
hitPos = result.getHitPos()
distance = (hitPos - streamPos).length()
if time - self.lastSprayTime >= self.SprayTraceIval and not self.released:
if result.hasHit():
self.__doSplat(distance, hitPos)
self.getFPSCam().addViewPunch(
Vec3(random.uniform(-0.6, 0.6), random.uniform(0.25, 1.0),
0.0))
self.primaryFirePress(True)
self.lastSprayTime = time
else:
pFrom = self.avatar.getPos(render) + self.avatar.getEyePoint() + (
1, 0, 0)
quat = Quat()
quat.setHpr(
self.avatar.getHpr(render) + (0, self.avatar.lookPitch, 0))
pTo = pFrom + quat.xform(
Vec3.forward()) * (self.sprayParticleDist +
(pFrom - streamPos).length())
hitPos = Point3(pTo)
hit = PhysicsUtils.rayTestClosestNotMe(
self.avatar, pFrom, pTo,
CIGlobals.WorldGroup | CIGlobals.LocalAvGroup)
if hit is not None:
hitPos = hit.getHitPos()
distance = (hitPos - streamPos).length()
self.waterStreamParent.lookAt(render, hitPos)
if self.sprayParticle:
system = self.sprayParticle.getParticlesNamed('particles-1')
# Make the particles die off at the hit point.
lifespan = min(
1, distance / self.sprayParticleDist) * self.sprayParticleLife
system.factory.setLifespanBase(lifespan)
def load(self):
DistributedEntity.load(self)
self.axis = base.bspLoader.getEntityValueVector(self.entnum, "axis")
self.speed = base.bspLoader.getEntityValueFloat(self.entnum, "speed")
self.timeToFull = base.bspLoader.getEntityValueFloat(self.entnum, "timeToFull")
base.materialData.update(PhysicsUtils.makeBulletCollFromGeoms(self.cEntity.getModelNp()))
def start(self):
Gag.start(self)
self.hitSfx.play()
gag = self.gag
if self.isLocal():
vm = self.getViewModel()
fpsCam = self.getFPSCam()
fpsCam.setVMAnimTrack(
Sequence(ActorInterval(vm, "sg_shoot_begin"),
ActorInterval(vm, "sg_shoot_end"),
Func(vm.loop, "sg_idle")))
gag = self.getVMGag()
nozzle = gag.find("**/joint_nozzle")
if self.isLocal() and base.localAvatar.battleControls:
if base.localAvatar.isFirstPerson():
self.getFPSCam().resetViewPunch()
self.getFPSCam().addViewPunch(
Vec3(random.uniform(-0.6, 0.6),
random.uniform(-0.25, -0.5), 0.0))
startPos = camera.getPos(render)
else:
startPos = nozzle.getPos(render)
hitPos = PhysicsUtils.getHitPosFromCamera()
else:
startPos = nozzle.getPos(render)
quat = Quat()
quat.setHpr(
self.avatar.getHpr(render) + (0, self.avatar.lookPitch, 0))
hitPos = quat.xform(Vec3.forward() * 10000)
hit = PhysicsUtils.rayTestClosestNotMe(
self.avatar, startPos, hitPos,
CIGlobals.WorldGroup | CIGlobals.LocalAvGroup)
if hit is not None:
hitPos = hit.getHitPos()
pellet = WaterPellet(self.isLocal())
pellet.addToWorld(nozzle.getPos(render),
lookAt=hitPos,
velo=Vec3.forward() * self.pelletSpeed)
if self.isLocal():
base.localAvatar.sendUpdate('usedGag', [self.id])
def load(self):
Entity.load(self)
loader = self.cEntity.getLoader()
entnum = self.cEntity.getEntnum()
rbnode = BulletRigidBodyNode('func_physics')
mass = loader.getEntityValueFloat(entnum, "mass")
rbnode.setMass(100)
min = Point3(0)
max = Point3(0)
self.cEntity.getModelBounds(min, max)
center = PhysicsUtils.centerFromMinMax(min, max)
extents = PhysicsUtils.extentsFromMinMax(min, max)
shape = BulletBoxShape(extents)
rbnode.addShape(shape)
self.assign(base.bspLoader.getResult().find(
"**/brushroot").attachNewNode(rbnode))
self.setPos(center)
self.cEntity.getModelNp().wrtReparentTo(self)
base.physicsWorld.attachRigidBody(rbnode)
def __handleUse(self, task):
#if self.mode == LocalControls.MThirdPerson:
# return task.cont
time = globalClock.getFrameTime()
use = inputState.isSet('use')
if use:
# see if there is anything for us to use.
distance = 7.5
camQuat = base.camera.getQuat(render)
camFwd = camQuat.xform(Vec3.forward())
camPos = base.camera.getPos(render)
if self.mode == self.MFirstPerson:
start = camPos
else:
# Move the line out to their character.
# This prevents the player from using things that
# are behind their character, but in front of
# the camera.
laPos = base.localAvatar.getPos(render)
camToPlyr = (camPos.getXy() - laPos.getXy()).length()
start = camPos + (camFwd * camToPlyr)
stop = start + (camFwd * distance)
hit = PhysicsUtils.rayTestClosestNotMe(base.localAvatar, start,
stop,
CIGlobals.UseableGroup)
somethingToUse = False
if hit is not None:
node = hit.getNode()
if node.hasPythonTag("useableObject"):
somethingToUse = True
obj = node.getPythonTag("useableObject")
if obj.canUse():
if self.currentObjectUsing != obj:
if self.currentObjectUsing is not None:
self.currentObjectUsing.stopUse()
obj.startUse()
self.lastUseObjectTime = time
elif time - self.lastUseObjectTime >= obj.useIval:
obj.use()
self.lastUseObjectTime = time
self.currentObjectUsing = obj
if not somethingToUse and not self.lastUse:
self.useInvalidSound.play()
else:
if self.currentObjectUsing is not None:
self.currentObjectUsing.stopUse()
self.currentObjectUsing = None
self.lastUse = use
return task.cont
def consider(self, node, pos, eyeHeight):
self.reparentTo(node)
self.setPos(pos)
result = None
floorLineStart = self.getPos(render) + (0, 0, 0.1)
floorLineEnd = floorLineStart - (0, 0, 10000)
floorResult = base.physicsWorld.rayTestClosest(floorLineStart, floorLineEnd, CIGlobals.FloorMask)
if floorResult.hasHit():
floorPoint = self.getRelativePoint(render, floorResult.getHitPos())
if abs(floorPoint[2]) <= 4.0:
pos += floorPoint
self.setPos(pos)
base.physicsWorld.attach(self.cSphereNodePath.node())
self.cSphereNodePath.node().setTransformDirty()
sphereContactResult = base.physicsWorld.contactTest(self.cSphereNodePath.node())
base.physicsWorld.remove(self.cSphereNodePath.node())
wallEntry = False
for iContact in range(sphereContactResult.getNumContacts()):
contact = sphereContactResult.getContact(iContact)
node0 = NodePath(contact.getNode0())
node1 = NodePath(contact.getNode1())
if (node0 == self.cSphereNodePath and
not base.localAvatar.isAncestorOf(node1) and
not node.isAncestorOf(node1)):
if not (node1.getCollideMask() & CIGlobals.WallGroup).isZero():
wallEntry = True
break
elif (node1 == self.cSphereNodePath and
not base.localAvatar.isAncestorOf(node0) and
not node.isAncestorOf(node0)):
if not (node0.getCollideMask() & CIGlobals.WallGroup).isZero():
wallEntry = True
break
if not wallEntry:
lineStart = render.getRelativePoint(self, (0, 0, eyeHeight))
lineEnd = render.getRelativePoint(self, (-pos[0], -pos[1], eyeHeight))
lineResult = PhysicsUtils.rayTestClosestNotMe(node, lineStart, lineEnd, CIGlobals.WallGroup)
if not lineResult:
result = pos
self.reparentTo(hidden)
return result
def doesLineTraceToPlayer(self, plyr):
# Do we have a clear LOS to the player?
world = self.battleZone.physicsWorld
result = PhysicsUtils.rayTestClosestNotMe(self,
self.getPos(render) + self.getEyePosition(), plyr.getPos(render) + plyr.getEyePosition(),
CIGlobals.WorldGroup | CIGlobals.CharacterGroup, world)
# Assume clear LOS if ray hit nothing
if not result:
return True
# Also clear LOS if ray hits the player
np = NodePath(result.getNode()).getParent()
return np.getKey() == plyr.getKey()
def load(self):
if self.autoPhysBox:
min = Point3(0)
max = Point3(0)
self.getUseableBounds(min, max)
min -= Point3(0.1, 0.1, 0.1)
max += Point3(0.1, 0.1, 0.1)
center = PhysicsUtils.centerFromMinMax(min, max)
extents = PhysicsUtils.extentsFromMinMax(min, max)
shape = BulletBoxShape(extents)
# Use the box as a trigger and collision geometry.
if self.hasPhysGeom:
bodyNode = BulletGhostNode('useableObject')
else:
bodyNode = BulletRigidBodyNode('useableObject')
bodyNode.setKinematic(True)
bodyNode.addShape(shape, TransformState.makePos(center))
self.setupPhysics(bodyNode)
if self.bodyNP:
self.bodyNP.setPythonTag('useableObject', self)
def load(self, physName='useableObject'):
if self.autoPhysBox:
min = Point3(0)
max = Point3(0)
self.getUseableBounds(min, max)
min -= Point3(0.1, 0.1, 0.1)
max += Point3(0.1, 0.1, 0.1)
extents = PhysicsUtils.extentsFromMinMax(min, max)
shape = BulletBoxShape(extents)
# Use the box as a trigger and collision geometry.
if self.hasPhysGeom:
bodyNode = BulletGhostNode(physName)
else:
bodyNode = BulletRigidBodyNode(physName)
bodyNode.setKinematic(True)
if not self.underneathSelf:
center = PhysicsUtils.centerFromMinMax(min, max)
bodyNode.addShape(shape, TransformState.makePos(center))
else:
bodyNode.addShape(shape)
self.setupPhysics(bodyNode)
else:
for np in self.findAllMatches("**/+BulletRigidBodyNode"):
if (np.getCollideMask() & CIGlobals.WallGroup) != 0:
np.setCollideMask(np.getCollideMask()
| CIGlobals.UseableGroup)
self.bodyNP = np
self.bodyNode = np.node()
if self.bodyNP:
self.bodyNP.setPythonTag('useableObject', self)
def doTraceAndDamage(self, origin, dir, dist, traces=1, impact=True):
# Trace a line from the trace origin outward along the trace direction
# to find out what we hit, and adjust the direction of the hitscan
traceEnd = origin + (dir * dist)
hit = PhysicsUtils.rayTestClosestNotMe(
self.avatar, origin, traceEnd, self.TraceMask,
self.avatar.getBattleZone().getPhysicsWorld())
if hit is not None:
node = hit.getNode()
hitPos = hit.getHitPos()
distance = (hitPos - origin).length()
self.__handleHitSomething_trace(NodePath(node), hitPos, distance,
origin, traces, impact)
return node
return None
def __updateEyeRay(self):
fromOrigin = camera.getPos(render)
toOrigin = fromOrigin + (camera.getQuat(render).getForward() * 100)
result = PhysicsUtils.rayTestClosestNotMe(self.movementParent, fromOrigin, toOrigin)
if self.__eyeRayNode and ((not result) or (result.getNode() != self.__eyeRayNode)):
node = self.__eyeRayNode
messenger.send('rayexit' + node.getName(), [NodePath(node)])
self.__eyeRayNode = None
if result:
if (self.__eyeRayNode != result.getNode()):
node = result.getNode()
messenger.send('rayenter' + node.getName(), [NodePath(node)])
self.__eyeRayNode = node
else:
self.__eyeRayNode = None
def onSetAction(self, action):
if action == self.StateThrow:
self.takeAmmo(-1)
av = self.getAvatar()
throwVector = PhysicsUtils.getThrowVector(
self.traceOrigin, self.traceVector, self.throwOrigin, av,
av.getBattleZone().getPhysicsWorld()) + (0, 0, 0.1)
proj = TNTProjectileAI(base.air, self.avatar, self)
proj.generateWithRequired(self.avatar.getBattleZone().zoneId)
proj.setPos(self.throwOrigin)
proj.lookAt(throwVector)
proj.node().setLinearVelocity(throwVector * self.ThrowPower)
proj.d_clearSmoothing()
proj.d_broadcastPosHpr()
def addExitWaypoint(self):
vpos = self.getPos()
quat = self.getQuat()
if self.rearOrFront == 0:
endPos = vpos + quat.xform((0, 11, 0))
else:
endPos = vpos + quat.xform((0, -11, 0))
# Snap to floor
result = PhysicsUtils.rayTestClosestNotMe(
self, endPos + (0, 0, 0.5), endPos - (0, 0, 20),
CIGlobals.WorldGroup,
self.getBattleZone().getPhysicsWorld())
if result:
endPos = result.getHitPos()
self.motor.setWaypoints([endPos])
self.motor.setFwdSpeed(5.0)
def think(self):
BaseAttackAI.think(self)
time = self.ThrowAfterTime
if not time:
try:
time = self.__calculateThrowAfterTime()
except:
pass
if self.action == self.StateThrow:
if not CIGlobals.isNodePathOk(self.target):
return
# Lock onto the target
self.avatar.headsUp(self.target)
if self.getActionTime() >= time and not self.didThrow:
self.calibrate(self.target)
# Trace a line from the trace origin outward along the trace direction
# to find out what we hit, and adjust the direction of the projectile launch
traceEnd = self.traceOrigin + (self.traceVector * 10000)
hit = PhysicsUtils.rayTestClosestNotMe(
self.avatar, self.traceOrigin, traceEnd,
CIGlobals.WorldGroup | CIGlobals.CharacterGroup,
self.avatar.getBattleZone().getPhysicsWorld())
if hit is not None:
hitPos = hit.getHitPos()
else:
hitPos = traceEnd
vecThrow = (hitPos - self.throwOrigin).normalized()
endPos = self.throwOrigin + (vecThrow * self.ThrowPower)
proj = GenericThrowableLinearProjectileAI(base.air)
proj.setData(self.ID)
proj.setLinear(1.5, self.throwOrigin, endPos,
globalClockDelta.getFrameNetworkTime())
proj.generateWithRequired(self.avatar.getBattleZone().zoneId)
proj.addHitCallback(self.onProjectileHit)
proj.addExclusion(self.avatar)
self.didThrow = True
def updateSmartCamera(self, task):
if base.localAvatarReachable(
) and base.localAvatar.battleControls and base.localAvatar.isFirstPerson(
):
return Task.cont
if not self.__camCollCanMove and not self.__cameraHasBeenMoved:
if self.__lastPosWrtRender == camera.getPos(render):
if self.__lastHprWrtRender == camera.getHpr(render):
return Task.cont
self.__cameraHasBeenMoved = 0
self.__lastPosWrtRender = camera.getPos(render)
self.__lastHprWrtRender = camera.getHpr(render)
self.__idealCameraObstructed = 0
self.updateSmartCameraCollisionLineSegment()
if not self.__disableSmartCam:
pointA = render.getRelativePoint(camera.getParent(), self.pointA)
pointB = render.getRelativePoint(camera.getParent(), self.pointB)
mask = CIGlobals.WallGroup | CIGlobals.CameraGroup
if base.localAvatarReachable():
if base.localAvatar.battleControls:
mask |= (CIGlobals.FloorGroup | CIGlobals.StreetVisGroup)
result = PhysicsUtils.rayTestClosestNotMe(
base.localAvatar, pointA, pointB, mask)
if result:
self.handleCameraObstruction(result)
if not self.__onLevelGround:
self.handleCameraFloorInteraction()
if not self.__idealCameraObstructed:
self.nudgeCamera()
return Task.cont
def think(self):
BaseHitscanAI.think(self)
if self.action == self.StateFire:
if self.isAIUser():
if CIGlobals.isNodePathOk(self.target):
self.avatar.headsUp(self.target)
self.calibrate(self.target)
else:
return
if (self.gumballsToFire > 0
and globalClock.getFrameTime() >= self.nextFireTime):
throwVector = PhysicsUtils.getThrowVector(
self.traceOrigin, self.traceVector, self.fireOrigin,
self.avatar,
self.avatar.getBattleZone().getPhysicsWorld())
endPos = CIGlobals.extrude(self.fireOrigin, self.FirePower,
throwVector) - (0, 0, 90)
if self.isAIUser():
endPos = endPos + Point3(random.uniform(-2.5, 2.5),
random.uniform(-2.5, 2.5),
random.uniform(-2.5, 2.5))
self.takeAmmo(-1)
self.fireProjectile(endPos)
self.gumballsToFire = self.gumballsToFire - 1
if (self.gumballsToFire > 0):
self.nextFireTime = globalClock.getFrameTime(
) + random.uniform(self.MIN_BURST_DELAY,
self.MAX_BURST_DELAY)
def __updateParticleParent(self, task=None):
time = globalClock.getFrameTime()
streamPos = self.waterStreamParent.getPos(render)
distance = self.sprayParticleDist
if self.isLocal():
if base.localAvatar.backpack.getSupply(self.id) <= 0:
base.localAvatar.b_gagThrow(self.id)
return task.done
camQuat = camera.getQuat(render)
pFrom = camera.getPos(render)
push = (streamPos - pFrom).length()
pFrom += camQuat.xform(Vec3.forward()) * push
pTo = pFrom + camQuat.xform(
Vec3.forward()) * (self.sprayParticleDist +
(pFrom - streamPos).length())
hitPos = Point3(pTo)
result = base.physicsWorld.rayTestClosest(pFrom, pTo,
CIGlobals.WorldGroup)
if result.hasHit():
node = result.getNode()
hitPos = result.getHitPos()
distance = (hitPos - streamPos).length()
if time - self.lastDmgTime >= self.dmgIval:
self._handleSprayCollision(NodePath(node), hitPos,
distance)
self.lastDmgTime = time
if time - self.lastSprayTime >= self.dmgIval:
self.getFPSCam().addViewPunch(
Vec3(random.uniform(-0.6, 0.6), random.uniform(0.25, 1.0),
0.0))
base.localAvatar.sendUpdate('usedGag', [self.id])
self.lastSprayTime = time
else:
pFrom = self.avatar.getPos(render) + self.avatar.getEyePoint() + (
1, 0, 0)
quat = Quat()
quat.setHpr(
self.avatar.getHpr(render) + (0, self.avatar.lookPitch, 0))
pTo = pFrom + quat.xform(
Vec3.forward()) * (self.sprayParticleDist +
(pFrom - streamPos).length())
hitPos = Point3(pTo)
hit = PhysicsUtils.rayTestClosestNotMe(
self.avatar, pFrom, pTo,
CIGlobals.WorldGroup | CIGlobals.LocalAvGroup)
if hit is not None:
hitPos = hit.getHitPos()
distance = (hitPos - streamPos).length()
self.waterStreamParent.lookAt(render, hitPos)
if self.sprayParticle:
system = self.sprayParticle.getParticlesNamed('particles-1')
# Make the particles die off at the hit point.
lifespan = min(
1, distance / self.sprayParticleDist) * self.sprayParticleLife
system.factory.setLifespanBase(lifespan)
if task:
return task.cont
def disableAndRemovePhysicsNodes(self, rootNode):
PhysicsUtils.detachAndRemoveBulletNodes(rootNode)
def removePhysicsNodes(self, rootNode):
PhysicsUtils.removeBulletNodes(rootNode)
def createPhysicsNodes(self, rootNode):
PhysicsUtils.makeBulletCollFromPandaColl(rootNode)
