152 lines
5.5 KiB
Python
152 lines
5.5 KiB
Python
from toontown.toonbase.ToontownGlobals import *
|
|
from direct.interval.IntervalGlobal import *
|
|
from direct.directnotify import DirectNotifyGlobal
|
|
from toontown.suit import GoonPathData
|
|
from otp.level import PathEntity
|
|
|
|
class PathMasterEntity(PathEntity.PathEntity):
|
|
notify = DirectNotifyGlobal.directNotify.newCategory('PathMasterEntity')
|
|
|
|
def __init__(self, level, entId):
|
|
self.pathScale = 1.0
|
|
PathEntity.PathEntity.__init__(self, level, entId)
|
|
self.setPathIndex(self.pathIndex)
|
|
self.initPath()
|
|
|
|
def initPath(self):
|
|
self.pathTargetList = [None,
|
|
None,
|
|
None,
|
|
None,
|
|
None,
|
|
None,
|
|
None,
|
|
None]
|
|
if not hasattr(self, 'pathTarget0'):
|
|
self.pathTarget0 = None
|
|
else:
|
|
self.pathTargetList[0] = self.pathTarget0
|
|
if not hasattr(self, 'pathTarget1'):
|
|
self.pathTarget1 = None
|
|
else:
|
|
self.pathTargetList[1] = self.pathTarget1
|
|
if not hasattr(self, 'pathTarget2'):
|
|
self.pathTarget2 = None
|
|
else:
|
|
self.pathTargetList[2] = self.pathTarget2
|
|
if not hasattr(self, 'pathTarget3'):
|
|
self.pathTarget3 = None
|
|
else:
|
|
self.pathTargetList[3] = self.pathTarget3
|
|
if not hasattr(self, 'pathTarget4'):
|
|
self.pathTarget4 = None
|
|
else:
|
|
self.pathTargetList[4] = self.pathTarget4
|
|
if not hasattr(self, 'pathTarget5'):
|
|
self.pathTarget5 = None
|
|
else:
|
|
self.pathTargetList[5] = self.pathTarget5
|
|
if not hasattr(self, 'pathTarget6'):
|
|
self.pathTarget6 = None
|
|
else:
|
|
self.pathTargetList[6] = self.pathTarget6
|
|
if not hasattr(self, 'pathTarget7'):
|
|
self.pathTarget7 = None
|
|
else:
|
|
self.pathTargetList[7] = self.pathTarget7
|
|
return
|
|
|
|
def destroy(self):
|
|
PathEntity.PathEntity.destroy(self)
|
|
|
|
def setPathTarget0(self, targetId):
|
|
self.pathTarget0 = targetId
|
|
self.pathTargetList[0] = targetId
|
|
|
|
def setPathTarget1(self, targetId):
|
|
self.pathTarget1 = targetId
|
|
self.pathTargetList[1] = targetId
|
|
|
|
def setPathTarget2(self, targetId):
|
|
self.pathTarget2 = targetId
|
|
self.pathTargetList[2] = targetId
|
|
|
|
def setPathTarget3(self, targetId):
|
|
self.pathTarget3 = targetId
|
|
self.pathTargetList[3] = targetId
|
|
|
|
def setPathTarget4(self, targetId):
|
|
self.pathTarget4 = targetId
|
|
self.pathTargetList[4] = targetId
|
|
|
|
def setPathTarget5(self, targetId):
|
|
self.pathTarget5 = targetId
|
|
self.pathTargetList[5] = targetId
|
|
|
|
def setPathTarget6(self, targetId):
|
|
self.pathTarget6 = targetId
|
|
self.pathTargetList[6] = targetId
|
|
|
|
def setPathTarget7(self, targetId):
|
|
self.pathTarget7 = targetId
|
|
self.pathTargetList[7] = targetId
|
|
|
|
def getReducedPath(self):
|
|
returnPath = []
|
|
for entityId in self.pathTargetList:
|
|
if self.level and entityId != 0:
|
|
thing = self.level.entities.get(entityId, None)
|
|
returnPath.append(thing.getPos(self))
|
|
|
|
return returnPath
|
|
|
|
def setPathIndex(self, pathIndex):
|
|
self.pathIndex = pathIndex
|
|
pathTableId = GoonPathData.taskZoneId2pathId[self.level.getTaskZoneId()]
|
|
if self.pathIndex in GoonPathData.Paths[pathTableId]:
|
|
self.path = GoonPathData.Paths[pathTableId][self.pathIndex]
|
|
else:
|
|
PathEntity.notify.warning('invalid pathIndex: %s' % pathIndex)
|
|
self.path = None
|
|
return
|
|
|
|
def makePathTrack(self, node, velocity, name, turnTime = 1, lookAroundNode = None):
|
|
track = Sequence(name=name)
|
|
self.path = self.getReducedPath()
|
|
if self.path is None or len(self.path) < 1:
|
|
track.append(WaitInterval(1.0))
|
|
return track
|
|
path = self.path + [self.path[0]]
|
|
for pointIndex in xrange(len(path) - 1):
|
|
startPoint = Point3(path[pointIndex]) * self.pathScale
|
|
endPoint = Point3(path[pointIndex + 1]) * self.pathScale
|
|
v = startPoint - endPoint
|
|
node.setPos(startPoint[0], startPoint[1], startPoint[2])
|
|
node.headsUp(endPoint[0], endPoint[1], endPoint[2])
|
|
theta = node.getH() % 360
|
|
track.append(LerpHprInterval(node, turnTime, Vec3(theta, 0, 0)))
|
|
distance = Vec3(v).length()
|
|
duration = distance / velocity
|
|
track.append(LerpPosInterval(node, duration=duration, pos=endPoint, startPos=startPoint))
|
|
|
|
return track
|
|
|
|
def makePathTrackBak(self, node, velocity, name, turnTime = 1, lookAroundNode = None):
|
|
track = Sequence(name=name)
|
|
if self.path is None:
|
|
track.append(WaitInterval(1.0))
|
|
return track
|
|
path = self.path + [self.path[0]]
|
|
for pointIndex in xrange(len(path) - 1):
|
|
startPoint = Point3(path[pointIndex]) * self.pathScale
|
|
endPoint = Point3(path[pointIndex + 1]) * self.pathScale
|
|
v = startPoint - endPoint
|
|
node.setPos(startPoint[0], startPoint[1], startPoint[2])
|
|
node.headsUp(endPoint[0], endPoint[1], endPoint[2])
|
|
theta = node.getH() % 360
|
|
track.append(LerpHprInterval(node, turnTime, Vec3(theta, 0, 0)))
|
|
distance = Vec3(v).length()
|
|
duration = distance / velocity
|
|
track.append(LerpPosInterval(node, duration=duration, pos=endPoint, startPos=startPoint))
|
|
|
|
return track
|