class DistributedPiratesTutorialWorld(
DistributedInstanceBase.DistributedInstanceBase):
notify = directNotify.newCategory('DistributedPiratesTutorialWorld')
def __init__(self, cr):
DistributedInstanceBase.DistributedInstanceBase.__init__(self, cr)
self.tutorialHandler = None
self.tutorialHandlerId = 0
def setTutorialHandlerId(self, doId):
self.tutorialHandlerId = doId
def tutorialHandlerExists(tutorialHandler):
self.tutorialHandler = tutorialHandler
self.tutorialHandler.setInstance(self)
self.cr.relatedObjectMgr.requestObjects(
[self.tutorialHandlerId], eachCallback=tutorialHandlerExists)
def addWorldInterest(self, area=None):
DistributedInstanceBase.DistributedInstanceBase.addWorldInterest(
self, area)
if area:
area.turnOn(localAvatar)
addWorldInterest = report(types=['frameCount', 'args'],
dConfigParam='connector')(addWorldInterest)
def removeWorldInterest(self, area=None):
if not area and area.gridVisContext:
area = None
DistributedInstanceBase.DistributedInstanceBase.removeWorldInterest(
self, area)
removeWorldInterest = report(types=['frameCount', 'args'],
dConfigParam='connector')(removeWorldInterest)
def turnOff(self, cacheIslands=[]):
self._turnOffIslands(cacheIslands)
DistributedInstanceBase.DistributedInstanceBase.turnOff(
self, cacheIslands)
turnOff = report(types=['frameCount', 'args'],
dConfigParam='connector')(turnOff)
def turnOn(self, av=None):
DistributedInstanceBase.DistributedInstanceBase.turnOn(self, av)
self._turnOnIslands()
turnOn = report(types=['frameCount', 'args'],
dConfigParam='connector')(turnOn)
def handleAvatarTeleportResponse(self, avId, available, shardId, instanceDoId, areaDoId):
if not avId == self.teleportQueryId:
self.clearTeleportQueryId()
return None
self.clearTeleportQueryId()
handle = self.cr.identifyAvatar(avId)
if handle:
avName = handle.getName()
else:
return None
if available == PiratesGlobals.TAAvailable:
def teleportConfirmation(confirmed, shardId = shardId, instanceDoID = instanceDoId, avId = avId, avatarParentId = areaDoId):
if confirmed:
self.requestTeleportToAvatar(shardId, instanceDoId, avatarId = avId, avatarParentId = areaDoId)
teleportConfirmation = report(types = [
'args',
'deltaStamp'], dConfigParam = 'teleport')(teleportConfirmation)
localAvatar.setTeleportFlag(PiratesGlobals.TFSameArea, localAvatar.confirmNotSameAreaTeleportToPlayer, [
areaDoId])
localAvatar.confirmTeleport(teleportConfirmation, feedback = True)
localAvatar.clearTeleportFlag(PiratesGlobals.TFSameArea)
else:
flag = PiratesGlobals.decodeTeleportFlag(available)
if flag == PiratesGlobals.TAIgnore:
pass
1
if flag in PiratesGlobals.TFNoTeleportToReasons:
localAvatar.guiMgr.createWarning(PiratesGlobals.TFNoTeleportToReasons[flag] % avName, duration = 10)
def handleAvatarTeleportQuery(self, requesterId, requesterBandMgrId, requesterBandId, requesterGuildId, requesterShardId):
handle = self.cr.identifyAvatar(requesterId)
if not handle:
return None
if self.cr.identifyFriend(requesterId):
if requesterId in localAvatar.ignoreList or self.cr.avatarFriendsManager.checkIgnored(requesterId):
handle.sendTeleportResponse(PiratesGlobals.encodeTeleportFlag(PiratesGlobals.TFIgnore), 0, 0, 0, sendToId = requesterId)
return None
if localAvatar.ship and len(localAvatar.ship.crew) >= localAvatar.ship.getMaxCrew():
handle.sendTeleportResponse(PiratesGlobals.encodeTeleportFlag(PiratesGlobals.TFOnShip), 0, 0, 0, sendToId = requesterId)
return None
avName = handle.getName()
def confirmed(canTeleportTo, avId, failedFlag, avName = avName):
if canTeleportTo:
if self.cr.getActiveWorld() and self.cr.distributedDistrict and localAvatar.getParentObj():
handle.sendTeleportResponse(PiratesGlobals.TAAvailable, self.cr.distributedDistrict.doId, self.cr.getActiveWorld().doId, localAvatar.getParentObj().doId, sendToId = requesterId)
else:
handle.sendTeleportResponse(PiratesGlobals.encodeTeleportFlag(PiratesGlobals.TFUnavailable), 0, 0, 0, sendToId = requesterId)
elif localAvatar.failedTeleportMessageOk(requesterId):
localAvatar.setSystemMessage(requesterId, OTPLocalizer.WhisperFailedVisit % avName)
handle.sendTeleportResponse(PiratesGlobals.encodeTeleportFlag(failedFlag), 0, 0, 0, sendToId = requesterId)
confirmed = report(types = [
'args',
'deltaStamp'], dConfigParam = 'teleport')(confirmed)
localAvatar.confirmTeleportTo(confirmed, requesterId, avName, requesterBandMgrId, requesterBandId, requesterGuildId)
def handleAvatarTeleportQuery(self, requesterId, requesterBandMgrId,
requesterBandId, requesterGuildId,
requesterShardId):
handle = self.cr.identifyAvatar(requesterId)
if not handle:
return None
if self.cr.identifyFriend(requesterId):
if requesterId in localAvatar.ignoreList or self.cr.avatarFriendsManager.checkIgnored(
requesterId):
handle.sendTeleportResponse(PiratesGlobals.encodeTeleportFlag(
PiratesGlobals.TFIgnore),
0,
0,
0,
sendToId=requesterId)
return None
avName = handle.getName()
def confirmed(canTeleportTo, avId, failedFlag, avName=avName):
if canTeleportTo:
if self.cr.getActiveWorld(
) and self.cr.distributedDistrict and localAvatar.getParentObj(
):
handle.sendTeleportResponse(
PiratesGlobals.TAAvailable,
self.cr.distributedDistrict.doId,
self.cr.getActiveWorld().doId,
localAvatar.getParentObj().doId,
sendToId=requesterId)
else:
handle.sendTeleportResponse(
PiratesGlobals.encodeTeleportFlag(
PiratesGlobals.TFUnavailable),
0,
0,
0,
sendToId=requesterId)
elif localAvatar.failedTeleportMessageOk(requesterId):
localAvatar.setSystemMessage(
requesterId, OTPLocalizer.WhisperFailedVisit % avName)
handle.sendTeleportResponse(
PiratesGlobals.encodeTeleportFlag(failedFlag),
0,
0,
0,
sendToId=requesterId)
confirmed = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(confirmed)
localAvatar.confirmTeleportTo(confirmed, requesterId, avName,
requesterBandMgrId, requesterBandId,
requesterGuildId)
def setArea(self, worldStack, areaDoId, autoFadeIn = True):
self.cr.setWorldStack(worldStack, event = 'WorldOpen')
def areaFinishedCallback(area):
self.pendingArea = None
self.loadAreaFinished(area, autoFadeIn)
areaFinishedCallback = report(types = [
'frameCount',
'args'], dConfigParam = 'connector')(areaFinishedCallback)
self.cr.relatedObjectMgr.abortRequest(self.pendingArea)
self.pendingArea = self.cr.relatedObjectMgr.requestObjects([
areaDoId], eachCallback = areaFinishedCallback)
def setArea(self, worldStack, areaDoId, autoFadeIn=True):
self.cr.setWorldStack(worldStack, event='WorldOpen')
def areaFinishedCallback(area):
self.pendingArea = None
self.loadAreaFinished(area, autoFadeIn)
areaFinishedCallback = report(
types=['frameCount',
'args'], dConfigParam='connector')(areaFinishedCallback)
self.cr.relatedObjectMgr.abortRequest(self.pendingArea)
self.pendingArea = self.cr.relatedObjectMgr.requestObjects(
[areaDoId], eachCallback=areaFinishedCallback)
def setArea(self, worldLocationId, worldLocationZone, areaDoId, autoFadeIn = True):
localAvatar.setInterest(worldLocationId, worldLocationZone, [
'instanceInterest'])
def areaFinishedCallback(area):
self.pendingArea = None
self.loadAreaFinished(area, autoFadeIn)
areaFinishedCallback = report(types = [
'frameCount'], dConfigParam = 'connector')(areaFinishedCallback)
if self.pendingArea:
self.cr.relatedObjectMgr.abortRequest(self.pendingArea)
self.pendingArea = self.cr.relatedObjectMgr.requestObjects([
areaDoId], eachCallback = areaFinishedCallback)
class DistributedWelcomeWorld(DistributedInstanceBase.DistributedInstanceBase):
notify = directNotify.newCategory('DistributedWelcomeWorld')
def handleOnStage(self):
DistributedInstanceBase.DistributedInstanceBase.handleOnStage(self)
base.cr.timeOfDayManager.setEnvironment(TODGlobals.ENV_DEFAULT)
handleOnStage = report(types=['args'],
dConfigParam=['dteleport'])(handleOnStage)
def getWorldPos(self, node):
if not node.isEmpty() and self.isOnStage():
return node.getPos(self)
def getAggroRadius(self):
return EnemyGlobals.MAX_SEARCH_RADIUS
def localAvEnterDeath(self, av):
DistributedInstanceBase.DistributedInstanceBase.localAvEnterDeath(
self, av)
self.d_localAvatarDied()
localAvEnterDeath = report(types=['frameCount'],
dConfigParam='jail')(localAvEnterDeath)
class DistributedWelcomeWorld(DistributedInstanceBase.DistributedInstanceBase):
notify = directNotify.newCategory('DistributedWelcomeWorld')
def announceGenerate(self):
DistributedInstanceBase.DistributedInstanceBase.announceGenerate(self)
if not self.playerControlledObj.hasParent():
self.playerControlledObj.reparentTo(self)
def delete(self):
self.ignore('sendingLocalAvatarToJail')
DistributedInstanceBase.DistributedInstanceBase.delete(self)
def addWorldInterest(self, area=None):
DistributedInstanceBase.DistributedInstanceBase.addWorldInterest(
self, area)
if area:
area.turnOn(localAvatar)
def removeWorldInterest(self, area=None):
if not area and area.gridVisContext:
area = None
DistributedInstanceBase.DistributedInstanceBase.removeWorldInterest(
self, area)
def turnOff(self, cacheIslands=[]):
DistributedInstanceBase.DistributedInstanceBase.turnOff(
self, cacheIslands)
def turnOn(self, av=None):
DistributedInstanceBase.DistributedInstanceBase.turnOn(self, None)
self._turnOnIslands()
base.cr.timeOfDayManager.setEnvironment(TODGlobals.ENV_DEFAULT)
def getWorldPos(self, node):
if not node.isEmpty() and self.isOn():
return node.getPos(self)
def getAggroRadius(self):
return EnemyGlobals.MAX_SEARCH_RADIUS
def localAvEnterDeath(self, av):
DistributedInstanceBase.DistributedInstanceBase.localAvEnterDeath(
self, av)
self.d_localAvatarDied()
localAvEnterDeath = report(types=['frameCount'],
dConfigParam='jail')(localAvEnterDeath)
def loadAreaFinished(self, area, autoFadeIn=True):
def leaveTunnel():
areaIndex = self.getAreaIndex(area)
entranceNode = self.areaNode[areaIndex]
entryLocator = area.find('**/' + entranceNode + '*')
localAvatar.reparentTo(entryLocator)
localAvatar.setPos(0, 0, 0)
if not autoFadeIn:
if localAvatar.style.tutorial == PiratesGlobals.TUT_KILLED_1_SKELETON:
localAvatar.setX(30)
localAvatar.setH(90)
else:
localAvatar.setH(-90)
localAvatar.wrtReparentTo(area)
if autoFadeIn:
def leaveTunnelFinished():
localAvatar.b_clearTeleportFlag(PiratesGlobals.TFInTunnel)
if localAvatar.gameFSM.preTunnelState:
localAvatar.b_setGameState(
localAvatar.gameFSM.preTunnelState)
if localAvatar.gameFSM.preTunnelState == 'Battle':
localAvatar.guiMgr.combatTray.toggleWeapon(
localAvatar.currentWeaponId,
localAvatar.currentWeaponSlotId)
else:
localAvatar.b_setGameState('LandRoam')
self.acceptOnce('LeaveTunnelFinished', leaveTunnelFinished)
base.localAvatar.b_setGameState('LeaveTunnel')
else:
self.sendUpdate('sendLeaveTunnelDone')
self.fadeInAmbient(self.floorIndex)
leaveTunnel = report(types=['frameCount', 'printInterests'],
dConfigParam='connector')(leaveTunnel)
base.cr.setAllInterestsCompleteCallback(leaveTunnel)
transform = localAvatar.getTransform(self)
DistributedGAConnector.DistributedGAConnector.loadAreaFinished(
self, area, autoFadeIn)
self.lastFloorTime = globalClock.getFrameTime()
self.loadedAreaDoId = area.doId
localAvatar.setTransform(self, transform)
localAvatar.wrtReparentTo(area)
area.handleEnterGameArea(None)
def loadAreaFinished(self, area, autoFadeIn = True):
def handleFinished():
for currHandle in self.ownHandles:
self.cr.removeTaggedInterest(currHandle)
self.ownHandles = []
self.acceptOnce('EnterTunnelFinished', handleFinished)
def leaveTunnel():
if autoFadeIn:
def leaveTunnelFinished():
self._inTransition = False
area.forceManagePass(localAvatar)
localAvatar.sendCurrentPosition()
self.acceptOnce('LeaveTunnelFinished', leaveTunnelFinished)
localAvatar.b_setGameState('LeaveTunnel', [
self,
area,
not autoFadeIn])
else:
def leaveTunnelFinished():
self.sendUpdate('sendLeaveTunnelDone')
area.forceManagePass(localAvatar)
localAvatar.sendCurrentPosition()
localAvatar.b_setGameState('LeaveTunnel', [
self,
area,
not autoFadeIn])
self.cr.setAllInterestsCompleteCallback(leaveTunnelFinished)
area.handleEnterGameArea()
self.fadeInAmbient(self.floorIndex)
leaveTunnel = report(types = [
'deltaStamp',
'args'], dConfigParam = 'connector')(leaveTunnel)
world = area.getParentObj()
world.goOnStage()
area.goOnStage()
self.cr.setAllInterestsCompleteCallback(leaveTunnel)
def loadAreaFinished(self, area, autoFadeIn = True):
def handleFinished():
for currHandle in self.ownHandles:
self.cr.removeTaggedInterest(currHandle)
self.ownHandles = []
self.acceptOnce('EnterTunnelFinished', handleFinished)
def leaveTunnel():
if autoFadeIn:
def leaveTunnelFinished():
self._inTransition = False
area.forceManagePass(localAvatar)
localAvatar.sendCurrentPosition()
self.acceptOnce('LeaveTunnelFinished', leaveTunnelFinished)
localAvatar.b_setGameState('LeaveTunnel', [
self,
area,
not autoFadeIn])
else:
def leaveTunnelFinished():
self.sendUpdate('sendLeaveTunnelDone')
area.forceManagePass(localAvatar)
localAvatar.sendCurrentPosition()
localAvatar.b_setGameState('LeaveTunnel', [
self,
area,
not autoFadeIn])
self.cr.setAllInterestsCompleteCallback(leaveTunnelFinished)
area.handleEnterGameArea()
self.fadeInAmbient(self.floorIndex)
leaveTunnel = report(types = [
'deltaStamp',
'args'], dConfigParam = 'connector')(leaveTunnel)
world = area.getParentObj()
world.goOnStage()
area.goOnStage()
self.cr.setAllInterestsCompleteCallback(leaveTunnel)
def loadAreaFinished(self, area, autoFadeIn=True):
def leaveTunnel():
areaIndex = self.getAreaIndex(area)
entranceNode = self.areaNode[areaIndex]
entryLocator = area.find("**/" + entranceNode + "*")
localAvatar.reparentTo(entryLocator)
localAvatar.setPos(0, 0, 0)
if not autoFadeIn:
if localAvatar.style.tutorial == PiratesGlobals.TUT_KILLED_1_SKELETON:
localAvatar.setX(30)
localAvatar.setH(90)
else:
localAvatar.setH(-90)
localAvatar.wrtReparentTo(area)
if autoFadeIn:
def leaveTunnelFinished():
localAvatar.b_clearTeleportFlag(PiratesGlobals.TFInTunnel)
if localAvatar.gameFSM.preTunnelState:
localAvatar.b_setGameState(localAvatar.gameFSM.preTunnelState)
if localAvatar.gameFSM.preTunnelState == "Battle":
localAvatar.guiMgr.combatTray.toggleWeapon(
localAvatar.currentWeaponId, localAvatar.currentWeaponSlotId
)
else:
localAvatar.b_setGameState("LandRoam")
self.acceptOnce("LeaveTunnelFinished", leaveTunnelFinished)
base.localAvatar.b_setGameState("LeaveTunnel")
else:
self.sendUpdate("sendLeaveTunnelDone")
self.fadeInAmbient(self.floorIndex)
leaveTunnel = report(types=["frameCount", "printInterests"], dConfigParam="connector")(leaveTunnel)
base.cr.setAllInterestsCompleteCallback(leaveTunnel)
transform = localAvatar.getTransform(self)
DistributedGAConnector.DistributedGAConnector.loadAreaFinished(self, area, autoFadeIn)
self.lastFloorTime = globalClock.getFrameTime()
self.loadedAreaDoId = area.doId
localAvatar.setTransform(self, transform)
localAvatar.wrtReparentTo(area)
area.handleEnterGameArea(None)
def queryAvatarForTeleport(self, avId):
self.setTeleportQueryId(avId)
def teleportConfirmation(confirmed, avId=avId):
if confirmed:
handle = self.cr.identifyAvatar(avId)
if handle:
shardId = self.cr.distributedDistrict.doId
if not localAvatar.getBandId():
pass
(bandMgr, bandId) = (0, 0)
guildId = localAvatar.getGuildId()
handle.sendTeleportQuery(avId, bandMgr, bandId, guildId,
shardId)
teleportConfirmation = report(
types=['args', 'deltaStamp'],
dConfigParam='teleport')(teleportConfirmation)
localAvatar.confirmTeleport(teleportConfirmation, feedback=True)
def handleAvatarTeleportResponse(self, avId, available, shardId,
instanceDoId, areaDoId):
if not avId == self.teleportQueryId:
self.clearTeleportQueryId()
return None
self.clearTeleportQueryId()
handle = self.cr.identifyAvatar(avId)
if handle:
avName = handle.getName()
else:
return None
if available == PiratesGlobals.TAAvailable:
def teleportConfirmation(confirmed,
shardId=shardId,
instanceDoID=instanceDoId,
avId=avId,
avatarParentId=areaDoId):
if confirmed:
self.requestTeleportToAvatar(shardId,
instanceDoId,
avatarId=avId,
avatarParentId=areaDoId)
teleportConfirmation = report(
types=['args', 'deltaStamp'],
dConfigParam='teleport')(teleportConfirmation)
localAvatar.setTeleportFlag(
PiratesGlobals.TFSameArea,
localAvatar.confirmNotSameAreaTeleportToPlayer, [areaDoId])
localAvatar.confirmTeleport(teleportConfirmation, feedback=True)
localAvatar.clearTeleportFlag(PiratesGlobals.TFSameArea)
else:
flag = PiratesGlobals.decodeTeleportFlag(available)
if flag == PiratesGlobals.TAIgnore:
pass
1
if flag in PiratesGlobals.TFNoTeleportToReasons:
localAvatar.guiMgr.createWarning(
PiratesGlobals.TFNoTeleportToReasons[flag] % avName,
duration=10)
def queryAvatarForTeleport(self, avId):
self.setTeleportQueryId(avId)
def teleportConfirmation(confirmed, avId = avId):
if confirmed:
handle = self.cr.identifyAvatar(avId)
if handle:
shardId = self.cr.distributedDistrict.doId
if not localAvatar.getBandId():
pass
(bandMgr, bandId) = (0, 0)
guildId = localAvatar.getGuildId()
handle.sendTeleportQuery(avId, bandMgr, bandId, guildId, shardId)
teleportConfirmation = report(types = [
'args',
'deltaStamp'], dConfigParam = 'teleport')(teleportConfirmation)
localAvatar.confirmTeleport(teleportConfirmation, feedback = True)
def setArea(self,
worldLocationId,
worldLocationZone,
areaDoId,
autoFadeIn=True):
localAvatar.setInterest(worldLocationId, worldLocationZone,
['instanceInterest'])
def areaFinishedCallback(area):
self.pendingArea = None
self.loadAreaFinished(area, autoFadeIn)
areaFinishedCallback = report(
types=['frameCount'],
dConfigParam='connector')(areaFinishedCallback)
if self.pendingArea:
self.cr.relatedObjectMgr.abortRequest(self.pendingArea)
self.pendingArea = self.cr.relatedObjectMgr.requestObjects(
[areaDoId], eachCallback=areaFinishedCallback)
def placeInWorld(self):
def stepObjHere(tunnelObj):
self.pendingStepObj = None
area = base.cr.getDo(self.questStep.getOriginDoId())
areaUid = area.getUniqueId()
areaNodeName = tunnelObj.getAreaNodeNameFromAreaUid(areaUid)
areaNode = area.getConnectorNodeNamed(areaNodeName)
self.reparentTo(areaNode)
self.setPosHpr(0, 0, 0, 0, 0, 0)
self.setPos(self, self.LOD_CENTER_OFFSET_X, 0, 5)
self.wrtReparentTo(area)
stepObjHere = report(types=['frameCount', 'args'],
dConfigParam='quest-indicator')(stepObjHere)
if self.pendingStepObj:
base.cr.relatedObjectMgr.abortRequest(self.pendingStepObj)
self.pendingStepObj = None
self.pendingStepObj = base.cr.relatedObjectMgr.requestObjects(
[self.questStep.getStepDoId()], eachCallback=stepObjHere)
def placeInWorld(self):
def stepObjHere(stepObj):
self.pendingStepObj = None
def performReparent(tunnelObj = stepObj):
if tunnelObj == stepObj:
areaIndex = tunnelObj.getAreaIndexFromDoId(self.questStep.getOriginDoId())
if areaIndex != None:
(pos, hpr) = tunnelObj.getConnectorNodePosHpr(areaIndex)
t = TransformState.makePosHpr(pos, hpr)
ti = t.invertCompose(TransformState.makeIdentity())
self.reparentTo(tunnelObj)
self.setPos(ti.getPos())
self.setHpr(ti.getHpr())
self.setPos(self, self.LOD_CENTER_OFFSET_X, 0, 5)
parent = base.cr.doId2do[self.questStep.getOriginDoId()]
self.wrtReparentTo(parent)
self.arrowNode = tunnelObj.attachNewNode('arrowNode')
self.arrowNode.setPos(ti.getPos())
if not stepObj.isConnectorLoaded():
self.acceptOnce('tunnelSetLinks', performReparent)
else:
performReparent()
stepObjHere = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(stepObjHere)
if self.pendingStepObj:
base.cr.relatedObjectMgr.abortRequest(self.pendingStepObj)
self.pendingStepObj = None
self.pendingStepObj = base.cr.relatedObjectMgr.requestObjects([
self.questStep.getStepDoId()], eachCallback = stepObjHere)
def placeInWorld(self):
def stepObjHere(stepObj):
self.pendingStepObj = None
def performReparent(tunnelObj=stepObj):
if tunnelObj == stepObj:
areaIndex = tunnelObj.getAreaIndexFromDoId(
self.questStep.getOriginDoId())
if areaIndex != None:
(pos,
hpr) = tunnelObj.getConnectorNodePosHpr(areaIndex)
t = TransformState.makePosHpr(pos, hpr)
ti = t.invertCompose(TransformState.makeIdentity())
self.reparentTo(tunnelObj)
self.setPos(ti.getPos())
self.setHpr(ti.getHpr())
self.setPos(self, self.LOD_CENTER_OFFSET_X, 0, 5)
parent = base.cr.doId2do[
self.questStep.getOriginDoId()]
self.wrtReparentTo(parent)
self.arrowNode = tunnelObj.attachNewNode('arrowNode')
self.arrowNode.setPos(ti.getPos())
if not stepObj.isConnectorLoaded():
self.acceptOnce('tunnelSetLinks', performReparent)
else:
performReparent()
stepObjHere = report(types=['frameCount', 'args'],
dConfigParam='quest-indicator')(stepObjHere)
if self.pendingStepObj:
base.cr.relatedObjectMgr.abortRequest(self.pendingStepObj)
self.pendingStepObj = None
self.pendingStepObj = base.cr.relatedObjectMgr.requestObjects(
[self.questStep.getStepDoId()], eachCallback=stepObjHere)
class QuestIndicatorNodeIntDoor(QuestIndicatorNode):
def __init__(self, questStep):
self.pendingStepObj = None
QuestIndicatorNode.__init__(self, 'IntDoorIndicator', [
5], questStep)
self.nearEffect = None
def delete(self):
if self.pendingStepObj:
base.cr.relatedObjectMgr.abortRequest(self.pendingStepObj)
self.pendingStepObj = None
QuestIndicatorNode.delete(self)
if self.nearEffect:
self.nearEffect.cleanUpEffect()
self.nearEffect = None
def placeInWorld(self):
def stepObjHere(stepObj):
self.pendingStepObj = None
self.reparentTo(stepObj)
self.setPos(0, 0, 0)
self.setHpr(0, 0, 0)
self.setScale(render, 1)
if self.pendingStepObj:
base.cr.relatedObjectMgr.abortRequest(self.pendingStepObj)
self.pendingStepObj = None
self.pendingStepObj = base.cr.relatedObjectMgr.requestObjects([
self.questStep.getStepDoId()], eachCallback = stepObjHere)
def loadZoneLevel(self, level):
QuestIndicatorNode.loadZoneLevel(self, level)
if level == 0:
self.request('At')
if level == 1:
self.request('Near')
def unloadZoneLevel(self, level):
QuestIndicatorNode.unloadZoneLevel(self, level)
if level == 0:
self.request('Near')
if level == 1:
self.request('Off')
def enterOff(self):
QuestIndicatorNode.enterOff(self)
self.stopNearEffect()
enterOff = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(enterOff)
def enterNear(self):
self.startNearEffect()
enterNear = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(enterNear)
def exitNear(self):
self.stopNearEffect()
exitNear = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(exitNear)
def enterAt(self):
pass
def exitAt(self):
pass
def showEffect(self):
QuestIndicatorNode.showEffect(self)
self.startNearEffect()
def hideEffect(self):
QuestIndicatorNode.hideEffect(self)
self.stopNearEffect()
def startNearEffect(self):
if self.muted:
return None
if not self.nearEffect:
self.nearEffect = RayOfLight()
self.nearEffect.setBottomRayEnabled(self.wantBottomEffect)
self.nearEffect.reparentTo(self)
self.nearEffect.startLoop()
startNearEffect = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(startNearEffect)
def stopNearEffect(self):
if self.nearEffect:
self.nearEffect.stopLoop()
self.nearEffect = None
stopNearEffect = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(stopNearEffect)
class PiratesClientRepository(OTPClientRepository):
notify = directNotify.newCategory('PiratesClientRepository')
SupportTutorial = 0
GameGlobalsId = OTP_DO_ID_PIRATES
StopVisibilityEvent = 'pirates-stop-visibility'
def __init__(self, serverVersion, launcher=None):
self.loadingScreen = base.loadingScreen
self.loadingScreen.parent = self
self.accept('connectionIssue', self.loadingScreen.hide)
self.accept('connectionRetrying', self.loadingScreen.show)
OTPClientRepository.__init__(self,
serverVersion,
launcher,
playGame=PlayGame.PlayGame)
self.createAvatarClass = DistributedPlayerPirate.DistributedPlayerPirate
self.tradeManager = None
self.pvpManager = None
self.csm = self.generateGlobalObject(
OtpDoGlobals.OTP_DO_ID_CLIENT_SERVICES_MANAGER,
'ClientServicesManager')
#self.avatarManager = self.generateGlobalObject(OtpDoGlobals.OTP_DO_ID_PIRATES_AVATAR_MANAGER, 'DistributedAvatarManager')
#self.chatManager = self.generateGlobalObject(OtpDoGlobals.OTP_DO_ID_CHAT_MANAGER, 'DistributedChatManager')
#self.crewMatchManager = self.generateGlobalObject(OtpDoGlobals.OTP_DO_ID_PIRATES_CREW_MATCH_MANAGER, 'DistributedCrewMatchManager')
#self.avatarFriendsManager = self.generateGlobalObject(OtpDoGlobals.OTP_DO_ID_AVATAR_FRIENDS_MANAGER, 'PCAvatarFriendsManager')
#self.playerFriendsManager = self.generateGlobalObject(OtpDoGlobals.OTP_DO_ID_PLAYER_FRIENDS_MANAGER, 'PCPlayerFriendsManager')
#self.guildManager = self.generateGlobalObject(OtpDoGlobals.OTP_DO_ID_PIRATES_GUILD_MANAGER, 'PCGuildManager')
#self.speedchatRelay = self.generateGlobalObject(OtpDoGlobals.OTP_DO_ID_PIRATES_SPEEDCHAT_RELAY, 'PiratesSpeedchatRelay')
#self.shipLoader = self.generateGlobalObject(OtpDoGlobals.OTP_DO_ID_PIRATES_SHIP_MANAGER, 'DistributedShipLoader')
#self.matchMaker = self.generateGlobalObject(OtpDoGlobals.OTP_DO_ID_PIRATES_MATCH_MAKER, 'DistributedMatchMaker')
base.loadingScreen.tick()
#self.codeRedemption = self.generateGlobalObject(OtpDoGlobals.OTP_DO_ID_PIRATES_CODE_REDEMPTION, 'CodeRedemption')
base.loadingScreen.tick()
#self.settingsMgr = self.generateGlobalObject(OtpDoGlobals.OTP_DO_ID_PIRATES_SETTINGS_MANAGER, 'PiratesSettingsMgr')
#self.statusDatabase = self.generateGlobalObject(OtpDoGlobals.OTP_DO_ID_STATUS_DATABASE, 'StatusDatabase')
self.wantSeapatch = base.config.GetBool('want-seapatch', 1)
self.wantSpecialEffects = base.config.GetBool('want-special-effects',
1)
self.wantMakeAPirate = base.config.GetBool('wantMakeAPirate', 0)
self.forceTutorial = base.config.GetBool('force-tutorial', 0)
self.skipTutorial = base.config.GetBool('skip-tutorial', 0)
self.tutorialObject = None
self.avChoiceDoneEvent = None
self.avChoice = None
self.avCreate = None
self.currentCutscene = None
self.activeWorld = None
self.oldWorld = None
self.teleportMgr = None
self.treasureMap = None
self.newsManager = None
self.distributedDistrict = None
self.district = None
self.profileMgr = None
self.battleMgr = BattleManager.BattleManager(self)
self.combatAnims = CombatAnimations.CombatAnimations()
self.interactionMgr = InteractionManager.InteractionManager()
self.currCamParent = None
self.uidMgr = UniqueIdManager.UniqueIdManager(self)
self.fakeMSP = None
self.questDynMap = QuestLadderDynMap.QuestLadderDynMap()
self.questDependency = QuestLadderDependency()
self.questChoiceSibsMap = QuestChoiceDynMap()
base.loadingScreen.beginStep('MasterHumans', 52, 45)
self.humanHigh = [MasterHuman.MasterHuman(), MasterHuman.MasterHuman()]
self.humanHigh[0].billboardNode.removeNode()
self.humanHigh[1].billboardNode.removeNode()
self.humanHigh[0].style = HumanDNA.HumanDNA('m')
self.humanHigh[1].style = HumanDNA.HumanDNA('f')
self.humanHigh[0].generateHuman('m')
base.loadingScreen.tick()
self.humanHigh[1].generateHuman('f')
base.loadingScreen.tick()
self.humanHigh[0].ignoreAll()
self.humanHigh[1].ignoreAll()
self.humanHigh[0].stopBlink()
self.humanHigh[1].stopBlink()
self.humanLow = [MasterHuman.MasterHuman(), MasterHuman.MasterHuman()]
self.humanLow[0].billboardNode.removeNode()
self.humanLow[1].billboardNode.removeNode()
self.humanLow[0].style = HumanDNA.HumanDNA('m')
self.humanLow[1].style = HumanDNA.HumanDNA('f')
self.humanLow[0].generateHuman('m')
base.loadingScreen.tick()
self.humanLow[1].generateHuman('f')
base.loadingScreen.tick()
base.loadingScreen.endStep('MasterHumans')
self.humanLow[0].ignoreAll()
self.humanLow[1].ignoreAll()
self.humanLow[0].stopBlink()
self.humanLow[1].stopBlink()
for i in range(2):
self.humanLow[i]._Actor__sortedLODNames = ['500']
del self.humanLow[i]._Actor__partBundleDict['2000']
del self.humanLow[i]._Actor__partBundleDict['1000']
self.humanLow[i].getLOD('2000').detachNode()
self.humanLow[i].getLOD('1000').detachNode()
self.humanLow[i].getLODNode().clearSwitches()
self.humanLow[i].getLODNode().addSwitch(10000, 0)
if base.options.getCharacterDetailSetting() == 0:
self.human = self.humanLow
else:
self.human = self.humanHigh
A = AvatarTypes
del A
self.preloadedCutscenes = {}
self.defaultShard = 0
if __dev__:
__builtin__.go = self.getDo
self.effectTypes = {
'damageSmoke': ['BlackSmoke'],
'damageFire': ['Fire'],
'cannonDeckFire': ['CannonSmokeSimple', 'CannonBlastSmoke'],
'cannonBSFire': [
'MuzzleFlameBS', 'CannonSmokeSimpleBS',
'CannonBlastSmokeBS', 'GrapeshotEffectBS'
],
'cannonHit': ['SimpleSmokeCloud', 'ExplosionFlip'],
'cannonSplash': ['CannonSplash']
}
self.effectToggles = {}
self.cannonballCollisionDebug = 1
self.npcManager = NPCManager.NPCManager()
self.accountDetailRecord = AccountDetailRecord()
def gotoFirstScreen(self):
base.loadingScreen.beginStep('PrepLogin', 9, 0.14000000000000001)
self.startReaderPollTask()
#self.startHeartbeat()
base.loadingScreen.tick()
self.loginFSM.request('login')
base.loadingScreen.tick()
base.loadingScreen.endStep('PrepLogin')
gotoFirstScreen = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(gotoFirstScreen)
def getOldWorld(self):
return self.oldWorld
def getActiveWorld(self):
return self.activeWorld
def preloadCutscene(self, name):
if name not in self.preloadedCutscenes:
newCutscene = Cutscene.Cutscene(self, name)
self.preloadedCutscenes[name] = newCutscene
def getPreloadedCutsceneInfo(self, name):
return self.preloadedCutscenes.get(name)
def cleanupPreloadedCutscene(self, name):
plCutscene = self.preloadedCutscenes.get(name)
if plCutscene:
if not plCutscene.isEmpty():
plCutscene.destroy()
del self.preloadedCutscenes[name]
def setActiveWorld(self, world):
if self.activeWorld != world:
self.oldWorld = self.activeWorld
self.activeWorld = world
setActiveWorld = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(setActiveWorld)
def getWaterHeight(self, node):
if self.wantSeapatch and self.activeWorld:
water = self.activeWorld.getWater()
if water:
return water.calcHeight(node=node)
else:
return 0.0
def isOceanEnabled(self):
if self.wantSeapatch and self.activeWorld and self.activeWorld.hasWater(
):
return self.activeWorld.getWater().enabled
return 0
def enterChooseAvatar(self, avList):
base.loadingScreen.beginStep('AvChooser', 14, 10)
self.sendSetAvatarIdMsg(0)
self.handler = self.handleMessageType
if __dev__:
bp.loginCfg()
config_slot = base.config.GetInt('login-pirate-slot', -1)
if config_slot >= 0 and len(avList) > 0:
config_subId = base.config.GetInt('login-pirate-subId',
avList.keys()[0])
slots = avList.get(config_subId, [])
if config_slot in range(len(slots)):
potAv = slots[config_slot]
if isinstance(potAv, PotentialAvatar):
base.cr.loadingScreen.hide()
ConfigVariableInt('login-pirate-slot').setValue(-1)
base.loadingScreen.endStep('AvChooser')
base.cr.avatarManager.sendRequestPlayAvatar(
potAv.id, config_subId)
self.handleAvatarChoice('chose', config_subId,
config_slot)
return None
self.avChoiceDoneEvent = 'avatarChooserDone'
self.avChoice = AvatarChooser(self.loginFSM, self.avChoiceDoneEvent)
base.loadingScreen.tick()
self.avChoice.load()
base.loadingScreen.tick()
self.avChoice.enter()
base.loadingScreen.tick()
self.accept(self.avChoiceDoneEvent, self.__handleAvatarChooserDone)
base.loadingScreen.endStep('AvChooser')
base.cr.loadingScreen.hide()
enterChooseAvatar = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(enterChooseAvatar)
def __handleAvatarChooserDone(self, doneStatus):
done = doneStatus['mode']
if done == 'exit':
self.notify.info('handleAvatarChooserDone: shutting down')
self.loginFSM.request('shutdown')
return None
(subId, slot) = self.avChoice.getChoice()
self.avChoice.exit()
self.handleAvatarChoice(done, subId, slot)
__handleAvatarChooserDone = report(
types=['args', 'deltaStamp'],
dConfigParam='teleport')(__handleAvatarChooserDone)
def handleAvatarChoice(self, done, subId, slot):
access = self.accountDetailRecord.subDetails[subId].subAccess
base.setEmbeddedFrameMode(access)
if done == 'chose':
av = self.avList[subId][slot]
if av.dna.getTutorial() < 3 and self.skipTutorial == 0:
self.tutorial = 1
else:
self.tutorial = 0
self.loadingScreen.beginStep('waitForAv')
self.loginFSM.request('waitForSetAvatarResponse', [av])
elif done == 'create':
self.loginFSM.request('createAvatar',
[self.avList[subId], slot, subId])
def exitChooseAvatar(self):
self.handler = None
if self.avChoice:
self.avChoice.exit()
self.avChoice.unload()
self.avChoice = None
if self.avChoiceDoneEvent:
self.ignore(self.avChoiceDoneEvent)
self.avChoiceDoneEvent = None
exitChooseAvatar = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(exitChooseAvatar)
def enterCreateAvatar(self, avList, index, subId):
self.tutorial = 0
self.avCreate = MakeAPirate(avList, 'makeAPirateComplete', subId,
index, self.isPaid())
self.avCreate.load()
self.avCreate.enter()
self.accept('makeAPirateComplete', self.__handleMakeAPirate)
enterCreateAvatar = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(enterCreateAvatar)
def handleAvatarCreated(self, newPotAv, avatarId, subId):
newPotAv.id = avatarId
self.loginFSM.request('waitForSetAvatarResponse', [newPotAv])
handleAvatarCreated = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(handleAvatarCreated)
def __handleMakeAPirate(self):
done = self.avCreate.getDoneStatus()
if done == 'cancel':
self.avCreate.exit()
self.loginFSM.request('chooseAvatar', [self.avList])
elif done == 'created':
self.handleAvatarCreated(self.avCreate.newPotAv,
self.avCreate.avId, self.avCreate.subId)
else:
self.notify.error('Invalid doneStatus from MakeAPirate: ' +
str(done))
__handleMakeAPirate = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(__handleMakeAPirate)
def exitCreateAvatar(self):
if self.skipTutorial:
self.ignore('makeAPirateComplete')
self.ignore('nameShopPost')
self.ignore('nameShopCreateAvatar')
self.avCreate.exit()
self.avCreate.unload()
self.avCreate = None
self.handler = None
self.ignore('createdNewAvatar')
exitCreateAvatar = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(exitCreateAvatar)
def handleCreateAvatarResponse(self, avId):
self.avId = avId
newPotAv = PotentialAvatar(self.avId, [self.newName, '', '', ''],
self.newDNA, self.newPosition, 1)
self.loginFSM.request('waitForSetAvatarResponse', [newPotAv])
def avatarListFailed(self, reason):
dialogClass = OTPGlobals.getGlobalDialogClass()
self.avatarListFailedBox = dialogClass(
message=PLocalizer.CRAvatarListFailed,
doneEvent='avatarListFailedAck',
text_wordwrap=18,
style=OTPDialog.Acknowledge)
self.avatarListFailedBox.show()
self.acceptOnce('avatarListFailedAck',
self.__handleAvatarListFailedAck)
avatarListFailed = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(avatarListFailed)
def __handleAvatarListFailedAck(self):
self.ignore('avatarListFailedAck')
self.avatarListFailedBox.cleanup()
self.loginFSM.request('shutdown')
__handleAvatarListFailedAck = report(
types=['args', 'deltaStamp'],
dConfigParam='teleport')(__handleAvatarListFailedAck)
def avatarList(self, avatars):
self.ignore('avatarListFailed')
self.ignore('avatarList')
self.avList = avatars
if self.loginFSM.getCurrentState().getName() == 'chooseAvatar':
self.avChoice.updateAvatarList()
else:
self.loginFSM.request('chooseAvatar', [self.avList])
avatarList = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(avatarList)
def handleGetAvatarsRespMsg(self, di):
pass
handleGetAvatarsRespMsg = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(handleGetAvatarsRespMsg)
def handleGetAvatarsResp2Msg(self, di):
pass
handleGetAvatarsResp2Msg = report(
types=['args', 'deltaStamp'],
dConfigParam='teleport')(handleGetAvatarsResp2Msg)
def handleAvatarResponseMsg(self, di):
self.loadingScreen.endStep('waitForAv')
self.cleanupWaitingForDatabase()
avatarId = di.getUint32()
returnCode = di.getUint8()
if returnCode == 0:
dclass = self.dclassesByName['DistributedPlayerPirate']
NametagGlobals.setMasterArrowsOn(0)
self.loadingScreen.show(waitForLocation=True, expectedLoadScale=4)
self.loadingScreen.beginStep('LocalAvatar', 36, 120)
localAvatar = LocalPirate(self)
localAvatar.dclass = dclass
if __dev__:
__builtins__['lu'] = self.getDo
localAvatar.doId = avatarId
self.localAvatarDoId = avatarId
self.doId2do[avatarId] = localAvatar
parentId = None
zoneId = None
localAvatar.setLocation(parentId, zoneId)
localAvatar.generate()
localAvatar.updateAllRequiredFields(dclass, di)
locUID = localAvatar.getReturnLocation()
if __dev__ and not getBase().config.GetBool(
'login-location-used-pcr', False):
bp.loginCfg()
ConfigVariableBool('login-location-used-pcr').setValue(True)
config_location = getBase().config.GetString(
'login-location', '').lower()
config_location_uid = PLocalizer.LocationUids.get(
config_location)
if config_location and config_location_uid:
locUID = config_location_uid
localAvatar.setReturnLocation(locUID)
if locUID:
self.loadingScreen.showTarget(locUID)
self.loadingScreen.showHint(locUID)
else:
locUID = '1150922126.8dzlu'
localAvatar.setReturnLocation(locUID)
self.loadingScreen.showTarget(jail=True)
self.loadingScreen.endStep('LocalAvatar')
self.loginFSM.request('playingGame')
else:
self.notify.error('Bad avatar: return code %d' % returnCode)
handleAvatarResponseMsg = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(handleAvatarResponseMsg)
def enterWaitForDeleteAvatarResponse(self, potentialAvatar):
raise StandardError, 'This should be handled within AvatarChooser.py'
enterWaitForDeleteAvatarResponse = report(
types=['args', 'deltaStamp'],
dConfigParam='teleport')(enterWaitForDeleteAvatarResponse)
def exitWaitForDeleteAvatarResponse(self):
raise StandardError, 'This should be handled within AvatarChooser.py'
exitWaitForDeleteAvatarResponse = report(
types=['args', 'deltaStamp'],
dConfigParam='teleport')(exitWaitForDeleteAvatarResponse)
def sendUpdateToGlobalDoId(self, dclassName, fieldName, doId, args):
dcfile = self.getDcFile()
dclass = dcfile.getClassByName(dclassName)
dg = dclass.clientFormatUpdate(fieldName, doId, args)
self.send(dg)
sendUpdateToGlobalDoId = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(sendUpdateToGlobalDoId)
def sendMsgToTravelAgent(self, fieldName, args):
self.sendUpdateToGlobalDoId(
'DistributedTravelAgent', fieldName,
OtpDoGlobals.OTP_DO_ID_PIRATES_TRAVEL_AGENT, args)
sendMsgToTravelAgent = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(sendMsgToTravelAgent)
def enterPlayingGame(self):
OTPClientRepository.enterPlayingGame(self)
if __dev__ and config.GetDouble('want-dev-hotkeys', 0):
def toggleKraken():
if base.localAvatar:
if base.localAvatar.ship:
messenger.send('magicWord', [
'~kraken',
base.localAvatar.getDoId(), base.localAvatar.zoneId
])
self.accept(PiratesGlobals.KrakenHotkey, toggleKraken)
def logout():
if not base.config.GetBool('location-kiosk', 0) and hasattr(
base, 'localAvatar') and localAvatar.getCanLogout():
self._userLoggingOut = True
self.gameFSM.request('closeShard', ['waitForAvatarList'])
self._userLoggingOut = False
self.accept(PiratesGlobals.LogoutHotkey, logout)
if __dev__ and config.GetDouble('want-dev-hotkeys', 0):
def deployShip():
messenger.send('magicWord', [
'~deployShip',
base.localAvatar.getDoId(), base.localAvatar.zoneId
])
self.accept(PiratesGlobals.ShipHotkey, deployShip)
if localAvatar.style.getTutorial(
) < PiratesGlobals.TUT_MET_JOLLY_ROGER and self.skipTutorial == 0:
localAvatar.teleportToType = PiratesGlobals.INSTANCE_TUTORIAL
localAvatar.teleportToName = WorldGlobals.PiratesTutorialSceneFileBase
self.sendMsgToTravelAgent('requestInitLocUD', ['unused', 0])
elif localAvatar.onWelcomeWorld and self.defaultShard != 0 and config.GetBool(
'want-welcome-worlds', 0):
localAvatar.teleportToType = PiratesGlobals.INSTANCE_WELCOME
localAvatar.teleportToName = 'Welcome World'
self.sendMsgToTravelAgent('requestInitLocUD', ['unused', 0])
else:
desiredShard = self.defaultShard
localAvatar.teleportToType = PiratesGlobals.INSTANCE_MAIN
localAvatar.teleportToName = WorldGlobals.PiratesWorldSceneFileBase
self.sendMsgToTravelAgent('requestInitLocUD',
['unused', desiredShard])
base.loadingScreen.beginStep('beginTeleport', 11, 32)
enterPlayingGame = report(types=['args', 'deltaStamp', 'module'],
dConfigParam='teleport')(enterPlayingGame)
def playingGameLocReceived(self, shardId, zoneId):
self.gameFSM.request('waitOnEnterResponses',
[shardId, zoneId, zoneId, -1])
playingGameLocReceived = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(playingGameLocReceived)
def exitPlayingGame(self):
self.notify.info('exitPlayingGame')
ivalMgr.interrupt()
self.notify.info('sending clientLogout')
messenger.send('clientLogout')
if config.GetDouble('want-dev-hotkeys', 0):
self.ignore(PiratesGlobals.KrakenHotkey)
self.ignore(PiratesGlobals.ShipHotkey)
self.ignore(PiratesGlobals.LogoutHotkey)
self.uidMgr.reset()
if self.distributedDistrict:
self.distributedDistrict.worldCreator.cleanupAllAreas()
for (doId, obj) in self.doId2do.items():
if not isinstance(obj, LocalPirate) and not isinstance(
obj, DistributedDistrict.DistributedDistrict):
if hasattr(self, 'disableObject'):
self.disableObject(doId)
hasattr(self, 'disableObject')
if hasattr(base, 'localAvatar'):
camera.reparentTo(render)
camera.setPos(0, 0, 0)
camera.setHpr(0, 0, 0)
base.transitions.noTransitions()
if self._userLoggingOut:
self.detectLeaks(okTasks=[
'physics-avatar', 'memory-monitor-task', 'multitexFlatten'
],
okEvents=[
'destroy-ToontownLoadingScreenTitle',
'destroy-ToontownLoadingScreenTip',
'destroy-ToontownLoadingScreenWaitBar', 'f12',
'f7', 'close_main_window', 'open_main_window',
PiratesGlobals.LogoutHotkey
])
OTPClientRepository.exitPlayingGame(self)
exitPlayingGame = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(exitPlayingGame)
def enterTutorialQuestion(self, hoodId, zoneId, avId):
self.__requestTutorial(hoodId, zoneId, avId)
enterTutorialQuestion = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(enterTutorialQuestion)
def handleTutorialQuestion(self, msgType, di):
if msgType == CLIENT_CREATE_OBJECT_REQUIRED:
self.handleGenerateWithRequired(di)
elif msgType == CLIENT_CREATE_OBJECT_REQUIRED_OTHER:
self.handleGenerateWithRequiredOther(di)
elif msgType == CLIENT_OBJECT_UPDATE_FIELD:
self.handleUpdateField(di)
elif msgType == CLIENT_OBJECT_DISABLE:
self.handleDisable(di)
elif msgType == CLIENT_OBJECT_DISABLE_OWNER:
self.handleDisableOwner(di)
elif msgType == CLIENT_OBJECT_DELETE_RESP:
self.handleDelete(di)
elif msgType == CLIENT_GET_AVATAR_DETAILS_RESP:
self.handleGetAvatarDetailsResp(di)
else:
self.handleUnexpectedMsgType(msgType, di)
handleTutorialQuestion = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(handleTutorialQuestion)
def exitTutorialQuestion(self):
self.handler = None
self.handlerArgs = None
self.ignore('startTutorial')
taskMgr.remove('waitingForTutorial')
exitTutorialQuestion = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(exitTutorialQuestion)
def __requestTutorial(self, hoodId, zoneId, avId):
self.acceptOnce('startTutorial', self.__handleStartTutorial, [avId])
messenger.send('requestTutorial')
__requestTutorial = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(__requestTutorial)
def __handleStartTutorial(self, avId, zoneId):
pass # TODO
def isShardInterestOpen(self):
return False # TODO: When should this return true? :(
class DistributedMainWorld(DistributedInstanceBase):
notify = directNotify.newCategory('DistributedMainWorld')
def __init__(self, cr):
DistributedInstanceBase.__init__(self, cr)
self.setName('MainWorld')
self.pvpRespawnCall = None
def disable(self):
if self.pvpRespawnCall:
self.pvpRespawnCall.destroy()
self.pvpRespawnCall = None
DistributedInstanceBase.disable(self)
def delete(self):
self.ignore('sendingLocalAvatarToJail')
DistributedInstanceBase.delete(self)
def handleOffStage(self, cacheAreas = []):
self.disableFireworkShow()
DistributedInstanceBase.handleOffStage(self, cacheAreas)
handleOffStage = report(types = [
'args'], dConfigParam = [
'dteleport'])(handleOffStage)
def handleOnStage(self):
DistributedInstanceBase.handleOnStage(self)
base.cr.timeOfDayManager.setEnvironment(TODGlobals.ENV_DEFAULT)
handleOnStage = report(types = [
'args'], dConfigParam = [
'dteleport'])(handleOnStage)
def localAvEnterDeath(self, av):
DistributedInstanceBase.localAvEnterDeath(self, av)
self.d_localAvatarDied()
if av.getSiegeTeam():
self._startPvpRespawn(PVPGlobals.MainWorldAvRespawnDelay)
localAvEnterDeath = report(types = [
'frameCount'], dConfigParam = 'jail')(localAvEnterDeath)
def _startPvpRespawn(self, delay):
self.pvpRespawnCall = DelayedCall(self._doPvpRespawn, name = 'PVPrespawn', delay = delay)
def _doPvpRespawn(self):
try:
pass
except:
return None
if hasattr(localAvatar, 'ship') and localAvatar.ship and not localAvatar.ship.isSailable():
self._startPvpRespawn(0.20000000000000001)
return None
self.hideDeathLoadingScreen(localAvatar)
localAvatar.b_setGameState('LandRoam')
def localAvExitDeath(self, av):
DistributedInstanceBase.localAvExitDeath(self, av)
localAvExitDeath = report(types = [
'frameCount'], dConfigParam = 'jail')(localAvExitDeath)
def getWorldPos(self, node):
if not node.isEmpty() and self.isOnStage():
return node.getPos(self)
def getAggroRadius(self):
return EnemyGlobals.MAX_SEARCH_RADIUS
def enableFireworkShow(self, timestamp = 0.0, showType = None):
if showType != None:
if not self.fireworkShowMgr:
self.fireworkShowMgr = FireworkShowManager()
self.fireworkShowMgr.enable(showType, timestamp)
elif base.fourthOfJuly:
if not self.fireworkShowMgr:
self.fireworkShowMgr = FireworkShowManager()
self.fireworkShowMgr.enable(FireworkShowType.FourthOfJuly, timestamp)
def disableFireworkShow(self):
if self.fireworkShowMgr:
self.fireworkShowMgr.disable()
self.fireworkShowMgr = None
if __dev__:
def printIslands(self):
for (doId, island) in self.islands.iteritems():
print doId, `island`
class QuestIndicatorNodeExtDoor(QuestIndicatorGridNode):
def __init__(self, questStep):
self.nearEffect = None
QuestIndicatorGridNode.__init__(self, 'ExtDoorIndicator', [
10,
150], questStep)
def delete(self):
QuestIndicatorGridNode.delete(self)
if self.nearEffect:
self.nearEffect.cleanUpEffect()
self.nearEffect = None
delete = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(delete)
def enterOff(self):
QuestIndicatorGridNode.enterOff(self)
self.stopNearEffect()
enterOff = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(enterOff)
def enterNear(self):
QuestIndicatorGridNode.enterNear(self)
self.startNearEffect()
def exitNear(self):
QuestIndicatorGridNode.exitNear(self)
self.stopNearEffect()
def stepObjArrived(self, stepObj):
QuestIndicatorGridNode.stepObjArrived(self, stepObj)
if self.getCurrentOrNextState() in ('Near',):
self.startNearEffect()
stepObjArrived = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(stepObjArrived)
def stepObjLeft(self):
QuestIndicatorGridNode.stepObjLeft(self)
self.stopNearEffect()
stepObjLeft = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(stepObjLeft)
def showEffect(self):
QuestIndicatorGridNode.showEffect(self)
self.startNearEffect()
showEffect = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(showEffect)
def hideEffect(self):
QuestIndicatorGridNode.hideEffect(self)
self.stopNearEffect()
hideEffect = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(hideEffect)
def startNearEffect(self):
if self.muted:
return None
if not self.nearEffect:
self.nearEffect = RayOfLight()
self.nearEffect.setBottomRayEnabled(self.wantBottomEffect)
self.nearEffect.setPos(Point3(0, 5, 0))
self.nearEffect.startLoop()
if self.stepObj:
self.nearEffect.reparentTo(self.stepObj)
startNearEffect = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(startNearEffect)
def stopNearEffect(self):
if self.nearEffect:
self.nearEffect.stopLoop()
self.nearEffect = None
stopNearEffect = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(stopNearEffect)
shipId = colEntry.getFromNodePath().getNetTag('shipId')
shipId = int(shipId)
sphereId = colEntry.getIntoNodePath().getNetTag('deploySphereId')
sphereId = int(sphereId)
self.d_shipExitedSphere(shipId, sphereId)
def handleShipEnterMinSphere(self, colEntry):
if localAvatar.ship and localAvatar.ship.steeringAvId == localAvatar.doId:
if localAvatar.guiMgr.lockInstructionMessage(self, PLocalizer.CoralReefWarning, messageCategory = MessageGlobals.MSG_CAT_SHORE_CLOSE):
self.lockedMessage = 1
handleShipEnterMinSphere = report(types = [
'frameCount',
'args'], dConfigParam = 'shipboard')(handleShipEnterMinSphere)
def handleShipExitMinSphere(self, colEntry):
if self.lockedMessage == 1:
localAvatar.guiMgr.unlockInstructionMessage(self)
self.lockedMessage = 0
handleShipExitMinSphere = report(types = [
'frameCount',
'args'], dConfigParam = 'shipboard')(handleShipExitMinSphere)
def handleShipEnterSoftBarrier(self, colEntry):
shipId = colEntry.getFromNodePath().getNetTag('shipId')
shipId = int(shipId)
class DistributedTreasureMapInstance(
DistributedInstanceWorld.DistributedInstanceWorld,
QuestHolder.QuestHolder, FSM.FSM):
notify = directNotify.newCategory('DistributedTreasureMapInstance')
def __init__(self, cr):
DistributedInstanceWorld.DistributedInstanceWorld.__init__(self, cr)
FSM.FSM.__init__(self, 'DistributedTreasureMapInstance')
QuestHolder.QuestHolder.__init__(self)
self.pendingObjectiveRequest = None
self.pendingShipRequest = None
self.objectives = []
def announceGenerate(self):
DistributedInstanceWorld.DistributedInstanceWorld.announceGenerate(
self)
base.cr.treasureMap = self
localAvatar.guiMgr.crewHUD.setTM(True)
localAvatar.guiMgr.showTMUI(self)
localAvatar.guiMgr.hideTrackedQuestInfo()
localAvatar.b_setTeleportFlag(PiratesGlobals.TFTreasureMap)
localAvatar.guiMgr.disableLookoutPanel(True)
def disable(self):
base.cr.treasureMap = None
FSM.FSM.cleanup(self)
localAvatar.guiMgr.crewHUD.setTM(False)
localAvatar.guiMgr.hideTMUI()
if localAvatar.guiMgr.crewHUD.crew:
localAvatar.guiMgr.crewHUD.leaveCrew()
localAvatar.guiMgr.crewHUD.setHUDOn()
localAvatar.guiMgr.showTrackedQuestInfo()
localAvatar.b_clearTeleportFlag(PiratesGlobals.TFTreasureMap)
localAvatar.guiMgr.disableLookoutPanel(False)
if self.pendingObjectiveRequest:
base.cr.relatedObjectMgr.abortRequest(self.pendingObjectiveRequest)
self.pendingObjectiveRequest = None
if self.pendingShipRequest:
base.cr.relatedObjectMgr.abortRequest(self.pendingShipRequest)
self.pendingShipRequest = None
DistributedInstanceWorld.DistributedInstanceWorld.disable(self)
def enterWaitClientsReady(self):
pass
def setBarrierData(self, data):
DistributedInstanceWorld.DistributedInstanceWorld.setBarrierData(
self, data)
self.doneBarrier(self.uniqueName('allAvatarsReady'))
setBarrierData = report(types=['frameCount', 'deltaStamp', 'args'],
dConfigParam='blackpearl')(setBarrierData)
def enterOff(self):
pass
def exitOff(self):
pass
def enterReward(self):
pass
def exitReward(self):
pass
def filterReward(self, request, args=[]):
if request in ['Completed']:
return self.defaultFilter(request, args)
def enterNotCompleted(self):
pass
def exitNotCompleted(self):
pass
def filterNotCompleted(self, request, args=[]):
if request in ['Completed']:
return self.defaultFilter(request, args)
def enterCompleted(self):
pass
def exitCompleted(self):
pass
def getItemList(self):
return self.getObjectives()
def getObjectives(self):
return self.objectives
def setObjectives(self, objectives):
self.objectives = []
for currObjective in objectives:
self.objectives.append({
'Type': 'ObjectId',
'Value': currObjective
})
self.pendingObjectiveRequest = base.cr.relatedObjectMgr.requestObjects(
[currObjective], eachCallback=self.tagAsObjective)
print 'got new objectives list %s' % objectives
messenger.send(self.getItemChangeMsg())
def getItemChangeMsg(self):
return self.taskName('objectiveChanged')
def tagAsObjective(self, quest):
quest.type = DistributedQuest.QUEST_TYPE_TM
def setTMComplete(self, instanceResults, playerResults):
guiMgr = base.localAvatar.guiMgr
guiMgr.hideTrays()
guiMgr.hideTMUI()
guiMgr.showTMCompleteUI(self, playerResults)
def createNewItem(self,
item,
parent,
itemType=None,
columnWidths=[],
color=None):
return MiniQuestItemGui(item, parent)
def requestTreasureMapLeave(self):
localAvatar.guiMgr.crewHUD.leaveCrew()
localAvatar.guiMgr.hideTMCompleteUI()
localAvatar.guiMgr.showTrays()
self.sendUpdate('requestLeave', [0])
def requestLeaveApproved(self, parentId, zoneId, shipId):
localAvatar.setInterest(parentId, zoneId, ['tmExit'])
self.pendingShipRequest = base.cr.relatedObjectMgr.requestObjects(
[shipId], eachCallback=self.goToShip)
def goToShip(self, pendingObj):
pendingObj.localAvatarBoardShip()
self.cr.teleportMgr.initiateTeleport(
PiratesGlobals.INSTANCE_TM, WorldGlobals.PiratesWorldSceneFileBase)
shipId = colEntry.getFromNodePath().getNetTag('shipId')
shipId = int(shipId)
sphereId = colEntry.getIntoNodePath().getNetTag('deploySphereId')
sphereId = int(sphereId)
self.d_shipExitedSphere(shipId, sphereId)
def handleShipEnterMinSphere(self, colEntry):
if localAvatar.ship and localAvatar.ship.steeringAvId == localAvatar.doId:
if localAvatar.guiMgr.lockInstructionMessage(self, PLocalizer.CoralReefWarning, messageCategory = MessageGlobals.MSG_CAT_SHORE_CLOSE):
self.lockedMessage = 1
handleShipEnterMinSphere = report(types = [
'frameCount',
'args'], dConfigParam = 'shipboard')(handleShipEnterMinSphere)
def handleShipExitMinSphere(self, colEntry):
if self.lockedMessage == 1:
localAvatar.guiMgr.unlockInstructionMessage(self)
self.lockedMessage = 0
handleShipExitMinSphere = report(types = [
'frameCount',
'args'], dConfigParam = 'shipboard')(handleShipExitMinSphere)
def handleShipEnterSoftBarrier(self, colEntry):
shipId = colEntry.getFromNodePath().getNetTag('shipId')
shipId = int(shipId)
class AnimationMixer:
__metaclass__ = MixerType
notify = DirectNotifyGlobal.directNotify.newCategory('AnimationMixer')
NA_INDEX = -1
LOOP_INDEX = 0
ACTION_INDEX = 1
LOOP = {
'NA': NA_INDEX,
'LOOP': LOOP_INDEX }
ACTION = {
'NA': NA_INDEX,
'ACTION': ACTION_INDEX }
sectionNames = [
None]
partNameLists = {
None: [] }
AnimRankings = { }
defaultBlendT = 0.14999999999999999
def __init__(self, actor):
self.actor = actor
channelCount = max(*self.ACTION.values())
channelCount = max(channelCount, *self.LOOP.values()) + 1
self.partMixers = {}
for part in self.sectionNames:
self.partMixers[part] = PartMixer(self, channelCount, actor, self.getPartsNameList(part))
self.ownedIvals = []
def __str__(self):
outStr = '(%s: %s)\n' % (self.__class__.__name__, `self.actor`)
for sectionName in self.partMixers:
outStr += '%s\n' % str(self.partMixers[sectionName])
outStr += '\nOwned Intervals\n-------------------------------\n'
for ival in self.ownedIvals:
outStr += `ival` + ': isPlaying = ' + `ival.isPlaying()` + '\n'
return outStr
def getPartsNameList(self, sectionName):
outList = []
if sectionName is None or set(sectionName) == set(self.sectionNames):
return None
elif isinstance(sectionName, types.StringType):
sectionNames = [
sectionName]
elif isinstance(sectionName, types.ListType):
sectionNames = sectionName
else:
sectionNames = []
for section in sectionNames:
partList = self.partNameLists.get(section)
if partList:
outList.extend(partList)
return outList
def getSectionList(self, sectionName):
if not sectionName:
return self.sectionNames
elif isinstance(sectionName, types.StringType):
return [
sectionName]
elif isinstance(sectionName, types.ListType):
return sectionName
else:
return []
def addIvalToOwnedList(self, ival):
self.ownedIvals = _[1]
self.ownedIvals.append(ival)
def __getPlayIval(self, newAnim, partName = None, fromFrame = None, toFrame = None, blendInT = defaultBlendT, blendOutT = defaultBlendT, duration = 0.0, blendInto = None):
sectionNames = self.getSectionList(partName)
rankings = self.AnimRankings.get(newAnim)
if rankings:
loopRanks = self.LOOP.values()
ival = Parallel()
for section in sectionNames:
rank = rankings[self.sectionNameIds[section]]
if rank in loopRanks:
pass
1
if rank > self.NA_INDEX:
pDuration = duration
partNames = self.getPartsNameList(section)
if not pDuration:
pDuration = Actor.getDuration(self.actor, newAnim, partNames, fromFrame, toFrame)
if pDuration == None:
continue
if pDuration == 0.0:
continue
playRate = Actor.getPlayRate(self.actor, newAnim, partNames)
if playRate:
pDuration /= abs(playRate)
if pDuration < blendInT + blendOutT:
blendInT = pDuration / 2
blendOutT = pDuration / 2
ival.append(self.partMixers[section].getPlayIval(rank, newAnim, pDuration, blendInT = blendInT, blendOutT = blendOutT, blendInto = blendInto))
if len(ival):
return ival
_AnimationMixer__getPlayIval = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(__getPlayIval)
def __getLoopIval(self, newAnim, rate = 1.0, partName = None, fromFrame = None, toFrame = None, blendT = defaultBlendT, blendDelay = 0):
sectionNames = self.getSectionList(partName)
rankings = self.AnimRankings.get(newAnim)
if rankings:
loopRanks = self.LOOP.values()
loopRanks.sort(reverse = True)
ival = Parallel()
for section in sectionNames:
rank = rankings[self.sectionNameIds[section]]
if rank not in loopRanks:
for loopRank in loopRanks:
if loopRank < rank:
break
continue
rank = loopRank
if rank > self.NA_INDEX:
loopIval = self.partMixers[section].getLoopIval(rank, newAnim, blendT, blendDelay)
if loopIval:
ival.append(loopIval)
if len(ival):
return ival
_AnimationMixer__getLoopIval = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(__getLoopIval)
def __getPoseIval(self, newAnim, partName = None, frame = 0, blendT = defaultBlendT):
sectionNames = self.getSectionList(partName)
rankings = self.AnimRankings.get(newAnim)
if rankings:
loopIndices = self.LOOP.values()
loopIndices.sort()
ival = Parallel()
for section in sectionNames:
rank = rankings[self.sectionNameIds[section]]
loopRank = loopIndices[0]
for loopIndex in loopIndices:
if rank >= loopIndex:
loopRank = loopIndex
continue
rank = loopRank
if rank > self.NA_INDEX:
loopIval = self.partMixers[section].getLoopIval(rank, newAnim, blendT, blendDelay = 0)
if loopIval:
ival.append(loopIval)
if len(ival):
return ival
_AnimationMixer__getPoseIval = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(__getPoseIval)
def _AnimationMixer__processActorInterval(self, actorInterval, partName, blendInT, blendOutT, blendInto):
if not isinstance(actorInterval, ActorInterval) and self.actor is not actorInterval.actor or hasattr(actorInterval, 'animMixed'):
return actorInterval
newAnim = actorInterval.animName
sectionName = self.getSectionList(partName)
partName = self.getPartsNameList(sectionName)
fromFrame = actorInterval.startFrame
toFrame = actorInterval.endFrame
duration = actorInterval.duration
ival = self._AnimationMixer__getPlayIval(newAnim, sectionName, fromFrame, toFrame, blendInT, blendOutT, duration, blendInto)
if ival:
actorInterval.resetControls(partName)
actorInterval = Parallel(ival, actorInterval)
actorInterval.animMixed = True
return actorInterval
def loop(self, newAnim, rate = 1.0, restart = True, partName = None, fromFrame = None, toFrame = None, blendT = defaultBlendT, blendDelay = 0):
ival = self._AnimationMixer__getLoopIval(newAnim, rate, partName, fromFrame, toFrame, blendT, blendDelay)
if ival:
partName = self.getPartsNameList(self.getSectionList(partName))
self.actor.setPlayRate(rate, newAnim, partName)
Actor.loop(self.actor, newAnim, restart = restart, partName = partName, fromFrame = fromFrame, toFrame = toFrame)
ival.start()
ival.setT(0.01)
self.addIvalToOwnedList(ival)
loop = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(loop)
def play(self, newAnim, partName = None, fromFrame = None, toFrame = None, blendInT = defaultBlendT, blendOutT = defaultBlendT, blendInto = None):
partNames = self.getPartsNameList(self.getSectionList(partName))
ival = self._AnimationMixer__getPlayIval(newAnim, partName, fromFrame, toFrame, blendInT, blendOutT, blendInto = blendInto)
if ival:
Actor.play(self.actor, newAnim, partName = partNames, fromFrame = fromFrame, toFrame = toFrame)
ival.start()
ival.setT(0.01)
self.addIvalToOwnedList(ival)
play = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(play)
def pingpong(self, newAnim, rate = 1.0, partName = None, fromFrame = None, toFrame = None, blendT = defaultBlendT):
ival = self._AnimationMixer__getLoopIval(newAnim, rate, partName, fromFrame, toFrame, blendT)
if ival:
partName = self.getPartsNameList(self.getSectionList(partName))
self.actor.setPlayRate(rate, newAnim, partName)
Actor.pingpong(self.actor, newAnim, partName = partName, fromFrame = fromFrame, toFrame = toFrame)
ival.start()
ival.setT(0.01)
self.addIvalToOwnedList(ival)
pingpong = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(pingpong)
def pose(self, newAnim, frame, partName = None, blendT = defaultBlendT):
ival = self._AnimationMixer__getPoseIval(newAnim, partName, frame, blendT)
if ival:
partName = self.getPartsNameList(self.getSectionList(partName))
Actor.pose(self.actor, newAnim, frame = frame, partName = partName)
ival.start()
ival.setT(0.01)
self.addIvalToOwnedList(ival)
pose = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(pose)
def actorInterval(self, actorInterval, partName, blendInT = defaultBlendT, blendOutT = defaultBlendT, blendInto = None):
return self._AnimationMixer__processActorInterval(actorInterval, partName, blendInT, blendOutT, blendInto)
actorInterval = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(actorInterval)
def stop(self, animName = None, partName = None):
Actor.stop(self.actor, animName, partName)
stop = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(stop)
def cleanup(self):
for ival in self.ownedIvals:
ival.finish()
self.ownedIvals = []
for sectionName in self.partMixers:
self.partMixers[sectionName].cleanup()
Actor.stop(self.actor)
Actor.setControlEffect(self.actor, None, 0.0)
cleanup = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(cleanup)
def delete(self):
self.cleanup()
for sectionName in self.partMixers:
self.partMixers[sectionName].delete()
self.actor = None
self.partMixers = { }
class DistributedTeleportMgr(DistributedObject.DistributedObject):
notify = directNotify.newCategory('DistributedTeleportMgr')
def __init__(self, cr):
DistributedObject.DistributedObject.__init__(self, cr)
self.instanceType = None
self.fromInstanceType = None
self.lastLocalTeleportLoc = None
self.teleportQueryId = None
self.inInstanceType = PiratesGlobals.INSTANCE_MAIN
self.instanceName = WorldGlobals.PiratesWorldSceneFileBase
self.doneCallback = None
self.startedCallback = None
self.oldWorld = None
self.requestData = None
self.localTeleportId = None
self.localTeleportingObj = None
self.localTeleportCallback = None
self.localTeleportDestPos = None
self.popupDialog = None
self.doEffect = False
self.stowawayEffect = False
self.miniLog = None
self.teleportQueue = []
self.teleportQueueProcess = None
def generate(self):
DistributedObject.DistributedObject.generate(self)
base.cr.teleportMgr = self
def requestTeleportToFishingShip(self):
self.cr.teleportMgr.sendUpdate('requestTeleportToFishingShip')
def requestTeleportToFishingShip(self):
self.cr.teleportMgr.sendUpdate('requestTeleportToFishingShip')
def localTeleportToId(self,
locationId,
teleportingObj=None,
destPos=None,
callback=None,
objectLocation=None,
showLoadingScreen=True):
if showLoadingScreen:
self.cr.loadingScreen.show(waitForLocation=True)
if locationId in base.cr.doId2do and base.cr.doId2do[
locationId].dclass.getName() == 'DistributedOceanGrid':
logBlock(
1, 'localTeleportToId(%s,%s,%s,%s,%s,%s) to ocean grid\n\n' %
(locationId, teleportingObj, destPos, callback, objectLocation,
showLoadingScreen) + str(StackTrace()))
self.localTeleportId = locationId
self.localTeleportingObj = teleportingObj
self.localTeleportCallback = callback
self.localTeleportDestPos = destPos
destObj = self.cr.doId2do.get(locationId)
if destObj:
self._localTeleportToIdInterestComplete()
self.notify.debug(
'destination object %s found, teleporting to there now' %
locationId)
elif objectLocation:
self._localTeleportToIdResponse(objectLocation[0],
objectLocation[1])
self.notify.debug(
'destination object %s not found, but location %s given' %
(locationId, objectLocation))
else:
self.sendUpdate('requestTargetsLocation', [int(locationId)])
self.notify.debug(
'destination object %s not found, querying AI for its location'
% locationId)
localTeleportToId = report(types=['args', 'deltaStamp'],
dConfigParam=['teleport', 'shipboardreport'
])(localTeleportToId)
def _localTeleportToIdResponse(self, parentId, zoneId):
if parentId != 0 and zoneId != 0:
if self.cr.doId2do.get(parentId):
localAvatar.setInterest(
parentId, zoneId, ['localTeleportToId'],
'localTeleportToIdInterestAddComplete')
self.acceptOnce('localTeleportToIdInterestAddComplete',
self._localTeleportToIdInterestComplete)
self.notify.debug(
'parent %s of destination object found, setting up interest'
% parentId)
else:
self.notify.warning(
'parent %s of destination object not found, teleport failure'
% parentId)
else:
self.failTeleport(parentId, zoneId)
_localTeleportToIdResponse = report(
types=['args', 'deltaStamp'],
dConfigParam=['teleport',
'shipboardreport'])(_localTeleportToIdResponse)
def failTeleport(self,
parentId=None,
zoneId=None,
message=PLocalizer.TeleportToPlayerFailMessage):
self.sendUpdate('requestClearPreventDamage')
fallbackAreaId = localAvatar.getReturnLocation()
if fallbackAreaId != '':
areaDoId = base.cr.uidMgr.getDoId(fallbackAreaId)
self.clearAmInTeleport()
if areaDoId:
destPos = base.cr.activeWorld.getPlayerSpawnPt(areaDoId)
if destPos and self.localTeleportingObj:
self.localTeleportToId(areaDoId, self.localTeleportingObj,
destPos)
else:
self.initiateTeleport(
PiratesGlobals.INSTANCE_MAIN,
WorldGlobals.PiratesWorldSceneFileBase,
doEffect=False)
else:
self.initiateTeleport(PiratesGlobals.INSTANCE_MAIN,
WorldGlobals.PiratesWorldSceneFileBase,
doEffect=False)
self._DistributedTeleportMgr__createDialog(message)
else:
self.notify.warning(
" teleport to object (%s %s) AND 'return location' %s failed"
% (parentId, zoneId, fallbackAreaId))
def failTeleportRequest(self, reasonBit):
if reasonBit >= 0:
localAvatar.guiMgr.createWarning(
PiratesGlobals.TFNoTeleportReasons.get(
BitMask32.bit(reasonBit),
PLocalizer.TeleportGenericFailMessage))
else:
self._DistributedTeleportMgr__createDialog(
PLocalizer.TeleportToPlayerFailMessage)
def _DistributedTeleportMgr__cleanupDialog(self, value=None):
if self.popupDialog:
self.popupDialog.destroy()
del self.popupDialog
self.popupDialog = None
def _DistributedTeleportMgr__createDialog(self, message):
if message:
popupDialogText = message
if self.popupDialog:
self._DistributedTeleportMgr__cleanupDialog()
self.popupDialog = PDialog.PDialog(
text=popupDialogText,
style=OTPDialog.Acknowledge,
command=self._DistributedTeleportMgr__cleanupDialog)
def _localTeleportToIdDone(self):
self.cr.loadingScreen.scheduleHide(
base.cr.getAllInterestsCompleteEvent())
curParent = localAvatar.getParentObj()
if isinstance(curParent, ZoneLOD.ZoneLOD):
localAvatar.enterZoneLOD(curParent)
if self.localTeleportCallback:
self.localTeleportCallback()
self.localTeleportId = None
self.localTeleportingObj = None
self.localTeleportCallback = None
self.localTeleportDestPos = None
localAvatar.guiMgr.socialPanel.updateAll()
_localTeleportToIdDone = report(
types=['args', 'deltaStamp'],
dConfigParam=['teleport', 'shipboardreport'])(_localTeleportToIdDone)
def disable(self):
DistributedObject.DistributedObject.disable(self)
messenger.send('destroyCrewMatchInvite')
taskMgr.removeTasksMatching('teleportRemoveInterest')
taskMgr.removeTasksMatching('teleportAddInterest')
taskMgr.removeTasksMatching(self.uniqueName('localTeleportPos'))
taskMgr.removeTasksMatching(self.uniqueName('fadeDone'))
self.requestData = None
self.ignoreAll()
if base.cr.teleportMgr == self:
base.cr.teleportMgr = None
requestData = self.requestData
self.requestData = None
if self.teleportQueueProcess:
taskMgr.remove(self.teleportQueueProcess)
def requestTeleport(self,
instanceType,
instanceName,
shardId=0,
locationUid='',
instanceDoId=0,
doneCallback=None,
startedCallback=None,
gameType=-1,
friendDoId=0,
friendAreaDoId=0,
doEffect=True):
self.requestData = ((instanceType, instanceName), {
'shardId': shardId,
'locationUid': locationUid,
'instanceDoId': instanceDoId,
'doneCallback': doneCallback,
'startedCallback': startedCallback,
'gameType': gameType,
'friendDoId': friendDoId,
'friendAreaDoId': friendAreaDoId,
'doEffect': doEffect
})
localAvatar.confirmTeleport(self.teleportConfirmation, feedback=True)
requestTeleport = report(types=['args', 'deltaStamp'],
dConfigParam=['teleport'])(requestTeleport)
def teleportConfirmation(self, confirmed):
if confirmed:
requestData = self.requestData
self.initiateTeleport(*requestData[0], **requestData[0])
locationUid = requestData[1]['locationUid']
base.cr.loadingScreen.showTarget(locationUid)
base.cr.loadingScreen.showHint(locationUid)
self.requestData = None
def requestTeleportToAvatar(self, shardId, instanceDoId, avatarId,
avatarParentId):
self.requestTeleport(PiratesGlobals.INSTANCE_MAIN,
'',
shardId,
'',
instanceDoId,
friendDoId=avatarId,
friendAreaDoId=avatarParentId)
requestTeleportToAvatar = report(types=['args', 'deltaStamp'],
dConfigParam=['teleport'
])(requestTeleportToAvatar)
def queryAvatarForTeleport(self, avId):
self.setTeleportQueryId(avId)
def teleportConfirmation(confirmed, avId=avId):
if confirmed:
handle = self.cr.identifyAvatar(avId)
if handle:
shardId = self.cr.distributedDistrict.doId
if not localAvatar.getBandId():
pass
(bandMgr, bandId) = (0, 0)
guildId = localAvatar.getGuildId()
handle.sendTeleportQuery(avId, bandMgr, bandId, guildId,
shardId)
teleportConfirmation = report(
types=['args', 'deltaStamp'],
dConfigParam='teleport')(teleportConfirmation)
localAvatar.confirmTeleport(teleportConfirmation, feedback=True)
queryAvatarForTeleport = report(types=['args', 'deltaStamp'],
dConfigParam=['teleport'
])(queryAvatarForTeleport)
def handleAvatarTeleportQuery(self, requesterId, requesterBandMgrId,
requesterBandId, requesterGuildId,
requesterShardId):
handle = self.cr.identifyAvatar(requesterId)
if not handle:
return None
if self.cr.identifyFriend(requesterId):
if requesterId in localAvatar.ignoreList or self.cr.avatarFriendsManager.checkIgnored(
requesterId):
handle.sendTeleportResponse(PiratesGlobals.encodeTeleportFlag(
PiratesGlobals.TFIgnore),
0,
0,
0,
sendToId=requesterId)
return None
if localAvatar.ship and len(
localAvatar.ship.crew) >= localAvatar.ship.getMaxCrew():
handle.sendTeleportResponse(PiratesGlobals.encodeTeleportFlag(
PiratesGlobals.TFOnShip),
0,
0,
0,
sendToId=requesterId)
return None
avName = handle.getName()
def confirmed(canTeleportTo, avId, failedFlag, avName=avName):
if canTeleportTo:
if self.cr.getActiveWorld(
) and self.cr.distributedDistrict and localAvatar.getParentObj(
):
handle.sendTeleportResponse(
PiratesGlobals.TAAvailable,
self.cr.distributedDistrict.doId,
self.cr.getActiveWorld().doId,
localAvatar.getParentObj().doId,
sendToId=requesterId)
else:
handle.sendTeleportResponse(
PiratesGlobals.encodeTeleportFlag(
PiratesGlobals.TFUnavailable),
0,
0,
0,
sendToId=requesterId)
elif localAvatar.failedTeleportMessageOk(requesterId):
localAvatar.setSystemMessage(
requesterId, OTPLocalizer.WhisperFailedVisit % avName)
handle.sendTeleportResponse(
PiratesGlobals.encodeTeleportFlag(failedFlag),
0,
0,
0,
sendToId=requesterId)
confirmed = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(confirmed)
localAvatar.confirmTeleportTo(confirmed, requesterId, avName,
requesterBandMgrId, requesterBandId,
requesterGuildId)
handleAvatarTeleportQuery = report(
types=['args', 'deltaStamp'],
dConfigParam='teleport')(handleAvatarTeleportQuery)
def handleAvatarTeleportResponse(self, avId, available, shardId,
instanceDoId, areaDoId):
if not avId == self.teleportQueryId:
self.clearTeleportQueryId()
return None
self.clearTeleportQueryId()
handle = self.cr.identifyAvatar(avId)
if handle:
avName = handle.getName()
else:
return None
if available == PiratesGlobals.TAAvailable:
self.requestTeleportToAvatar(shardId,
instanceDoId,
avatarId=avId,
avatarParentId=areaDoId)
else:
flag = PiratesGlobals.decodeTeleportFlag(available)
if flag == PiratesGlobals.TAIgnore:
pass
1
if flag in PiratesGlobals.TFNoTeleportToReasons:
localAvatar.guiMgr.createWarning(
PiratesGlobals.TFNoTeleportToReasons[flag] % avName,
duration=10)
handleAvatarTeleportResponse = report(
types=['args', 'deltaStamp'],
dConfigParam=['teleport'])(handleAvatarTeleportResponse)
def initiateTeleport(self,
instanceType,
instanceName,
shardId=0,
locationUid='',
instanceDoId=0,
doneCallback=None,
startedCallback=None,
gameType=-1,
friendDoId=0,
friendAreaDoId=0,
doEffect=True,
queue=False,
stowawayEffect=False):
if friendDoId:
self.d_requestPlayerTeleport(friendDoId, shardId)
elif instanceName == '':
self.notify.error(
'cannot perform this teleport without instanceName')
self.d_requestInstanceTeleport(instanceType, instanceName)
return None
currInteractive = base.cr.interactionMgr.getCurrentInteractive()
if currInteractive:
currInteractive.requestExit()
if self.cr.activeWorld:
fromInstanceType = self.cr.activeWorld.getType()
else:
fromInstanceType = PiratesGlobals.INSTANCE_NONE
if instanceType not in [
PiratesGlobals.INSTANCE_MAIN, PiratesGlobals.INSTANCE_WELCOME
] and fromInstanceType not in [
PiratesGlobals.INSTANCE_MAIN, PiratesGlobals.INSTANCE_GENERIC,
PiratesGlobals.INSTANCE_NONE
]:
if not base.config.GetBool('can-break-teleport-rules', 0):
import pdb as pdb
pdb.set_trace()
return None
if self.amInTeleport():
if queue:
self.queueInitiateTeleport(instanceType, instanceName, shardId,
locationUid, instanceDoId,
doneCallback, startedCallback,
gameType, friendDoId,
friendAreaDoId, doEffect,
stowawayEffect)
return None
return None
self.setAmInTeleport()
if instanceType == PiratesGlobals.INSTANCE_MAIN and not locationUid:
locationUid = localAvatar.getReturnLocation()
localAvatar.teleportFriendDoId = friendDoId
self.doEffect = doEffect
self.stowawayEffect = stowawayEffect
self.sendUpdate('initiateTeleport', [
instanceType, fromInstanceType, shardId, locationUid, instanceDoId,
instanceName, gameType, friendDoId, friendAreaDoId
])
self.doneCallback = doneCallback
self.startedCallback = startedCallback
self.teleportInit(instanceType, fromInstanceType, instanceName)
initiateTeleport = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(initiateTeleport)
def queueInitiateTeleport(self,
instanceType,
instanceName,
shardId=0,
locationUid='',
instanceDoId=0,
doneCallback=None,
startedCallback=None,
gameType=-1,
friendDoId=0,
friendAreaDoId=0,
doEffect=True,
stowawayEffect=False):
teleInfo = [
instanceType, instanceName, shardId, locationUid, instanceDoId,
doneCallback, startedCallback, gameType, friendDoId,
friendAreaDoId, doEffect, stowawayEffect
]
self.teleportQueue.append(teleInfo)
def processTeleportQueue(task=None):
if self.amInTeleport():
return Task.again
if not self.teleportQueue:
return Task.done
teleportInfo = self.teleportQueue.pop(0)
self.initiateTeleport(*teleportInfo)
if self.teleportQueue:
return Task.again
return Task.done
self.teleportQueueProcess = taskMgr.doMethodLater(
1, processTeleportQueue, 'processTeleportQueue')
def amInTeleport(self):
return localAvatar.testTeleportFlag(PiratesGlobals.TFInTeleport)
def setAmInTeleport(self):
localAvatar.b_setTeleportFlag(PiratesGlobals.TFInTeleport)
localAvatar.b_clearTeleportFlag(PiratesGlobals.TFLookoutJoined)
def clearAmInTeleport(self):
localAvatar.clearTeleportFlag(PiratesGlobals.TFInInitTeleport)
localAvatar.b_clearTeleportFlag(PiratesGlobals.TFInTeleport)
def setTeleportQueryId(self, avId):
self.teleportQueryId = avId
setTeleportQueryId = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(setTeleportQueryId)
def clearTeleportQueryId(self):
self.teleportQueryId = 0
clearTeleportQueryId = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(clearTeleportQueryId)
def initiateTeleportAI(self, instanceType, instanceName):
self.teleportInit(instanceType, instanceName)
initiateTeleportAI = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(initiateTeleportAI)
def teleportInit(self,
instanceType,
fromInstanceType,
instanceName,
gameType=None):
self.clearTeleportQueryId()
self.oldWorld = base.cr.activeWorld
self.instanceType = instanceType
self.fromInstanceType = fromInstanceType
self.instanceName = instanceName
self.gameType = gameType
self.miniLog = MiniLog('TeleportLog')
MiniLogSentry(self.miniLog, 'teleportInit', instanceType,
fromInstanceType, instanceName, gameType)
teleportInit = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(teleportInit)
def teleportHasBegun(self, instanceType, fromInstanceType, instanceName,
gameType):
if not self.miniLog:
self.miniLog = MiniLog('TeleportLog')
s = MiniLogSentry(self.miniLog, 'teleportHasBegun', instanceType,
fromInstanceType, instanceName, gameType)
if self.startedCallback:
self.startedCallback()
self.startedCallback = None
if self.oldWorld == None or self.oldWorld.isEmpty():
self.teleportInit(instanceType, fromInstanceType, instanceName,
gameType)
teleportHasBegun = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(teleportHasBegun)
def getRemoveInterestEventName(self):
return self.uniqueName('teleportRemoveInterest')
def getAddInterestEventName(self):
return self.uniqueName('teleportAddInterest')
def forceTeleportStart(self, instanceName, tzDoId, thDoId, worldGridDoId,
tzParent, tzZone):
s = MiniLogSentry(self.miniLog, 'forceTeleportStart', instanceName,
tzDoId, thDoId, worldGridDoId, tzParent, tzZone)
self.setAmInTeleport()
localAvatar.guiMgr.request('Cutscene')
if not base.transitions.fadeOutActive():
base.transitions.fadeOut()
if self.fromInstanceType == PiratesGlobals.INSTANCE_MAIN:
self.inInstanceType = PiratesGlobals.INSTANCE_MAIN
else:
self.inInstanceType = self.instanceType
if self.fromInstanceType == PiratesGlobals.INSTANCE_PVP:
localAvatar.clearTeleportFlag(PiratesGlobals.TFInPVP)
elif self.fromInstanceType == PiratesGlobals.INSTANCE_TUTORIAL:
localAvatar.clearTeleportFlag(PiratesGlobals.TFInTutorial)
def fadeDone():
base.cr.loadingScreen.show()
s = MiniLogSentry(self.miniLog, 'fadeDone')
curParent = localAvatar.getParentObj()
parentIsZoneLOD = isinstance(curParent, ZoneLOD.ZoneLOD)
if parentIsZoneLOD:
localAvatar.leaveZoneLOD(curParent)
curParent.turnOff()
if self.cr.doId2do.get(tzParent) == None:
self.failTeleport(None, None,
PLocalizer.TeleportGenericFailMessage)
else:
self.teleportAddInterestTZ(instanceName, tzDoId, thDoId,
worldGridDoId, tzParent, tzZone)
localAvatar.guiMgr.request('Interactive')
taskMgr.removeTasksMatching(self.uniqueName('fadeDone'))
taskMgr.doMethodLater(1,
fadeDone,
self.uniqueName('fadeDone'),
extraArgs=[])
forceTeleportStart = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(forceTeleportStart)
def teleportAddInterestTZ(self, instanceName, tzDoId, thDoId,
worldGridDoId, tzParent, tzZone):
s = MiniLogSentry(self.miniLog, 'teleportAddInterestTZ', instanceName,
tzDoId, thDoId, worldGridDoId, tzParent, tzZone)
addEvent = self.getAddInterestEventName()
self.accept(addEvent,
self.teleportAddInterestCompleteTZ,
extraArgs=[tzDoId, thDoId, worldGridDoId])
localAvatar.setInterest(tzParent, tzZone, ['TZInterest'], addEvent)
self.instanceName = instanceName
def requestRespawn(self):
self.sendUpdate('requestLocalTeleport')
def teleportAddInterestCompleteTZ(self, tzDoId, thDoId, worldGridDoId):
s = MiniLogSentry(self.miniLog, 'teleportAddInterestCompleteTZ',
tzDoId, thDoId, worldGridDoId)
base.cr.relatedObjectMgr.requestObjects(
[tzDoId],
eachCallback=lambda param1, param2=thDoId: self.teleportZoneExists(
param1, param2))
teleportAddInterestCompleteTZ = report(
types=['args', 'deltaStamp'],
dConfigParam='teleport')(teleportAddInterestCompleteTZ)
def teleportZoneExists(self, teleportZone, thDoId):
s = MiniLogSentry(self.miniLog, 'teleportZoneExists', teleportZone,
thDoId)
base.cr.relatedObjectMgr.requestObjects(
[thDoId],
eachCallback=lambda param1, param2=teleportZone: self.
teleportHandlerExists(param1, param2))
teleportZoneExists = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(teleportZoneExists)
def teleportHandlerExists(self, teleportHandler, teleportZone):
s = MiniLogSentry(self.miniLog, 'teleportHandlerExists',
teleportHandler, teleportZone)
teleportHandler.instanceName = self.instanceName
teleportHandler.instanceType = self.instanceType
teleportHandler.doneCallback = self.doneCallback
self.doneCallback = None
teleportHandler.oldWorld = self.oldWorld
self.oldWorld = None
teleportHandler.miniLog = self.miniLog
self.miniLog = None
teleportHandler.startTeleport()
teleportHandlerExists = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(teleportHandlerExists)
def createSpawnInterests(self, parents, callback, destGrid,
teleportingObj):
s = MiniLogSentry(self.miniLog, 'createSpawnInterests', parents,
callback.__name__, destGrid, teleportingObj)
parentsLen = len(parents)
if self.miniLog:
self.miniLog.appendLine('parents - %s' % (parents, ))
self.miniLog.appendLine('destGrid - %s' % (destGrid, ))
if parentsLen == 0:
logBlock(2, self.miniLog)
callback(destGrid, teleportingObj)
else:
parentObj = base.cr.doId2do.get(parents[0])
if parentObj:
callback(parentObj, teleportingObj)
elif parentsLen > 2 and base.cr.doId2do.has_key(parents[2]):
base.cr.relatedObjectMgr.requestObjects(
[parents[0]],
eachCallback=lambda param1=None, param2=teleportingObj:
callback(param1, param2))
localAvatar.setInterest(parents[2], parents[1],
['instanceInterest'])
elif parentsLen > 2:
parentParentId = parents[2]
parentParentZone = parents[1]
else:
parentParentId = '<None Given>'
parentParentZone = '<None Given>'
parentId = parents[0]
self.notify.warning(
('createSpawnInterests: parent %s of parent %s in zone %s ' +
'does not exist locally, aborting teleport') %
(parentParentId, parentId, parentParentZone))
self.failTeleport(None, None,
PLocalizer.TeleportGenericFailMessage)
createSpawnInterests = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(createSpawnInterests)
def initiateCrossShardDeploy(self,
shardId=0,
islandUid='',
shipId=0,
doneCallback=None,
startedCallback=None,
doEffect=True):
if not islandUid or not shipId:
return None
currInteractive = base.cr.interactionMgr.getCurrentInteractive()
if currInteractive:
currInteractive.requestExit()
if self.cr.activeWorld:
fromInstanceType = self.cr.activeWorld.getType()
else:
fromInstanceType = PiratesGlobals.INSTANCE_NONE
if self.amInTeleport():
return None
self.setAmInTeleport()
self.doEffect = doEffect
self.sendUpdate('requestCrossShardDeploy',
[shardId, islandUid, shipId])
self.doneCallback = doneCallback
self.startedCallback = startedCallback
self.teleportInit(PiratesGlobals.INSTANCE_MAIN, fromInstanceType,
'Main World')
def d_requestShardTeleport(self, shardId, skipConfirm=False):
def teleportConfirmation(confirmed):
if confirmed:
self.sendUpdate('requestShardTeleport', [shardId])
if skipConfirm:
teleportConfirmation(True)
else:
localAvatar.confirmTeleport(teleportConfirmation, feedback=True)
def d_requestPlayerTeleport(self, targetAvId, shardId, skipConfirm=False):
def teleportConfirmation(confirmed):
if confirmed:
self.sendUpdate('requestPlayerTeleport', [targetAvId, shardId])
if skipConfirm:
teleportConfirmation(True)
else:
localAvatar.confirmTeleport(teleportConfirmation, feedback=True)
def d_requestIslandTeleport(self, islandUid, skipConfirm=False):
def teleportConfirmation(confirmed):
if confirmed:
self.sendUpdate('requestIslandTeleport', [islandUid])
if skipConfirm:
teleportConfirmation(True)
else:
localAvatar.confirmTeleport(teleportConfirmation, feedback=True)
def d_requestInstanceTeleport(self,
instanceType,
instanceName,
skipConfirm=False):
def teleportConfirmation(confirmed):
if confirmed:
self.sendUpdate('requestInstanceTeleport',
[instanceType, instanceName])
if skipConfirm:
teleportConfirmation(True)
else:
localAvatar.confirmTeleport(teleportConfirmation, feedback=True)
def notifyFriendVisit(self, avId):
av = base.cr.identifyAvatar(avId)
if av:
avName = av.getName()
else:
avName = PLocalizer.Someone
localAvatar.setSystemMessage(
avId, OTPLocalizer.WhisperComingToVisit % avName)
localAvatar.guiMgr.messageStack.addTextMessage(
OTPLocalizer.WhisperComingToVisit % avName, icon=('friends', None))
class DistributedGAInterior(DistributedGameArea, DistributedCartesianGrid, MappableGrid):
notify = directNotify.newCategory('DistributedGAInterior')
def __init__(self, cr):
DistributedGameArea.__init__(self, cr)
DistributedCartesianGrid.__init__(self, cr)
MappableGrid.__init__(self)
self.intervals = []
self.fadeInTrack = None
self.autoFadeIn = True
self.musicName = None
def announceGenerate(self):
DistributedGameArea.announceGenerate(self)
DistributedCartesianGrid.announceGenerate(self)
self.getParentObj().setWorldGrid(self)
self.loadModel()
for obj in self.geom.findAllMatches('**/=ignore-lighting'):
obj.setLightOff(1000)
doorPlanes = self.geom.findAllMatches('**/door_collision_planar_*;+s')
doorPlanes.stash()
base.worldCreator.registerSpecialNodes(self, self.uniqueId)
self.builder.loadObjects()
self.enableFloors()
self.initBlockers(self)
self.startCustomEffects()
self.builder.resumeSFX()
self.closeSfx = loadSfx(SoundGlobals.SFX_DOOR_SLAM)
def disable(self):
self.stopCustomEffects()
self.builder.pauseSFX()
self.unloadConnectors()
if self.fadeInTrack:
self.fadeInTrack.pause()
self.fadeInTrack = None
self.ignoreAll()
DistributedGameArea.disable(self)
DistributedCartesianGrid.disable(self)
del self.closeSfx
def delete(self):
del self.coll
self.geom.removeNode()
if self.modelPath != 'models/buildings/navy_jail_interior':
self.handleExitGameArea(None)
self.fadeOutSoundAndMusic()
self.disableFloors()
for anim in self.intervals:
if anim:
anim.pause()
del anim
continue
self.intervals = []
DistributedGameArea.delete(self)
DistributedCartesianGrid.delete(self)
def isGrid(self):
return DistributedCartesianGrid.isGrid(self)
def setConnectorId(self, connectorId):
self.connectorId = connectorId
setConnectorId = report(types = [
'frameCount',
'args'], dConfigParam = [
'jail',
'teleport'])(setConnectorId)
def enableFloors(self):
return None
floorName = 'floor_interior'
self.uniqueFloorName = self.uniqueName(floorName)
collNodes = self.findAllMatches('**/+CollisionNode')
for collNode in collNodes:
curMask = collNode.node().getIntoCollideMask()
if curMask.hasBitsInCommon(PiratesGlobals.FloorBitmask):
collNode.setName(self.uniqueFloorName)
self.setupCannonballLandColl(collNode, PiratesGlobals.TargetBitmask | curMask, 0)
continue
self.accept('enterFloor' + self.uniqueFloorName, self.handleEnterGameArea)
self.accept('exitFloor' + self.uniqueFloorName, self.handleExitGameArea)
def disableFloors(self):
return None
if self.uniqueFloorName:
self.ignore('enterFloor' + self.uniqueFloorName)
self.ignore('exitFloor' + self.uniqueFloorName)
def handleEnterGameArea(self, collEntry = None):
self.setupMinimap()
if self.minimap and localAvatar.getMinimapObject():
self.minimap.addObject(localAvatar.getMinimapObject())
localAvatar.guiMgr.setMinimap(self.minimap)
DistributedGameArea.handleEnterGameArea(self, collEntry)
handleEnterGameArea = report(types = [
'frameCount'], dConfigParam = ('jail', 'minimap'))(handleEnterGameArea)
def setLocation(self, parentId, zoneId):
DistributedGameArea.setLocation(self, parentId, zoneId)
def handleExitGameArea(self, collEntry):
if collEntry:
return None
DistributedGameArea.handleExitGameArea(self, collEntry)
handleExitGameArea = report(types = [
'frameCount',
'args'], dConfigParam = ('jail', 'minimap'))(handleExitGameArea)
def loadModelParts(self):
if self.modelPath.startswith('models/islands/pir_m_are_isl_'):
self.geom = loader.loadModel(self.modelPath)
return None
modelBaseName = self.modelPath.split('_zero')[0]
terrainModel = loader.loadModel(modelBaseName + '_terrain', okMissing = True)
if terrainModel:
self.geom = terrainModel
else:
self.geom = loader.loadModel(self.modelPath)
return None
terrainDetailModel = loader.loadModel(modelBaseName + '_terrain_detail', okMissing = True)
if terrainDetailModel:
self.notify.debug('loading _terrain_detail')
terrainDetailModel.getChild(0).reparentTo(self.geom)
pierModel = loader.loadModel(modelBaseName + 'pier', okMissing = True)
if pierModel:
self.notify.debug('loading pier')
pierModel.getChild(0).reparentTo(self.geom)
fortModel = loader.loadModel(modelBaseName + '_fort', okMissing = True)
if fortModel:
self.notify.debug('loading _fort')
fortModel.getChild(0).reparentTo(self.geom)
logModel = loader.loadModel(modelBaseName + '_logs', okMissing = True)
if logModel:
self.notify.debug('loading _logs')
logModel.getChild(0).reparentTo(self.geom)
vegeWallModel = loader.loadModel(modelBaseName + '_nat_wall', okMissing = True)
if vegeWallModel:
self.notify.debug('loading _nat_wall')
vegeWallModel.getChild(0).reparentTo(self.geom)
vegModel = loader.loadModel(modelBaseName + '_veg', okMissing = True)
if vegModel:
self.notify.debug('loading _veg')
vegModel.getChild(0).reparentTo(self.geom)
rockModel = loader.loadModel(modelBaseName + '_rocks', okMissing = True)
if rockModel:
self.notify.debug('loading _rocks')
rockModel.getChild(0).reparentTo(self.geom)
mapNode = self.getMapNode()
if mapNode and not mapNode.isEmpty():
mapNode.hide()
def loadModel(self):
if 'interior' not in self.modelPath:
self.loadModelParts()
else:
self.geom = loader.loadModel(self.modelPath)
self.geom.findAllMatches('**/door_hole*').setColorScale(Vec4(0, 0, 0, 1))
self.geom.reparentTo(self)
self.geom.hide(OTPRender.MainCameraBitmask)
self.geom.showThrough(OTPRender.EnviroCameraBitmask)
coll = self.geom.findAllMatches('**/+CollisionNode')
self.coll = coll
locatorNodes = self.geom.findAllMatches('**/portal_interior_*')
locatorNodes.wrtReparentTo(self)
self.locatorNodes = locatorNodes
self.portalNodes = self.geom.findAllMatches('**/portal_[0-9]')
self.initBlockers(self.geom)
def setName(self, name):
self.name = name
def getTeam(self):
return PiratesGlobals.ISLAND_TEAM
def updateAvReturnLocation(self, av):
av.d_requestReturnLocation(self.doId)
updateAvReturnLocation = report(types = [
'frameCount'], dConfigParam = 'jail')(updateAvReturnLocation)
def enterInteriorFromDoor(self, doorIndex):
base.cr.loadingScreen.showTarget(self.uniqueId)
base.cr.loadingScreen.show()
doorIndexStr = ''
if doorIndex > 0:
doorIndexStr = '_' + str(doorIndex + 1)
self.doorLeftStr = '**/door_left' + doorIndexStr
self.doorRightStr = '**/door_right' + doorIndexStr
self.doorLocatorStr = '**/door_locator' + doorIndexStr
doorLeft = self.geom.find(self.doorLeftStr)
doorRight = self.geom.find(self.doorRightStr)
self.openDoorIval = Parallel()
self.closeDoorIval = Parallel()
self.tOpen = 0.5
if doorLeft:
self.openDoorIval.append(LerpHprInterval(doorLeft, self.tOpen, Vec3(-90, 0, 0)))
self.closeDoorIval.append(LerpHprInterval(doorLeft, self.tOpen, Vec3(0, 0, 0)))
if doorRight:
self.openDoorIval.append(LerpHprInterval(doorRight, self.tOpen, Vec3(90, 0, 0)))
self.closeDoorIval.append(LerpHprInterval(doorRight, self.tOpen, Vec3(0, 0, 0)))
doorLocator = self.geom.find(self.doorLocatorStr)
if doorLocator.isEmpty():
doorLocator = self.geom.find(self.doorLeftStr)
if doorLocator.isEmpty():
doorLocator = self.geom.find(self.doorRightStr)
localAvatar.reparentTo(doorLocator)
localAvatar.setPos(0, 10, 0)
localAvatar.setHpr(0, 0, 0)
localAvatar.wrtReparentTo(self)
localAvatar.setP(0)
localAvatar.setR(0)
localAvatar.setScale(1)
self.handleEnterGameArea(None)
base.loadingScreen.tick()
messenger.send('doorToInteriorFadeIn', [
self.uniqueId])
base.loadingScreen.tick()
if self.autoFadeIn:
fadeInFunc = Func(base.transitions.fadeIn, self.tOpen)
playerStateFunc = Func(localAvatar.gameFSM.request, 'LandRoam')
else:
def Nothing():
pass
fadeInFunc = Func(Nothing)
if self.autoFadeIn:
sf = Sequence(Func(self.requestDoorInteract), fadeInFunc, self.openDoorIval, self.closeDoorIval, Func(self.closeSfx.play), Func(self.requestPlayerStateFunc))
else:
sf = Sequence(Func(self.requestDoorInteract), fadeInFunc, self.openDoorIval, self.closeDoorIval, Func(self.requestPlayerStateFunc))
self.fadeInTrack = sf
self.fadeInTrack.start()
base.cr.loadingScreen.hide()
def requestPlayerStateFunc(self):
if localAvatar.getGameState() in [
'Injured']:
return None
if self.autoFadeIn:
localAvatar.gameFSM.request('LandRoam')
def requestDoorInteract(self):
if localAvatar.getGameState() in [
'Injured']:
return None
localAvatar.gameFSM.request('DoorInteract')
def handleChildArrive(self, childObj, zoneId):
DistributedGameArea.handleChildArrive(self, childObj, zoneId)
DistributedCartesianGrid.handleChildArrive(self, childObj, zoneId)
if childObj.isLocal():
self.updateAvReturnLocation(childObj)
self.builder.checkForHolidayObjects()
self.requestSoundAndMusic()
if not self.footstepSound:
localAvatar.setAreaFootstep('Wood')
self.setupMinimap()
if self.minimap and localAvatar.getMinimapObject():
self.minimap.addObject(localAvatar.getMinimapObject())
localAvatar.guiMgr.setMinimap(self.minimap)
handleChildArrive = report(types = [
'deltaStamp',
'args'], dConfigParam = 'connector')(handleChildArrive)
def handleChildLeave(self, childObj, zoneId):
DistributedGameArea.handleChildLeave(self, childObj, zoneId)
DistributedCartesianGrid.handleChildLeave(self, childObj, zoneId)
if childObj.isLocal():
localAvatar.guiMgr.clearMinimap(self.minimap)
self.destroyMinimap()
self.fadeOutSoundAndMusic()
def loadConnectors(self):
if 'interior' in self.modelPath and 'fortCharles_zero' in self.modelPath and 'kingshead_zero' in self.modelPath or 'pir_m_bld_int_tavernA_oneDoor' in self.modelPath:
return None
DistributedGameArea.loadConnectors(self)
loadConnectors = report(types = [
'frameCount',
'args'], dConfigParam = [
'jail',
'teleport'])(loadConnectors)
def unloadConnectors(self):
if 'interior' in self.modelPath and 'fortCharles_zero' in self.modelPath and 'kingshead_zero' in self.modelPath or 'pir_m_bld_int_tavernA_oneDoor' in self.modelPath:
return None
DistributedGameArea.unloadConnectors(self)
unloadConnectors = report(types = [
'frameCount',
'args'], dConfigParam = [
'jail',
'teleport'])(unloadConnectors)
def setAutoFadeInOnEnter(self, autoFadeIn):
self.autoFadeIn = autoFadeIn
def getTeleportDestPosH(self, index = 0):
pt = self._getTunnelSpawnPos(index)
if pt == None:
pt = self._getDoorSpawnPos(index)
return (pt[0], pt[1], pt[2], 0)
def _getDoorSpawnPos(self, index = 0):
doorIndexStr = ''
if index > 0:
index = '_' + str(index + 1)
doorLocatorStr = '**/door_locator' + doorIndexStr
doorLocator = self.find(doorLocatorStr)
if doorLocator.isEmpty():
doorLocator = self.find(self.doorLeftStr)
if doorLocator.isEmpty():
doorLocator = self.find(self.doorRightStr)
return self.getRelativePoint(doorLocator, Point3(0, 10, 0))
def handleOnStage(self):
self.unstash()
self.loadConnectors()
DistributedGameArea.handleOnStage(self)
DistributedCartesianGrid.handleOnStage(self)
handleOnStage = report(types = [
'args'], dConfigParam = [
'dteleport'])(handleOnStage)
def handleOffStage(self, av = None):
self.stash()
DistributedGameArea.handleOffStage(self)
DistributedCartesianGrid.handleOffStage(self)
handleOffStage = report(types = [
'args'], dConfigParam = [
'dteleport'])(handleOffStage)
def getLevel(self):
return 1
def handleLowTerrainDetail(self):
grids = self.findAllMatches('**/Grid-*')
for dl in self.builder.dynamicLights:
if dl.type != 0:
for gi in range(0, grids.getNumPaths()):
geomParent = grids[gi].getChild(0)
geomParent.setLightOff(dl.lightNodePath)
for ci in range(0, geomParent.getNumChildren()):
geoms = geomParent.getChild(ci)
geoms.setLightOff(dl.lightNodePath)
def requestSoundAndMusic(self):
self.ambientName = SoundGlobals.getAmbientFromStr(self.modelPath)
if not self.ambientName == SoundGlobals.AMBIENT_JUNGLE and self.ambientName == SoundGlobals.AMBIENT_CAVE or self.ambientName == SoundGlobals.AMBIENT_SWAMP:
base.ambientMgr.requestFadeIn(self.ambientName, finalVolume = PiratesGlobals.DEFAULT_AMBIENT_VOLUME)
if self.musicName:
base.musicMgr.requestFadeOut(self.musicName)
self.musicName = None
if self.uniqueId == LocationIds.RAMBLESHACK_INSIDE and localAvatar.getTutorialState() < 2:
self.musicName = SoundGlobals.MUSIC_COMBAT_A
base.musicMgr.request(self.musicName, priority = 1, volume = 0.29999999999999999)
elif 'tavern' in self.modelPath:
self.musicName = random.choice((SoundGlobals.MUSIC_TAVERN_A, SoundGlobals.MUSIC_TAVERN_B, SoundGlobals.MUSIC_TAVERN_C))
base.musicMgr.request(self.musicName, priority = 1, volume = 0.5)
def fadeOutSoundAndMusic(self):
if hasattr(self, 'ambientName'):
if not self.ambientName == SoundGlobals.AMBIENT_JUNGLE and self.ambientName == SoundGlobals.AMBIENT_CAVE:
pass
if not (self.ambientName == SoundGlobals.AMBIENT_SWAMP):
base.ambientMgr.requestFadeOut(self.ambientName)
if self.musicName:
base.musicMgr.requestFadeOut(self.musicName)
self.musicName = None
def setupMinimap(self):
if not (self.minimap) and self.getMapNode():
self.minimap = InteriorMap(self)
setupMinimap = report(types = [
'frameCount',
'args'], dConfigParam = 'minimap')(setupMinimap)
def destroyMinimap(self):
if self.minimap:
self.minimap.destroy()
self.minimap = None
destroyMinimap = report(types = [
'frameCount',
'args'], dConfigParam = 'minimap')(destroyMinimap)
def getGridParameters(self):
return (self.cellWidth, self.viewingRadius)
def getTunnelNodes(self):
return self.locatorNodes
def isInInvasion(self):
return False
def getArmorScale(self):
return 1.0
class QuestIndicatorGridNode(QuestIndicatorNode):
def __init__(self, name, zoneRadii, questStep):
self.pendingStepObj = None
self.stepObj = None
QuestIndicatorNode.__init__(self, name, zoneRadii, questStep)
def delete(self):
self.ignoreAll()
if self.pendingStepObj:
base.cr.relatedObjectMgr.abortRequest(self.pendingStepObj)
self.pendingStepObj = None
QuestIndicatorNode.delete(self)
delete = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(delete)
def placeInWorld(self):
if self.stepObj:
self.reparentTo(self.stepObj)
self.setPos(0, 0, 0)
self.setHpr(0, 0, 0)
self.setScale(render, 1)
elif self.pendingStepObj:
base.cr.relatedObjectMgr.abortRequest(self.pendingStepObj)
self.pendingStepObj = None
questStepDoId = self.questStep.getStepDoId()
self.pendingStepObj = base.cr.relatedObjectMgr.requestObjects([
questStepDoId], eachCallback = self.stepObjArrived)
if self.stepObj:
return None
originObj = base.cr.doId2do.get(self.questStep.getOriginDoId())
if originObj:
posH = self.questStep.getPosH()
pos = posH[:3]
h = posH[3]
self.reparentTo(originObj)
self.setPos(*pos)
self.setHpr(h, 0, 0)
self.setScale(render, 1)
placeInWorld = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(placeInWorld)
def loadZoneLevel(self, level):
QuestIndicatorNode.loadZoneLevel(self, level)
if level == 0:
self.request('At')
if level == 1:
self.request('Near')
if level == 2:
self.request('Far')
loadZoneLevel = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(loadZoneLevel)
def unloadZoneLevel(self, level):
QuestIndicatorNode.unloadZoneLevel(self, level)
if level == 0:
self.request('Near')
if level == 1:
self.request('Far')
if level == 2:
self.request('Off')
unloadZoneLevel = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(unloadZoneLevel)
def enterFar(self):
QuestIndicatorNode.enterFar(self)
enterFar = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(enterFar)
def exitFar(self):
QuestIndicatorNode.exitFar(self)
exitFar = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(exitFar)
def enterNear(self):
QuestIndicatorNode.enterNear(self)
enterNear = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(enterNear)
def exitNear(self):
QuestIndicatorNode.exitNear(self)
exitNear = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(exitNear)
def enterAt(self):
QuestIndicatorNode.enterAt(self)
enterAt = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(enterAt)
def exitAt(self):
QuestIndicatorNode.exitAt(self)
exitAt = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(exitAt)
def _reparentFarEffectToSelf(self):
if self.farEffect:
self.farEffect.wrtReparentTo(self)
_reparentFarEffectToSelf = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(_reparentFarEffectToSelf)
def _reparentFarEffectToOriginObj(self, stepObj):
if self.farEffect:
self.farEffect.wrtReparentTo(stepObj.getParent())
_reparentFarEffectToOriginObj = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(_reparentFarEffectToOriginObj)
def stepObjArrived(self, stepObj):
self.pendingStepObj = None
self.stepObj = stepObj
self.accept(stepObj.getDisableEvent(), self.stepObjLeft)
self.placeInWorld()
stepObjArrived = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(stepObjArrived)
def stepObjLeft(self):
self.stepObj = None
self.placeInWorld()
stepObjLeft = report(types = [
'frameCount',
'args'], dConfigParam = 'quest-indicator')(stepObjLeft)
class DistributedCartesianGrid(DistributedNode, CartesianGridBase):
notify = directNotify.newCategory('DistributedCartesianGrid')
notify.setDebug(0)
VisualizeGrid = config.GetBool('visualize-cartesian-grid', 0)
RuleSeparator = ':'
def __init__(self, cr):
DistributedNode.__init__(self, cr)
self.visAvatar = None
self.gridVisContext = None
self._onOffState = False
def generate(self):
DistributedNode.generate(self)
def disable(self):
DistributedNode.disable(self)
self.stopProcessVisibility()
def delete(self):
DistributedNode.delete(self)
taskMgr.remove(self.taskName('processVisibility'))
def isGridParent(self):
return 1
def setCellWidth(self, width):
self.cellWidth = width
def setParentingRules(self, style, rule):
rules = rule.split(self.RuleSeparator)
self.style = style
self.startingZone = int(rules[0])
self.gridSize = int(rules[1])
self.viewingRadius = int(rules[2])
cx = self.cellWidth * self.gridSize / 2.0
self.centerPos = Vec3(cx, cx, 0)
def getCenterPos(self):
return self.centerPos
def handleChildArrive(self, child, zoneId):
DistributedNode.handleChildArrive(self, child, zoneId)
if zoneId >= self.startingZone:
if not child.gridParent:
child.gridParent = GridParent(child)
child.gridParent.setGridParent(self, zoneId)
elif child.gridParent:
child.gridParent.delete()
child.gridParent = None
def handleChildArriveZone(self, child, zoneId):
DistributedNode.handleChildArrive(self, child, zoneId)
if zoneId >= self.startingZone:
if not child.gridParent:
child.gridParent = GridParent(child)
child.gridParent.setGridParent(self, zoneId)
elif child.gridParent:
child.gridParent.delete()
child.gridParent = None
def handleChildLeave(self, child, zoneId):
if child.gridParent:
child.gridParent.delete()
child.gridParent = None
def startProcessVisibility(self, avatar):
if not self._onOffState:
return None
if self.cr.noNewInterests():
self.notify.warning(
'startProcessVisibility(%s): tried to open a new interest during logout'
% self.doId)
return None
taskMgr.remove(self.taskName('processVisibility'))
self.acceptOnce(self.cr.StopVisibilityEvent,
self.stopProcessVisibility)
self.visAvatar = avatar
self.visZone = None
self.visDirty = True
taskMgr.add(self.processVisibility, self.taskName('processVisibility'))
self.processVisibility(0)
startProcessVisibility = report(types=['deltaStamp', 'avLocation', 'args'],
dConfigParam=['connector', 'shipboard'
])(startProcessVisibility)
def stopProcessVisibility(self, clearAll=False, event=None):
self.ignore(self.cr.StopVisibilityEvent)
taskMgr.remove(self.taskName('processVisibility'))
if event is not None:
eventGroup = EventGroup('DistCartesianGrid.stopProcessVis',
doneEvent=event)
if self.gridVisContext is not None:
if event is not None:
removeEvent = eventGroup.newEvent('%s.removeInterest' %
self.doId)
else:
removeEvent = None
self.cr.removeInterest(self.gridVisContext, removeEvent)
self.gridVisContext = None
elif event is not None:
messenger.send(event)
self.visAvatar = None
self.visZone = None
if clearAll:
if event is not None:
parentEvent = eventGroup.newEvent('%s.parent.removeInterest' %
self.doId)
else:
parentEvent = None
if hasattr(self.cr.doId2do[self.parentId], 'worldGrid'):
self.cr.doId2do[self.parentId].worldGrid.stopProcessVisibility(
event=parentEvent)
stopProcessVisibility = report(types=['deltaStamp', 'avLocation', 'args'],
dConfigParam=['connector', 'shipboard'
])(stopProcessVisibility)
def processVisibility(self, task):
if self.visAvatar == None:
return Task.done
if self.visAvatar.isDisabled():
self.visAvatar = None
return Task.done
if self.visAvatar.gameFSM.state == 'Cutscene':
return Task.cont
pos = self.visAvatar.getPos(self)
dx = self.cellWidth * self.gridSize * 0.5
x = pos[0] + dx
y = pos[1] + dx
col = x // self.cellWidth
row = y // self.cellWidth
if row < 0 and col < 0 and row > self.gridSize or col > self.gridSize:
if self.gridVisContext:
self.cr.removeInterest(self.gridVisContext)
self.visZone = None
self.gridVisContext = None
return Task.cont
zoneId = int(self.startingZone + row * self.gridSize + col)
if zoneId == self.visZone:
if self.visDirty:
messenger.send(self.uniqueName('visibility'))
self.visDirty = False
return Task.cont
else:
self.visZone = zoneId
if not self.gridVisContext:
self.gridVisContext = self.cr.addInterest(
self.getDoId(),
self.visZone,
self.uniqueName('visibility'),
event=self.uniqueName('visibility'))
else:
event = None
if self.visDirty:
event = self.uniqueName('visibility')
self.cr.alterInterest(self.gridVisContext,
self.getDoId(),
self.visZone,
event=event)
parentId = self.visAvatar.parentId
oldZoneId = self.visAvatar.zoneId
if parentId == self.doId:
messenger.send('avatarZoneChanged',
[self.visAvatar, self.doId, zoneId])
self.visDirty = False
return Task.cont
def addObjectToGrid(self, av):
pos = av.getPos(self)
zoneId = self.getZoneFromXYZ(pos)
messenger.send('avatarZoneChanged', [av, self.doId, zoneId])
def removeObjectFromGrid(self, av):
if av.getParent().compareTo(self) == 0:
av.detachNode()
def handleAvatarZoneChange(self, av, zoneId):
if not self.isValidZone(zoneId):
return None
av.b_setLocation(self.doId, zoneId)
def turnOff(self):
self._onOffState = False
self.stopProcessVisibility()
def turnOn(self, av=None):
self._onOffState = True
if av:
self.startProcessVisibility(av)
def setWorldContext(self, worldContext):
pass
def clearWorldContext(self, event=None):
pass
class DistributedGATunnel(DistributedGAConnector.DistributedGAConnector):
notify = directNotify.newCategory('DistributedGATunnel')
def __init__(self, cr):
DistributedGAConnector.DistributedGAConnector.__init__(
self, cr, 'DistributedGATunnel')
self.builder = GridAreaBuilder.GridAreaBuilder(self)
self.loadSphere = [None, None]
self.unloadSphere = None
self.connectorNodes = ['portal_connector_1', 'portal_connector_2']
self.ambientNames = [None, None]
self.avatarZoneContext = None
self.ownContext = None
self.floorIndex = -1
self.lastFloor = -1
self.lastFloorTime = 0
self.loadedAreaDoId = 0
self.floorNames = []
self.quickLoadActive = False
def generate(self):
DistributedGAConnector.DistributedGAConnector.generate(self)
self._DistributedGATunnel__startProcessVisibility()
def announceGenerate(self):
DistributedGAConnector.DistributedGAConnector.announceGenerate(self)
self.geom.hide(OTPRender.MainCameraBitmask)
self.geom.showThrough(OTPRender.EnviroCameraBitmask)
def disable(self):
DistributedGAConnector.DistributedGAConnector.disable(self)
def delete(self):
self._DistributedGATunnel__stopProcessVisibility()
if self.ownContext:
self.cr.removeInterest(self.ownContext)
self.ownContext = None
for sphere in self.loadSphere:
if sphere:
sphere.removeNode()
continue
del self.loadSphere
self.fadeoutAllAmbient()
DistributedGAConnector.DistributedGAConnector.delete(self)
self.builder.delete()
def loadModel(self):
DistributedGAConnector.DistributedGAConnector.loadModel(self)
def _DistributedGATunnel__startProcessVisibility(self):
if not (self.avatarZoneContext) and self.isGenerated():
self.avatarZoneContext = self.cr.addInterest(
self.getDoId(), 500, self.uniqueName('visibility'))
def _DistributedGATunnel__stopProcessVisibility(self):
if self.avatarZoneContext:
self.cr.removeInterest(self.avatarZoneContext)
self.avatarZoneContext = None
def setupCollisions(self):
if self.floorNames == []:
self.floorNames = [
'collision_floor_1', 'collision_floor_2',
'collision_floor_middle'
]
floors = []
for i in range(len(self.floorNames)):
floorName = self.floorNames[i]
floor = self.find('**/' + floorName)
uniqueFloorName = self.uniqueName(floorName)
floor.setName(uniqueFloorName)
self.floorNames[i] = uniqueFloorName
self.accept('enterFloor' + uniqueFloorName,
self._DistributedGATunnel__handleOnFloor,
extraArgs=[i])
def unloadWorldFinished(self, areaDoId):
DistributedGAConnector.DistributedGAConnector.unloadWorldFinished(
self, areaDoId)
self.loadArea(self.floorIndex, False)
unloadWorldFinished = report(types=['frameCount', 'printInterests'],
dConfigParam='connector')(unloadWorldFinished)
def fadeOutAmbient(self, index):
if self.ambientNames[index]:
base.ambientMgr.requestFadeOut(self.ambientNames[index],
duration=0.01)
if self.ambientNames[1 - index]:
base.ambientMgr.requestChangeVolume(self.ambientNames[1 - index],
duration=0,
finalVolume=0)
def fadeInAmbient(self, index):
if self.ambientNames[index]:
base.ambientMgr.requestChangeVolume(
self.ambientNames[index],
duration=0.10000000000000001,
finalVolume=PiratesGlobals.DEFAULT_AMBIENT_VOLUME_NEAR)
def __handleOnFloor(self, areaIndex, collEntry):
if (not collEntry or areaIndex in (0, 1)
) and not localAvatar.testTeleportFlag(PiratesGlobals.TFInTunnel):
if not self.ownContext:
(parent, zone) = self.getLocation()
self.ownContext = self.cr.addInterest(parent, zone,
'tunnelSelfInterest')
def enterTunnelFinished():
if localAvatar.getGameState() in ('EnterTunnel', 'Off',
'Dialog', 'Cutscene',
'LandRoam'):
localAvatar.b_setLocation(self.doId, 500)
self.floorIndex = 1 - areaIndex
self.unloadLoadedArea()
if localAvatar.gameFSM.preTunnelState:
localAvatar.b_setGameState(
localAvatar.gameFSM.preTunnelState)
else:
localAvatar.b_setGameState('LandRoam')
if collEntry != None:
area = self.getLoadedArea()
if not area:
self.notify.warning(
'***JCW*** No loaded area in GATunnel: %s' %
self.getUniqueId())
self.notify.warning('***JCW*** Areas: %s, %s' %
(self.areaUid[0], self.areaUid[1]))
self.notify.warning(
'***JCW*** Ignoring __handleOnFloor(%s) event' %
areaIndex)
return None
entranceNode = self.areaNode[areaIndex]
entryLocator = area.find('**/' + entranceNode + '*')
if entryLocator.isEmpty():
return None
camera.wrtReparentTo(render)
localAvatar.lookAt(entryLocator, -50, 0,
localAvatar.getZ(entryLocator))
camera.wrtReparentTo(localAvatar)
self.acceptOnce('EnterTunnelFinished', enterTunnelFinished)
localAvatar.gameFSM.preTunnelState = localAvatar.getGameState()
localAvatar.b_setGameState('EnterTunnel')
else:
base.transitions.fadeOut(0.75, Func(enterTunnelFinished))
localAvatar.motionFSM.off()
localAvatar.b_setTeleportFlag(PiratesGlobals.TFInTunnel)
_DistributedGATunnel__handleOnFloor = report(
types=['frameCount',
'printInterests'], dConfigParam='connector')(__handleOnFloor)
def loadAreaFinished(self, area, autoFadeIn=True):
def leaveTunnel():
areaIndex = self.getAreaIndex(area)
entranceNode = self.areaNode[areaIndex]
entryLocator = area.find('**/' + entranceNode + '*')
localAvatar.reparentTo(entryLocator)
localAvatar.setPos(0, 0, 0)
if not autoFadeIn:
if localAvatar.style.tutorial == PiratesGlobals.TUT_KILLED_1_SKELETON:
localAvatar.setX(30)
localAvatar.setH(90)
else:
localAvatar.setH(-90)
localAvatar.wrtReparentTo(area)
if autoFadeIn:
def leaveTunnelFinished():
localAvatar.b_clearTeleportFlag(PiratesGlobals.TFInTunnel)
if localAvatar.gameFSM.preTunnelState:
localAvatar.b_setGameState(
localAvatar.gameFSM.preTunnelState)
if localAvatar.gameFSM.preTunnelState == 'Battle':
localAvatar.guiMgr.combatTray.toggleWeapon(
localAvatar.currentWeaponId,
localAvatar.currentWeaponSlotId)
else:
localAvatar.b_setGameState('LandRoam')
self.acceptOnce('LeaveTunnelFinished', leaveTunnelFinished)
base.localAvatar.b_setGameState('LeaveTunnel')
else:
self.sendUpdate('sendLeaveTunnelDone')
self.fadeInAmbient(self.floorIndex)
leaveTunnel = report(types=['frameCount', 'printInterests'],
dConfigParam='connector')(leaveTunnel)
base.cr.setAllInterestsCompleteCallback(leaveTunnel)
transform = localAvatar.getTransform(self)
DistributedGAConnector.DistributedGAConnector.loadAreaFinished(
self, area, autoFadeIn)
self.lastFloorTime = globalClock.getFrameTime()
self.loadedAreaDoId = area.doId
localAvatar.setTransform(self, transform)
localAvatar.wrtReparentTo(area)
area.handleEnterGameArea(None)
loadAreaFinished = report(types=['frameCount', 'printInterests'],
dConfigParam='connector')(loadAreaFinished)
def handleChildArrive(self, childObj, zoneId):
DistributedGAConnector.DistributedGAConnector.handleChildArrive(
self, childObj, zoneId)
if childObj.isLocal():
childObj.wrtReparentTo(self)
handleChildArrive = report(types=['frameCount'],
dConfigParam='connector')(handleChildArrive)
def handleChildLeave(self, childObj, zoneId):
DistributedGAConnector.DistributedGAConnector.handleChildLeave(
self, childObj, zoneId)
if childObj.isLocal():
if self.ownContext:
self.cr.removeInterest(self.ownContext)
self.ownContext = None
handleChildLeave = report(types=['frameCount'],
dConfigParam='connector')(handleChildLeave)
def fadeoutAllAmbient(self):
if self.lastFloor >= 0:
for ambientName in self.ambientNames:
if ambientName:
base.ambientMgr.requestFadeOut(ambientName)
continue
def setLinks(self, isExterior, exteriorUid, links):
DistributedGAConnector.DistributedGAConnector.setLinks(
self, isExterior, exteriorUid, links)
self.calcAmbientNames()
def calcOneAmbientName(self, area):
retval = None
if area:
parts = area.split('_')
retval = SoundGlobals.getAmbientFromStr(parts[-1])
return retval
def calcAmbientNames(self):
for i in xrange(2):
area = self.areaNode[i]
ambientName = self.calcOneAmbientName(area)
self.ambientNames[i] = ambientName
if not self.ambientNames[0] and not self.ambientNames[1]:
self.ambientNames[1] = SoundGlobals.getAmbientFromStr(
self.modelPath)
self.notify.debug('Assuming self.ambientNames[1] = %s' %
self.ambientNames[1])
def quickLoadOtherSide(self):
base.cr.loadingScreen.show(waitForLocation=True)
if self.floorIndex != -1:
self._DistributedGATunnel__handleOnFloor(self.floorIndex, None)
def turnOn(self):
DistributedGAConnector.DistributedGAConnector.turnOn(self)
self._DistributedGATunnel__startProcessVisibility()
turnOn = report(types=['frameCount'], dConfigParam='connector')(turnOn)
def turnOff(self):
self._DistributedGATunnel__stopProcessVisibility()
DistributedGAConnector.DistributedGAConnector.turnOff(self)
turnOff = report(types=['frameCount'], dConfigParam='connector')(turnOff)
def isGridParent(self):
return 0
class ReducedAnimationMixer(AnimationMixer):
def __init__(self, actor):
AnimationMixer.__init__(self, actor)
self.actionAnim = None
self.loopAnim = None
self.loopOp = None
self.loopArgs = ()
self.loopKw = { }
self._ReducedAnimationMixer__actionContext = 0
__init__ = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(__init__)
def __str__(self):
outStr = '(%s: %s)\n' % (self.__class__.__name__, `self.actor`)
outStr += 'actionAnim: %s\n' % (self.actionAnim,)
if self.loopOp:
outStr += 'loopStatus: %s(%s, %s, %s)\n' % (self.loopOp.__name__, self.loopAnim, self.loopArgs, self.loopKw)
else:
outStr += 'loopStatus: None\n'
outStr += '\nOwned Intervals\n-------------------------------\n'
for ival in self.ownedIvals:
outStr += `ival` + ': isPlaying = ' + `ival.isPlaying()` + '\n'
return outStr
def nextActionContext(self):
self._ReducedAnimationMixer__actionContext += 1
return self._ReducedAnimationMixer__actionContext
def setAction(self, anim, context):
if context >= self._ReducedAnimationMixer__actionContext:
self.actionAnim = anim
self.actor.setControlEffect(anim, 1)
setAction = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(setAction)
def clearAction(self, context):
if context >= self._ReducedAnimationMixer__actionContext:
if self.actionAnim:
self.stop(self.actionAnim)
self.actionAnim = None
self._ReducedAnimationMixer__startLoopIfAble()
clearAction = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(clearAction)
def setLoop(self, loopOp, anim, *args, **kw):
self.clearLoop()
self.loopOp = loopOp
self.loopAnim = anim
self.loopArgs = args
self.loopKw = kw
self._ReducedAnimationMixer__startLoopIfAble()
self.actor.setControlEffect(anim, 1)
setLoop = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(setLoop)
def __startLoopIfAble(self):
if not (self.actionAnim) and self.loopOp:
self.loopOp(self.actor, self.loopAnim, *self.loopArgs, **self.loopArgs)
_ReducedAnimationMixer__startLoopIfAble = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(__startLoopIfAble)
def clearLoop(self):
if self.loopAnim:
self.loopAnim = None
self.loopOp = None
clearLoop = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(clearLoop)
def __getPlayIval(self, newAnim, fromFrame, toFrame, duration = 0):
pDuration = duration
if not pDuration:
pDuration = Actor.getDuration(self.actor, newAnim, None, fromFrame, toFrame)
if pDuration == None:
return Sequence()
if pDuration == 0.0:
return Sequence()
playRate = Actor.getPlayRate(self.actor, newAnim)
if playRate:
pDuration /= abs(playRate)
context = self.nextActionContext()
return Sequence(Func(self.setAction, newAnim, context), Wait(pDuration + 1), Func(self.clearAction, context))
_ReducedAnimationMixer__getPlayIval = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(__getPlayIval)
def __processActorInterval(self, actorInterval):
actorInterval.resetControls(None)
context = self.nextActionContext()
return Sequence(Func(self.setAction, actorInterval.animName, context), actorInterval, Func(self.clearAction, context))
_ReducedAnimationMixer__processActorInterval = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(__processActorInterval)
def play(self, newAnim, fromFrame = None, toFrame = None, blendInT = 0, blendOutT = 0, blendInto = None):
ival = self._ReducedAnimationMixer__getPlayIval(newAnim, fromFrame, toFrame)
if ival:
Actor.play(self.actor, newAnim, fromFrame = fromFrame, toFrame = toFrame)
ival.start()
ival.setT(0.01)
self.addIvalToOwnedList(ival)
play = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(play)
def loop(self, newAnim, rate = 1.0, restart = True, fromFrame = None, toFrame = None, blendT = 0, blendDelay = 0):
self.setLoop(Actor.loop, newAnim, restart = restart, fromFrame = fromFrame, toFrame = toFrame)
Actor.loop(self.actor, newAnim, restart = restart, fromFrame = fromFrame, toFrame = toFrame)
self.actor.setPlayRate(rate, newAnim)
loop = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(loop)
def pingpong(self, newAnim, rate = 1.0, fromFrame = None, toFrame = None, blendT = 0):
self.setLoop(Actor.pingpong, newAnim, fromFrame = fromFrame, toFrame = toFrame)
Actor.pingpong(self.actor, newAnim, fromFrame = fromFrame, toFrame = toFrame)
self.actor.setPlayRate(rate, newAnim)
pingpong = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(pingpong)
def pose(self, newAnim, frame, partName = None, blendT = 0):
self.setLoop(Actor.pose, newAnim, frame)
Actor.pose(self.actor, newAnim, frame)
pose = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(pose)
def actorInterval(self, actorInterval, partName = None, blendInT = 0, blendOutT = 0, blendInto = None):
return self._ReducedAnimationMixer__processActorInterval(actorInterval)
actorInterval = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(actorInterval)
def cleanup(self):
self.clearAction(self.nextActionContext())
self.clearLoop()
AnimationMixer.cleanup(self)
Actor.setControlEffect(self.actor, None, 1.0)
cleanup = report(types = [
'deltaStamp',
'args'], dConfigParam = 'animmixer')(cleanup)
class GameFSMShip(FSM.FSM):
def __init__(self, ship):
FSM.FSM.__init__(self, 'GameFSMShip')
self.ship = ship
self.risingIval = None
self.sinkIval = None
self.fadeIval = None
self.currentMusic = None
self.grappleSfx = None
self.targetSphereStr = 'grappleTargetSphere'
self.targets = []
self.pendingAddTarget = None
def cleanup(self):
if self.pendingAddTarget:
base.cr.relatedObjectMgr.abortRequest(self.pendingAddTarget)
self.pendingAddTarget = None
self.removeTargets()
if self.risingIval:
self.risingIval.finish()
self.risingIval = None
if self.sinkIval:
self.sinkIval.finish()
self.sinkIval = None
if self.fadeIval:
self.fadeIval.finish()
self.fadeIval = None
FSM.FSM.cleanup(self)
self.ship = None
def enterNeutral(self):
pass
def exitNeutral(self):
pass
def enterSpawn(self):
pass
def exitSpawn(self):
pass
def enterAdrift(self):
pass
def exitAdrift(self):
pass
def enterAISteering(self, avId):
self.ship.startSmooth()
self.ship.clientSteeringBegin(avId)
def exitAISteering(self):
self.ship.stopSmooth()
self.ship.clientSteeringEnd()
def enterClientSteering(self, avId):
self.ship.clientSteeringBegin(avId)
enterClientSteering = report(types=['frameCount', 'deltaStamp', 'args'],
dConfigParam='shipboard')(enterClientSteering)
def exitClientSteering(self):
if self.ship.wheel and self.ship.wheel[1]:
if base.cr.interactionMgr.getCurrentInteractive() is self:
self.ship.wheel[1].requestExit()
else:
self.ship.wheel[1].refreshState()
self.ship.clientSteeringEnd()
exitClientSteering = report(types=['frameCount', 'deltaStamp', 'args'],
dConfigParam='shipboard')(exitClientSteering)
def enterDocked(self):
self.ship.rollupSails()
def exitDocked(self):
pass
def enterPinned(self):
self.ship.actorNode.getPhysicsObject().setVelocity(Vec3.zero())
if self.ship.isInCrew(localAvatar.doId):
base.musicMgr.requestFadeOut(self.currentMusic)
self.currentMusic = SoundGlobals.MUSIC_AMBUSH
base.musicMgr.request(self.currentMusic, priority=1)
self.ship.rollupSails()
self.ship.disableWheelInteraction()
def exitPinned(self):
self.fadeOutMusicIfInCrew()
self.ship.enableWheelInteraction()
def enterEnsnared(self):
if self.ship.isInCrew(localAvatar.doId):
base.musicMgr.requestFadeOut(self.currentMusic)
self.currentMusic = SoundGlobals.MUSIC_SHIP_ENSNARED
base.musicMgr.request(self.currentMusic, priority=1)
if self.risingIval:
self.risingIval.finish()
self.risingIval = None
sinking = Sequence(
LerpPosInterval(self.ship, 1.0, Point3(0.0, 0, -3.0)))
listing = Sequence(LerpHprInterval(self.ship, 1.0, Vec3(0, 0, 10)))
self.sinkIval = Parallel(sinking, listing)
self.sinkIval.start()
def exitEnsnared(self):
self.fadeOutMusicIfInCrew()
if self.sinkIval:
self.sinkIval.finish()
self.sinkIval = None
rising = Sequence(LerpPosInterval(self.ship, 1.0, Point3(0, 0, 0)))
unlisting = Sequence(LerpHprInterval(self.ship, 1.0, Vec3(0, 0, 0)))
self.riseIval = Parallel(rising, unlisting)
self.riseIval.start()
def enterShoveOff(self):
pass
def exitShoveOff(self):
pass
def enterFollow(self):
self.ship.startSmooth()
def exitFollow(self):
self.ship.stopSmooth()
def enterFadeOut(self):
self.ship.model.modelRoot.setTransparency(1, 100000)
self.fadeIval = LerpColorScaleInterval(self.ship.model.modelRoot, 5,
Vec4(1.0, 1.0, 1.0, 0.0))
self.fadeIval.start()
def exitFadeOut(self):
if self.fadeIval:
self.fadeIval.finish()
self.fadeIval = None
def enterSinking(self):
actorNode = self.ship.getActorNode()
if actorNode:
actorNode.getPhysicsObject().setVelocity(Vec3.zero())
self.ship.registerMainBuiltFunction(self.ship.sinkingBegin)
if self.ship.isInCrew(localAvatar.doId):
base.musicMgr.requestFadeOut(self.currentMusic)
self.currentMusic = SoundGlobals.MUSIC_DEATH
base.musicMgr.request(self.currentMusic, priority=2, looping=0)
def exitSinking(self):
self.ship.sinkingEnd()
self.fadeOutMusicIfInCrew()
def enterSunk(self):
pass
def enterRecoverFromSunk(self):
self.ship.recoverFromSunk()
def enterInBoardingPosition(self):
pass
def exitInBoardingPosition(self):
pass
def enterPathFollow(self):
self.ship.startSmooth()
def exitPathFollow(self):
self.ship.stopSmooth()
def enterCannonDefenseFollowPath(self):
self.ship.startSmooth()
def exitCannonDefenseFollowPath(self):
self.ship.stopSmooth()
def enterPatrol(self):
self.ship.startSmooth()
def exitPatrol(self):
self.ship.stopSmooth()
def enterAttackChase(self):
self.ship.startSmooth()
def exitAttackChase(self):
self.ship.stopSmooth()
def enterOff(self):
self.ship.stopAutoSailing()
def exitOff(self):
messenger.send('shipStateOn-%s' % self.ship.doId, [self.ship])
def enterPutAway(self):
self.ship.stopAutoSailing()
def exitPutAway(self):
pass
def enterScriptedMovement(self):
self.ship.startSmooth()
def exitScriptedMovement(self):
self.ship.stopSmooth()
def initAudio(self):
base.ambientMgr.requestFadeIn(SoundGlobals.AMBIENT_SHIP)
self.currentMusic = random.choice(
(SoundGlobals.MUSIC_SAILING_A, SoundGlobals.MUSIC_SAILING_B,
SoundGlobals.MUSIC_SAILING_C))
base.musicMgr.request(self.currentMusic,
priority=0,
volume=0.59999999999999998)
def clearAudio(self):
base.ambientMgr.requestFadeOut(SoundGlobals.AMBIENT_SHIP)
base.musicMgr.requestFadeOut(self.currentMusic)
def stopCurrentMusic(self):
if self.currentMusic:
base.musicMgr.requestFadeOut(self.currentMusic)
self.currentMusic = None
def startCurrentMusic(self, music=None):
if music and self.currentMusic != music:
self.currentMusic = music
if self.currentMusic:
base.musicMgr.request(self.currentMusic)
def fadeOutMusicIfInCrew(self):
try:
if self.ship.isInCrew(localAvatar.doId):
self.stopCurrentMusic()
except NameError:
self.stopCurrentMusic()
def createGrappleProximitySphere(self):
self.grappleProximityStr = self.ship.uniqueName('grappleProximity')
collSphere = CollisionSphere(0, 0, 0, 200)
collSphere.setTangible(0)
collSphereNode = CollisionNode(self.grappleProximityStr)
collSphereNode.addSolid(collSphere)
collSphereNode.setCollideMask(PiratesGlobals.ShipCollideBitmask)
collSphereNodePath = self.ship.attachNewNode(collSphereNode)
self.grappleProximityCollision = collSphereNodePath
self.stashGrappleProximitySphere()
def stashGrappleProximitySphere(self):
self.grappleProximityCollision.stash()
def unstashGrappleProximitySphere(self):
self.grappleProximityCollision.unstash()
def enterWaitingForGrapple(self):
self.notify.debug('enterWaitingForGrapple')
self.ship.removeWake()
if self.ship.boardableShipId == None:
return None
self.unstashGrappleProximitySphere()
self.removeTargets()
self.pendingAddTarget = base.cr.relatedObjectMgr.requestObjects(
[self.ship.boardableShipId], eachCallback=self.addTargets)
if localAvatar.ship and localAvatar.ship.doId == self.ship.boardableShipId:
localAvatar.guiMgr.messageStack.addTextMessage(
PLocalizer.FlagshipWaitingForGrappleInstructions)
def exitWaitingForGrapple(self):
self.ship.removeTarget()
def addTargets(self, boardableShip):
if localAvatar.ship != boardableShip:
return None
attackX = boardableShip.getX(self.ship)
gStr = '**/grapple_right_*'
xOffset = -5.0
if attackX < 0:
gStr = '**/grapple_left_*'
xOffset = 5.0
locators = self.ship.findLocators(gStr + ';+s')
for locator in locators:
target = loader.loadModel('models/effects/selectionCursor')
target.setColorScale(0, 1, 0, 1)
self.ship.addGrappleTarget(target, locator, xOffset)
target.setTwoSided(1)
target.setBillboardPointEye()
target.setFogOff()
(scaleA, scaleB) = (10, 16)
target.setScale(scaleA)
t = 0.5
ival = Sequence(
LerpScaleInterval(target,
2 * t,
Vec3(scaleB, scaleB, scaleB),
blendType='easeInOut'),
LerpScaleInterval(target,
t,
Vec3(scaleA, scaleA, scaleA),
blendType='easeInOut'))
ival.loop()
collSphere = CollisionSphere(0, 0, 0, 10)
collSphere.setTangible(1)
collSphereNode = CollisionNode('grappleTargetSphere')
collSphereNode.addSolid(collSphere)
collSphereNode.setTag('objType',
str(PiratesGlobals.COLL_GRAPPLE_TARGET))
collSphereNode.setTag('shipId', str(self.ship.doId))
collSphereNode.setTag('targetId', locator.getName())
collSphereNode.setCollideMask(PiratesGlobals.TargetBitmask)
collSphereNodePath = self.ship.getModelRoot().attachNewNode(
collSphereNode)
collSphereNodePath.setPos(target.getPos())
collSphereNodePath.setTag('targetIndex', str(len(self.targets)))
self.targets.append([target, ival, collSphereNodePath])
self.accept('enterGrappleTargetSphere', self.handleTargetHit)
def removeTargets(self):
for (target, ival, csnp) in self.targets:
target.removeNode()
csnp.removeNode()
if ival:
ival.pause()
del ival
continue
self.targets = []
self.ignore('entergrappleTargetSphere')
def handleTargetHit(self, collEntry):
print '**********HANDLE TARGET HIT*****************'
def enterGrappleLerping(self):
self.notify.debug('enterGrappleLerping')
self.ship.startSmooth()
self.grappleSfx = loadSfx(SoundGlobals.SFX_SHIP_GRAPPLE)
base.playSfx(self.grappleSfx, looping=1)
grappler = base.cr.doId2do.get(self.ship.boardableShipId)
if grappler:
grappler.grappledShip(self.ship)
def exitGrappleLerping(self):
self.ship.stopSmooth()
self.ship.removeTarget()
if self.grappleSfx:
self.grappleSfx.stop()
self.grappleSfx = None
def enterInPosition(self):
self.notify.debug('enterInPosition')
self.removeTargets()
myShip = localAvatar.getShip()
if myShip and myShip.doId == self.ship.boardableShipId:
if myShip.isCaptain(localAvatar.doId):
localAvatar.guiMgr.messageStack.addTextMessage(
PLocalizer.FlagshipInPositionInstructionsCaptain)
myShip.showBoardingChoice(self.ship)
else:
localAvatar.guiMgr.messageStack.addTextMessage(
PLocalizer.FlagshipInPositionInstructionsCrew)
def exitInPosition(self):
self.ship.removeTarget()
myShip = localAvatar.getShip()
if myShip and myShip.doId == self.ship.boardableShipId:
if myShip.isCaptain(localAvatar.doId):
myShip.removeBoardingChoice()
def enterBoarded(self):
self.ship.disableOnDeckInteractions()
def exitBoarded(self):
pass
def enterDefeated(self):
self.explosionIval = None
if self.ship:
self.notify.debug('%s enterDefeated' % self.ship.doId)
self.ship.removeTarget()
if self.ship.getModelRoot():
pos = self.ship.getClosestBoardingPos()
if base.options.getSpecialEffectsSetting(
) >= base.options.SpecialEffectsHigh:
effectsIval = Parallel()
explosionEffect = Explosion.getEffect()
if explosionEffect:
explosionEffect.reparentTo(self.ship.getModelRoot())
explosionEffect.setPos(self.ship.getModelRoot(), pos)
explosionEffect.setEffectScale(1.0)
effectsIval.append(Func(explosionEffect.play))
shipSplintersAEffect = ShipSplintersA.getEffect()
if shipSplintersAEffect:
shipSplintersAEffect.wrtReparentTo(
self.ship.getModelRoot())
shipSplintersAEffect.setPos(self.ship.getModelRoot(),
pos)
effectsIval.append(Func(shipSplintersAEffect.play))
effect1 = FlamingDebris.getEffect()
if effect1:
effect1.wrtReparentTo(self.ship.getModelRoot())
effect1.setPos(self.ship.getModelRoot(), pos)
effect1.velocityX = 25
effect1.velocityY = 0
effectsIval.append(Func(effect1.play))
effect2 = FlamingDebris.getEffect()
if effect2:
effect2.wrtReparentTo(self.ship.getModelRoot())
effect2.setPos(self.ship.getModelRoot(), pos)
effect2.velocityX = 0
effect2.velocityY = 25
effectsIval.append(Func(effect2.play))
self.explosionIval = Sequence(Wait(4.0), effectsIval)
self.explosionIval.start()
def enterKrakenPinned(self):
if self.ship.model:
self.ship.model.modelRoot.setR(10)
def exitKrakenPinned(self):
if self.ship.model:
self.ship.model.modelRoot.setR(0)
def exitDefeated(self):
self.notify.debug('%s exitDefeated' % self.ship.doId)
if self.explosionIval:
self.explosionIval.pause()
self.explosionIval = None
def enterInactive(self):
pass
def exitInactive(self):
pass
def enterCaptured(self):
if self.ship:
self.notify.debug('%s enterCaptured' % self.ship.doId)
self.ship.removeTarget()
def exitCaptured(self):
if self.ship:
self.notify.debug('%s exitCaptured' % self.ship.doId)
class DistributedShipDeployer(DistributedNode, GridChild):
def __init__(self, cr):
DistributedNode.__init__(self, cr)
NodePath.__init__(self, 'ShipDeployer')
GridChild.__init__(self)
self.minRadius = 0
self.spacing = 0
self.maxRadius = 0
self.heading = 0
self.minSphere = None
self.maxSphereSoft = None
self.maxSphereHard = None
self.deploySpheres = []
self.lockedMessage = 0
self.outerBarrierState = True
def announceGenerate(self):
DistributedNode.announceGenerate(self)
self.reparentTo(self.getParentObj())
self.createSpheres()
self.enableDeploySpheres(False)
self.accept(self.uniqueName('enterShipDeploySphere'), self.handleShipCollideEnter)
self.accept(self.uniqueName('exitShipDeploySphere'), self.handleShipCollideExit)
self.accept(self.uniqueName('enterShipDeploy-MaxSphereSoft'), self.handleShipEnterSoftBarrier)
self.accept(self.uniqueName('exitShipDeploy-MaxSphereSoft'), self.handleShipExitSoftBarrier)
self.accept(self.uniqueName('enterShipDeploy-MaxSphereHard'), self.handleShipEnterHardBarrier)
self.accept(self.uniqueName('exitShipDeploy-MaxSphereHard'), self.handleShipExitHardBarrier)
self.accept(self.uniqueName('enterShipDeploy-MinSphere'), self.handleShipEnterMinSphere)
self.accept(self.uniqueName('exitShipDeploy-MinSphere'), self.handleShipExitMinSphere)
self.accept('settingLocalShip', self.unlockMessages)
announceGenerate = report(types = [
'frameCount',
'args'], dConfigParam = 'shipboard')(announceGenerate)
def disable(self):
self.ignore(self.uniqueName('enterShipDeploySphere'))
self.ignore(self.uniqueName('exitShipDeploySphere'))
self.ignore(self.uniqueName('enterShipDeploy-MaxSphereSoft'))
self.ignore(self.uniqueName('exitShipDeploy-MaxSphereSoft'))
self.ignore(self.uniqueName('enterShipDeploy-MaxSphereHard'))
self.ignore(self.uniqueName('exitShipDeploy-MaxSphereHard'))
self.ignore(self.uniqueName('enterShipDeploy-MinSphere'))
self.ignore(self.uniqueName('exitShipDeploy-MinSphere'))
self.ignore('settingLocalShip')
self.unlockMessages()
self.removeChildren()
self.minSphere = None
self.maxSphereSoft = None
self.maxSphereHard = None
self.deploySpheres = []
DistributedNode.disable(self)
disable = report(types = [
'frameCount',
'args'], dConfigParam = 'shipboard')(disable)
def delete(self):
DistributedNode.delete(self)
GridChild.delete(self)
def unlockMessages(self, data = None):
if self.lockedMessage:
localAvatar.guiMgr.unlockInstructionMessage(self)
def setMinRadius(self, radius):
self.minRadius = radius
def setMaxRadius(self, radius):
self.maxRadius = radius
def setSpacing(self, spacing):
self.spacing = spacing
def setHeading(self, heading):
self.heading = heading
def d_shipEnteredSphere(self, shipId, sphereId):
self.sendUpdate('shipEnteredSphere', [
shipId,
sphereId])
def d_shipExitedSphere(self, shipId, sphereId):
self.sendUpdate('shipExitedSphere', [
shipId,
sphereId])
def d_shipExitedBarrier(self, shipId):
self.sendUpdate('shipExitedBarrier', [
shipId])
def createSpheres(self):
self.createMinSphere()
self.createMaxSpheres()
self.createDeploySpheres()
createSpheres = report(types = [
'frameCount',
'args'], dConfigParam = 'shipboard')(createSpheres)
def createMinSphere(self):
cSphere = CollisionSphere(0, 0, 0, self.minRadius)
cSphere.setTangible(1)
cSphereNode = CollisionNode(self.uniqueName('ShipDeploy-MinSphere'))
cSphereNode.setFromCollideMask(BitMask32.allOff())
cSphereNode.setIntoCollideMask(PiratesGlobals.ShipCollideBitmask)
cSphereNode.addSolid(cSphere)
self.minSphere = self.attachNewNode(cSphereNode)
def createMaxSpheres(self):
cSphere = CollisionSphere(0, 0, 0, self.maxRadius)
cSphere.setTangible(0)
cSphereNode = CollisionNode(self.uniqueName('ShipDeploy-MaxSphereSoft'))
cSphereNode.setFromCollideMask(BitMask32.allOff())
cSphereNode.setIntoCollideMask(PiratesGlobals.ShipCollideBitmask)
cSphereNode.addSolid(cSphere)
self.maxSphereSoft = self.attachNewNode(cSphereNode)
cSphere = CollisionSphere(0, 0, 0, self.maxRadius)
cSphere.setTangible(1)
cSphereNode = CollisionNode(self.uniqueName('ShipDeploy-MaxSphereHard'))
cSphereNode.setFromCollideMask(BitMask32.allOff())
cSphereNode.setIntoCollideMask(PiratesGlobals.ShipDeployBitmask)
cSphereNode.addSolid(cSphere)
self.maxSphereHard = self.attachNewNode(cSphereNode)
def createDeploySpheres(self):
deployRingRadius = self.minRadius + self.spacing / 2.0
C = 2 * math.pi * deployRingRadius
numSpheres = int(C / self.spacing)
stepAngle = 360.0 / numSpheres
def getSpherePos(sphereId):
h = sphereId * stepAngle + 90.0 + self.heading
angle = h * math.pi / 180.0
pos = Point3(math.cos(angle), math.sin(angle), 0) * deployRingRadius
return pos
for x in xrange(numSpheres):
pos = getSpherePos(x)
cSphere = CollisionSphere(pos[0], pos[1], pos[2], self.spacing / 2.0)
cSphere.setTangible(0)
cSphereNode = CollisionNode(self.uniqueName('ShipDeploySphere'))
cSphereNode.addSolid(cSphere)
cSphereNode.setFromCollideMask(BitMask32.allOff())
cSphereNode.setIntoCollideMask(PiratesGlobals.ShipCollideBitmask)
sphere = self.attachNewNode(cSphereNode)
sphere.setTag('deploySphereId', `x`)
self.deploySpheres.append(sphere)
def showSpheres(self):
self.minSphere.show()
self.maxSphereSoft.show()
self.maxSphereHard.show()
for sphere in self.deploySpheres:
sphere.show()
def hideSpheres(self):
self.minSphere.hide()
self.maxSphereSoft.hide()
self.maxSphereHard.hide()
for sphere in self.deploySpheres:
sphere.hide()
def handleShipCollideEnter(self, colEntry):
shipId = colEntry.getFromNodePath().getNetTag('shipId')
shipId = int(shipId)
sphereId = colEntry.getIntoNodePath().getNetTag('deploySphereId')
sphereId = int(sphereId)
self.d_shipEnteredSphere(shipId, sphereId)
for sphere in self.deploySpheres:
sphere.stash()
padding = 3
numSpheres = len(self.deploySpheres)
for sphere in lambda [outmost-iterable]: for s in [outmost-iterable]:
class DistributedInteractive(DistributedNode, InteractiveBase, DistributedLocatableObject, GridChild):
notify = DirectNotifyGlobal.directNotify.newCategory('DistributedInteractive')
def __init__(self, cr):
DistributedNode.__init__(self, cr)
InteractiveBase.__init__(self)
DistributedLocatableObject.__init__(self, cr)
GridChild.__init__(self)
self.interactGUI = None
self.hideHpMeterFlag = 0
self.userId = 0
self.uniqueId = None
def delete(self):
DistributedNode.delete(self)
InteractiveBase.delete(self)
DistributedLocatableObject.delete(self)
GridChild.delete(self)
def generate(self):
DistributedNode.generate(self)
InteractiveBase.generate(self)
DistributedLocatableObject.generate(self)
def disable(self):
DistributedNode.disable(self)
InteractiveBase.disable(self)
DistributedLocatableObject.disable(self)
def announceGenerate(self):
DistributedNode.announceGenerate(self)
DistributedLocatableObject.announceGenerate(self)
def isBattleable(self):
return 0
def requestInteraction(self, avId, interactType = 0, instant = 0):
if self.cr:
self.sendUpdate('requestInteraction', [
base.localAvatar.doId,
interactType,
instant])
self.cr.interactionMgr.stop()
self.request('Waiting')
requestInteraction = report(types = [
'frameCount',
'deltaStamp'], dConfigParam = 'shipboard')(requestInteraction)
def setLocation(self, parentId, zoneId):
DistributedNode.setLocation(self, parentId, zoneId)
def requestExit(self):
self.sendUpdate('requestExit')
self.refreshState()
def demandExit(self):
self.sendUpdate('demandExit')
self.refreshState()
def refreshState(self):
if self.hasProximityCollision and self.allowInteract and not (self.ignoreProximity) and not self.proximityCollisionNodePath.isEmpty():
distance = self.proximityCollisionNodePath.getDistance(localAvatar)
proxSphereRadius = self.proximityCollisionNodePath.getScale()[0]
avRadius = 1.3999999999999999
if distance <= proxSphereRadius + avRadius:
self.request('Proximity')
else:
self.request('Idle')
else:
self.request('Idle')
def acceptInteraction(self):
self.request('Use')
def rejectInteraction(self):
self.cr.interactionMgr.start()
self.refreshState()
def rejectExit(self):
pass
def offerOptions(self, optionIds, statusCodes):
if self.interactGUI:
self.notify.warning('offerOptions: old interact GUI still around')
self.interactGUI.destroy()
self.interactGUI = None
self.interactGUI = InteractGUI.InteractGUI()
title = self.getMenuTitle()
self.interactGUI.setOptions(title, optionIds, statusCodes, self.b_selectOption)
def b_selectOption(self, optionId):
self.d_selectOption(optionId)
self.selectOption(optionId)
def d_selectOption(self, optionId):
self.sendUpdate('selectOption', [
optionId])
def selectOption(self, optionId):
if self.interactGUI:
self.interactGUI.destroy()
self.interactGUI = None
def getMenuTitle(self):
return ''
def setUserId(self, avId):
self.userId = avId
def getUserId(self):
return self.userId
def setUniqueId(self, uid):
if self.uniqueId != '' and uid != self.uniqueId:
base.cr.uidMgr.removeUid(self.uniqueId)
self.uniqueId = uid
base.cr.uidMgr.addUid(self.uniqueId, self.getDoId())
def getUniqueId(self):
return self.uniqueId
def getWorld(self):
return base.cr.activeWorld
def isInvisibleGhost(self):
return 0
class QuestIndicatorNodeQuestNode(QuestIndicatorNode):
def __init__(self, questStep):
self.pendingStepObj = None
QuestIndicatorNode.__init__(self, 'QuestNodeIndicator',
questStep.nodeSizes, questStep)
def delete(self):
if self.pendingStepObj:
base.cr.relatedObjectMgr.abortRequest(self.pendingStepObj)
self.pendingStepObj = None
self.ignore('tunnelSetLinks')
QuestIndicatorNode.delete(self)
def placeInWorld(self):
originObj = base.cr.doId2do.get(self.questStep.getOriginDoId())
if originObj:
posH = self.questStep.getPosH()
pos = posH[:3]
h = posH[3]
self.reparentTo(originObj)
self.setPos(*pos)
self.setHpr(h, 0, 0)
self.setZoneLODOffset(1, Point3(*self.questStep.getNearOffset()))
placeInWorld = report(types=['frameCount', 'args'],
dConfigParam='quest-indicator')(placeInWorld)
def loadZoneLevel(self, level):
if level == 0:
self.request('At')
elif level == 1:
self.request('Near')
elif level == 2:
self.request('Far')
def unloadZoneLevel(self, level, cacheObs=False):
if level == 0:
self.request('Near')
elif level == 1:
self.request('Far')
elif level == 2:
self.request('Off')
def enterFar(self):
QuestIndicatorNode.enterFar(self)
if self.farEffect:
self.farEffect.setPos(*self.questStep.getNearVis())
def exitFar(self):
QuestIndicatorNode.exitFar(self)
def enterNear(self):
self.startFarEffect()
def exitNear(self):
self.stopFarEffect()
def enterAt(self):
pass
def exitAt(self):
pass
def startFarEffect(self):
QuestIndicatorNode.startFarEffect(self)
if self.farEffect:
self.farEffect.setPos(0, 0, -3.5)
startFarEffect = report(types=['frameCount', 'args'],
dConfigParam='quest-indicator')(startFarEffect)
def updateGuiHints(self, questId):
pass
class PiratesClientRepository(OTPClientRepository):
notify = directNotify.newCategory('PiratesClientRepository')
SupportTutorial = 0
GameGlobalsId = OTP_DO_ID_PIRATES
StopVisibilityEvent = 'pirates-stop-visibility'
def __init__(self, serverVersion, launcher=None):
self.loadingScreen = base.loadingScreen
self.loadingScreen.parent = self
self.accept('connectionIssue', self.loadingScreen.hide)
self.accept('connectionRetrying', self.loadingScreen.show)
OTPClientRepository.__init__(self,
serverVersion,
launcher,
playGame=PlayGame.PlayGame)
self.createAvatarClass = DistributedPlayerPirate.DistributedPlayerPirate
self.tradeManager = None
self.pvpManager = None
self.CentralLogger = self.generateGlobalObject(
OtpDoGlobals.OTP_DO_ID_CENTRAL_LOGGER, 'CentralLogger')
self.avatarManager = self.generateGlobalObject(
OtpDoGlobals.OTP_DO_ID_PIRATES_AVATAR_MANAGER,
'DistributedAvatarManager')
self.chatManager = self.generateGlobalObject(
OtpDoGlobals.OTP_DO_ID_CHAT_MANAGER, 'DistributedChatManager')
self.crewMatchManager = self.generateGlobalObject(
OtpDoGlobals.OTP_DO_ID_PIRATES_CREW_MATCH_MANAGER,
'DistributedCrewMatchManager')
self.avatarFriendsManager = self.generateGlobalObject(
OtpDoGlobals.OTP_DO_ID_AVATAR_FRIENDS_MANAGER,
'PCAvatarFriendsManager')
self.playerFriendsManager = self.generateGlobalObject(
OtpDoGlobals.OTP_DO_ID_PLAYER_FRIENDS_MANAGER,
'PCPlayerFriendsManager')
self.guildManager = self.generateGlobalObject(
OtpDoGlobals.OTP_DO_ID_PIRATES_GUILD_MANAGER, 'PCGuildManager')
self.speedchatRelay = self.generateGlobalObject(
OtpDoGlobals.OTP_DO_ID_PIRATES_SPEEDCHAT_RELAY,
'PiratesSpeedchatRelay')
self.shipLoader = self.generateGlobalObject(
OtpDoGlobals.OTP_DO_ID_PIRATES_SHIP_MANAGER,
'DistributedShipLoader')
self.travelAgent = self.generateGlobalObject(
OtpDoGlobals.OTP_DO_ID_PIRATES_TRAVEL_AGENT,
'DistributedTravelAgent')
base.loadingScreen.tick()
self.matchMaker = self.generateGlobalObject(
OtpDoGlobals.OTP_DO_ID_PIRATES_MATCH_MAKER,
'DistributedMatchMaker')
base.loadingScreen.tick()
self.codeRedemption = self.generateGlobalObject(
OtpDoGlobals.OTP_DO_ID_PIRATES_CODE_REDEMPTION, 'CodeRedemption')
base.loadingScreen.tick()
self.settingsMgr = self.generateGlobalObject(
OtpDoGlobals.OTP_DO_ID_PIRATES_SETTINGS_MANAGER,
'PiratesSettingsMgr')
#self.statusDatabase = self.generateGlobalObject(OtpDoGlobals.OTP_DO_ID_STATUS_DATABASE, 'StatusDatabase')
self.wantSeapatch = base.config.GetBool('want-seapatch', 1)
self.wantSpecialEffects = base.config.GetBool('want-special-effects',
1)
self.wantMakeAPirate = base.config.GetBool('wantMakeAPirate', 0)
self.forceTutorial = base.config.GetBool('force-tutorial', 0)
self.skipTutorial = base.config.GetBool('skip-tutorial', 0)
self.tutorialObject = None
self.avChoiceDoneEvent = None
self.avChoice = None
self.avCreate = None
self.currentCutscene = None
self.activeWorld = None
self.teleportMgr = None
self.treasureMap = None
self.newsManager = None
self.distributedDistrict = None
self.district = None
self.profileMgr = None
self.battleMgr = BattleManager.BattleManager(self)
self.combatAnims = CombatAnimations.CombatAnimations()
self.interactionMgr = InteractionManager.InteractionManager()
self.currCamParent = None
self.uidMgr = UniqueIdManager.UniqueIdManager(self)
self.fakeMSP = None
self.questDynMap = QuestLadderDynMap.QuestLadderDynMap()
self.questDependency = QuestLadderDependency()
self.questChoiceSibsMap = QuestChoiceDynMap()
base.loadingScreen.beginStep('MasterHumans', 52, 45)
self.humanHigh = [MasterHuman.MasterHuman(), MasterHuman.MasterHuman()]
self.humanHigh[0].billboardNode.removeNode()
self.humanHigh[1].billboardNode.removeNode()
self.humanHigh[0].style = HumanDNA.HumanDNA('m')
self.humanHigh[1].style = HumanDNA.HumanDNA('f')
self.humanHigh[0].generateHuman('m')
base.loadingScreen.tick()
self.humanHigh[1].generateHuman('f')
base.loadingScreen.tick()
self.humanHigh[0].ignoreAll()
self.humanHigh[1].ignoreAll()
self.humanHigh[0].stopBlink()
self.humanHigh[1].stopBlink()
self.humanLow = [MasterHuman.MasterHuman(), MasterHuman.MasterHuman()]
self.humanLow[0].billboardNode.removeNode()
self.humanLow[1].billboardNode.removeNode()
self.humanLow[0].style = HumanDNA.HumanDNA('m')
self.humanLow[1].style = HumanDNA.HumanDNA('f')
self.humanLow[0].generateHuman('m')
base.loadingScreen.tick()
self.humanLow[1].generateHuman('f')
base.loadingScreen.tick()
base.loadingScreen.endStep('MasterHumans')
self.humanLow[0].ignoreAll()
self.humanLow[1].ignoreAll()
self.humanLow[0].stopBlink()
self.humanLow[1].stopBlink()
for i in range(2):
self.humanLow[i]._Actor__sortedLODNames = ['500']
del self.humanLow[i]._Actor__partBundleDict['2000']
del self.humanLow[i]._Actor__partBundleDict['1000']
self.humanLow[i].getLOD('2000').detachNode()
self.humanLow[i].getLOD('1000').detachNode()
self.humanLow[i].getLODNode().clearSwitches()
self.humanLow[i].getLODNode().addSwitch(10000, 0)
if base.options.getCharacterDetailSetting() == 0:
self.human = self.humanLow
else:
self.human = self.humanHigh
A = AvatarTypes
del A
self.preloadedCutscenes = {}
self.defaultShard = 0
NametagGlobals.setMasterArrowsOn(0)
self._tagsToInterests = {}
self._interestsToTags = {}
self._worldStack = []
if __dev__:
__builtin__.go = self.getDo
__builtin__.gov = self.getOwnerView
import pdb as pdb
__builtin__.trace = pdb.set_trace
__builtin__.pm = pdb.pm
self.effectTypes = {
'damageSmoke': ['BlackSmoke'],
'damageFire': ['Fire'],
'cannonDeckFire': ['CannonSmokeSimple', 'CannonBlastSmoke'],
'cannonBSFire': [
'MuzzleFlameBS', 'CannonSmokeSimpleBS',
'CannonBlastSmokeBS', 'GrapeshotEffectBS'
],
'cannonHit': ['SimpleSmokeCloud', 'ExplosionFlip'],
'cannonSplash': ['CannonSplash']
}
self.effectToggles = {}
self.cannonballCollisionDebug = 1
self.npcManager = NPCManager.NPCManager()
PotionGlobals.updatePotionBuffDuration(
C_SUMMON_CHICKEN, config.GetInt('summon-duration-chicken', 300))
PotionGlobals.updatePotionBuffDuration(
C_SUMMON_MONKEY, config.GetInt('summon-duration-monkey', 300))
PotionGlobals.updatePotionBuffDuration(
C_SUMMON_WASP, config.GetInt('summon-duration-wasp', 300))
PotionGlobals.updatePotionBuffDuration(
C_SUMMON_DOG, config.GetInt('summon-duration-dog', 300))
def __repr__(self):
return 'PiratesClientRepository'
def gotoFirstScreen(self):
base.loadingScreen.beginStep('PrepLogin', 9, 0.14000000000000001)
self.startReaderPollTask()
self.startHeartbeat()
base.loadingScreen.tick()
self.loginFSM.request('login')
base.loadingScreen.tick()
base.loadingScreen.endStep('PrepLogin')
gotoFirstScreen = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(gotoFirstScreen)
def getActiveWorld(self):
return self.activeWorld
def preloadCutscene(self, name):
if name not in self.preloadedCutscenes:
newCutscene = Cutscene.Cutscene(self, name)
self.preloadedCutscenes[name] = newCutscene
def getPreloadedCutsceneInfo(self, name):
return self.preloadedCutscenes.get(name)
def cleanupPreloadedCutscene(self, name):
plCutscene = self.preloadedCutscenes.get(name)
if plCutscene:
if not plCutscene.isEmpty():
plCutscene.destroy()
del self.preloadedCutscenes[name]
def setActiveWorld(self, world):
self.activeWorld = world
setActiveWorld = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(setActiveWorld)
def clearActiveWorld(self, world):
if self.activeWorld:
if world is self.activeWorld or self.activeWorld.isEmpty():
self.activeWorld = None
clearActiveWorld = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(clearActiveWorld)
def getWaterHeight(self, node):
if self.wantSeapatch and self.activeWorld:
water = self.activeWorld.getWater()
if water:
return water.calcHeight(node=node)
else:
return 0.0
def isOceanEnabled(self):
if self.wantSeapatch and self.activeWorld and self.activeWorld.hasWater(
):
return self.activeWorld.getWater().enabled
return 0
def enterChooseAvatar(self, avList):
base.loadingScreen.beginStep('AvChooser', 14, 10)
self.sendSetAvatarIdMsg(0)
self.handler = self.handleMessageType
if __dev__:
bp.loginCfg()
config_slot = base.config.GetInt('login-pirate-slot', -1)
if config_slot >= 0 and len(avList) > 0:
config_subId = base.config.GetInt('login-pirate-subId',
avList.keys()[0])
slots = avList.get(config_subId, [])
if config_slot in range(len(slots)):
potAv = slots[config_slot]
if isinstance(potAv, PotentialAvatar):
base.cr.loadingScreen.hide()
ConfigVariableInt('login-pirate-slot').setValue(-1)
base.loadingScreen.endStep('AvChooser')
base.cr.avatarManager.sendRequestPlayAvatar(
potAv.id, config_subId)
self.handleAvatarChoice('chose', config_subId,
config_slot)
return None
self.avChoiceDoneEvent = 'avatarChooserDone'
self.avChoice = AvatarChooser(self.loginFSM, self.avChoiceDoneEvent)
base.loadingScreen.tick()
self.avChoice.load()
base.loadingScreen.tick()
self.avChoice.enter()
base.loadingScreen.tick()
self.accept(self.avChoiceDoneEvent,
self._PiratesClientRepository__handleAvatarChooserDone)
base.loadingScreen.endStep('AvChooser')
base.cr.loadingScreen.hide()
enterChooseAvatar = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(enterChooseAvatar)
def __handleAvatarChooserDone(self, doneStatus):
done = doneStatus['mode']
if done == 'exit':
self.notify.info('handleAvatarChooserDone: shutting down')
self.loginFSM.request('shutdown')
return None
(subId, slot) = self.avChoice.getChoice()
self.avChoice.exit()
self.handleAvatarChoice(done, subId, slot)
_PiratesClientRepository__handleAvatarChooserDone = report(
types=['args', 'deltaStamp'],
dConfigParam='teleport')(__handleAvatarChooserDone)
def handleAvatarChoice(self, done, subId, slot):
access = self.accountDetailRecord.subDetails[subId].subAccess
base.setEmbeddedFrameMode(access)
if done == 'chose':
av = self.avList[subId][slot]
if av.dna.getTutorial() < 3 and self.skipTutorial == 0:
self.tutorial = 1
else:
self.tutorial = 0
self.loadingScreen.beginStep('waitForAv')
self.loginFSM.request('waitForSetAvatarResponse', [av])
elif done == 'create':
self.loginFSM.request('createAvatar',
[self.avList[subId], slot, subId])
def exitChooseAvatar(self):
self.handler = None
if self.avChoice:
self.avChoice.exit()
self.avChoice.unload()
self.avChoice = None
if self.avChoiceDoneEvent:
self.ignore(self.avChoiceDoneEvent)
self.avChoiceDoneEvent = None
exitChooseAvatar = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(exitChooseAvatar)
def enterCreateAvatar(self, avList, index, subId):
self.handler = self.handleCreateAvatar
if self.skipTutorial:
self.tutorial = 0
self.avCreate = MakeAPirate(avList, 'makeAPirateComplete', subId,
index, self.isPaid())
self.avCreate.load()
self.avCreate.enter()
self.accept('makeAPirateComplete',
self._PiratesClientRepository__handleMakeAPirate)
self.accept('nameShopCreateAvatar', self.sendCreateAvatarMsg)
else:
self.tutorial = 1
dna = HumanDNA.HumanDNA()
newPotAv = PotentialAvatar(0, ['dbp', '', '', ''], dna, index, 0)
self.avatarManager.sendRequestCreateAvatar(subId)
self.accept('createdNewAvatar', self.handleAvatarCreated,
[newPotAv])
enterCreateAvatar = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(enterCreateAvatar)
def handleAvatarCreated(self, newPotAv, avatarId, subId):
newPotAv.id = avatarId
self.loginFSM.request('waitForSetAvatarResponse', [newPotAv])
handleAvatarCreated = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(handleAvatarCreated)
def __handleMakeAPirate(self):
done = self.avCreate.getDoneStatus()
if done == 'cancel':
self.avCreate.exit()
self.loginFSM.request('chooseAvatar', [self.avList])
elif done == 'created':
self.handleAvatarCreated(self.avCreate.newPotAv,
self.avCreate.avId, self.avCreate.subId)
else:
self.notify.error('Invalid doneStatus from MakeAPirate: ' +
str(done))
_PiratesClientRepository__handleMakeAPirate = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(__handleMakeAPirate)
def exitCreateAvatar(self):
if self.skipTutorial:
self.ignore('makeAPirateComplete')
self.ignore('nameShopPost')
self.ignore('nameShopCreateAvatar')
self.avCreate.exit()
self.avCreate.unload()
self.avCreate = None
self.handler = None
self.ignore('createdNewAvatar')
exitCreateAvatar = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(exitCreateAvatar)
def handleCreateAvatar(self, msgType, di):
if msgType == CLIENT_CREATE_AVATAR_RESP:
self.handleCreateAvatarResponseMsg(di)
else:
self.handleMessageType(msgType, di)
handleCreateAvatar = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(handleCreateAvatar)
def handleCreateAvatarResponseMsg(self, di):
echoContext = di.getUint16()
returnCode = di.getUint8()
if returnCode == 0:
self.avId = di.getUint32()
newPotAv = PotentialAvatar(self.avId, [self.newName, '', '', ''],
self.newDNA, self.newPosition, 1)
self.loginFSM.request('waitForSetAvatarResponse', [newPotAv])
else:
self.notify.error('name rejected')
handleCreateAvatarResponseMsg = report(
types=['args', 'deltaStamp'],
dConfigParam='teleport')(handleCreateAvatarResponseMsg)
def sendGetAvatarsMsg(self):
self.accept('avatarListFailed', self.avatarListFailed)
self.accept('avatarList', self.avatarList)
self.avatarManager.sendRequestAvatarList()
self.defaultShard = 0
sendGetAvatarsMsg = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(sendGetAvatarsMsg)
def avatarListFailed(self, reason):
self.ignore('avatarListFailed')
self.ignore('avatarList')
dialogClass = OTPGlobals.getGlobalDialogClass()
self.avatarListFailedBox = dialogClass(
message=PLocalizer.CRAvatarListFailed,
doneEvent='avatarListFailedAck',
text_wordwrap=18,
style=OTPDialog.Acknowledge)
self.avatarListFailedBox.show()
self.acceptOnce(
'avatarListFailedAck',
self._PiratesClientRepository__handleAvatarListFailedAck)
avatarListFailed = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(avatarListFailed)
def __handleAvatarListFailedAck(self):
self.ignore('avatarListFailedAck')
self.avatarListFailedBox.cleanup()
self.loginFSM.request('shutdown')
_PiratesClientRepository__handleAvatarListFailedAck = report(
types=['args', 'deltaStamp'],
dConfigParam='teleport')(__handleAvatarListFailedAck)
def avatarList(self, avatars):
self.ignore('avatarListFailed')
self.ignore('avatarList')
self.avList = {}
for (subId, avData) in avatars.items():
data = []
self.avList[subId] = data
for av in avData:
if av == OTPGlobals.AvatarSlotAvailable:
data.append(OTPGlobals.AvatarSlotAvailable)
continue
if av == OTPGlobals.AvatarSlotUnavailable:
data.append(OTPGlobals.AvatarSlotUnavailable)
continue
if av == OTPGlobals.AvatarPendingCreate:
data.append(OTPGlobals.AvatarPendingCreate)
continue
avNames = [av['name'], av['wishName'], '', '']
aName = 0
pa = PotentialAvatar(
av['id'],
avNames,
av['dna'],
av['slot'],
aName,
av['creator'] == self.accountDetailRecord.playerAccountId,
av['shared'],
av['online'],
wishState=av['wishState'],
wishName=av['wishName'],
defaultShard=av['defaultShard'],
lastLogout=av['lastLogout'])
data.append(pa)
if self.loginFSM.getCurrentState().getName() == 'chooseAvatar':
self.avChoice.updateAvatarList()
else:
self.loginFSM.request('chooseAvatar', [self.avList])
avatarList = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(avatarList)
def handleGetAvatarsRespMsg(self, di):
pass
handleGetAvatarsRespMsg = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(handleGetAvatarsRespMsg)
def handleGetAvatarsResp2Msg(self, di):
pass
handleGetAvatarsResp2Msg = report(
types=['args', 'deltaStamp'],
dConfigParam='teleport')(handleGetAvatarsResp2Msg)
def handleAvatarResponseMsg(self, di):
self.loadingScreen.endStep('waitForAv')
avatarId = di.getUint32()
returnCode = di.getUint8()
if returnCode == 0:
self.loadingScreen.show(waitForLocation=True, expectedLoadScale=4)
self.loadingScreen.beginStep('LocalAvatar', 36, 120)
localAvatar = LocalPirate(self)
localAvatar.dclass = self.dclassesByName['DistributedPlayerPirate']
localAvatar.doId = avatarId
self.localAvatarDoId = avatarId
self.doId2do[avatarId] = localAvatar
localAvatar.setLocation(parentId=None, zoneId=None)
localAvatar.generate()
localAvatar.updateAllRequiredFields(localAvatar.dclass, di)
self.loadingScreen.endStep('LocalAvatar')
self.loginFSM.request('playingGame')
else:
self.notify.error('Bad avatar: return code %d' % returnCode)
handleAvatarResponseMsg = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(handleAvatarResponseMsg)
def enterWaitForDeleteAvatarResponse(self, potentialAvatar):
raise StandardError, 'This should be handled within AvatarChooser.py'
enterWaitForDeleteAvatarResponse = report(
types=['args', 'deltaStamp'],
dConfigParam='teleport')(enterWaitForDeleteAvatarResponse)
def exitWaitForDeleteAvatarResponse(self):
raise StandardError, 'This should be handled within AvatarChooser.py'
exitWaitForDeleteAvatarResponse = report(
types=['args', 'deltaStamp'],
dConfigParam='teleport')(exitWaitForDeleteAvatarResponse)
def enterPlayingGame(self):
OTPClientRepository.enterPlayingGame(self)
self.doDetectLeaks = False
self.shardFSM = ShardFSM(self)
if localAvatar.style.getTutorial(
) < PiratesGlobals.TUT_MET_JOLLY_ROGER and not (self.skipTutorial):
self.travelAgent.d_requestTutorialTeleport()
elif localAvatar.onWelcomeWorld and not (self.defaultShard):
self.travelAgent.d_requestWelcomeWorldTeleport()
elif self.defaultShard:
self.travelAgent.d_requestLoginTeleport(self.defaultShard)
elif self.avPlayedRecently:
self.travelAgent.d_requestLoginTeleport(localAvatar.defaultShard)
else:
self.travelAgent.d_requestLoginTeleport()
enterPlayingGame = report(types=['args', 'deltaStamp', 'module'],
dConfigParam='teleport')(enterPlayingGame)
def playingGameLocReceived(self, shardId, zoneId):
self.gameFSM.request('waitOnEnterResponses',
[shardId, zoneId, zoneId, -1])
playingGameLocReceived = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(playingGameLocReceived)
def exitPlayingGame(self):
self.shardFSM.request('Off')
ivalMgr.interrupt()
base.ambientMgr.delete()
base.musicMgr.delete()
messenger.send('clientLogout')
for (doId, obj) in self.doId2do.items():
if not isinstance(obj, LocalPirate) and not isinstance(
obj, DistributedDistrict.DistributedDistrict):
if hasattr(self, 'disableObject'):
self.disableObject(doId)
hasattr(self, 'disableObject')
camera.reparentTo(render)
camera.setPos(0, 0, 0)
camera.setHpr(0, 0, 0)
base.transitions.noTransitions()
OTPClientRepository.exitPlayingGame(self)
self.detectLeaks(okTasks=[
'physics-avatar', 'memory-monitor-task', 'multitexFlatten'
],
okEvents=[
'destroy-ToontownLoadingScreenTitle',
'destroy-ToontownLoadingScreenTip',
'destroy-ToontownLoadingScreenWaitBar',
PiratesGlobals.LogoutHotkey,
PiratesGlobals.HideGuiHotkey,
PiratesGlobals.OptionsHotkey, 'close_main_window',
'open_main_window', 'texture_state_changed',
'connectionIssue', 'connectionRetrying',
self.getConnectedEvent()
])
exitPlayingGame = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(exitPlayingGame)
def enterTutorialQuestion(self, hoodId, zoneId, avId):
self._PiratesClientRepository__requestTutorial(hoodId, zoneId, avId)
enterTutorialQuestion = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(enterTutorialQuestion)
def handleTutorialQuestion(self, msgType, di):
if msgType == CLIENT_CREATE_OBJECT_REQUIRED:
self.handleGenerateWithRequired(di)
elif msgType == CLIENT_CREATE_OBJECT_REQUIRED_OTHER:
self.handleGenerateWithRequiredOther(di)
elif msgType == CLIENT_OBJECT_UPDATE_FIELD:
self.handleUpdateField(di)
elif msgType == CLIENT_OBJECT_DISABLE:
self.handleDisable(di)
elif msgType == CLIENT_OBJECT_DISABLE_OWNER:
self.handleDisableOwner(di)
elif msgType == CLIENT_OBJECT_DELETE_RESP:
self.handleDelete(di)
elif msgType == CLIENT_GET_AVATAR_DETAILS_RESP:
self.handleGetAvatarDetailsResp(di)
else:
self.handleUnexpectedMsgType(msgType, di)
handleTutorialQuestion = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(handleTutorialQuestion)
def exitTutorialQuestion(self):
self.handler = None
self.handlerArgs = None
self.ignore('startTutorial')
taskMgr.remove('waitingForTutorial')
exitTutorialQuestion = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(exitTutorialQuestion)
def __requestTutorial(self, hoodId, zoneId, avId):
self.acceptOnce('startTutorial',
self._PiratesClientRepository__handleStartTutorial,
[avId])
messenger.send('requestTutorial')
_PiratesClientRepository__requestTutorial = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(__requestTutorial)
def __handleStartTutorial(self, avId, zoneId):
self.gameFSM.request('playGame', [Tutorial, zoneId, avId])
_PiratesClientRepository__handleStartTutorial = report(
types=['args',
'deltaStamp'], dConfigParam='teleport')(__handleStartTutorial)
def enterWaitOnEnterResponses(self, shardId, hoodId, zoneId, avId):
self.cleanGameExit = False
self.handler = self.handleWaitOnEnterResponses
self.handlerArgs = {'hoodId': hoodId, 'zoneId': zoneId, 'avId': avId}
self.distributedDistrict = self.activeDistrictMap.get(shardId)
self.waitForDatabaseTimeout(requestName='WaitOnEnterResponses')
self.handleSetShardComplete()
enterWaitOnEnterResponses = report(
types=['args', 'deltaStamp',
'module'], dConfigParam='teleport')(enterWaitOnEnterResponses)
def handleSetShardComplete(self):
hoodId = self.handlerArgs['hoodId']
zoneId = self.handlerArgs['zoneId']
avId = self.handlerArgs['avId']
self.uberZoneInterest = self.addInterest(
base.localAvatar.getDefaultShard(), OTPGlobals.UberZone,
'uberZone', 'uberZoneInterestComplete')
self.acceptOnce('uberZoneInterestComplete',
self.uberZoneInterestComplete)
self.waitForDatabaseTimeout(20, requestName='waitingForUberZone')
handleSetShardComplete = report(
types=['args', 'deltaStamp',
'module'], dConfigParam='teleport')(handleSetShardComplete)
def gotTimeSync(self):
self.notify.info('gotTimeSync')
self.ignore('gotTimeSync')
self._PiratesClientRepository__gotTimeSync = 1
self.moveOnFromUberZone()
gotTimeSync = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(gotTimeSync)
def moveOnFromUberZone(self):
if not self._PiratesClientRepository__gotTimeSync:
self.notify.info('Waiting for time sync.')
return None
hoodId = self.handlerArgs['hoodId']
zoneId = self.handlerArgs['zoneId']
avId = self.handlerArgs['avId']
moveOnFromUberZone = report(types=['args', 'deltaStamp'],
dConfigParam='teleport')(moveOnFromUberZone)
def enterGameOff(self):
pass
def exitGameOff(self):
pass
def getFriendFlags(self, doId):
return 0
def isFriend(self, doId):
if not self.avatarFriendsManager.isFriend(doId):
pass
return self.playerFriendsManager.isFriend(doId)
def isFriendOnline(self, doId):
info = self.identifyFriend(doId)
if info:
return info.isOnline()
