mirror of
https://github.com/Sneed-Group/Poodletooth-iLand
synced 2024-10-31 00:37:54 +00:00
254 lines
12 KiB
Python
Executable file
254 lines
12 KiB
Python
Executable file
from direct.distributed.PyDatagram import *
|
|
from panda3d.core import *
|
|
|
|
from otp.ai.AIZoneData import AIZoneDataStore
|
|
from otp.ai.MagicWordManagerAI import MagicWordManagerAI
|
|
from otp.ai.TimeManagerAI import TimeManagerAI
|
|
from otp.ai import BanManagerAI
|
|
from otp.distributed.OtpDoGlobals import *
|
|
from otp.friends.FriendManagerAI import FriendManagerAI
|
|
from toontown.ai import CogPageManagerAI
|
|
from toontown.ai import CogSuitManagerAI
|
|
from toontown.ai import PromotionManagerAI
|
|
from toontown.ai.FishManagerAI import FishManagerAI
|
|
from toontown.ai.NewsManagerAI import NewsManagerAI
|
|
from toontown.ai.QuestManagerAI import QuestManagerAI
|
|
from toontown.ai.DistributedBlackCatMgrAI import DistributedBlackCatMgrAI
|
|
from toontown.ai.DistributedReportMgrAI import DistributedReportMgrAI
|
|
from toontown.building.DistributedBuildingQueryMgrAI import DistributedBuildingQueryMgrAI
|
|
from toontown.building.DistributedTrophyMgrAI import DistributedTrophyMgrAI
|
|
from toontown.catalog.CatalogManagerAI import CatalogManagerAI
|
|
from toontown.coghq import CountryClubManagerAI
|
|
from toontown.coghq import FactoryManagerAI
|
|
from toontown.coghq import LawOfficeManagerAI
|
|
from toontown.coghq import MintManagerAI
|
|
from toontown.distributed.ToontownDistrictAI import ToontownDistrictAI
|
|
from toontown.distributed.ToontownDistrictStatsAI import ToontownDistrictStatsAI
|
|
from toontown.distributed.ToontownInternalRepository import ToontownInternalRepository
|
|
from toontown.coderedemption.TTCodeRedemptionMgrAI import TTCodeRedemptionMgrAI
|
|
from toontown.dna.DNAParser import loadDNAFileAI
|
|
from toontown.estate.EstateManagerAI import EstateManagerAI
|
|
from toontown.hood import BRHoodAI
|
|
from toontown.hood import BossbotHQAI
|
|
from toontown.hood import CashbotHQAI
|
|
from toontown.hood import DDHoodAI
|
|
from toontown.hood import DGHoodAI
|
|
from toontown.hood import DLHoodAI
|
|
from toontown.hood import GSHoodAI
|
|
from toontown.hood import GZHoodAI
|
|
from toontown.hood import LawbotHQAI
|
|
from toontown.hood import MMHoodAI
|
|
from toontown.hood import OZHoodAI
|
|
from toontown.hood import SellbotHQAI
|
|
from toontown.hood import TTHoodAI
|
|
from toontown.hood import ZoneUtil
|
|
from toontown.racing.LeaderboardMgrAI import LeaderboardMgrAI
|
|
from toontown.pets.PetManagerAI import PetManagerAI
|
|
from toontown.safezone.SafeZoneManagerAI import SafeZoneManagerAI
|
|
from toontown.suit.SuitInvasionManagerAI import SuitInvasionManagerAI
|
|
from toontown.groups.GroupManagerAI import GroupManagerAI
|
|
from toontown.toon import NPCToons
|
|
from toontown.toonbase import ToontownGlobals
|
|
from toontown.tutorial.TutorialManagerAI import TutorialManagerAI
|
|
from toontown.uberdog.DistributedPartyManagerAI import DistributedPartyManagerAI
|
|
from toontown.uberdog.DistributedTopToonsManagerAI import DistributedTopToonsManagerAI
|
|
#from toontown.uberdog.DistributedLobbyManagerAI import DistributedLobbyManagerAI
|
|
|
|
class ToontownAIRepository(ToontownInternalRepository):
|
|
def __init__(self, baseChannel, stateServerChannel, districtName):
|
|
ToontownInternalRepository.__init__(
|
|
self, baseChannel, stateServerChannel, dcSuffix='AI')
|
|
|
|
self.districtName = districtName
|
|
|
|
self.notify.setInfo(True) # Our AI repository should always log info.
|
|
self.hoods = []
|
|
self.cogHeadquarters = []
|
|
self.dnaStoreMap = {}
|
|
self.dnaDataMap = {}
|
|
self.suitPlanners = {}
|
|
self.buildingManagers = {}
|
|
self.factoryMgr = None
|
|
self.mintMgr = None
|
|
self.lawOfficeMgr = None
|
|
self.countryClubMgr = None
|
|
self.groupManager = GroupManagerAI(self)
|
|
self.topToonsMgr = DistributedTopToonsManagerAI(self)
|
|
|
|
self.zoneAllocator = UniqueIdAllocator(ToontownGlobals.DynamicZonesBegin,
|
|
ToontownGlobals.DynamicZonesEnd)
|
|
self.zoneDataStore = AIZoneDataStore()
|
|
|
|
self.wantFishing = self.config.GetBool('want-fishing', True)
|
|
self.wantHousing = self.config.GetBool('want-housing', True)
|
|
self.wantPets = self.config.GetBool('want-pets', True)
|
|
self.wantKarts = self.config.GetBool('want-karts', True)
|
|
self.wantParties = self.config.GetBool('want-parties', True)
|
|
self.wantEmblems = self.config.GetBool('want-emblems', True)
|
|
self.wantCogbuildings = self.config.GetBool('want-cogbuildings', True)
|
|
self.wantCogdominiums = self.config.GetBool('want-cogdominiums', True)
|
|
self.wantTrackClsends = self.config.GetBool('want-track-clsends', False)
|
|
self.baseXpMultiplier = self.config.GetFloat('base-xp-multiplier', 1.0)
|
|
|
|
self.cogSuitMessageSent = False
|
|
|
|
def createManagers(self):
|
|
self.timeManager = TimeManagerAI(self)
|
|
self.timeManager.generateWithRequired(2)
|
|
self.magicWordManager = MagicWordManagerAI(self)
|
|
self.magicWordManager.generateWithRequired(2)
|
|
self.newsManager = NewsManagerAI(self)
|
|
self.newsManager.generateWithRequired(2)
|
|
self.safeZoneManager = SafeZoneManagerAI(self)
|
|
self.safeZoneManager.generateWithRequired(2)
|
|
self.tutorialManager = TutorialManagerAI(self)
|
|
self.tutorialManager.generateWithRequired(2)
|
|
self.friendManager = FriendManagerAI(self)
|
|
self.friendManager.generateWithRequired(2)
|
|
self.questManager = QuestManagerAI(self)
|
|
self.banManager = BanManagerAI.BanManagerAI(self)
|
|
self.suitInvasionManager = SuitInvasionManagerAI(self)
|
|
self.blackCatMgr = DistributedBlackCatMgrAI(self)
|
|
self.blackCatMgr.generateWithRequired(2)
|
|
self.reportMgr = DistributedReportMgrAI(self)
|
|
self.reportMgr.generateWithRequired(2)
|
|
self.trophyMgr = DistributedTrophyMgrAI(self)
|
|
self.trophyMgr.generateWithRequired(2)
|
|
self.cogSuitMgr = CogSuitManagerAI.CogSuitManagerAI()
|
|
self.promotionMgr = PromotionManagerAI.PromotionManagerAI(self)
|
|
self.cogPageManager = CogPageManagerAI.CogPageManagerAI()
|
|
self.codeRedemptionMgr = TTCodeRedemptionMgrAI(self)
|
|
self.codeRedemptionMgr.generateWithRequired(2)
|
|
self.buildingQueryMgr = DistributedBuildingQueryMgrAI(self)
|
|
self.buildingQueryMgr.generateWithRequired(2)
|
|
self.groupManager.generateWithRequired(2)
|
|
if self.wantKarts:
|
|
self.leaderboardMgr = LeaderboardMgrAI(self)
|
|
if self.wantFishing:
|
|
self.fishManager = FishManagerAI(self)
|
|
if self.wantHousing:
|
|
self.estateManager = EstateManagerAI(self)
|
|
self.estateManager.generateWithRequired(2)
|
|
self.catalogManager = CatalogManagerAI(self)
|
|
self.catalogManager.generateWithRequired(2)
|
|
if self.wantPets:
|
|
self.petMgr = PetManagerAI(self)
|
|
if self.wantParties:
|
|
self.partyManager = DistributedPartyManagerAI(self)
|
|
self.partyManager.generateWithRequired(2)
|
|
self.globalPartyMgr = self.generateGlobalObject(
|
|
OTP_DO_ID_GLOBAL_PARTY_MANAGER, 'GlobalPartyManager')
|
|
#self.lobbyManager = DistributedLobbyManagerAI(self)
|
|
#self.lobbyManager.generateWithRequired(2)
|
|
#self.globalLobbyMgr = self.generateGlobalObject(
|
|
# OTP_DO_ID_GLOBAL_LOBBY_MANAGER, 'GlobalLobbyManager')
|
|
|
|
def createSafeZones(self):
|
|
NPCToons.generateZone2NpcDict()
|
|
if self.config.GetBool('want-toontown-central', True):
|
|
self.hoods.append(TTHoodAI.TTHoodAI(self))
|
|
if self.config.GetBool('want-donalds-dock', True):
|
|
self.hoods.append(DDHoodAI.DDHoodAI(self))
|
|
if self.config.GetBool('want-daisys-garden', True):
|
|
self.hoods.append(DGHoodAI.DGHoodAI(self))
|
|
if self.config.GetBool('want-minnies-melodyland', True):
|
|
self.hoods.append(MMHoodAI.MMHoodAI(self))
|
|
if self.config.GetBool('want-the-brrrgh', True):
|
|
self.hoods.append(BRHoodAI.BRHoodAI(self))
|
|
if self.config.GetBool('want-donalds-dreamland', True):
|
|
self.hoods.append(DLHoodAI.DLHoodAI(self))
|
|
if self.config.GetBool('want-goofy-speedway', True):
|
|
self.hoods.append(GSHoodAI.GSHoodAI(self))
|
|
if self.config.GetBool('want-outdoor-zone', True):
|
|
self.hoods.append(OZHoodAI.OZHoodAI(self))
|
|
if self.config.GetBool('want-golf-zone', True):
|
|
self.hoods.append(GZHoodAI.GZHoodAI(self))
|
|
|
|
def createCogHeadquarters(self):
|
|
NPCToons.generateZone2NpcDict()
|
|
if self.config.GetBool('want-sellbot-headquarters', True):
|
|
self.factoryMgr = FactoryManagerAI.FactoryManagerAI(self)
|
|
self.cogHeadquarters.append(SellbotHQAI.SellbotHQAI(self))
|
|
if self.config.GetBool('want-cashbot-headquarters', True):
|
|
self.mintMgr = MintManagerAI.MintManagerAI(self)
|
|
self.cogHeadquarters.append(CashbotHQAI.CashbotHQAI(self))
|
|
if self.config.GetBool('want-lawbot-headquarters', True):
|
|
self.lawOfficeMgr = LawOfficeManagerAI.LawOfficeManagerAI(self)
|
|
self.cogHeadquarters.append(LawbotHQAI.LawbotHQAI(self))
|
|
if self.config.GetBool('want-bossbot-headquarters', True):
|
|
self.countryClubMgr = CountryClubManagerAI.CountryClubManagerAI(self)
|
|
self.cogHeadquarters.append(BossbotHQAI.BossbotHQAI(self))
|
|
|
|
def handleConnected(self):
|
|
ToontownInternalRepository.handleConnected(self)
|
|
self.districtId = self.allocateChannel()
|
|
self.notify.info('Creating ToontownDistrictAI(%d)...' % self.districtId)
|
|
self.distributedDistrict = ToontownDistrictAI(self)
|
|
self.distributedDistrict.setName(self.districtName)
|
|
self.distributedDistrict.generateWithRequiredAndId(
|
|
self.districtId, self.getGameDoId(), 2)
|
|
self.notify.info('Claiming ownership of channel ID: %d...' % self.districtId)
|
|
self.claimOwnership(self.districtId)
|
|
|
|
self.districtStats = ToontownDistrictStatsAI(self)
|
|
self.districtStats.setDistrictId(self.districtId)
|
|
self.districtStats.generateWithRequiredAndId(
|
|
self.allocateChannel(), self.getGameDoId(), 3)
|
|
self.notify.info('Created ToontownDistrictStats(%d)' % self.districtStats.doId)
|
|
|
|
self.notify.info('Creating managers...')
|
|
self.createManagers()
|
|
if self.config.GetBool('want-safe-zones', True):
|
|
self.notify.info('Creating safe zones...')
|
|
self.createSafeZones()
|
|
if self.config.GetBool('want-cog-headquarters', True):
|
|
self.notify.info('Creating Cog headquarters...')
|
|
self.createCogHeadquarters()
|
|
|
|
self.notify.info('Making district available...')
|
|
self.distributedDistrict.b_setAvailable(1)
|
|
self.notify.info('Done.')
|
|
|
|
def claimOwnership(self, channelId):
|
|
datagram = PyDatagram()
|
|
datagram.addServerHeader(channelId, self.ourChannel, STATESERVER_OBJECT_SET_AI)
|
|
datagram.addChannel(self.ourChannel)
|
|
self.send(datagram)
|
|
|
|
def lookupDNAFileName(self, zoneId):
|
|
zoneId = ZoneUtil.getCanonicalZoneId(zoneId)
|
|
hoodId = ZoneUtil.getCanonicalHoodId(zoneId)
|
|
hood = ToontownGlobals.dnaMap[hoodId]
|
|
if hoodId == zoneId:
|
|
zoneId = 'sz'
|
|
phaseNum = ToontownGlobals.phaseMap[hoodId]
|
|
else:
|
|
phaseNum = ToontownGlobals.streetPhaseMap[hoodId]
|
|
return 'phase_%s/dna/%s_%s.pdna' % (phaseNum, hood, zoneId)
|
|
|
|
def loadDNAFileAI(self, dnastore, filename):
|
|
return loadDNAFileAI(dnastore, filename)
|
|
|
|
def incrementPopulation(self):
|
|
self.districtStats.b_setAvatarCount(self.districtStats.getAvatarCount() + 1)
|
|
|
|
def decrementPopulation(self):
|
|
self.districtStats.b_setAvatarCount(self.districtStats.getAvatarCount() - 1)
|
|
|
|
def allocateZone(self):
|
|
return self.zoneAllocator.allocate()
|
|
|
|
def deallocateZone(self, zone):
|
|
self.zoneAllocator.free(zone)
|
|
|
|
def getZoneDataStore(self):
|
|
return self.zoneDataStore
|
|
|
|
def getTrackClsends(self):
|
|
return self.wantTrackClsends
|
|
|
|
def getAvatarExitEvent(self, avId):
|
|
return 'distObjDelete-%d' % avId
|
|
|
|
def trueUniqueName(self, name):
|
|
return self.uniqueName(name)
|