from direct.distributed import DistributedObjectGlobal
from toontown.ai import WelcomeValleyManager/AI
from toontown.building import DistributedAnimatedProp/AI
from toontown.toon import DistributedToon/AI/UD
from toontown.classicchars import DistributedCCharBase/AI
from toontown.classicchars import DistributedMickey/AI
from toontown.classicchars import DistributedVampireMickey/AI
from toontown.classicchars import DistributedMinnie/AI
from toontown.classicchars import DistributedWitchMinnie/AI
from toontown.classicchars import DistributedGoofy/AI
from toontown.classicchars import DistributedSuperGoofy/AI
from toontown.classicchars import DistributedDaisy/AI
from toontown.classicchars import DistributedSockHopDaisy/AI
from toontown.classicchars import DistributedChip/AI
from toontown.classicchars import DistributedPoliceChip/AI
from toontown.classicchars import DistributedDale/AI
from toontown.classicchars import DistributedJailbirdDale/AI
from toontown.classicchars import DistributedGoofySpeedway/AI
from toontown.classicchars import DistributedDonald/AI
from toontown.classicchars import DistributedFrankenDonald/AI
from toontown.classicchars import DistributedDonaldDock/AI
from toontown.classicchars import DistributedPluto/AI
from toontown.classicchars import DistributedWesternPluto/AI
from toontown.safezone import DistributedTrolley/AI
from toontown.safezone import DistributedPartyGate/AI
from toontown.suit import DistributedSuitPlanner/AI
from toontown.suit import DistributedSuitBase/AI
from toontown.suit import DistributedSuit/AI
from toontown.suit import DistributedTutorialSuit/AI
from toontown.suit import DistributedFactorySuit/AI
from toontown.suit import DistributedMintSuit/AI
from toontown.suit import DistributedStageSuit/AI
//from toontown.election import DistributedInvasionSuit/AI
from toontown.suit import DistributedSellbotBoss/AI
from toontown.suit import DistributedCashbotBoss/AI
from toontown.coghq import DistributedCashbotBossSafe/AI
from toontown.coghq import DistributedCashbotBossCrane/AI
from toontown.suit import DistributedCashbotBossGoon/AI
from toontown.battle import DistributedBattleBase/AI
from toontown.battle import DistributedBattle/AI
from toontown.battle import DistributedBattleBldg/AI
from toontown.tutorial import DistributedBattleTutorial/AI
from toontown.coghq import DistributedBattleFactory/AI
from toontown.battle import DistributedBattleFinal/AI
from toontown.safezone import DistributedBoat/AI
from toontown.safezone import DistributedButterfly/AI
from toontown.safezone import DistributedMMPiano/AI
from toontown.safezone import DistributedDGFlower/AI
//from toontown.election import DistributedElectionEvent/AI
//from toontown.election import DistributedHotAirBalloon/AI
//from toontown.election import DistributedSafezoneInvasion/AI
//from toontown.election import DistributedElectionCamera/AI
//from toontown.election import DistributedElectionCameraManager/AI
from toontown.fishing import DistributedFishingPond/AI
from toontown.fishing import DistributedFishingTarget/AI
from toontown.fishing import DistributedPondBingoManager/AI
from toontown.safezone import DistributedFishingSpot/AI
from toontown.estate import DistributedCannon/AI
from toontown.estate import DistributedTarget/AI
from toontown.minigame import DistributedMinigame/AI
from toontown.minigame import DistributedMinigameTemplate/AI
from toontown.minigame import DistributedRaceGame/AI
from toontown.minigame import DistributedCannonGame/AI
from toontown.minigame import DistributedPhotoGame/AI
from toontown.minigame import DistributedPatternGame/AI
from toontown.minigame import DistributedRingGame/AI
from toontown.minigame import DistributedTagGame/AI
from toontown.minigame import DistributedMazeGame/AI
from toontown.minigame import DistributedTugOfWarGame/AI
from toontown.minigame import DistributedCatchGame/AI
from toontown.minigame import DistributedDivingGame/AI
from toontown.minigame import DistributedTargetGame/AI
from toontown.estate import EstateManager/AI
from toontown.estate import DistributedEstate/AI
from toontown.estate import DistributedHouse/AI
from toontown.estate import DistributedHouseInterior/AI
from toontown.estate import DistributedGarden/AI
from toontown.shtiker import DeleteManager/AI
from toontown.ai import NewsManager/AI
from toontown.shtiker import PurchaseManager/AI
from toontown.shtiker import NewbiePurchaseManager/AI
from toontown.tutorial import TutorialManager/AI
from toontown.catalog import CatalogManager/AI
from toontown.safezone import DistributedTreasure/AI
from toontown.coghq import DistributedCashbotBossTreasure/AI
from toontown.building import DistributedTrophyMgr/AI
from toontown.building import DistributedBuilding/AI
from toontown.building import DistributedAnimBuilding/AI
from toontown.building import DistributedToonInterior/AI
from toontown.building import DistributedToonHallInterior/AI
from toontown.building import DistributedSuitInterior/AI
from toontown.building import DistributedHQInterior/AI
from toontown.building import DistributedGagshopInterior/AI
from toontown.building import DistributedPetshopInterior/AI
from toontown.building import DistributedKartShopInterior/AI
from toontown.building import DistributedDoor/AI
from toontown.building import DistributedAnimDoor/AI
from toontown.estate import DistributedHouseDoor/AI
from toontown.coghq import DistributedCogHQDoor/AI
from toontown.coghq import DistributedSellbotHQDoor/AI
from toontown.toon import DistributedNPCToonBase/AI
from toontown.toon import DistributedNPCToon/AI
from toontown.toon import DistributedNPCSnowballGiver/AI
from toontown.toon import DistributedNPCSpecialQuestGiver/AI
from toontown.toon import DistributedNPCFlippyInToonHall/AI
from toontown.toon import DistributedNPCScientist/AI
from toontown.toon import DistributedNPCClerk/AI
from toontown.toon import DistributedNPCTailor/AI
from toontown.toon import DistributedNPCBlocker/AI
from toontown.toon import DistributedNPCFisherman/AI
from toontown.toon import DistributedNPCPartyPerson/AI
from toontown.toon import DistributedNPCPetclerk/AI
from toontown.toon import DistributedNPCKartClerk/AI
from toontown.building import DistributedKnockKnockDoor/AI
from toontown.building import DistributedElevator/AI
from toontown.building import DistributedElevatorFSM/AI
from toontown.building import DistributedElevatorExt/AI
from toontown.building import DistributedElevatorInt/AI
from toontown.coghq import DistributedFactoryElevatorExt/AI
from toontown.coghq import DistributedMintElevatorExt/AI
from toontown.coghq import DistributedLawOfficeElevatorExt/AI
from toontown.coghq import DistributedLawOfficeElevatorInt/AI
from toontown.building import DistributedElevatorFloor/AI
from toontown.building import DistributedBossElevator/AI
from toontown.building import DistributedVPElevator/AI
from toontown.building import DistributedCFOElevator/AI
from toontown.building import DistributedCJElevator/AI
from toontown.building import DistributedBBElevator/AI
from toontown.building import DistributedBoardingParty/AI
from toontown.building import DistributedTutorialInterior/AI
from toontown.estate import DistributedBankMgr/AI
from toontown.estate import DistributedMailbox/AI
from toontown.estate import DistributedFurnitureManager/AI
from toontown.estate import DistributedFurnitureItem/AI
from toontown.estate import DistributedBank/AI
from toontown.estate import DistributedCloset/AI
from toontown.estate import DistributedTrunk/AI
from toontown.estate import DistributedPhone/AI
from toontown.effects import DistributedFireworkShow/AI
from toontown.estate import DistributedFireworksCannon/AI
from toontown.coghq import LobbyManager/AI
from otp.level import DistributedLevel/AI
from otp.level import DistributedEntity/AI
from otp.level import DistributedInteractiveEntity/AI
from toontown.coghq import DistributedFactory/AI
from toontown.coghq import DistributedLawOffice/AI
from toontown.coghq import DistributedLawOfficeFloor/AI
from toontown.coghq import DistributedLift/AI
from toontown.coghq import DistributedDoorEntity/AI
from toontown.coghq import DistributedSwitch/AI
from toontown.coghq import DistributedButton/AI
from toontown.coghq import DistributedTrigger/AI
from toontown.coghq import DistributedCrushableEntity/AI
from toontown.coghq import DistributedCrusherEntity/AI
from toontown.coghq import DistributedStomper/AI
from toontown.coghq import DistributedStomperPair/AI
from toontown.coghq import DistributedLaserField/AI
from toontown.coghq import DistributedGolfGreenGame/AI
from toontown.coghq import DistributedSecurityCamera/AI
from toontown.coghq import DistributedMover/AI
from toontown.coghq import DistributedElevatorMarker/AI
from toontown.coghq import DistributedBarrelBase/AI
from toontown.coghq import DistributedGagBarrel/AI
from toontown.coghq import DistributedBeanBarrel/AI
from toontown.coghq import DistributedHealBarrel/AI
from toontown.coghq import DistributedGrid/AI
from toontown.coghq import ActiveCell/AI
from toontown.coghq import DirectionalCell/AI
from toontown.coghq import CrusherCell/AI
from toontown.coghq import DistributedCrate/AI
from toontown.coghq import DistributedSinkingPlatform/AI
from toontown.suit import DistributedGoon/AI
from toontown.suit import DistributedGridGoon/AI
from toontown.coghq import BattleBlocker/AI
from toontown.ai import DistributedBlackCatMgr/AI
from toontown.ai import DistributedPolarBearMgr/AI
from toontown.ai import DistributedPolarPlaceEffectMgr/AI
from toontown.ai import DistributedGreenToonEffectMgr/AI
from toontown.ai import DistributedResistanceEmoteMgr/AI
from toontown.ai import DistributedScavengerHuntTarget/AI
from toontown.ai import DistributedTrickOrTreatTarget/AI
from toontown.ai import DistributedWinterCarolingTarget/AI
from toontown.coghq import DistributedMint/AI
from toontown.coghq import DistributedMintRoom/AI
from toontown.coghq import DistributedMintBattle/AI
from toontown.coghq import DistributedStage/AI
from toontown.coghq import DistributedStageRoom/AI
from toontown.coghq import DistributedStageBattle/AI
from toontown.pets.PetDCImports/AI import *
from toontown.pets import DistributedPetProxy/AI
from toontown.coghq.InGameEditorDCImports/AI import *
from toontown.distributed import ToontownDistrict/AI
from toontown.distributed import ToontownDistrictStats/AI
from toontown.racing import DistributedVehicle/AI
from toontown.racing import DistributedStartingBlock/AI
from toontown.racing import DistributedRace/AI
from toontown.racing import DistributedKartPad/AI
from toontown.racing import DistributedRacePad/AI
from toontown.racing import DistributedViewPad/AI
from toontown.racing import DistributedStartingBlock/AI
from toontown.racing import DistributedLeaderBoard/AI
from toontown.racing import DistributedGag/AI
from toontown.racing import DistributedProjectile/AI
from toontown.racing.DistributedStartingBlock/AI import DistributedViewingBlock/AI
from toontown.uberdog.ClientServicesManager/UD import ClientServicesManager/UD
from toontown.uberdog.DistributedDeliveryManager/AI/UD import DistributedDeliveryManager/AI/UD
from toontown.uberdog.DistributedDataStoreManager/AI/UD import DistributedDataStoreManager/AI/UD
from toontown.suit import DistributedLawbotBoss/AI
from toontown.coghq import DistributedLawbotBossGavel/AI
from toontown.suit import DistributedLawbotBossSuit/AI
from toontown.coghq import DistributedLawbotCannon/AI
from toontown.coghq import DistributedLawbotChair/AI
from toontown.estate import DistributedLawnDecor/AI
from toontown.estate import DistributedGardenPlot/AI
from toontown.estate import DistributedGardenBox/AI
from toontown.estate import DistributedFlower/AI
from toontown.estate import DistributedGagTree/AI
from toontown.estate import DistributedStatuary/AI
from toontown.estate import DistributedToonStatuary/AI
from toontown.estate import DistributedChangingStatuary/AI
from toontown.estate import DistributedAnimatedStatuary/AI
from toontown.estate import DistributedPlantBase/AI
from toontown.estate import DistributedLawnDecor/AI
from toontown.minigame import DistributedTravelGame/AI
from toontown.minigame import DistributedPairingGame/AI
from toontown.minigame import DistributedVineGame/AI
from toontown.golf import DistributedPhysicsWorld/AI
from toontown.golf import DistributedGolfHole/AI
from toontown.golf import DistributedGolfCourse/AI
from toontown.parties import DistributedParty/AI
from toontown.parties import DistributedPartyActivity/AI
from toontown.parties import DistributedPartyTeamActivity/AI
from toontown.parties import DistributedPartyCannon/AI
from toontown.parties import DistributedPartyCannonActivity/AI
from toontown.parties import DistributedPartyCatchActivity/AI
from toontown.parties import DistributedPartyWinterCatchActivity/AI
from toontown.parties import DistributedPartyCogActivity/AI
from toontown.parties import DistributedPartyWinterCogActivity/AI
from toontown.parties import DistributedPartyFireworksActivity/AI
from toontown.parties import DistributedPartyDanceActivityBase/AI
from toontown.parties import DistributedPartyDanceActivity/AI
from toontown.parties import DistributedPartyDance20Activity/AI
from toontown.parties import DistributedPartyValentineDanceActivity/AI
from toontown.parties import DistributedPartyValentineDance20Activity/AI
from toontown.parties import DistributedPartyTrampolineActivity/AI
from toontown.parties import DistributedPartyValentineTrampolineActivity/AI
from toontown.parties import DistributedPartyVictoryTrampolineActivity/AI
from toontown.parties import DistributedPartyWinterTrampolineActivity/AI
from toontown.parties import DistributedPartyTugOfWarActivity/AI
from toontown.parties import DistributedPartyJukeboxActivityBase/AI
from toontown.parties import DistributedPartyJukeboxActivity/AI
from toontown.parties import DistributedPartyJukebox40Activity/AI
from toontown.parties import DistributedPartyValentineJukeboxActivity/AI
from toontown.parties import DistributedPartyValentineJukebox40Activity/AI
from toontown.friends import TTPlayerFriendsManager/UD
from toontown.friends import TTRFriendsManager/UD
from toontown.uberdog import TTSpeedchatRelay/UD
from toontown.safezone import DistributedGolfKart/AI
from toontown.safezone import DistributedPicnicBasket/AI
from toontown.distributed import DistributedTimer/AI
from toontown.suit import DistributedBossbotBoss/AI
from toontown.coghq import DistributedCogKart/AI
from toontown.coghq import DistributedCountryClub/AI
from toontown.coghq import DistributedCountryClubRoom/AI
from toontown.coghq import DistributedMoleField/AI
from toontown.coghq import DistributedCountryClubBattle/AI
from toontown.building import DistributedClubElevator/AI
from toontown.coghq import DistributedMaze/AI
from toontown.battle import DistributedBattleWaiters/AI
from toontown.coghq import DistributedFoodBelt/AI
from toontown.coghq import DistributedBanquetTable/AI
from toontown.battle import DistributedBattleDiners/AI
from toontown.coghq import DistributedGolfSpot/AI
from toontown.minigame import DistributedIceGame/AI
from toontown.minigame import DistributedCogThiefGame/AI
from toontown.minigame import DistributedTwoDGame/AI
from toontown.safezone import DistributedPicnicTable/AI
from toontown.safezone import DistributedChineseCheckers/AI
from toontown.safezone import DistributedCheckers/AI
from toontown.safezone import DistributedFindFour/AI
from toontown.uberdog.DistributedMailManager/AI/UD import DistributedMailManager/AI/UD
from toontown.uberdog.DistributedPartyManager/AI/UD import DistributedPartyManager/AI/UD
from toontown.rpc.AwardManager/UD import AwardManager/UD
from toontown.uberdog.DistributedCpuInfoMgr/AI/UD import DistributedCpuInfoMgr/AI/UD
from toontown.uberdog.DistributedSecurityMgr/AI/UD import DistributedSecurityMgr/AI/UD
from toontown.rpc.RATManager/UD import RATManager/UD
from toontown.uberdog.DistributedInGameNewsMgr/AI/UD import DistributedInGameNewsMgr/AI/UD
from toontown.uberdog.DistributedWhitelistMgr/AI/UD import DistributedWhitelistMgr/AI/UD
from toontown.coderedemption.TTCodeRedemptionMgr/AI/UD import TTCodeRedemptionMgr/AI/UD
from toontown.distributed.NonRepeatableRandomSourceAI import NonRepeatableRandomSourceAI
from toontown.distributed.NonRepeatableRandomSourceUD import NonRepeatableRandomSourceUD
from toontown.ai.DistributedPhaseEventMgr/AI import DistributedPhaseEventMgr/AI
from toontown.ai.DistributedHydrantZeroMgr/AI import DistributedHydrantZeroMgr/AI
from toontown.ai.DistributedMailboxZeroMgr/AI import DistributedMailboxZeroMgr/AI
from toontown.ai.DistributedTrashcanZeroMgr/AI import DistributedTrashcanZeroMgr/AI
from toontown.ai import DistributedSillyMeterMgr/AI
from toontown.cogdominium import DistributedCogdoInterior/AI
from toontown.cogdominium import DistributedCogdoBattleBldg/AI
from toontown.cogdominium import DistributedCogdoElevatorExt/AI
from toontown.cogdominium import DistributedCogdoElevatorInt/AI
from toontown.cogdominium import DistributedCogdoBarrel/AI
from toontown.cogdominium import DistCogdoGame/AI
from toontown.cogdominium import DistCogdoLevelGame/AI
from toontown.cogdominium import DistCogdoBoardroomGame/AI
from toontown.cogdominium import DistCogdoCraneGame/AI
from toontown.cogdominium import DistCogdoMazeGame/AI
from toontown.cogdominium import DistCogdoFlyingGame/AI
from toontown.cogdominium import DistCogdoCrane/AI
from toontown.cogdominium import DistCogdoCraneMoneyBag/AI
from toontown.cogdominium import DistCogdoCraneCog/AI
from toontown.parties.GlobalPartyManager/AI/UD import GlobalPartyManager/AI/UD
from toontown.uberdog.ARGManager/AI/UD import ARGManager/AI/UD

struct GiftItem {
  blob Item;
  string giftTag;
};

struct gardenSpecial {
  uint8 index;
  uint8 count;
};

struct simpleMail {
  uint64 msgId;
  uint32 senderId;
  uint16 year;
  uint8 month;
  uint8 day;
  string body;
};

struct invite {
  uint64 inviteKey;
  uint64 partyId;
  uint8 status;
};

struct decoration {
  uint8 decorId;
  uint8 x;
  uint8 y;
  uint8 h;
};

struct activity {
  uint8 activityId;
  uint8 x;
  uint8 y;
  uint8 h;
};

struct party {
  uint64 partyId;
  uint32 hostId;
  uint16 startYear;
  uint8 startMonth;
  uint8 startDay;
  uint8 startHour;
  uint8 startMinute;
  uint16 endYear;
  uint8 endMonth;
  uint8 endDay;
  uint8 endHour;
  uint8 endMinute;
  uint8 isPrivate;
  uint8 inviteTheme;
  activity activities[];
  decoration decors[];
  uint8 status;
};

struct partyReply {
  uint32 inviteeId;
  uint8 status;
};

struct repliesForOneParty {
  uint64 partyId;
  partyReply partyReplies[];
};

struct publicPartyInfo {
  uint32 shardId;
  uint32 zoneId;
  uint8 numberOfGuests;
  string hostName;
  uint8[] activityIds;
  uint16 minLeft;
};

struct jukeboxSongInfo {
  uint8/10 phase;
  string fileName;
};

struct partyCloudColor {
  uint16 cloudNumber;
  uint8/100 r;
  uint8/100 g;
  uint8/100 b;
};

struct datetime {
  uint16 year;
  uint8 month;
  uint8 day;
  uint8 hour;
  uint8 minutes;
  uint8 seconds;
};

dclass ToontownDistrict : DistributedDistrict {
  setParentingRules(string, string) broadcast ram;
  allowAHNNLog(bool allow) broadcast required ram;
  rpcSetAvailable(bool available) airecv;
};

dclass ToontownDistrictStats : DistributedObject {
  settoontownDistrictId(uint32 value) broadcast required ram;
  setAvatarCount(uint32 avatarCount) broadcast required ram;
  setNewAvatarCount(uint32 newAvatarCount) broadcast required ram;
  setStats : setAvatarCount, setNewAvatarCount;
};

dclass WelcomeValleyManager : DistributedObject {
  clientSetZone(uint32 todo0) airecv clsend;
  requestZoneIdMessage(uint32 origZoneId, uint16 context) airecv clsend;
  requestZoneIdResponse(uint32 zoneId, uint16 context);
};

dclass DistributedAnimatedProp : DistributedObject {
  setPropId(uint16 propId) required broadcast ram;
  setAvatarInteract(uint32 avatarId) required broadcast ram;
  requestInteract() airecv clsend;
  rejectInteract();
  requestExit() airecv clsend;
  avatarExit(uint32 avatarId) broadcast;
  setState(string state, int16 timestamp) required broadcast ram;
};

typedef int16 pair16[2];

dclass DistributedToon : DistributedPlayer {
  setWantBetaKeyQuest(uint8 = 0) required db airecv;
  setWebAccountId(uint32 webId = 0) required airecv;
  setDNAString(blob dnaString) required broadcast ownrecv db;
  setGM(uint8 type = 0) required broadcast ownrecv db;
  setMaxBankMoney(int16 maxMoney = 15000) required broadcast ownrecv db;
  setBankMoney(int16 money = 0) required broadcast ownrecv db;
  setMaxMoney(int16 maxMoney = 40) required broadcast ownrecv db;
  setMoney(int16 money = 0) required broadcast ownrecv db;
  setMaxHp(int16 hitPoints = 15) required broadcast ownrecv db;
  setHp(int16 hp = 15) required broadcast ownrecv db;
  toonUp(uint16 hpGained) broadcast ownrecv;
  takeDamage(uint16 hpLost) broadcast ownrecv;
  setBattleId(uint32 battleId = 0) required broadcast ram;
  setExperience(blob experience = [0*14]) required broadcast db;
  setMaxCarry(uint8 maxCarry = 20) required ownrecv db;
  setTrackAccess(uint16 trackArray[] = [0,0,0,0,1,1,0]) required broadcast ownrecv db;
  setTrackProgress(int8 trackId = -1, uint32 progress = 0) required ownrecv db;
  setTrackBonusLevel(int8 trackArray[] = [-1,-1,-1,-1,-1,-1,-1]) required broadcast ownrecv db;
  setInventory(blob inventoryNetString = [0*7, 0*7, 0*7, 0*7, 1, 0*6, 1, 0*6, 0*7]) required broadcast db;
  setMaxNPCFriends(uint16 max = 16) required ownrecv db;
  setNPCFriendsDict(FriendEntry NPCFriendsList[] = []) required ownrecv db;
  setDefaultShard(uint32 shard = 0) required ownrecv broadcast db;
  setDefaultZone(uint32 zoneId = 0) required ownrecv broadcast db;
  setShtickerBook(blob str = []) required ownrecv db;
  setZonesVisited(uint32 hoods[] = [ 2000 ]) required ownrecv db;
  setHoodsVisited(uint32 hoods[] = [ 2000 ]) required ownrecv db;
  setInterface(blob str = []) required ownrecv db;
  setLastHood(uint32 lastHood = 0) required ownrecv broadcast db;
  setTutorialAck(uint8 tutorialAck = 0) required ownrecv db;
  setMaxClothes(uint32 max = 10) required ownrecv db;
  setClothesTopsList(uint8 clothesList[] = []) required ownrecv db;
  setClothesBottomsList(uint8 clothesList[] = []) required ownrecv db;
  setMaxAccessories(uint32 max = 0) required ownrecv db;
  setHatList(uint8 clothesList[] = []) required ownrecv db;
  setGlassesList(uint8 clothesList[] = []) required ownrecv db;
  setBackpackList(uint8 clothesList[] = []) required ownrecv db;
  setShoesList(uint8 clothesList[] = []) required ownrecv db;
  setHat(uint8 idx = 0, uint8 textureIdx = 0, uint8 colorIdx = 0) required broadcast db ownrecv;
  setGlasses(uint8 idx = 0, uint8 textureIdx = 0, uint8 colorIdx = 0) required broadcast db ownrecv;
  setBackpack(uint8 idx = 0, uint8 textureIdx = 0, uint8 colorIdx = 0) required broadcast db ownrecv;
  setShoes(uint8 idx = 0, uint8 textureIdx = 0, uint8 colorIdx = 0) required broadcast db ownrecv;
  setGardenSpecials(gardenSpecial specials[] = []) required ownrecv db airecv;
  setEarnedExperience(uint16 earnedExp[]) ownrecv;
  setTunnelIn(int16 timestamp, int16/10 endX, int16/10 x, int16/10 y, int16/100 z, int32/100 h) ownsend broadcast;
  setTunnelOut(int16 timestamp, int16/10 startX, int16/10 startY, int16/10 x, int16/10 y, int16/100 z, int32/100 h) ownsend broadcast;
  setAnimState(char animName[0-1024], int16/1000 animMultiplier, int16 timestamp) broadcast ram ownsend airecv;
  setEmoteState(int16 animIndex, int16/1000 animMultiplier, int16 timestamp) broadcast ram ownsend;
  setEmoteAccess(uint8 bits[] = [1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]) required ownrecv db;
  setCustomMessages(uint16 customMessages[] = []) required ownrecv db;
  setSleepAutoReply(uint32 fromId) broadcast clsend ownrecv;
  setResistanceMessages(pair16 resistanceMessages[] = []) required ownrecv db;
  setPetTrickPhrases(uint8 tricks[] = [0]) required ownrecv db;
  setCatalogSchedule(uint16 currentWeek = 0, uint32 nextTime = 0) required ownrecv db;
  setCatalog(blob monthlyCatalog = [], blob weeklyCatalog = [], blob backCatalog = []) required ownrecv db;
  setMailboxContents(blob mailboxContents = []) required ownrecv db;
  setDeliverySchedule(blob onOrder = []) required ownrecv db airecv;
  setGiftSchedule(blob onGiftOrder = []) required ownrecv db airecv;
  setAwardMailboxContents(blob awardMailboxContents = []) required ownrecv db;
  setAwardSchedule(blob onOrder = []) required ownrecv db airecv;
  setAwardNotify(uint8 awardNotify = 0) required ownrecv db;
  setCatalogNotify(uint8 catalogNotify = 0, uint8 mailboxNotify = 0) required ownrecv db;
  playSplashEffect(int16/10 x, int16/10 y, int16/10 z) broadcast ownsend;
  setWhisperSCToontaskFrom(uint32 fromId, uint32 taskId, uint32 toNpcId, uint32 toonProgress, uint8 msgIndex) ownrecv clsend;
  setSCToontask(uint32 taskId, uint32 toNpcId, uint32 toonProgress, uint8 msgIndex) broadcast ownsend;
  reqSCResistance(uint16 msgIndex, uint32 nearbyPlayers[]) ownsend airecv;
  setSCResistance(uint16 msgIndex, uint32 nearbyToons[]) broadcast ownrecv;
  setSpeedChatStyleIndex(uint8 index = 1) required ownsend broadcast db;
  setTrophyScore(uint16 score) broadcast ownrecv ram;
  setTeleportAccess(uint32 teleportZoneArray[] = []) required ownrecv db;
  checkTeleportAccess(uint16 zoneId) airecv ownsend;
  setTeleportOverride(uint8 flag) clsend airecv;
  battleSOS(uint32 requesterId) ownrecv clsend;
  teleportQuery(uint32 requesterId) ownrecv clsend;
  teleportResponse(uint32 avId, int8 available, uint32 shardId, uint32 hoodId, uint32 zoneId) ownrecv clsend;
  teleportResponseToAI(uint32 toAvId, int8 available, uint32 shardId, uint32 hoodId, uint32 zoneId, uint32 fromAvId) ownsend airecv;
  teleportGiveup(uint32 requesterId) ownrecv clsend;
  teleportGreeting(uint32 avId) broadcast ownsend;
  setCogStatus(uint32 cogStatusList[] = [1 * 32]) required ownrecv db;
  setCogCount(uint32 cogCountList[] = [0 * 32]) required ownrecv db;
  setCogRadar(uint8 radar[] = [0 * 4]) required ownrecv db;
  setBuildingRadar(uint8 radar[] = [0 * 4]) required ownrecv db;
  setCogLevels(uint8 levels[] = [0 * 4]) required broadcast ownrecv db;
  setCogTypes(uint8 types[] = [0 * 4]) required broadcast ownrecv db;
  setCogParts(uint32 parts[] = [0 * 4]) required broadcast ownrecv db;
  setCogMerits(uint16 merits[] = [0 * 4]) required ownrecv db;
  setCogIndex(int8 index) broadcast ram;
  setDisguisePageFlag(int8 flag) ownrecv;
  setSosPageFlag(int8 flag) ownrecv;
  setHouseId(uint32 id = 0) required ownrecv db;
  setQuests(uint32 flattenedQuests[] = []) required broadcast ownrecv db;
  setQuestHistory(uint16 questList[] = []) required ownrecv db;
  setRewardHistory(uint8 rewardTier = 0, uint16 rewardList[] = [100]) required ownrecv db;
  setQuestCarryLimit(uint8 limit = 1) required ownrecv db;
  requestDeleteQuest(uint32 questDesc[]) ownsend airecv;
  setCheesyEffect(int16 effect = 0, uint32 hoodId = 0, uint32 expireTime = 0) required broadcast ownrecv db;
  setGhostMode(uint8 flag) broadcast ownrecv ram;
  setPosIndex(uint8 index = 0) required ownrecv db;
  setFishCollection(uint8 genusList[] = [], uint8 speciesList[] = [], uint16 weightList[] = []) required ownrecv db;
  setMaxFishTank(uint8 maxTank = 20) required ownrecv db;
  setFishTank(uint8 genusList[] = [], uint8 speciesList[] = [], uint16 weightList[] = []) required ownrecv db;
  setFishingRod(uint8 rodId = 0) required broadcast ownrecv db;
  setFishingTrophies(uint8 trophyList[] = []) required ownrecv db;
  setFlowerCollection(uint8 speciesList[] = [], uint8 varietyList[] = []) required ownrecv db;
  setFlowerBasket(uint8 speciesList[] = [], uint8 varietyList[] = []) required ownrecv db;
  setMaxFlowerBasket(uint8 maxFlowerBasket = 20) required ownrecv db;
  setGardenTrophies(uint8 trophyList[] = []) required ownrecv db;
  setShovel(uint8 shovelId = 0) required broadcast ownrecv db;
  setShovelSkill(uint32 skillLevel = 0) required ownrecv db;
  setWateringCan(uint8 wateringCanId = 0) required broadcast ownrecv db;
  setWateringCanSkill(uint32 skillLevel = 0) required ownrecv db;
  promoteShovel(uint8 shovel) ownrecv;
  promoteWateringCan(uint8 wateringCan) ownrecv;
  reactivateWater() ownrecv;
  presentPie(int16/10 x, int16/10 y, int16/10 z, int16/10 h, int32 timestamp) broadcast ownsend;
  tossPie(int16/10 x, int16/10 y, int16/10 z, int16/10 h, uint8 sequence, uint8 power, uint8 throwType, int32 timestamp) broadcast ownsend;
  pieSplat(int16/10 x, int16/10 y, int16/10 z, uint8 sequence, uint8 pieCode, int32 timestamp32) broadcast ownsend;
  setPieType(uint8 pieType) broadcast ownrecv ram;
  setNumPies(uint16 numPies) broadcast ownrecv ram;
  setPieThrowType(uint8 throwType) broadcast ownrecv ram;
  setHealthDisplay(uint8 mode) broadcast ownrecv ram;
  catalogGenClothes(uint32 avId) broadcast ownrecv;
  catalogGenAccessories(uint32 avId) broadcast ownrecv;
  setPetId(uint32 petId = 0) required broadcast ownrecv db;
  setPetMovie(uint32 petId, uint8 flag) ownsend airecv;
  setPetTutorialDone(uint8 bDone = 0) required ownsend airecv db;
  setFishBingoTutorialDone(uint8 bDone = 0) required ownsend airecv db;
  setFishBingoMarkTutorialDone(uint8 bDone = 0) required ownsend airecv db;
  setKartBodyType(int8 bodyType = -1) required broadcast ownrecv db;
  setKartBodyColor(int8 bodyColor = -1) required broadcast ownrecv db;
  setKartAccessoryColor(int8 accColor = -1) required broadcast ownrecv db;
  setKartEngineBlockType(int8 ebType = -1) required broadcast ownrecv db;
  setKartSpoilerType(int8 spType = -1) required broadcast ownrecv db;
  setKartFrontWheelWellType(int8 fwwType = -1) required broadcast ownrecv db;
  setKartBackWheelWellType(int8 bwwType = -1) required broadcast ownrecv db;
  setKartRimType(int8 rimsType = -1) required broadcast ownrecv db;
  setKartDecalType(int8 decalType = -1) required broadcast ownrecv db;
  updateKartDNAField(int8 dnaField, int8 fieldValue) ownsend airecv;
  addOwnedAccessory(int8 accessoryId) ownsend airecv;
  removeOwnedAccessory(int8 accessoryId) ownsend airecv;
  setTickets(uint32 numTickets = 200) required broadcast ownrecv db;
  setKartingHistory(uint8 history[16] = [0*16]) required ownrecv db;
  setKartingTrophies(uint8 trophyList[33] = [0*33]) required ownrecv db;
  setKartingPersonalBest(uint32/1000 bestTimes[6] = [0*6]) required ownrecv db;
  setKartingPersonalBest2(uint32/1000 bestTimes2[12] = [0*12]) required ownrecv db;
  setKartAccessoriesOwned(int8 accessories[16] = [-1*16]) required broadcast ownrecv db;
  setCurrentKart(uint32 avId) broadcast ownrecv ram;
  squish(uint8 damage) ownsend airecv;
  announceBingo() broadcast ownrecv;
  trickOrTreatTargetMet(uint32 beanAmount) ownrecv;
  trickOrTreatMilestoneMet() ownrecv;
  winterCarolingTargetMet(uint32 beanAmount) ownrecv;
  setCogSummonsEarned(uint8 cogSummonsEarned[] = [0*32]) required ownrecv db;
  reqCogSummons(char type[0-256], uint32 suitIndex) ownsend airecv;
  cogSummonsResponse(string returnCode, uint32 suitIndex, uint32 doId) ownrecv;
  reqUseSpecial(int32 special) ownsend airecv;
  useSpecialResponse(string returnCode) ownrecv;
  setGardenStarted(uint8 bStarted = 0) required ownrecv db;
  sendToGolfCourse(uint32 zoneId) ownrecv;
  setGolfHistory(uint16 history[18] = [0*18]) required ownrecv db;
  setPackedGolfHoleBest(uint8 packedHoleBest[18] = [0*18]) required ownrecv db;
  setGolfCourseBest(uint8 courseBest[3] = [0*3]) required ownrecv db;
  setUnlimitedSwing(uint8 unlimitedSwing) broadcast ownrecv ram;
  logSuspiciousEvent(char eventName[0-1024]) ownsend airecv;
  logMessage(char message[0-1024]) ownsend airecv;
  forceLogoutWithNotify() ownrecv;
  setPinkSlips(uint8 pinkSlips = 0) required ownrecv db;
  setNametagStyle(uint8 nametagStyle = 100) required broadcast ownrecv db;
  setMail(simpleMail mail[]) ownrecv;
  setNumMailItems(uint32 numMailItems) airecv;
  setSimpleMailNotify(uint8 simpleMailNotify) ownrecv airecv;
  setInvites(invite invites[]) ownrecv airecv ram;
  setPartiesInvitedTo(party partiesInvitedTo[]) ownrecv airecv ram;
  setHostedParties(party hostedParties[]) ownrecv airecv ram;
  setPartyReplies(repliesForOneParty replies[]) ownrecv airecv ram;
  updateInvite(uint64 inviteKey, uint8 newStatus) ownrecv airecv;
  updateReply(uint64 partyId, uint64 inviteeId, uint8 newStatus) ownrecv airecv;
  setPartyCanStart(uint64 partyId) ownrecv airecv;
  setPartyStatus(uint64 partyId, uint8 newStatus) ownrecv airecv;
  announcePartyStarted(uint64 partyId) ownrecv;
  setNeverStartedPartyRefunded(uint64 partyId, int8 newStatus, uint16 refund) ownrecv;
  setModuleInfo(string info[]) airecv clsend;
  setDISLname(string name) ram;
  setDISLid(uint32 id) ram db airecv;
  flagAv(uint32 avId, uint16 reason, string params[]) airecv ownsend;
  magicFanfare() broadcast;
  magicTeleportRequest(uint32 requesterId) ownrecv;
  magicTeleportResponse(uint32 requesterId, uint32 hoodId) ownsend airecv;
  magicTeleportInitiate(uint32 hoodId, uint32 zoneId) ownrecv;
  keepAlive() ownsend airecv;
  setLastSeen(uint32 timestamp = 0) required db;
};

dclass DistributedCCharBase : DistributedObject {
  setChat(uint32 category, uint32 msg, uint32 avId) broadcast;
  fadeAway() broadcast;
  setWalk(string srcNode, string destNode, int16 timestamp) required broadcast ram;
  avatarEnter() airecv clsend;
  avatarExit() airecv clsend;
  setNearbyAvatarChat(char msg[0-1024]) airecv clsend;
  setNearbyAvatarSC(uint16 msgIndex) airecv clsend;
  setNearbyAvatarSCCustom(uint16 msgIndex) airecv clsend;
  setNearbyAvatarSCToontask(uint32 taskId, uint32 toNpcId, uint32 toonProgress, uint8 msgIndex) airecv clsend;
};

dclass DistributedMickey : DistributedCCharBase {
};

dclass DistributedVampireMickey : DistributedMickey {
};

dclass DistributedWitchMinnie : DistributedMickey {
};

dclass DistributedMinnie : DistributedCCharBase {
};

dclass DistributedGoofy : DistributedCCharBase {
};

dclass DistributedDaisy : DistributedCCharBase {
};

dclass DistributedSockHopDaisy : DistributedDaisy {
};

dclass DistributedChip : DistributedCCharBase {
};

dclass DistributedPoliceChip : DistributedChip {
};

dclass DistributedDale : DistributedCCharBase {
  setFollowChip(string srcNode, string destNode, int16 timestamp, int16/100 offsetX, int16/100 offsetY) broadcast ram;
  setChipId(uint32 chipId) required broadcast ram;
};

dclass DistributedJailbirdDale : DistributedDale {
};

dclass DistributedDonald : DistributedCCharBase {
};

dclass DistributedFrankenDonald : DistributedDonald {
};

dclass DistributedDonaldDock : DistributedCCharBase {
};

dclass DistributedPluto : DistributedCCharBase {
};

dclass DistributedWesternPluto : DistributedPluto {
};

dclass DistributedGoofySpeedway : DistributedCCharBase {
};

dclass DistributedSuperGoofy : DistributedGoofySpeedway {
};

dclass DistributedPartyGate : DistributedObject {
  getPartyList(uint32 avId) airecv clsend;
  partyChoiceRequest(uint32 avId, uint64 shardId, uint64 zoneId) airecv clsend;
  listAllPublicParties(publicPartyInfo publicPartyInfo[]);
  partyRequestDenied(uint8 reason);
  setParty(publicPartyInfo partyInfoTuple, uint32 hostId);
};

dclass DistributedTrolley : DistributedObject {
  setState(string state, int16 timestamp) broadcast ram;
  fillSlot0(uint32 avId) broadcast ram;
  fillSlot1(uint32 avId) broadcast ram;
  fillSlot2(uint32 avId) broadcast ram;
  fillSlot3(uint32 avId) broadcast ram;
  emptySlot0(uint32 avId, int16 timestamp) broadcast ram;
  emptySlot1(uint32 avId, int16 timestamp) broadcast ram;
  emptySlot2(uint32 avId, int16 timestamp) broadcast ram;
  emptySlot3(uint32 avId, int16 timestamp) broadcast ram;
  requestBoard() airecv clsend;
  rejectBoard(uint32 avId);
  requestExit() airecv clsend;
  setMinigameZone(uint32 zoneId, uint16 minigameId);
};

dclass DistributedSuitPlanner : DistributedObject {
  setZoneId(uint32 zoneId) required broadcast ram;
  suitListQuery() airecv clsend;
  suitListResponse(uint8 suitList[]);
  buildingListQuery() airecv clsend;
  buildingListResponse(uint8 buildingList[]);
};

dclass DistributedSuitBase : DistributedObject {
  denyBattle();
  setDNAString(blob dnaString) required broadcast ram;
  setLevelDist(int16 level) required broadcast ram;
  setBrushOff(int16 index) broadcast;
  setSkelecog(uint8 flag) required broadcast ram;
  setSkeleRevives(uint8 num) required broadcast ram;
  setHP(int16 hp) required broadcast ram;
};

dclass DistributedSuit : DistributedSuitBase {
  requestBattle(int16/10 x, int16/10 y, int16/10 z, int16/10 h, int16/10 p, int16/10 r) airecv clsend;
  setSPDoId(uint32 doId) required broadcast ram;
  setPathEndpoints(uint16 start, uint16 end, uint16 minPathLen, uint16 maxPathLen) required broadcast ram;
  setPathPosition(uint16 index, int16 timestamp) required broadcast ram;
  setPathState(int8 state) required broadcast ram;
  debugSuitPosition(int16/10 elapsed, int16 currentLeg, int16/10 x, int16/10 y, int16 timestamp) broadcast;
};

dclass DistributedTutorialSuit : DistributedSuitBase {
  requestBattle(int16/10 x, int16/10 y, int16/10 z, int16/10 h, int16/10 p, int16/10 r) airecv clsend;
};

dclass DistributedFactorySuit : DistributedSuitBase {
  setLevelDoId(uint32 levelDoId) required broadcast ram;
  setCogId(uint32 cogId) required broadcast ram;
  setReserve(uint8 reserve) required broadcast ram;
  requestBattle(int16/10 x, int16/10 y, int16/10 z, int16/10 h, int16/10 p, int16/10 r) airecv clsend;
  setAlert(uint32 avId) airecv clsend;
  setConfrontToon(uint32 avId) broadcast;
  setStrayed() airecv clsend;
  setReturn() broadcast;
};

dclass DistributedMintSuit : DistributedFactorySuit {
};

dclass DistributedStageSuit : DistributedFactorySuit {
};

dclass DistributedInvasionSuit : DistributedSuitBase {
  // This should be networked BEFORE the current state, so that the spawn point
  // can be known and the position can be initialized.
  setSpawnPoint(uint8 pointId) required broadcast ram;
  // Ditto:
  setAttackInfo(uint32 targetId, string prop, uint8 damage) required broadcast ram;

  setState(string state, int32 timestamp) required broadcast ram;
  setMarchLerp(int16/10 x1, int16/10 y1, int16/10 x2, int16/10 y2, int32 timestamp) broadcast ram;

  setStaticPoint(int16/10 x, int16/10 y, uint16%360/100 h) broadcast ram;

  sayFaceoffTaunt(bool custom, string phrase) broadcast;
  makeSkelecog() broadcast ram;

  takeShakerDamage(uint8 damage) clsend airecv;
  setInvasionFinale(bool finale) required broadcast ram;
};

dclass DistributedBossCog : DistributedNode {
  setDNAString(blob) required broadcast db;
  setToonIds(uint32[], uint32[], uint32[]) broadcast ram;
  setBattleIds(uint8, uint32, uint32) broadcast ram;
  setArenaSide(uint8) broadcast ram;
  avatarEnter() airecv clsend;
  avatarExit() airecv clsend;
  avatarNearEnter() airecv clsend;
  avatarNearExit() airecv clsend;
  toonDied(uint32) broadcast;
  setBattleExperience(int32, int16[], int16[], uint32[], int16[], int16[], int16[], int16[], uint32[], int32, int16[], int16[], uint32[], int16[], int16[], int16[], int16[], uint32[], int32, int16[], int16[], uint32[], int16[], int16[], int16[], int16[], uint32[], int32, int16[], int16[], uint32[], int16[], int16[], int16[], int16[], uint32[], int32, int16[], int16[], uint32[], int16[], int16[], int16[], int16[], uint32[], int32, int16[], int16[], uint32[], int16[], int16[], int16[], int16[], uint32[], int32, int16[], int16[], uint32[], int16[], int16[], int16[], int16[], uint32[], int32, int16[], int16[], uint32[], int16[], int16[], int16[], int16[], uint32[], uint8[], int16[], uint32[]) required broadcast ram;
  zapToon(int16/10, int16/10, int16/10, int16/10, int16/10, int16/10, int8/100, int8/100, uint8, int16) airecv clsend;
  showZapToon(uint32, int16/10, int16/10, int16/10, int16/10, int16/10, int16/10, uint8, int16) broadcast;
  setAttackCode(uint8, uint32) broadcast;
};

dclass DistributedSellbotBoss : DistributedBossCog {
  setCagedToonNpcId(uint32 npcId) required broadcast ram;
  setDooberIds(uint32 dooberIds[]) broadcast ram;
  setBossDamage(uint16 bossDamage, uint8 recoverRate, int16 timestamp) broadcast ram;
  setState(string state) broadcast ram;
  hitBoss(uint8 bossDamage) airecv clsend;
  hitBossInsides() airecv clsend;
  hitToon(uint32 toonId) airecv clsend;
  finalPieSplat() airecv clsend;
  touchCage() airecv clsend;
  doStrafe(uint8 side, uint8 direction) broadcast;
  cagedToonBattleThree(uint16 index, uint32 avId) broadcast;
  toonPromoted(uint8(0-1) promoted);
};

dclass DistributedCashbotBoss : DistributedBossCog {
  setState(string state) broadcast ram;
  setBossDamage(uint16 bossDamage) broadcast ram;
  setRewardId(uint16 rewardId) broadcast ram;
  applyReward() airecv clsend;
};

struct LinkPosition {
  int16/100 x;
  int16/100 y;
  int16/100 z;
};

dclass DistributedCashbotBossCrane : DistributedObject {
  setBossCogId(uint32 bossCogId) required broadcast ram;
  setIndex(uint8 index) required broadcast ram;
  setState(char state, uint32 avId) broadcast ram;
  requestControl() airecv clsend;
  requestFree() airecv clsend;
  clearSmoothing(int8 bogus) broadcast clsend;
  setCablePos(uint8 changeSeq, int16/100 y, uint16%360/100 h, LinkPosition links[3], int16 timestamp) broadcast clsend;
};

dclass DistributedCashbotBossObject : DistributedObject {
  setBossCogId(uint32) required broadcast ram;
  setObjectState(char, uint32, uint32) broadcast ram;
  requestGrab() airecv clsend;
  rejectGrab();
  requestDrop() airecv clsend;
  hitFloor() clsend;
  requestFree(int16/10, int16/10, int16/10, uint16%360/100) airecv clsend;
  hitBoss(uint16/255) airecv clsend;
  setX(int16/10) broadcast ram clsend airecv;
  setY(int16/10) broadcast ram clsend airecv;
  setZ(int16/10) broadcast ram clsend airecv;
  setH(int16%360/10) broadcast ram clsend airecv;
  setP(int16%360/10) broadcast ram clsend airecv;
  setR(int16%360/10) broadcast ram clsend airecv;
  setPos : setX, setY, setZ;
  setHpr : setH, setP, setR;
  setPosHpr : setX, setY, setZ, setH, setP, setR;
  setXY : setX, setY;
  setXZ : setX, setZ;
  setXYH : setX, setY, setH;
  setXYZH : setX, setY, setZ, setH;
  setComponentL(uint64) broadcast ram clsend airecv;
  setComponentX(int16/10) broadcast ram clsend airecv;
  setComponentY(int16/10) broadcast ram clsend airecv;
  setComponentZ(int16/10) broadcast ram clsend airecv;
  setComponentH(int16%360/10) broadcast ram clsend airecv;
  setComponentP(int16%360/10) broadcast ram clsend airecv;
  setComponentR(int16%360/10) broadcast ram clsend airecv;
  setComponentT(int16) broadcast ram clsend airecv;
  setSmStop : setComponentT;
  setSmH : setComponentH, setComponentT;
  setSmZ : setComponentZ, setComponentT;
  setSmXY : setComponentX, setComponentY, setComponentT;
  setSmXZ : setComponentX, setComponentZ, setComponentT;
  setSmPos : setComponentX, setComponentY, setComponentZ, setComponentT;
  setSmHpr : setComponentH, setComponentP, setComponentR, setComponentT;
  setSmXYH : setComponentX, setComponentY, setComponentH, setComponentT;
  setSmXYZH : setComponentX, setComponentY, setComponentZ, setComponentH, setComponentT;
  setSmPosHpr : setComponentX, setComponentY, setComponentZ, setComponentH, setComponentP, setComponentR, setComponentT;
  setSmPosHprL : setComponentL, setComponentX, setComponentY, setComponentZ, setComponentH, setComponentP, setComponentR, setComponentT;
  clearSmoothing(int8) broadcast clsend;
};

dclass DistributedCashbotBossSafe : DistributedCashbotBossObject {
  setIndex(uint8 index) required broadcast ram;
  requestInitial() airecv clsend;
};

dclass DistributedCashbotBossGoon : DistributedCashbotBossObject {
  requestBattle(int16/10 pauseTime) airecv clsend;
  requestStunned(int16/10 pauseTime) airecv clsend;
  setVelocity(uint8/10 velocity) broadcast ram;
  setHFov(uint8 hFov) broadcast ram;
  setAttackRadius(uint8 attackRadius) broadcast ram;
  setStrength(uint8 strength) broadcast ram;
  setGoonScale(uint8/50 scale) broadcast ram;
  setupGoon : setVelocity, setHFov, setAttackRadius, setStrength, setGoonScale;
  setTarget(int16/10 x, int16/10 y, uint16%360/100 h, int16 arrivalTime) broadcast ram;
  destroyGoon() broadcast clsend airecv;
};

dclass DistributedBattleBase : DistributedObject {
  setLevelDoId(uint32 levelDoId) required broadcast ram;
  setBattleCellId(uint32 battleCellId) required broadcast ram;
  setInteractivePropTrackBonus(int8 trackBonus) required broadcast ram;
  setPosition(int16/10 x, int16/10 y, int16/10 z) required broadcast ram;
  setZoneId(uint32 zoneId) required broadcast ram;
  setInitialSuitPos(int16/10 x, int16/10 y, int16/10 z) required broadcast ram;
  setMembers(uint32 suits[], string suitsJoining, string suitsPending, string suitsActive, string suitsLured, string suitTraps, uint32 toons[], string toonsJoining, string toonsPending, string toonsActive, string toonsRunning, int16 timestamp) required broadcast ram;
  adjust(int16 timestamp) broadcast;
  setMovie(int8 active, uint32 toons[], uint32 suits[], int8 id0, int8 tr0, int8 le0, int32 tg0, int16 hp0[], int16 ac0, int16 hpb0, int16 kbb0[], int8 died0, int8 revive0, int8 id1, int8 tr1, int8 le1, int32 tg1, int16 hp1[], int16 ac1, int16 hpb1, int16 kbb1[], int8 died1, int8 revive1, int8 id2, int8 tr2, int8 le2, int32 tg2, int16 hp2[], int16 ac2, int16 hpb2, int16 kbb2[], int8 died2, int8 revive2, int8 id3, int8 tr3, int8 le3, int32 tg3, int16 hp3[], int16 ac3, int16 hpb3, int16 kbb3[], int8 died3, int8 revive3, int8 sid0, int8 at0, int8 stg0, int16 dm0[], int8 sd0, int8 sb0, int8 st0, int8 sid1, int8 at1, int8 stg1, int16 dm1[], int8 sd1, int8 sb1, int8 st1, int8 sid2, int8 at2, int8 stg2, int16 dm2[], int8 sd2, int8 sb2, int8 st2, int8 sid3, int8 at3, int8 stg3, int16 dm3[], int8 sd3, int8 sb3, int8 st3) required broadcast ram;
  setChosenToonAttacks(uint32 ids[], int16 tracks[], int16 levels[], int32 targets[]) broadcast ram;
  setBattleExperience(int32 id0, int16 origExp0[], int16 earnedExp0[], uint32 origQuests0[], int16 items0[], int16 missedItems0[], int16 origMerits0[], int16 merits0[], uint32 parts0[], int32 id1, int16 origExp1[], int16 earnedExp1[], uint32 origQuests1[], int16 items1[], int16 missedItems1[], int16 origMerits1[], int16 merits1[], uint32 parts1[], int32 id2, int16 origExp2[], int16 earnedExp2[], uint32 origQuests2[], int16 items2[], int16 missedItems2[], int16 origMerits2[], int16 merits2[], uint32 parts2[], int32 id3, int16 origExp3[], int16 earnedExp3[], uint32 origQuests3[], int16 items3[], int16 missedItems3[], int16 origMerits3[], int16 merits3[], uint32 parts3[], uint8 deathList[], int16 uberList[], uint32 helpfulToonsList[]) required broadcast ram;
  denyLocalToonJoin();
  setBossBattle(uint8 value) required broadcast ram;
  setState(string state, int16 timestamp) required broadcast ram;
  faceOffDone() airecv clsend;
  toonRequestJoin(int16/10 x, int16/10 y, int16/10 z) airecv clsend;
  toonRequestRun() airecv clsend;
  toonDied() airecv clsend;
  adjustDone() airecv clsend;
  timeout() airecv clsend;
  movieDone() airecv clsend;
  rewardDone() airecv clsend;
  joinDone(uint32 avId) airecv clsend;
  requestAttack(int8 track, int8 level, int32 av) airecv clsend;
  requestPetProxy(uint32 av) airecv clsend;
};

dclass DistributedBattle : DistributedBattleBase {
};

dclass DistributedBattleBldg : DistributedBattleBase {
};

dclass DistributedBattleTutorial : DistributedBattle {
};

dclass DistributedLevelBattle : DistributedBattle {
};

dclass DistributedBattleFactory : DistributedLevelBattle {
};

dclass DistributedMintBattle : DistributedLevelBattle {
};

dclass DistributedStageBattle : DistributedLevelBattle {
};

dclass DistributedBattleFinal : DistributedBattleBase {
  setBossCogId(uint32 bossCogId) required broadcast ram;
  setBattleNumber(uint8 battleNumber) required broadcast ram;
  setBattleSide(uint8 battleSide) required broadcast ram;
};

dclass DistributedBoat : DistributedObject {
  setState(string state, int16 timestamp) required broadcast ram;
};

dclass DistributedButterfly : DistributedObject {
  setArea(int16 playground, int16 area) required broadcast ram;
  setState(int8 stateIndex, uint8 curIndex, uint8 destIndex, uint16/10 time, int16 timestamp) required broadcast ram;
  avatarEnter() airecv clsend;
};

dclass DistributedMMPiano : DistributedObject {
  requestSpeedUp() airecv clsend;
  requestChangeDirection() airecv clsend;
  setSpeed(int16/1000 rpm, uint16/100 offset, int16 timestamp) broadcast ram;
  playSpeedUp(uint32 avId) broadcast;
  playChangeDirection(uint32 avId) broadcast;
};

dclass DistributedDGFlower : DistributedObject {
  avatarEnter() airecv clsend;
  avatarExit() airecv clsend;
  setHeight(uint8/10 newHeight) broadcast ram;
};

dclass DistributedElectionEvent : DistributedObject {
  setState(string state, int32 timestamp) required broadcast ram;
  wheelbarrowAvatarEnter() clsend airecv;
  slappyAvatarEnter() clsend airecv;
  requestSuit() clsend airecv;
  setSuitPhrase(string phrase) clsend airecv;
  setSuitState(string state) clsend airecv;
  setSuitDamage(uint8 damage, bool) clsend airecv;
  phraseSaidToFlippy(uint16 phraseId) clsend airecv;
  saySurleePhrase(string phrase, bool, bool) broadcast;
  flippySpeech(uint32 avId, uint16 phraseId) broadcast;
};

dclass DistributedElectionCamera : DistributedNode
{
  setState(string state, int32 ts, int16/10 x, int16/10 y, int16/10 z, int16%360/10 h, int16%360/10 p, uint32 target) required broadcast ram;

};

dclass DistributedElectionCameraManager : DistributedObject
{
  setMainCamera(uint32 doId) required broadcast ram;
  setCameraIds(uint32[]) required broadcast ram;
};

dclass DistributedHotAirBalloon : DistributedObject {
  setState(string state, int32 timestamp, uint32 avId) required broadcast ram;
  requestEnter() clsend airecv;
  setFlightPath(uint8 flightPathIndex) required broadcast ram;
};

dclass DistributedSafezoneInvasion : DistributedObject {
  pieHitToon(uint32 avId) clsend airecv;
  pieHitSuit(uint32 avId) clsend airecv;
  takeDamage(uint8 damage) clsend airecv;
  setInvasionStarted(bool started) required broadcast ram;
  stopMusic() broadcast ram;
};

dclass DistributedFishingPond : DistributedObject {
  hitTarget(uint32 target) airecv clsend;
  setArea(uint32 area) required broadcast ram;
};

dclass DistributedFishingTarget : DistributedNode {
  setPondDoId(uint32 pondDoId) required broadcast ram;
  setState(uint8 stateIndex, int16/10 angle, uint16/100 radius, uint16/10 time, int16 timeStamp) required broadcast ram;
};

dclass DistributedFishingSpot : DistributedObject {
  setPondDoId(uint32 pondDoId) required broadcast ram;
  setPosHpr(int16/10 x, int16/10 y, int16/10 z, int16/10 h, int16/10 p, int16/10 r) required broadcast ram;
  requestEnter() airecv clsend;
  rejectEnter();
  requestExit() airecv clsend;
  setOccupied(uint32 avId) broadcast ram;
  doCast(uint8/255 p, int16/100 h) airecv clsend;
  sellFish() airecv clsend;
  sellFishComplete(uint8 trophyResult, uint16 numFishCaught);
  setMovie(uint8 mode, uint8 code, uint16 itemDesc1, uint16 itemDesc2, uint16 itemDesc3, uint8/100 power, int16/100 h) broadcast ram;
};

dclass DistributedPondBingoManager : DistributedObject {
  setPondDoId(uint32 pondId) required broadcast ram;
  updateGameState(uint32 gameState, uint8 cellId);
  setCardState(uint16 cardId, uint8 typeId, uint16 tileSeed, uint32 gameState);
  setState(string state, int16 timeStamp);
  cardUpdate(uint16 cardId, uint8 cellId, uint8 genus, uint8 species) airecv clsend;
  enableBingo();
  handleBingoCall(uint16 cardId) airecv clsend;
  setJackpot(uint16 jackpot);
};

dclass DistributedCannon : DistributedObject {
  setEstateId(uint32 estateId) required broadcast ram;
  setTargetId(uint32 targetId) required broadcast ram;
  setPosHpr(int16/10 x, int16/10 y, int16/10 z, int16/10 h, int16/10 p, int16/10 r) required broadcast ram;
  setActive(uint8 active) airecv clsend;
  setActiveState(uint8 active) broadcast ram;
  requestEnter() airecv clsend;
  requestExit() broadcast;
  setMovie(uint8 mode, uint32 avId) broadcast ram;
  setCannonPosition(int32/100 rotation, uint32/100 angle) airecv clsend;
  setCannonLit(int32/100 rotation, uint32/100 angle) airecv clsend;
  setFired() airecv clsend;
  setLanded() airecv clsend;
  updateCannonPosition(uint32 avId, int32/100 zRot, uint32/100 angle) broadcast ram;
  setCannonWillFire(uint32 avId, int32/100 fireTime, int32/100 zRot, uint32/100 angle, int16 timestamp) broadcast;
  setCannonExit(uint32 avId) broadcast;
  requestBumperMove(int32/100 x, int32/100 y, int32/100 z) airecv clsend;
  setCannonBumperPos(int32/100 x, int32/100 y, int32/100 z) required broadcast ram;
};

dclass DistributedTarget : DistributedObject {
  setPosition(int16/10 x, int16/10 y, int16/10 z) required broadcast ram;
  setState(uint8 enabled, uint32/10 score, uint8 time) broadcast;
  setReward(uint32 reward) broadcast;
  setResult(uint32 avId) airecv clsend;
  setBonus(int16/10 bonus) airecv clsend;
  setCurPinballScore(uint32 avId, int32 score, int32 multiplier) clsend airecv;
  setPinballHiScorer(string name) broadcast ram;
  setPinballHiScore(int32 score) broadcast ram;
};

dclass DistributedMinigame : DistributedObject {
  setParticipants(uint32 avIds[]) broadcast ram required;
  setTrolleyZone(uint32 trolleyZone) broadcast ram required;
  setStartingVotes(uint16 startingVotesArray[]) broadcast ram required;
  setMetagameRound(int8 metagameRound) broadcast ram required;
  setDifficultyOverrides(int32 difficultyOverride, int32 trolleyZoneOverride) broadcast ram required;
  setAvatarJoined() airecv clsend;
  setAvatarReady() airecv clsend;
  setAvatarExited() airecv clsend;
  requestExit() airecv clsend;
  setGameReady() broadcast;
  setGameStart(int16 timestamp) broadcast;
  setGameExit() broadcast;
  setGameAbort() broadcast;
};

dclass DistributedMinigameTemplate : DistributedMinigame {
};

dclass DistributedRaceGame : DistributedMinigame {
  setTimerStartTime(int16 timestamp) broadcast;
  setAvatarChoice(uint8 choice) airecv clsend;
  setAvatarChose(uint32 avId) broadcast;
  setChancePositions(uint8 positions[]) broadcast;
  setServerChoices(int8 choices[], uint8 positions[], int8 rewards[]) broadcast;
};

dclass DistributedCannonGame : DistributedMinigame {
  setCannonPosition(int32/100 zRot, uint32/100 angle) airecv clsend;
  setCannonLit(int32/100 zRot, uint32/100 angle) airecv clsend;
  updateCannonPosition(uint32 avId, int32/100 zRot, uint32/100 angle) broadcast;
  setCannonWillFire(uint32 avId, int32/100 fireTime, int32/100 zRot, uint32/100 angle) broadcast;
  setToonWillLandInWater(int32/100 landTime) airecv clsend;
  announceToonWillLandInWater(uint32 avId, int32/100 landTime) broadcast;
};

dclass DistributedPhotoGame : DistributedMinigame {
  newClientPhotoScore(uint8 subjectIndex, char pose[0-256], uint32/100 score) airecv clsend;
  newAIPhotoScore(uint32 playerId, uint8 assignmentIndex, uint32/100 score) broadcast;
  filmOut() airecv clsend;
};

dclass DistributedPatternGame : DistributedMinigame {
  reportPlayerReady() airecv clsend;
  setPattern(uint8 pattern[]) broadcast;
  reportPlayerPattern(uint8 pattern[], uint16/1000 totalTime) airecv clsend;
  setPlayerPatterns(uint8 pattern1[], uint8 pattern2[], uint8 pattern3[], uint8 pattern4[], uint32 fastestAvId) broadcast;
  reportButtonPress(uint8 index, uint8 wrong) airecv clsend;
  remoteButtonPressed(uint32 avId, uint8 index, uint8 wrong) broadcast;
};

dclass DistributedRingGame : DistributedMinigame {
  setTimeBase(int16 timestamp) broadcast ram required;
  setColorIndices(int8 a, int8 b, int8 c, int8 d) broadcast ram required;
  setToonGotRing(uint8 success) airecv clsend;
  setRingGroupResults(uint8 bitfield) broadcast;
};

dclass DistributedTagGame : DistributedMinigame {
  tag(uint32 taggedAvId) airecv clsend;
  setIt(uint32 avId) broadcast;
  setTreasureScore(uint16 scores[]) broadcast;
};

dclass DistributedMazeGame : DistributedMinigame {
  claimTreasure(uint32 treasureNum) airecv clsend;
  setTreasureGrabbed(uint32 avId, uint32 treasureNum) broadcast;
  allTreasuresTaken() broadcast;
  hitBySuit(uint32 avId, int16 timestamp) clsend broadcast;
};

dclass DistributedTugOfWarGame : DistributedMinigame {
  reportPlayerReady(uint8 side) airecv clsend;
  sendGoSignal(uint8 index[]) broadcast;
  sendStopSignal(uint32 winners[], uint32 losers[], uint32 tieers[]) broadcast;
  sendGameType(uint8 index, uint8 suit) broadcast;
  reportEndOfContest(uint8 index) airecv clsend;
  sendNewAvIdList(uint32 newAvIdList[]) airecv clsend;
  reportCurrentKeyRate(uint32 keyRate, int16/100 force) airecv clsend;
  sendCurrentPosition(uint32 avIdList[], int16/1000 offsetList[]) broadcast;
  sendSuitPosition(int32/1000 suitOffset) broadcast;
  remoteKeyRateUpdate(uint32 avId, uint32 keyRate) broadcast;
};

dclass DistributedCatchGame : DistributedMinigame {
  claimCatch(uint32 objNum, uint32 DropObjTypeId) airecv clsend;
  setObjectCaught(uint32 avId, uint32 objNum) broadcast;
  hitBySuit(uint32 avId, int16 timestamp) clsend broadcast;
  reportDone() airecv clsend;
  setEveryoneDone() broadcast;
};

dclass DistributedDivingGame : DistributedMinigame {
  pickupTreasure(uint32 chestId) airecv clsend;
  setTreasureGrabbed(uint32 avId, uint32 chestId) broadcast;
  handleFishCollision(uint32 spawnId, uint32 spawnerId, char status[0-256]) airecv clsend;
  performFishCollision(uint32 avId, uint32 spawnId, uint32 spawnerId, int16 timestamp) broadcast;
  handleCrabCollision(char status[0-256]) airecv clsend;
  performCrabCollision(uint32 avId, int16 timestamp) broadcast;
  setTreasureDropped(uint32 avId, int16 timestamp) broadcast;
  fishSpawn(int16 timestamp, uint32 fishcode, uint32 spawnerId, uint16 offset) broadcast;
  removeFish(uint32) airecv clsend;
  getCrabMoving(uint32 crabId, int16 crabX, int8 dir) airecv clsend;
  setCrabMoving(uint32 crabId, int16 timestamp, int8 rand1, int8 rand2, int16 crabX, int8 dir) broadcast;
  treasureRecovered() airecv clsend;
  dropTreasure() airecv clsend;
  incrementScore(uint32 avId, uint32 newSpot, int16 timestamp) broadcast;
};

dclass DistributedTargetGame : DistributedMinigame {
  setTimeBase(int16 timestamp) broadcast ram required;
  setToonGotRing(uint8) airecv clsend;
  setRingGroupResults(uint8) broadcast;
  setPlayerDone() airecv clsend;
  setScore(int32 scoreX, int32 scoreY) airecv clsend;
  setTargetSeed(uint32 targetSeed) broadcast ram;
  setRoundDone() broadcast;
  setSingleScore(uint16 score, uint32 avId) broadcast;
  setGameDone() broadcast;
};

dclass EstateManager : DistributedObject {
  startAprilFools() broadcast;
  stopAprilFools() broadcast;
  getEstateZone(uint32 avId) airecv clsend;
  setEstateZone(uint32 ownerId, uint32 zoneId);
  setAvHouseId(uint32 avId, uint32 houseIds[]) broadcast;
  sendAvToPlayground(DoId avId, uint8 reason);
  exitEstate() airecv clsend;
  removeFriend(uint32 ownerId, uint32 avId) airecv clsend;
};

struct decorItem {
  uint8 decorType;
  uint8 dataByte[];
  uint32 dataWord[];
};

struct lawnItem {
  uint8 type;
  uint8 hardPoint;
  int8 waterLevel;
  int8 growthLevel;
  uint16 optional;
};

dclass DistributedEstate : DistributedObject {
  setEstateReady() broadcast;
  setClientReady() airecv clsend;
  setEstateType(uint8 type = 0) required broadcast db;
  setClosestHouse(uint8 house) airecv clsend;
  setTreasureIds(uint32 doIds[]) broadcast ram;
  requestServerTime() airecv clsend;
  setServerTime(uint32 ts);
  setDawnTime(uint32 ts) required broadcast ram;
  placeOnGround(uint32 UNKNOWN) broadcast ram;
  setDecorData(lawnItem items[] = []) required airecv db;
  setLastEpochTimeStamp(uint32 timestamp = 0) required airecv db;
  setRentalTimeStamp(uint32 timestamp = 0) required airecv db;
  setRentalType(uint8 type = 0) required airecv db;
  setSlot0ToonId(uint32 toonId = 0) required airecv db;
  setSlot0Items(lawnItem items[] = []) required airecv db;
  setSlot1ToonId(uint32 toonId = 0) required airecv db;
  setSlot1Items(lawnItem items[] = []) required airecv db;
  setSlot2ToonId(uint32 toonId = 0) required airecv db;
  setSlot2Items(lawnItem items[] = []) required airecv db;
  setSlot3ToonId(uint32 toonId = 0) required airecv db;
  setSlot3Items(lawnItem items[] = []) required airecv db;
  setSlot4ToonId(uint32 toonId = 0) required airecv db;
  setSlot4Items(lawnItem items[] = []) required airecv db;
  setSlot5ToonId(uint32 toonId = 0) required airecv db;
  setSlot5Items(lawnItem items[] = []) required airecv db;
  setIdList(uint32 idList[]) broadcast ram;
  completeFlowerSale(uint8 sell) airecv clsend;
  awardedTrophy(uint32 avId) broadcast;
  setClouds(uint8 clouds) required broadcast ram;
  cannonsOver() broadcast;
  gameTableOver() broadcast;
};

dclass DistributedHouse : DistributedObject {
  setHousePos(uint8 index) required broadcast;
  setHouseType(uint8 type = 0) required broadcast db;
  setGardenPos(uint8 index = 0) required broadcast db;
  setAvatarId(uint32 toonId = 0) required broadcast db;
  setName(string toonName = "") required broadcast db;
  setColor(uint8 colorIndex = 0) required broadcast db;
  setGender(uint8 genderIndex = 1) required;
  setAtticItems(blob atticItems = "") required db;
  setInteriorItems(blob interiorItems = "") required db;
  setAtticWallpaper(blob atticWallpaper = "") required db;
  setInteriorWallpaper(blob interiorWallpaper = "") required db;
  setAtticWindows(blob atticWindows = "") required db;
  setInteriorWindows(blob interiorWindows = "") required db;
  setDeletedItems(blob deletedItems = "") required db;
  setInteriorInitialized(uint8 initialized = 0) required db;
  setCannonEnabled(uint8 enabled) required;
  setHouseReady() broadcast ram;
};

dclass DistributedHouseInterior : DistributedObject {
  setHouseId(uint32 index) required broadcast ram;
  setHouseIndex(uint8 index) required broadcast ram;
  setWallpaper(blob items) required broadcast ram;
  setWindows(blob items) required broadcast ram;
};

dclass DistributedGarden : DistributedObject {
  sendNewProp(uint8 prop, int16/10 x, int16/10 y, int16/10 z) broadcast;
};

dclass DistributedParty : DistributedObject {
  setPartyClockInfo(uint8 x, uint8 y, uint8 h) required broadcast;
  setInviteeIds(uint32 inviteeIds[]) required broadcast;
  setPartyState(bool partyState) required broadcast;
  setPartyInfoTuple(party partyInfoTuple) required broadcast;
  setAvIdsAtParty(uint32 avIdsAtParty[]) required broadcast;
  setPartyStartedTime(string startedTime) required broadcast;
  setHostName(string hostName) required broadcast;
  enteredParty() clsend airecv;
};

dclass DistributedPartyActivity : DistributedObject {
  setX(int16/10 x) broadcast required;
  setY(int16/10 y) broadcast required;
  setH(uint16%360/100 h) broadcast required;
  setPartyDoId(uint32 partyDoId) broadcast required;
  toonJoinRequest() airecv clsend;
  toonExitRequest() airecv clsend;
  toonExitDemand() airecv clsend;
  toonReady() airecv clsend;
  joinRequestDenied(uint8 reason);
  exitRequestDenied(uint8 reason);
  setToonsPlaying(uint32 toonIds[]) broadcast ram;
  setState(string newState, int16 timestamp) broadcast ram;
  showJellybeanReward(uint32 earnedAmount, uint8 jarAmount, string message);
};

dclass DistributedPartyTeamActivity : DistributedPartyActivity {
  toonJoinRequest(uint8(0-1) todo0) airecv clsend;
  toonExitRequest(uint8(0-1) todo0) airecv clsend;
  toonSwitchTeamRequest() airecv clsend;
  setPlayersPerTeam(uint8 min, uint8 max) broadcast required;
  setDuration(uint8 duration) broadcast required;
  setCanSwitchTeams(bool canSwitchTeams) broadcast required;
  setState(string newState, int16 timestamp, uint32 data) broadcast ram;
  setToonsPlaying(uint32 leftTeamToonIds[0-8], uint32 rightTeamToonIds[0-8]) required broadcast ram;
  setAdvantage(uint16/100 advantage);
  switchTeamRequestDenied(uint8 reason);
};

struct CatchGeneration {
  uint32 generation;
  uint32 timestamp;
  int8 numPlayers;
};

dclass DistributedPartyCatchActivity : DistributedPartyActivity {
  setStartTimestamp(uint32 timestamp32) required broadcast ram;
  setGenerations(CatchGeneration generations[]) required broadcast ram;
  requestActivityStart() airecv clsend;
  startRequestResponse(uint8 UNKNOWN);
  claimCatch(uint32 generation, uint32 objNum, uint32 objType) airecv clsend;
  setObjectCaught(uint32 avId, uint32 generation, uint32 objNum) broadcast;
};

dclass DistributedPartyWinterCatchActivity : DistributedPartyCatchActivity {
};

dclass DistributedPartyCogActivity : DistributedPartyTeamActivity {
  pieThrow(uint32 toonId, int32 timestamp, int32/100 h, int32/100 x, int32/100 y, int32/100 z, uint8 power) clsend broadcast;
  pieHitsToon(uint32 toonId, int32 timestamp, int32/100 x, int32/100 y, int32/100 z) clsend broadcast;
  pieHitsCog(uint32 toonId, int32 timestamp, int8(0-2) hitCogNum, int32/100 x, int32/100 y, int32/100 z, int32 direction, bool part) clsend broadcast airecv;
  setCogDistances(int8/100 distances[3]) broadcast ram;
  setHighScore(string toonName, uint16 score) broadcast ram;
};

dclass DistributedPartyWinterCogActivity : DistributedPartyCogActivity {
};

dclass DistributedPartyDanceActivityBase : DistributedPartyActivity {
  updateDancingToon(uint8 state, char anim[0-256]) clsend airecv;
  setToonsPlaying(uint32 toonIds[], uint16%360/100 toonHeadings[]) broadcast ram;
  setDancingToonState(uint32 toonId, uint8 state, string anim) broadcast;
};

dclass DistributedPartyDanceActivity : DistributedPartyDanceActivityBase {
};

dclass DistributedPartyDance20Activity : DistributedPartyDanceActivityBase {
};

dclass DistributedPartyValentineDanceActivity : DistributedPartyDanceActivityBase {
};

dclass DistributedPartyValentineDance20Activity : DistributedPartyDanceActivityBase {
};

dclass DistributedPartyJukeboxActivityBase : DistributedPartyActivity {
  setNextSong(jukeboxSongInfo song) clsend airecv;
  setSongPlaying(jukeboxSongInfo songInfo, uint32 toonId) broadcast ram;
  queuedSongsRequest() clsend airecv;
  queuedSongsResponse(jukeboxSongInfo songInfoList[], int16 index);
  setSongInQueue(jukeboxSongInfo songInfo);
  moveHostSongToTopRequest() clsend airecv;
  moveHostSongToTop();
};

dclass DistributedPartyJukeboxActivity : DistributedPartyJukeboxActivityBase {
};

dclass DistributedPartyJukebox40Activity : DistributedPartyJukeboxActivityBase {
};

dclass DistributedPartyValentineJukeboxActivity : DistributedPartyJukeboxActivityBase {
};

dclass DistributedPartyValentineJukebox40Activity : DistributedPartyJukeboxActivityBase {
};

dclass DistributedPartyCannonActivity : DistributedPartyActivity {
  setMovie(uint8 mode, uint32 toonId) broadcast;
  setLanded(uint32 toonId) airecv broadcast clsend;
  setCannonWillFire(uint32 cannonId, int32/100 zRot, uint32/100 angle) broadcast;
  cloudsColorRequest() clsend airecv;
  cloudsColorResponse(partyCloudColor cloudColorList[]);
  requestCloudHit(uint16 cloudId, uint8/100 r, uint8/100 g, uint8/100 b) clsend airecv;
  setCloudHit(uint16 cloudNumber, uint8/100 r, uint8/100 g, uint8/100 b) broadcast;
  setToonTrajectoryAi(int32 launchTime, int32/100 x, int32/100 y, int32/100 z, int32/100 h, int32/100 p, int32/100 r, int32/100 vx, int32/100 vy, int32/100 vz) airecv clsend;
  setToonTrajectory(uint32 avId, int32 launchTime, int32/100 x, int32/100 y, int32/100 z, int32/100 h, int32/100 p, int32/100 r, int32/100 vx, int32/100 vy, int32/100 vz) broadcast;
  updateToonTrajectoryStartVelAi(int32/100 vx, int32/100 vy, int32/100 vz) airecv clsend;
  updateToonTrajectoryStartVel(uint32 avId, int32/100 vx, int32/100 vy, int32/100 vz) broadcast;
};

dclass DistributedPartyCannon : DistributedObject {
  setActivityDoId(uint64 doId) required broadcast ram;
  setPosHpr(int16/10 x, int16/10 y, int16/10 z, int16/10 h, int16/10 p, int16/10 r) required broadcast ram;
  requestEnter() airecv clsend;
  requestExit() broadcast;
  setMovie(uint8 mode, uint32 avId) broadcast ram;
  setCannonPosition(int32/100 rot, uint32/100 angle) airecv clsend;
  setCannonLit(int32/100 rot, uint32/100 angle) airecv clsend;
  setFired() airecv clsend;
  setLanded(uint32 avId) airecv clsend;
  updateCannonPosition(uint32 avId, int32/100 zRot, uint32/100 angle) broadcast ram;
  setCannonExit(uint32) broadcast;
  setTimeout() clsend airecv;
};

dclass DistributedPartyFireworksActivity : DistributedPartyActivity {
  setEventId(uint8 eventId) required broadcast;
  setShowStyle(uint8 style) required broadcast;
  setSongId(uint8 songId) required broadcast;
};

dclass DistributedPartyTrampolineActivity : DistributedPartyActivity {
  awardBeans(uint8 numBeans, uint16 height) clsend airecv;
  setBestHeightInfo(string toonName, uint16 height) broadcast ram;
  reportHeightInformation(uint16 height) airecv clsend;
  leaveTrampoline() broadcast;
  requestAnim(char request[0-256]) clsend airecv;
  requestAnimEcho(string request) broadcast;
  removeBeans(int8 beansToRemove[]) clsend airecv;
  removeBeansEcho(int8 beansToRemove[]) broadcast;
};

dclass DistributedPartyValentineTrampolineActivity : DistributedPartyTrampolineActivity {
};

dclass DistributedPartyVictoryTrampolineActivity : DistributedPartyTrampolineActivity {
};

dclass DistributedPartyWinterTrampolineActivity : DistributedPartyTrampolineActivity {
};

dclass DistributedPartyTugOfWarActivity : DistributedPartyTeamActivity {
  reportKeyRateForce(uint32 todo0, int16/100 todo1) airecv clsend;
  reportFallIn(uint8 todo0) airecv clsend;
  setToonsPlaying(uint32 leftTeamToonIds[0-4], uint32 rightTeamToonIds[0-4]) required broadcast ram;
  updateToonKeyRate(uint32 toonId, uint32 keyRate) broadcast;
  updateToonPositions(int16/1000 offset) broadcast;
};

dclass DeleteManager : DistributedObject {
  setInventory(blob newInventoryString) airecv clsend;
};

struct weeklyCalendarHoliday {
  uint8 holidayId;
  uint8 dayOfTheWeek;
};

struct yearlyCalendarHoliday {
  uint8 holidayId;
  uint8[] firstStartTime;
  uint8[] lastEndTime;
};

struct oncelyCalendarHoliday {
  uint8 holidayId;
  uint16[] firstStartTime;
  uint16[] lastEndTime;
};

struct relativelyCalendarHoliday {
  uint8 holidayId;
  uint16[] firstStartTime;
  uint16[] lastEndTime;
};

struct startAndEndTime {
  uint16[] startTime;
  uint16[] endTime;
};

struct multipleStartHoliday {
  uint8 holidayId;
  startAndEndTime times[];
};

dclass NewsManager : DistributedObject {
  setPopulation(uint32 population) broadcast ram;
  setBingoWin(uint32 zoneId) broadcast ram;
  setBingoStart() broadcast;
  setBingoEnd() broadcast;
  setCircuitRaceStart() broadcast;
  setCircuitRaceEnd() broadcast;
  setTrolleyHolidayStart() broadcast;
  setTrolleyHolidayEnd() broadcast;
  setTrolleyWeekendStart() broadcast;
  setTrolleyWeekendEnd() broadcast;
  setRoamingTrialerWeekendStart() broadcast;
  setRoamingTrialerWeekendEnd() broadcast;
  setInvasionStatus(uint8 msgType, string cogType, uint32 numRemaining, uint8 specialSuit) broadcast;
  setHolidayIdList(uint32 holidayIdList[]) broadcast ram;
  holidayNotify() broadcast;
  setWeeklyCalendarHolidays(weeklyCalendarHoliday weeklyCalendarHolidays[]) required broadcast ram;
  setYearlyCalendarHolidays(yearlyCalendarHoliday yearlyCalendarHolidays[]) required broadcast ram;
  setOncelyCalendarHolidays(oncelyCalendarHoliday oncelyCalendarHolidays[]) required broadcast ram;
  setRelativelyCalendarHolidays(relativelyCalendarHoliday relativelyCalendarHolidays[]) required broadcast ram;
  setMultipleStartHolidays(multipleStartHoliday multipleStartHolidays[]) required broadcast ram;
  sendSystemMessage(string message, uint8 style) broadcast ram;
};

dclass PurchaseManager : DistributedObject {
  setPlayerIds(uint32 playerIds, uint32, uint32, uint32) required broadcast ram;
  setNewbieIds(uint32 newbieIds[]) required broadcast ram;
  setMinigamePoints(uint8 mpArray, uint8, uint8, uint8) required broadcast ram;
  setPlayerMoney(uint8 moneyArray, uint8, uint8, uint8) required broadcast ram;
  setPlayerStates(uint8 stateArray, uint8, uint8, uint8) required broadcast ram;
  setCountdown(int16 timestamp) required broadcast ram;
  setMetagameRound(int8 round) required broadcast ram;
  setVotesArray(int16 votesArray[]) required broadcast ram;
  requestExit() airecv clsend;
  requestPlayAgain() airecv clsend;
  setInventory(blob data, int16 newMoney, uint8 done) airecv clsend;
  setPurchaseExit() broadcast;
};

dclass NewbiePurchaseManager : PurchaseManager {
  setOwnedNewbieId(uint32 ownedNewbieId) required broadcast ram;
};

dclass TutorialManager : DistributedObject {
  requestTutorial() airecv clsend;
  rejectTutorial() airecv clsend;
  requestSkipTutorial() airecv clsend;
  skipTutorialResponse(uint8 allOk);
  enterTutorial(uint32 branchZone, uint32 streetZone, uint32 shopZone, uint32 hqZone);
  allDone() airecv clsend;
  toonArrived() airecv clsend;
};

dclass CatalogManager : DistributedObject {
  startCatalog() airecv clsend;
};

dclass DistributedMyTest : DistributedObject {
  setMyTest(uint16) broadcast;
};

dclass DistributedTreasure : DistributedObject {
  setTreasureType(uint16 treasureType) required broadcast ram;
  setPosition(int16/10 x, int16/10 y, int16/10 z) required broadcast ram;
  requestGrab() airecv clsend;
  setGrab(uint32 avId) broadcast ram;
  setReject() broadcast;
};

dclass DistributedCashbotBossTreasure : DistributedTreasure {
  setGoonId(uint32 todo0) required broadcast ram;
  setFinalPosition(int16/10 todo0, int16/10 todo1, int16/10 todo2) required broadcast ram;
  setStyle(uint16 todo0) required broadcast ram;
};

dclass DistributedLargeBlobSender : DistributedObject {
  setMode(uint8) required broadcast ram;
  setTargetAvId(uint32) required broadcast ram;
  setChunk(blob);
  setFilename(string);
  setAck() airecv clsend;
};

dclass DistributedLevel : DistributedObject {
  setLevelZoneId(uint32 zoneId) required broadcast ram;
  setPlayerIds(uint32 avIdList[]) required broadcast ram;
  setEntranceId(uint8 entranceId) required broadcast ram;
  setZoneIds(uint32 zoneIds[]) broadcast ram;
  setStartTimestamp(int32 timestamp) broadcast ram;
  setOuch(uint8 penalty) airecv clsend;
  requestCurrentLevelSpec(string specHash, string entTypeRegHash) airecv clsend;
  setSpecDeny(blob);
  setSpecSenderDoId(uint32);
  setAttribChange(uint32, blob, blob, blob) broadcast;
};

dclass DistributedEntity : DistributedObject {
  setLevelDoId(uint32 levelDoId) required broadcast ram;
  setEntId(uint32 entId) required broadcast ram;
};

dclass DistributedInteractiveEntity : DistributedEntity {
  setAvatarInteract(uint32 avatarId) required broadcast ram;
  requestInteract() airecv clsend;
  rejectInteract();
  requestExit() airecv clsend;
  avatarExit(uint32 avatarId) broadcast;
  setState(string state, int32 timestamp) required broadcast ram;
};

dclass DistributedTrophyMgr : DistributedObject {
  requestTrophyScore() airecv clsend;
};

dclass DistributedBuilding : DistributedObject {
  setBlock(uint16 block, uint32 interiorZoneId) required broadcast ram;
  setSuitData(int8 suitTrack, int8 difficulty, int8 numFloors) required broadcast ram;
  setVictorList(uint32 victorList[]) broadcast ram;
  setState(string state, int16 timestamp) broadcast ram;
  setVictorReady() airecv clsend;
};

dclass DistributedAnimBuilding : DistributedBuilding {
};

dclass DistributedToonInterior : DistributedObject {
  setZoneIdAndBlock(uint32 zoneId, uint16 block) required broadcast ram;
  setToonData(blob toonData) required broadcast ram;
  setState(string state, int16 timestamp) required broadcast ram;
  nextSnowmanHeadPart() clsend airecv;
};

dclass DistributedToonHallInterior : DistributedToonInterior {
};

dclass DistributedSuitInterior : DistributedObject {
  setZoneId(uint32 zoneId) required broadcast ram;
  setExtZoneId(uint32 extZoneId) required broadcast ram;
  setDistBldgDoId(uint32 distBldgDoId) required broadcast ram;
  setNumFloors(int8 numFloors) required broadcast ram;
  setToons(uint32 toonIds[], uint16 hack) broadcast ram;
  setSuits(uint32 suitIds[], uint32 reserveIds[], uint16 values[]) broadcast ram;
  setState(string state, int16 timestamp) required broadcast ram;
  setAvatarJoined() airecv clsend;
  elevatorDone() airecv clsend;
  reserveJoinDone() airecv clsend;
};

dclass DistributedCogdoBarrel : DistributedObject {
  requestGrab() airecv clsend;
  setIndex(uint32 index) required broadcast ram;
  setState(uint32 state) required broadcast ram;
  setGrab(uint32 avId) broadcast ram;
  setReject() broadcast;
};

dclass DistributedCogdoInterior : DistributedObject {
  setZoneId(uint32 zoneId) required broadcast ram;
  setExtZoneId(uint32 extZoneId) required broadcast ram;
  setDistBldgDoId(uint32 distBldgDoId) required broadcast ram;
  setNumFloors(int8 numFloors) required broadcast ram;
  setShopOwnerNpcId(uint32 npcId) required broadcast ram;
  setSOSNpcId(uint32 npcId) broadcast ram;
  setFOType(int8 typeId) broadcast ram;
  setToons(uint32 toonIds[], uint16 hack) broadcast ram;
  setSuits(uint32 suitIds[], uint32 reserveIds[], uint16 values[]) broadcast ram;
  setState(string state, int16 timestamp) required broadcast ram;
  setAvatarJoined() airecv clsend;
  elevatorDone() airecv clsend;
  reserveJoinDone() airecv clsend;
  toonLeftBarrelRoom() airecv clsend;
  toonBarrelRoomIntroDone() airecv clsend;
  setBarrelRoomReward(uint32 avIds[], uint8 laffs[]) broadcast;
  toonBarrelRoomRewardDone() airecv clsend;
};

dclass DistributedCogdoBattleBldg : DistributedBattleBldg {
};

dclass DistCogdoGame : DistributedObject {
  setInteriorId(uint32 interiorId) required broadcast ram;
  setExteriorZone(uint32 exteriorZone) broadcast ram required;
  setDifficultyOverrides(int32 difficultyOverride, int32 exteriorZoneOverride) broadcast ram required;
  setVisible() broadcast;
  setIntroStart() broadcast;
  setToonSad(uint32 toonId) broadcast;
  setToonDisconnect(uint32 toonId) broadcast;
  setAvatarReady() airecv clsend;
  setGameStart(int16 timestamp) broadcast;
  setGameFinish(int16 timestamp) broadcast;
};

dclass DistCogdoLevelGame : DistCogdoGame, DistributedLevel {
};

dclass DistCogdoMazeGame : DistCogdoGame {
  requestAction(uint8 action, uint32 data) airecv clsend;
  doAction(uint8 action, uint32 data, int16 networkTime) broadcast;
  setNumSuits(uint8 numSuits[3]) required broadcast;
  requestUseGag(int16/10 x, int16/10 y, int16/10 h, int16 networkTime) clsend airecv;
  toonUsedGag(uint32 toonId, int16/10 x, int16/10 y, int16/10 h, int16 networkTime) broadcast;
  requestSuitHitByGag(uint8 suitType, uint8 suitNum) clsend airecv;
  suitHitByGag(uint32 toonId, uint8 suitType, uint8 suitNum) broadcast;
  requestHitBySuit(uint8 suitType, uint8 suitNum, int16 networkTime) clsend airecv;
  toonHitBySuit(uint32 toonId, uint8 suitType, uint8 suitNum, int16 networkTime) broadcast;
  requestHitByDrop() clsend airecv;
  toonHitByDrop(uint32 toonId) broadcast;
  requestPickUp(uint8 pickupNum) clsend airecv;
  pickUp(uint32 toonId, uint8 pickupNum, int16 networkTime) broadcast;
  requestGag(uint8 waterCoolerIndex) clsend airecv;
  hasGag(uint32 toonId, int16 networkTime) broadcast;
};

dclass DistCogdoFlyingGame : DistCogdoGame {
  requestAction(uint8 action, uint8 data) airecv clsend;
  requestPickUp(uint16 pickupNum, uint8 pickupType) airecv clsend;
  pickUp(uint32 toonId, uint16 pickupNum, int16 networkTime) broadcast;
  debuffPowerup(uint32 toonId, uint16 pickupType, int16 networkTime) broadcast;
  doAction(uint8 action, uint32 data) broadcast;
  eagleExitCooldown(uint32 eagleId, int16 networkTime) broadcast;
  toonSetAsEagleTarget(uint32 toonId, uint8 eagleId, int16 networkTime) broadcast;
  toonClearAsEagleTarget(uint32 toonId, uint8 eagleId, int16 networkTime) broadcast;
  toonDied(uint32 toonId, int32 networkTime) broadcast;
  toonSpawn(uint32 toonId, int32 networkTime) broadcast;
  toonSetBlades(uint32 toonId, int32 fuelState) broadcast;
  toonBladeLost(uint32 toonId) broadcast;
};

dclass DistCogdoBoardroomGame : DistCogdoLevelGame {
};

dclass DistCogdoCraneGame : DistCogdoLevelGame {
};

dclass DistCogdoCrane : DistributedObject {
  setCraneGameId(uint32 craneGameId) required broadcast ram;
  setIndex(uint8 index) required broadcast ram;
  setState(char state, uint32 avId) broadcast ram;
  clearSmoothing(int8 bogus) broadcast clsend;
  setCablePos(uint8 changeSeq, int16/100 y, uint16%360/100 h, LinkPosition links[3], int16 timestamp) broadcast clsend;
};

dclass DistCogdoCraneObject : DistributedObject {
  setCraneGameId(uint32) required broadcast ram;
  setObjectState(char, uint32, uint32) broadcast ram;
  requestGrab() airecv clsend;
  rejectGrab();
  requestDrop() airecv clsend;
  hitFloor() clsend;
  requestFree(int16/10, int16/10, int16/10, uint16%360/100) airecv clsend;
  hitBoss(uint16/255) airecv clsend;
  setX(int16/10) broadcast ram clsend airecv;
  setY(int16/10) broadcast ram clsend airecv;
  setZ(int16/10) broadcast ram clsend airecv;
  setH(int16%360/10) broadcast ram clsend airecv;
  setP(int16%360/10) broadcast ram clsend airecv;
  setR(int16%360/10) broadcast ram clsend airecv;
  setPos : setX, setY, setZ;
  setHpr : setH, setP, setR;
  setPosHpr : setX, setY, setZ, setH, setP, setR;
  setXY : setX, setY;
  setXZ : setX, setZ;
  setXYH : setX, setY, setH;
  setXYZH : setX, setY, setZ, setH;
  setComponentL(uint64) broadcast ram clsend airecv;
  setComponentX(int16/10) broadcast ram clsend airecv;
  setComponentY(int16/10) broadcast ram clsend airecv;
  setComponentZ(int16/10) broadcast ram clsend airecv;
  setComponentH(int16%360/10) broadcast ram clsend airecv;
  setComponentP(int16%360/10) broadcast ram clsend airecv;
  setComponentR(int16%360/10) broadcast ram clsend airecv;
  setComponentT(int16) broadcast ram clsend airecv;
  setSmStop : setComponentT;
  setSmH : setComponentH, setComponentT;
  setSmZ : setComponentZ, setComponentT;
  setSmXY : setComponentX, setComponentY, setComponentT;
  setSmXZ : setComponentX, setComponentZ, setComponentT;
  setSmPos : setComponentX, setComponentY, setComponentZ, setComponentT;
  setSmHpr : setComponentH, setComponentP, setComponentR, setComponentT;
  setSmXYH : setComponentX, setComponentY, setComponentH, setComponentT;
  setSmXYZH : setComponentX, setComponentY, setComponentZ, setComponentH, setComponentT;
  setSmPosHpr : setComponentX, setComponentY, setComponentZ, setComponentH, setComponentP, setComponentR, setComponentT;
  setSmPosHprL : setComponentL, setComponentX, setComponentY, setComponentZ, setComponentH, setComponentP, setComponentR, setComponentT;
  clearSmoothing(int8) broadcast clsend;
};

dclass DistCogdoCraneMoneyBag : DistCogdoCraneObject {
  setIndex(uint8 index) required broadcast ram;
  requestInitial() airecv clsend;
};

dclass DistCogdoCraneCog : DistributedObject {
  setGameId(uint32 gameId) required broadcast ram;
  setDNAString(blob dnaString) required broadcast ram;
  setSpawnInfo(uint8 entranceId, int16 timestamp) required broadcast ram;
};

dclass DistributedHQInterior : DistributedObject {
  setZoneIdAndBlock(uint32 zoneId, uint16 block) required broadcast ram;
  setLeaderBoard(blob leaderData) required broadcast ram;
  setTutorial(uint8 flag) required broadcast ram;
};

dclass DistributedGagshopInterior : DistributedObject {
  setZoneIdAndBlock(uint32 zoneId, uint16 block) required broadcast ram;
};

dclass DistributedPetshopInterior : DistributedObject {
  setZoneIdAndBlock(uint32 zoneId, uint16 block) required broadcast ram;
};

dclass DistributedKartShopInterior : DistributedObject {
  setZoneIdAndBlock(uint32 zoneId, uint16 block) required broadcast ram;
};

dclass DistributedDoor : DistributedObject {
  setZoneIdAndBlock(uint32 zoneId, uint32 block) required broadcast ram;
  setSwing(int8 flags) required broadcast ram;
  setDoorType(uint8 doorType) required broadcast ram;
  setDoorIndex(uint8 doorIndex) required broadcast ram;
  setOtherZoneIdAndDoId(uint32 zoneId, uint32 distributedObjectID);
  requestEnter() airecv clsend;
  requestExit() airecv clsend;
  rejectEnter(int8 reason);
  avatarEnter(uint32 avatarID) broadcast;
  avatarExit(uint32 avatarID) broadcast;
  setState(string state, int16 timestamp) required broadcast ram;
  setExitDoorState(string state, int16 timestamp) required broadcast ram;
};

dclass DistributedAnimDoor : DistributedDoor {
};

dclass DistributedHouseDoor : DistributedDoor {
};

dclass DistributedCogHQDoor : DistributedDoor {
};

dclass DistributedSellbotHQDoor : DistributedCogHQDoor {
  informPlayer(uint8 suitType) broadcast ram;
};

dclass DistributedNPCToonBase : DistributedNode {
  setName(string name) required broadcast ram;
  setDNAString(blob dnaString) required broadcast ram;
  setPositionIndex(uint8 posIndex) required broadcast ram;
  setAnimState(string animName, int16/1000 animMultiplier, int16 timestamp) broadcast ram;
  setPageNumber(int16 paragraph, int8 pageNumber, int16 timestamp) broadcast ram clsend;
  avatarEnter() airecv clsend;
  freeAvatar();
};

dclass DistributedNPCToon : DistributedNPCToonBase {
  setMovie(uint8 mode, uint32 npcId, uint32 avId, uint16 quests[], int16 timestamp) broadcast ram;
  setMovieDone() airecv clsend;
  chooseQuest(uint16 questId) airecv clsend;
  chooseTrack(int8 trackId) airecv clsend;
};

dclass DistributedNPCSnowballGiver : DistributedNPCToonBase {
  gaveSnowballs(uint32 npcId, uint32 avId, uint8 sbPhraseId) broadcast ram;
};

dclass DistributedNPCSpecialQuestGiver : DistributedNPCToonBase {
  setMovie(uint8 mode, uint32 npcId, uint32 avId, uint16 quests[], int16 timestamp) broadcast ram;
  setMovieDone() airecv clsend;
  chooseQuest(uint16 questId) airecv clsend;
  chooseTrack(int8 trackId) airecv clsend;
};

dclass DistributedNPCFlippyInToonHall : DistributedNPCToon {
};

dclass DistributedNPCScientist : DistributedNPCToonBase {
  setChat(char topic[0-1024], uint8 partPos, uint32 partId, uint8 progress, uint8 flags) ownsend broadcast;
};

dclass DistributedNPCClerk : DistributedNPCToonBase {
  setMovie(uint8 mode, uint32 npcId, uint32 avId, int16 timestamp) broadcast ram;
  setInventory(blob inventoryNetString, int16, uint8) airecv clsend;
};

dclass DistributedNPCTailor : DistributedNPCToonBase {
  setMovie(uint8 mode, uint32 npcId, uint32 avId, int16 timestamp) broadcast ram;
  setDNA(blob dna, int8 black, uint8 heads) airecv clsend;
  setCustomerDNA(uint32 avId, blob dnaString) broadcast ram;
};

dclass DistributedNPCBlocker : DistributedNPCToonBase {
  setMovie(uint8 mode, uint32 npcId, uint32 avId, int16 timestamp) broadcast ram;
};

dclass DistributedNPCFisherman : DistributedNPCToonBase {
  setMovie(uint8 mode, uint32 npcId, uint32 avId, uint32 extraArgs[], int16 timestamp) broadcast ram;
  completeSale(uint8 sell) airecv clsend;
};

dclass DistributedNPCPartyPerson : DistributedNPCToonBase {
  setMovie(uint8 mode, uint32 npcId, uint32 avId, uint32 extraArgs[], int16 timestamp) broadcast ram;
  answer(uint8 wantsToPlan) airecv clsend;
};

dclass DistributedNPCPetclerk : DistributedNPCToonBase {
  setMovie(uint8 mode, uint32 npcId, uint32 avId, uint32 extraArgs[], int16 timestamp) broadcast ram;
  setPetSeeds(uint32 petSeeds[]);
  petAdopted(uint8 petNum, uint32 nameIndex) airecv clsend;
  petReturned() airecv clsend;
  fishSold() airecv clsend;
  transactionDone() airecv clsend;
};

dclass DistributedNPCKartClerk : DistributedNPCToonBase {
  setMovie(uint8 mode, uint32 npcId, uint32 avId, uint32 extraArgs[], int16 timestamp) broadcast ram;
  buyKart(uint8 whichKart) airecv clsend;
  buyAccessory(uint8 whichAcc) airecv clsend;
  transactionDone() airecv clsend;
};

dclass DistributedKnockKnockDoor : DistributedAnimatedProp {
};

dclass DistributedElevator : DistributedObject {
  setBldgDoId(uint32 bldgDoId) required broadcast ram;
  setState(string state, int16 timestamp) broadcast ram;
  fillSlot0(uint32 avId, uint8 wantBoardingShow) broadcast ram;
  fillSlot1(uint32 avId, uint8 wantBoardingShow) broadcast ram;
  fillSlot2(uint32 avId, uint8 wantBoardingShow) broadcast ram;
  fillSlot3(uint32 avId, uint8 wantBoardingShow) broadcast ram;
  fillSlot4(uint32 avId, uint8 wantBoardingShow) broadcast ram;
  fillSlot5(uint32 avId, uint8 wantBoardingShow) broadcast ram;
  fillSlot6(uint32 avId, uint8 wantBoardingShow) broadcast ram;
  fillSlot7(uint32 avId, uint8 wantBoardingShow) broadcast ram;
  emptySlot0(uint32 avId, int8 bailFlag, int16 timestamp, int16 time) broadcast ram;
  emptySlot1(uint32 avId, int8 bailFlag, int16 timestamp, int16 time) broadcast ram;
  emptySlot2(uint32 avId, int8 bailFlag, int16 timestamp, int16 time) broadcast ram;
  emptySlot3(uint32 avId, int8 bailFlag, int16 timestamp, int16 time) broadcast ram;
  emptySlot4(uint32 avId, int8 bailFlag, int16 timestamp, int16 time) broadcast ram;
  emptySlot5(uint32 avId, int8 bailFlag, int16 timestamp, int16 time) broadcast ram;
  emptySlot6(uint32 avId, int8 bailFlag, int16 timestamp, int16 time) broadcast ram;
  emptySlot7(uint32 avId, int8 bailFlag, int16 timestamp, int16 time) broadcast ram;
  requestBoard() airecv clsend;
  rejectBoard(uint32 avId, uint8 reason);
  requestExit() airecv clsend;
  setElevatorTripId(uint32 id) required broadcast ram;
  setAntiShuffle(uint8 antiShuffle) required broadcast ram;
  setMinLaff(uint8 minLaff) required broadcast ram;
};

dclass DistributedElevatorFSM : DistributedObject {
  setBldgDoId(uint32 bldgDoId) required broadcast ram;
  setState(string state, int16 timestamp) broadcast ram;
  fillSlot0(uint32 avId) broadcast ram;
  fillSlot1(uint32 avId) broadcast ram;
  fillSlot2(uint32 avId) broadcast ram;
  fillSlot3(uint32 avId) broadcast ram;
  fillSlot4(uint32 avId) broadcast ram;
  fillSlot5(uint32 avId) broadcast ram;
  fillSlot6(uint32 avId) broadcast ram;
  fillSlot7(uint32 avId) broadcast ram;
  emptySlot0(uint32 avId, int8 bailFlag, int16 timestamp) broadcast ram;
  emptySlot1(uint32 avId, int8 bailFlag, int16 timestamp) broadcast ram;
  emptySlot2(uint32 avId, int8 bailFlag, int16 timestamp) broadcast ram;
  emptySlot3(uint32 avId, int8 bailFlag, int16 timestamp) broadcast ram;
  emptySlot4(uint32 avId, int8 bailFlag, int16 timestamp) broadcast ram;
  emptySlot5(uint32 avId, int8 bailFlag, int16 timestamp) broadcast ram;
  emptySlot6(uint32 avId, int8 bailFlag, int16 timestamp) broadcast ram;
  emptySlot7(uint32 avId, int8 bailFlag, int16 timestamp) broadcast ram;
  requestBoard() airecv clsend;
  rejectBoard(uint32 avId, uint8 reason);
  requestExit() airecv clsend;
  setElevatorTripId(uint32 id) required broadcast ram;
  setAntiShuffle(uint8 antiShuffle) required broadcast ram;
  setMinLaff(uint8 minLaff) required broadcast ram;
};

dclass DistributedElevatorFloor : DistributedElevatorFSM {
  setFloor(int8 floorNumber) broadcast ram;
  setLocked(uint16 locked) required broadcast ram;
  setEntering(uint16 entering) required broadcast ram;
  kickToonsOut() broadcast;
  setLatch(uint32 markerId) required broadcast ram;
};

dclass DistributedElevatorExt : DistributedElevator {
  setFloor(int8 floorNumber) broadcast ram;
};

dclass DistributedLawOfficeElevatorExt : DistributedElevatorExt {
  setEntranceId(uint8 entranceId) required broadcast ram;
  setLawOfficeInteriorZone(uint32 zoneId);
  setLawOfficeInteriorZoneForce(uint32 zoneId);
};

dclass DistributedElevatorInt : DistributedElevator {
  requestBuildingExit() airecv clsend;
  forcedExit(uint32 avId);
};

dclass DistributedFactoryElevatorExt : DistributedElevatorExt {
  setEntranceId(uint8 entranceId) required broadcast ram;
  setFactoryInteriorZone(uint32 zoneId);
  setFactoryInteriorZoneForce(uint32 zoneId);
};

dclass DistributedMintElevatorExt : DistributedElevatorExt {
  setMintId(uint16 mintId) required broadcast ram;
  setMintInteriorZone(uint32 zoneId);
  setMintInteriorZoneForce(uint32 zoneId);
};

dclass DistributedCogdoElevatorExt : DistributedElevatorExt {
};

dclass DistributedLawOfficeElevatorInt : DistributedElevatorFloor {
  setLawOfficeInteriorZone(uint32 zoneId);
};

dclass DistributedCogdoElevatorInt : DistributedElevatorInt {
};

dclass DistributedBossElevator : DistributedElevatorExt {
  setBossOfficeZone(uint32 zoneId);
  setBossOfficeZoneForce(uint32 zoneId);
};

dclass DistributedVPElevator : DistributedBossElevator {
};

dclass DistributedCFOElevator : DistributedBossElevator {
};

dclass DistributedCJElevator : DistributedBossElevator {
};

dclass DistributedBBElevator : DistributedBossElevator {
};

dclass DistributedBoardingParty : DistributedObject {
  postGroupInfo(uint32 leaderId, uint32 memberList[], uint32 inviteeList[], uint32 kickedList[]) broadcast;
  informDestinationInfo(uint8 offset) clsend airecv;
  postDestinationInfo(uint8 offset) broadcast;
  postInvite(uint32 leaderId, uint32 inviterId) broadcast;
  postInviteCanceled() broadcast;
  postKick(uint32 leaderId) broadcast;
  postKickReject(uint32 leaderId, uint32 inviterId, uint32 inviteeId) broadcast;
  postSizeReject(uint32 leaderId, uint32 inviterId, uint32 inviteeId) broadcast;
  postInviteAccepted(uint32 inviteeId) broadcast;
  postInviteDelcined(uint32 inviteeId) broadcast;
  postInviteNotQualify(uint32 avId, int8 reason, uint32 elevatorId) broadcast;
  postAlreadyInGroup() broadcast;
  postGroupDissolve(uint32 quitterId, uint32 leaderId, uint32 memberList[], uint8 kick) broadcast;
  postMessageAcceptanceFailed(uint32 inviteeId, int8 reason) broadcast;
  postGroupAlreadyFull() broadcast;
  postSomethingMissing() broadcast;
  postRejectBoard(uint32 elevatorId, int8 reason, uint32 avatarsFailingRequirements[], uint32 avatarsInBattle[]) broadcast;
  postRejectGoto(uint32 elevatorId, int8 reason, uint32 avatarsFailingRequirements[], uint32 avatarsInBattle[]) broadcast;
  postMessageInvited(uint32 inviteeId, uint32 inviterId) broadcast;
  postMessageInvitationFailed(uint32 inviterId) broadcast;
  acceptGoToFirstTime(uint32 elevatorId) broadcast;
  acceptGoToSecondTime(uint32 elevatorId) broadcast;
  rejectGoToRequest(uint32 elevatorId, int8 reason, uint32 avatarsFailingRequirements[], uint32 avatarsInBattle[]) broadcast;
  requestInvite(uint32 inviteeId) airecv clsend;
  requestCancelInvite(uint32 inviteeId) airecv clsend;
  requestAcceptInvite(uint32 leaderId, uint32 inviterId) airecv clsend;
  requestRejectInvite(uint32 leaderId, uint32 inviterId) airecv clsend;
  requestKick(uint32 kickId) airecv clsend;
  requestLeave(uint32 place) airecv clsend;
  requestBoard(uint32 elevatorId) airecv clsend;
  requestGoToFirstTime(uint32 elevatorId) airecv clsend;
  requestGoToSecondTime(uint32 elevatorId) airecv clsend;
  setElevatorIdList(uint32 elevatorIdList[]) required broadcast ram;
  setGroupSize(uint8 groupSize) required broadcast ram;
};

dclass DistributedTutorialInterior : DistributedObject {
  setZoneIdAndBlock(uint32 zoneId, uint16 block) required broadcast ram;
  setTutorialNpcId(uint32 npcId) required broadcast ram;
};

dclass DistributedBankMgr : DistributedObject {
  transferMoney(int16 amount) airecv clsend;
};

dclass DistributedMailbox : DistributedObject {
  setHouseId(uint32 houseId) required broadcast ram;
  setHousePos(uint8 housePosInd) required broadcast ram;
  setName(string name) required broadcast ram;
  setFullIndicator(uint8 full) broadcast ram;
  avatarEnter() airecv clsend;
  avatarExit() airecv clsend;
  freeAvatar();
  setMovie(uint8 mode, uint32 avId) broadcast ram;
  acceptItemMessage(uint16 todo0, blob todo1, uint8 todo2, int32 todo3) airecv clsend;
  acceptItemResponse(uint16 context, int8 retcode);
  discardItemMessage(uint16 todo0, blob todo1, uint8 todo2, int32 todo3) airecv clsend;
  discardItemResponse(uint16 context, int8 retcode);
  acceptInviteMessage(uint16 todo0, uint64 todo1) airecv clsend;
  rejectInviteMessage(uint16 todo0, uint64 todo1) airecv clsend;
  markInviteReadButNotReplied(uint64 todo0) airecv clsend;
};

dclass DistributedFurnitureManager : DistributedObject {
  setOwnerId(uint32 ownerId) required broadcast ram;
  setOwnerName(string ownerName) required broadcast ram;
  setInteriorId(uint32 interiorId) required broadcast ram;
  setAtticItems(blob atticItems) required broadcast ram;
  setAtticWallpaper(blob atticWallpaper) required broadcast ram;
  setAtticWindows(blob atticWindows) required broadcast ram;
  setDeletedItems(blob deletedItems) required broadcast ram;
  suggestDirector(uint32 directorId) airecv clsend;
  setDirector(uint32 directorId) broadcast ram;
  avatarEnter() airecv clsend;
  avatarExit() airecv clsend;
  moveItemToAtticMessage(uint32 doId, uint16 context) airecv clsend;
  moveItemToAtticResponse(int8 retval, uint16 context);
  moveItemFromAtticMessage(uint16 index, int16/10 x, int16/10 y, int16/100 z, int16/10 h, int16/10 p, int16/10 r, uint16 context) airecv clsend;
  moveItemFromAtticResponse(int8 retval, uint32 doId, uint16 context);
  deleteItemFromAtticMessage(blob item, uint16 index, uint16 context) airecv clsend;
  deleteItemFromAtticResponse(int8 retval, uint16 context);
  deleteItemFromRoomMessage(blob item, uint32 doId, uint16 context) airecv clsend;
  deleteItemFromRoomResponse(int8 retval, uint16 context);
  moveWallpaperFromAtticMessage(uint16 index, uint8 room, uint16 context) airecv clsend;
  moveWallpaperFromAtticResponse(int8 retval, uint16 context);
  deleteWallpaperFromAtticMessage(blob item, uint16 index, uint16 context) airecv clsend;
  deleteWallpaperFromAtticResponse(int8 retval, uint16 context);
  moveWindowToAtticMessage(uint8 slot, uint16 context) airecv clsend;
  moveWindowToAtticResponse(int8 retval, uint16 context);
  moveWindowFromAtticMessage(uint16 index, uint8 slot, uint16 context) airecv clsend;
  moveWindowFromAtticResponse(int8 retval, uint16 context);
  moveWindowMessage(uint8 fromSlot, uint8 toSlot, uint16 context) airecv clsend;
  moveWindowResponse(int8 retval, uint16 context);
  deleteWindowFromAtticMessage(blob item, uint16 index, uint16 context) airecv clsend;
  deleteWindowFromAtticResponse(int8 retval, uint16 context);
  recoverDeletedItemMessage(blob item, uint16 index, uint16 context) airecv clsend;
  recoverDeletedItemResponse(int8 retval, uint16 context);
};

dclass DistributedFurnitureItem : DistributedSmoothNode {
  setItem(uint32 furnitureMgrId, blob item) required broadcast ram;
  requestPosHpr(uint8 final, int16/10 x, int16/10 y, int16/100 z, int16/10 h, int16/10 p, int16/10 r, int16 t) airecv clsend;
  setMode(uint8 mdoe, uint32 avId) required broadcast ram;
};

dclass DistributedBank : DistributedFurnitureItem {
  avatarEnter() airecv clsend;
  freeAvatar();
  setMovie(uint8 mode, uint32 avId, int16 timestamp) broadcast ram;
  transferMoney(int16 amount) airecv clsend;
};

dclass DistributedCloset : DistributedFurnitureItem {
  setOwnerId(uint32 avId) required broadcast ram;
  enterAvatar() airecv clsend;
  freeAvatar();
  removeItem(blob trashItem, uint8 t_or_b) airecv clsend;
  setDNA(blob dnaString, int8 finished, uint8 whichItems) airecv clsend;
  setState(uint8 mode, uint32 avId, uint32 ownerId, string gender, uint8 topList[], uint8 botList[]) broadcast ram;
  setMovie(uint8 mode, uint32 avId, int16 timestamp) broadcast ram;
  resetItemLists() broadcast ram;
  setCustomerDNA(uint32 avId, blob dnaString) broadcast ram;
};

dclass DistributedTrunk : DistributedCloset {
  setState(uint8 mode, uint32 avId, uint32 ownerId, string gender, uint8 hatList[], uint8 glassesList[], uint8 backpackList[], uint8 shoesList[]) broadcast ram;
  removeItem(uint8 todo0, uint8 todo1, uint8 todo2, uint8 todo3) airecv clsend;
  setDNA(uint8 todo0, uint8 todo1, uint8 todo2, uint8 todo3, uint8 todo4, uint8 todo5, uint8 todo6, uint8 todo7, uint8 todo8, uint8 todo9, uint8 todo10, uint8 todo11, int8 todo12, uint8 todo13) airecv clsend;
  setCustomerDNA(uint32 avId, uint8 hatIdx, uint8 hatTexture, uint8 hatColor, uint8 glassesIdx, uint8 glassesTexture, uint8 glassesColor, uint8 backpackIdx, uint8 backpackTexture, uint8 backpackColor, uint8 shoesIdx, uint8 shoesTexture, uint8 shoesColor, uint8 which) broadcast ram;
};

dclass DistributedPhone : DistributedFurnitureItem {
  setInitialScale(uint8/170 sx, uint8/170 sy, uint8/170 sz) required broadcast ram;
  setNewScale(uint8/170 sx, uint8/170 sy, uint8/170 sz) airecv clsend;
  avatarEnter() airecv clsend;
  avatarExit() airecv clsend;
  freeAvatar();
  setLimits(uint16 numHouseItems);
  setMovie(uint8 mode, uint32 avId, int32 timestamp) broadcast ram;
  requestPurchaseMessage(uint16 context, blob data, int32 optional) airecv clsend;
  requestPurchaseResponse(uint16 context, int8 retcode);
  requestGiftPurchaseMessage(uint16 context, uint32 targetDoID, blob data, int32 optional) airecv clsend;
  requestGiftPurchaseResponse(uint16 context, int8 retcode);
};

dclass DistributedFireworkShow : DistributedObject {
  startShow(uint8 eventId, uint8 style, uint8 songId, int16 timestamp) broadcast ram;
  requestFirework(int16/10 x, int16/10 y, int16/100 z, uint8 style, uint8 color1, uint8 color2) airecv clsend;
  shootFirework(int16/10 x, int16/10 y, int16/100 z, uint8 style, uint8 color1, uint8 color2) broadcast;
};

dclass DistributedFireworksCannon : DistributedFireworkShow {
  avatarEnter() airecv clsend;
  avatarExit() airecv clsend;
  freeAvatar();
  setMovie(uint8 mode, uint32 avId, int16 timestamp) broadcast ram;
  setPosition(int16/10 x, int16/10 y, int16/10 z) required broadcast ram;
};

dclass LobbyManager : DistributedObject {
};

dclass DistributedFactory : DistributedLevel {
  setFactoryId(uint16 id) required broadcast ram;
  setSuits(uint32 suitIds[], uint32 reserveSuitIds[]) broadcast ram;
  setForemanConfronted(uint32 avId) broadcast ram;
  setDefeated() broadcast ram;
};

dclass DistributedLawOffice : DistributedObject {
  setLawOfficeId(uint16 id) required broadcast ram;
  startSignal() broadcast ram;
  readyForNextFloor() airecv clsend;
};

dclass DistributedLawOfficeFloor : DistributedLevel {
  setLawOfficeId(uint16 id) required broadcast ram;
  setSuits(uint32 suitIds[], uint32 reserveSuitIds[]) broadcast ram;
  readyForNextFloor() airecv clsend;
  setForemanConfronted(uint32 avId) broadcast ram;
  setDefeated() broadcast ram;
};

dclass DistributedMint : DistributedObject {
  setZoneId(uint32 zoneId) required broadcast ram;
  setMintId(uint16 id) required broadcast ram;
  setFloorNum(uint8 num) required broadcast ram;
  setRoomDoIds(uint32 roomDoIds[]) broadcast ram;
};

dclass DistributedMintRoom : DistributedLevel {
  setMintId(uint16 mintId) required broadcast ram;
  setRoomId(uint16 roomId) required broadcast ram;
  setRoomNum(uint8 num) required broadcast ram;
  setSuits(uint32 suitIds[], uint32 reserveSuitIds[]) broadcast ram;
  setBossConfronted(uint32 avId) broadcast ram;
  setDefeated() broadcast ram;
};

dclass DistributedStage : DistributedObject {
  setZoneId(uint32 zoneId) required broadcast ram;
  setStageId(uint16 id) required broadcast ram;
  setLayoutIndex(uint16 layoutIndex) required broadcast ram;
  setFloorNum(uint8 num) required broadcast ram;
  setRoomDoIds(uint32 roomDoIds[]) broadcast ram;
  setStageZone(uint32 zoneId) broadcast ram;
  elevatorAlert(uint32 avId) broadcast ram;
};

dclass DistributedStageRoom : DistributedLevel {
  setStageId(uint16 stageId) required broadcast ram;
  setRoomId(uint16 roomId) required broadcast ram;
  setRoomNum(uint8 num) required broadcast ram;
  setSuits(uint32 suitIds[], uint32 reserveSuitIds[]) broadcast ram;
  setBossConfronted(uint32 avId) broadcast ram;
  setDefeated() broadcast ram;
};

dclass DistributedInGameEditor : DistributedObject {
  setEditorAvId(uint32) required broadcast ram;
  setEditUsername(blob) required broadcast ram;
  setLevelDoId(uint32) required broadcast ram;
  requestCurrentLevelSpec() airecv clsend;
  setSpecSenderDoId(uint32);
  setEdit(uint32, blob, blob, blob) airecv clsend;
  setAttribChange(uint32, blob, blob, blob);
  setFinished() airecv clsend;
};

dclass DistributedLift : DistributedEntity {
  setStateTransition(uint8 toState, uint8 fromState, uint32 arrivalTimestamp) required broadcast ram;
  setAvatarEnter() airecv clsend;
  setAvatarLeave() airecv clsend;
};

dclass DistributedDoorEntity : DistributedEntity {
  setLocksState(uint16 stateBits) required broadcast ram;
  setDoorState(uint8 stateIndex, int32 timeStamp) required broadcast ram;
  requestOpen() airecv clsend;
};

dclass DistributedSwitch : DistributedInteractiveEntity {
};

dclass DistributedButton : DistributedSwitch {
};

dclass DistributedTrigger : DistributedSwitch {
};

dclass DistributedCrushableEntity : DistributedEntity {
  setPosition(int16/10 x, int16/10 y, int16/10 z) broadcast ram;
  setCrushed(uint32 crusherId, uint8 axis) broadcast ram;
};

dclass DistributedCrusherEntity : DistributedEntity {
};

dclass DistributedElevatorMarker : DistributedEntity {
};

dclass DistributedStomper : DistributedCrusherEntity {
  setMovie(uint8 mode, int16 timestamp, uint32 crushedList[]) broadcast ram;
};

dclass DistributedStomperPair : DistributedEntity {
  setChildren(uint32 doIds[]) broadcast ram;
  setSquash() airecv clsend;
};

dclass DistributedBarrelBase : DistributedEntity {
  requestGrab() airecv clsend;
  setGrab(uint32 avId) broadcast ram;
  setReject() broadcast;
};

dclass DistributedGagBarrel : DistributedBarrelBase {
};

dclass DistributedBeanBarrel : DistributedBarrelBase {
};

dclass DistributedHealBarrel : DistributedBarrelBase {
};

dclass DistributedGrid : DistributedEntity {
};

dclass ActiveCell : DistributedEntity {
  setState(uint8 state, uint32 objId) broadcast ram;
};

dclass DirectionalCell : ActiveCell {
};

dclass CrusherCell : ActiveCell {
};

dclass DistributedCrate : DistributedCrushableEntity {
  requestPush(uint8 side) airecv clsend;
  setReject();
  setAccept() broadcast;
  setMoveTo(uint32 avId, int16/10 x0, int16/10 y0, int16/10 z0, int16/10 x1, int16/10 y1, int16/10 z1) broadcast ram;
  setDone() airecv clsend;
};

dclass DistributedSinkingPlatform : DistributedEntity {
  setOnOff(uint8 on, uint32 timestamp) airecv clsend;
  setSinkMode(uint32 avId, uint8 mode, uint32 ts) broadcast ram;
};

dclass DistributedGoon : DistributedCrushableEntity {
  requestBattle(int16/10 pauseTime) airecv clsend;
  requestStunned(int16/10 pauseTime) airecv clsend;
  requestResync() airecv clsend;
  setParameterize(int16/10 x, int16/10 y, int16/10 z, uint32 pathIndex) airecv clsend;
  setMovie(uint8 mode, uint32 avId, int32/10 pauseTime, int16 timestamp) broadcast ram;
};

dclass DistributedGridGoon : DistributedGoon {
  setPathPts(int16/10 xi, int16/10 yi, int16/10 zi, int16/10 xf, int16/10 yf, int16/10 zf) broadcast ram;
};

dclass BattleBlocker : DistributedEntity {
  setActive(uint8 active) required broadcast ram;
  setSuits(uint32 suitIds[]) broadcast ram;
  setBattle(uint32 battleId) broadcast ram;
  setBattleFinished() broadcast ram;
};

dclass DistributedLaserField : BattleBlocker {
  setGrid(uint8 gridNumX, uint8 gridNumY) required broadcast ram;
  setField(uint8 fieldData[]) required broadcast ram;
  setSuccess(uint8 success) broadcast ram;
  hit(int8 hitX, int8 hitY, int8 oldX, int8 oldY) airecv clsend;
  trapFire() airecv clsend;
  setActiveLF(uint8 active) broadcast ram;
  hideSuit(uint32 suitIdarray[]) broadcast ram;
  showSuit(uint32 suitIdarray[]) broadcast ram;
  setGridGame(string gameName) broadcast ram;
};

struct golfGreenGameBoardData {
  uint8 posX;
  uint8 posZ;
  uint8 typeIndex;
};

struct golfGreenGameScoreData {
  uint32 avId;
  uint8 score;
};

dclass DistributedGolfGreenGame : BattleBlocker {
  requestJoin() airecv clsend;
  leaveGame() airecv clsend;
  acceptJoin(uint16 time, int32 timeStamp, uint32 avIds[]) broadcast ram;
  requestBoard(uint8 boardVerify) airecv clsend;
  startBoard(golfGreenGameBoardData board[], uint8 attackPattern[]);
  signalDone(uint8 success) broadcast ram;
  boardCleared(uint32 avId);
  scoreData(uint8 total, uint8 closed, golfGreenGameScoreData scoreList[]) broadcast ram;
  informGag(uint8 track, uint8 level);
  helpOthers(uint32 avId) broadcast;
  setTimerStart(uint16 time, int32 timeStamp) broadcast ram;
};

dclass DistributedSecurityCamera : DistributedEntity {
  trapFire() airecv clsend;
  setTarget(uint8 targetHash) broadcast ram;
};

dclass DistributedMover : DistributedEntity {
  startMove(int16 timeStamp) broadcast ram;
};

typedef uint16/10000 PetTrait;

dclass DistributedPet : DistributedSmoothNode {
  setOwnerId(uint32) required broadcast db;
  setPetName(string) required broadcast db;
  setTraitSeed(uint32) required broadcast db;
  setSafeZone(uint32) required broadcast db;
  setForgetfulness(PetTrait) required broadcast db;
  setBoredomThreshold(PetTrait) required broadcast db;
  setRestlessnessThreshold(PetTrait) required broadcast db;
  setPlayfulnessThreshold(PetTrait) required broadcast db;
  setLonelinessThreshold(PetTrait) required broadcast db;
  setSadnessThreshold(PetTrait) required broadcast db;
  setFatigueThreshold(PetTrait) required broadcast db;
  setHungerThreshold(PetTrait) required broadcast db;
  setConfusionThreshold(PetTrait) required broadcast db;
  setExcitementThreshold(PetTrait) required broadcast db;
  setAngerThreshold(PetTrait) required broadcast db;
  setSurpriseThreshold(PetTrait) required broadcast db;
  setAffectionThreshold(PetTrait) required broadcast db;
  setHead(int8(-1 - 1)) required broadcast db; // Supposed to be -1 - 0, but minification causes this to become -1-0, which is a parse problem.
  setEars(int8(-1 - 4)) required broadcast db;
  setNose(int8(-1 - 3)) required broadcast db;
  setTail(int8(-1 - 6)) required broadcast db;
  setBodyTexture(int8(0-6)) required broadcast db;
  setColor(int8(0-25)) required broadcast db;
  setColorScale(int8(0-8)) required broadcast db;
  setEyeColor(int8(0-5)) required broadcast db;
  setGender(int8(0-1)) required broadcast db;
  setLastSeenTimestamp(uint32) required broadcast db;
  setBoredom(uint16/1000(0-1)) required broadcast db;
  setRestlessness(uint16/1000(0-1)) required broadcast db;
  setPlayfulness(uint16/1000(0-1)) required broadcast db;
  setLoneliness(uint16/1000(0-1)) required broadcast db;
  setSadness(uint16/1000(0-1)) required broadcast db;
  setAffection(uint16/1000(0-1)) required broadcast db;
  setHunger(uint16/1000(0-1)) required broadcast db;
  setConfusion(uint16/1000(0-1)) required broadcast db;
  setExcitement(uint16/1000(0-1)) required broadcast db;
  setFatigue(uint16/1000(0-1)) required broadcast db;
  setAnger(uint16/1000(0-1)) required broadcast db;
  setSurprise(uint16/1000(0-1)) required broadcast db;
  setMood : setBoredom, setRestlessness, setPlayfulness, setLoneliness, setSadness, setAffection, setHunger, setConfusion, setExcitement, setFatigue, setAnger, setSurprise;
  teleportIn(int16) broadcast ownsend;
  teleportOut(int16) broadcast ownsend;
  setTrickAptitudes(uint16/10000(0-1) []) required broadcast db;
  doTrick(uint8, int16) broadcast ram;
  avatarInteract(uint32);
  setMovie(uint8, uint32, int16) broadcast ram;
  freeAvatar();
};

dclass DistributedPetProxy : DistributedPet {
  setDominantMood(string dominantMood) broadcast ram;
};

dclass DistributedBlackCatMgr : DistributedObject {
  doBlackCatTransformation(uint32 avId) broadcast;
  requestBlackCatTransformation() airecv clsend;
};

dclass DistributedPolarBearMgr : DistributedObject {
  doPolarBearTransformation(uint32 avId) broadcast;
  requestPolarBearTransformation() airecv clsend;
};

dclass DistributedPolarPlaceEffectMgr : DistributedObject {
  addPolarPlaceEffect() airecv clsend;
};

dclass DistributedGreenToonEffectMgr : DistributedObject {
  addGreenToonEffect() airecv clsend;
};

dclass DistributedResistanceEmoteMgr : DistributedObject {
  addResistanceEmote() airecv clsend;
};

dclass DistributedScavengerHuntTarget : DistributedObject {
  attemptScavengerHunt() airecv clsend;
};

dclass DistributedTrickOrTreatTarget : DistributedScavengerHuntTarget {
};

dclass DistributedWinterCarolingTarget : DistributedScavengerHuntTarget {
};

dclass DistributedDataStoreManager : DistributedObject {
  startStore(uint8 todo0);
  stopStore(uint8 todo0);
  queryStore(uint8 todo0, string todo1);
  receiveResults(uint8 todo0, string todo1);
  deleteBackupStores();
};

dclass DistributedVehicle : DistributedSmoothNode {
  setOwner(uint32 avId) required broadcast ram;
  setState(char state, uint32 avId) broadcast ram;
  setBodyType(int8 bodyType) required broadcast ram;
  setBodyColor(int8 bodyColor) required broadcast ram;
  setAccessoryColor(int8 accColor) required broadcast ram;
  setEngineBlockType(int8 ebType) required broadcast ram;
  setSpoilerType(int8 spType) required broadcast ram;
  setFrontWheelWellType(int8 fwwType) required broadcast ram;
  setBackWheelWellType(int8 bwwType) required broadcast ram;
  setRimType(int8 rimsType) required broadcast ram;
  setDecalType(int8 decalType) required broadcast ram;
  requestControl() airecv clsend;
  requestParked() airecv clsend;
  setInput(int8 on) broadcast ram;
};

struct avatarAndKart {
  uint32 avId;
  uint32 kartId;
};

dclass DistributedRace : DistributedObject {
  setZoneId(uint32 zoneId) required broadcast ram;
  setTrackId(uint16 id) required broadcast ram;
  setRaceType(uint16 raceType) required broadcast ram;
  setCircuitLoop(uint16 circuitLoop[]) required broadcast ram;
  setAvatars(uint32 avIds[]) required broadcast ram;
  setStartingPlaces(uint8 startList[]) required broadcast ram;
  setLapCount(uint8 lapCount) broadcast required ram;
  waitingForJoin() broadcast ram;
  setEnteredRacers(avatarAndKart avAndKarts[]) broadcast ram;
  prepForRace() broadcast ram;
  startTutorial() broadcast ram;
  startRace(int16 startTime) broadcast ram;
  goToSpeedway(uint32 avIds[], uint8 reason) broadcast ram;
  genGag(uint8 slot, uint16 number, uint8 type) broadcast ram;
  dropAnvilOn(uint32 ownerId, uint32 avId, int16 timeStamp) broadcast ram;
  shootPiejectile(uint32 sourceId, uint32 targetId, uint8 type) broadcast ram;
  racerDisconnected(uint32 avId) broadcast ram;
  setPlace(uint32 avId, uint32/1000 totalTime, uint8 place, uint32 entryFee, uint8 qualify, uint32 winnings, uint32 bonus, uint32 trophies[], uint16 circuitPoints[], uint32/1000 circuitTime) broadcast ram;
  setCircuitPlace(uint32 avId, uint8 place, uint32 entryFee, uint32 winnings, uint32 bonus, uint32 trophies[]) broadcast ram;
  endCircuitRace() broadcast ram;
  setRaceZone(uint32 zoneId, uint32 trackId);
  hasGag(uint8 slot, uint8 type, uint8 index) broadcast airecv clsend;
  racerLeft(uint32 avId) clsend airecv broadcast ram;
  heresMyT(uint32 avId, int8 avNumLaps, uint16/65535 avTime, int16 timestamp) clsend airecv broadcast;
  requestThrow(int32/1000 x, int32/1000 y, int32/1000 z) clsend airecv;
  requestKart() clsend airecv;
};

dclass DistributedGag : DistributedObject {
  setInitTime(int16 initTime) required broadcast ram;
  setActivateTime(int16 actTime) required broadcast ram;
  setPos(int32/1000 x, int32/1000 y, int32/1000 z) required broadcast ram;
  setRace(uint32 doId) required broadcast ram;
  setOwnerId(uint32 ownerId) required broadcast ram;
  setType(uint8 type) required broadcast ram;
  hitSomebody(uint32 avId, int16 timeStamp) broadcast clsend airecv;
};

dclass DistributedProjectile : DistributedObject {
  setInitTime(int16 todo0) required broadcast ram;
  setPos(int32/1000 pos, int32/1000, int32/1000) required broadcast ram;
  setRace(uint32 todo0) required broadcast ram;
  setOwnerId(uint32 todo0) required broadcast ram;
  setType(uint8 todo0) required broadcast ram;
  hitSomebody(uint32 todo0, int16 todo1) broadcast clsend airecv;
};

dclass DistributedKartPad : DistributedObject {
  setArea(uint32 area) required broadcast ram;
};

dclass DistributedRacePad : DistributedKartPad {
  setState(string state, int16 timestamp) required broadcast ram;
  setRaceZone(uint32 zoneId);
  setTrackInfo(uint16 trackInfo[]) required broadcast ram;
};

dclass DistributedViewPad : DistributedKartPad {
  setLastEntered(int16 timeStamp) required broadcast ram;
};

dclass DistributedStartingBlock : DistributedObject {
  setPadDoId(uint32 padDoId) required broadcast ram;
  setPosHpr(int16/10 x, int16/10 y, int16/10 z, int16/10 h, int16/10 p, int16/10 r) required broadcast ram;
  setPadLocationId(uint8 padLocationId) required broadcast ram;
  requestEnter(uint8 isPaid) airecv clsend;
  rejectEnter(uint8 errCode);
  requestExit() airecv clsend;
  setOccupied(uint32 avId) broadcast ram;
  setMovie(uint8 mode) broadcast ram;
  movieFinished() airecv clsend;
};

dclass DistributedViewingBlock : DistributedStartingBlock {
};

dclass DistributedLeaderBoard : DistributedObject {
  setPosHpr(int16/10 x, int16/10 y, int16/10 z, int16/10 h, int16/10 p, int16/10 r) required broadcast ram;
  setDisplay(blob pData) broadcast ram;
};

dclass DistributedDeliveryManager : DistributedObject {
  hello(string todo0) clsend;
  rejectHello(string message);
  helloResponse(string message);
  getName(uint32 todo0);
  receiveRejectGetName(string todo0);
  receiveAcceptGetName(string todo0);
  addName(uint32 todo0, string todo1);
  receiveRejectAddName(uint32 todo0);
  receiveAcceptAddName(uint32 todo0);
  addGift(uint32 todo0, blob todo1, uint32 todo2, uint32 todo3, uint32 todo4);
  receiveRejectAddGift(uint32 todo0);
  receiveAcceptAddGift(uint32 todo0, uint32 todo1, uint32 todo2, uint32 todo3);
  deliverGifts(uint32 todo0, uint32 todo1);
  receiveAcceptDeliverGifts(uint32 todo0, string todo1);
  receiveRejectDeliverGifts(uint32 todo0, string todo1);
  receiveRequestPayForGift(blob todo0, uint32 todo1, uint32 todo2) airecv clsend;
  receiveRequestPurchaseGift(blob todo0, uint32 todo1, uint32 todo2, uint32 todo3) airecv;
  receiveAcceptPurchaseGift(uint32 todo0, uint32 todo1, int16 todo2);
  receiveRejectPurchaseGift(uint32 todo0, uint32 todo1, int16 todo2, uint16 todo3);
  heartbeat() airecv;
  giveBeanBonus(uint32 todo0, uint16 todo1);
  requestAck() clsend;
  returnAck();
  givePartyRefund(uint32 todo0, uint32 todo1, uint64 todo2, int8 todo3, uint16 todo4);
};

dclass DistributedLawbotBoss : DistributedBossCog {
  setState(string state) broadcast ram;
  setBossDamage(uint16 bossDamage, uint8 recoverRate, int16 timestamp) broadcast ram;
  touchWitnessStand() airecv clsend;
  hitBoss(uint8 bossDamage) airecv clsend;
  healBoss(uint8 bossHeal) airecv clsend;
  hitToon(uint32 toonId) airecv clsend;
  hitDefensePan() airecv clsend;
  hitProsecutionPan() airecv clsend;
  hitChair(uint8 chairNum, uint8 index) airecv clsend;
  setLawyerIds(uint32 lawyerIds[]) broadcast ram;
  setTaunt(int8 tauntIndex, int8 extraInfo) broadcast;
  toonGotHealed(uint32 toonId) broadcast;
  enteredBonusState() broadcast;
  setBattleDifficulty(uint8 diff) broadcast ram;
};

dclass DistributedLawbotBossSuit : DistributedSuitBase {
  setPosHpr(int16/10 posHpr, int16/10, int16/10, int16/10, int16/10, int16/10) required broadcast ram;
  doAttack(int16/10 x1, int16/10 y1, int16/10 z1, int16/10 x2, int16/10 y2, int16/10 z2) broadcast;
  doProsecute() broadcast;
  hitByToon() airecv clsend;
  doStun() broadcast;
};

dclass DistributedLawbotBossGavel : DistributedObject {
  setBossCogId(uint32 bossCogId) required broadcast ram;
  setIndex(uint8 index) required broadcast ram;
  setState(char state) broadcast ram;
};

dclass DistributedLawbotCannon : DistributedObject {
  setBossCogId(uint32 bossCogId) required broadcast ram;
  setIndex(uint8 index) required broadcast ram;
  setPosHpr(int16/10 x, int16/10 y, int16/10 z, int16/10 h, int16/10 p, int16/10 r) required broadcast ram;
  requestEnter() airecv clsend;
  setMovie(int8 mode, uint32 avId, uint8 extraInfo) broadcast;
  setCannonPosition(int16/10 rotation, int16/10 angle) airecv clsend;
  updateCannonPosition(uint32 avId, int16/10 zRot, int16/10 angle) broadcast;
  setCannonLit(int16/10 rotation, int16/10 angle) airecv clsend;
  setCannonWillFire(uint32 avId, int16/10 fireTime, int16/10 zRot, int16/10 angle, int16 timestamp) broadcast;
  setLanded() airecv clsend;
  requestLeave() airecv clsend;
};

dclass DistributedLawbotChair : DistributedObject {
  setBossCogId(uint32 bossCogId) required broadcast ram;
  setIndex(uint8 index) required broadcast ram;
  setState(char state) broadcast ram;
  showCogJurorFlying() broadcast;
  setToonJurorIndex(int8 newVal) broadcast ram;
};

dclass DistributedLawnDecor : DistributedNode {
  setPlot(int8 plot) required broadcast ram;
  setHeading(int16/10 h) required broadcast ram;
  setPosition(int16/10 x, int16/10 y, int16/10 z) required broadcast ram;
  setOwnerIndex(int8 index) required broadcast ram;
  plotEntered() airecv clsend;
  removeItem() airecv clsend;
  setMovie(uint8 mode, uint32 avId) broadcast ram;
  movieDone() airecv clsend;
  interactionDenied(uint32 avId) broadcast ram;
};

dclass DistributedGardenPlot : DistributedLawnDecor {
  plantFlower(uint8 todo0, uint8 todo1) airecv clsend;
  plantGagTree(uint8 todo0, uint8 todo1) airecv clsend;
  plantStatuary(uint8 todo0) airecv clsend;
  plantToonStatuary(uint8 todo0, uint16 todo1) airecv clsend;
  plantNothing(uint8 todo0) airecv clsend;
};

dclass DistributedGardenBox : DistributedLawnDecor {
  setTypeIndex(uint8 typeIndex) required broadcast ram;
};

dclass DistributedStatuary : DistributedLawnDecor {
  setTypeIndex(uint8 typeIndex) required broadcast ram;
  setWaterLevel(int8 waterLevel) required broadcast ram;
  setGrowthLevel(int8 growthLevel) required broadcast ram;
};

dclass DistributedToonStatuary : DistributedStatuary {
  setOptional(uint16 optional) required broadcast ram;
};

dclass DistributedAnimatedStatuary : DistributedStatuary {
};

dclass DistributedChangingStatuary : DistributedStatuary {
  setGrowthLevel(int8 growthLevel) required broadcast ram;
};

dclass DistributedPlantBase : DistributedLawnDecor {
  setTypeIndex(uint8 typeIndex) required broadcast ram;
  setWaterLevel(int8 waterLevel) required broadcast ram;
  setGrowthLevel(int8 growthLevel) required broadcast ram;
  waterPlant() airecv clsend;
  waterPlantDone() airecv clsend;
};

dclass DistributedFlower : DistributedPlantBase {
  setTypeIndex(uint8 typeIndex) required broadcast ram;
  setVariety(uint8 variety) required broadcast ram;
};

dclass DistributedGagTree : DistributedPlantBase {
  setWilted(int8 wilted) required broadcast ram;
  requestHarvest() airecv clsend;
};

dclass DistributedTravelGame : DistributedMinigame {
  setTimerStartTime(int16 timestamp) broadcast;
  setAvatarChoice(uint16 votes, uint8 direction) airecv clsend;
  setAvatarVotes(uint32 avId, uint16 votes) broadcast;
  setAvatarChose(uint32 avId) broadcast;
  setServerChoices(int16 votes[], uint8 directions[], uint8 directionToGo, uint8 directionReason) broadcast;
  setMinigames(uint8 switches[], uint8 minigames[]) broadcast;
  setBonuses(uint8 switches[], uint8 beans[]) broadcast;
  setBoardIndex(uint8 boardIndex) required broadcast ram;
};

dclass DistributedPairingGame : DistributedMinigame {
  setDeckSeed(uint32 deckSeed) required broadcast ram;
  setMaxOpenCards(uint8) broadcast ram;
  openCardRequest(int16 deckOrderIndex, int16 bonusGlowCard) airecv clsend;
  openCardResult(int16 cardToTurnUp, uint32 avId, int16 matchingCard, int8 points, int16 cardsToTurnDown[]) broadcast;
  reportDone() airecv clsend;
  setEveryoneDone() broadcast;
  setSignaling(uint32 avId) clsend broadcast;
};

struct golfData {
  int16 frame;
  int32/100000 x;
  int32/100000 y;
  int32/100000 z;
};

struct Coord3 {
  int32/100000 x;
  int32/100000 y;
  int32/100000 z;
};

struct CommonObjectData {
  uint8 id;
  uint8 type;
  int32/100000 x;
  int32/100000 y;
  int32/100000 z;
  int32/100000 q1;
  int32/100000 q2;
  int32/100000 q3;
  int32/100000 q4;
  int32/100000 aVX;
  int32/100000 aVY;
  int32/100000 aVZ;
  int32/100000 lVX;
  int32/100000 lVY;
  int32/100000 lVZ;
};

dclass DistributedPhysicsWorld : DistributedObject {
  clientCommonObject(uint8 type, uint8 commonId, Coord3 pos, Coord3 hpr, int32/100 sizeX, int32/100 sizeY, int32/1000 moveDistance) broadcast ram;
  setCommonObjects(CommonObjectData objectData[]) broadcast;
  upSetCommonObjects(CommonObjectData objectData[]) airecv clsend;
};

dclass DistributedGolfHole : DistributedPhysicsWorld {
  setHoleId(int8 holeId) broadcast ram required;
  setTimingCycleLength(uint32/1000 time) broadcast ram required;
  setAvatarReadyHole() airecv clsend;
  setGolfCourseDoId(uint32 golfCourseDoId) broadcast ram required;
  turnDone() airecv clsend;
  ballInHole() airecv clsend;
  setAvatarTempTee(uint32 avId, uint8 tempTee) clsend broadcast;
  setTempAimHeading(uint32 avId, int32/1000 heading) clsend broadcast;
  setAvatarFinalTee(uint32 avId, uint8 finalTee) broadcast;
  setGolferIds(uint32 avIds[]) broadcast ram required;
  golfersTurn(uint32 avId) broadcast;
  golferChooseTee(uint32 avId) broadcast;
  setAvatarTee(uint8 tee) airecv clsend;
  postSwing(uint32/1000 todo0, int32 todo1, int32/1000 todo2, int32/1000 todo3, int32/1000 todo4, int32/1000 todo5, int32/1000 todo6) airecv clsend;
  postSwingState(uint32/1000 cycleTime, int32 power, int32/1000 bX, int32/1000 bY, int32/1000 bZ, int32/1000 x, int32/1000 y, uint16/100 aimTime, CommonObjectData cod[]) airecv clsend;
  swing(uint32 todo0, int32 todo1, int32/1000 todo2, int32/1000 todo3, int32/1000 todo4, int32/1000 todo5, int32/1000 todo6) broadcast;
  ballMovie2AI(uint32/1000 cycleTime, uint32 avId, golfData recording[], golfData aVRecording[], uint16 ballInHoleFrame, uint16 ballTouchedHoleFrame, uint16 ballFirstTouchedHoleFrame, CommonObjectData COD[]) airecv clsend;
  ballMovie2Client(uint32/1000 cycleTime, uint32 avId, golfData movie[], golfData spinMovie[], uint16 ballInFrame, uint16 ballTouchedHoleFrame, uint16 ballFirstTouchedHoleFrame, CommonObjectData commonObjectData[]) broadcast;
  assignRecordSwing(uint32 avId, uint32/1000 cycleTime, int32 power, int32/1000 x, int32/1000 y, int32/1000 z, int32/1000 dirX, int32/1000 dirY, CommonObjectData commonObjectData[]);
  setBox(int32/1000 todo0, int32/1000 todo1, int32/1000 todo2, int32/1000 todo3, int32/1000 todo4, int32/1000 todo5, int32/1000 todo6, int32/1000 todo7, int32/1000 todo8, int32/1000 todo9, int32/1000 todo10, int32/1000 todo11, int32/1000 todo12) airecv clsend;
  sendBox(int32/1000 pos0, int32/1000 pos1, int32/1000 pos2, int32/1000 quat0, int32/1000 quat1, int32/1000 quat2, int32/1000 quat3, int32/1000 anV0, int32/1000 anV1, int32/1000 anV2, int32/1000 lnV0, int32/1000 lnV1, int32/1000 lnV2) broadcast;
};

dclass DistributedGolfCourse : DistributedObject {
  setGolferIds(uint32 avIds[]) broadcast ram required;
  setCourseId(int8 courseId) broadcast ram required;
  setAvatarJoined() airecv clsend;
  setAvatarReadyCourse() airecv clsend;
  setAvatarReadyHole() airecv clsend;
  setAvatarExited() airecv clsend;
  setCurHoleIndex(int8 holeIndex) broadcast ram required;
  setCurHoleDoId(uint32 holeDoId) broadcast ram required;
  setDoneReward() airecv clsend;
  setReward(uint8[] [], int8[], uint8[] [], uint8[] [], uint8[] [], uint32, uint32/100, uint32/100, uint32/100, uint32/100) broadcast;
  setCourseReady(int8 numHoles, int16 holeIds[], int8 coursePar) broadcast;
  setHoleStart(int16 UNKNOWN) broadcast;
  setCourseExit() broadcast;
  setCourseAbort(uint32 avId) broadcast;
  setPlayHole() broadcast;
  avExited(uint32 avId) broadcast;
  setScores(int16 scoreList[]) broadcast;
  changeDrivePermission(uint32 avId, int8 canDrive) broadcast;
};

dclass DistributedVineGame : DistributedMinigame {
  reachedEndVine(int8 vineIndex) clsend airecv;
  setNewVine(uint32 avId, int8 vineIndex, uint32/10000 vineT, int8 facingRight) airecv clsend broadcast;
  setNewVineT(uint32 avId, uint32/10000 vineT, int8 climbDir) clsend broadcast;
  setJumpingFromVine(uint32 avId, int8 vineIndex, int8 facingRight, int32/100 posX, int16/100 posZ, int16/100 velX, int16 velZ) clsend broadcast;
  claimTreasure(uint32 treasureNum) airecv clsend;
  setTreasureGrabbed(uint32 avId, uint32 treasureNum) broadcast;
  setScore(uint32 avId, uint32 score) broadcast;
  allAtEndVine() broadcast;
  setFallingFromVine(uint32 avId, int8 vineIndex, int8 facingRight, int32/100 posX, int16/100 posZ, int16/100 velX, int16 velZ, int8 fallingInfo) clsend broadcast;
  setFallingFromMidair(uint32 avId, int8 facingRight, int32/100 posX, int16/100 posZ, int16/100 velX, int16 velZ, int8 fallingInfo) clsend broadcast;
  setVineSections(uint8 vineSections[]) required broadcast ram;
};

dclass TTAvatarFriendsManager : AvatarFriendsManager {
};

dclass TTPlayerFriendsManager : PlayerFriendsManager {
};

dclass TTSpeedchatRelay : SpeedchatRelay {
};

dclass DistributedGolfKart : DistributedObject {
  setState(string state, int16 timestamp) broadcast ram;
  fillSlot0(uint32 avId) broadcast ram;
  fillSlot1(uint32 avId) broadcast ram;
  fillSlot2(uint32 avId) broadcast ram;
  fillSlot3(uint32 avId) broadcast ram;
  emptySlot0(uint32 avId, int16 timestamp) broadcast ram;
  emptySlot1(uint32 avId, int16 timestamp) broadcast ram;
  emptySlot2(uint32 avId, int16 timestamp) broadcast ram;
  emptySlot3(uint32 avId, int16 timestamp) broadcast ram;
  requestBoard() airecv clsend;
  rejectBoard(uint32 avId);
  requestExit() airecv clsend;
  setMinigameZone(uint32 zoneId, uint16 minigameId);
  setGolfZone(uint32 zoneId, uint16 courseId);
  setGolfCourse(int8 golfCourse) required broadcast ram;
  setPosHpr(int16/10 x, int16/10 y, int16/10 z, int16/10 h, int16/10 p, int16/10 r) required broadcast ram;
  setColor(int16 r, int16 g, int16 b) required broadcast ram;
};

dclass DistributedTimer : DistributedObject {
  setStartTime(int32 time) broadcast ram required;
};

dclass DistributedPicnicBasket : DistributedObject {
  setState(string state, uint16 seed, int16 timestamp) broadcast ram;
  fillSlot0(uint32 avId) broadcast ram;
  fillSlot1(uint32 avId) broadcast ram;
  fillSlot2(uint32 avId) broadcast ram;
  fillSlot3(uint32 avId) broadcast ram;
  emptySlot0(uint32 avId, int16 timestamp) broadcast ram;
  emptySlot1(uint32 avId, int16 timestamp) broadcast ram;
  emptySlot2(uint32 avId, int16 timestamp) broadcast ram;
  emptySlot3(uint32 avId, int16 timestamp) broadcast ram;
  requestBoard(int16 todo0) airecv clsend;
  rejectBoard(uint32 avId);
  requestExit() airecv clsend;
  doneExit() airecv clsend;
  setMinigameZone(uint32 todo0, uint16 todo1);
  setPicnicDone();
  setPosHpr(int16/10 x, int16/10 y, int16/10 z, int16/10 h, int16/10 p, int16/10 r) required broadcast ram;
  setTableNumber(int16 tn) required broadcast ram;
};

dclass DistributedBossbotBoss : DistributedBossCog {
  setState(string state) broadcast ram;
  setBattleDifficulty(uint8 diff) broadcast ram;
  requestGetFood(int8 beltIndex, int8 foodIndex, uint32 foodNum) airecv clsend;
  toonGotFood(uint32 avId, int8 beltIndex, int8 foodIndex, uint32 foodNum) broadcast;
  requestServeFood(int8 tableIndex, int8 chairIndex) airecv clsend;
  toonServeFood(uint32 avId, int8 tableIndex, int8 chairIndex) broadcast;
  hitBoss(uint8 bossDamage) airecv clsend;
  hitToon(uint32 toonId) airecv clsend;
  ballHitBoss(uint8 bossDamage) airecv clsend;
  setBossDamage(uint16 bossDamage, uint8 recoverRate, int16 recoverStartTime) broadcast ram;
  setSpeedDamage(uint16 speedDamage, uint8 recoverRate, int16 timestamp) broadcast ram;
  reachedTable(uint8 tableIndex) airecv clsend;
  hitTable(uint8 tableIndex) airecv clsend;
  awayFromTable(uint8 tableIndex) airecv clsend;
  toonGotHealed(uint32 toonId) broadcast;
  requestGetToonup(int8 beltIndex, int8 toonupIndex, uint32 toonupNum) airecv clsend;
  toonGotToonup(uint32 avId, int8 beltIndex, int8 toonupIndex, uint32 toonupNum) broadcast;
};

dclass DistributedCogKart : DistributedElevatorExt {
  setCountryClubId(uint16 countryClubId) required broadcast ram;
  setPosHpr(int16/10 x, int16/10 y, int16/10 z, int16/10 h, int16/10 p, int16/10 r) required broadcast ram;
  setCountryClubInteriorZone(uint32 zoneId);
  setCountryClubInteriorZoneForce(uint32 zoneId);
};

dclass DistributedCountryClub : DistributedObject {
  setZoneId(uint32 zoneId) required broadcast ram;
  setBlockedRooms(uint8 blockedRooms[]) required broadcast ram;
  setCountryClubId(uint16 id) required broadcast ram;
  setLayoutIndex(uint16 layoutIndex) required broadcast ram;
  setFloorNum(uint8 num) required broadcast ram;
  setRoomDoIds(uint32 roomDoIds[]) broadcast ram;
  setCountryClubZone(uint32 zoneId) broadcast ram;
  elevatorAlert(uint32 avId) broadcast ram;
};

dclass DistributedCountryClubRoom : DistributedLevel {
  setCountryClubId(uint16 countryClubId) required broadcast ram;
  setRoomId(uint16 roomId) required broadcast ram;
  setRoomNum(uint8 num) required broadcast ram;
  setSuits(uint32 suitIds[], uint32 reserveSuitIds[]) broadcast ram;
  setBossConfronted(uint32 avId) broadcast ram;
  setDefeated() broadcast ram;
  forceOuch(uint8 penalty) broadcast;
};

dclass DistributedMoleField : DistributedEntity {
  setGameStart(int16 timestamp, uint8 molesWhackTarget, uint16 totalTime) broadcast;
  setClientTriggered() airecv clsend;
  whackedMole(int8 moleIndex, int16 popupNum) airecv clsend;
  whackedBomb(int8 moleIndex, int16 popupNum, int32 timestamp) airecv clsend;
  updateMole(int8 moleIndex, int8 status) broadcast;
  reportToonHitByBomb(uint32 avId, int8 moleIndex, int32 timestamp) broadcast;
  setScore(int16 score) required broadcast ram;
  damageMe() airecv clsend;
  setPityWin() broadcast;
};

dclass DistributedCountryClubBattle : DistributedLevelBattle {
};

dclass DistributedClubElevator : DistributedElevatorFSM {
  setFloor(int8 floorNumber) broadcast ram;
  setLocked(uint16 locked) required broadcast ram;
  setEntering(uint16 entering) required broadcast ram;
  kickToonsOut() broadcast;
  setLatch(uint32 markerId) required broadcast ram;
};

dclass DistributedMaze : DistributedEntity {
  setRoomDoId(uint32 roomDoId) required broadcast ram;
  setGameStart(int16 timestamp) broadcast;
  setClientTriggered() airecv clsend;
  setFinishedMaze() airecv clsend;
  setGameOver() broadcast;
  toonFinished(uint32 avId, uint8 place, uint8 lastToon) broadcast;
  damageMe() airecv clsend;
};

dclass DistributedBattleWaiters : DistributedBattleFinal {
};

dclass DistributedFoodBelt : DistributedObject {
  setBossCogId(uint32 bossCogId) required broadcast ram;
  setIndex(uint8 index) required broadcast ram;
  setState(char state) broadcast ram;
};

dclass DistributedBanquetTable : DistributedObject {
  setIndex(uint8 index) required broadcast ram;
  setNumDiners(uint8 numDiners) required broadcast ram;
  setBossCogId(uint32 bossCogId) required broadcast ram;
  setDinerInfo(uint8 hungryDurations[], uint8 eatingDurations[], uint8 dinerLevels[]) required broadcast ram;
  setState(char state, uint32 avId, int8 extraInfo) broadcast ram;
  setDinerStatus(uint8 chairIndex, uint8 status) broadcast;
  requestControl() airecv clsend;
  requestFree(int8 gotHitByBoss) airecv clsend;
  setPitcherPos(uint8 changeSeq, uint16%360/100 h, int16 timestamp) broadcast clsend;
  clearSmoothing(int8 bogus) broadcast clsend;
  firingWater(int32/100 startX, int32/100 startY, int32/100 startZ, int32/100 endX, int32/100 endY, int32/100 endZ) broadcast clsend;
  waterHitBoss(uint8 tableIndex) broadcast clsend;
};

dclass DistributedBattleDiners : DistributedBattleFinal {
};

dclass DistributedGolfSpot : DistributedObject {
  setIndex(uint8 index) required broadcast ram;
  setBossCogId(uint32 bossCogId) required broadcast ram;
  setState(char state, uint32 avId, int8 extraInfo) broadcast ram;
  setGoingToReward() broadcast ram;
  requestControl() airecv clsend;
  requestFree(int8 gotHitByBoss) airecv clsend;
  setGolfSpotPos(uint8 changeSeq, uint16%360/100 h, int16 timestamp) broadcast clsend;
  clearSmoothing(int8 bogus) broadcast clsend;
  setSwingInfo(uint8 power, int16/10 angle, uint8 sequenceNum) broadcast clsend;
};

struct TireInput {
  int32/100 force;
  int32/100 heading;
};

dclass DistributedIceGame : DistributedMinigame {
  setForceArrowInfo(uint32 avId, int32/100 force, int32/100 heading) broadcast clsend;
  setAvatarChoice(int32/100 force, int32/100 direction) airecv clsend;
  endingPositions(Coord3 positions[]) airecv clsend;
  reportScoringMovieDone() airecv clsend;
  claimTreasure(uint8 treasureNum) airecv clsend;
  claimPenalty(uint8 penaltyNum) airecv clsend;
  setTireInputs(TireInput tireInputs[]) broadcast;
  setTimerStartTime(int16 timestamp) broadcast;
  setFinalPositions(Coord3 finalPos[]) broadcast;
  setMatchAndRound(int8 match, int8 round) broadcast;
  setScores(int8 match, int8 round, int16 scores[]) broadcast;
  setNewState(string state) broadcast;
  setTreasureGrabbed(uint32 avId, uint32 treasureNum) broadcast;
  setPenaltyGrabbed(uint32 avId, uint32 penaltyNum) broadcast;
};

dclass DistributedCogThiefGame : DistributedMinigame {
  throwingPie(uint32 avId, int32 timestamp, int32/100 heading, int32/100 x, int32/100 y, int32/100 z) clsend broadcast;
  hitBySuit(uint32 avId, int32 timestamp, int8 suitNum, int32/100 x, int32/100 y, int32/100 z) clsend broadcast airecv;
  pieHitSuit(uint32 avId, int32 timestamp, int8 suitNum, int32/100 x, int32/100 y, int32/100 z) clsend broadcast airecv;
  cogHitBarrel(int32 clientStamp, int8 cogIndex, int8 barrelIndex, int32/100 x, int32/100 y, int32/100 z) clsend airecv;
  cogAtReturnPos(int32 clientstamp, int8 cogIndex, int8 barrelIndex) clsend airecv;
  updateSuitGoal(int32 timestamp, int32 inResponseToClientStamp, int8 suitNum, int8 goalType, int64 goalId, int32/100 x, int32/100 y, int32/100 z) broadcast;
  makeCogCarryBarrel(int32 timestamp, int32 inResponseToClientStamp, int8 cogIndex, int8 barrelIndex, int32/100 x, int32/100 y, int32/100 z) broadcast;
  makeCogDropBarrel(int32 timestamp, int32 inResponseToClientStamp, int8 cogIndex, int8 barrelIndex, int32/100 x, int32/100 y, int32/100 z) broadcast;
  markBarrelStolen(int32 timestamp, int32 inResponseToClientStamp, int8 barrelIndex) broadcast;
};

struct twoDTreasureInfo {
  uint8 treasureIndex;
  uint8 treasureValue;
};

struct twoDSectionInfo {
  uint8 sectionIndex;
  uint8 enemyIndicesSelected[];
  twoDTreasureInfo treasureIndicesSelected[];
  uint8 spawnPointIndicesSelected[];
  uint8 stomperIndicesSelected[];
};

dclass DistributedTwoDGame : DistributedMinigame {
  showShootGun(uint32 avId, int16 timestamp) clsend broadcast;
  toonHitByEnemy(uint32 avId, int16 timestamp) clsend broadcast airecv;
  toonFellDown(uint32 avId, int16 timestamp) clsend broadcast airecv;
  toonSquished(uint32 avId, int16 timestamp) clsend broadcast airecv;
  toonVictory(uint32 avId, int16 timestamp) clsend broadcast airecv;
  claimTreasure(uint8 sectionIndex, uint8 treasureIndex) airecv clsend;
  claimEnemyShot(uint8 sectionIndex, uint8 enemyIndex) airecv clsend;
  reportDone() airecv clsend;
  setSectionsSelected(twoDSectionInfo sectionsSelected[]) required broadcast ram;
  setTreasureGrabbed(uint32 avId, uint8 sectionIndex, uint8 treasureIndex) broadcast;
  setEnemyShot(uint32 avId, uint8 sectionIndex, uint8 enemyIndex, uint32 enemyHealth) broadcast;
  addVictoryScore(uint32 avId, uint8 score) broadcast;
  setEveryoneDone() broadcast;
};

dclass DistributedPicnicTable : DistributedNode {
  fillSlot(uint32 avId, uint8 index, int16/10 x, int16/10 y, int16/10 z, int16/10 h, int16/10 p, int16/10 r, int16 timestamp, uint32 parentDoId) broadcast;
  emptySlot(uint32 avId, uint8 index, int16 timestamp) broadcast;
  requestTableState() airecv clsend;
  setTableState(uint32 tableStateList[], uint8 isplaying) broadcast ram;
  setGameZone(uint32 zoneId, uint8 gamestate) broadcast;
  setIsPlaying(uint8 isPlaying) broadcast ram;
  requestJoin(uint8 todo0, int16/10 todo1, int16/10 todo2, int16/10 todo3, int16/10 todo4, int16/10 todo5, int16/10 todo6) airecv clsend;
  rejectJoin() broadcast;
  requestObserve() airecv clsend;
  leaveObserve() airecv clsend;
  requestGameZone() airecv clsend;
  requestPickedGame(uint8 todo0) clsend airecv;
  requestExit() airecv clsend;
  requestZone() clsend airecv;
  announceWinner(string winString, uint32 avId) broadcast;
  allowObserve() broadcast;
  allowPick() broadcast;
  setZone(uint32 zoneId) broadcast;
};

dclass DistributedChineseCheckers : DistributedNode {
  requestExit() clsend airecv;
  requestBegin() clsend airecv;
  requestMove(uint8 todo0[]) clsend airecv;
  requestTimer() clsend airecv;
  requestSeatPositions() clsend airecv;
  startBeginTimer(uint16 todo0, int16 todo1) broadcast ram;
  gameStart(uint8 playerNum) broadcast;
  setTableDoId(uint32 doId) required broadcast ram;
  setGameState(uint8 tableState[], uint8 moveList[]) required broadcast ram;
  setTimer(int16 timerEnd) broadcast ram required;
  setTurnTimer(int16 turnEnd) broadcast ram required;
  sendTurn(uint8 playersTurn) broadcast ram;
  requestWin() clsend airecv;
  announceWin(uint32 avId) broadcast;
  announceSeatPositions(uint8 playerPos[]) broadcast;
};

dclass DistributedCheckers : DistributedNode {
  requestExit() clsend airecv;
  requestBegin() clsend airecv;
  requestTimer() clsend airecv;
  requestMove(uint8 todo0[]) clsend airecv;
  startBeginTimer(uint16 todo0, int16 todo1) broadcast ram;
  gameStart(uint8 playerNum) broadcast;
  setTableDoId(uint32 doId) required broadcast ram;
  setGameState(uint8 tableState[], uint8 moveList[]) required broadcast ram;
  setTimer(int16 timerEnd) broadcast ram required;
  setTurnTimer(int16 turnEnd) broadcast ram required;
  sendTurn(uint8 playersTurn) broadcast ram;
  requestWin() clsend airecv;
  announceWin(uint32 avId) broadcast;
  illegalMove() broadcast;
};

dclass DistributedFindFour : DistributedNode {
  requestExit() clsend airecv;
  requestBegin() clsend airecv;
  requestMove(uint8 todo0) clsend airecv;
  requestTimer() clsend airecv;
  requestWin(uint8 todo0[]) clsend airecv;
  startBeginTimer(uint16 todo0, int16 todo1) broadcast ram;
  setTableDoId(uint32 doId) required broadcast ram;
  setGameState(uint8 tableState[][], uint8 moveCol, uint8 movePos, uint8 turn) required broadcast ram;
  setTimer(int16 timerEnd) broadcast ram required;
  setTurnTimer(int16 turnEnd) broadcast ram required;
  gameStart(uint8 playerNum) broadcast;
  sendTurn(uint8 playersTurn) broadcast ram;
  announceWin(uint32 avId) broadcast;
  announceWinLocation(uint8 todo0, uint8 todo1, uint8 todo2, uint8 todo3) broadcast;
  announceWinnerPosition(uint8 x, uint8 y, uint8 winDirection, uint8 playerNum) broadcast;
  illegalMove() broadcast;
  tie() broadcast;
};

dclass DistributedMailManager : DistributedObject {
  sendSimpleMail(uint32 todo0, uint32 todo1, string todo2);
  setNumMailItems(uint32 todo0, uint32 todo1) airecv;
};

dclass DistributedPartyManager : DistributedObject {
  addParty(uint32 todo0, uint32 todo1, string todo2, string todo3, int8 todo4, int8 todo5, activity todo6[], decoration todo7[], uint32 todo8[], uint16 todo9);
  addPartyRequest(uint32 hostId, char startTime[0-256], char endTime[0-256], int8 isPrivate, int8 inviteTheme, activity activities[], decoration decorations[], uint32 inviteeIds[]) airecv clsend;
  addPartyResponse(uint32 hostId, int8 errorCode);
  addPartyResponseUdToAi(uint64 partyId, int8 errorCode, party partyStruct) airecv;

  markInviteAsReadButNotReplied(uint32 todo0, uint64 todo1);
  respondToInvite(uint32 todo0, uint32 todo1, uint16 todo2, uint64 todo3, uint8 todo4);
  respondToInviteResponse(uint32 todo0, uint16 todo1, uint64 todo2, int8 todo3, uint8 todo4) airecv;

  changePrivateRequest(uint64 todo0, int8 todo1) airecv clsend;
  changePrivateRequestAiToUd(uint32 todo0, uint64 todo1, int8 todo2);
  changePrivateResponseUdToAi(uint32 todo0, uint64 todo1, int8 todo2, int8 todo3) airecv;
  changePrivateResponse(uint64 partyId, int8 newPrivateStatus, int8 errorCode);

  changePartyStatusRequest(uint64 partyId, int8 newPartyStatus) airecv clsend;
  changePartyStatusRequestAiToUd(uint32 todo0, uint64 todo1, int8 todo2);
  changePartyStatusResponseUdToAi(uint32 todo0, uint64 todo1, int8 todo2, int8 todo3) airecv;
  changePartyStatusResponse(uint64 partyId, int8 newPartyStatus, int8 errorCode, uint16 beansRefunded);

  partyInfoOfHostRequestAiToUd(uint32 todo0, uint32 todo1);
  partyInfoOfHostFailedResponseUdToAi(uint32 todo0) airecv;
  partyInfoOfHostResponseUdToAi(party partyStruct, uint32 inviteeIds[]) airecv;

  givePartyRefundResponse(uint32 todo0, uint64 todo1, int8 todo2, uint16 todo3, uint32 todo4);
  getPartyZone(uint32 hostId, uint32 zoneId, uint8 isAvAboutToPlanParty) clsend airecv;
  receivePartyZone(uint32 hostId, uint64 partyId, uint32 zoneId);
  freeZoneIdFromPlannedParty(uint32 hostId, uint32 zoneId) clsend airecv;

  sendAvToPlayground(uint32 avId, uint8 retCode);
  exitParty(uint32 partyZone) clsend airecv;
  removeGuest(uint32 ownerId, uint32 avId) airecv clsend;
  partyManagerAIStartingUp(uint32 todo0, uint32 todo1);
  partyManagerAIGoingDown(uint32 todo0, uint32 todo1);
  partyHasStartedAiToUd(uint64 partyId, uint32 shardId, uint32 zoneId, string hostName);
  toonHasEnteredPartyAiToUd(uint32 todo0);
  toonHasExitedPartyAiToUd(uint32 todo0);
  partyHasFinishedUdToAllAi(uint64 partyId) airecv;
  updateToPublicPartyInfoUdToAllAi(uint32 shardId, uint32 zoneId, uint64 partyId, uint32 hostId, uint8 numGuests, uint8 maxGuests, string hostName, uint8 activities[], uint8 minLeft) airecv;
  updateToPublicPartyCountUdToAllAi(uint32 partyCount, uint64 partyId) airecv;
  requestShardIdZoneIdForHostId(uint32 todo0) clsend airecv;
  sendShardIdZoneIdToAvatar(uint32 shardId, uint32 zoneId);
  partyManagerUdStartingUp() airecv;
  partyManagerUdLost() airecv;
  updateAllPartyInfoToUd(uint32 todo0, uint64 todo1, uint32 todo2, uint32 todo3, uint8 todo4, uint8 todo5, string todo6, uint8 todo7[], uint64 todo8);
  forceCheckStart();
  requestMw(uint32 todo0, string todo1, uint32 todo2, uint32 todo3);
  mwResponseUdToAllAi(uint32 todo0, string todo1, uint32 todo2, uint32 todo3) airecv;
  receiveId(uint64 ids[]) airecv;
};

dclass DistributedObjectGlobal : DistributedObject {
};

dclass GlobalPartyManager : DistributedObjectGlobal {
    partyManagerAIHello(uint32 channel);
    queryParty(uint32 hostId);
    addParty(DoId avId, uint64 partyId, string start, string end, int8 isPrivate,
             int8 inviteTheme, activity activities[], decoration decorations[], DoIdList inviteeIds);
    partyHasStarted(uint64 partyId, uint32 shardId, uint32 zoneId, string hostName);
    toonJoinedParty(uint64 partyId, uint32 avId);
    toonLeftParty(uint64 partyId, uint32 avId);
    requestPartySlot(uint64 partyId, uint32 avId, uint32 gateId);
    partyDone(uint64 partyId);
    allocIds(uint16 count);
    avatarJoined(uint32 avId);
};

struct PotentialToon {
  uint32 avNum;
  string avName;
  string avDNA;
  uint8 avPosition;
  uint8 aname;
};

dclass ClientServicesManager : DistributedObjectGlobal {
  login(string cookie, blob sig) clsend;
  acceptLogin();

  requestAvatars() clsend;
  setAvatars(PotentialToon avatars[]);

  createAvatar(blob dna, uint8 index) clsend;
  createAvatarResp(uint32 avId);

  setNameTyped(uint32 avId, string name) clsend;
  setNameTypedResp(uint32 avId, uint8 status);
  setNamePattern(uint32 avId, int16 p1, uint8 f1, int16 p2, uint8 f2, int16 p3, uint8 f3, int16 p4, uint8 f4) clsend;
  setNamePatternResp(uint32 avId, uint8 status);

  acknowledgeAvatarName(uint32 avId) clsend;
  acknowledgeAvatarNameResp();

  deleteAvatar(uint32 avId) clsend;

  chooseAvatar(uint32 avId) clsend;

  systemMessage(uint16 code, string params[]);

  reportPlayer(uint32 avId, uint8 category) clsend;
};

dclass RATManager : DistributedObjectGlobal {
};

dclass AwardManager : DistributedObjectGlobal {
  giveAwardToToon(uint32 todo0, DoId todo1, string todo2, DoId todo3, uint32 todo4, uint32 todo5);
};

dclass DistributedCpuInfoMgr : DistributedObjectGlobal {
  setCpuInfoToUd(uint32 todo0, uint32 todo1, string todo2, string todo3);
};

dclass DistributedSecurityMgr : DistributedObjectGlobal {
  requestAccountId(uint32 todo0, uint32 todo1, uint32 todo2);
  requestAccountIdResponse(uint32 todo0, uint32 todo1) airecv;
};

dclass NonRepeatableRandomSourceClient {
  getRandomSamplesReply(uint32, uint32 []) airecv;
};

dclass TTCodeRedemptionMgr : DistributedObject, NonRepeatableRandomSourceClient {
  giveAwardToToonResult(uint32 todo0, uint32 todo1);
  redeemCode(uint32 code, char callback[0-256]) airecv clsend;
  redeemCodeAiToUd(uint32 todo0, DoId todo1, uint32 todo2, string todo3, uint32 todo4);
  redeemCodeResultUdToAi(uint32 todo0, uint32 todo1, uint32 todo2, uint32 todo3, uint32 todo4) airecv;
  redeemCodeResult(uint32 context, uint32 result, uint32 awardMgrResult);
};

dclass NonRepeatableRandomSource : DistributedObject, NonRepeatableRandomSourceClient {
  getRandomSamples(DoId callback, string num, uint32 context, uint32);
  randomSample(DoId nrrsDoId, uint32 random);
  randomSampleAck() airecv;
};

dclass DistributedInGameNewsMgr : DistributedObjectGlobal {
  setLatestIssueStr(string issueStr) required broadcast ram;
  inGameNewsMgrAIStartingUp(uint32 todo0, uint32 todo1);
  newIssueUDtoAI(string todo0) airecv;
};

dclass DistributedWhitelistMgr : DistributedObjectGlobal {
  updateWhitelist() broadcast;
  whitelistMgrAIStartingUp(uint32 todo0, uint32 todo1);
  newListUDtoAI() airecv;
};

struct Friend
{
uint32 doId;
string name;
blob dna;
uint32 petId;
};

dclass TTRFriendsManager : DistributedObjectGlobal {
  clearList(uint32 avId);
  removeFriend(uint32 avId) clsend;
  requestAvatarInfo(uint32 avIds[]) clsend;

  requestFriendsList() clsend;

  friendInfo(Friend resp);
  friendList(Friend resp[]);

  friendOnline(uint32 id, uint8 commonChatFlags, uint8 whitelistChatFlags);
  friendOffline(uint32 id);

  comingOnline(uint32 avId, uint32 friendIds[]);
  goingOffline(uint32 avId);

  getAvatarDetails(uint32 friendId) clsend;
  friendDetails(uint32 friendId, blob details);
};


dclass DistributedPhaseEventMgr : DistributedObject {
  setNumPhases(uint8 numPhases) required broadcast ram;
  setDates(datetime holidayDates[]) broadcast required;
  setCurPhase(int8 curPhase) required broadcast ram;
  setIsRunning(bool isRunning) required broadcast ram;
};

dclass DistributedHydrantZeroMgr : DistributedPhaseEventMgr {
};

dclass DistributedMailboxZeroMgr : DistributedPhaseEventMgr {
};

dclass DistributedTrashcanZeroMgr : DistributedPhaseEventMgr {
};

dclass DistributedSillyMeterMgr : DistributedPhaseEventMgr {
};

dclass ARGManager : DistributedObjectGlobal {
};