Poodletooth-iLand/toontown/hood/GenericAnimatedProp.py

import AnimatedProp
from direct.actor import Actor
from direct.interval.IntervalGlobal import *
from direct.directnotify import DirectNotifyGlobal
from toontown.toonbase import ToontownGlobals
from toontown.hood import ZoneUtil
from toontown.hood import HoodUtil

class GenericAnimatedProp(AnimatedProp.AnimatedProp):
    notify = DirectNotifyGlobal.directNotify.newCategory('GenericAnimatedProp')

    def __init__(self, node):
        AnimatedProp.AnimatedProp.__init__(self, node)
        self.origAnimNameToSound = {}
        code = node.getTag('DNACode')

        if code.startswith('interactive_prop_'):
            pathStr = code[len('interactive_prop_'):].split('__')[0]
        elif code.startswith('animated_prop_generic_'):
            pathStr = code[len('animated_prop_generic_'):].split('__')[0]
        elif code.startswith('animated_prop_'):
            tempStr = code[len('animated_prop_'):]
            nextUnderscore = tempStr.find('_')
            finalStr = tempStr[nextUnderscore + 1:]
            pathStr = finalStr.split('__')[0]

        phaseDelimeter = len('phase_') + pathStr[len('phase_'):].find('_')
        phaseStr = pathStr[:phaseDelimeter]
        pathTokens = pathStr[phaseDelimeter + 1:].split('_')
        self.path = phaseStr

        for path in pathTokens:
            self.path += '/'
            self.path += path

        self.notify.debug('self.path=%s' % self.path)
        self.calcHoodId(node)
        self.propType = HoodUtil.calcPropType(node)
        self.setupActor(node)
        self.code = code

    def delete(self):
        AnimatedProp.AnimatedProp.delete(self)

        if hasattr(self, 'soundNode'):
            self.soundNode.removeNode()
            del self.soundNode

        self.node.cleanup()
        del self.node
        del self.trashcan

    def enter(self):
        self.node.postFlatten()
        AnimatedProp.AnimatedProp.enter(self)
        self.node.loop('anim')

    def exit(self):
        AnimatedProp.AnimatedProp.exit(self)
        self.node.stop()

    def getActor(self):
        return self.node

    def setupActor(self, node):
        anim = node.getTag('DNAAnim')
        self.trashcan = Actor.Actor(node, copy=0)
        self.trashcan.reparentTo(node)
        self.trashcan.loadAnims({'anim': '%s/%s' % (self.path, anim)})
        self.trashcan.pose('anim', 0)
        self.node = self.trashcan

    def calcHoodId(self, node):
        self.hoodId = ToontownGlobals.ToontownCentral
        fullString = str(node)
        splits = fullString.split('/')

        if len(splits) >= 5:
            visId = int(splits[4])
            self.visId = visId
            self.hoodId = ZoneUtil.getCanonicalHoodId(visId)
            self.notify.debug('calcHoodId %d from %s' % (self.hoodId, fullString))
        else:
            self.notify.warning("calcHoodId couldn't parse %s using 0" % fullString)
            self.hoodId = 0
            self.visId = 0

    def createSoundInterval(self, origAnimNameWithPath, maximumDuration):
        if not hasattr(base, 'localAvatar'):
            return Sequence()

        if not hasattr(self, 'soundPath'):
            self.soundPath = self.path.replace('/models/char', '/audio/sfx')

        origAnimName = origAnimNameWithPath.split('/')[-1]
        sound = self.origAnimNameToSound.get(origAnimName)

        if not sound:
            sound = loader.loadSfx('%s/%s.ogg' % (self.soundPath, origAnimName.replace('tt_a_ara', 'tt_s_ara')))
            self.origAnimNameToSound[origAnimName] = sound

        if sound:
            if not hasattr(self, 'soundNode'):
                self.soundNode = render.attachNewNode('Sound Node')
                self.soundNode.setPos(self.trashcan.getBounds().getCenter())

            return SoundInterval(sound, node=self.soundNode, listenerNode=base.localAvatar, volume=1.0, cutOff=45, startTime=0, duration=min(sound.length(), maximumDuration))

        return Sequence()