import random
import math
import time
import re
import zlib
from direct.interval.IntervalGlobal import *
from direct.distributed.ClockDelta import *
from direct.showbase.PythonUtil import *
from direct.gui.DirectGui import *
from direct.task import Task
from direct.showbase import PythonUtil
from direct.directnotify import DirectNotifyGlobal
from direct.gui import DirectGuiGlobals
from pandac.PandaModules import *
from libotp import *
from otp.avatar import LocalAvatar
from otp.login import LeaveToPayDialog
from otp.avatar import PositionExaminer
from otp.otpbase import OTPGlobals
from otp.avatar import DistributedPlayer
from toontown.shtiker import ShtikerBook
from toontown.shtiker import InventoryPage
from toontown.shtiker import MapPage
from toontown.shtiker import OptionsPage
from toontown.shtiker import ShardPage
from toontown.shtiker import QuestPage
from toontown.shtiker import TrackPage
from toontown.shtiker import KartPage
from toontown.shtiker import GardenPage
from toontown.shtiker import GolfPage
from toontown.shtiker import SuitPage
from toontown.shtiker import DisguisePage
from toontown.shtiker import PhotoAlbumPage
from toontown.shtiker import FishPage
from toontown.shtiker import NPCFriendPage
from toontown.shtiker import EventsPage
from toontown.shtiker import TIPPage
from toontown.quest import Quests
from toontown.quest import QuestParser
from toontown.toonbase.ToontownGlobals import *
from toontown.toonbase import ToontownGlobals
from toontown.toonbase import TTLocalizer
from toontown.catalog import CatalogNotifyDialog
from toontown.chat import ToontownChatManager
from toontown.chat import TTTalkAssistant
from toontown.estate import GardenGlobals
from toontown.battle.BattleSounds import *
from toontown.battle import Fanfare
from toontown.parties import PartyGlobals
from toontown.toon import ElevatorNotifier
from toontown.toon import ToonDNA
import DistributedToon
import Toon
import LaffMeter
from toontown.quest import QuestMap
from toontown.toon.DistributedNPCToonBase import DistributedNPCToonBase
WantNewsPage = base.config.GetBool('want-news-page', ToontownGlobals.DefaultWantNewsPageSetting)
from toontown.toontowngui import NewsPageButtonManager
if WantNewsPage:
from toontown.shtiker import NewsPage
AdjustmentForNewsButton = -0.275
ClaraBaseXPos = 1.45
if (__debug__):
import pdb
class LocalToon(DistributedToon.DistributedToon, LocalAvatar.LocalAvatar):
neverDisable = 1
piePowerSpeed = base.config.GetDouble('pie-power-speed', 0.2)
piePowerExponent = base.config.GetDouble('pie-power-exponent', 0.75)
def __init__(self, cr):
try:
self.LocalToon_initialized
except:
self.LocalToon_initialized = 1
self.numFlowers = 0
self.maxFlowerBasket = 0
DistributedToon.DistributedToon.__init__(self, cr)
chatMgr = ToontownChatManager.ToontownChatManager(cr, self)
talkAssistant = TTTalkAssistant.TTTalkAssistant()
LocalAvatar.LocalAvatar.__init__(self, cr, chatMgr, talkAssistant, passMessagesThrough=True)
self.soundRun = base.loader.loadSfx('phase_3.5/audio/sfx/AV_footstep_runloop.wav')
self.soundWalk = base.loader.loadSfx('phase_3.5/audio/sfx/AV_footstep_walkloop.wav')
self.soundWhisper = base.loader.loadSfx('phase_3.5/audio/sfx/GUI_whisper_3.mp3')
self.soundPhoneRing = base.loader.loadSfx('phase_3.5/audio/sfx/telephone_ring.mp3')
self.soundSystemMessage = base.loader.loadSfx('phase_3/audio/sfx/clock03.mp3')
self.positionExaminer = PositionExaminer.PositionExaminer()
friendsGui = loader.loadModel('phase_3.5/models/gui/friendslist_gui')
friendsButtonNormal = friendsGui.find('**/FriendsBox_Closed')
friendsButtonPressed = friendsGui.find('**/FriendsBox_Rollover')
friendsButtonRollover = friendsGui.find('**/FriendsBox_Rollover')
newScale = oldScale = 0.8
if WantNewsPage:
newScale = oldScale * ToontownGlobals.NewsPageScaleAdjust
self.bFriendsList = DirectButton(image=(friendsButtonNormal, friendsButtonPressed, friendsButtonRollover), relief=None, pos=(1.192, 0, 0.875), scale=newScale, text=('', TTLocalizer.FriendsListLabel, TTLocalizer.FriendsListLabel), text_scale=0.09, text_fg=Vec4(1, 1, 1, 1), text_shadow=Vec4(0, 0, 0, 1), text_pos=(0, -0.18), text_font=ToontownGlobals.getInterfaceFont(), command=self.sendFriendsListEvent)
self.bFriendsList.hide()
self.friendsListButtonActive = 0
self.friendsListButtonObscured = 0
self.moveFurnitureButtonObscured = 0
self.clarabelleButtonObscured = 0
friendsGui.removeNode()
self.__furnitureGui = None
self.__clarabelleButton = None
self.__clarabelleFlash = None
self.furnitureManager = None
self.furnitureDirector = None
self.gotCatalogNotify = 0
self.__catalogNotifyDialog = None
self.accept('phaseComplete-5.5', self.loadPhase55Stuff)
Toon.loadDialog()
self.isIt = 0
self.cantLeaveGame = 0
self.tunnelX = 0.0
self.estate = None
self.__pieBubble = None
self.allowPies = 0
self.__pieButton = None
self.__piePowerMeter = None
self.__piePowerMeterSequence = None
self.__pieButtonType = None
self.__pieButtonCount = None
self.tossPieStart = None
self.__presentingPie = 0
self.__pieSequence = 0
self.wantBattles = base.config.GetBool('want-battles', 1)
self.seeGhosts = base.config.GetBool('see-ghosts', 0)
wantNameTagAvIds = base.config.GetBool('want-nametag-avids', 0)
if wantNameTagAvIds:
messenger.send('nameTagShowAvId', [])
base.idTags = 1
self.glitchX = 0
self.glitchY = 0
self.glitchZ = 0
self.glitchCount = 0
self.ticker = 0
self.glitchOkay = 1
self.tempGreySpacing = 0
self.wantStatePrint = base.config.GetBool('want-statePrint', 0)
self.__gardeningGui = None
self.__gardeningGuiFake = None
self.__shovelButton = None
self.shovelRelatedDoId = 0
self.shovelAbility = ''
self.plantToWater = 0
self.shovelButtonActiveCount = 0
self.wateringCanButtonActiveCount = 0
self.showingWateringCan = 0
self.showingShovel = 0
self.touchingPlantList = []
self.inGardenAction = None
self.guiConflict = 0
self.lastElevatorLeft = 0
self.elevatorNotifier = ElevatorNotifier.ElevatorNotifier()
self.accept(OTPGlobals.AvatarFriendAddEvent, self.sbFriendAdd)
self.accept(OTPGlobals.AvatarFriendUpdateEvent, self.sbFriendUpdate)
self.accept(OTPGlobals.AvatarFriendRemoveEvent, self.sbFriendRemove)
self._zoneId = None
self.accept('system message aknowledge', self.systemWarning)
self.systemMsgAckGuiDoneEvent = 'systemMsgAckGuiDoneEvent'
self.accept(self.systemMsgAckGuiDoneEvent, self.hideSystemMsgAckGui)
self.systemMsgAckGui = None
self.createSystemMsgAckGui()
if not hasattr(base.cr, 'lastLoggedIn'):
base.cr.lastLoggedIn = self.cr.toontownTimeManager.convertStrToToontownTime('')
self.setLastTimeReadNews(base.cr.lastLoggedIn)
self.acceptingNewFriends = Settings.getAcceptingNewFriends() and base.config.GetBool('accepting-new-friends-default', True)
self.acceptingNonFriendWhispers = Settings.getAcceptingNonFriendWhispers() and base.config.GetBool('accepting-non-friend-whispers-default', True)
self.physControls.event.addAgainPattern('again%in')
self.oldPos = None
self.questMap = None
self.prevToonIdx = 0
def wantLegacyLifter(self):
return True
def startGlitchKiller(self):
if localAvatar.getZoneId() not in GlitchKillerZones:
return
if __dev__:
self.glitchMessage = 'START GLITCH KILLER'
randChoice = random.randint(0, 3)
if randChoice == 0:
self.glitchMessage = 'START GLITCH KILLER'
elif randChoice == 1:
self.glitchMessage = 'GLITCH KILLER ENGAGED'
elif randChoice == 2:
self.glitchMessage = 'GLITCH KILLER GO!'
elif randChoice == 3:
self.glitchMessage = 'GLITCH IN YO FACE FOOL!'
self.notify.debug(self.glitchMessage)
taskMgr.remove(self.uniqueName('glitchKiller'))
taskMgr.add(self.glitchKiller, self.uniqueName('glitchKiller'))
self.glitchOkay = 1
def pauseGlitchKiller(self):
self.tempGreySpacing = 1
def unpauseGlitchKiller(self):
self.tempGreySpacing = 0
def stopGlitchKiller(self):
if __dev__ and hasattr(self, 'glitchMessage'):
if self.glitchMessage == 'START GLITCH KILLER':
self.notify.debug('STOP GLITCH KILLER')
elif self.glitchMessage == 'GLITCH KILLER ENGAGED':
self.notify.debug('GLITCH KILLER DISENGAGED')
elif self.glitchMessage == 'GLITCH KILLER GO!':
self.notify.debug('GLITCH KILLER NO GO!')
elif self.glitchMessage == 'GLITCH IN YO FACE FOOL!':
self.notify.debug('GLITCH OFF YO FACE FOOL!')
taskMgr.remove(self.uniqueName('glitchKiller'))
self.glitchOkay = 1
def glitchKiller(self, taskFooler = 0):
if base.greySpacing or self.tempGreySpacing:
return Task.cont
self.ticker += 1
if not self.physControls.lifter.hasContact() and not self.glitchOkay:
self.glitchCount += 1
else:
self.glitchX = self.getX()
self.glitchY = self.getY()
self.glitchZ = self.getZ()
self.glitchCount = 0
if self.physControls.lifter.hasContact():
self.glitchOkay = 0
if hasattr(self, 'physControls'):
if self.ticker >= 10:
self.ticker = 0
if self.glitchCount >= 7:
print 'GLITCH MAXED!!! resetting pos'
self.setX(self.glitchX - 1 * (self.getX() - self.glitchX))
self.setY(self.glitchY - 1 * (self.getY() - self.glitchY))
self.glitchCount = 0
return Task.cont
def announceGenerate(self):
self.startLookAround()
if base.wantNametags:
self.nametag.manage(base.marginManager)
self.startHackObservation()
DistributedToon.DistributedToon.announceGenerate(self)
from otp.friends import FriendInfo
def toonPosCheck(self, task = None):
toon = random.choice(self.cr.toons.values())
if toon and toon is not self and not isinstance(toon, DistributedNPCToonBase):
self.notify.debug('checking position for %s' % toon.doId)
realTimeStart = globalClock.getRealTime()
numOtherToons = len(self.cr.toons.values())
for otherToonIdxBase in range(numOtherToons):
otherToonIdx = otherToonIdxBase + self.prevToonIdx
if otherToonIdx >= numOtherToons:
otherToonIdx = otherToonIdx % numOtherToons
if globalClock.getRealTime() > realTimeStart + AV_TOUCH_CHECK_TIMELIMIT_CL:
self.notify.debug('too much time, exiting at index %s' % otherToonIdx)
self.prevToonIdx = otherToonIdx
break
otherToon = self.cr.toons.values()[otherToonIdx]
self.notify.debug('comparing with toon %s at index %s' % (otherToon.doId, otherToonIdx))
if otherToon and otherToon is not toon and otherToon is not self and not isinstance(otherToon, DistributedNPCToonBase):
toonPos = toon.getPos(render)
otherToonPos = otherToon.getPos(render)
self.notify.debug('pos1: %s pos2: %s' % (toonPos, otherToonPos))
zDist = otherToonPos.getZ() - toonPos.getZ()
toonPos.setZ(0)
otherToonPos.setZ(0)
moveVec = otherToonPos - toonPos
dist = moveVec.length()
self.notify.debug('distance to %s is %s %s' % (otherToon.doId, dist, zDist))
if dist < AV_TOUCH_CHECK_DIST and zDist < AV_TOUCH_CHECK_DIST_Z:
self.notify.debug('inappropriate touching!!!')
if toon.getParent() == render:
toonToMoveId = toon.doId
toonToNotMoveId = otherToon.doId
else:
toonToMoveId = otherToon.doId
toonToNotMoveId = toon.doId
self.sendUpdate('flagAv', [toonToMoveId, AV_FLAG_REASON_TOUCH, [str(toonToNotMoveId)]])
self.prevToonIdx = otherToonIdx
break
self.notify.debug('spent %s seconds doing pos check for %s' % (globalClock.getRealTime() - realTimeStart, toon.doId))
return Task.again
def tmdcc(self, task = None):
toon = random.choice(self.cr.toons.values())
result = self._tmdcc(toon)
if task:
if result:
task.setDelay(5.0)
else:
task.setDelay(1.5)
return Task.again
def _tmdcc(self, toon, checks = []):
result = None
if isinstance(toon, DistributedNPCToonBase) or toon is localAvatar or toon.isEmpty() or toon.bFake or toon._delayDeleteForceAllow:
return result
startTime = globalClock.getRealTime()
def delayedSend(toon, msg):
if toon:
toon.sendLogSuspiciousEvent(msg)
return Task.done
def sendT(header, msg, sToon, sendFooter = False, sendLs = True):
uid = '[' + str(globalClock.getRealTime()) + ']'
msgSize = 800 - (len(header) + len(uid) + 1)
uname = self.uniqueName('ioorrd234')
currCounter = 0
def sendAsParts(message, counter):
for currBlock in range(0, len(message) / msgSize + 1):
fmsg = '%s %02d: ' % (uid, currBlock + counter) + header + ': "%s"' % message[currBlock * msgSize:currBlock * msgSize + msgSize]
taskMgr.doMethodLater(0.08 * (currBlock + counter), delayedSend, uname + str(currBlock + counter), extraArgs=[sToon, fmsg])
return currBlock + counter + 1
currCounter = sendAsParts(msg, currCounter)
if sendLs:
sstream = StringStream.StringStream()
sToon.ls(sstream)
sdata = sstream.getData()
currCounter = sendAsParts(sdata, currCounter)
if sendFooter:
sstream.clearData()
if hasattr(sToon, 'suitGeom'):
sToon.suitGeom.ls(sstream)
bs = ''
nodeNames = config.GetString('send-suspicious-bam', 'to_head')
if nodeNames != '':
bs = ' bam ' + nodeNames + ': '
nodesToLog = []
for currName in nodeNames.split():
nodesToLog.append(sToon.find('**/' + currName))
for currNode in nodesToLog:
bs += zlib.compress(currNode.encodeToBamStream()).encode('hex') + '_'
footer = 'loc: %s dna: %s gmname: %s ntag: %s ceffect: %s disguise: %s sstyle: %s sgeom: %s %s' % (str(sToon.getLocation()),
str(sToon.style.asTuple()),
sToon.gmNameTagEnabled,
str(sToon.nametag and sToon.nametag.getContents()),
str(sToon.cheesyEffect),
sToon.isDisguised,
hasattr(sToon, 'suit') and str(sToon.suit.style),
hasattr(sToon, 'suitGeom') and sstream.getData(),
bs)
currCounter = sendAsParts(footer, currCounter)
self.sendUpdate('requestPing', [toon.doId])
if not checks:
numChecks = 6
checks = [random.choice(range(1, numChecks + 1))]
def findParentAv(node):
avId = 0
topParent = node
while topParent and not topParent.getTag('avatarDoId'):
topParent = topParent.getParent()
if topParent:
avIdStr = topParent.getTag('avatarDoId')
if avIdStr:
avId = int(avIdStr)
return (self.cr.getDo(avId), avId)
msgHeader = 'AvatarHackWarning!'
def hacker_detect_immediate(cbdata):
action = cbdata.getAction()
node = cbdata.getNode()
np = NodePath(node)
if not self.cr or not self.cr.distributedDistrict or not self.cr.distributedDistrict.getAllowAHNNLog():
if self.cr and self.cr.distributedDistrict:
sToon, avId = findParentAv(np)
if sToon is localAvatar:
return
if sToon and isinstance(sToon, DistributedToon.DistributedToon):
msg = "Blocking '%s' '%s' '%s'" % (self.cr.distributedDistrict.getAllowAHNNLog(), np, re.sub('<', '[', StackTrace(start=1).compact()))
sendT(msgHeader, msg, sToon, sendFooter=False, sendLs=False)
return
try:
parentNames = ['__Actor_modelRoot', 'to_head']
newParent = np.getParent()
if newParent and newParent.getName() in parentNames:
newParentParent = newParent.getParent()
parentParentNames = ['actorGeom', '__Actor_modelRoot']
if newParentParent and newParentParent.getName() in parentParentNames:
sToon, avId = findParentAv(newParentParent.getParent())
if sToon is localAvatar:
return
header = msgHeader + ' nodename'
avInfo = "hacker activity '%s' avatar %s node name '%s' with parents '%s' and '%s'!" % (action,
avId,
np.getName(),
newParent.getName(),
newParentParent.getName())
if sToon and isinstance(sToon, DistributedToon.DistributedToon):
avInfo += ' trace: '
avInfo += re.sub('<', '[', StackTrace(start=1).compact())
sendT(header, avInfo, sToon=sToon, sendFooter=True)
else:
sendLogSuspiciousEvent(header, 'got non-toon or missing parent %s...' % sToon + avInfo)
except:
pass
if config.GetBool('detect-suspicious-nodename', True):
PandaNode.setDetectCallback(PythonCallbackObject(hacker_detect_immediate))
def trackChat(chattingToon):
def _spoke(cbdata):
avId = cbdata.getId()
av = self.cr.getDo(avId)
chat = cbdata.getChat()
if avId != localAvatar.doId and av:
avInfo = 'suspicious chat "%s" trace: ' % chat
avInfo += re.sub('<', '[', StackTrace(start=1).compact())
sendT(msgHeader + ' chat', avInfo, chattingToon, sendFooter=False, sendLs=False)
chattingToon.nametag.setChatCallback(PythonCallbackObject(_spoke))
chattingToon.nametag.setChatCallbackId(chattingToon.doId)
if 1 in checks:
if base.config.GetBool('tmdcc-headcheck', 1):
headNodes = toon.findAllMatches('**/__Actor_head')
if len(headNodes) != 3 or not toon.getGeomNode().isHidden() and filter(lambda x: x.isHidden(), headNodes):
sendT(msgHeader, 'missing head node', toon)
result = toon
if base.config.GetBool('tmdcc-chatcheck', 1):
trackChat(toon)
else:
checks.append(2)
if 2 in checks:
if base.config.GetBool('tmdcc-handcheck', 1):
if not toon.getGeomNode().isHidden():
handNodes = toon.findAllMatches('**/hands')
for currHandNode in handNodes:
if currHandNode.hasColor() and currHandNode.getColor() != VBase4(1, 1, 1, 1):
sendT(msgHeader, 'invalid hand color: %s' % currHandNode.getColor(), toon)
result = toon
break
else:
checks.append(3)
if 3 in checks:
if base.config.GetBool('tmdcc-namecheck', 1):
nameNode = toon.find('**/nametag3d')
if not nameNode or nameNode.isHidden() and not toon.getGeomNode().isHidden() and toon.ghostMode == 0:
sendT(msgHeader, 'missing nametag for name: %s' % toon.getName(), toon)
result = toon
else:
checks.append(4)
if 4 in checks:
if base.config.GetBool('tmdcc-animcheck', 1):
if toon.zoneId in [ToontownGlobals.DonaldsDock,
ToontownGlobals.OutdoorZone,
ToontownGlobals.ToontownCentral,
ToontownGlobals.TheBrrrgh,
ToontownGlobals.MinniesMelodyland,
ToontownGlobals.DaisyGardens,
ToontownGlobals.FunnyFarm,
ToontownGlobals.GoofySpeedway,
ToontownGlobals.DonaldsDreamland]:
currAnim = toon.animFSM.getCurrentState().getName()
if currAnim != None and currAnim not in ['neutral',
'Happy',
'off',
'Sad',
'TeleportIn',
'jumpAirborne',
'CloseBook',
'run',
'OpenBook',
'TeleportOut',
'TeleportedOut',
'ReadBook',
'walk',
'Sit',
'jumpLand',
'Sleep',
'cringe',
'jumpSquat',
'Died']:
sendT(msgHeader, 'invalid animation playing: %s' % currAnim, toon)
result = toon
else:
checks.append(5)
if 5 in checks:
if base.config.GetBool('tmdcc-cogsuit', 1):
if toon.zoneId in [ToontownGlobals.DonaldsDock,
ToontownGlobals.OutdoorZone,
ToontownGlobals.ToontownCentral,
ToontownGlobals.TheBrrrgh,
ToontownGlobals.MinniesMelodyland,
ToontownGlobals.DaisyGardens,
ToontownGlobals.FunnyFarm,
ToontownGlobals.GoofySpeedway,
ToontownGlobals.DonaldsDreamland]:
if toon.isDisguised:
sendT(msgHeader, 'toon %s is in a cog suit' % toon.getName(), toon)
result = toon
else:
checks.append(6)
if 6 in checks:
if base.config.GetBool('tmdcc-colorcheck', 1):
torsoPieces = toon.getPieces(('torso', ('arms', 'neck')))
legPieces = toon.getPieces(('legs', ('legs', 'feet')))
headPieces = toon.getPieces(('head', '*head*'))
if (filter(lambda x: x.hasColor() and x.getColor() not in ToonDNA.allowedColors,
torsoPieces) or
filter(lambda x: x.hasColor() and x.getColor() not in ToonDNA.allowedColors,
legPieces) or
filter(lambda x: x.hasColor() and x.getColor() not in ToonDNA.allowedColors,
headPieces)) and toon.cheesyEffect == ToontownGlobals.CENormal:
torsoColors = str(map(lambda x: not x.hasColor() and 'clear' or x.getColor() in ToonDNA.allowedColors and 'ok' or x.getColor(), torsoPieces))
legColors = str(map(lambda x: not x.hasColor() and 'clear' or x.getColor() in ToonDNA.allowedColors and 'ok' or x.getColor(), legPieces))
headColors = str(map(lambda x: not x.hasColor() and 'clear' or x.getColor() in ToonDNA.allowedColors and 'ok' or x.getColor(), headPieces))
sendT(msgHeader, 'invalid color...arm: %s leg: %s head: %s' % (torsoColors, legColors, headColors), toon)
result = toon
else:
checks.append(7)
endTime = globalClock.getRealTime()
return result
def startHackObservation(self):
taskMgr.doMethodLater(AV_TOUCH_CHECK_DELAY_CL, self.toonPosCheck, self.uniqueName('toonPosCheck'))
taskMgr.doMethodLater(config.GetDouble('tmdcc-delay', 5.0), self.tmdcc, self.uniqueName('tmdcc'))
if __dev__ and base.config.GetBool('tmdcc-keys', 0):
from toontown.testenv import safezoneAutoVisit
safezoneAutoVisit.setupKeys()
from toontown.testenv import watchDistObj
watchDistObj.watchObj.setupKeys()
def stopHackObservation(self):
taskMgr.remove(self.uniqueName('toonPosCheck'))
taskMgr.remove(self.uniqueName('tmdcc'))
def disable(self):
self.stopHackObservation()
self.laffMeter.destroy()
del self.laffMeter
self.questMap.destroy()
self.questMap = None
if hasattr(self, 'purchaseButton'):
self.purchaseButton.destroy()
del self.purchaseButton
self.newsButtonMgr.request('Off')
base.whiteList.unload()
self.book.unload()
del self.optionsPage
del self.shardPage
del self.mapPage
del self.invPage
del self.questPage
del self.suitPage
del self.sosPage
del self.disguisePage
del self.fishPage
del self.gardenPage
del self.trackPage
del self.book
if base.wantKarts:
if hasattr(self, 'kartPage'):
del self.kartPage
if base.wantNametags:
self.nametag.unmanage(base.marginManager)
taskMgr.removeTasksMatching('*ioorrd234*')
self.ignoreAll()
DistributedToon.DistributedToon.disable(self)
return
def disableBodyCollisions(self):
pass
def delete(self):
try:
self.LocalToon_deleted
except:
self.LocalToon_deleted = 1
Toon.unloadDialog()
QuestParser.clear()
DistributedToon.DistributedToon.delete(self)
LocalAvatar.LocalAvatar.delete(self)
self.bFriendsList.destroy()
del self.bFriendsList
if self.__pieButton:
self.__pieButton.destroy()
self.__pieButton = None
if self.__piePowerMeter:
self.__piePowerMeter.destroy()
self.__piePowerMeter = None
taskMgr.remove('unlockGardenButtons')
taskMgr.remove('lerpFurnitureButton')
if self.__furnitureGui:
self.__furnitureGui.destroy()
del self.__furnitureGui
if self.__gardeningGui:
self.__gardeningGui.destroy()
del self.__gardeningGui
if self.__gardeningGuiFake:
self.__gardeningGuiFake.destroy()
del self.__gardeningGuiFake
if self.__clarabelleButton:
self.__clarabelleButton.destroy()
del self.__clarabelleButton
if self.__clarabelleFlash:
self.__clarabelleFlash.finish()
del self.__clarabelleFlash
if self.__catalogNotifyDialog:
self.__catalogNotifyDialog.cleanup()
del self.__catalogNotifyDialog
return
def initInterface(self):
self.newsButtonMgr = NewsPageButtonManager.NewsPageButtonManager()
self.newsButtonMgr.request('Hidden')
self.book = ShtikerBook.ShtikerBook('bookDone')
self.book.load()
self.book.hideButton()
self.optionsPage = OptionsPage.OptionsPage()
self.optionsPage.load()
self.book.addPage(self.optionsPage, pageName=TTLocalizer.OptionsPageTitle)
self.shardPage = ShardPage.ShardPage()
self.shardPage.load()
self.book.addPage(self.shardPage, pageName=TTLocalizer.ShardPageTitle)
self.mapPage = MapPage.MapPage()
self.mapPage.load()
self.book.addPage(self.mapPage, pageName=TTLocalizer.MapPageTitle)
self.invPage = InventoryPage.InventoryPage()
self.invPage.load()
self.book.addPage(self.invPage, pageName=TTLocalizer.InventoryPageTitle)
self.questPage = QuestPage.QuestPage()
self.questPage.load()
self.book.addPage(self.questPage, pageName=TTLocalizer.QuestPageToonTasks)
self.trackPage = TrackPage.TrackPage()
self.trackPage.load()
self.book.addPage(self.trackPage, pageName=TTLocalizer.TrackPageShortTitle)
self.suitPage = SuitPage.SuitPage()
self.suitPage.load()
self.book.addPage(self.suitPage, pageName=TTLocalizer.SuitPageTitle)
if base.config.GetBool('want-photo-album', 0):
self.photoAlbumPage = PhotoAlbumPage.PhotoAlbumPage()
self.photoAlbumPage.load()
self.book.addPage(self.photoAlbumPage, pageName=TTLocalizer.PhotoPageTitle)
self.fishPage = FishPage.FishPage()
self.fishPage.setAvatar(self)
self.fishPage.load()
self.book.addPage(self.fishPage, pageName=TTLocalizer.FishPageTitle)
if base.wantKarts:
self.addKartPage()
if self.disguisePageFlag:
self.loadDisguisePages()
if self.sosPageFlag:
self.loadSosPages()
if self.gardenStarted:
self.loadGardenPages()
self.addGolfPage()
self.addEventsPage()
if WantNewsPage:
self.addNewsPage()
self.book.setPage(self.mapPage, enterPage=False)
self.laffMeter = LaffMeter.LaffMeter(self.style, self.hp, self.maxHp)
self.laffMeter.setAvatar(self)
self.laffMeter.setScale(0.075)
if self.style.getAnimal() == 'monkey':
self.laffMeter.setPos(-1.18, 0.0, -0.87)
else:
self.laffMeter.setPos(-1.2, 0.0, -0.87)
self.laffMeter.stop()
self.questMap = QuestMap.QuestMap(self)
self.questMap.stop()
if not base.cr.isPaid():
guiButton = loader.loadModel('phase_3/models/gui/quit_button')
self.purchaseButton = DirectButton(parent=aspect2d, relief=None, image=(guiButton.find('**/QuitBtn_UP'), guiButton.find('**/QuitBtn_DN'), guiButton.find('**/QuitBtn_RLVR')), image_scale=0.9, text=TTLocalizer.OptionsPagePurchase, text_scale=0.05, text_pos=(0, -0.01), textMayChange=0, pos=(0.885, 0, -0.94), sortOrder=100, command=self.__handlePurchase)
base.setCellsAvailable([base.bottomCells[4]], 0)
self.accept('time-insert', self.__beginTossPie)
self.accept('time-insert-up', self.__endTossPie)
self.accept('time-delete', self.__beginTossPie)
self.accept('time-delete-up', self.__endTossPie)
self.accept('pieHit', self.__pieHit)
self.accept('interrupt-pie', self.interruptPie)
self.accept('InputState-jump', self.__toonMoved)
self.accept('InputState-forward', self.__toonMoved)
self.accept('InputState-reverse', self.__toonMoved)
self.accept('InputState-turnLeft', self.__toonMoved)
self.accept('InputState-turnRight', self.__toonMoved)
self.accept('InputState-slide', self.__toonMoved)
QuestParser.init()
return
def __handlePurchase(self):
self.purchaseButton.hide()
if (base.cr.isWebPlayToken() or __dev__):
if base.cr.isPaid():
if base.cr.productName in ['DisneyOnline-UK', 'DisneyOnline-AP', 'JP', 'DE', 'BR', 'FR']:
paidNoParentPassword = launcher and launcher.getParentPasswordSet()
else:
paidNoParentPassword = launcher and not launcher.getParentPasswordSet()
else:
paidNoParentPassword = 0
self.leaveToPayDialog = LeaveToPayDialog.LeaveToPayDialog(paidNoParentPassword, self.purchaseButton.show)
self.leaveToPayDialog.show()
else:
self.notify.error('You should not get here without a PlayToken')
if base.wantKarts:
def addKartPage(self):
if self.hasKart():
if hasattr(self, 'kartPage') and self.kartPage != None:
return
if not launcher.getPhaseComplete(6):
self.acceptOnce('phaseComplete-6', self.addKartPage)
return
self.kartPage = KartPage.KartPage()
self.kartPage.setAvatar(self)
self.kartPage.load()
self.book.addPage(self.kartPage, pageName=TTLocalizer.KartPageTitle)
return
def setWantBattles(self, wantBattles):
self.wantBattles = wantBattles
def loadDisguisePages(self):
if self.disguisePage != None:
return
if not launcher.getPhaseComplete(9):
self.acceptOnce('phaseComplete-9', self.loadDisguisePages)
return
self.disguisePage = DisguisePage.DisguisePage()
self.disguisePage.load()
self.book.addPage(self.disguisePage, pageName=TTLocalizer.DisguisePageTitle)
self.loadSosPages()
return
def loadSosPages(self):
if self.sosPage != None:
return
self.sosPage = NPCFriendPage.NPCFriendPage()
self.sosPage.load()
self.book.addPage(self.sosPage, pageName=TTLocalizer.NPCFriendPageTitle)
return
def loadGardenPages(self):
if self.gardenPage != None:
return
if not launcher.getPhaseComplete(5.5):
self.acceptOnce('phaseComplete-5.5', self.loadPhase55Stuff)
return
self.gardenPage = GardenPage.GardenPage()
self.gardenPage.load()
self.book.addPage(self.gardenPage, pageName=TTLocalizer.GardenPageTitle)
return
def loadPhase55Stuff(self):
if self.gardenPage == None:
self.gardenPage = GardenPage.GardenPage()
self.gardenPage.load()
self.book.addPage(self.gardenPage, pageName=TTLocalizer.GardenPageTitle)
elif not launcher.getPhaseComplete(5.5):
self.acceptOnce('phaseComplete-5.5', self.loadPhase55Stuff)
self.refreshOnscreenButtons()
return
def setAsGM(self, state):
self.notify.debug('Setting GM State: %s in LocalToon' % state)
DistributedToon.DistributedToon.setAsGM(self, state)
if self.gmState:
if base.config.GetString('gm-nametag-string', '') != '':
self.gmNameTagString = base.config.GetString('gm-nametag-string')
if base.config.GetString('gm-nametag-color', '') != '':
self.gmNameTagColor = base.config.GetString('gm-nametag-color')
if base.config.GetInt('gm-nametag-enabled', 0):
self.gmNameTagEnabled = 1
self.d_updateGMNameTag()
def displayTalkWhisper(self, fromId, avatarName, rawString, mods):
sender = base.cr.identifyAvatar(fromId)
if sender:
chatString, scrubbed = sender.scrubTalk(rawString, mods)
else:
chatString, scrubbed = self.scrubTalk(rawString, mods)
sender = self
sfx = self.soundWhisper
chatString = avatarName + ': ' + chatString
whisper = WhisperPopup(chatString, OTPGlobals.getInterfaceFont(), WhisperPopup.WTNormal)
whisper.setClickable(avatarName, fromId)
whisper.manage(base.marginManager)
base.playSfx(sfx)
def displayTalkAccount(self, fromId, senderName, rawString, mods):
sender = None
playerInfo = None
sfx = self.soundWhisper
playerInfo = base.cr.playerFriendsManager.playerId2Info.get(fromId, None)
if playerInfo == None:
return
senderAvId = base.cr.playerFriendsManager.findAvIdFromPlayerId(fromId)
if not senderName and base.cr.playerFriendsManager.playerId2Info.get(fromId):
senderName = base.cr.playerFriendsManager.playerId2Info.get(fromId).playerName
senderAvatar = base.cr.identifyAvatar(senderAvId)
if sender:
chatString, scrubbed = senderAvatar.scrubTalk(rawString, mods)
else:
chatString, scrubbed = self.scrubTalk(rawString, mods)
chatString = senderName + ': ' + chatString
whisper = WhisperPopup(chatString, OTPGlobals.getInterfaceFont(), WhisperPopup.WTNormal)
if playerInfo != None:
whisper.setClickable(senderName, fromId, 1)
whisper.manage(base.marginManager)
base.playSfx(sfx)
return
def isLocal(self):
return 1
def canChat(self):
if not self.cr.allowAnyTypedChat():
return 0
if self.commonChatFlags & (ToontownGlobals.CommonChat | ToontownGlobals.SuperChat):
return 1
if base.cr.whiteListChatEnabled:
return 1
for friendId, flags in self.friendsList:
if flags & ToontownGlobals.FriendChat:
return 1
return 0
def startChat(self):
if self.tutorialAck:
self.notify.info('calling LocalAvatar.startchat')
LocalAvatar.LocalAvatar.startChat(self)
self.accept('chatUpdateSCToontask', self.b_setSCToontask)
self.accept('chatUpdateSCResistance', self.d_reqSCResistance)
self.accept('chatUpdateSCSinging', self.b_setSCSinging)
self.accept('whisperUpdateSCToontask', self.whisperSCToontaskTo)
else:
self.notify.info('NOT calling LocalAvatar.startchat, in tutorial')
def stopChat(self):
LocalAvatar.LocalAvatar.stopChat(self)
self.ignore('chatUpdateSCToontask')
self.ignore('chatUpdateSCResistance')
self.ignore('chatUpdateSCSinging')
self.ignore('whisperUpdateSCToontask')
def tunnelIn(self, tunnelOrigin):
self.b_setTunnelIn(self.tunnelX * 0.8, tunnelOrigin)
def tunnelOut(self, tunnelOrigin):
self.tunnelX = self.getX(tunnelOrigin)
tunnelY = self.getY(tunnelOrigin)
self.b_setTunnelOut(self.tunnelX * 0.95, tunnelY, tunnelOrigin)
def handleTunnelIn(self, startTime, endX, x, y, z, h):
self.notify.debug('LocalToon.handleTunnelIn')
tunnelOrigin = render.attachNewNode('tunnelOrigin')
tunnelOrigin.setPosHpr(x, y, z, h, 0, 0)
self.b_setAnimState('run', self.animMultiplier)
self.stopLookAround()
self.reparentTo(render)
self.runSound()
camera.reparentTo(render)
camera.setPosHpr(tunnelOrigin, 0, 20, 12, 180, -20, 0)
base.transitions.irisIn(0.4)
toonTrack = self.getTunnelInToonTrack(endX, tunnelOrigin)
def cleanup(self = self, tunnelOrigin = tunnelOrigin):
self.stopSound()
tunnelOrigin.removeNode()
messenger.send('tunnelInMovieDone')
self.tunnelTrack = Sequence(toonTrack, Func(cleanup))
self.tunnelTrack.start(globalClock.getFrameTime() - startTime)
def handleTunnelOut(self, startTime, startX, startY, x, y, z, h):
self.notify.debug('LocalToon.handleTunnelOut')
tunnelOrigin = render.attachNewNode('tunnelOrigin')
tunnelOrigin.setPosHpr(x, y, z, h, 0, 0)
self.b_setAnimState('run', self.animMultiplier)
self.runSound()
self.stopLookAround()
tracks = Parallel()
camera.wrtReparentTo(render)
startPos = camera.getPos(tunnelOrigin)
startHpr = camera.getHpr(tunnelOrigin)
camLerpDur = 1.0
reducedCamH = fitDestAngle2Src(startHpr[0], 180)
tracks.append(LerpPosHprInterval(camera, camLerpDur, pos=Point3(0, 20, 12), hpr=Point3(reducedCamH, -20, 0), startPos=startPos, startHpr=startHpr, other=tunnelOrigin, blendType='easeInOut', name='tunnelOutLerpCamPos'))
toonTrack = self.getTunnelOutToonTrack(startX, startY, tunnelOrigin)
tracks.append(toonTrack)
irisDur = 0.4
tracks.append(Sequence(Wait(toonTrack.getDuration() - (irisDur + 0.1)), Func(base.transitions.irisOut, irisDur)))
def cleanup(self = self, tunnelOrigin = tunnelOrigin):
self.stopSound()
self.detachNode()
tunnelOrigin.removeNode()
messenger.send('tunnelOutMovieDone')
self.tunnelTrack = Sequence(tracks, Func(cleanup))
self.tunnelTrack.start(globalClock.getFrameTime() - startTime)
def getPieBubble(self):
if self.__pieBubble == None:
bubble = CollisionSphere(0, 0, 0, 1)
node = CollisionNode('pieBubble')
node.addSolid(bubble)
node.setFromCollideMask(ToontownGlobals.PieBitmask | ToontownGlobals.CameraBitmask | ToontownGlobals.FloorBitmask)
node.setIntoCollideMask(BitMask32.allOff())
self.__pieBubble = NodePath(node)
self.pieHandler = CollisionHandlerEvent()
self.pieHandler.addInPattern('pieHit')
self.pieHandler.addInPattern('pieHit-%in')
return self.__pieBubble
def __beginTossPieMouse(self, mouseParam):
self.__beginTossPie(globalClock.getFrameTime())
def __endTossPieMouse(self, mouseParam):
self.__endTossPie(globalClock.getFrameTime())
def __beginTossPie(self, time):
if self.tossPieStart != None:
return
if not self.allowPies:
return
if self.numPies == 0:
messenger.send('outOfPies')
return
if self.__pieInHand():
return
if getattr(self.controlManager.currentControls, 'isAirborne', 0):
return
messenger.send('wakeup')
self.localPresentPie(time)
taskName = self.uniqueName('updatePiePower')
taskMgr.add(self.__updatePiePower, taskName)
return
def __endTossPie(self, time):
if self.tossPieStart == None:
return
taskName = self.uniqueName('updatePiePower')
taskMgr.remove(taskName)
messenger.send('wakeup')
power = self.__getPiePower(time)
self.tossPieStart = None
self.localTossPie(power)
return
def localPresentPie(self, time):
import TTEmote
from otp.avatar import Emote
self.__stopPresentPie()
if self.tossTrack:
tossTrack = self.tossTrack
self.tossTrack = None
tossTrack.finish()
self.interruptPie()
self.tossPieStart = time
self.__pieSequence = self.__pieSequence + 1 & 255
sequence = self.__pieSequence
self.__presentingPie = 1
pos = self.getPos()
hpr = self.getHpr()
timestamp32 = globalClockDelta.getFrameNetworkTime(bits=32)
self.sendUpdate('presentPie', [pos[0],
pos[1],
pos[2],
hpr[0] % 360.0,
hpr[1],
hpr[2],
timestamp32])
Emote.globalEmote.disableBody(self)
messenger.send('begin-pie')
ival = self.getPresentPieInterval(pos[0], pos[1], pos[2], hpr[0], hpr[1], hpr[2])
ival = Sequence(ival, name=self.uniqueName('localPresentPie'))
self.tossTrack = ival
ival.start()
self.makePiePowerMeter()
self.__piePowerMeter.show()
self.__piePowerMeterSequence = sequence
self.__piePowerMeter['value'] = 0
return
def __stopPresentPie(self):
if self.__presentingPie:
import TTEmote
from otp.avatar import Emote
Emote.globalEmote.releaseBody(self)
messenger.send('end-pie')
self.__presentingPie = 0
taskName = self.uniqueName('updatePiePower')
taskMgr.remove(taskName)
def __getPiePower(self, time):
elapsed = max(time - self.tossPieStart, 0.0)
t = elapsed / self.piePowerSpeed
t = math.pow(t, self.piePowerExponent)
power = int(t * 100) % 200
if power > 100:
power = 200 - power
return power
def __updatePiePower(self, task):
if not self.__piePowerMeter:
return Task.done
self.__piePowerMeter['value'] = self.__getPiePower(globalClock.getFrameTime())
return Task.cont
def interruptPie(self):
self.cleanupPieInHand()
self.__stopPresentPie()
if self.__piePowerMeter:
self.__piePowerMeter.hide()
pie = self.pieTracks.get(self.__pieSequence)
if pie and pie.getT() < 14.0 / 24.0:
del self.pieTracks[self.__pieSequence]
pie.pause()
def __pieInHand(self):
pie = self.pieTracks.get(self.__pieSequence)
return pie and pie.getT() < 15.0 / 24.0
def __toonMoved(self, isSet):
if isSet:
self.interruptPie()
def localTossPie(self, power):
if not self.__presentingPie:
return
pos = self.getPos()
hpr = self.getHpr()
timestamp32 = globalClockDelta.getFrameNetworkTime(bits=32)
sequence = self.__pieSequence
if self.tossTrack:
tossTrack = self.tossTrack
self.tossTrack = None
tossTrack.finish()
if self.pieTracks.has_key(sequence):
pieTrack = self.pieTracks[sequence]
del self.pieTracks[sequence]
pieTrack.finish()
if self.splatTracks.has_key(sequence):
splatTrack = self.splatTracks[sequence]
del self.splatTracks[sequence]
splatTrack.finish()
self.makePiePowerMeter()
self.__piePowerMeter['value'] = power
self.__piePowerMeter.show()
self.__piePowerMeterSequence = sequence
pieBubble = self.getPieBubble().instanceTo(NodePath())
def pieFlies(self = self, pos = pos, hpr = hpr, sequence = sequence, power = power, timestamp32 = timestamp32, pieBubble = pieBubble):
self.sendUpdate('tossPie', [pos[0],
pos[1],
pos[2],
hpr[0] % 360.0,
hpr[1],
hpr[2],
sequence,
power,
timestamp32])
if self.numPies != ToontownGlobals.FullPies:
self.setNumPies(self.numPies - 1)
base.cTrav.addCollider(pieBubble, self.pieHandler)
toss, pie, flyPie = self.getTossPieInterval(pos[0], pos[1], pos[2], hpr[0], hpr[1], hpr[2], power, beginFlyIval=Func(pieFlies))
pieBubble.reparentTo(flyPie)
flyPie.setTag('pieSequence', str(sequence))
toss = Sequence(toss)
self.tossTrack = toss
toss.start()
pie = Sequence(pie, Func(base.cTrav.removeCollider, pieBubble), Func(self.pieFinishedFlying, sequence))
self.pieTracks[sequence] = pie
pie.start()
return
def pieFinishedFlying(self, sequence):
DistributedToon.DistributedToon.pieFinishedFlying(self, sequence)
if self.__piePowerMeterSequence == sequence:
self.__piePowerMeter.hide()
def __finishPieTrack(self, sequence):
if self.pieTracks.has_key(sequence):
pieTrack = self.pieTracks[sequence]
del self.pieTracks[sequence]
pieTrack.finish()
def __pieHit(self, entry):
if not entry.hasSurfacePoint() or not entry.hasInto():
return
if not entry.getInto().isTangible():
return
sequence = int(entry.getFromNodePath().getNetTag('pieSequence'))
self.__finishPieTrack(sequence)
if self.splatTracks.has_key(sequence):
splatTrack = self.splatTracks[sequence]
del self.splatTracks[sequence]
splatTrack.finish()
pieCode = 0
pieCodeStr = entry.getIntoNodePath().getNetTag('pieCode')
if pieCodeStr:
pieCode = int(pieCodeStr)
pos = entry.getSurfacePoint(render)
timestamp32 = globalClockDelta.getFrameNetworkTime(bits=32)
self.sendUpdate('pieSplat', [pos[0],
pos[1],
pos[2],
sequence,
pieCode,
timestamp32])
splat = self.getPieSplatInterval(pos[0], pos[1], pos[2], pieCode)
splat = Sequence(splat, Func(self.pieFinishedSplatting, sequence))
self.splatTracks[sequence] = splat
splat.start()
messenger.send('pieSplat', [self, pieCode])
messenger.send('localPieSplat', [pieCode, entry])
def beginAllowPies(self):
self.allowPies = 1
self.updatePieButton()
def endAllowPies(self):
self.allowPies = 0
self.updatePieButton()
def makePiePowerMeter(self):
from direct.gui.DirectGui import DirectWaitBar, DGG
if self.__piePowerMeter == None:
self.__piePowerMeter = DirectWaitBar(frameSize=(-0.2,
0.2,
-0.03,
0.03), relief=DGG.SUNKEN, borderWidth=(0.005, 0.005), barColor=(0.4, 0.6, 1.0, 1), pos=(0, 0.1, 0.8))
self.__piePowerMeter.hide()
return
def updatePieButton(self):
from toontown.toonbase import ToontownBattleGlobals
from direct.gui.DirectGui import DirectButton, DGG
wantButton = 0
if self.allowPies and self.numPies > 0:
wantButton = 1
if not launcher.getPhaseComplete(5):
wantButton = 0
haveButton = self.__pieButton != None
if not haveButton and not wantButton:
return
if haveButton and not wantButton:
self.__pieButton.destroy()
self.__pieButton = None
self.__pieButtonType = None
self.__pieButtonCount = None
return
if self.__pieButtonType != self.pieType:
if self.__pieButton:
self.__pieButton.destroy()
self.__pieButton = None
if self.__pieButton == None:
inv = self.inventory
if self.pieType >= len(inv.invModels[ToontownBattleGlobals.THROW_TRACK]):
gui = loader.loadModel('phase_3.5/models/gui/stickerbook_gui')
pieGui = gui.find('**/summons')
pieScale = 0.1
else:
gui = None
pieGui = (inv.invModels[ToontownBattleGlobals.THROW_TRACK][self.pieType],)
pieScale = 0.85
self.__pieButton = DirectButton(image=(inv.upButton, inv.downButton, inv.rolloverButton), geom=pieGui, text='50', text_scale=0.04, text_align=TextNode.ARight, geom_scale=pieScale, geom_pos=(-0.01, 0, 0), text_fg=Vec4(1, 1, 1, 1), text_pos=(0.07, -0.04), relief=None, image_color=(0, 0.6, 1, 1), pos=(0, 0.1, 0.9))
self.__pieButton.bind(DGG.B1PRESS, self.__beginTossPieMouse)
self.__pieButton.bind(DGG.B1RELEASE, self.__endTossPieMouse)
self.__pieButtonType = self.pieType
self.__pieButtonCount = None
if gui:
del gui
if self.__pieButtonCount != self.numPies:
if self.numPies == ToontownGlobals.FullPies:
self.__pieButton['text'] = ''
else:
self.__pieButton['text'] = str(self.numPies)
self.__pieButtonCount = self.numPies
return
def displayWhisper(self, fromId, chatString, whisperType):
sender = None
sfx = self.soundWhisper
if fromId == TTLocalizer.Clarabelle:
chatString = TTLocalizer.Clarabelle + ': ' + chatString
sfx = self.soundPhoneRing
elif fromId != 0:
sender = base.cr.identifyAvatar(fromId)
if whisperType == WhisperPopup.WTNormal or whisperType == WhisperPopup.WTQuickTalker:
if sender == None:
return
chatString = sender.getName() + ': ' + chatString
elif whisperType == WhisperPopup.WTSystem:
sfx = self.soundSystemMessage
whisper = WhisperPopup(chatString, OTPGlobals.getInterfaceFont(), whisperType)
if sender != None:
whisper.setClickable(sender.getName(), fromId)
whisper.manage(base.marginManager)
base.playSfx(sfx)
return
def displaySystemClickableWhisper(self, fromId, chatString, whisperType):
sender = None
sfx = self.soundWhisper
if fromId == TTLocalizer.Clarabelle:
chatString = TTLocalizer.Clarabelle + ': ' + chatString
sfx = self.soundPhoneRing
elif fromId != 0:
sender = base.cr.identifyAvatar(fromId)
if whisperType == WhisperPopup.WTNormal or whisperType == WhisperPopup.WTQuickTalker:
if sender == None:
return
chatString = sender.getName() + ': ' + chatString
elif whisperType == WhisperPopup.WTSystem:
sfx = self.soundSystemMessage
whisper = WhisperPopup(chatString, OTPGlobals.getInterfaceFont(), whisperType)
whisper.setClickable('', fromId)
whisper.manage(base.marginManager)
base.playSfx(sfx)
return
def clickedWhisper(self, doId, isPlayer = None):
if doId > 0:
LocalAvatar.LocalAvatar.clickedWhisper(self, doId, isPlayer)
else:
foundCanStart = False
for partyInfo in self.hostedParties:
if partyInfo.status == PartyGlobals.PartyStatus.CanStart:
foundCanStart = True
break
if base.cr and base.cr.playGame and base.cr.playGame.getPlace() and base.cr.playGame.getPlace().fsm:
fsm = base.cr.playGame.getPlace().fsm
curState = fsm.getCurrentState().getName()
if curState == 'walk':
if hasattr(self, 'eventsPage'):
desiredMode = -1
if doId == -1:
desiredMode = EventsPage.EventsPage_Invited
elif foundCanStart:
desiredMode = EventsPage.EventsPage_Host
if desiredMode >= 0:
self.book.setPage(self.eventsPage)
self.eventsPage.setMode(desiredMode)
fsm.request('stickerBook')
def loadFurnitureGui(self):
if self.__furnitureGui:
return
guiModels = loader.loadModel('phase_5.5/models/gui/house_design_gui')
self.__furnitureGui = DirectFrame(relief=None, pos=(-1.19, 0.0, 0.33), scale=0.04, image=guiModels.find('**/attic'))
DirectLabel(parent=self.__furnitureGui, relief=None, image=guiModels.find('**/rooftile'))
bMoveStartUp = guiModels.find('**/bu_attic/bu_attic_up')
bMoveStartDown = guiModels.find('**/bu_attic/bu_attic_down')
bMoveStartRollover = guiModels.find('**/bu_attic/bu_attic_rollover')
DirectButton(parent=self.__furnitureGui, relief=None, image=[bMoveStartUp,
bMoveStartDown,
bMoveStartRollover,
bMoveStartUp], text=['', TTLocalizer.HDMoveFurnitureButton, TTLocalizer.HDMoveFurnitureButton], text_fg=(1, 1, 1, 1), text_shadow=(0, 0, 0, 1), text_font=ToontownGlobals.getInterfaceFont(), pos=(-0.3, 0, 9.4), command=self.__startMoveFurniture)
self.__furnitureGui.hide()
guiModels.removeNode()
return
def showFurnitureGui(self):
self.loadFurnitureGui()
self.__furnitureGui.show()
def hideFurnitureGui(self):
if self.__furnitureGui:
self.__furnitureGui.hide()
def clarabelleNewsPageCollision(self, show = True):
if self.__clarabelleButton == None:
return
claraXPos = ClaraBaseXPos
notifyXPos = CatalogNotifyDialog.CatalogNotifyBaseXPos
if show:
claraXPos += AdjustmentForNewsButton
notifyXPos += AdjustmentForNewsButton
newPos = (claraXPos - 0.1, 1.0, 0.45)
self.__clarabelleButton.setPos(newPos)
if self.__catalogNotifyDialog == None or self.__catalogNotifyDialog.frame == None:
return
notifyPos = self.__catalogNotifyDialog.frame.getPos()
notifyPos[0] = notifyXPos
self.__catalogNotifyDialog.frame.setPos(notifyPos)
return
def loadClarabelleGui(self):
if self.__clarabelleButton:
return
guiItems = loader.loadModel('phase_5.5/models/gui/catalog_gui')
circle = guiItems.find('**/cover/blue_circle')
icon = guiItems.find('**/cover/clarabelle')
icon.reparentTo(circle)
rgba = VBase4(0.71589, 0.784547, 0.974, 1.0)
white = VBase4(1.0, 1.0, 1.0, 1.0)
icon.setColor(white)
claraXPos = ClaraBaseXPos
newScale = oldScale = 0.5
newPos = (claraXPos, 1.0, 0.37)
if WantNewsPage:
claraXPos += AdjustmentForNewsButton
oldPos = ((claraXPos, 1.0, 0.37),)
newScale = oldScale * ToontownGlobals.NewsPageScaleAdjust
newPos = (claraXPos - 0.1, 1.0, 0.45)
self.__clarabelleButton = DirectButton(relief=None, image=circle, text='', text_fg=(1, 1, 1, 1), text_shadow=(0, 0, 0, 1), text_scale=0.1, text_pos=(-1.06, 1.06), text_font=ToontownGlobals.getInterfaceFont(), pos=newPos, scale=newScale, command=self.__handleClarabelleButton)
self.__clarabelleButton.reparentTo(aspect2d, DGG.BACKGROUND_SORT_INDEX - 1)
button = self.__clarabelleButton.stateNodePath[0]
self.__clarabelleFlash = Sequence(LerpColorInterval(button, 2, white, blendType='easeInOut'), LerpColorInterval(button, 2, rgba, blendType='easeInOut'))
self.__clarabelleFlash.loop()
self.__clarabelleFlash.pause()
return
def showClarabelleGui(self, mailboxItems):
self.loadClarabelleGui()
if mailboxItems:
self.__clarabelleButton['text'] = ['', TTLocalizer.CatalogNewDeliveryButton, TTLocalizer.CatalogNewDeliveryButton]
else:
self.__clarabelleButton['text'] = ['', TTLocalizer.CatalogNewCatalogButton, TTLocalizer.CatalogNewCatalogButton]
if not self.mailboxNotify and not self.awardNotify and self.catalogNotify == ToontownGlobals.OldItems and (self.simpleMailNotify != ToontownGlobals.NoItems or self.inviteMailNotify != ToontownGlobals.NoItems):
self.__clarabelleButton['text'] = ['', TTLocalizer.MailNewMailButton, TTLocalizer.MailNewMailButton]
if self.newsButtonMgr.isNewIssueButtonShown():
self.clarabelleNewsPageCollision(True)
self.__clarabelleButton.show()
self.__clarabelleFlash.resume()
def hideClarabelleGui(self):
if self.__clarabelleButton:
self.__clarabelleButton.hide()
self.__clarabelleFlash.pause()
def __handleClarabelleButton(self):
self.stopMoveFurniture()
place = base.cr.playGame.getPlace()
if place == None:
self.notify.warning('Tried to go home, but place is None.')
return
if self.__catalogNotifyDialog:
self.__catalogNotifyDialog.cleanup()
self.__catalogNotifyDialog = None
if base.config.GetBool('want-qa-regression', 0):
self.notify.info('QA-REGRESSION: VISITESTATE: Visit estate')
place.goHomeNow(self.lastHood)
return
def __startMoveFurniture(self):
self.oldPos = self.getPos()
if base.config.GetBool('want-qa-regression', 0):
self.notify.info('QA-REGRESSION: ESTATE: Furniture Placement')
if self.cr.furnitureManager != None:
self.cr.furnitureManager.d_suggestDirector(self.doId)
elif self.furnitureManager != None:
self.furnitureManager.d_suggestDirector(self.doId)
return
def stopMoveFurniture(self):
if self.oldPos:
self.setPos(self.oldPos)
if self.furnitureManager != None:
self.furnitureManager.d_suggestDirector(0)
return
def setFurnitureDirector(self, avId, furnitureManager):
if avId == 0:
if self.furnitureManager == furnitureManager:
messenger.send('exitFurnitureMode', [furnitureManager])
self.furnitureManager = None
self.furnitureDirector = None
elif avId != self.doId:
if self.furnitureManager == None or self.furnitureDirector != avId:
self.furnitureManager = furnitureManager
self.furnitureDirector = avId
messenger.send('enterFurnitureMode', [furnitureManager, 0])
else:
if self.furnitureManager != None:
messenger.send('exitFurnitureMode', [self.furnitureManager])
self.furnitureManager = None
self.furnitureManager = furnitureManager
self.furnitureDirector = avId
messenger.send('enterFurnitureMode', [furnitureManager, 1])
self.refreshOnscreenButtons()
return
def getAvPosStr(self):
pos = self.getPos()
hpr = self.getHpr()
serverVersion = base.cr.getServerVersion()
districtName = base.cr.getShardName(base.localAvatar.defaultShard)
if hasattr(base.cr.playGame.hood, 'loader') and hasattr(base.cr.playGame.hood.loader, 'place') and base.cr.playGame.getPlace() != None:
zoneId = base.cr.playGame.getPlace().getZoneId()
else:
zoneId = '?'
strPosCoordText = 'X: %.3f' % pos[0] + ', Y: %.3f' % pos[1] + '\nZ: %.3f' % pos[2] + ', H: %.3f' % hpr[0] + '\nZone: %s' % str(zoneId) + ', Ver: %s, ' % serverVersion + 'District: %s' % districtName
return strPosCoordText
self.refreshOnscreenButtons()
return
def thinkPos(self):
pos = self.getPos()
hpr = self.getHpr()
serverVersion = base.cr.getServerVersion()
districtName = base.cr.getShardName(base.localAvatar.defaultShard)
if hasattr(base.cr.playGame.hood, 'loader') and hasattr(base.cr.playGame.hood.loader, 'place') and base.cr.playGame.getPlace() != None:
zoneId = base.cr.playGame.getPlace().getZoneId()
else:
zoneId = '?'
strPos = '(%.3f' % pos[0] + '\n %.3f' % pos[1] + '\n %.3f)' % pos[2] + '\nH: %.3f' % hpr[0] + '\nZone: %s' % str(zoneId) + ',\nVer: %s, ' % serverVersion + '\nDistrict: %s' % districtName
print 'Current position=', strPos.replace('\n', ', ')
self.setChatAbsolute(strPos, CFThought | CFTimeout)
return
def __placeMarker(self):
pos = self.getPos()
hpr = self.getHpr()
chest = loader.loadModel('phase_4/models/props/coffin')
chest.reparentTo(render)
chest.setColor(1, 0, 0, 1)
chest.setPosHpr(pos, hpr)
chest.setScale(0.5)
def setFriendsListButtonActive(self, active):
self.friendsListButtonActive = active
self.refreshOnscreenButtons()
def obscureFriendsListButton(self, increment):
self.friendsListButtonObscured += increment
self.refreshOnscreenButtons()
def obscureMoveFurnitureButton(self, increment):
self.moveFurnitureButtonObscured += increment
self.refreshOnscreenButtons()
def obscureClarabelleButton(self, increment):
self.clarabelleButtonObscured += increment
self.refreshOnscreenButtons()
def refreshOnscreenButtons(self):
self.bFriendsList.hide()
self.hideFurnitureGui()
self.hideClarabelleGui()
clarabelleHidden = 1
self.ignore(ToontownGlobals.FriendsListHotkey)
if self.friendsListButtonActive and self.friendsListButtonObscured <= 0:
self.bFriendsList.show()
self.accept(ToontownGlobals.FriendsListHotkey, self.sendFriendsListEvent)
if self.clarabelleButtonObscured <= 0 and self.isTeleportAllowed():
if self.catalogNotify == ToontownGlobals.NewItems or self.mailboxNotify == ToontownGlobals.NewItems or self.simpleMailNotify == ToontownGlobals.NewItems or self.inviteMailNotify == ToontownGlobals.NewItems or self.awardNotify == ToontownGlobals.NewItems:
showClarabelle = not launcher or launcher.getPhaseComplete(5.5)
for quest in self.quests:
if quest[0] in Quests.PreClarabelleQuestIds and self.mailboxNotify != ToontownGlobals.NewItems and self.awardNotify != ToontownGlobals.NewItems:
showClarabelle = 0
if base.cr.playGame.getPlace().getState() == 'stickerBook':
showClarabelle = 0
if showClarabelle:
newItemsInMailbox = self.mailboxNotify == ToontownGlobals.NewItems or self.awardNotify == ToontownGlobals.NewItems
self.showClarabelleGui(newItemsInMailbox)
clarabelleHidden = 0
if clarabelleHidden:
if self.__catalogNotifyDialog:
self.__catalogNotifyDialog.cleanup()
self.__catalogNotifyDialog = None
else:
self.newCatalogNotify()
if self.moveFurnitureButtonObscured <= 0:
if self.furnitureManager != None and self.furnitureDirector == self.doId:
self.loadFurnitureGui()
self.__furnitureGui.setPos(-1.16, 0, -0.03)
self.__furnitureGui.setScale(0.06)
elif self.cr.furnitureManager != None:
self.showFurnitureGui()
taskMgr.remove('lerpFurnitureButton')
self.__furnitureGui.lerpPosHprScale(pos=Point3(-1.19, 0.0, 0.33), hpr=Vec3(0.0, 0.0, 0.0), scale=Vec3(0.04, 0.04, 0.04), time=1.0, blendType='easeInOut', task='lerpFurnitureButton')
if hasattr(self, 'inEstate') and self.inEstate:
self.loadGardeningGui()
self.hideGardeningGui()
else:
self.hideGardeningGui()
return
def setGhostMode(self, flag):
if flag == 2:
self.seeGhosts = 1
DistributedToon.DistributedToon.setGhostMode(self, flag)
def newCatalogNotify(self):
if not self.gotCatalogNotify:
return
hasPhase = not launcher or launcher.getPhaseComplete(5.5)
if not hasPhase:
return
if not self.friendsListButtonActive or self.friendsListButtonObscured > 0:
return
self.gotCatalogNotify = 0
currentWeek = self.catalogScheduleCurrentWeek - 1
if currentWeek < 57:
seriesNumber = currentWeek / ToontownGlobals.CatalogNumWeeksPerSeries + 1
weekNumber = currentWeek % ToontownGlobals.CatalogNumWeeksPerSeries + 1
elif currentWeek < 65:
seriesNumber = 6
weekNumber = currentWeek - 56
else:
seriesNumber = currentWeek / ToontownGlobals.CatalogNumWeeksPerSeries + 2
weekNumber = currentWeek % ToontownGlobals.CatalogNumWeeksPerSeries + 1
message = None
if self.mailboxNotify == ToontownGlobals.NoItems:
if self.catalogNotify == ToontownGlobals.NewItems:
if self.catalogScheduleCurrentWeek == 1:
message = (TTLocalizer.CatalogNotifyFirstCatalog, TTLocalizer.CatalogNotifyInstructions)
else:
message = (TTLocalizer.CatalogNotifyNewCatalog % weekNumber,)
elif self.mailboxNotify == ToontownGlobals.NewItems:
if self.catalogNotify == ToontownGlobals.NewItems:
message = (TTLocalizer.CatalogNotifyNewCatalogNewDelivery % weekNumber,)
else:
message = (TTLocalizer.CatalogNotifyNewDelivery,)
elif self.mailboxNotify == ToontownGlobals.OldItems:
if self.catalogNotify == ToontownGlobals.NewItems:
message = (TTLocalizer.CatalogNotifyNewCatalogOldDelivery % weekNumber,)
else:
message = (TTLocalizer.CatalogNotifyOldDelivery,)
if self.awardNotify == ToontownGlobals.NoItems:
pass
elif self.awardNotify == ToontownGlobals.NewItems:
oldStr = ''
if message:
oldStr = message[0] + ' '
oldStr += TTLocalizer.AwardNotifyNewItems
message = (oldStr,)
elif self.awardNotify == ToontownGlobals.OldItems:
oldStr = ''
if message:
oldStr = message[0] + ' '
oldStr += TTLocalizer.AwardNotifyOldItems
message = (oldStr,)
if self.simpleMailNotify == ToontownGlobals.NewItems or self.inviteMailNotify == ToontownGlobals.NewItems:
oldStr = ''
if message:
oldStr = message[0] + ' '
oldStr += TTLocalizer.MailNotifyNewItems
message = (oldStr,)
if message == None:
return
if self.__catalogNotifyDialog:
self.__catalogNotifyDialog.cleanup()
self.__catalogNotifyDialog = CatalogNotifyDialog.CatalogNotifyDialog(message)
base.playSfx(self.soundPhoneRing)
return
def allowHardLand(self):
retval = LocalAvatar.LocalAvatar.allowHardLand(self)
return retval and not self.isDisguised
def setShovelGuiLevel(self, level = 0):
pass
def setWateringCanGuiLevel(self, level = 0):
pass
def loadGardeningGui(self):
if self.__gardeningGui:
return
gardenGuiCard = loader.loadModel('phase_5.5/models/gui/planting_gui')
self.__gardeningGui = DirectFrame(relief=None, geom=gardenGuiCard, geom_color=GlobalDialogColor, geom_scale=(0.17, 1.0, 0.3), pos=(-1.2, 0, 0.5), scale=1.0)
self.__gardeningGui.setName('gardeningFrame')
self.__gardeningGuiFake = DirectFrame(relief=None, geom=None, geom_color=GlobalDialogColor, geom_scale=(0.17, 1.0, 0.3), pos=(-1.2, 0, 0.5), scale=1.0)
self.__gardeningGuiFake.setName('gardeningFrameFake')
iconScale = 1
iconColorWhite = Vec4(1.0, 1.0, 1.0, 1.0)
iconColorGrey = Vec4(0.7, 0.7, 0.7, 1.0)
iconColorBrown = Vec4(0.7, 0.4, 0.3, 1.0)
iconColorBlue = Vec4(0.2, 0.3, 1.0, 1.0)
shovelCardP = loader.loadModel('phase_5.5/models/gui/planting_but_shovel_P')
shovelCardY = loader.loadModel('phase_5.5/models/gui/planting_but_shovel_Y')
wateringCanCardP = loader.loadModel('phase_5.5/models/gui/planting_but_can_P')
wateringCanCardY = loader.loadModel('phase_5.5/models/gui/planting_but_can_Y')
backCard = loader.loadModel('phase_5.5/models/gui/planting_gui')
iconImage = None
iconModels = loader.loadModel('phase_3.5/models/gui/sos_textures')
iconGeom = iconModels.find('**/fish')
buttonText = TTLocalizer.GardeningPlant
self.shovelText = ('',
'',
buttonText,
'')
self.__shovelButtonFake = DirectLabel(parent=self.__gardeningGuiFake, relief=None, text=self.shovelText, text_align=TextNode.ALeft, text_pos=(0.0, -0.0), text_scale=0.07, text_fg=(1, 1, 1, 1), text_shadow=(0, 0, 0, 1), image_scale=(0.18, 1.0, 0.36), geom=None, geom_scale=iconScale, geom_color=iconColorWhite, pos=(0.15, 0, 0.2), scale=0.775)
self.shovelButtonFake = self.__shovelButtonFake
self.shovelText = ('',
'',
buttonText,
'')
self.__shovelButton = DirectButton(parent=self.__gardeningGui, relief=None, text=self.shovelText, text_align=TextNode.ACenter, text_pos=(0.0, -0.0), text_scale=0.1, text_fg=(1, 1, 1, 1), text_shadow=(0, 0, 0, 1), image=(shovelCardP,
shovelCardY,
shovelCardY,
shovelCardY), image_scale=(0.18, 1.0, 0.36), geom=None, geom_scale=iconScale, geom_color=iconColorWhite, pos=(0, 0, 0.2), scale=0.775, command=self.__shovelButtonClicked)
self.shovelButton = self.__shovelButton
iconGeom = iconModels.find('**/teleportIcon')
buttonText = TTLocalizer.GardeningWater
self.waterText = (buttonText,
buttonText,
buttonText,
'')
self.__wateringCanButtonFake = DirectLabel(parent=self.__gardeningGuiFake, relief=None, text=self.waterText, text_align=TextNode.ALeft, text_pos=(0.0, -0.0), text_scale=0.07, text_fg=(1, 1, 1, 1), text_shadow=(0, 0, 0, 1), image_scale=(0.18, 1.0, 0.36), geom=None, geom_scale=iconScale, geom_color=iconColorWhite, pos=(0.15, 0, 0.01), scale=0.775)
self.wateringCanButtonFake = self.__wateringCanButtonFake
self.__wateringCanButton = DirectButton(parent=self.__gardeningGui, relief=None, text=self.waterText, text_align=TextNode.ACenter, text_pos=(0.0, -0.0), text_scale=0.1, text_fg=(1, 1, 1, 1), text_shadow=(0, 0, 0, 1), image=(wateringCanCardP,
wateringCanCardY,
wateringCanCardY,
wateringCanCardY), image_scale=(0.18, 1.0, 0.36), geom=None, geom_scale=iconScale, geom_color=iconColorWhite, pos=(0, 0, 0.01), scale=0.775, command=self.__wateringCanButtonClicked)
self.wateringCanButton = self.__wateringCanButton
self.basketText = '%s / %s' % (self.numFlowers, self.maxFlowerBasket)
self.basketButton = DirectLabel(parent=self.__gardeningGui, relief=None, text=self.basketText, text_align=TextNode.ALeft, text_pos=(0.82, -1.4), text_scale=0.2, text_fg=(1, 1, 1, 1), text_shadow=(0, 0, 0, 1), image=None, image_scale=iconScale, geom=None, geom_scale=iconScale, geom_color=iconColorWhite, pos=(-0.34, 0, 0.16), scale=0.3, textMayChange=1)
if hasattr(self, 'shovel'):
self.setShovelGuiLevel(self.shovel)
if hasattr(self, 'wateringCan'):
self.setWateringCanGuiLevel(self.wateringCan)
self.__shovelButton.hide()
self.__wateringCanButton.hide()
self.__shovelButtonFake.hide()
self.__wateringCanButtonFake.hide()
return
def changeButtonText(self, button, text):
button['text'] = text
def resetWaterText(self):
self.wateringCanButton['text'] = self.waterText
def resetShovelText(self):
self.shovelButton['text'] = self.holdShovelText
def showGardeningGui(self):
self.loadGardeningGui()
self.__gardeningGui.show()
base.setCellsAvailable([base.leftCells[2]], 0)
def hideGardeningGui(self):
if self.__gardeningGui:
self.__gardeningGui.hide()
base.setCellsAvailable([base.leftCells[2]], 1)
def showShovelButton(self, add = 0):
if add:
self.shovelButtonActiveCount += add
else:
self.showingShovel = 1
self.notify.debug('showing shovel %s' % self.shovelButtonActiveCount)
self.__gardeningGui.show()
self.__shovelButton.show()
def hideShovelButton(self, deduct = 0):
self.shovelButtonActiveCount -= deduct
if deduct == 0:
self.showingShovel = 0
if self.shovelButtonActiveCount < 1:
self.shovelButtonActiveCount = 0
if self.showingShovel == 0:
self.__shovelButton.hide()
self.handleAllGardeningButtonsHidden()
self.notify.debug('hiding shovel %s' % self.shovelButtonActiveCount)
def showWateringCanButton(self, add = 0):
if add:
self.wateringCanButtonActiveCount += add
else:
self.showingWateringCan = 1
self.__gardeningGui.show()
self.__wateringCanButton.show()
self.basketButton.show()
def hideWateringCanButton(self, deduct = 0):
self.wateringCanButtonActiveCount -= deduct
if deduct == 0:
self.showingWateringCan = 0
if self.wateringCanButtonActiveCount < 1:
wateringCanButtonActiveCount = 0
if self.showingWateringCan == 0:
self.__wateringCanButton.hide()
self.handleAllGardeningButtonsHidden()
def showWateringCanButtonFake(self, add = 0):
self.__wateringCanButtonFake.show()
def hideWateringCanButtonFake(self, deduct = 0):
self.__wateringCanButtonFake.hide()
def showShovelButtonFake(self, add = 0):
self.__shovelButtonFake.show()
def hideShovelButtonFake(self, deduct = 0):
self.__shovelButtonFake.hide()
def levelWater(self, change = 1):
if change < 0:
return
self.showWateringCanButtonFake(1)
if change < 1:
changeString = TTLocalizer.GardeningNoSkill
else:
changeString = '+%s %s' % (change, TTLocalizer.GardeningWaterSkill)
self.waterTrack = Sequence(Wait(0.0), Func(self.changeButtonText, self.wateringCanButtonFake, changeString), SoundInterval(globalBattleSoundCache.getSound('GUI_balloon_popup.mp3'), node=self), Wait(1.0), Func(self.hideWateringCanButtonFake, 1))
self.waterTrack.start()
def levelShovel(self, change = 1):
if change < 1:
return
self.showShovelButtonFake(1)
if change < 1:
changeString = TTLocalizer.GardeningNoSkill
else:
changeString = '+%s %s' % (change, TTLocalizer.GardeningShovelSkill)
plant = base.cr.doId2do.get(self.shovelRelatedDoId)
if plant:
self.holdShovelText = plant.getShovelAction()
self.shovelTrack = Sequence(Wait(0.0), Func(self.changeButtonText, self.shovelButtonFake, changeString), SoundInterval(globalBattleSoundCache.getSound('GUI_balloon_popup.mp3'), node=self), Wait(1.0), Func(self.hideShovelButtonFake, 1))
self.shovelTrack.start()
def setGuiConflict(self, con):
self.guiConflict = con
def getGuiConflict(self, con):
return self.guiConflict
def verboseState(self):
self.lastPlaceState = 'None'
taskMgr.add(self.__expressState, 'expressState', extraArgs=[])
def __expressState(self, task = None):
place = base.cr.playGame.getPlace()
if place:
state = place.fsm.getCurrentState()
if state.getName() != self.lastPlaceState:
print 'Place State Change From %s to %s' % (self.lastPlaceState, state.getName())
self.lastPlaceState = state.getName()
return Task.cont
def addShovelRelatedDoId(self, doId):
if hasattr(base.cr.playGame.getPlace(), 'detectedGardenPlotDone'):
place = base.cr.playGame.getPlace()
state = place.fsm.getCurrentState()
if state.getName() == 'stopped':
return
self.touchingPlantList.append(doId)
self.autoSetActivePlot()
def removeShovelRelatedDoId(self, doId):
if doId in self.touchingPlantList:
self.touchingPlantList.remove(doId)
self.autoSetActivePlot()
def autoSetActivePlot(self):
if self.guiConflict:
return
if len(self.touchingPlantList) > 0:
minDist = 10000
minDistPlot = 0
for plot in self.touchingPlantList:
plant = base.cr.doId2do.get(plot)
if plant:
if self.getDistance(plant) < minDist:
minDist = self.getDistance(plant)
minDistPlot = plot
else:
self.touchingPlantList.remove(plot)
if len(self.touchingPlantList) == 0:
self.setActivePlot(None)
else:
self.setActivePlot(minDistPlot)
else:
self.setActivePlot(None)
return
def setActivePlot(self, doId):
if not self.gardenStarted:
return
self.shovelRelatedDoId = doId
plant = base.cr.doId2do.get(doId)
if plant:
self.startStareAt(plant, Point3(0, 0, 1))
self.__shovelButton['state'] = DGG.NORMAL
if not plant.canBePicked():
self.hideShovelButton()
else:
self.showShovelButton()
self.setShovelAbility(TTLocalizer.GardeningPlant)
if plant.getShovelAction():
self.setShovelAbility(plant.getShovelAction())
if plant.getShovelAction() == TTLocalizer.GardeningPick:
if not plant.unlockPick():
self.__shovelButton['state'] = DGG.DISABLED
self.setShovelAbility(TTLocalizer.GardeningFull)
self.notify.debug('self.shovelRelatedDoId = %d' % self.shovelRelatedDoId)
if plant.getShovelCommand():
self.extraShovelCommand = plant.getShovelCommand()
self.__shovelButton['command'] = self.__shovelButtonClicked
if plant.canBeWatered():
self.showWateringCanButton()
else:
self.hideWateringCanButton()
else:
self.stopStareAt()
self.shovelRelatedDoId = 0
if self.__shovelButton:
self.__shovelButton['command'] = None
self.hideShovelButton()
self.hideWateringCanButton()
self.handleAllGardeningButtonsHidden()
if not self.inGardenAction:
if hasattr(base.cr.playGame.getPlace(), 'detectedGardenPlotDone'):
place = base.cr.playGame.getPlace()
if place:
place.detectedGardenPlotDone()
return
def setPlantToWater(self, plantId):
import pdb
pdb.set_trace()
if self.plantToWater == None:
self.plantToWater = plantId
self.notify.debug('setting plant to water %s' % plantId)
return
def clearPlantToWater(self, plantId):
if not hasattr(self, 'secondaryPlant'):
self.secondaryWaterPlant = None
if self.plantToWater == plantId:
self.plantToWater = None
self.hideWateringCanButton()
return
def hasPlant(self):
if self.plantToWater != None:
return 1
else:
return 0
return
def handleAllGardeningButtonsHidden(self):
somethingVisible = False
if not self.__shovelButton.isHidden():
somethingVisible = True
if not self.__wateringCanButton.isHidden():
somethingVisible = True
if not somethingVisible:
self.hideGardeningGui()
def setShovelAbility(self, ability):
self.shovelAbility = ability
if self.__shovelButton:
self.__shovelButton['text'] = ability
def setFlowerBasket(self, speciesList, varietyList):
DistributedToon.DistributedToon.setFlowerBasket(self, speciesList, varietyList)
self.numFlowers = len(self.flowerBasket.flowerList)
self.maxFlowerBasket
if hasattr(self, 'basketButton'):
self.basketText = '%s / %s' % (self.numFlowers, self.maxFlowerBasket)
self.basketButton['text'] = self.basketText
def setShovelSkill(self, skillLevel):
if hasattr(self, 'shovelSkill') and hasattr(self, 'shovelButton'):
if self.shovelSkill != None:
self.levelShovel(skillLevel - self.shovelSkill)
oldShovelSkill = self.shovelSkill
DistributedToon.DistributedToon.setShovelSkill(self, skillLevel)
if hasattr(self, 'shovel'):
oldShovelPower = GardenGlobals.getShovelPower(self.shovel, oldShovelSkill)
newShovelPower = GardenGlobals.getShovelPower(self.shovel, self.shovelSkill)
almostMaxedSkill = GardenGlobals.ShovelAttributes[GardenGlobals.MAX_SHOVELS - 1]['skillPts'] - 2
if skillLevel >= GardenGlobals.ShovelAttributes[self.shovel]['skillPts']:
self.promoteShovel()
elif oldShovelSkill and oldShovelPower < newShovelPower:
self.promoteShovelSkill(self.shovel, self.shovelSkill)
elif oldShovelSkill == almostMaxedSkill and newShovelPower == GardenGlobals.getNumberOfShovelBoxes():
self.promoteShovelSkill(self.shovel, self.shovelSkill)
return
def setWateringCanSkill(self, skillLevel):
skillDelta = skillLevel - self.wateringCanSkill
if skillDelta or 1:
if hasattr(self, 'wateringCanSkill') and hasattr(self, 'wateringCanButton'):
if self.wateringCanSkill != None:
self.levelWater(skillDelta)
DistributedToon.DistributedToon.setWateringCanSkill(self, skillLevel)
if hasattr(self, 'wateringCan'):
if skillLevel >= GardenGlobals.WateringCanAttributes[self.wateringCan]['skillPts']:
self.promoteWateringCan()
return
def unlockGardeningButtons(self, task = None):
if hasattr(self, '_LocalToon__shovelButton'):
try:
self.__shovelButton['state'] = DGG.NORMAL
except TypeError:
self.notify.warning('Could not unlock the shovel button- Type Error')
if hasattr(self, '_LocalToon__wateringCanButton'):
try:
self.__wateringCanButton['state'] = DGG.NORMAL
except TypeError:
self.notify.warning('Could not unlock the watering can button - Type Error')
taskMgr.remove('unlockGardenButtons')
return None
def lockGardeningButtons(self, task = None):
if hasattr(self, '_LocalToon__shovelButton'):
try:
self.__shovelButton['state'] = DGG.DISABLED
except TypeError:
self.notify.warning('Could not lock the shovel button- Type Error')
if hasattr(self, '_LocalToon__wateringCanButton'):
try:
self.__wateringCanButton['state'] = DGG.DISABLED
except TypeError:
self.notify.warning('Could not lock the watering can button - Type Error')
self.accept('endPlantInteraction', self.__handleEndPlantInteraction)
return None
def reactivateShovel(self, task = None):
if hasattr(self, '_LocalToon__shovelButton'):
self.__shovelButton['state'] = DGG.NORMAL
taskMgr.remove('reactShovel')
return None
def reactivateWater(self, task = None):
if hasattr(self, '_LocalToon__wateringCanButton'):
self.__wateringCanButton['state'] = DGG.NORMAL
taskMgr.remove('reactWater')
return None
def handleEndPlantInteraction(self, object = None, replacement = 0):
if not replacement:
self.setInGardenAction(None, object)
self.autoSetActivePlot()
return
def __handleEndPlantInteraction(self, task = None):
self.setInGardenAction(None)
self.autoSetActivePlot()
return
def promoteShovelSkill(self, shovelLevel, shovelSkill):
shovelName = GardenGlobals.ShovelAttributes[shovelLevel]['name']
shovelBeans = GardenGlobals.getShovelPower(shovelLevel, shovelSkill)
oldShovelBeans = GardenGlobals.getShovelPower(shovelLevel, shovelSkill - 1)
doPartyBall = False
message = TTLocalizer.GardenShovelSkillLevelUp % {'shovel': shovelName,
'oldbeans': oldShovelBeans,
'newbeans': shovelBeans}
if shovelBeans == GardenGlobals.getNumberOfShovelBoxes():
if shovelSkill == GardenGlobals.ShovelAttributes[shovelLevel]['skillPts'] - 1:
doPartyBall = True
message = TTLocalizer.GardenShovelSkillMaxed % {'shovel': shovelName,
'oldbeans': oldShovelBeans,
'newbeans': shovelBeans}
messagePos = Vec2(0, 0.2)
messageScale = 0.07
image = loader.loadModel('phase_5.5/models/gui/planting_but_shovel_P')
imagePos = Vec3(0, 0, -0.13)
imageScale = Vec3(0.28, 0, 0.56)
if doPartyBall:
go = Fanfare.makeFanfareWithMessageImage(0, base.localAvatar, 1, message, Vec2(0, 0.2), 0.08, image, Vec3(0, 0, -0.1), Vec3(0.35, 0, 0.7), wordwrap=23)
Sequence(go[0], Func(go[1].show), LerpColorScaleInterval(go[1], duration=0.5, startColorScale=Vec4(1, 1, 1, 0), colorScale=Vec4(1, 1, 1, 1)), Wait(10), LerpColorScaleInterval(go[1], duration=0.5, startColorScale=Vec4(1, 1, 1, 1), colorScale=Vec4(1, 1, 1, 0)), Func(go[1].remove)).start()
else:
go = Fanfare.makePanel(base.localAvatar, 1)
Fanfare.makeMessageBox(go, message, messagePos, messageScale, wordwrap=24)
Fanfare.makeImageBox(go.itemFrame, image, imagePos, imageScale)
Sequence(Func(go.show), LerpColorScaleInterval(go, duration=0.5, startColorScale=Vec4(1, 1, 1, 0), colorScale=Vec4(1, 1, 1, 1)), Wait(10), LerpColorScaleInterval(go, duration=0.5, startColorScale=Vec4(1, 1, 1, 1), colorScale=Vec4(1, 1, 1, 0)), Func(go.remove)).start()
def promoteShovel(self, shovelLevel = 0):
shovelName = GardenGlobals.ShovelAttributes[shovelLevel]['name']
shovelBeans = GardenGlobals.getShovelPower(shovelLevel, 0)
message = TTLocalizer.GardenShovelLevelUp % {'shovel': shovelName,
'oldbeans': shovelBeans - 1,
'newbeans': shovelBeans}
messagePos = Vec2(0, 0.2)
messageScale = 0.07
image = loader.loadModel('phase_5.5/models/gui/planting_but_shovel_P')
imagePos = Vec3(0, 0, -0.13)
imageScale = Vec3(0.28, 0, 0.56)
go = Fanfare.makePanel(base.localAvatar, 1)
Fanfare.makeMessageBox(go, message, messagePos, messageScale, wordwrap=24)
Fanfare.makeImageBox(go.itemFrame, image, imagePos, imageScale)
Sequence(Func(go.show), LerpColorScaleInterval(go, duration=0.5, startColorScale=Vec4(1, 1, 1, 0), colorScale=Vec4(1, 1, 1, 1)), Wait(10), LerpColorScaleInterval(go, duration=0.5, startColorScale=Vec4(1, 1, 1, 1), colorScale=Vec4(1, 1, 1, 0)), Func(go.remove)).start()
def promoteWateringCan(self, wateringCanlevel = 0):
message = TTLocalizer.GardenWateringCanLevelUp + ' \n' + GardenGlobals.WateringCanAttributes[wateringCanlevel]['name']
messagePos = Vec2(0, 0.2)
messageScale = 0.08
image = loader.loadModel('phase_5.5/models/gui/planting_but_can_P')
imagePos = Vec3(0, 0, -0.1)
imageScale = Vec3(0.35, 0, 0.7)
if wateringCanlevel >= GardenGlobals.MAX_WATERING_CANS - 1:
go = Fanfare.makeFanfareWithMessageImage(0, base.localAvatar, 1, message, Vec2(0, 0.2), 0.08, image, Vec3(0, 0, -0.1), Vec3(0.35, 0, 0.7))
Sequence(go[0], Func(go[1].show), LerpColorScaleInterval(go[1], duration=0.5, startColorScale=Vec4(1, 1, 1, 0), colorScale=Vec4(1, 1, 1, 1)), Wait(5), LerpColorScaleInterval(go[1], duration=0.5, startColorScale=Vec4(1, 1, 1, 1), colorScale=Vec4(1, 1, 1, 0)), Func(go[1].remove)).start()
else:
go = Fanfare.makePanel(base.localAvatar, 1)
Fanfare.makeMessageBox(go, message, messagePos, messageScale)
Fanfare.makeImageBox(go.itemFrame, image, imagePos, imageScale)
Sequence(Func(go.show), LerpColorScaleInterval(go, duration=0.5, startColorScale=Vec4(1, 1, 1, 0), colorScale=Vec4(1, 1, 1, 1)), Wait(5), LerpColorScaleInterval(go, duration=0.5, startColorScale=Vec4(1, 1, 1, 1), colorScale=Vec4(1, 1, 1, 0)), Func(go.remove)).start()
def setInGardenAction(self, actionObject, fromObject = None):
if actionObject:
self.lockGardeningButtons()
elif fromObject:
self.unlockGardeningButtons()
else:
self.unlockGardeningButtons()
self.inGardenAction = actionObject
def __wateringCanButtonClicked(self):
self.notify.debug('wateringCanButtonClicked')
if self.inGardenAction:
return
plant = base.cr.doId2do.get(self.shovelRelatedDoId)
if plant:
if hasattr(plant, 'handleWatering'):
plant.handleWatering()
messenger.send('wakeup')
def __shovelButtonClicked(self):
if self.inGardenAction:
return
self.notify.debug('shovelButtonClicked')
messenger.send('wakeup')
thingId = self.shovelRelatedDoId
thing = base.cr.doId2do.get(thingId)
if hasattr(self, 'extraShovelCommand'):
self.extraShovelCommand()
self.setActivePlot(thingId)
def setShovel(self, shovelId):
DistributedToon.DistributedToon.setShovel(self, shovelId)
if self.__gardeningGui:
self.setShovelGuiLevel(shovelId)
def setWateringCan(self, wateringCanId):
DistributedToon.DistributedToon.setWateringCan(self, wateringCanId)
if self.__gardeningGui:
self.setWateringCanGuiLevel(wateringCanId)
def setGardenStarted(self, bStarted):
self.gardenStarted = bStarted
if self.gardenStarted and not self.gardenPage and hasattr(self, 'book'):
self.loadGardenPages()
def b_setAnimState(self, animName, animMultiplier = 1.0, callback = None, extraArgs = []):
if self.wantStatePrint:
print 'Local Toon Anim State %s' % animName
DistributedToon.DistributedToon.b_setAnimState(self, animName, animMultiplier, callback, extraArgs)
def swimTimeoutAction(self):
self.ignore('wakeup')
self.takeOffSuit()
base.cr.playGame.getPlace().fsm.request('final')
self.b_setAnimState('TeleportOut', 1, self.__handleSwimExitTeleport, [0])
return Task.done
def __handleSwimExitTeleport(self, requestStatus):
self.notify.info('closing shard...')
base.cr.gameFSM.request('closeShard', ['afkTimeout'])
def sbFriendAdd(self, id, info):
print 'sbFriendAdd'
def sbFriendUpdate(self, id, info):
print 'sbFriendUpdate'
def sbFriendRemove(self, id):
print 'sbFriendRemove'
def addGolfPage(self):
if self.hasPlayedGolf():
if hasattr(self, 'golfPage') and self.golfPage != None:
return
if not launcher.getPhaseComplete(6):
self.acceptOnce('phaseComplete-6', self.addGolfPage)
return
self.golfPage = GolfPage.GolfPage()
self.golfPage.setAvatar(self)
self.golfPage.load()
self.book.addPage(self.golfPage, pageName=TTLocalizer.GolfPageTitle)
return
def addEventsPage(self):
if hasattr(self, 'eventsPage') and self.eventsPage != None:
return
if not launcher.getPhaseComplete(4):
self.acceptOnce('phaseComplete-4', self.addEventsPage)
return
self.eventsPage = EventsPage.EventsPage()
self.eventsPage.load()
self.book.addPage(self.eventsPage, pageName=TTLocalizer.EventsPageName)
return
def addNewsPage(self):
self.newsPage = NewsPage.NewsPage()
self.newsPage.load()
self.book.addPage(self.newsPage, pageName=TTLocalizer.NewsPageName)
def addTIPPage(self):
self.tipPage = TIPPage.TIPPage()
self.tipPage.load()
self.book.addPage(self.tipPage, pageName=TTLocalizer.TIPPageTitle)
def setPinkSlips(self, pinkSlips):
DistributedToon.DistributedToon.setPinkSlips(self, pinkSlips)
self.inventory.updateTotalPropsText()
def getAccountDays(self):
days = 0
defaultDays = base.cr.config.GetInt('account-days', -1)
if defaultDays >= 0:
days = defaultDays
elif hasattr(base.cr, 'accountDays'):
days = base.cr.accountDays
return days
def hasActiveBoardingGroup(self):
if hasattr(localAvatar, 'boardingParty') and localAvatar.boardingParty:
return localAvatar.boardingParty.hasActiveGroup(localAvatar.doId)
else:
return False
def getZoneId(self):
return self._zoneId
def setZoneId(self, value):
if value == -1:
self.notify.error('zoneId should not be set to -1, tell Redmond')
self._zoneId = value
zoneId = property(getZoneId, setZoneId)
def systemWarning(self, warningText = 'Acknowledge this system message.'):
self.createSystemMsgAckGui()
self.systemMsgAckGui['text'] = warningText
self.systemMsgAckGui.show()
def createSystemMsgAckGui(self):
if self.systemMsgAckGui == None or self.systemMsgAckGui.isEmpty():
message = 'o' * 100
self.systemMsgAckGui = TTDialog.TTGlobalDialog(doneEvent=self.systemMsgAckGuiDoneEvent, message=message, style=TTDialog.Acknowledge)
self.systemMsgAckGui.hide()
return
def hideSystemMsgAckGui(self):
if self.systemMsgAckGui != None and not self.systemMsgAckGui.isEmpty():
self.systemMsgAckGui.hide()
return
def setSleepAutoReply(self, fromId):
av = base.cr.identifyAvatar(fromId)
if isinstance(av, DistributedToon.DistributedToon):
base.localAvatar.setSystemMessage(0, TTLocalizer.sleep_auto_reply % av.getName(), WhisperPopup.WTToontownBoardingGroup)
elif av is not None:
self.notify.warning('setSleepAutoReply from non-toon %s' % fromId)
return
def setLastTimeReadNews(self, newTime):
self.lastTimeReadNews = newTime
def getLastTimeReadNews(self):
return self.lastTimeReadNews
def cheatCogdoMazeGame(self, kindOfCheat = 0):
if base.config.GetBool('allow-cogdo-maze-suit-hit-cheat'):
maze = base.cr.doFind('DistCogdoMazeGame')
if maze:
if kindOfCheat == 0:
for suitNum in maze.game.suitsById.keys():
suit = maze.game.suitsById[suitNum]
maze.sendUpdate('requestSuitHitByGag', [suit.type, suitNum])
elif kindOfCheat == 1:
for joke in maze.game.pickups:
maze.sendUpdate('requestPickUp', [joke.serialNum])
else:
self.sendUpdate('logSuspiciousEvent', ['cheatCogdoMazeGame'])
def isReadingNews(self):
result = False
if base.cr and base.cr.playGame and base.cr.playGame.getPlace() and hasattr(base.cr.playGame.getPlace(), 'fsm') and base.cr.playGame.getPlace().fsm:
fsm = base.cr.playGame.getPlace().fsm
curState = fsm.getCurrentState().getName()
if curState == 'stickerBook' and WantNewsPage:
if hasattr(self, 'newsPage'):
if self.book.isOnPage(self.newsPage):
result = True
return result
def doTeleportResponse(self, fromAvatar, toAvatar, avId, available, shardId, hoodId, zoneId, sendToId):
localAvatar.d_teleportResponse(avId, available, shardId, hoodId, zoneId, sendToId)
def d_teleportResponse(self, avId, available, shardId, hoodId, zoneId, sendToId = None):
if base.config.GetBool('want-tptrack', False):
if available == 1:
self.notify.debug('sending teleportResponseToAI')
self.sendUpdate('teleportResponseToAI', [avId,
available,
shardId,
hoodId,
zoneId,
sendToId])
else:
self.sendUpdate('teleportResponse', [avId,
available,
shardId,
hoodId,
zoneId], sendToId)
else:
DistributedPlayer.DistributedPlayer.d_teleportResponse(self, avId, available, shardId, hoodId, zoneId, sendToId)
def startQuestMap(self):
if self.questMap:
self.questMap.start()
def stopQuestMap(self):
if self.questMap:
self.questMap.stop()
def _startZombieCheck(self):
pass
def _stopZombieCheck(self):
pass