"""ProjectileInterval module: contains the ProjectileInterval class"""
__all__ = ['ProjectileInterval']
from panda3d.core import *
from panda3d.direct import *
from direct.directnotify.DirectNotifyGlobal import *
from .Interval import Interval
from direct.showbase import PythonUtil
[docs]class ProjectileInterval(Interval):
"""ProjectileInterval class: moves a nodepath through the trajectory
of a projectile under the influence of gravity"""
# create ProjectileInterval DirectNotify category
notify = directNotify.newCategory('ProjectileInterval')
# serial num for unnamed intervals
projectileIntervalNum = 1
# g ~ 9.8 m/s^2 ~ 32 ft/s^2
gravity = 32.
# the projectile's velocity is constant in the X and Y directions.
# the projectile's motion in the Z (up) direction is parabolic
# due to the constant force of gravity, which acts in the -Z direction
[docs] def __init__(self, node, startPos = None,
endPos = None, duration = None,
startVel = None, endZ = None,
wayPoint = None, timeToWayPoint = None,
gravityMult = None, name = None,
collNode = None):
"""
You may specify several different sets of input parameters.
(If startPos is not provided, it will be obtained from the node's
position at the time that the interval is first started. Note that
in this case you must provide a duration of some kind.)
# go from startPos to endPos in duration seconds
startPos, endPos, duration
# given a starting velocity, go for a specific time period
startPos, startVel, duration
# given a starting velocity, go until you hit a given Z plane
startPos, startVel, endZ
# pass through wayPoint at time 'timeToWayPoint'. Go until
# you hit a given Z plane
startPos, wayPoint, timeToWayPoint, endZ
You may alter gravity by providing a multiplier in 'gravityMult'.
'2.' will make gravity twice as strong, '.5' half as strong.
'-1.' will reverse gravity
If collNode is not None, it should be an empty CollisionNode
which will be filled with an appropriate CollisionParabola
when the interval starts. This CollisionParabola will be set
to match the interval's parabola, and its t1, t2 values will
be updated automatically as the interval plays. It will *not*
be automatically removed from the node when the interval
finishes.
"""
self.node = node
self.collNode = collNode
if self.collNode:
if isinstance(self.collNode, NodePath):
self.collNode = self.collNode.node()
assert self.collNode.getNumSolids() == 0
if name is None:
name = '%s-%s' % (self.__class__.__name__,
self.projectileIntervalNum)
ProjectileInterval.projectileIntervalNum += 1
args = (startPos, endPos, duration, startVel, endZ,
wayPoint, timeToWayPoint, gravityMult)
self.implicitStartPos = 0
if startPos is None:
if duration is None:
self.notify.error('must provide either startPos or duration')
self.duration = duration
# we can't calc the trajectory until we know our starting
# position; delay until the interval is actually started
self.trajectoryArgs = args
self.implicitStartPos = 1
else:
self.trajectoryArgs = args
self.__calcTrajectory(*args)
Interval.__init__(self, name, self.duration)
def __calcTrajectory(self, startPos = None,
endPos = None, duration = None,
startVel = None, endZ = None,
wayPoint = None, timeToWayPoint = None,
gravityMult = None):
if startPos is None:
startPos = self.node.getPos()
def doIndirections(*items):
result = []
for item in items:
if callable(item):
item = item()
result.append(item)
return result
startPos, endPos, startVel, endZ, gravityMult, wayPoint, \
timeToWayPoint = \
doIndirections(startPos, endPos, startVel, endZ, gravityMult,
wayPoint, timeToWayPoint)
# we're guaranteed to know the starting position at this point
self.startPos = startPos
# gravity is applied in the -Z direction
self.zAcc = -self.gravity
if gravityMult:
self.zAcc *= gravityMult
def calcStartVel(startPos, endPos, duration, zAccel):
# p(t) = p_0 + t*v_0 + .5*a*t^2
# v_0 = [p(t) - p_0 - .5*a*t^2] / t
if duration == 0:
return Point3(0, 0, 0)
else:
return Point3((endPos[0] - startPos[0]) / duration,
(endPos[1] - startPos[1]) / duration,
(endPos[2] - startPos[2] - (.5*zAccel*duration*duration)) / duration)
def calcTimeOfImpactOnPlane(startHeight, endHeight, startVel, accel):
return PythonUtil.solveQuadratic(accel * .5, startVel,
startHeight-endHeight)
def calcTimeOfLastImpactOnPlane(startHeight, endHeight,
startVel, accel):
time = calcTimeOfImpactOnPlane(startHeight, endHeight,
startVel, accel)
if not time:
return None
if isinstance(time, list):
# projectile hits plane once going up, once going down
# assume they want the one on the way down
assert self.notify.debug('projectile hits plane twice at times: %s' %
time)
time = max(*time)
else:
assert self.notify.debug('projectile hits plane once at time: %s' %
time)
return time
# now all we need is startVel, duration, and endPos.
# which set of input parameters do we have?
if None not in (endPos, duration):
assert not startVel
assert not endZ
assert not wayPoint
assert not timeToWayPoint
self.duration = duration
self.endPos = endPos
self.startVel = calcStartVel(self.startPos, self.endPos,
self.duration, self.zAcc)
elif None not in (startVel, duration):
assert not endPos
assert not endZ
assert not wayPoint
assert not timeToWayPoint
self.duration = duration
self.startVel = startVel
self.endPos = None
elif None not in (startVel, endZ):
assert not endPos
assert not duration
assert not wayPoint
assert not timeToWayPoint
self.startVel = startVel
time = calcTimeOfLastImpactOnPlane(self.startPos[2], endZ,
self.startVel[2], self.zAcc)
if time is None:
self.notify.error(
'projectile never reaches plane Z=%s' % endZ)
self.duration = time
self.endPos = None
elif None not in (wayPoint, timeToWayPoint, endZ):
assert not endPos
assert not duration
assert not startVel
# we pass through wayPoint at time 'timeToWayPoint', and we
# stop when we reach endZ
self.startVel = calcStartVel(self.startPos, wayPoint,
timeToWayPoint, self.zAcc)
time = calcTimeOfLastImpactOnPlane(
self.startPos[2], endZ, self.startVel[2], self.zAcc)
if time is None:
self.notify.error(
'projectile never reaches plane Z=%s' % endZ)
self.duration = time
self.endPos = None
else:
self.notify.error('invalid set of inputs to ProjectileInterval')
self.parabola = LParabola(VBase3(0, 0, 0.5 * self.zAcc),
self.startVel,
self.startPos)
if not self.endPos:
self.endPos = self.__calcPos(self.duration)
# these are the parameters that we need to know:
assert self.notify.debug('startPos: %s' % repr(self.startPos))
assert self.notify.debug('endPos: %s' % repr(self.endPos))
assert self.notify.debug('duration: %s' % self.duration)
assert self.notify.debug('startVel: %s' % repr(self.startVel))
assert self.notify.debug('z-accel: %s' % self.zAcc)
def __initialize(self):
if self.implicitStartPos:
self.__calcTrajectory(*self.trajectoryArgs)
[docs] def testTrajectory(self):
try:
self.__calcTrajectory(*self.trajectoryArgs)
except Exception:
assert self.notify.error('invalid projectile parameters')
return False
return True
[docs] def privInitialize(self, t):
self.__initialize()
if self.collNode:
self.collNode.clearSolids()
csolid = CollisionParabola(self.parabola, 0, 0)
self.collNode.addSolid(csolid)
Interval.privInitialize(self, t)
[docs] def privInstant(self):
self.__initialize()
Interval.privInstant(self)
if self.collNode:
self.collNode.clearSolids()
csolid = CollisionParabola(self.parabola, 0, self.duration)
self.collNode.addSolid(csolid)
def __calcPos(self, t):
return self.parabola.calcPoint(t)
[docs] def privStep(self, t):
self.node.setFluidPos(self.__calcPos(t))
Interval.privStep(self, t)
if self.collNode and self.collNode.getNumSolids() > 0:
csolid = self.collNode.modifySolid(0)
csolid.setT1(csolid.getT2())
csolid.setT2(t)
