Poodletooth-iLand/astron/dclass/otp.dc

from direct.distributed import DistributedObject/AI/UD
from direct.distributed import DistributedNode/AI/UD
from direct.distributed import DistributedSmoothNode/AI
from direct.distributed import DistributedCartesianGrid/AI
from direct.distributed import DistributedCamera/AI/OV
from otp.distributed import Account/AI/UD
from otp.ai import TimeManager/AI
from otp.ai import MagicWordManager/AI
from otp.avatar import DistributedAvatar/AI/UD
from otp.avatar import DistributedPlayer/AI
from otp.friends import FriendManager/AI
from otp.friends import AvatarFriendsManager/UD
from otp.friends import PlayerFriendsManager/UD
from otp.friends import GuildManager/AI/UD
from otp.friends import FriendInfo
from otp.friends import AvatarFriendInfo
from otp.distributed import ObjectServer/AI/UD
from otp.distributed import DistributedDistrict/AI/UD
from otp.distributed import DistributedDirectory/AI
from otp.distributed import DistributedTestObject/AI
from otp.chat import ChatAgent/UD
from otp.distributed import CentralLogger/AI/UD
from otp.avatar import AvatarHandle

typedef uint8 bool;

typedef uint32 DoId;

typedef DoId DoIdList[];

struct AvatarPendingDel {
  uint32 Avatar;
  uint32 date;
};

dclass Account {
  string DcObjectType db;
  uint32 ACCOUNT_AV_SET[] required db;
  uint32 ESTATE_ID db;
  AvatarPendingDel ACCOUNT_AV_SET_DEL[] db;
  string CREATED db;
  string LAST_LOGIN db;
  string ACCOUNT_ID db;
  uint16 ACCESS_LEVEL db;
  uint32 MONEY db;
};

struct BarrierData {
  uint16 context;
  string name;
  DoIdList avIds;
};

dclass DistributedObject {
  setBarrierData(BarrierData []) broadcast ram;
  setBarrierReady(uint16 barrierContext) airecv clsend;
  execCommand(string command, DoId magicWordMgr,
              DoId avatar, uint32 zoneId);
  broadcastMessage() broadcast;
};

dclass DistributedTestObject : DistributedObject {
  uint32 AutoInterest[];
  setParentingRules(string, string) broadcast ram;
  setRequiredField(uint32) required broadcast ram;
  setB(uint32) broadcast;
  setBA(uint32) broadcast airecv;
  setBO(uint32) broadcast ownsend;
  setBR(uint32) broadcast ram;
  setBRA(uint32) broadcast ram airecv;
  setBRO(uint32) broadcast ram ownsend;
  setBROA(uint32) broadcast ram ownsend airecv;
};

struct OSInfo {
  string name;
  int16 platform;
  int16 major;
  int16 minor;
};

struct CPUSpeed {
  int32/1000 maxSpeed;
  int32/1000 currentSpeed;
};

dclass TimeManager : DistributedObject {
  requestServerTime(uint8 context) airecv clsend;
  serverTime(uint8 context, int32 timestap, uint32 timeOfDay);
  setDisconnectReason(uint8) airecv clsend;
  setExceptionInfo(string(0-1024)) airecv clsend;
  setSignature(string(0-1024) signature, char prcHash[16],
               char pycHash[16]) airecv clsend;
  setFrameRate(uint16/10 fps, uint16/1000 deviation, uint16 numAvatars,
               string(0-256) locationCode, uint32/10 timeInLocation,
               uint32/10 timeInGame, string(0-256) gameOptionsCode,
               uint16 vendorId, uint16 deviceId, uint32/10 processMemory,
               uint32/10 pageFileUsage, uint32/10 physicalMemory,
               uint32 pageFaultCount, OSInfo, CPUSpeed, uint16 cpuCores,
               uint16 logicalCPUs, string(0-256) apiName) airecv clsend;
  setCpuInfo(string(0-1024) infoStr, string cacheStatus) airecv clsend;
  checkForGarbageLeaks(bool) airecv clsend;
  setNumAIGarbageLeaks(uint32);
  setClientGarbageLeak(uint32, string(0-1024)) airecv clsend;
  checkAvOnDistrict(uint32 context, DoId avatar) clsend airecv;
  checkAvOnDistrictResult(uint32 context, DoId av, bool isOnDistrict);
};

dclass ObjectServer {
  setName(string) airecv ram required;
  setDcHash(uint32) ram required;
  setDateCreated(uint32) airecv;
};

dclass DistributedDirectory : DistributedObject {
  setParentingRules(string, string) broadcast ram;
};

dclass DistributedDistrict : DistributedObject {
  setName(string) required broadcast ram;
  setAvailable(uint8) required broadcast ram;
};

dclass DistributedNode : DistributedObject {
  setParentStr(blob) broadcast ram ownsend airecv;
  setParent(uint32) broadcast ram ownsend airecv;
  setX(int16/10) broadcast ram ownsend airecv;
  setY(int16/10) broadcast ram ownsend airecv;
  setZ(int16/10) broadcast ram ownsend airecv;
  setH(int16%360/10) broadcast ram ownsend airecv;
  setP(int16%360/10) broadcast ram ownsend airecv;
  setR(int16%360/10) broadcast ram ownsend 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;
};

dclass DistributedSmoothNode : DistributedNode {
  setComponentL(uint64) broadcast ram ownsend airecv;
  setComponentX(int16/10) broadcast ram ownsend airecv;
  setComponentY(int16/10) broadcast ram ownsend airecv;
  setComponentZ(int16/10) broadcast ram ownsend airecv;
  setComponentH(int16%360/10) broadcast ram ownsend airecv;
  setComponentP(int16%360/10) broadcast ram ownsend airecv;
  setComponentR(int16%360/10) broadcast ram ownsend airecv;
  setComponentT(int16) broadcast ram ownsend 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 ownsend;
  suggestResync(uint32, int16, int16, int32, uint16, uint16/100) ownrecv clsend;
  returnResync(uint32, int16, int32, uint16, uint16/100) ownrecv clsend;
};

dclass DistributedCartesianGrid : DistributedNode {
  setCellWidth(uint32) required broadcast ram;
  setParentingRules(string, string) broadcast ram;
};

struct Fixture {
  int32/10 x;
  int32/10 y;
  int32/10 z;
  int16/10 h;
  int16/10 p;
  int16/10 r;
  string state;
};

dclass DistributedCamera : DistributedNode {
  setCamParent(uint32) required broadcast ram ownsend airecv;
  setFixtures(Fixture []) required broadcast ram ownsend airecv;
};

struct TalkModification {
  uint16 offset;
  uint16 size;
};

dclass TalkPath_owner {
  setTalk(DoId fromAv, DoId fromAcc, string(0-256) avName,
          string(0-400) chat, TalkModification [], uint8 flags) broadcast ownsend;
};

dclass TalkPath_whisper {
  setTalkWhisper(DoId fromAv, DoId fromAcc, string(0-256) avName,
                 string(0-400) chat, TalkModification [], uint8 flags) ownrecv clsend;
};

dclass TalkPath_group {
  setTalkGroup(DoId fromAv, DoId fromAcc, string(0-256) avName,
               string(0-400) chat, TalkModification [], uint8 flags) clsend airecv;
};

dclass TalkPath_account {
  setTalkAccount(DoId toAcc, DoId fromAcc, string(0-256) avName,
                 string(0-400) msg, TalkModification [], uint8 flags) airecv clsend;
};

dclass AvatarHandle : TalkPath_whisper {
};

dclass DistributedAvatar : DistributedSmoothNode, TalkPath_whisper {
  string DcObjectType db;
  setName(string = "[Name not set]") required broadcast db airecv;
  friendsNotify(DoId avId, int8 status) ownrecv airecv;
  checkAvOnShard(DoId) clsend airecv;
  confirmAvOnShard(DoId avId, int8 isOnShard);
  setTalk(DoId fromAv, DoId fromAcc, string(0-256) avName,
          string(0-400) chat, TalkModification [], uint8 flags) broadcast;
};

struct FriendEntry {
  uint32 friendId;
  uint8 friendType;
}

dclass DistributedPlayer : DistributedAvatar {
  arrivedOnDistrict(DoId districtId) ownrecv ram;
  setAccountName(string name = "") required ownrecv db;
  setWhisperSCFrom(DoId fromAv, uint16 msgIndex) ownrecv clsend;
  setWhisperSCCustomFrom(DoId fromAv, uint16 msgIndex) ownrecv clsend;
  setWhisperSCEmoteFrom(DoId fromAv, uint16 emoteId) ownrecv clsend;
  setSystemMessage(DoId aboutId, string(0-256) chatString) ownrecv;
  setCommonChatFlags(uint8) broadcast ownrecv ram airecv;
  setWhitelistChatFlags(uint8) broadcast ownrecv ram airecv;
  setSC(uint16 msgIndex) broadcast ownsend airecv;
  setSCCustom(uint16 msgIndex) broadcast ownsend airecv;
  setFriendsList(FriendEntry[] = []) ownrecv required db airecv;
  setDISLname(string) broadcast ownrecv ram;
  setDISLid(uint32 = 0) broadcast ownrecv ram db airecv required;
  OwningAccount(DoId);
  WishName(string = "") db ram;
  WishNameState(string = "OPEN") db ram;
  setPreviousAccess(uint8 = 0) required db airecv;
  setAccess(uint8 = 2) broadcast ownrecv required ram airecv;
  setAdminAccess(uint16 = 0) broadcast ownrecv required airecv;
  setAsGM(bool = 0) required ram broadcast ownrecv airecv;
};

dclass MagicWordManager : DistributedObject {
  sendMagicWord(string, uint32) airecv clsend;
  sendMagicWordResponse(string);
};

dclass ChatAgent : DistributedObject {
  adminChat(uint32, string);
  chatMessage(string(0-256)) clsend;
};

dclass FriendManager : DistributedObject {
  friendQuery(int32) airecv clsend;
  cancelFriendQuery(int32) airecv clsend;
  inviteeFriendConsidering(int8, int32) airecv clsend;
  inviteeFriendResponse(int8, int32) airecv clsend;
  inviteeAcknowledgeCancel(int32) airecv clsend;
  friendConsidering(int8, int32);
  friendResponse(int8, int32);
  inviteeFriendQuery(int32, string, blob, int32);
  inviteeCancelFriendQuery(int32);
  requestSecret() airecv clsend;
  requestSecretResponse(int8, string);
  submitSecret(string(0-256)) airecv clsend;
  submitSecretResponse(int8, int32);
};

struct FriendInfo {
  string avatarName;
  uint32 avatarId;
  string playerName;
  uint8 onlineYesNo;
  uint8 openChatEnabledYesNo;
  uint8 openChatFriendshipYesNo;
  uint8 wlChatEnabledYesNo;
  string location;
  string sublocation;
  uint32 timestamp;
};

struct AvatarFriendInfo {
  string avatarName;
  string playerName;
  uint32 playerId;
  uint8 onlineYesNo;
  uint8 openChatEnabledYesNo;
  uint8 openChatFriendshipYesNo;
  uint8 wlChatEnabledYesNo;
};

struct MemberInfo {
  uint32 avatarId;
  string avatarName;
  uint8 avatarRank;
  uint8 avatarOnline;
  uint32 bandManagerId;
  uint32 bandId;
};

struct leaderBoardRecordResponces {
  char found;
  uint32 id;
  string text;
  int32 value;
};

struct leaderBoardRecord {
  uint32 id;
  string text;
  int32 value;
};

dclass LeaderBoardReceiver {
  getTopTenResponce(string, leaderBoardRecord []);
  getValuesResponce(string, leaderBoardRecordResponces []);
};

dclass LeaderBoard : LeaderBoardReceiver {
  setValue(string [], uint32, string, int32);
  alterValue(string [], uint32, string, int32);
  setHighScore(string [], uint32, string, int32);
  getValues(string, uint32 []);
  getTopTen(string);
  getValuesRespondTo(string, uint32 [], uint32);
  getTopTenRespondTo(string, uint32);
};

dclass GuildManager : DistributedObject, LeaderBoardReceiver, TalkPath_group {
  online();
  guildRejectInvite(uint32, uint32);
  invitationFrom(uint32, string, uint32, string);
  requestInvite(uint32) airecv clsend;
  memberList() airecv clsend;
  createGuild() airecv clsend;
  acceptInvite() airecv clsend;
  declineInvite() airecv clsend;
  setWantName(string(0-256)) airecv clsend;
  removeMember(uint32) airecv clsend;
  changeRank(uint32, uint8) airecv clsend;
  changeRankAvocate(uint32) airecv clsend;
  statusRequest() airecv clsend;
  requestLeaderboardTopTen() airecv clsend;
  guildStatusUpdate(uint32, string(0-256), uint8);
  guildNameReject(uint32);
  guildNameChange(string, uint8);
  receiveMember(MemberInfo);
  receiveMembersDone();
  guildAcceptInvite(uint32);
  guildDeclineInvite(uint32);
  updateRep(uint32, uint32);
  leaderboardTopTen(leaderBoardRecord []);
  recvAvatarOnline(uint32, string, uint32, uint32);
  recvAvatarOffline(uint32, string);
  sendChat(string(0-256), uint8, uint32) airecv clsend;
  sendWLChat(string(0-256), uint8, uint32) airecv clsend;
  sendSC(uint16) airecv clsend;
  sendSCQuest(uint16, uint16, uint16) airecv clsend;
  recvChat(uint32, string, uint8, uint32);
  recvWLChat(uint32, string, uint8, uint32);
  recvSC(uint32, uint16);
  recvSCQuest(uint32, uint16, uint16, uint16);
  sendTokenRequest() airecv clsend;
  recvTokenGenerated(string);
  recvTokenInviteValue(string, int8);
  sendTokenForJoinRequest(string(0-256), string(0-256)) airecv clsend;
  recvTokenRedeemMessage(string);
  recvTokenRedeemedByPlayerMessage(string);
  sendTokenRValue(string(0-256), int8) airecv clsend;
  sendPermToken() airecv clsend;
  sendNonPermTokenCount() airecv clsend;
  recvPermToken(string);
  recvNonPermTokenCount(uint8);
  sendClearTokens(uint8) airecv clsend;
  sendAvatarBandId(uint32, uint32, uint32);
  recvMemberAdded(MemberInfo, uint32, string);
  notifyGuildKicksMaxed();
  recvMemberRemoved(uint32, uint32, string, string);
  recvMemberUpdateName(uint32, string);
  recvMemberUpdateRank(uint32, uint32, string, string, uint8, bool);
  recvMemberUpdateBandId(uint32, uint32, uint32);
  avatarOnline(uint32, uint16);
  avatarOffline(uint32);
  reflectTeleportQuery(uint32, uint32, uint32, uint32, uint32) clsend airecv;
  teleportQuery(uint32, uint32, uint32, uint32, uint32);
  reflectTeleportResponse(uint32, int8, uint32, uint32, uint32) clsend airecv;
  teleportResponse(uint32, int8, uint32, uint32, uint32);
  requestGuildMatesList(uint32, uint32, uint32);
  updateAvatarName(uint32, string);
  avatarDeleted(uint32);
};

dclass AvatarFriendsManager : DistributedObject {
  online();
  requestInvite(uint32) airecv clsend;
  friendConsidering(uint32) airecv clsend;
  invitationFrom(uint32, string);
  retractInvite(uint32);
  rejectInvite(uint32, uint32);
  requestRemove(uint32) airecv clsend;
  rejectRemove(uint32, uint32);
  updateAvatarFriend(uint32, AvatarFriendInfo);
  removeAvatarFriend(uint32);
  updateAvatarName(uint32, string);
  avatarOnline(uint32, uint32, string, bool, bool, string, string);
  avatarOffline(uint32);
};

dclass PlayerFriendsManager : DistributedObject, TalkPath_account {
  requestInvite(uint32, uint32, uint8) airecv clsend;
  invitationFrom(uint32, string);
  retractInvite(uint32);
  invitationResponse(uint32, uint16, uint32);
  requestDecline(uint32, uint32) airecv clsend;
  requestDeclineWithReason(uint32, uint32, uint32) airecv clsend;
  requestRemove(uint32, uint32) airecv clsend;
  secretResponse(string);
  rejectSecret(string);
  rejectUseSecret(string);
  updatePlayerFriend(uint32, FriendInfo, uint8);
  removePlayerFriend(uint32);
};

dclass CentralLogger : DistributedObject {
  sendMessage(string(0-256), string(0-1024), uint32, uint32) clsend;
  logAIGarbage() airecv;
};

dclass CallbackObject {
  callback(uint32, bool, uint8);
};