def makeCommandStringDatagram(self, commandString):
datagram = PyDatagram()
datagram.addUint32(self.packetNumber)
self.packetNumber = self.packetNumber + 1
datagram.addUint8(CLUSTER_COMMAND_STRING)
datagram.addString(commandString)
return datagram
def makeNamedMovementDone(self):
datagram = PyDatagram()
datagram.addUint32(self.packetNumber)
self.packetNumber = self.packetNumber + 1
datagram.addUint8(CLUSTER_NAMED_MOVEMENT_DONE)
return datagram
def createObject(self, objectType):
values = {}
for key, value in values.items():
values[key] = PyDatagram(str(value))
context = self.air.dbObjContext
self.air.dbObjContext += 1
self.air.dbObjMap[context] = self
self.createObjType = objectType
dg = PyDatagram()
dg.addServerHeader(
DBSERVER_ID,
self.air.ourChannel,
DBSERVER_CREATE_STORED_OBJECT)
dg.addUint32(context)
dg.addString('')
dg.addUint16(objectType)
dg.addUint16(len(values))
for field in values.keys():
dg.addString(field)
for value in values.values():
dg.addString(value.getMessage())
self.air.send(dg)
def deleteObject(self):
self.notify.warning('deleting object %s' % self.doId)
dg = PyDatagram()
dg.addServerHeader(DBSERVER_ID, self.air.ourChannel, DBSERVER_DELETE_STORED_OBJECT)
dg.addUint32(self.doId)
dg.addUint32(0xDEADBEEFL)
self.air.send(dg)
def setObjectZone(self, owner, object, zoneId):
if object.zoneId == zoneId:
# No change.
return
oldZoneId = object.zoneId
self.objectsByZoneId[object.zoneId].remove(object)
if not self.objectsByZoneId[object.zoneId]:
del self.objectsByZoneId[object.zoneId]
owner.objectsByZoneId[object.zoneId].remove(object)
if not owner.objectsByZoneId[object.zoneId]:
del owner.objectsByZoneId[object.zoneId]
object.zoneId = zoneId
self.objectsByZoneId.setdefault(zoneId, set()).add(object)
owner.objectsByZoneId.setdefault(zoneId, set()).add(object)
self.updateClientInterestZones(owner)
# Any clients that are listening to oldZoneId but not zoneId
# should receive a disable message: this object has just gone
# out of scope for you.
datagram = PyDatagram()
datagram.addUint16(OBJECT_DISABLE_CMU)
datagram.addUint32(object.doId)
for client in self.zonesToClients[oldZoneId]:
if client != owner:
if zoneId not in client.currentInterestZoneIds:
self.cw.send(datagram, client.connection)
self.needsFlush.add(client)
def requestAvatarInfo(self, avId):
if avId == 0:
return
datagram = PyDatagram()
datagram.addUint16(CLIENT_GET_FRIEND_LIST_EXTENDED)
datagram.addUint16(1)
datagram.addUint32(avId)
base.cr.send(datagram)
def sendOffToons(self, game, zoneid):
for avatar in self.station.avatars:
pkg = PyDatagram()
pkg.addUint16(STATION_HEAD_OFF)
pkg.addUint32(avatar.doId)
pkg.addString(game)
pkg.addUint16(zoneid)
base.sr.sendDatagram(pkg)
def sendClientAddInterest(self, di, connection, handle, contextId, parentId, zoneId): datagram = PyDatagram() datagram.addUint16(CLIENT_DONE_INTEREST_RESP) datagram.addUint16(handle) datagram.addUint32(contextId) client_channel = self.connectionToChannel[connection] if client_channel in self.registeredClients: self.cw.send(datagram, connection)
def sendClientRemoveInterest(self, di, connection, handle, contextId): datagram = PyDatagram() datagram.addUint16(CLIENT_REMOVE_INTEREST) datagram.addUint16(handle) datagram.addUint32(contextId) client_channel = self.connectionToChannel[connection] if client_channel in self.registeredClients: self.cw.send(datagram, connection)
def makeTimeDataDatagram(self, frameCount, frameTime, dt):
datagram = PyDatagram()
datagram.addUint32(self.packetNumber)
self.packetNumber = self.packetNumber + 1
datagram.addUint8(CLUSTER_TIME_DATA)
datagram.addUint32(frameCount)
datagram.addFloat32(frameTime)
datagram.addFloat32(dt)
return datagram
def sendRemoveInterest(self, handle, contextId):
datagram = PyDatagram()
datagram.addUint16(CONTROL_MESSAGE)
datagram.addUint64(sender)
datagram.addUint64(self.ourChannel)
datagram.addUint16(STATESERVER_BOUNCE_MESSAGE)
datagram.addUint16(CLIENT_AGENT_REMOVE_INTEREST)
datagram.addUint16(handle)
datagram.addUint32(contextId)
self.cw.send(datagram, self.connection)
def connectSuccess(self):
""" Successfully connected. But we still can't really do
anything until we send an CLIENT_HELLO message. """
self.makeWaitingText()
dg = PyDatagram()
dg.addUint16(CLIENT_HELLO)
dg.addUint32(self.hashVal)
dg.addString(self.gameVersion)
self.send(dg)
def sendLoginMsg(self):
cr = self.cr
datagram = PyDatagram()
datagram.addUint16(CLIENT_LOGIN_2)
datagram.addString(self.password)
datagram.addString(cr.serverVersion)
datagram.addUint32(cr.hashVal)
self.__addTokenType(datagram)
datagram.addString(cr.validateDownload)
datagram.addString(cr.wantMagicWords)
cr.send(datagram)
def sendLoginMsg(self):
cr = self.cr
datagram = PyDatagram()
datagram.addUint16(CLIENT_LOGIN_3)
datagram.addString(self.DISLToken)
datagram.addString(cr.serverVersion)
datagram.addUint32(cr.hashVal)
datagram.addInt32(CLIENT_LOGIN_3_DISL_TOKEN)
datagram.addString(cr.validateDownload)
datagram.addString(cr.wantMagicWords)
cr.send(datagram)
def sendAvatarGenerate(self):
datagram = PyDatagram()
# Message type is 1
datagram.addUint16(ALL_OBJECT_GENERATE_WITH_REQUIRED)
# Avatar class type is 2
datagram.addUint8(2)
# A sample id
datagram.addUint32(10)
# The only required field is the zone field
datagram.addUint32(999)
self.cw.send(datagram, self.lastConnection)
def makeCamFrustumDatagram(self, focalLength, filmSize, filmOffset):
datagram = PyDatagram()
datagram.addUint32(self.packetNumber)
self.packetNumber = self.packetNumber + 1
datagram.addUint8(CLUSTER_CAM_FRUSTUM)
datagram.addFloat32(focalLength)
datagram.addFloat32(filmSize[0])
datagram.addFloat32(filmSize[1])
datagram.addFloat32(filmOffset[0])
datagram.addFloat32(filmOffset[1])
return datagram
def __sendGetAvatarDetails(self, avId):
# return
self.ttrFriendsManager.d_getAvatarDetails(avId)
return
datagram = PyDatagram()
avatar = self.__queryAvatarMap[avId].avatar
datagram.addUint16(avatar.getRequestID())
datagram.addUint32(avId)
self.send(datagram)
def makeCamOffsetDatagram(self, xyz, hpr):
datagram = PyDatagram()
datagram.addUint32(self.packetNumber)
self.packetNumber = self.packetNumber + 1
datagram.addUint8(CLUSTER_CAM_OFFSET)
datagram.addFloat32(xyz[0])
datagram.addFloat32(xyz[1])
datagram.addFloat32(xyz[2])
datagram.addFloat32(hpr[0])
datagram.addFloat32(hpr[1])
datagram.addFloat32(hpr[2])
return datagram
def removeFriend(self, avatarId):
base.localAvatar.sendUpdate('friendsNotify', [base.localAvatar.doId, 1], sendToId=avatarId)
datagram = PyDatagram()
datagram.addUint16(CLIENT_REMOVE_FRIEND)
datagram.addUint32(avatarId)
self.send(datagram)
self.estateMgr.removeFriend(base.localAvatar.doId, avatarId)
for pair in base.localAvatar.friendsList:
friendId = pair[0]
if friendId == avatarId:
base.localAvatar.friendsList.remove(pair)
return
def makeCamMovementDatagram(self, xyz, hpr):
datagram = PyDatagram()
datagram.addUint32(self.packetNumber)
self.packetNumber = self.packetNumber + 1
datagram.addUint8(CLUSTER_CAM_MOVEMENT)
datagram.addFloat32(xyz[0])
datagram.addFloat32(xyz[1])
datagram.addFloat32(xyz[2])
datagram.addFloat32(hpr[0])
datagram.addFloat32(hpr[1])
datagram.addFloat32(hpr[2])
return datagram
def setAllowClientSend(self, avId, dObj, fieldNameList=[]):
dg = PyDatagram()
dg.addServerHeader(dObj.GetPuppetConnectionChannel(avId), self.ourChannel, CLIENTAGENT_SET_FIELDS_SENDABLE)
fieldIds = []
for fieldName in fieldNameList:
field = dObj.dclass.getFieldByName(fieldName)
if field:
fieldIds.append(field.getNumber())
dg.addUint32(dObj.getDoId())
dg.addUint16(len(fieldIds))
for fieldId in fieldIds:
dg.addUint16(fieldId)
self.send(dg)
def send(self, args = None):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_NPCDEATH)
pkg.addUint32(args[0])
self.cWriter.send(pkg, self.connection)
#self.log('Sent [' + str(Constants.RAND_INT) + '] Int Request')
except:
self.log('Bad [' + str(Constants.RAND_INT) + '] Int Request')
print_exc()
def setFields(self, values):
dg = PyDatagram()
dg.addServerHeader(DBSERVER_ID, self.air.ourChannel, DBSERVER_SET_STORED_VALUES)
dg.addUint32(self.doId)
dg.addUint16(len(values))
items = values.items()
for (field, value) in items:
dg.addString(field)
for (field, value) in items:
dg.addString(value.getMessage())
self.air.send(dg)
def sendAvatarInfoRequests(self, task = None):
print 'Sending request Queue for AV Handles'
if not hasattr(self, 'avatarInfoRequests'):
return
if len(self.avatarInfoRequests) == 0:
return
datagram = PyDatagram()
datagram.addUint16(CLIENT_GET_FRIEND_LIST_EXTENDED)
datagram.addUint16(len(self.avatarInfoRequests))
for avId in self.avatarInfoRequests:
datagram.addUint32(avId)
base.cr.send(datagram)
def getFields(self, fields):
context = self.air.dbObjContext
self.air.dbObjContext += 1
self.air.dbObjMap[context] = self
dg = PyDatagram()
dg.addServerHeader(DBSERVER_ID, self.air.ourChannel, DBSERVER_GET_STORED_VALUES)
dg.addUint32(context)
dg.addUint32(self.doId)
dg.addUint16(len(fields))
for f in fields:
dg.addString(f)
self.air.send(dg)
def checkNameTyped(self, justCheck = False):
self.notify.debug('checkNameTyped')
if self._submitTypeANameAsPickAName():
return
datagram = PyDatagram()
datagram.addUint16(CLIENT_SET_WISHNAME)
if justCheck:
avId = 0
else:
avId = self.avId
datagram.addUint32(avId)
datagram.addString(self.nameEntry.get())
messenger.send('nameShopPost', [datagram])
self.waitForServer()
def sendRequest108(self,task):
if(self.received):
print "->Client request:"
# Send a request to the server
myPyDatagram108 = PyDatagram()
prot = 108
change_Health = raw_input('Change in health (-100 to 100):')
myPyDatagram108.addUint16(prot)
myPyDatagram108.addUint32(change_Health)
self.cWriter.send(myPyDatagram108,self.connection)
self.received = 0
taskMgr.add(self.receiveResponse108,"healthresponse")
def checkNamePattern(self):
self.notify.debug('checkNamePattern')
datagram = PyDatagram()
datagram.addUint16(CLIENT_SET_NAME_PATTERN)
datagram.addUint32(self.avId)
datagram.addInt16(self.nameIndices[0])
datagram.addInt16(self.nameFlags[0])
datagram.addInt16(self.nameIndices[1])
datagram.addInt16(self.nameFlags[1])
datagram.addInt16(self.nameIndices[2])
datagram.addInt16(self.nameFlags[2])
datagram.addInt16(self.nameIndices[3])
datagram.addInt16(self.nameFlags[3])
messenger.send('nameShopPost', [datagram])
self.waitForServer()
def __handleCongrats(self, avatarChoice):
self.acceptedBanner.destroy()
self.acceptedText.destroy()
self.okButton.destroy()
self.acceptedScreen.removeNode()
del self.acceptedScreen
del self.okButton
del self.acceptedText
del self.acceptedBanner
datagram = PyDatagram()
datagram.addUint16(CLIENT_SET_WISHNAME_CLEAR)
datagram.addUint32(avatarChoice.id)
datagram.addUint8(1)
self.send(datagram)
self.loginFSM.request('waitForSetAvatarResponse', [avatarChoice])
def __handleReject(self, avList, index):
self.rejectDialog.cleanup()
datagram = PyDatagram()
datagram.addUint16(CLIENT_SET_WISHNAME_CLEAR)
avid = 0
for k in avList:
if k.position == index:
avid = k.id
if avid == 0:
self.notify.error('Avatar rejected not found in avList. Index is: ' + str(index))
datagram.addUint32(avid)
datagram.addUint8(0)
self.send(datagram)
self.loginFSM.request('waitForAvatarList')
def sendLoginMsg(self):
cr = self.cr
datagram = PyDatagram()
if self.useTTSpecificLogin:
datagram.addUint16(CLIENT_LOGIN_TOONTOWN)
self.__addPlayToken(datagram)
datagram.addString(cr.serverVersion)
datagram.addUint32(cr.hashVal)
self.__addTokenType(datagram)
datagram.addString(cr.wantMagicWords)
else:
datagram.addUint16(CLIENT_LOGIN_2)
self.__addPlayToken(datagram)
datagram.addString(cr.serverVersion)
datagram.addUint32(cr.hashVal)
self.__addTokenType(datagram)
datagram.addString(cr.validateDownload)
datagram.addString(cr.wantMagicWords)
cr.send(datagram)
def requestSecret(self, requesterId):
"""
Requests a "secret" from the database server. This is a
unique string that will be associated with the indicated
requesterId, for the purposes of authenticating true-life
friends.
When the secret is ready, a "requestSecretReply" message will
be thrown with three parameters: the result code (0 or 1,
indicating failure or success), the generated secret, and the
requesterId again.
"""
datagram = PyDatagram()
datagram.addServerHeader(DBSERVER_ID,self.ourChannel,DBSERVER_REQUEST_SECRET)
# Indicate the number we want to associate with the new secret.
datagram.addUint32(requesterId)
# Send it off!
self.send(datagram)
def makeFriends(self, avatarAId, avatarBId, flags, context):
"""
Requests to make a friendship between avatarA and avatarB with
the indicated flags (or upgrade an existing friendship with
the indicated flags). The context is any arbitrary 32-bit
integer. When the friendship is made, or the operation fails,
the "makeFriendsReply" event is generated, with two
parameters: an integer result code, and the supplied context.
"""
datagram = PyDatagram()
datagram.addServerHeader(DBSERVER_ID, self.ourChannel,
DBSERVER_MAKE_FRIENDS)
# Indicate the two avatars who are making friends
datagram.addUint32(avatarAId)
datagram.addUint32(avatarBId)
datagram.addUint8(flags)
datagram.addUint32(context)
self.send(datagram)
def createObject(self, objectType):
# If we just want the default values for the new object's fields,
# there's no need to specify any field values here. (Upon generation,
# fields that are not stored in the database are assigned their
# default values).
# In the future, when creating an object in the DB, we may want
# to provide values that differ from the default; this dict is
# the place to put those values.
# Note that the values in this dict must be specially formatted in
# a datagram; I haven't sussed that out. See self.reload() and
# AIDistUpdate.insertArg().
values = {}
for key, value in list(values.items()):
values[key] = PyDatagram(str(value))
# objectType is an integer that the DB uses to distinguish object
# types, i.e. ToontownAIMsgTypes.DBSERVER_PET_OBJECT_TYPE
assert type(objectType) is int
# Get a unique context for this query and associate ourselves
# in the map.
context = self.air.dbObjContext
self.air.dbObjContext += 1
self.air.dbObjMap[context] = self
self.createObjType = objectType
dg = PyDatagram()
dg.addServerHeader(DBSERVER_ID, self.air.ourChannel,
DBSERVER_CREATE_STORED_OBJECT)
dg.addUint32(context)
dg.addString('')
dg.addUint16(objectType)
dg.addUint16(len(values))
for field in list(values.keys()):
dg.addString(field)
for value in list(values.values()):
dg.addString(value.getMessage())
self.air.send(dg)
def submitSecret(self, requesterId, secret):
"""
Submits a "secret" back to the database server for validation.
This attempts to match the indicated string, entered by the
user, to a string returned by a previous call to
requestSecret().
When the response comes back from the server, a
"submitSecretReply" message will be thrown with four
parameters: the result code (0 or 1, indicating failure or
success), the secret again, the requesterId again, and the
number associated with the original secret (that is, the
original requesterId).
"""
datagram = PyDatagram()
datagram.addServerHeader(
DBSERVER_ID, self.ourChannel, DBSERVER_SUBMIT_SECRET)
# Pass in our identifying number, and the string.
datagram.addUint32(requesterId)
datagram.addString(secret)
self.send(datagram)
def makeNamedObjectMovementDatagram(self, xyz, hpr, scale, color, hidden, name):
datagram = PyDatagram()
datagram.addUint32(self.packetNumber)
self.packetNumber = self.packetNumber + 1
datagram.addUint8(CLUSTER_NAMED_OBJECT_MOVEMENT)
datagram.addString(name)
datagram.addFloat32(xyz[0])
datagram.addFloat32(xyz[1])
datagram.addFloat32(xyz[2])
datagram.addFloat32(hpr[0])
datagram.addFloat32(hpr[1])
datagram.addFloat32(hpr[2])
datagram.addFloat32(scale[0])
datagram.addFloat32(scale[1])
datagram.addFloat32(scale[2])
datagram.addFloat32(color[0])
datagram.addFloat32(color[1])
datagram.addFloat32(color[2])
datagram.addFloat32(color[3])
datagram.addBool(hidden)
return datagram
def handleConnected(self):
OTPInternalRepository.handleConnected(self)
# register the AI on the state server...
dg = PyDatagram()
dg.addServerHeader(self.serverId, self.ourChannel,
STATESERVER_ADD_SHARD)
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)
# create the AI globals...
self.createGlobals()
self.createZones()
def setAvatar(self, fields, avId, sender):
accId = self.GetAccountConnectionChannel(sender)
# Give a POST_REMOVE to unload the avatar just
# in case we lose connection while working.
dgc = PyDatagram()
dgc.addServerHeader(avId, accId,
STATESERVER_OBJECT_DELETE_RAM)
dgc.addUint32(avId)
dg = PyDatagram()
dg.addServerHeader(accId,
self.air.ourChannel,
CLIENTAGENT_ADD_POST_REMOVE)
dg.addString(dgc.getMessage())
self.air.send(dg)
# Activate the avatar on the db stateserver.
self.air.sendActivate(avId, 0, 0, self.air.dclassesByName['DistributedToonUD'])
# Add the connection to the avatar channel.
dg = PyDatagram()
dg.addServerHeader(accId, self.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL)
dg.addChannel(self.GetPuppetConnectionChannel(avId))
self.air.send(dg)
# Set the sender channel to represent their account affiliation.
dg = PyDatagram()
dg.addServerHeader(accId, self.air.ourChannel,
CLIENTAGENT_SET_CLIENT_ID)
dg.addChannel(sender << 32 | avId)
self.air.send(dg)
# Grant the client ownership of the avatar.
dg = PyDatagram()
dg.addServerHeader(avId, self.air.ourChannel, STATESERVER_OBJECT_SET_OWNER)
dg.addChannel(sender << 32 | avId)
self.air.send(dg)
# Tell the friends manager a toon has gone online.
self.__handleToonOnline(avId)
def sendSetLocation(self, doId, parentId, zoneId):
dg = PyDatagram()
dg.addUint16(CLIENT_OBJECT_LOCATION)
dg.addUint32(doId)
dg.addUint32(parentId)
dg.addUint32(zoneId)
self.send(dg)
def setObjectZone(self, owner, object, zoneId):
if object.zoneId == zoneId:
# No change.
return
oldZoneId = object.zoneId
self.objectsByZoneId[object.zoneId].remove(object)
if not self.objectsByZoneId[object.zoneId]:
del self.objectsByZoneId[object.zoneId]
owner.objectsByZoneId[object.zoneId].remove(object)
if not owner.objectsByZoneId[object.zoneId]:
del owner.objectsByZoneId[object.zoneId]
object.zoneId = zoneId
self.objectsByZoneId.setdefault(zoneId, set()).add(object)
owner.objectsByZoneId.setdefault(zoneId, set()).add(object)
self.updateClientInterestZones(owner)
# Any clients that are listening to oldZoneId but not zoneId
# should receive a disable message: this object has just gone
# out of scope for you.
datagram = PyDatagram()
datagram.addUint16(OBJECT_DISABLE_CMU)
datagram.addUint32(object.doId)
for client in self.zonesToClients[oldZoneId]:
if client != owner:
if zoneId not in client.currentInterestZoneIds:
self.cw.send(datagram, client.connection)
self.needsFlush.add(client)
def sendUpdateToChannel(self, distObj, channelId, fieldName, args):
""" Sends a targeted update of a single field to a particular
client. The top 32 bits of channelId is ignored; the lower 32
bits should be the client Id of the recipient (i.e. the
client's doIdbase). The field update will be sent to the
indicated client only. The field must be marked clsend or
p2p, and may not be marked broadcast. """
datagram = distObj.dclass.clientFormatUpdate(fieldName, distObj.doId,
args)
dgi = PyDatagramIterator(datagram)
# Reformat the packed datagram to change the message type and
# add the target id.
dgi.getUint16()
dg = PyDatagram()
dg.addUint16(CLIENT_OBJECT_UPDATE_FIELD_TARGETED_CMU)
dg.addUint32(channelId & 0xffffffff)
dg.appendData(dgi.getRemainingBytes())
self.send(dg)
def sendLoginMsg(self):
"""
Send a message to the server with our loginName
"""
cr = self.cr
# Time to send a login message
datagram = PyDatagram()
# Add message type
datagram.addUint16(CLIENT_LOGIN_2)
# Add the token--this has been stored as the password.
datagram.addString(self.password)
# Add the Server Version ID
datagram.addString(cr.serverVersion)
# Add the dc file hash
datagram.addUint32(cr.hashVal)
self.__addTokenType(datagram)
# Add the download verification string.
datagram.addString(cr.validateDownload)
# And the magic word enable string.
datagram.addString(cr.wantMagicWords)
# Send the message
cr.send(datagram)
def createObject(self, databaseId, dclass, fields={}, callback=None):
"""
Create an object in the specified database.
databaseId specifies the control channel of the target database.
dclass specifies the class of the object to be created.
fields is a dict with any fields that should be stored in the object on creation.
callback will be called with callback(doId) if specified. On failure, doId is 0.
"""
# Save the callback:
ctx = self.air.getContext()
self._callbacks[ctx] = callback
# Pack up/count valid fields.
fieldPacker = DCPacker()
fieldCount = 0
for k, v in fields.items():
field = dclass.getFieldByName(k)
if not field:
self.notify.error('Creation request for %s object contains '
'invalid field named %s' %
(dclass.getName(), k))
fieldPacker.rawPackUint16(field.getNumber())
fieldPacker.beginPack(field)
field.packArgs(fieldPacker, v)
fieldPacker.endPack()
fieldCount += 1
# Now generate and send the datagram:
dg = PyDatagram()
dg.addServerHeader(databaseId, self.air.ourChannel,
DBSERVER_CREATE_OBJECT)
dg.addUint32(ctx)
dg.addUint16(dclass.getNumber())
dg.addUint16(fieldCount)
dg.appendData(fieldPacker.getString())
self.air.send(dg)
def handle_client_login(self, dgi, connection):
# TODO - dynamically set user info from the DBServer
token = dgi.getString()
self.logger.debug("logging in user %s" % token)
# TODO - sanity checks
serverVersion = dgi.getString()
hashVal = dgi.getInt32()
dg = PyDatagram()
dg.addUint16(msg_types.CLIENT_LOGIN_2_RESP)
dg.addUint8(0) # returnCode
dg.addString("") # errorString
# begin account details
dg.addString(token) # username
dg.addUint8(0) # secretChatAllowed
dg.addUint32(int(time.time())) # sec
dg.addUint32(int(time.clock())) # usec
dg.addUint8(1) # isPaid
self.cWriter.send(dg, connection)
def createObject(self, objectType):
values = { }
for (key, value) in values.items():
values[key] = PyDatagram(str(value))
context = self.air.dbObjContext
self.air.dbObjContext += 1
self.air.dbObjMap[context] = self
self.createObjType = objectType
dg = PyDatagram()
dg.addServerHeader(DBSERVER_ID, self.air.ourChannel, DBSERVER_CREATE_STORED_OBJECT)
dg.addUint32(context)
dg.addString('')
dg.addUint16(objectType)
dg.addUint16(len(values))
for field in values.keys():
dg.addString(field)
for value in values.values():
dg.addString(value.getMessage())
self.air.send(dg)
def updateClientInterestZones(self, client):
origZoneIds = client.currentInterestZoneIds
newZoneIds = client.explicitInterestZoneIds | set(
client.objectsByZoneId.keys())
if origZoneIds == newZoneIds:
# No change.
return
client.currentInterestZoneIds = newZoneIds
addedZoneIds = newZoneIds - origZoneIds
removedZoneIds = origZoneIds - newZoneIds
dg = PyDatagram()
dg.addUint16(NetMessages.SV_GenerateObject)
for zoneId in addedZoneIds:
self.zonesToClients.setdefault(zoneId, set()).add(client)
# The client is opening interest in this zone. Need to inform
# client of all objects in this zone.
for object in self.objectsByZoneId.get(zoneId, []):
if object.owner != client:
# Don't do this if the client owns the object, it should
# already be generated for them.
self.packObjectGenerate(dg, object)
self.sendDatagram(dg, client.connection)
dg = PyDatagram()
dg.addUint16(NetMessages.SV_DeleteObject)
for zoneId in removedZoneIds:
self.zonesToClients[zoneId].remove(client)
# The client is abandoning interest in this zone. Any
# objects in this zone should be deleted on the client.
for object in self.objectsByZoneId.get(zoneId, []):
if object.owner != client:
# Never delete objects owned by this client on interest change.
dg.addUint32(object.doId)
self.sendDatagram(dg, client.connection)
def handle_get_avatars(self, connection, di):
## Send the client OUR AVATARS (TODO)
datagram = PyDatagram()
#datagram.addUint16(0) #dummy
datagram.addUint16(CLIENT_GET_AVATARS_RESP) #msgType
datagram.addUint8(0) #ReturnCode (uint8)
datagram.addUint16(1) #How many toons does this user have? (uint16)
## lets give our client a avatar.
datagram.addUint32(1) #avNum (uint32)
datagram.addString('Toon') #avNames 1 (string)
datagram.addString('') #avNames 2 (string)
datagram.addString('') #avNames 3 (string)
datagram.addString('') #avNames 4 (string)
datagram.addString(
"t\x00\x02\x02\x01\x00\x00\x00\x00\x00\x01\22\x00\22\22"
) #avDNA (hex)
datagram.addUint8(1) #avPosition (uint8)
datagram.addUint8(1) #avName pos (uint8)
self.cw.send(datagram, connection)
def sendLoginMsg(self):
"""
Send a message to the server with our loginName
"""
cr = self.cr
# Time to send a login message
datagram = PyDatagram()
# Add message type
datagram.addUint16(CLIENT_LOGIN_3)
# Add the token
datagram.addString(self.DISLToken)
# Add the Server Version ID
datagram.addString(cr.serverVersion)
# Add the dc file hash
datagram.addUint32(cr.hashVal)
# Token type
datagram.addInt32(CLIENT_LOGIN_3_DISL_TOKEN)
# Add the download verification string.
datagram.addString(cr.validateDownload)
# And the magic word enable string.
datagram.addString(cr.wantMagicWords)
# Send the message
cr.send(datagram)
def handle_set_avatar(self, connection, di):
## Send the client HIS character's info.
## TODO: NOT SEND STATIC INFO
datagram = PyDatagram()
#datagram.addUint16(0) #dummy
datagram.addUint32(CLIENT_GET_AVATAR_DETAILS_RESP) #msgType
datagram.addUint32(1) #avatarId (uint32)
datagram.addUint8(0) #returnCode (uint8)
## NOW, HERE COMES THE GOOD PART
datagram.addString(
"t\x00\x02\x02\x01\x00\x00\x00\x00\x00\x01\22\x00\22\22"
) #setDNAString
datagram.addInt16(1000) #setMaxBankMoney
datagram.addInt16(0) #setMoney
datagram.addInt16(40) #setMaxMoney
datagram.addInt16(15) #setMaxHP
datagram.addInt16(15) #setHP
self.cw.send(datagram, connection)
def game_start(self):
base.oobe()
self.display_text.setText("Begin")
pkg = PyDatagram()
pkg.addUint16(GAME_INITIALIZE)
pkg.addUint32(self.network.playerCount)
for client_id in self.network.CLIENTS_ID:
x = random.randint(1, 5)
y = random.randint(1, 5)
self.gameEngine.players.append(Player(x, y, 20, client_id))
self.gameEngine.world.attachCharacter(
self.gameEngine.players[client_id].playerNP.node())
pkg.addUint32(client_id)
pkg.addFloat32(x)
pkg.addFloat32(y)
for client_id in self.network.CLIENTS_ID:
temp = pkg.__copy__()
temp.addUint32(client_id)
self.network.cWriter.send(temp,
self.network.RELATION_OBJ_ID[client_id])
# taskMgr.add(self.update, 'update')
self.clientsAlive = self.network.CLIENTS_ID.copy()
self.display_text.destroy()
def sendLoginMsg(self):
"""
Send a message to the game server with our playToken.
"""
assert "playToken" in self.__dict__ # Hey, there's no playToken.
#...no error code in the response, so we have a play token.
cr = self.cr
# Time to send a login message
datagram = PyDatagram()
# Add message type
if self.useTTSpecificLogin:
datagram.addUint16(CLIENT_LOGIN_TOONTOWN)
self.__addPlayToken(datagram)
# Add the Server Version ID
datagram.addString(cr.serverVersion)
# Add the dc file hash
datagram.addUint32(cr.hashVal)
self.__addTokenType(datagram)
# Add the download verification string.
# new version doesn't have this field
# datagram.addString(cr.validateDownload)
# And the magic word enable string.
datagram.addString(cr.wantMagicWords)
else:
datagram.addUint16(CLIENT_LOGIN_2)
self.__addPlayToken(datagram)
# Add the Server Version ID
datagram.addString(cr.serverVersion)
# Add the dc file hash
datagram.addUint32(cr.hashVal)
self.__addTokenType(datagram)
# Add the download verification string.
datagram.addString(cr.validateDownload)
# And the magic word enable string.
datagram.addString(cr.wantMagicWords)
# Send the message
cr.send(datagram)
def sendLoginMsg(self):
"""
Send a message to the server with our loginName
"""
DISLID = ConfigVariableInt('fake-DISL-PlayerAccountId',0).getValue()
if not DISLID:
NameStringId = ("DISLID_%s" % (self.loginName))
DISLID = ConfigVariableInt(NameStringId, 0).getValue()
cr=self.cr
# Time to send a login message
datagram = PyDatagram()
# Add message type
datagram.addUint16(CLIENT_LOGIN)
# Add login name
datagram.addString(self.loginName)
# Add our IP address
if cr.connectMethod != cr.CM_HTTP:
datagram.addUint32(cr.tcpConn.getAddress().getIp())
else:
# Actually, using the OpenSSL library we don't know our
# own IP address. But no one really cares anyway.
datagram.addUint32(0)
# Add the UDP port we will be listening on. (Bogus for now)
datagram.addUint16(5150)
# Add the Server Version ID
datagram.addString(cr.serverVersion)
# Add the dc file hash
datagram.addUint32(cr.hashVal)
# Add password
datagram.addString(self.password)
# Add create flag
datagram.addBool(self.createFlag)
# Add the download verification string.
datagram.addString(cr.validateDownload)
# And the magic word enable string.
datagram.addString(cr.wantMagicWords)
# And our dev fake DISL account ID
datagram.addUint32(DISLID)
# Whether or not to enable OTP_WHITELIST
datagram.addString(ConfigVariableString('otp-whitelist',"YES").getValue())
# Send the message
cr.send(datagram)
def handleClientCreateObject(self, datagram, dgi):
""" client wants to create an object, so we store appropriate
data, and then pass message along to corresponding zones """
connection = datagram.getConnection()
zoneId = dgi.getUint32()
classId = dgi.getUint16()
doId = dgi.getUint32()
client = self.clientsByConnection[connection]
if self.getDoIdBase(doId) != client.doIdBase:
self.notify.warning(
"Ignoring attempt to create invalid doId %s from client %s" %
(doId, client.doIdBase))
return
dclass = self.dclassesByNumber[classId]
object = client.objectsByDoId.get(doId)
if object:
# This doId is already in use; thus, this message is
# really just an update.
if object.dclass != dclass:
self.notify.warning(
"Ignoring attempt to change object %s from %s to %s by client %s"
% (doId, object.dclass.getName(), dclass.getName(),
client.doIdBase))
return
self.setObjectZone(client, object, zoneId)
else:
if self.notify.getDebug():
self.notify.debug(
"Creating object %s of type %s by client %s" %
(doId, dclass.getName(), client.doIdBase))
object = self.Object(doId, zoneId, dclass)
client.objectsByDoId[doId] = object
client.objectsByZoneId.setdefault(zoneId, set()).add(object)
self.objectsByZoneId.setdefault(zoneId, set()).add(object)
self.updateClientInterestZones(client)
# Rebuild the new datagram that we'll send on. We shim in the
# doIdBase of the owner.
dg = PyDatagram()
dg.addUint16(OBJECT_GENERATE_CMU)
dg.addUint32(client.doIdBase)
dg.addUint32(zoneId)
dg.addUint16(classId)
dg.addUint32(doId)
dg.appendData(dgi.getRemainingBytes())
self.sendToZoneExcept(zoneId, dg, [client])
def sendLoginMsg(self):
DISLID = config.GetInt('fake-DISL-PlayerAccountId', 0)
if not DISLID:
NameStringId = 'DISLID_%s' % self.loginName
DISLID = config.GetInt(NameStringId, 0)
cr = self.cr
datagram = PyDatagram()
datagram.addUint16(CLIENT_LOGIN)
datagram.addString(self.loginName)
if cr.connectMethod != cr.CM_HTTP:
datagram.addUint32(cr.tcpConn.getAddress().getIp())
else:
datagram.addUint32(0)
datagram.addUint16(5150)
datagram.addString(cr.serverVersion)
datagram.addUint32(cr.hashVal)
datagram.addString(self.password)
datagram.addBool(self.createFlag)
datagram.addString(cr.validateDownload)
datagram.addString(cr.wantMagicWords)
datagram.addUint32(DISLID)
datagram.addString(config.GetString('otp-whitelist', 'YES'))
cr.send(datagram)
def handleClientLoginToontown(self, di, conn):
if(MAINTENANCE == True):
dg = PyDatagram()
dg.addUint16(CLIENT_GO_GET_LOST)
dg.addUint16(151)
dg.addString('The servers are currently closed for maintenance.')
self.cw.send(dg, conn)
else:
token = di.getString()
sv = di.getString()
if (token != 'daXy321/4432125/DSaGSX=='):
self.notify.warning('Client doesn\'t have temporary token, booting.')
dg = PyDatagram()
dg.addUint16(CLIENT_GO_GET_LOST)
dg.addUint16(101)
dg.addString('Login token: %s doesn\'t exist.' % token)
self.cw.send(dg, conn)
elif (sv != SERVER_VERSION):
self.notify.warning('Booting client out.')
dg = PyDatagram()
dg.addUint16(CLIENT_GO_GET_LOST)
dg.addUint16(124)
dg.addString('Client and Server version do not match. Server is running ' + SERVER_VERSION + ', while client was running ' + sv + '.')
self.cw.send(dg, conn)
else:
now = datetime.now
dg = PyDatagram()
dg.addUint16(CLIENT_LOGIN_TOONTOWN_RESP)
dg.addUint8(0) #Return Code
dg.addString('OK') #respString
dg.addUint32(123456) #Account Number
dg.addString('Infinity') #Account Name
dg.addUint8(1) #accountNameApproved
dg.addString('YES') #self.openChatEnabled
dg.addString('YES') #self.createFriendsWithChat
dg.addString('YES') #chatCodeCreationRule
dg.addUint32(time.time()) #sec?
dg.addUint32(time.clock()) #usec?
dg.addString('FULL') #self.isPaid
dg.addString('YES') #WhiteListReponse
dg.addString(time.strftime('%Y-%m-%d'))#lastLoggedInStr
dg.addInt32(0) #accountDays
dg.addString('NO_PARENT_ACCOUNT')
dg.addString('Infinity')
self.cw.send(dg, conn)
def sendRequest113(self):
if (self.received):
print "->Client request:"
# Send a request to the server
myPyDatagram113 = PyDatagram()
prot = 113
myPyDatagram113.addUint16(prot)
print MyApp.uname + '-------'
if MyApp.uname == 'chintan':
myPyDatagram113.addUint32(18)
elif MyApp.uname == 'paras':
myPyDatagram113.addUint32(35)
else:
myPyDatagram113.addUint32(3)
self.cWriter.send(myPyDatagram113, self.connection)
self.received = 0
#taskMgr.add(self.updateRoutine,'update113')
#taskMgr.doMethodLater(1,self.sendRequest301,'HeatBeat')
MyApp.retrieve113(self)
def sendRequest106(self, task):
if (self.received):
print "->Client request:"
# Send a request to the server
myPyDatagram106 = PyDatagram()
prot = 106
xpos = raw_input('X Position :')
ypos = raw_input('Y Position :')
zpos = raw_input('Z Position :')
hpos = raw_input('Heading (0 to 360):')
ismoving = raw_input('Moving ? -- 0 for NO , 1 for YES :')
myPyDatagram106.addUint16(prot)
myPyDatagram106.addUint32(xpos)
myPyDatagram106.addUint32(ypos)
myPyDatagram106.addUint32(zpos)
myPyDatagram106.addUint32(hpos)
myPyDatagram106.addUint32(ismoving)
self.cWriter.send(myPyDatagram106, self.connection)
self.received = 0
taskMgr.add(self.receiveResponse106, "characterresponse")
def sendLoginMsg(self):
cr = self.cr
tokenString = ''
access = base.config.GetString('force-paid-status', '')
if access == '':
access = 'FULL'
elif access == 'paid':
access = 'FULL'
elif access == 'unpaid':
access = 'VELVET_ROPE'
elif access == 'VELVET':
access = 'VELVET_ROPE'
else:
self.notify.error(
"don't know what to do with force-paid-status %s" % access)
tokenString += 'TOONTOWN_ACCESS=%s&' % access
tokenString += 'TOONTOWN_GAME_KEY=%s&' % self.loginName
wlChatEnabled = 'YES'
if base.config.GetString('otp-whitelist', 'YES') == 'NO':
wlChatEnabled = 'NO'
tokenString += 'WL_CHAT_ENABLED=%s &' % wlChatEnabled
openChatEnabled = 'NO'
if cr.openChatAllowed:
openChatEnabled = 'YES'
tokenString += 'OPEN_CHAT_ENABLED=%s&' % openChatEnabled
createFriendsWithChat = 'NO'
if cr.allowSecretChat:
createFriendsWithChat = 'CODE'
tokenString += 'CREATE_FRIENDS_WITH_CHAT=%s&' % createFriendsWithChat
chatCodeCreationRule = 'No'
if cr.allowSecretChat:
if base.config.GetBool('secret-chat-needs-parent-password', 0):
chatCodeCreationRule = 'PARENT'
else:
chatCodeCreationRule = 'YES'
tokenString += 'CHAT_CODE_CREATION_RULE=%s&' % chatCodeCreationRule
DISLID = config.GetInt('fake-DISL-PlayerAccountId', 0)
if not DISLID:
NameStringId = 'DISLID_%s' % self.loginName
DISLID = config.GetInt(NameStringId, 0)
tokenString += 'ACCOUNT_NUMBER=%d&' % DISLID
tokenString += 'ACCOUNT_NAME=%s&' % self.loginName
tokenString += 'GAME_USERNAME=%s&' % self.loginName
tokenString += 'ACCOUNT_NAME_APPROVED=TRUE&'
tokenString += 'FAMILY_NUMBER=&'
tokenString += 'Deployment=US&'
withParentAccount = base.config.GetBool('dev-with-parent-account', 0)
if withParentAccount:
tokenString += 'TOON_ACCOUNT_TYPE=WITH_PARENT_ACCOUNT&'
else:
tokenString += 'TOON_ACCOUNT_TYPE=NO_PARENT_ACCOUNT&'
tokenString += 'valid=true'
self.notify.info('tokenString=\n%s' % tokenString)
datagram = PyDatagram()
datagram.addUint16(CLIENT_LOGIN_TOONTOWN)
playToken = tokenString
datagram.addString(playToken)
datagram.addString('dev')
datagram.addUint32(cr.hashVal)
datagram.addUint32(4)
magicWords = base.config.GetString('want-magic-words', '')
datagram.addString(magicWords)
cr.send(datagram)
def makeSwapReadyDatagram(self):
datagram = PyDatagram()
datagram.addUint32(self.packetNumber)
self.packetNumber = self.packetNumber + 1
datagram.addUint8(CLUSTER_SWAP_READY)
return datagram
def makeExitDatagram(self):
datagram = PyDatagram()
datagram.addUint32(self.packetNumber)
self.packetNumber = self.packetNumber + 1
datagram.addUint8(CLUSTER_EXIT)
return datagram
