def enterUnloadAvatar(self):
channel = self.csm.GetAccountConnectionChannel(self.target)
# Tell FriendsManager somebody is logging off:
self.csm.air.friendsManager.toonOffline(self.avId)
# Clear off POSTREMOVE:
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_CLEAR_POST_REMOVES)
self.csm.air.send(dg)
# Remove avatar channel:
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_CLOSE_CHANNEL)
dg.addChannel(self.csm.GetPuppetConnectionChannel(self.avId))
self.csm.air.send(dg)
# Reset sender channel:
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID)
dg.addChannel(self.target<<32) # accountId in high 32 bits, no avatar in low
self.csm.air.send(dg)
# Unload avatar object:
dg = PyDatagram()
dg.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM)
dg.addUint32(self.avId)
self.csm.air.send(dg)
# Done!
self.csm.air.writeServerEvent('avatarUnload', self.avId)
self.demand('Off')
def handleConnected(self):
self.districtId = self.allocateChannel()
# register the AI on the state server...
dg = PyDatagram()
dg.addServerHeader(self.serverId, self.ourChannel, STATESERVER_ADD_SHARD)
dg.addUint32(self.districtId)
dg.addString(self.districtName)
dg.addUint32(self.districtPopulation)
self.send(dg)
# add a post remove to remove the shard from the state server
# when we disconnect from the message director...
dg = PyDatagram()
dg.addServerHeader(self.serverId, self.ourChannel, STATESERVER_REMOVE_SHARD)
self.addPostRemove(dg)
self.rootObj = DistributedObjectAI(self)
self.rootObj.generateWithRequiredAndId(self.districtId, 0, 0)
self.notify.info('Creating managers...')
self.createManagers()
if self.config.GetBool('want-safe-zones', True):
self.notify.info('Creating safe zones...')
self.createSafeZones()
if self.config.GetBool('want-cog-headquarters', True):
self.notify.info('Creating Cog headquarters...')
self.createCogHeadquarters()
self.notify.info('Done.')
def enterSetAvatar(self):
channel = self.csm.GetAccountConnectionChannel(self.target)
# First, give them a POSTREMOVE to unload the avatar, just in case they
# disconnect while we're working.
datagramCleanup = PyDatagram()
datagramCleanup.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM)
datagramCleanup.addUint32(self.avId)
datagram = PyDatagram()
datagram.addServerHeader( channel, self.csm.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE)
datagram.addString(datagramCleanup.getMessage())
self.csm.air.send(datagram)
# Activate the avatar on the DBSS:
self.csm.air.sendActivate(self.avId, 0, 0, self.csm.air.dclassesByName['DistributedToonUD'], {'setAdminAccess': \
[self.account.get('ACCESS_LEVEL', 100)]})
# Next, add them to the avatar channel:
datagram = PyDatagram()
datagram.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL)
datagram.addChannel(self.csm.GetPuppetConnectionChannel(self.avId))
self.csm.air.send(datagram)
# Now set their sender channel to represent their account affiliation:
datagram = PyDatagram()
datagram.addServerHeader( channel, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID)
datagram.addChannel(self.target<<32 | self.avId)
self.csm.air.send(datagram)
# Eliminate race conditions.
taskMgr.doMethodLater(0.2, self.enterSetAvatarTask, 'avatarTask-%s' % (self.avId), extraArgs=[channel],
appendTask=True)
def __handleSetAvatar(self):
channel = self.loginManager.GetAccountConnectionChannel(self.sender)
cleanupDatagram = PyDatagram()
cleanupDatagram.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM)
cleanupDatagram.addUint32(self.avId)
datagram = PyDatagram()
datagram.addServerHeader(channel, self.loginManager.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE)
datagram.addString(cleanupDatagram.getMessage())
self.loginManager.air.send(datagram)
self.loginManager.air.sendActivate(self.avId, 0, 0, self.loginManager.air.dclassesByName['DistributedToonUD'])
datagram = PyDatagram()
datagram.addServerHeader(channel, self.loginManager.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL)
datagram.addChannel(self.loginManager.GetPuppetConnectionChannel(self.avId))
self.loginManager.air.send(datagram)
self.loginManager.air.clientAddSessionObject(channel, self.avId)
datagram = PyDatagram()
datagram.addServerHeader(channel, self.loginManager.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID)
datagram.addChannel(self.sender << 32 | self.avId) # accountId in high 32 bits, avatar in low.
self.loginManager.air.send(datagram)
self.loginManager.air.setOwner(self.avId, channel)
self._handleDone()
def __handleUnloadAvatar(self):
channel = self.loginManager.GetAccountConnectionChannel(self.sender)
datagram = PyDatagram()
datagram.addServerHeader(channel, self.loginManager.air.ourChannel,
CLIENTAGENT_CLEAR_POST_REMOVES)
self.loginManager.air.send(datagram)
datagram = PyDatagram()
datagram.addServerHeader(channel, self.loginManager.air.ourChannel,
CLIENTAGENT_CLOSE_CHANNEL)
datagram.addChannel(
self.loginManager.GetPuppetConnectionChannel(self.avId))
self.loginManager.air.send(datagram)
datagram = PyDatagram()
datagram.addServerHeader(channel, self.loginManager.air.ourChannel,
CLIENTAGENT_SET_CLIENT_ID)
datagram.addChannel(
self.sender << 32) # accountId in high 32 bits, no avatar in low.
self.loginManager.air.send(datagram)
datagram = PyDatagram()
datagram.addServerHeader(channel, self.loginManager.air.ourChannel,
CLIENTAGENT_REMOVE_SESSION_OBJECT)
datagram.addUint32(self.avId)
self.loginManager.air.send(datagram)
datagram = PyDatagram()
datagram.addServerHeader(self.avId, channel,
STATESERVER_OBJECT_DELETE_RAM)
datagram.addUint32(self.avId)
self.loginManager.air.send(datagram)
self._handleDone()
def enterUnloadAvatar(self):
channel = self.csm.GetAccountConnectionChannel(self.target)
self.csm.air.friendsManager.toonOffline(self.avId)
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_CLEAR_POST_REMOVES)
self.csm.air.send(dg)
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_CLOSE_CHANNEL)
dg.addChannel(self.csm.GetPuppetConnectionChannel(self.avId))
self.csm.air.send(dg)
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_SET_CLIENT_ID)
dg.addChannel(self.target << 32)
self.csm.air.send(dg)
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_REMOVE_SESSION_OBJECT)
dg.addUint32(self.avId)
self.csm.air.send(dg)
dg = PyDatagram()
dg.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM)
dg.addUint32(self.avId)
self.csm.air.send(dg)
self.csm.air.writeServerEvent('avatar-unload', avId=self.avId)
self.demand('Off')
def sendShardInfo(self):
dg = PyDatagram()
dg.addServerHeader(self.serverId, self.ourChannel,
STATESERVER_UPDATE_SHARD)
dg.addString(self.districtName)
dg.addUint32(self.districtPopulation)
self.send(dg)
def enterSetAvatar(self):
channel = self.csm.GetAccountConnectionChannel(self.target)
datagramCleanup = PyDatagram()
datagramCleanup.addServerHeader(self.avId, channel,
STATESERVER_OBJECT_DELETE_RAM)
datagramCleanup.addUint32(self.avId)
datagram = PyDatagram()
datagram.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_ADD_POST_REMOVE)
datagram.addString(datagramCleanup.getMessage())
self.csm.air.send(datagram)
self.csm.air.sendActivate(
self.avId, 0, 0, self.csm.air.dclassesByName['DistributedToonUD'],
{'setAdminAccess': [self.account.get('ACCESS_LEVEL', 100)]})
datagram = PyDatagram()
datagram.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_OPEN_CHANNEL)
datagram.addChannel(self.csm.GetPuppetConnectionChannel(self.avId))
self.csm.air.send(datagram)
datagram = PyDatagram()
datagram.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_SET_CLIENT_ID)
datagram.addChannel(self.target << 32 | self.avId)
self.csm.air.send(datagram)
taskMgr.doMethodLater(0.2,
self.enterSetAvatarTask,
'avatarTask-%s' % self.avId,
extraArgs=[channel],
appendTask=True)
def enterUnloadAvatar(self):
channel = self.csm.GetAccountConnectionChannel(self.target)
self.csm.air.friendsManager.toonOffline(self.avId)
# Clear off POSTREMOVE:
datagram = PyDatagram()
datagram.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_CLEAR_POST_REMOVES)
self.csm.air.send(datagram)
# Remove avatar channel:
datagram = PyDatagram()
datagram.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_CLOSE_CHANNEL)
datagram.addChannel(self.csm.GetPuppetConnectionChannel(self.avId))
self.csm.air.send(datagram)
# Reset sender channel:
datagram = PyDatagram()
datagram.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID)
datagram.addChannel(self.target<<32)
self.csm.air.send(datagram)
# Unload avatar object:
datagram = PyDatagram()
datagram.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM)
datagram.addUint32(self.avId)
self.csm.air.send(datagram)
# Done!
self.csm.air.writeServerEvent('avatarUnload', self.avId)
self.demand('Off')
def enterUnloadAvatar(self):
channel = self.csm.GetAccountConnectionChannel(self.target)
# Fire off the avatarOffline message.
self.csm.air.netMessenger.send("avatarOffline", [self.avId])
# Get lost, POST_REMOVES!:
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_CLEAR_POST_REMOVES)
self.csm.air.send(dg)
# Remove avatar channel:
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_CLOSE_CHANNEL)
dg.addChannel(self.csm.GetPuppetConnectionChannel(self.avId))
self.csm.air.send(dg)
# Reset sender channel:
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID)
dg.addChannel(self.target << 32) # accountId in high 32 bits, no avatar in low
self.csm.air.send(dg)
# Unload avatar object:
dg = PyDatagram()
dg.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM)
dg.addUint32(self.avId)
self.csm.air.send(dg)
# Done!
self.csm.air.writeServerEvent("avatar-unload", avId=self.avId)
self.demand("Off")
def enterSetAvatar(self):
channel = self.csm.GetAccountConnectionChannel(self.target)
# First, give them a POSTREMOVE to unload the avatar, just in case they
# disconnect while we're working.
datagramCleanup = PyDatagram()
datagramCleanup.addServerHeader(
self.avId,
channel,
STATESERVER_OBJECT_DELETE_RAM)
datagramCleanup.addUint32(self.avId)
datagram = PyDatagram()
datagram.addServerHeader(
channel,
self.csm.air.ourChannel,
CLIENTAGENT_ADD_POST_REMOVE)
datagram.addString(datagramCleanup.getMessage())
self.csm.air.send(datagram)
# Activate the avatar on the DBSS:
self.csm.air.sendActivate(
self.avId, 0, 0, self.csm.air.dclassesByName['DistributedToonUD'],
{'setAdminAccess': [self.account.get('ACCESS_LEVEL', 100)]})
# Next, add them to the avatar channel:
datagram = PyDatagram()
datagram.addServerHeader(
channel,
self.csm.air.ourChannel,
CLIENTAGENT_OPEN_CHANNEL)
datagram.addChannel(self.csm.GetPuppetConnectionChannel(self.avId))
self.csm.air.send(datagram)
# Now set their sender channel to represent their account affiliation:
datagram = PyDatagram()
datagram.addServerHeader(
channel,
self.csm.air.ourChannel,
CLIENTAGENT_SET_CLIENT_ID)
datagram.addChannel(self.target<<32 | self.avId)
self.csm.air.send(datagram)
# Finally, grant ownership and shut down.
datagram = PyDatagram()
datagram.addServerHeader(
self.avId,
self.csm.air.ourChannel,
STATESERVER_OBJECT_SET_OWNER)
datagram.addChannel(self.target<<32 | self.avId)
self.csm.air.send(datagram)
# Tell TTRFriendsManager somebody is logging in:
self.csm.air.friendsManager.toonOnline(self.avId, self.avatar)
# Tell the GlobalPartyManager as well:
self.csm.air.globalPartyMgr.avatarJoined(self.avId)
self.csm.air.writeServerEvent('avatarChosen', self.avId, self.target)
self.demand('Off')
def inviteeFriendResponse(self, response, context):
avId = self.air.getAvatarIdFromSender()
if not context in self.requests:
self.air.writeServerEvent(
'suspicious',
avId=avId,
issue=
'Player tried to respond to a friend request that doesn\'t exist!'
)
return
if avId != self.requests[context][0][1]:
self.air.writeServerEvent(
'suspicious',
avId=avId,
issue='Player tried to respond to someone else\'s request!')
return
if self.requests[context][1] == 'cancelled':
self.air.writeServerEvent(
'suspicious',
avId=avId,
issue='Player tried to respond to non-active friend request!')
return
self.sendUpdateToAvatarId(self.requests[context][0][0],
'friendResponse', [response, context])
if response == 1:
requested = self.air.doId2do.get(self.requests[context][0][1])
requester = self.air.doId2do.get(self.requests[context][0][0])
if not (requested and requester):
# Likely they logged off just before a response was sent. RIP.
return
# Allow both toons to teleport to each other.
dg = PyDatagram()
dg.addServerHeader(
self.GetPuppetConnectionChannel(requested.getDoId()),
self.air.ourChannel, CLIENTAGENT_DECLARE_OBJECT)
dg.addUint32(requester.getDoId())
dg.addUint16(
self.air.dclassesByName['DistributedToonAI'].getNumber())
self.air.send(dg)
dg = PyDatagram()
dg.addServerHeader(
self.GetPuppetConnectionChannel(requester.getDoId()),
self.air.ourChannel, CLIENTAGENT_DECLARE_OBJECT)
dg.addUint32(requested.getDoId())
dg.addUint16(
self.air.dclassesByName['DistributedToonAI'].getNumber())
self.air.send(dg)
requested.extendFriendsList(requester.getDoId(), 0)
requester.extendFriendsList(requested.getDoId(), 0)
requested.d_setFriendsList(requested.getFriendsList())
requester.d_setFriendsList(requester.getFriendsList())
del self.requests[context]
def enterSetAvatar(self):
channel = self.csm.GetAccountConnectionChannel(self.target)
# First, give them a POSTREMOVE to unload the avatar, just in case they
# disconnect while we're working.
dgcleanup = PyDatagram()
dgcleanup.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM)
dgcleanup.addUint32(self.avId)
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE)
dg.addString(dgcleanup.getMessage())
self.csm.air.send(dg)
# Get the avatar's "true" access. (without "server" bit)
adminAccess = self.account.get('ADMIN_ACCESS', 0)
adminAccess = adminAccess - adminAccess % 100
# Activate the avatar on the DBSS:
self.csm.air.sendActivate(self.avId, 0, 0,
self.csm.air.dclassesByName['DistributedToonUD'],
{'setAdminAccess': [self.account.get('ADMIN_ACCESS', 0)]})
# Next, add them to the avatar channel:
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL)
dg.addChannel(self.csm.GetPuppetConnectionChannel(self.avId))
self.csm.air.send(dg)
# Now set their sender channel to represent their account affiliation:
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID)
dg.addChannel(self.target<<32 | self.avId) # accountId in high 32 bits, avatar in low
self.csm.air.send(dg)
# Finally, grant ownership and shut down.
dg = PyDatagram()
dg.addServerHeader(self.avId, self.csm.air.ourChannel, STATESERVER_OBJECT_SET_OWNER)
dg.addChannel(self.csm.GetAccountConnectionChannel(self.target)) # Set ownership channel to the connection's account channel.
self.csm.air.send(dg)
# Tell the GlobalPartyManager as well:
self.csm.air.globalPartyMgr.avatarJoined(self.avId)
# Tell everything that an avatar is coming online!
friendsList = [x for x, y in self.avatar['setFriendsList'][0]]
self.csm.air.netMessenger.send('avatarOnline', [self.avId, friendsList])
# Post-remove for an avatar that disconnects unexpectedly.
dgcleanup = self.csm.air.netMessenger.prepare('avatarOffline', [self.avId])
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE)
dg.addString(dgcleanup.getMessage())
self.csm.air.send(dg)
self.csm.air.writeServerEvent('avatar-chosen', avId=self.avId, accId=self.target)
self.demand('Off')
def __ready(self):
dg = PyDatagram()
dg.addServerHeader(self.districtStats.doId, self.ourChannel, STATESERVER_OBJECT_DELETE_RAM)
dg.addUint32(self.districtStats.doId)
self.addPostRemove(dg)
self.apiMgr = self.generateGlobalObject(100001, "ShardAPIManager")
self.apiMgr.start()
self.apiMgr.d_setShardData()
self.banMgr = self.generateGlobalObject(100002, "BanManager")
def enterUnloadAvatar(self):
# Get the client channel.
channel = self.gameServicesManager.GetAccountConnectionChannel(
self.target)
# Tell the friends manager that we're logging off.
self.gameServicesManager.air.ttoffFriendsManager.goingOffline(
self.avId)
# First, remove our POST_REMOVES.
datagram = PyDatagram()
datagram.addServerHeader(channel,
self.gameServicesManager.air.ourChannel,
CLIENTAGENT_CLEAR_POST_REMOVES)
self.gameServicesManager.air.send(datagram)
# Next, remove the avatar channel.
datagram = PyDatagram()
datagram.addServerHeader(channel,
self.gameServicesManager.air.ourChannel,
CLIENTAGENT_CLOSE_CHANNEL)
datagram.addChannel(
self.gameServicesManager.GetPuppetConnectionChannel(self.avId))
self.gameServicesManager.air.send(datagram)
# Next, reset the sender channel.
datagram = PyDatagram()
datagram.addServerHeader(channel,
self.gameServicesManager.air.ourChannel,
CLIENTAGENT_SET_CLIENT_ID)
datagram.addChannel(
self.target << 32) # accountId in high 32 bits, no avatar in low.
self.gameServicesManager.air.send(datagram)
# Reset the session object.
datagram = PyDatagram()
datagram.addServerHeader(channel,
self.gameServicesManager.air.ourChannel,
CLIENTAGENT_REMOVE_SESSION_OBJECT)
datagram.addUint32(self.avId)
self.gameServicesManager.air.send(datagram)
# Unload the avatar object.
datagram = PyDatagram()
datagram.addServerHeader(self.avId, channel,
STATESERVER_OBJECT_DELETE_RAM)
datagram.addUint32(self.avId)
self.gameServicesManager.air.send(datagram)
# We're done! We can now shut down this operation.
self.gameServicesManager.air.writeServerEvent('avatar-unloaded',
avId=self.avId)
self.demand('Off')
def inviteeFriendResponse(self, response, context):
avId = self.air.getAvatarIdFromSender()
if not avId:
return
if context not in self.requests:
self.air.writeServerEvent(
'suspicious', avId,
"Player tried to respond to a friend request that doesn't exist!"
)
return
if avId != self.requests[context][0][1]:
self.air.writeServerEvent(
'suspicious', avId,
"Player tried to respond to someone else's request!")
return
if self.requests[context][1] == 'cancelled':
self.air.writeServerEvent(
'suspicious', avId,
'Player tried to respond to a non-active friend request!')
return
self.sendUpdateToAvatarId(self.requests[context][0][0],
'friendResponse', [response, context])
if response == 1:
requestedAv = self.air.doId2do.get(self.requests[context][0][1])
if not requestedAv:
del self.requests[context]
return
requesterAv = self.air.doId2do.get(self.requests[context][0][0])
if not requesterAv:
del self.requests[context]
return
dg = PyDatagram()
dg.addServerHeader(
self.GetPuppetConnectionChannel(requestedAv.getDoId()),
self.air.ourChannel, CLIENTAGENT_DECLARE_OBJECT)
dg.addUint32(requesterAv.getDoId())
dg.addUint16(
self.air.dclassesByName['DistributedToonAI'].getNumber())
self.air.send(dg)
dg = PyDatagram()
dg.addServerHeader(
self.GetPuppetConnectionChannel(requesterAv.getDoId()),
self.air.ourChannel, CLIENTAGENT_DECLARE_OBJECT)
dg.addUint32(requestedAv.getDoId())
dg.addUint16(
self.air.dclassesByName['DistributedToonAI'].getNumber())
self.air.send(dg)
requestedAv.extendFriendsList(requesterAv.getDoId(), 0)
requesterAv.extendFriendsList(requestedAv.getDoId(), 0)
requestedAv.d_setFriendsList(requestedAv.getFriendsList())
requesterAv.d_setFriendsList(requesterAv.getFriendsList())
del self.requests[context]
def packGardenData(plants, statuary, started = True):
dg = PyDatagram()
for plant in plants:
a, b, c, d, e = plant
dg.addUint32(a)
dg.addInt8(b)
dg.addUint32(c)
dg.addInt8(d)
dg.addUint16(e)
dg.addUint8(statuary)
dg.addBool(started)
return dg.getMessage()
def packGardenData(plants, statuary, started=True):
dg = PyDatagram()
for plant in plants:
a, b, c, d, e = plant
dg.addUint32(a)
dg.addInt8(b)
dg.addUint32(c)
dg.addInt8(d)
dg.addUint16(e)
dg.addUint8(statuary)
dg.addBool(started)
return dg.getMessage()
def enterSetAvatar(self):
channel = self.csm.GetAccountConnectionChannel(self.target)
# First, give them a POSTREMOVE to unload the avatar, just in case they
# disconnect while we're working.
dgcleanup = PyDatagram()
dgcleanup.addServerHeader(self.avId, channel,
STATESERVER_OBJECT_DELETE_RAM)
dgcleanup.addUint32(self.avId)
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_ADD_POST_REMOVE)
dg.addString(dgcleanup.getMessage())
self.csm.air.send(dg)
# Activate the avatar on the DBSS:
self.csm.air.sendActivate(
self.avId, 0, 0, self.csm.air.dclassesByName['DistributedToonUD'],
{'setAdminAccess': [self.account.get('ADMIN_ACCESS', 0)]})
# Next, add them to the avatar channel:
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_OPEN_CHANNEL)
dg.addChannel(self.csm.GetPuppetConnectionChannel(self.avId))
self.csm.air.send(dg)
# Now set their sender channel to represent their account affiliation:
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_SET_CLIENT_ID)
dg.addChannel(self.target << 32
| self.avId) # accountId in high 32 bits, avatar in low
self.csm.air.send(dg)
# Finally, grant ownership and shut down.
dg = PyDatagram()
dg.addServerHeader(self.avId, self.csm.air.ourChannel,
STATESERVER_OBJECT_SET_OWNER)
dg.addChannel(self.target << 32
| self.avId) # accountId in high 32 bits, avatar in low
self.csm.air.send(dg)
# Tell TTRFriendsManager somebody is logging in:
self.csm.air.friendsManager.toonOnline(self.avId, self.avatar)
# Tell the GlobalPartyManager as well
self.csm.air.globalPartyMgr.avatarJoined(self.avId)
self.csm.air.writeServerEvent('avatarChosen', self.avId, self.target)
self.demand('Off')
def __ready(self):
dg = PyDatagram()
dg.addServerHeader(self.districtStats.doId, self.ourChannel,
STATESERVER_OBJECT_DELETE_RAM)
dg.addUint32(self.districtStats.doId)
self.addPostRemove(dg)
self.apiMgr = self.generateGlobalObject(100001, "ShardAPIManager")
self.apiMgr.start()
self.apiMgr.d_setShardData()
self.banMgr = self.generateGlobalObject(100002, "BanManager")
self.trophyMgr.updateToonData()
def login(self, cookie, authKey):
sender = self.air.getMsgSender()
hwid = cookie.split("#")[1]
backupCookie = cookie.split("#")[0]
cookie = cookie.split("#")[0]
self.pendingLogins[sender] = (sender, hwid, backupCookie, cookie,
authKey)
# CLIENTAGENT_GET_NETWORK_ADDRESS is defined in OtpDoGlobals for backwards compatibility with old versions of Panda3D
datagram = PyDatagram()
datagram.addServerHeader(sender, self.air.ourChannel,
OtpDoGlobals.CLIENTAGENT_GET_NETWORK_ADDRESS)
datagram.addUint32(sender)
self.air.send(datagram)
def __handleGoneOffline(self, avId, activated, otherId=None, accId=None):
if not (otherId and activated and accId):
return
dg = PyDatagram()
dg.addServerHeader(self.GetPuppetConnectionChannel(avId),
self.air.ourChannel, CLIENTAGENT_UNDECLARE_OBJECT)
dg.addUint32(otherId)
self.air.send(dg)
dg = PyDatagram()
dg.addServerHeader(self.GetAccountConnectionChannel(accId),
self.air.ourChannel, CLIENTAGENT_UNDECLARE_OBJECT)
dg.addUint32(avId)
self.air.send(dg)
self.sendUpdateToAvatarId(avId, 'friendOffline', [otherId])
def __comingOnlineFriendOnline(self, avId, activated, otherId=None):
if not (otherId and activated):
return
dg = PyDatagram()
dg.addServerHeader(self.GetPuppetConnectionChannel(avId),
self.air.ourChannel, CLIENTAGENT_DECLARE_OBJECT)
dg.addUint32(otherId)
dg.addUint16(self.air.dclassesByName['DistributedToonUD'].getNumber())
self.air.send(dg)
dg = PyDatagram()
dg.addServerHeader(self.GetPuppetConnectionChannel(otherId),
self.air.ourChannel, CLIENTAGENT_DECLARE_OBJECT)
dg.addUint32(avId)
dg.addUint16(self.air.dclassesByName['DistributedToonUD'].getNumber())
self.air.send(dg)
self.sendUpdateToAvatarId(avId, 'friendOnline', [otherId, 0, 0])
def setAllowClientSend(self, avId, distObj, fieldNameList=[]):
dg = PyDatagram()
dg.addServerHeader(distObj.GetPuppetConnectionChannel(avId),
self.ourChannel, CLIENTAGENT_SET_FIELDS_SENDABLE)
fieldIds = []
for fieldName in fieldNameList:
field = distObj.dclass.getFieldByName(fieldName)
if field:
fieldIds.append(field.getNumber())
dg.addUint32(distObj.getDoId())
dg.addUint16(len(fieldIds))
for fieldId in fieldIds:
dg.addUint16(fieldId)
self.send(dg)
def enterSetAvatar(self):
channel = self.csm.GetAccountConnectionChannel(self.target)
# First, give them a POSTREMOVE to unload the avatar, just in case they
# disconnect while we're working.
datagramCleanup = PyDatagram()
datagramCleanup.addServerHeader(
self.avId,
channel,
STATESERVER_OBJECT_DELETE_RAM)
datagramCleanup.addUint32(self.avId)
datagram = PyDatagram()
datagram.addServerHeader(
channel,
self.csm.air.ourChannel,
CLIENTAGENT_ADD_POST_REMOVE)
datagram.addString(datagramCleanup.getMessage())
self.csm.air.send(datagram)
# Activate the avatar on the DBSS:
self.csm.air.sendActivate(
self.avId, 0, 0, self.csm.air.dclassesByName['DistributedToonUD'],
{'setAdminAccess': [self.account.get('ACCESS_LEVEL', 100)],
'setBankMoney': [self.account.get('MONEY', 0)]})
# Next, add them to the avatar channel:
datagram = PyDatagram()
datagram.addServerHeader(
channel,
self.csm.air.ourChannel,
CLIENTAGENT_OPEN_CHANNEL)
datagram.addChannel(self.csm.GetPuppetConnectionChannel(self.avId))
self.csm.air.send(datagram)
# Now set their sender channel to represent their account affiliation:
datagram = PyDatagram()
datagram.addServerHeader(
channel,
self.csm.air.ourChannel,
CLIENTAGENT_SET_CLIENT_ID)
datagram.addChannel(self.target<<32 | self.avId)
self.csm.air.send(datagram)
# Eliminate race conditions.
taskMgr.doMethodLater(0.2, self.enterSetAvatarTask,
'avatarTask-%s' % self.avId, extraArgs=[channel],
appendTask=True)
def __offlineToonOnline(self, avId, activated, otherId=None, accId=None):
if not (otherId and activated and accId):
return
# Undeclare to the friend!
dg = PyDatagram()
dg.addServerHeader(self.GetPuppetConnectionChannel(avId), self.air.ourChannel, CLIENTAGENT_UNDECLARE_OBJECT)
dg.addUint32(otherId)
self.air.send(dg)
# Undeclare to our now-offline avId (they may still be around, about to log into a new toon!)
dg = PyDatagram()
dg.addServerHeader(self.GetAccountConnectionChannel(accId), self.air.ourChannel, CLIENTAGENT_UNDECLARE_OBJECT)
dg.addUint32(avId)
self.air.send(dg)
# Tell them they're offline!
self.sendUpdateToAvatarId(avId, 'friendOffline', [otherId])
def enterSetAvatar(self):
channel = self.csm.GetAccountConnectionChannel(self.target)
dgcleanup = PyDatagram()
dgcleanup.addServerHeader(self.avId, channel,
STATESERVER_OBJECT_DELETE_RAM)
dgcleanup.addUint32(self.avId)
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_ADD_POST_REMOVE)
dg.addString(dgcleanup.getMessage())
self.csm.air.send(dg)
adminAccess = self.account.get('ADMIN_ACCESS', 0)
adminAccess = adminAccess - adminAccess % 100
self.csm.air.sendActivate(
self.avId, 0, 0, self.csm.air.dclassesByName['DistributedToonUD'],
{'setAdminAccess': [self.account.get('ADMIN_ACCESS', 0)]})
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_OPEN_CHANNEL)
dg.addChannel(self.csm.GetPuppetConnectionChannel(self.avId))
self.csm.air.send(dg)
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_ADD_SESSION_OBJECT)
dg.addUint32(self.avId)
self.csm.air.send(dg)
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_SET_CLIENT_ID)
dg.addChannel(self.target << 32 | self.avId)
self.csm.air.send(dg)
dg = PyDatagram()
dg.addServerHeader(self.avId, self.csm.air.ourChannel,
STATESERVER_OBJECT_SET_OWNER)
dg.addChannel(self.csm.GetAccountConnectionChannel(self.target))
self.csm.air.send(dg)
fields = self.avatar
fields.update(
{'setAdminAccess': [self.account.get('ADMIN_ACCESS', 0)]})
self.csm.air.friendsManager.toonOnline(self.avId, fields)
self.csm.air.globalPartyMgr.avatarJoined(self.avId)
self.csm.air.writeServerEvent('avatar-chosen',
avId=self.avId,
accId=self.target)
self.demand('Off')
def __offlineToonOnline(self, avId, activated, otherId=None, accId=None):
if not (otherId and activated and accId):
return
# Undeclare to the friend!
dg = PyDatagram()
dg.addServerHeader(self.GetPuppetConnectionChannel(avId),
self.air.ourChannel, CLIENTAGENT_UNDECLARE_OBJECT)
dg.addUint32(otherId)
self.air.send(dg)
# Undeclare to our now-offline avId (they may still be around, about to log into a new toon!)
dg = PyDatagram()
dg.addServerHeader(self.GetAccountConnectionChannel(accId),
self.air.ourChannel, CLIENTAGENT_UNDECLARE_OBJECT)
dg.addUint32(avId)
self.air.send(dg)
# Tell them they're offline!
self.sendUpdateToAvatarId(avId, 'friendOffline', [otherId])
def __comingOnlineFriendOnline(self, avId, activated, otherId=None):
if not (otherId and activated):
#??!?!?
return
# Declare our avatar to their friend.
dg = PyDatagram()
dg.addServerHeader(self.GetPuppetConnectionChannel(avId), self.air.ourChannel, CLIENTAGENT_DECLARE_OBJECT)
dg.addUint32(otherId)
dg.addUint16(self.air.dclassesByName['DistributedToonUD'].getNumber())
self.air.send(dg)
# Declare the friend to the avatar.
dg = PyDatagram()
dg.addServerHeader(self.GetPuppetConnectionChannel(otherId), self.air.ourChannel, CLIENTAGENT_DECLARE_OBJECT)
dg.addUint32(avId)
dg.addUint16(self.air.dclassesByName['DistributedToonUD'].getNumber())
self.air.send(dg)
# Tell the client their friend is online.
self.sendUpdateToAvatarId(avId, 'friendOnline', [otherId, 0, 0])
def enterUnloadAvatar(self):
channel = self.csm.GetAccountConnectionChannel(self.target)
# Clear off POSTREMOVE:
datagram = PyDatagram()
datagram.addServerHeader(
channel,
self.csm.air.ourChannel,
CLIENTAGENT_CLEAR_POST_REMOVES)
self.csm.air.send(datagram)
# Remove avatar channel:
datagram = PyDatagram()
datagram.addServerHeader(
channel,
self.csm.air.ourChannel,
CLIENTAGENT_CLOSE_CHANNEL)
datagram.addChannel(self.csm.GetPuppetConnectionChannel(self.avId))
self.csm.air.send(datagram)
# Reset sender channel:
datagram = PyDatagram()
datagram.addServerHeader(
channel,
self.csm.air.ourChannel,
CLIENTAGENT_SET_CLIENT_ID)
datagram.addChannel(self.target<<32)
self.csm.air.send(datagram)
# Unload avatar object:
datagram = PyDatagram()
datagram.addServerHeader(
self.avId,
channel,
STATESERVER_OBJECT_DELETE_RAM)
datagram.addUint32(self.avId)
self.csm.air.send(datagram)
# Done!
self.csm.air.writeServerEvent('avatarUnload', self.avId)
self.demand('Off')
def inviteeFriendResponse(self, response, context):
avId = self.air.getAvatarIdFromSender()
if not context in self.requests:
self.air.writeServerEvent('suspicious', avId=avId, issue='Player tried to respond to a friend request that doesn\'t exist!')
return
if avId != self.requests[context][0][1]:
self.air.writeServerEvent('suspicious', avId=avId, issue='Player tried to respond to someone else\'s request!')
return
if self.requests[context][1] == 'cancelled':
self.air.writeServerEvent('suspicious', avId=avId, issue='Player tried to respond to non-active friend request!')
return
self.sendUpdateToAvatarId(self.requests[context][0][0], 'friendResponse', [response, context])
if response == 1:
requested = self.air.doId2do.get(self.requests[context][0][1])
requester = self.air.doId2do.get(self.requests[context][0][0])
if not (requested and requester):
# Likely they logged off just before a response was sent. RIP.
return
# Allow both toons to teleport to each other.
dg = PyDatagram()
dg.addServerHeader(self.GetPuppetConnectionChannel(requested.getDoId()), self.air.ourChannel, CLIENTAGENT_DECLARE_OBJECT)
dg.addUint32(requester.getDoId())
dg.addUint16(self.air.dclassesByName['DistributedToonAI'].getNumber())
self.air.send(dg)
dg = PyDatagram()
dg.addServerHeader(self.GetPuppetConnectionChannel(requester.getDoId()), self.air.ourChannel, CLIENTAGENT_DECLARE_OBJECT)
dg.addUint32(requested.getDoId())
dg.addUint16(self.air.dclassesByName['DistributedToonAI'].getNumber())
self.air.send(dg)
requested.extendFriendsList(requester.getDoId(), 0)
requester.extendFriendsList(requested.getDoId(), 0)
requested.d_setFriendsList(requested.getFriendsList())
requester.d_setFriendsList(requester.getFriendsList())
del self.requests[context]
def enterSetAvatar(self):
channel = self.csm.GetAccountConnectionChannel(self.target)
# First, give them a POSTREMOVE to unload the avatar, just in case they
# disconnect while we're working.
datagramCleanup = PyDatagram()
datagramCleanup.addServerHeader(
self.avId,
channel,
STATESERVER_OBJECT_DELETE_RAM)
datagramCleanup.addUint32(self.avId)
datagram = PyDatagram()
datagram.addServerHeader(
channel,
self.csm.air.ourChannel,
CLIENTAGENT_ADD_POST_REMOVE)
datagram.addString(datagramCleanup.getMessage())
self.csm.air.send(datagram)
# setup the avatar's inventory.
self.csm.air.inventoryManager.initiateInventory(self.avId, self.inventorySetup)
def enterUnloadAvatar(self):
channel = self.gameServicesManager.GetAccountConnectionChannel(
self.target)
self.gameServicesManager.air.ttoffFriendsManager.goingOffline(
self.avId)
datagram = PyDatagram()
datagram.addServerHeader(channel,
self.gameServicesManager.air.ourChannel,
CLIENTAGENT_CLEAR_POST_REMOVES)
self.gameServicesManager.air.send(datagram)
datagram = PyDatagram()
datagram.addServerHeader(channel,
self.gameServicesManager.air.ourChannel,
CLIENTAGENT_CLOSE_CHANNEL)
datagram.addChannel(
self.gameServicesManager.GetPuppetConnectionChannel(self.avId))
self.gameServicesManager.air.send(datagram)
datagram = PyDatagram()
datagram.addServerHeader(channel,
self.gameServicesManager.air.ourChannel,
CLIENTAGENT_SET_CLIENT_ID)
datagram.addChannel(self.target << 32)
self.gameServicesManager.air.send(datagram)
datagram = PyDatagram()
datagram.addServerHeader(channel,
self.gameServicesManager.air.ourChannel,
CLIENTAGENT_REMOVE_SESSION_OBJECT)
datagram.addUint32(self.avId)
self.gameServicesManager.air.send(datagram)
datagram = PyDatagram()
datagram.addServerHeader(self.avId, channel,
STATESERVER_OBJECT_DELETE_RAM)
datagram.addUint32(self.avId)
self.gameServicesManager.air.send(datagram)
simbase.air.banManager.removeClient(self.target)
self.gameServicesManager.air.writeServerEvent('avatar-unloaded',
avId=self.avId)
self.demand('Off')
def enterUnloadAvatar(self):
channel = self.csm.GetAccountConnectionChannel(self.target)
# Fire off the avatarOffline message.
self.csm.air.netMessenger.send('avatarOffline', [self.avId])
# Get lost, POST_REMOVES!:
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_CLEAR_POST_REMOVES)
self.csm.air.send(dg)
# Remove avatar channel:
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_CLOSE_CHANNEL)
dg.addChannel(self.csm.GetPuppetConnectionChannel(self.avId))
self.csm.air.send(dg)
# Reset sender channel:
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_SET_CLIENT_ID)
dg.addChannel(
self.target << 32) # accountId in high 32 bits, no avatar in low
self.csm.air.send(dg)
# Unload avatar object:
dg = PyDatagram()
dg.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM)
dg.addUint32(self.avId)
self.csm.air.send(dg)
# Done!
self.csm.air.writeServerEvent('avatar-unload', avId=self.avId)
self.demand('Off')
def enterSetAvatar(self):
channel = self.gameServicesManager.GetAccountConnectionChannel(
self.target)
cleanupDatagram = PyDatagram()
cleanupDatagram.addServerHeader(self.avId, channel,
STATESERVER_OBJECT_DELETE_RAM)
cleanupDatagram.addUint32(self.avId)
datagram = PyDatagram()
datagram.addServerHeader(channel,
self.gameServicesManager.air.ourChannel,
CLIENTAGENT_ADD_POST_REMOVE)
datagram.addString(cleanupDatagram.getMessage())
self.gameServicesManager.air.send(datagram)
creationDate = self.getCreationDate()
accountDays = -1
if creationDate:
now = datetime.fromtimestamp(
time.mktime(time.strptime(time.ctime())))
accountDays = abs((now - creationDate).days)
if accountDays < 0 or accountDays > 4294967295L:
accountDays = 100000
self.gameServicesManager.sendUpdateToAccountId(self.target,
'receiveAccountDays',
[accountDays])
accessLevel = self.account.get('ACCESS_LEVEL', 'NO_ACCESS')
accessLevel = OTPGlobals.AccessLevelName2Int.get(accessLevel, 0)
self.gameServicesManager.air.sendActivate(
self.avId, 0, 0, self.gameServicesManager.air.dclassesByName[
self.gameServicesManager.avatarDclass],
{'setAccessLevel': [accessLevel]})
datagram = PyDatagram()
datagram.addServerHeader(channel,
self.gameServicesManager.air.ourChannel,
CLIENTAGENT_OPEN_CHANNEL)
datagram.addChannel(
self.gameServicesManager.GetPuppetConnectionChannel(self.avId))
self.gameServicesManager.air.send(datagram)
self.gameServicesManager.air.clientAddSessionObject(channel, self.avId)
datagram = PyDatagram()
datagram.addServerHeader(channel,
self.gameServicesManager.air.ourChannel,
CLIENTAGENT_SET_CLIENT_ID)
datagram.addChannel(self.target << 32 | self.avId)
self.gameServicesManager.air.send(datagram)
self.gameServicesManager.air.setOwner(self.avId, channel)
friendsList = [x for x, y in self.avatar['setFriendsList'][0]]
self.gameServicesManager.air.ttoffFriendsManager.comingOnline(
self.avId, friendsList)
if self.gameServicesManager.air.ttoffFriendsManager:
friendsManagerDclass = self.gameServicesManager.air.ttoffFriendsManager.dclass
cleanupDatagram = friendsManagerDclass.aiFormatUpdate(
'goingOffline',
self.gameServicesManager.air.ttoffFriendsManager.doId,
self.gameServicesManager.air.ttoffFriendsManager.doId,
self.gameServicesManager.air.ourChannel, [self.avId])
else:
friendsManagerDoId = OtpDoGlobals.OTP_DO_ID_TTOFF_FRIENDS_MANAGER
friendsManagerDclass = self.gameServicesManager.air.dclassesByName[
'TTOffFriendsManagerUD']
cleanupDatagram = friendsManagerDclass.aiFormatUpdate(
'goingOffline', friendsManagerDoId, friendsManagerDoId,
self.gameServicesManager.air.ourChannel, [self.avId])
datagram = PyDatagram()
datagram.addServerHeader(channel,
self.gameServicesManager.air.ourChannel,
CLIENTAGENT_ADD_POST_REMOVE)
datagram.addString(cleanupDatagram.getMessage())
self.gameServicesManager.air.send(datagram)
simbase.air.banManager.addClient(self.target, self.hwId)
self.gameServicesManager.air.writeServerEvent('avatar-chosen',
avId=self.avId,
accId=self.target)
self.demand('Off')
def enterSetAvatar(self):
# Get the client channel.
channel = self.gameServicesManager.GetAccountConnectionChannel(
self.target)
# We will first assign a POST_REMOVE that will unload the
# avatar in the event of them disconnecting while we are working.
cleanupDatagram = PyDatagram()
cleanupDatagram.addServerHeader(self.avId, channel,
STATESERVER_OBJECT_DELETE_RAM)
cleanupDatagram.addUint32(self.avId)
datagram = PyDatagram()
datagram.addServerHeader(channel,
self.gameServicesManager.air.ourChannel,
CLIENTAGENT_ADD_POST_REMOVE)
datagram.addString(cleanupDatagram.getMessage())
self.gameServicesManager.air.send(datagram)
# We will now set the account's days since creation on the client.
creationDate = self.getCreationDate()
accountDays = -1
if creationDate:
now = datetime.fromtimestamp(
time.mktime(time.strptime(time.ctime())))
accountDays = abs((now - creationDate).days)
if accountDays < 0 or accountDays > 4294967295:
accountDays = 100000
self.gameServicesManager.sendUpdateToAccountId(self.target,
'receiveAccountDays',
[accountDays])
# Get the avatar's "true" access (that is, the integer value that corresponds to the assigned string value).
accessLevel = self.account.get('ACCESS_LEVEL', 'NO_ACCESS')
accessLevel = OTPGlobals.accessLevelValues.get(accessLevel, 0)
# We will now activate the avatar on the DBSS.
self.gameServicesManager.air.sendActivate(
self.avId, 0, 0, self.gameServicesManager.air.dclassesByName[
self.gameServicesManager.avatarDclass],
{'setAccessLevel': [accessLevel]})
# Next, we will add them to the avatar channel.
datagram = PyDatagram()
datagram.addServerHeader(channel,
self.gameServicesManager.air.ourChannel,
CLIENTAGENT_OPEN_CHANNEL)
datagram.addChannel(
self.gameServicesManager.GetPuppetConnectionChannel(self.avId))
self.gameServicesManager.air.send(datagram)
# We will now set the avatar as the client's session object.
self.gameServicesManager.air.clientAddSessionObject(channel, self.avId)
# Now we need to set their sender channel to represent their account affiliation.
datagram = PyDatagram()
datagram.addServerHeader(channel,
self.gameServicesManager.air.ourChannel,
CLIENTAGENT_SET_CLIENT_ID)
datagram.addChannel(
self.target << 32
| self.avId) # accountId in high 32 bits, avatar in low.
self.gameServicesManager.air.send(datagram)
# We will now grant ownership.
self.gameServicesManager.air.setOwner(self.avId, channel)
# Tell the friends manager that an avatar is coming online.
friendsList = [x for x, y in self.avatar['setFriendsList'][0]]
self.gameServicesManager.air.ttoffFriendsManager.comingOnline(
self.avId, friendsList)
# Now we'll assign a POST_REMOVE that will tell the friends manager
# that an avatar has gone offline, in the event that they disconnect
# unexpectedly.
if self.gameServicesManager.air.ttoffFriendsManager:
friendsManagerDclass = self.gameServicesManager.air.ttoffFriendsManager.dclass
cleanupDatagram = friendsManagerDclass.aiFormatUpdate(
'goingOffline',
self.gameServicesManager.air.ttoffFriendsManager.doId,
self.gameServicesManager.air.ttoffFriendsManager.doId,
self.gameServicesManager.air.ourChannel, [self.avId])
else:
friendsManagerDoId = OtpDoGlobals.OTP_DO_ID_TTOFF_FRIENDS_MANAGER
friendsManagerDclass = self.gameServicesManager.air.dclassesByName[
'TTOffFriendsManagerUD']
cleanupDatagram = friendsManagerDclass.aiFormatUpdate(
'goingOffline', friendsManagerDoId, friendsManagerDoId,
self.gameServicesManager.air.ourChannel, [self.avId])
datagram = PyDatagram()
datagram.addServerHeader(channel,
self.gameServicesManager.air.ourChannel,
CLIENTAGENT_ADD_POST_REMOVE)
datagram.addString(cleanupDatagram.getMessage())
self.gameServicesManager.air.send(datagram)
# We can now finally shut down this operation.
self.gameServicesManager.air.writeServerEvent('avatar-chosen',
avId=self.avId,
accId=self.target)
self.demand('Off')
def enterSetAvatar(self):
channel = self.csm.GetAccountConnectionChannel(self.target)
# First, give them a POSTREMOVE to unload the avatar, just in case they
# disconnect while we're working.
dgcleanup = PyDatagram()
dgcleanup.addServerHeader(self.avId, channel,
STATESERVER_OBJECT_DELETE_RAM)
dgcleanup.addUint32(self.avId)
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_ADD_POST_REMOVE)
dg.addString(dgcleanup.getMessage())
self.csm.air.send(dg)
# Get the avatar's "true" access. (without "server" bit)
adminAccess = self.account.get('ADMIN_ACCESS', 0)
adminAccess = adminAccess - adminAccess % 100
# Activate the avatar on the DBSS:
self.csm.air.sendActivate(
self.avId, 0, 0, self.csm.air.dclassesByName['DistributedToonUD'],
{'setAdminAccess': [self.account.get('ADMIN_ACCESS', 0)]})
# Next, add them to the avatar channel:
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_OPEN_CHANNEL)
dg.addChannel(self.csm.GetPuppetConnectionChannel(self.avId))
self.csm.air.send(dg)
# Now set their sender channel to represent their account affiliation:
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_SET_CLIENT_ID)
dg.addChannel(self.target << 32
| self.avId) # accountId in high 32 bits, avatar in low
self.csm.air.send(dg)
# Finally, grant ownership and shut down.
dg = PyDatagram()
dg.addServerHeader(self.avId, self.csm.air.ourChannel,
STATESERVER_OBJECT_SET_OWNER)
dg.addChannel(
self.csm.GetAccountConnectionChannel(self.target)
) # Set ownership channel to the connection's account channel.
self.csm.air.send(dg)
# Tell the GlobalPartyManager as well:
self.csm.air.globalPartyMgr.avatarJoined(self.avId)
# Tell everything that an avatar is coming online!
friendsList = [x for x, y in self.avatar['setFriendsList'][0]]
self.csm.air.netMessenger.send('avatarOnline',
[self.avId, friendsList])
# Post-remove for an avatar that disconnects unexpectedly.
dgcleanup = self.csm.air.netMessenger.prepare('avatarOffline',
[self.avId])
dg = PyDatagram()
dg.addServerHeader(channel, self.csm.air.ourChannel,
CLIENTAGENT_ADD_POST_REMOVE)
dg.addString(dgcleanup.getMessage())
self.csm.air.send(dg)
self.csm.air.writeServerEvent('avatar-chosen',
avId=self.avId,
accId=self.target)
self.demand('Off')
def submitSecret(self, secret):
avId = self.air.getAvatarIdFromSender()
av = self.air.doId2do.get(avId)
if not av:
return
secretInfo = self.tfCodes.get(secret)
if not secretInfo:
self.d_submitSecretResponse(avId, 0, 0)
return
friendId = secretInfo[0]
friend = self.air.doId2do.get(friendId)
if av:
if friend:
if avId == friendId:
self.d_submitSecretResponse(avId, 3, 0)
self.removeSecret(secret)
elif len(friend.getFriendsList()
) >= OTPGlobals.MaxFriends or len(
av.getFriendsList()) >= OTPGlobals.MaxFriends:
self.d_submitSecretResponse(avId, 2, friendId)
else:
dg = PyDatagram()
dg.addServerHeader(
self.GetPuppetConnectionChannel(friendId),
self.air.ourChannel, CLIENTAGENT_DECLARE_OBJECT)
dg.addUint32(avId)
dg.addUint16(self.air.dclassesByName['DistributedToonAI'].
getNumber())
self.air.send(dg)
dg = PyDatagram()
dg.addServerHeader(self.GetPuppetConnectionChannel(avId),
self.air.ourChannel,
CLIENTAGENT_DECLARE_OBJECT)
dg.addUint32(friendId)
dg.addUint16(self.air.dclassesByName['DistributedToonAI'].
getNumber())
self.air.send(dg)
friend.extendFriendsList(avId, 1)
av.extendFriendsList(friendId, 1)
friend.d_setFriendsList(friend.getFriendsList())
av.d_setFriendsList(av.getFriendsList())
self.d_submitSecretResponse(avId, 1, friendId)
self.removeSecret(secret)
else:
# Friend is offline!
def handleAvatar(dclass, fields):
if dclass != self.air.dclassesByName['DistributedToonAI']:
return
newFriendsList = []
oldFriendsList = fields['setFriendsList'][0]
if len(oldFriendsList) >= OTPGlobals.MaxFriends:
self.d_submitSecretResponse(avId, 2, friendId)
return
for oldFriend in oldFriendsList:
newFriendsList.append(oldFriend)
newFriendsList.append((avId, 1))
self.air.dbInterface.updateObject(
self.air.dbId, friendId,
self.air.dclassesByName['DistributedToonAI'],
{'setFriendsList': [newFriendsList]})
av.extendFriendsList(friendId, 1)
av.d_setFriendsList(av.getFriendsList())
self.d_submitSecretResponse(avId, 1, friendId)
self.removeSecret(secret)
self.air.dbInterface.queryObject(self.air.dbId, friendId,
handleAvatar)
self.air.writeServerEvent('tf-code-submitted',
avId=avId,
friendId=friendId,
tfCode=secret)
