class DistributedElevatorExt(DistributedElevator.DistributedElevator):
def __init__(self, cr):
DistributedElevator.DistributedElevator.__init__(self, cr)
self.nametag = None
self.currentFloor = -1
return
def setupElevator(self):
if self.isSetup:
self.elevatorSphereNodePath.removeNode()
self.leftDoor = self.bldg.leftDoor
self.rightDoor = self.bldg.rightDoor
DistributedElevator.DistributedElevator.setupElevator(self)
self.setupNametag()
def disable(self):
self.clearNametag()
DistributedElevator.DistributedElevator.disable(self)
def setupNametag(self):
if self.nametag == None:
self.nametag = NametagGroup()
self.nametag.setFont(ToontownGlobals.getBuildingNametagFont())
if TTLocalizer.BuildingNametagShadow:
self.nametag.setShadow(*TTLocalizer.BuildingNametagShadow)
self.nametag.setContents(Nametag.CName)
self.nametag.setColorCode(NametagGroup.CCSuitBuilding)
self.nametag.setActive(0)
self.nametag.setAvatar(self.getElevatorModel())
name = self.cr.playGame.dnaData.getBlock(self.bldg.block).title
if not name:
name = TTLocalizer.CogsInc
else:
name += TTLocalizer.CogsIncExt
self.nametag.setName(name)
self.nametag.manage(base.marginManager)
return
def clearNametag(self):
if self.nametag != None:
self.nametag.unmanage(base.marginManager)
self.nametag.setAvatar(NodePath())
self.nametag.destroy()
self.nametag = None
return
def getBldgDoorOrigin(self):
return self.bldg.getSuitDoorOrigin()
def gotBldg(self, buildingList):
self.bldgRequest = None
self.bldg = buildingList[0]
if not self.bldg:
self.notify.error('setBldgDoId: elevator %d cannot find bldg %d!' % (self.doId, self.bldgDoId))
return
if self.getBldgDoorOrigin():
self.bossLevel = self.bldg.getBossLevel()
self.setupElevator()
else:
self.notify.warning('setBldgDoId: elevator %d cannot find suitDoorOrigin for bldg %d!' % (self.doId, self.bldgDoId))
return
def setFloor(self, floorNumber):
if self.currentFloor >= 0:
if self.bldg.floorIndicator[self.currentFloor]:
self.bldg.floorIndicator[self.currentFloor].setColor(LIGHT_OFF_COLOR)
if floorNumber >= 0:
if self.bldg.floorIndicator[floorNumber]:
self.bldg.floorIndicator[floorNumber].setColor(LIGHT_ON_COLOR)
self.currentFloor = floorNumber
def handleEnterSphere(self, collEntry):
self.notify.debug('Entering Elevator Sphere....')
if hasattr(localAvatar, 'boardingParty') and localAvatar.boardingParty and localAvatar.boardingParty.getGroupLeader(localAvatar.doId) and localAvatar.boardingParty.getGroupLeader(localAvatar.doId) != localAvatar.doId:
base.localAvatar.elevatorNotifier.showMe(TTLocalizer.ElevatorGroupMember)
elif self.allowedToEnter(self.zoneId):
self.cr.playGame.getPlace().detectedElevatorCollision(self)
else:
place = base.cr.playGame.getPlace()
if place:
place.fsm.request('stopped')
self.dialog = TeaserPanel.TeaserPanel(pageName='cogHQ', doneFunc=self.handleOkTeaser)
def handleEnterElevator(self):
if hasattr(localAvatar, 'boardingParty') and localAvatar.boardingParty and localAvatar.boardingParty.getGroupLeader(localAvatar.doId):
if localAvatar.boardingParty.getGroupLeader(localAvatar.doId) == localAvatar.doId:
localAvatar.boardingParty.handleEnterElevator(self)
elif self.elevatorTripId and localAvatar.lastElevatorLeft == self.elevatorTripId:
self.rejectBoard(base.localAvatar.doId, REJECT_SHUFFLE)
elif base.localAvatar.hp > 0:
toon = base.localAvatar
self.sendUpdate('requestBoard', [])
else:
self.notify.warning('Tried to board elevator with hp: %d' % base.localAvatar.hp)
def enterWaitEmpty(self, ts):
self.elevatorSphereNodePath.unstash()
self.forceDoorsOpen()
self.accept(self.uniqueName('enterelevatorSphere'), self.handleEnterSphere)
self.accept(self.uniqueName('enterElevatorOK'), self.handleEnterElevator)
DistributedElevator.DistributedElevator.enterWaitEmpty(self, ts)
def exitWaitEmpty(self):
self.elevatorSphereNodePath.stash()
self.ignore(self.uniqueName('enterelevatorSphere'))
self.ignore(self.uniqueName('enterElevatorOK'))
DistributedElevator.DistributedElevator.exitWaitEmpty(self)
def enterWaitCountdown(self, ts):
DistributedElevator.DistributedElevator.enterWaitCountdown(self, ts)
self.forceDoorsOpen()
self.accept(self.uniqueName('enterElevatorOK'), self.handleEnterElevator)
self.startCountdownClock(self.countdownTime, ts)
def exitWaitCountdown(self):
self.ignore(self.uniqueName('enterElevatorOK'))
DistributedElevator.DistributedElevator.exitWaitCountdown(self)
def getZoneId(self):
return self.bldg.interiorZoneId
def getElevatorModel(self):
np = self.bldg.getSuitElevatorNodePath()
if np.isEmpty():
self.notify.error("np not ok")
return self.bldg.getSuitElevatorNodePath()
class DistributedHouse(DistributedObject.DistributedObject):
notify = directNotify.newCategory('DistributedHouse')
def __init__(self, cr):
DistributedObject.DistributedObject.__init__(self, cr)
self.houseType = 0
self.avId = -1
self.ownerId = 0
self.colorIndex = 0
self.house = None
self.name = ''
self.namePlate = None
self.nameText = None
self.nametag = None
self.floorMat = None
self.matText = None
self.randomGenerator = None
self.housePosInd = 0
self.house_loaded = 0
return
def disable(self):
DistributedObject.DistributedObject.disable(self)
def delete(self):
self.notify.debug('delete')
self.unload()
self.clearNametag()
if self.namePlate:
self.namePlate.removeNode()
del self.namePlate
self.namePlate = None
if self.floorMat:
self.floorMat.removeNode()
del self.floorMat
self.floorMat = None
if self.house:
self.house.removeNode()
del self.house
self.house_loaded = 0
del self.randomGenerator
DistributedObject.DistributedObject.delete(self)
return
def clearNametag(self):
if self.nametag != None:
self.nametag.unmanage(base.marginManager)
self.nametag.setAvatar(NodePath())
self.nametag.destroy()
self.nametag = None
return
def load(self):
self.notify.debug('load')
if not self.house_loaded:
if self.houseType >= len(self.cr.playGame.hood.loader.houseModels):
self.houseType = HouseGlobals.HOUSE_DEFAULT
houseModel = self.cr.playGame.hood.loader.houseModels[self.houseType]
self.house = houseModel.copyTo(self.cr.playGame.hood.loader.houseNode[self.housePosInd])
self.house_loaded = 1
self.cr.playGame.hood.loader.houseId2house[self.doId] = self.house
if self.houseType == HouseGlobals.HOUSE_DEFAULT:
self.__setHouseColor()
if self.houseType == HouseGlobals.HOUSE_DEFAULT or self.houseType == HouseGlobals.HOUSE_TEST:
self.__setupDoor()
else:
self.__setupDoorCustom()
messenger.send('houseLoaded-%d' % self.doId)
def announceGenerate(self):
DistributedObject.DistributedObject.announceGenerate(self)
messenger.send('setBuilding-' + str(self.doId))
def __setupDoor(self):
self.notify.debug('setupDoor')
self.dnaStore = self.cr.playGame.dnaStore
doorModelName = 'door_double_round_ul'
if doorModelName[-1:] == 'r':
doorModelName = doorModelName[:-1] + 'l'
else:
doorModelName = doorModelName[:-1] + 'r'
door = self.dnaStore.findNode(doorModelName)
door_origin = self.house.find('**/door_origin')
door_origin.setHpr(90, 0, 0)
door_origin.setScale(0.6, 0.6, 0.8)
door_origin.setPos(door_origin, 0.5, 0, 0.0)
doorNP = door.copyTo(door_origin)
self.door_origin = door_origin
self.randomGenerator = random.Random()
self.randomGenerator.seed(self.doId)
houseColor = HouseGlobals.stairWood
color = Vec4(houseColor[0], houseColor[1], houseColor[2], 1)
DNADoor.setupDoor(doorNP, door_origin, door_origin, self.dnaStore, str(self.doId), color)
self.__setupNamePlate()
self.__setupFloorMat()
self.__setupNametag()
def __setupDoorCustom(self):
self.randomGenerator = random.Random()
self.randomGenerator.seed(self.doId)
self.notify.debug('setupDoorCustom')
self.dnaStore = self.cr.playGame.dnaStore
door = self.house.find('**/door_0')
door_origin = self.house.find('**/door_origin')
door_origin.setHpr(90, 0, 0)
door_origin.setScale(0.6, 0.6, 0.8)
doorNP = door
self.door_origin = door_origin
color = Vec4(1, 1, 1, 1)
parent = door_origin
rightDoor = door.find('**/rightDoor')
rightDoor.setHpr(door_origin, Vec3(0, 0, 0))
leftDoor = door.find('**/leftDoor')
leftDoor.setHpr(door_origin, Vec3(0, 0, 0))
doorTrigger = doorNP.find('**/door_*_trigger')
doorTrigger.wrtReparentTo(door_origin)
doorTrigger.node().setName('door_trigger_' + str(self.doId))
self.__setupFloorMat(changeColor=False)
self.__setupNametag()
self.__setupNamePlateCustom()
def __setupNamePlate(self):
self.notify.debug('__setupNamePlate')
if self.namePlate:
self.namePlate.removeNode()
del self.namePlate
self.namePlate = None
nameText = TextNode('nameText')
r = self.randomGenerator.random()
g = self.randomGenerator.random()
b = self.randomGenerator.random()
nameText.setTextColor(r, g, b, 1)
nameText.setAlign(nameText.ACenter)
nameText.setFont(ToontownGlobals.getBuildingNametagFont())
nameText.setShadowColor(0, 0, 0, 1)
nameText.setBin('fixed')
if TTLocalizer.BuildingNametagShadow:
nameText.setShadow(*TTLocalizer.BuildingNametagShadow)
nameText.setWordwrap(16.0)
xScale = 1.0
numLines = 0
if self.name == '':
return
else:
houseName = TTLocalizer.AvatarsHouse % TTLocalizer.GetPossesive(self.name, 'house')
nameText.setText(houseName)
self.nameText = nameText
textHeight = nameText.getHeight() - 2
textWidth = nameText.getWidth()
xScale = 1.0
if textWidth > 16:
xScale = 16.0 / textWidth
sign_origin = self.house.find('**/sign_origin')
pos = sign_origin.getPos()
sign_origin.setPosHpr(pos[0], pos[1], pos[2] + 0.15 * textHeight, 90, 0, 0)
self.namePlate = sign_origin.attachNewNode(self.nameText)
self.namePlate.setDepthWrite(0)
self.namePlate.setPos(0, -0.05, 0)
self.namePlate.setScale(xScale)
return nameText
def __setupFloorMat(self, changeColor = True):
if self.floorMat:
self.floorMat.removeNode()
del self.floorMat
self.floorMat = None
mat = self.house.find('**/mat')
if changeColor:
mat.setColor(0.4, 0.357, 0.259, 1.0)
color = HouseGlobals.houseColors[self.housePosInd]
matText = TextNode('matText')
matText.setTextColor(color[0], color[1], color[2], 1)
matText.setAlign(matText.ACenter)
matText.setFont(ToontownGlobals.getBuildingNametagFont())
matText.setShadowColor(0, 0, 0, 1)
matText.setBin('fixed')
if TTLocalizer.BuildingNametagShadow:
matText.setShadow(*TTLocalizer.BuildingNametagShadow)
matText.setWordwrap(10.0)
xScale = 1.0
numLines = 0
if self.name == '':
return
else:
houseName = TTLocalizer.AvatarsHouse % TTLocalizer.GetPossesive(self.name, 'house')
matText.setText(houseName)
self.matText = matText
textHeight = matText.getHeight() - 2
textWidth = matText.getWidth()
xScale = 1.0
if textWidth > 8:
xScale = 8.0 / textWidth
mat_origin = self.house.find('**/mat_origin')
pos = mat_origin.getPos()
mat_origin.setPosHpr(pos[0] - 0.15 * textHeight, pos[1], pos[2], 90, -90, 0)
self.floorMat = mat_origin.attachNewNode(self.matText)
self.floorMat.setDepthWrite(0)
self.floorMat.setPos(0, -.025, 0)
self.floorMat.setScale(0.45 * xScale)
return
def __setupNametag(self):
if self.nametag:
self.clearNametag()
if self.name == '':
houseName = ''
else:
houseName = TTLocalizer.AvatarsHouse % TTLocalizer.GetPossesive(self.name, 'house')
self.nametag = NametagGroup()
self.nametag.setFont(ToontownGlobals.getBuildingNametagFont())
if TTLocalizer.BuildingNametagShadow:
self.nametag.setShadow(*TTLocalizer.BuildingNametagShadow)
self.nametag.setContents(Nametag.CName)
self.nametag.setColorCode(NametagGroup.CCHouseBuilding)
self.nametag.setActive(0)
self.nametag.setAvatar(self.house)
self.nametag.setObjectCode(self.doId)
self.nametag.setName(houseName)
self.nametag.manage(base.marginManager)
def unload(self):
self.notify.debug('unload')
self.ignoreAll()
def setHouseReady(self):
self.notify.debug('setHouseReady')
try:
self.House_initialized
except:
self.House_initialized = 1
self.load()
def setHousePos(self, index):
self.notify.debug('setHousePos')
self.housePosInd = index
self.__setHouseColor()
def setHouseType(self, index):
self.notify.debug('setHouseType')
self.houseType = index
def setFavoriteNum(self, index):
self.notify.debug('setFavoriteNum')
self.favoriteNum = index
def __setHouseColor(self):
if self.house:
bwall = self.house.find('**/*back')
rwall = self.house.find('**/*right')
fwall = self.house.find('**/*front')
lwall = self.house.find('**/*left')
kd = 0.8
color = HouseGlobals.houseColors[self.colorIndex]
dark = (kd * color[0], kd * color[1], kd * color[2])
if not bwall.isEmpty():
bwall.setColor(color[0], color[1], color[2], 1)
if not fwall.isEmpty():
fwall.setColor(color[0], color[1], color[2], 1)
if not rwall.isEmpty():
rwall.setColor(dark[0], dark[1], dark[2], 1)
if not lwall.isEmpty():
lwall.setColor(dark[0], dark[1], dark[2], 1)
aColor = HouseGlobals.atticWood
attic = self.house.find('**/attic')
if not attic.isEmpty():
attic.setColor(aColor[0], aColor[1], aColor[2], 1)
color = HouseGlobals.houseColors2[self.colorIndex]
chimneyList = self.house.findAllMatches('**/chim*')
for chimney in chimneyList:
chimney.setColor(color[0], color[1], color[2], 1)
def setAvId(self, id):
self.avId = id
def setAvatarId(self, avId):
self.notify.debug('setAvatarId = %s' % avId)
self.ownerId = avId
def getAvatarId(self):
self.notify.debug('getAvatarId')
return self.ownerId
def setName(self, name):
self.name = name
if self.nameText and self.nameText.getText() != self.name:
if self.name == '':
self.nameText.setText('')
else:
self.nameText.setText(self.name + "'s\n House")
def getName(self):
return self.name
def b_setColor(self, colorInd):
self.setColor(colorInd)
self.d_setColor(colorInd)
def d_setColor(self, colorInd):
self.sendUpdate('setColor', [colorInd])
def setColor(self, colorInd):
self.colorIndex = colorInd
if self.house:
self.__setHouseColor()
def getColor(self):
return self.colorIndex
def __setupNamePlateCustom(self):
self.notify.debug('__setupNamePlateCustom')
if self.namePlate:
self.namePlate.removeNode()
del self.namePlate
self.namePlate = None
nameText = TextNode('nameText')
nameText.setCardAsMargin(0.1, 0.1, 0.1, 0.1)
nameText.setCardDecal(True)
nameText.setCardColor(1.0, 1.0, 1.0, 0.0)
r = self.randomGenerator.random()
g = self.randomGenerator.random()
b = self.randomGenerator.random()
nameText.setTextColor(r, g, b, 1)
nameText.setAlign(nameText.ACenter)
nameText.setFont(ToontownGlobals.getBuildingNametagFont())
nameText.setShadowColor(0, 0, 0, 1)
nameText.setBin('fixed')
if TTLocalizer.BuildingNametagShadow:
nameText.setShadow(*TTLocalizer.BuildingNametagShadow)
nameText.setWordwrap(16.0)
xScale = 1.0
numLines = 0
if self.name == '':
return
else:
houseName = TTLocalizer.AvatarsHouse % TTLocalizer.GetPossesive(self.name, 'house')
nameText.setText(houseName)
self.nameText = nameText
textHeight = nameText.getHeight() - 2
textWidth = nameText.getWidth()
xScale = 1.0
if textWidth > 16:
xScale = 16.0 / textWidth
sign_origin = self.house.find('**/sign_origin')
pos = sign_origin.getPos()
sign_origin.setPosHpr(pos[0], pos[1], pos[2] + 0.15 * textHeight, 90, 0, 0)
self.namePlate = sign_origin.attachNewNode(self.nameText)
self.namePlate.setDepthWrite(0)
self.namePlate.setPos(0, -0.05, 0)
self.namePlate.setScale(xScale)
return nameText
class DistributedDoor(DistributedObject.DistributedObject, DelayDeletable):
deferFor = 1
def __init__(self, cr):
DistributedObject.DistributedObject.__init__(self, cr)
self.openSfx = base.loadSfx('phase_3.5/audio/sfx/Door_Open_1.ogg')
self.closeSfx = base.loadSfx('phase_3.5/audio/sfx/Door_Close_1.ogg')
self.nametag = None
self.fsm = ClassicFSM.ClassicFSM('DistributedDoor_right', [State.State('off', self.enterOff, self.exitOff, ['closing',
'closed',
'opening',
'open']),
State.State('closing', self.enterClosing, self.exitClosing, ['closed', 'opening']),
State.State('closed', self.enterClosed, self.exitClosed, ['opening']),
State.State('opening', self.enterOpening, self.exitOpening, ['open']),
State.State('open', self.enterOpen, self.exitOpen, ['closing', 'open'])], 'off', 'off')
self.fsm.enterInitialState()
self.exitDoorFSM = ClassicFSM.ClassicFSM('DistributedDoor_left', [State.State('off', self.exitDoorEnterOff, self.exitDoorExitOff, ['closing',
'closed',
'opening',
'open']),
State.State('closing', self.exitDoorEnterClosing, self.exitDoorExitClosing, ['closed', 'opening']),
State.State('closed', self.exitDoorEnterClosed, self.exitDoorExitClosed, ['opening']),
State.State('opening', self.exitDoorEnterOpening, self.exitDoorExitOpening, ['open']),
State.State('open', self.exitDoorEnterOpen, self.exitDoorExitOpen, ['closing', 'open'])], 'off', 'off')
self.exitDoorFSM.enterInitialState()
self.specialDoorTypes = {DoorTypes.EXT_HQ: 0,
DoorTypes.EXT_COGHQ: 0,
DoorTypes.INT_COGHQ: 0,
DoorTypes.EXT_KS: 0,
DoorTypes.INT_KS: 0}
self.doorX = 1.5
return
def generate(self):
DistributedObject.DistributedObject.generate(self)
self.avatarTracks = []
self.avatarExitTracks = []
self.avatarIDList = []
self.avatarExitIDList = []
self.doorTrack = None
self.doorExitTrack = None
return
def disable(self):
self.clearNametag()
taskMgr.remove(self.checkIsDoorHitTaskName())
self.ignore(self.getEnterTriggerEvent())
self.ignore(self.getExitTriggerEvent())
self.ignore('clearOutToonInterior')
self.fsm.request('off')
self.exitDoorFSM.request('off')
if self.__dict__.has_key('building'):
del self.building
self.finishAllTracks()
self.avatarIDList = []
self.avatarExitIDList = []
if hasattr(self, 'tempDoorNodePath'):
self.tempDoorNodePath.removeNode()
del self.tempDoorNodePath
DistributedObject.DistributedObject.disable(self)
def delete(self):
del self.fsm
del self.exitDoorFSM
del self.openSfx
del self.closeSfx
DistributedObject.DistributedObject.delete(self)
def wantsNametag(self):
return not ZoneUtil.isInterior(self.zoneId)
def setupNametag(self):
if not self.wantsNametag():
return
if self.nametag == None:
self.nametag = NametagGroup()
self.nametag.setFont(ToontownGlobals.getBuildingNametagFont())
if TTLocalizer.BuildingNametagShadow:
self.nametag.setShadow(*TTLocalizer.BuildingNametagShadow)
self.nametag.setContents(Nametag.CName)
self.nametag.setColorCode(NametagGroup.CCToonBuilding)
self.nametag.setActive(0)
self.nametag.setAvatar(self.getDoorNodePath())
self.nametag.setObjectCode(self.block)
name = self.cr.playGame.dnaData.getBlock(self.block).title
self.nametag.setName(name)
self.nametag.manage(base.marginManager)
return
def clearNametag(self):
if self.nametag != None:
self.nametag.unmanage(base.marginManager)
self.nametag.setAvatar(NodePath())
self.nametag.destroy()
self.nametag = None
return
def getTriggerName(self):
if self.doorType == DoorTypes.INT_HQ or self.specialDoorTypes.has_key(self.doorType):
return 'door_trigger_' + str(self.block) + '_' + str(self.doorIndex)
else:
return 'door_trigger_' + str(self.block)
def getTriggerName_wip(self):
name = 'door_trigger_%d' % (self.doId,)
return name
def getEnterTriggerEvent(self):
return 'enter' + self.getTriggerName()
def getExitTriggerEvent(self):
return 'exit' + self.getTriggerName()
def hideDoorParts(self):
if self.specialDoorTypes.has_key(self.doorType):
self.hideIfHasFlat(self.findDoorNode('rightDoor'))
self.hideIfHasFlat(self.findDoorNode('leftDoor'))
self.findDoorNode('doorFrameHoleRight').hide()
self.findDoorNode('doorFrameHoleLeft').hide()
else:
return
def setTriggerName(self):
if self.specialDoorTypes.has_key(self.doorType):
building = self.getBuilding()
doorTrigger = building.find('**/door_' + str(self.doorIndex) + '/**/door_trigger*')
doorTrigger.node().setName(self.getTriggerName())
else:
return
def setTriggerName_wip(self):
building = self.getBuilding()
doorTrigger = building.find('**/door_%d/**/door_trigger_%d' % (self.doorIndex, self.block))
if doorTrigger.isEmpty():
doorTrigger = building.find('**/door_trigger_%d' % (self.block,))
if doorTrigger.isEmpty():
doorTrigger = building.find('**/door_%d/**/door_trigger_*' % (self.doorIndex,))
if doorTrigger.isEmpty():
doorTrigger = building.find('**/door_trigger_*')
doorTrigger.node().setName(self.getTriggerName())
def setZoneIdAndBlock(self, zoneId, block):
self.zoneId = zoneId
self.block = block
def setDoorType(self, doorType):
self.notify.debug('Door type = ' + str(doorType) + ' on door #' + str(self.doId))
self.doorType = doorType
def setDoorIndex(self, doorIndex):
self.doorIndex = doorIndex
def setSwing(self, flags):
self.leftSwing = flags & 1 != 0
self.rightSwing = flags & 2 != 0
def setOtherZoneIdAndDoId(self, zoneId, distributedObjectID):
self.otherZoneId = zoneId
self.otherDoId = distributedObjectID
def setState(self, state, timestamp):
self.fsm.request(state, [globalClockDelta.localElapsedTime(timestamp)])
def setExitDoorState(self, state, timestamp):
self.exitDoorFSM.request(state, [globalClockDelta.localElapsedTime(timestamp)])
def announceGenerate(self):
DistributedObject.DistributedObject.announceGenerate(self)
if self.doorType == DoorTypes.INT_HQ:
if not getattr(base.cr, 'hqLoaded', False):
messenger.accept('hqInternalDone', self, self.__doPostAnnounceGenerate)
else:
self.doPostAnnounceGenerate()
else:
self.doPostAnnounceGenerate()
def __doPostAnnounceGenerate(self):
self.ignore('hqInternalDone')
self.doPostAnnounceGenerate()
def doPostAnnounceGenerate(self):
if self.doorType == DoorTypes.INT_STANDARD:
self.bHasFlat = True
else:
self.bHasFlat = not self.findDoorNode('door*flat', True).isEmpty()
self.hideDoorParts()
self.setTriggerName()
self.accept(self.getEnterTriggerEvent(), self.doorTrigger)
self.acceptOnce('clearOutToonInterior', self.doorTrigger)
self.setupNametag()
def getBuilding(self):
if not self.__dict__.has_key('building'):
if self.doorType == DoorTypes.INT_STANDARD:
door = render.find('**/leftDoor;+s')
self.building = door.getParent()
elif self.doorType == DoorTypes.INT_HQ:
door = render.find('**/door_0')
self.building = door.getParent()
elif self.doorType == DoorTypes.INT_KS:
self.building = render.find('**/KartShop_Interior*')
elif self.doorType == DoorTypes.EXT_STANDARD or self.doorType == DoorTypes.EXT_HQ or self.doorType == DoorTypes.EXT_KS:
self.building = self.cr.playGame.hood.loader.geom.find('**/??' + str(self.block) + ':*_landmark_*_DNARoot;+s')
if self.building.isEmpty():
self.building = self.cr.playGame.hood.loader.geom.find('**/??' + str(self.block) + ':animated_building_*_DNARoot;+s')
elif self.doorType == DoorTypes.EXT_COGHQ or self.doorType == DoorTypes.INT_COGHQ:
self.building = self.cr.playGame.hood.loader.geom
else:
self.notify.error('No such door type as ' + str(self.doorType))
return self.building
def getBuilding_wip(self):
if not self.__dict__.has_key('building'):
if self.__dict__.has_key('block'):
self.building = self.cr.playGame.hood.loader.geom.find('**/??' + str(self.block) + ':*_landmark_*_DNARoot;+s')
else:
self.building = self.cr.playGame.hood.loader.geom
print '---------------- door is interior -------'
return self.building
def readyToExit(self):
base.transitions.fadeScreen(1.0)
self.sendUpdate('requestExit')
def avatarEnterDoorTrack(self, avatar, duration):
trackName = 'avatarEnterDoor-%d-%d' % (self.doId, avatar.doId)
track = Parallel(name=trackName)
otherNP = self.getDoorNodePath()
if hasattr(avatar, 'stopSmooth'):
avatar.stopSmooth()
if avatar.doId == base.localAvatar.doId:
track.append(LerpPosHprInterval(nodePath=camera, other=avatar, duration=duration, pos=Point3(0, -8, avatar.getHeight()), hpr=VBase3(0, 0, 0), blendType='easeInOut'))
finalPos = avatar.getParent().getRelativePoint(otherNP, Point3(self.doorX, 2, ToontownGlobals.FloorOffset))
moveHere = Sequence(self.getAnimStateInterval(avatar, 'walk'), LerpPosInterval(nodePath=avatar, duration=duration, pos=finalPos, blendType='easeIn'))
track.append(moveHere)
if avatar.doId == base.localAvatar.doId:
track.append(Sequence(Wait(duration * 0.5), Func(base.transitions.irisOut, duration * 0.5), Wait(duration * 0.5), Func(avatar.b_setParent, ToontownGlobals.SPHidden)))
track.delayDelete = DelayDelete.DelayDelete(avatar, 'avatarEnterDoorTrack')
return track
def avatarEnqueueTrack(self, avatar, duration):
if hasattr(avatar, 'stopSmooth'):
avatar.stopSmooth()
back = -5.0 - 2.0 * len(self.avatarIDList)
if back < -9.0:
back = -9.0
offset = Point3(self.doorX, back, ToontownGlobals.FloorOffset)
otherNP = self.getDoorNodePath()
walkLike = ActorInterval(avatar, 'walk', startTime=1, duration=duration, endTime=0.0001)
standHere = Sequence(LerpPosHprInterval(nodePath=avatar, other=otherNP, duration=duration, pos=offset, hpr=VBase3(0, 0, 0), blendType='easeInOut'), self.getAnimStateInterval(avatar, 'neutral'))
trackName = 'avatarEnqueueDoor-%d-%d' % (self.doId, avatar.doId)
track = Parallel(walkLike, standHere, name=trackName)
track.delayDelete = DelayDelete.DelayDelete(avatar, 'avatarEnqueueTrack')
return track
def getAnimStateInterval(self, avatar, animName):
isSuit = isinstance(avatar, Suit.Suit)
if isSuit:
return Func(avatar.loop, animName, 0)
else:
return Func(avatar.setAnimState, animName)
def isDoorHit(self):
vec = base.localAvatar.getRelativeVector(self.currentDoorNp, self.currentDoorVec)
netScale = self.currentDoorNp.getNetTransform().getScale()
yToTest = vec.getY() / netScale[1]
return yToTest < -0.5
def enterDoor(self):
if self.allowedToEnter():
messenger.send('DistributedDoor_doorTrigger')
self.sendUpdate('requestEnter')
else:
place = base.cr.playGame.getPlace()
if place:
place.fsm.request('stopped')
self.dialog = TeaserPanel.TeaserPanel(pageName='otherHoods', doneFunc=self.handleOkTeaser)
def handleConfirm(self):
status = self.confirm.doneStatus
self.ignore('confirmDone')
self.confirm.cleanup()
del self.confirm
if status == 'ok':
base.localAvatar.enableAvatarControls()
self.accept(self.getExitTriggerEvent(), self.cancelCheckIsDoorHitTask) # Incase people want to try again
def handleOkTeaser(self):
self.accept(self.getEnterTriggerEvent(), self.doorTrigger)
self.dialog.destroy()
del self.dialog
place = base.cr.playGame.getPlace()
if place:
place.fsm.request('walk')
def allowedToEnter(self, zoneId = None):
allowed = False
if hasattr(base, 'ttAccess') and base.ttAccess:
if zoneId:
allowed = base.ttAccess.canAccess(zoneId)
else:
allowed = base.ttAccess.canAccess()
return allowed
def checkIsDoorHitTaskName(self):
return 'checkIsDoorHit' + self.getTriggerName()
def checkIsDoorHitTask(self, task):
if self.isDoorHit():
self.ignore(self.checkIsDoorHitTaskName())
self.ignore(self.getExitTriggerEvent())
self.enterDoor()
return Task.done
return Task.cont
def cancelCheckIsDoorHitTask(self, args):
taskMgr.remove(self.checkIsDoorHitTaskName())
del self.currentDoorNp
del self.currentDoorVec
self.ignore(self.getExitTriggerEvent())
self.accept(self.getEnterTriggerEvent(), self.doorTrigger)
def doorTrigger(self, args = None):
self.ignore(self.getEnterTriggerEvent())
if args == None:
self.enterDoor()
else:
self.currentDoorNp = NodePath(args.getIntoNodePath())
self.currentDoorVec = Vec3(args.getSurfaceNormal(self.currentDoorNp))
if self.isDoorHit():
self.enterDoor()
else:
self.accept(self.getExitTriggerEvent(), self.cancelCheckIsDoorHitTask)
taskMgr.add(self.checkIsDoorHitTask, self.checkIsDoorHitTaskName())
return
def avatarEnter(self, avatarID):
avatar = self.cr.doId2do.get(avatarID, None)
if avatar:
avatar.setAnimState('neutral')
track = self.avatarEnqueueTrack(avatar, 0.5)
track.start()
self.avatarTracks.append(track)
self.avatarIDList.append(avatarID)
return
def rejectEnter(self, reason):
message = FADoorCodes.reasonDict[reason]
if message:
self.__faRejectEnter(message)
else:
self.__basicRejectEnter()
def __basicRejectEnter(self):
self.accept(self.getEnterTriggerEvent(), self.doorTrigger)
if self.cr.playGame.getPlace():
self.cr.playGame.getPlace().setState('walk')
def __faRejectEnter(self, message):
self.rejectDialog = TTDialog.TTGlobalDialog(message=message, doneEvent='doorRejectAck', style=TTDialog.Acknowledge)
self.rejectDialog.show()
self.rejectDialog.delayDelete = DelayDelete.DelayDelete(self, '__faRejectEnter')
event = 'clientCleanup'
self.acceptOnce(event, self.__handleClientCleanup)
base.cr.playGame.getPlace().setState('stopped')
self.acceptOnce('doorRejectAck', self.__handleRejectAck)
self.acceptOnce('stoppedAsleep', self.__handleFallAsleepDoor)
def __handleClientCleanup(self):
if hasattr(self, 'rejectDialog') and self.rejectDialog:
self.rejectDialog.doneStatus = 'ok'
self.__handleRejectAck()
def __handleFallAsleepDoor(self):
self.rejectDialog.doneStatus = 'ok'
self.__handleRejectAck()
def __handleRejectAck(self):
self.ignore('doorRejectAck')
self.ignore('stoppedAsleep')
self.ignore('clientCleanup')
doneStatus = self.rejectDialog.doneStatus
if doneStatus != 'ok':
self.notify.error('Unrecognized doneStatus: ' + str(doneStatus))
self.__basicRejectEnter()
self.rejectDialog.delayDelete.destroy()
self.rejectDialog.cleanup()
del self.rejectDialog
def getDoorNodePath(self):
if self.doorType == DoorTypes.INT_STANDARD:
otherNP = render.find('**/door_origin')
elif self.doorType == DoorTypes.EXT_STANDARD:
otherNP = self.getBuilding().find('**/*door_origin')
elif self.specialDoorTypes.has_key(self.doorType):
building = self.getBuilding()
otherNP = building.find('**/door_origin_' + str(self.doorIndex))
elif self.doorType == DoorTypes.INT_HQ:
otherNP = render.find('**/door_origin_' + str(self.doorIndex))
else:
self.notify.error('No such door type as ' + str(self.doorType))
return otherNP
def avatarExitTrack(self, avatar, duration):
if hasattr(avatar, 'stopSmooth'):
avatar.stopSmooth()
otherNP = self.getDoorNodePath()
trackName = 'avatarExitDoor-%d-%d' % (self.doId, avatar.doId)
track = Sequence(name=trackName)
track.append(self.getAnimStateInterval(avatar, 'walk'))
track.append(PosHprInterval(avatar, Point3(-self.doorX, 0, ToontownGlobals.FloorOffset), VBase3(179, 0, 0), other=otherNP))
track.append(Func(avatar.setParent, ToontownGlobals.SPRender))
if avatar.doId == base.localAvatar.doId:
track.append(PosHprInterval(camera, VBase3(-self.doorX, 5, avatar.getHeight()), VBase3(180, 0, 0), other=otherNP))
if avatar.doId == base.localAvatar.doId:
finalPos = render.getRelativePoint(otherNP, Point3(-self.doorX, -6, ToontownGlobals.FloorOffset))
else:
finalPos = render.getRelativePoint(otherNP, Point3(-self.doorX, -3, ToontownGlobals.FloorOffset))
track.append(LerpPosInterval(nodePath=avatar, duration=duration, pos=finalPos, blendType='easeInOut'))
if avatar.doId == base.localAvatar.doId:
track.append(Func(self.exitCompleted))
track.append(Func(base.transitions.irisIn))
if hasattr(avatar, 'startSmooth'):
track.append(Func(avatar.startSmooth))
track.delayDelete = DelayDelete.DelayDelete(avatar, 'DistributedDoor.avatarExitTrack')
return track
def exitCompleted(self):
base.localAvatar.setAnimState('neutral')
place = self.cr.playGame.getPlace()
if place:
place.setState('walk')
base.localAvatar.d_setParent(ToontownGlobals.SPRender)
def avatarExit(self, avatarID):
if avatarID in self.avatarIDList:
self.avatarIDList.remove(avatarID)
if avatarID == base.localAvatar.doId:
self.exitCompleted()
else:
self.avatarExitIDList.append(avatarID)
def finishDoorTrack(self):
if self.doorTrack:
self.doorTrack.finish()
self.doorTrack = None
return
def finishDoorExitTrack(self):
if self.doorExitTrack:
self.doorExitTrack.finish()
self.doorExitTrack = None
return
def finishAllTracks(self):
self.finishDoorTrack()
self.finishDoorExitTrack()
for t in self.avatarTracks:
t.finish()
DelayDelete.cleanupDelayDeletes(t)
self.avatarTracks = []
for t in self.avatarExitTracks:
t.finish()
DelayDelete.cleanupDelayDeletes(t)
self.avatarExitTracks = []
def enterOff(self):
pass
def exitOff(self):
pass
def getRequestStatus(self):
zoneId = self.otherZoneId
request = {'loader': ZoneUtil.getBranchLoaderName(zoneId),
'where': ZoneUtil.getToonWhereName(zoneId),
'how': 'doorIn',
'hoodId': ZoneUtil.getHoodId(zoneId),
'zoneId': zoneId,
'shardId': None,
'avId': -1,
'allowRedirect': 0,
'doorDoId': self.otherDoId}
return request
def enterClosing(self, ts):
doorFrameHoleRight = self.findDoorNode('doorFrameHoleRight')
if doorFrameHoleRight.isEmpty():
self.notify.warning('enterClosing(): did not find doorFrameHoleRight')
return
rightDoor = self.findDoorNode('rightDoor')
if rightDoor.isEmpty():
self.notify.warning('enterClosing(): did not find rightDoor')
return
otherNP = self.getDoorNodePath()
trackName = 'doorClose-%d' % self.doId
if self.rightSwing:
h = 100
else:
h = -100
self.finishDoorTrack()
self.doorTrack = Sequence(LerpHprInterval(nodePath=rightDoor, duration=1.0, hpr=VBase3(0, 0, 0), startHpr=VBase3(h, 0, 0), other=otherNP, blendType='easeInOut'), Func(doorFrameHoleRight.hide), Func(self.hideIfHasFlat, rightDoor), SoundInterval(self.closeSfx, node=rightDoor), name=trackName)
self.doorTrack.start(ts)
if hasattr(self, 'done'):
request = self.getRequestStatus()
messenger.send('doorDoneEvent', [request])
def exitClosing(self):
pass
def enterClosed(self, ts):
pass
def exitClosed(self):
pass
def enterOpening(self, ts):
doorFrameHoleRight = self.findDoorNode('doorFrameHoleRight')
if doorFrameHoleRight.isEmpty():
self.notify.warning('enterOpening(): did not find doorFrameHoleRight')
return
rightDoor = self.findDoorNode('rightDoor')
if rightDoor.isEmpty():
self.notify.warning('enterOpening(): did not find rightDoor')
return
otherNP = self.getDoorNodePath()
trackName = 'doorOpen-%d' % self.doId
if self.rightSwing:
h = 100
else:
h = -100
self.finishDoorTrack()
self.doorTrack = Parallel(SoundInterval(self.openSfx, node=rightDoor), Sequence(HprInterval(rightDoor, VBase3(0, 0, 0), other=otherNP), Wait(0.4), Func(rightDoor.show), Func(doorFrameHoleRight.show), LerpHprInterval(nodePath=rightDoor, duration=0.6, hpr=VBase3(h, 0, 0), startHpr=VBase3(0, 0, 0), other=otherNP, blendType='easeInOut')), name=trackName)
self.doorTrack.start(ts)
def exitOpening(self):
pass
def enterOpen(self, ts):
for avatarID in self.avatarIDList:
avatar = self.cr.doId2do.get(avatarID)
if avatar:
track = self.avatarEnterDoorTrack(avatar, 1.0)
track.start(ts)
self.avatarTracks.append(track)
if avatarID == base.localAvatar.doId:
self.done = 1
self.avatarIDList = []
def exitOpen(self):
for track in self.avatarTracks:
track.finish()
DelayDelete.cleanupDelayDeletes(track)
self.avatarTracks = []
def exitDoorEnterOff(self):
pass
def exitDoorExitOff(self):
pass
def exitDoorEnterClosing(self, ts):
doorFrameHoleLeft = self.findDoorNode('doorFrameHoleLeft')
if doorFrameHoleLeft.isEmpty():
self.notify.warning('enterOpening(): did not find flatDoors')
return
if self.leftSwing:
h = -100
else:
h = 100
leftDoor = self.findDoorNode('leftDoor')
if not leftDoor.isEmpty():
otherNP = self.getDoorNodePath()
trackName = 'doorExitTrack-%d' % self.doId
self.finishDoorExitTrack()
self.doorExitTrack = Sequence(LerpHprInterval(nodePath=leftDoor, duration=1.0, hpr=VBase3(0, 0, 0), startHpr=VBase3(h, 0, 0), other=otherNP, blendType='easeInOut'), Func(doorFrameHoleLeft.hide), Func(self.hideIfHasFlat, leftDoor), SoundInterval(self.closeSfx, node=leftDoor), name=trackName)
self.doorExitTrack.start(ts)
def exitDoorExitClosing(self):
pass
def exitDoorEnterClosed(self, ts):
pass
def exitDoorExitClosed(self):
pass
def exitDoorEnterOpening(self, ts):
doorFrameHoleLeft = self.findDoorNode('doorFrameHoleLeft')
if doorFrameHoleLeft.isEmpty():
self.notify.warning('enterOpening(): did not find flatDoors')
return
leftDoor = self.findDoorNode('leftDoor')
if self.leftSwing:
h = -100
else:
h = 100
if not leftDoor.isEmpty():
otherNP = self.getDoorNodePath()
trackName = 'doorDoorExitTrack-%d' % self.doId
self.finishDoorExitTrack()
self.doorExitTrack = Parallel(SoundInterval(self.openSfx, node=leftDoor), Sequence(Func(leftDoor.show), Func(doorFrameHoleLeft.show), LerpHprInterval(nodePath=leftDoor, duration=0.6, hpr=VBase3(h, 0, 0), startHpr=VBase3(0, 0, 0), other=otherNP, blendType='easeInOut')), name=trackName)
self.doorExitTrack.start(ts)
else:
self.notify.warning('exitDoorEnterOpening(): did not find leftDoor')
def exitDoorExitOpening(self):
pass
def exitDoorEnterOpen(self, ts):
for avatarID in self.avatarExitIDList:
avatar = self.cr.doId2do.get(avatarID)
if avatar:
track = self.avatarExitTrack(avatar, 0.2)
track.start()
self.avatarExitTracks.append(track)
self.avatarExitIDList = []
def exitDoorExitOpen(self):
for track in self.avatarExitTracks:
track.finish()
DelayDelete.cleanupDelayDeletes(track)
self.avatarExitTracks = []
def findDoorNode(self, string, allowEmpty = False):
building = self.getBuilding()
if not building:
self.notify.warning('getBuilding() returned None, avoiding crash, remark 896029')
foundNode = None
else:
foundNode = building.find('**/door_' + str(self.doorIndex) + '/**/' + string + '*;+s+i')
if foundNode.isEmpty():
foundNode = building.find('**/' + string + '*;+s+i')
if allowEmpty:
return foundNode
return foundNode
def hideIfHasFlat(self, node):
if self.bHasFlat:
node.hide()