def resendLoginCookie(self):
cr = self.cr
datagram = PyDatagram()
datagram.addUint16(CLIENT_SET_SECURITY)
self.__addLoginCookie(datagram)
self.__addTokenType(datagram)
cr.send(datagram)
def resendPlayToken(self):
cr = self.cr
datagram = PyDatagram()
datagram.addUint16(CLIENT_SET_SECURITY)
self._LoginTTAccount__addPlayToken(datagram)
self._LoginTTAccount__addTokenType(datagram)
cr.send(datagram)
def sendMagicWord(self, word, targetId):
invokerId = self.air.getAvatarIdFromSender()
invoker = self.air.doId2do.get(invokerId)
if not 'DistributedToonAI' in str(self.air.doId2do.get(targetId)):
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', ['Target is not a toon object!'])
return
if not invoker:
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', ['missing invoker'])
return
if invoker.getAdminAccess() < MINIMUM_MAGICWORD_ACCESS:
self.air.writeServerEvent('suspicious', invokerId, 'Attempted to issue magic word: %s' % word)
dg = PyDatagram()
dg.addServerHeader(self.GetPuppetConnectionChannel(invokerId), self.air.ourChannel, CLIENTAGENT_EJECT)
dg.addUint16(102)
dg.addString('Magic Words are reserved for administrators only!')
self.air.send(dg)
return
target = self.air.doId2do.get(targetId)
if not target:
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', ['missing target'])
return
response = spellbook.process(invoker, target, word)
if response:
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', [response])
self.air.writeServerEvent('magic-word',
invokerId, invoker.getAdminAccess(),
targetId, target.getAdminAccess(),
word, response)
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 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 handle_create_account_request(self, netmgr, connection, username, password):
file_path = self.directory_path + str(username) + self.database_file_ext
self.netmgr = netmgr
data = {
"account_name": str(username),
"account_password": str(password)
}
if os.path.exists(file_path):
print ("Could not create account with username %s because it already exists." % username)
return
with open(file_path, 'w+') as file:
json.dump(data, file)
if os.path.exists(file_path):
datagram = PyDatagram()
datagram.addUint16(REQUEST_FOR_REGISTER_RESP)
datagram.addUint8(0)
datagram.addString("Successfully registered account! Now try to login!")
self.netmgr.send_response(connection, datagram)
print ("Database: Client %s Successfully registered an account with the name %s" % (connection, username))
else:
datagram = PyDatagram()
datagram.addUint16(REQUEST_FOR_REGISTER_RESP)
datagram.addUint8(1)
datagram.addString("Failed to create account, please contact customer support!")
self.netmgr.send_response(connection, datagram)
return
file.close()
def sendGameStatus():
px,py,pz = ballBody.getPosition()
prot = ballBody.getRotation()
r1,r2,r3,r4 = row1.getZ(), row2.getZ(), row3.getZ(), row4.getZ()
o1,o2,o3,o4 = rrow1.getZ(), rrow2.getZ(), rrow3.getZ(), rrow4.getZ()
rot = [None]*4
for i in range(0,4):
rot[i] = kicker[i].getH()
status = PyDatagram()
status.addUint16(PACKET_SET)
status.addFloat64(px)
status.addFloat64(py)
status.addFloat64(pz)
for r in range(9): #just to be explicit
status.addFloat64(prot[i])
status.addFloat64(r1)
status.addFloat64(r2)
status.addFloat64(r3)
status.addFloat64(r4)
status.addFloat64(o1)
status.addFloat64(o2)
status.addFloat64(o3)
status.addFloat64(o4)
for i in range(0,4):
status.addFloat64(rot[i])
toAll(status, activeConnections)
def disconnect(task):
dg = PyDatagram()
dg.addServerHeader(10, simbase.air.ourChannel, CLIENTAGENT_EJECT)
dg.addUint16(154)
dg.addString('Toontown Fellowship is now closed for maintenance.')
simbase.air.send(dg)
return Task.done
def sendMove(mx, my): move = PyDatagram() move.addUint16(PACKET_MOVE) sgn = (mode == MODE_2P or MY_POSITION>1) and -1 or 1 move.addFloat64(sgn*mx) move.addFloat64(sgn*my) cWriter.send(move, serverConnection)
def doAuth(self, opcode, data, _client):
"""
Handle auth for a single client connecting
"""
## Get the client id
newClientId = data.getString()
print "Server: New client connected -", newClientId
self.server.serverState.lastJoinedClientId = newClientId
# Create the player into the server players holder
self.server.serverState.newClientPlayerObj(newClientId, _client)
# Get all connected clientPlayers states and ids
#for conn in self.connections:
for client in self.clients:
clId = self.clients[client].id
clState = self.clients[client].state
# Create buffer
pkg = PyDatagram()
# Add response
pkg.addUint16(cmdToClient_authResponse)
pkg.addString(clId)
pkg.addString(str(clState.pos))
pkg.addString(str(clState.t))
self.networkMgr.tcpWriter.send(pkg, _client)
# maybe add a if to check to update other players about the new guy
# tell other connected players about the new player
newClientState = self.clients[newClientId].state
self.server.serverState.broadcastNewClient(newClientId, newClientState)
def close_connection(self, code, reason, connection):
datagram = PyDatagram()
datagram.addUint16(CLIENT_GO_GET_LOST)
datagram.addUint16(int(code))
datagram.addString(str(reason))
self.cw.send(datagram, connection)
self.remove_connection_instance(connection)
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 sendSetLocation(self, doId, parentId, zoneId):
""" Called by b_setLocation """
dg = PyDatagram()
dg.addUint16(CLIENT_OBJECT_LOCATION)
dg.addUint32(doId)
dg.addUint32(parentId)
dg.addUint32(zoneId)
self.send(dg)
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 route_message(self, di, datagram, reciever_channel, sender_channel):
dg = PyDatagram()
dg.addUint64(reciever_channel)
dg.addUint64(sender_channel)
dg.addUint16(di.getUint16())
dg.appendData(di.getRemainingBytes())
self.cw.send(dg, self.interface.registeredParticipants[reciever_channel])
dg.clear()
def moveRalph(self): pkg = PyDatagram() pkg.addUint16(114) pkg.addFloat32(self.ralph.getX()) pkg.addFloat32(self.ralph.getY()) pkg.addFloat32(self.ralph.getZ()) pkg.addFloat32(self.ralph.getH()) self.cWriter.send(pkg,self.connection)
def pingTask(task):
if (task.frame % 1000) > 0: #determine network delay every now and then (every 1000 frames)
return Task.cont
ping = PyDatagram()
ping.addUint16(PACKET_PING)
ping.addFloat64(time.time())
toAll(ping, activeConnections)
return Task.cont
def genericPacket(key, packetCount=0):
myPyDatagram = PyDatagram()
myPyDatagram.addUint8(key)
myPyDatagram.addUint8(packetCount)
myPyDatagram.addUint8(0)
myPyDatagram.addUint16(0)
myPyDatagram.addUint16(0)
return myPyDatagram
def makeNetString(self):
dataList = self.experience
datagram = PyDatagram()
for track in range(0, len(Tracks)):
datagram.addUint16(dataList[track])
dgi = PyDatagramIterator(datagram)
return dgi.getRemainingBytes()
def locateAvatar(self, zoneId):
if self.av:
dg = PyDatagram()
dg.addUint16(CLIENT_OBJECT_LOCATION)
dg.addUint32(self.av.doId)
dg.addUint32(self.timeManager.doId)
dg.addUint32(zoneId)
self.send(dg)
def ban(self, banner, target, time):
dg = PyDatagram()
dg.addServerHeader(target.GetPuppetConnectionChannel(target.doId), self.air.ourChannel, CLIENTAGENT_EJECT)
dg.addUint16(155)
dg.addString('You were kicked by a moderator!')
self.air.send(dg)
self.sendUpdate("banUD", [banner, target.DISLid, time])
def moveRequest(self, x, y, z, h, isMoving):
pkg = PyDatagram()
pkg.addUint16(106)
pkg.addFloat32(x)
pkg.addFloat32(y)
pkg.addFloat32(z)
pkg.addFloat32(h)
pkg.addUint16(isMoving)
return pkg
def move(self): self.player.x += 1 pkg = PyDatagram() pkg.addUint16(114) pkg.addFloat32(self.player.x) pkg.addFloat32(self.player.y) pkg.addFloat32(self.player.z) pkg.addFloat32(self.player.rotation) self.cWriter.send(pkg,self.connection)
def genBasicData(self, proto):
myPyDatagram = PyDatagram()
myPyDatagram.addUint8(proto)
myPyDatagram.addUint8(self.packetCount)
myPyDatagram.addUint8(0)
myPyDatagram.addUint16(0)
myPyDatagram.addUint16(0)
self.packetCount += 1
return myPyDatagram
def checkReset():
global lastResetPress
lastResetPress = time.time()
reset = PyDatagram() #send a reset request to partner
reset.addUint16(PACKET_RESET)
if role==ROLE_CLIENT:
cWriter.send(reset, serverConnection)
elif role == ROLE_SERVER and not isResetConfirmed():
toAll(reset, activeConnections)
def sendDisconnectClient(self, di, connection, errorCode, reason): datagram = PyDatagram() datagram.addUint16(CLIENT_GO_GET_LOST) datagram.addUint16(errorCode) datagram.addString(reason) self.cw.send(datagram, connection) datagram.clear() self.handleClientDisconnected(di, connection)
def handleAuth(self, opcode, data, client):
"""
Handle auth and player login.
NOTE: THIS IS REALLY SIMPLE FOR NOW
Add something to check if the user is already logged in
"""
# Get the data the client sent.
clientUser = data.getString()
clientPass = data.getString()
# Flag to be send back after serverside auth
flag = None
userpass = False
loginTries = 0 # Not thought out now, will return to it later...
# Get the data from DB
try:
# Here we can add the player to the PLAYERS{} by using a player
# ID or something
details = []
details = Database.getAccountData(clientUser, clientPass)
except:
print "Can't connected to ACCOUNT DATABASE"
# Will make some other checks later... this is just good for now..
if details == None:
flag = 2
print "Player: ", clientUser, " Doesn't exist! or Incorrect!"
loginTries += 1
# Check if the password/username match
elif clientPass == details[2] and clientUser == details[1]:
print details
userpass = True
self.network.base.PLAYERS[details[0]] = Player(self, details[0], details[1])
print "Player: ", details[1], " Logged in, ID: ", details[0]
flag = 1
else:
userpass = False
print "Player: ", clientUser, " login incorrect"
loginTries += 1
flag = 2
# Create buffer
pkg = PyDatagram()
# Add response
pkg.addUint16(SMSG_AUTH_RESPONSE)
# Add the flag
pkg.addUint16(flag)
# Send the packet
self.network.tcpWriter.send(pkg, client)
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 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 send(self, args=None):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.REQ_HEARTBEAT)
self.cWriter.send(pkg, self.connection)
# self.log('Sent [' + str(Constants.RAND_STRING) + '] Int Request')
except:
self.log("Bad [" + str(Constants.RAND_STRING) + "] Int Request")
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 rpc_kickChannel(self, channel, code, reason):
"""
Summary:
Kicks any client whose Client Agent is subscribed to the provided
[channel].
Parameters:
[int channel] = The channel to kick.
[int code] = The code for the kick.
[str reason] = The reason for the kick.
"""
datagram = PyDatagram()
datagram.addServerHeader(channel, self.air.ourChannel, CLIENTAGENT_EJECT)
datagram.addUint16(code)
datagram.addString(reason)
self.air.send(datagram)
def banId(id, reason):
"""
Ban and Kick the short id from the game server.
"""
target = simbase.air.doId2do.get(100000000 + id)
if target == spellbook.getInvoker():
return "You can't ban yourself!"
simbase.air.banManager.ban(target.doId, reason)
datagram = PyDatagram()
datagram.addServerHeader(target.GetPuppetConnectionChannel(target.doId),
simbase.air.ourChannel, CLIENTAGENT_EJECT)
datagram.addUint16(155)
datagram.addString(
'You were banned by a moderator for the following reason: %s' % reason)
simbase.air.send(datagram)
return "Kicked and Banned %s from the game server!" % target.getName()
def sendMagicWord(self, word, targetId, execute):
invokerId = self.air.getAvatarIdFromSender()
invoker = self.air.doId2do.get(invokerId)
if not invoker:
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse',
['missing invoker'])
return
if invoker.getAdminAccess() < MINIMUM_MAGICWORD_ACCESS:
self.air.writeServerEvent(
'suspicious',
avId=invokerId,
issue='Attempted to issue magic word: %s' % word)
dg = PyDatagram()
dg.addServerHeader(self.GetPuppetConnectionChannel(invokerId),
self.air.ourChannel, CLIENTAGENT_EJECT)
dg.addUint16(126)
dg.addString('Magic Words are reserved for administrators only!')
self.air.send(dg)
return
target = self.air.doId2do.get(targetId)
if not target:
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse',
['missing target'])
return
if execute:
response = spellbook.process(invoker, target, word)
if response[0]:
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse',
[response[0]])
else:
response = ('Client MW executed.', )
from otp.avatar.DistributedPlayerAI import DistributedPlayerAI
targetAccess = 0 if not isinstance(
target, DistributedPlayerAI) else target.getAdminAccess()
self.air.writeServerEvent('magic-word',
invokerId=invokerId,
invokerAccess=invoker.getAdminAccess(),
targetId=targetId,
targetAccess=targetAccess,
word=word,
response=response[0])
def queryObject(self,
databaseId,
doId,
callback,
dclass=None,
fieldNames=()):
"""
Query object `doId` out of the database.
On success, the callback will be invoked as callback(dclass, fields)
where dclass is a DCClass instance and fields is a dict.
On failure, the callback will be invoked as callback(None, None).
"""
# Save the callback:
ctx = self.air.getContext()
self._callbacks[ctx] = callback
self._dclasses[ctx] = dclass
# Generate and send the datagram:
dg = PyDatagram()
if not fieldNames:
dg.addServerHeader(databaseId, self.air.ourChannel,
DBSERVER_OBJECT_GET_ALL)
else:
# We need a dclass in order to convert the field names into field IDs:
assert dclass is not None
if len(fieldNames) > 1:
dg.addServerHeader(databaseId, self.air.ourChannel,
DBSERVER_OBJECT_GET_FIELDS)
else:
dg.addServerHeader(databaseId, self.air.ourChannel,
DBSERVER_OBJECT_GET_FIELD)
dg.addUint32(ctx)
dg.addUint32(doId)
if len(fieldNames) > 1:
dg.addUint16(len(fieldNames))
for fieldName in fieldNames:
field = dclass.getFieldByName(fieldName)
if field is None:
self.notify.error('Bad field named %s in query for'
' %s object' % (fieldName, dclass.getName()))
dg.addUint16(field.getNumber())
self.air.send(dg)
def constructFlower(self, plotIndex, species, variety):
dg = PyDatagram()
dg.addUint8(plotIndex)
dg.addUint8(species)
dg.addUint16(variety)
dg.addInt8(0) # Water Level
dg.addInt8(0) # Growth Level
dg.addUint32(self.getTimestamp())
dg.addUint8(0) # Wilted State (False)
gardenData = PyDatagramIterator(dg)
plot = occupier2Class[GardenGlobals.FlowerPlot](self.air, self,
self.house.housePos)
plot.construct(gardenData)
self.plots[plotIndex] = plot
self.updateGardenData()
def auth_REQ(self, user, passw):
"""
Handle the login packet to server.
"""
# Create the buffer
pkg = PyDatagram()
# Add the opcode
pkg.addUint16(CMSG_AUTH)
# Add the user and pass Details
# This is kept really simple
pkg.addString(user)
pkg.addString(passw)
# Send the packet
self.network.tcpWriter.send(pkg, self.tcpConn)
def sendRequest112(self, task):
if (self.received):
print "->Client request:"
# Send a request to the server
myPyDatagram112 = PyDatagram()
prot = 112
CP_id = raw_input('Control Point ID (1 to 5): ')
faction_id = raw_input('press 0 for Red Or 1 for Blue ? :')
myPyDatagram112.addUint16(prot)
myPyDatagram112.addUint32(CP_id)
myPyDatagram112.addUint32(faction_id)
self.cWriter.send(myPyDatagram112, self.connection)
#print " sent"
self.received = 0
taskMgr.add(self.receiveResponse112, "CPCaptureRes")
def send(self, args=[]):
try:
# print "sender's id:", args[0]
# print "receiver's id:", args[1]
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_CHAT_ONE)
pkg.addInt32(args[0]) # sender's id
pkg.addInt32(args[1]) # receiver's id
pkg.addString(args[2]) # message
self.cWriter.send(pkg, self.connection)
# self.log('Sent [' + str(Constants.CMSG_CHAT_ONE) + '] Chat Request')
except:
self.log('Bad [' + str(Constants.CMSG_CHAT_ONE) + '] Chat Request')
print_exc()
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 readerPollOnce(self):
try:
return AstronInternalRepository.readerPollOnce(self)
except (SystemExit, KeyboardInterrupt):
raise
except Exception as e:
if self.getAvatarIdFromSender(
) > 100000000: # If an avatar is sending, boot them
dg = PyDatagram()
dg.addServerHeader(self.getMsgSender(), self.ourChannel,
CLIENTAGENT_EJECT)
dg.addUint16(420)
dg.addString(
'You were disconnected to prevent a district reset.')
self.send(dg)
self.writeServerEvent('EXCEPTION-POTENTIAL-CRASH',
self.getAvatarIdFromSender(),
self.getAccountIdFromSender(), repr(e),
traceback.format_exc())
self.notify.warning('EXCEPTION-POTENTIAL-CRASH: %s (%s)' %
(repr(e), self.getAvatarIdFromSender()))
print traceback.format_exc()
sys.exc_clear()
import os
if os.getenv('DISTRICT_NAME', 'Test Canvas') == "Test Canvas":
return 1
from raven import Client
from os.path import expanduser
errorReporter = Client(
'https://*****:*****@sentry.io/189240'
)
errorReporter.tags_context({
'district_name':
os.getenv('DISTRICT_NAME', 'UNDEFINED'),
'AVID_SENDER':
self.getAvatarIdFromSender(),
'ACID_SENDER':
self.getAccountIdFromSender(),
'homedir':
expanduser('~'),
'CRITICAL':
'False'
})
errorReporter.captureException()
return 1
def handleNewAvatar(self, entry):
intoNP = entry.getIntoNodePath()
toonNP = intoNP.getParent()
for key in self.cr.doId2do.keys():
val = self.cr.doId2do[key]
if val.__class__.__name__ == 'DistributedToon':
if val.getKey() == toonNP.getKey():
if val.zoneId == 30:
if self.station.getAvailableSlots() > 0 and val not in self.station.avatars:
availableSlot = self.station.getAnAvailableSlot()
pkg = PyDatagram()
pkg.addUint16(STATION_SLOTS_OPEN)
pkg.addUint8(availableSlot)
pkg.addUint32(self.station.doId)
pkg.addUint32(val.doId)
base.sr.sendDatagram(pkg)
self.gotNewAvatar(val)
def send(self, args):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_ENTER_GAME_LOBBY)
#pkg.addString(args[0]) #username
#pkg.addUint16(args[1]) #gameId
#pkg.addUint16(args[2]) #lobbyId
pkg.addUInt16(args) #room id
self.cWriter.send(pkg, self.connection)
print "RequestEnterGameLobby sent"
except:
self.log('Bad [' + str(Constants.CMSG_ENTER_GAME_LOBBY) +
'] Login Request')
print_exc()
def readerPollOnce(self):
try:
return AstronInternalRepository.readerPollOnce(self)
except SystemExit as KeyboardInterrupt:
raise
except Exception as e:
if self.getAvatarIdFromSender() > 100000000:
dg = PyDatagram()
dg.addServerHeader(self.getMsgSender(), self.ourChannel, CLIENTAGENT_EJECT)
dg.addUint16(166)
dg.addString('You were disconnected to prevent a district reset.')
self.send(dg)
self.writeServerEvent('INTERNAL-EXCEPTION', self,getAvatarIdFromSender(), self.getAccountIdFromSender, repr(e), traceback.format_exc())
self.notify.warning('INTERNAL-EXCEPTION: {0} ({1})'.format(repr(e), self.getAvatarIdFromSender))
print(traceback.format_exc)
sys.exc_clear()
return 1
def send(self, args=None):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_MOVE)
pkg.addFloat32(args[0]) #x
pkg.addFloat32(args[1]) #y
pkg.addFloat32(args[2]) #z
pkg.addFloat32(args[3]) #h
pkg.addInt32(args[4]) #isMoving
self.cWriter.send(pkg, self.connection)
#self.log('Sent [' + str(Constants.RAND_FLOAT) + '] Float Request')
except:
self.log('Bad [' + str(Constants.CMSG_MOVE) + '] Move Request')
print_exc()
def getFields(self, fields):
# 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
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 sendMagicWord(self, word, targetId):
invokerId = self.air.getAvatarIdFromSender()
invoker = self.air.doId2do.get(invokerId)
if not invoker:
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse',
['missing invoker'])
return
if invoker.getAdminAccess() < MINIMUM_MAGICWORD_ACCESS:
self.air.writeServerEvent(
'suspicious', invokerId,
'Attempted to issue magic word: %s' % word)
dg = PyDatagram()
dg.addServerHeader(self.GetPuppetConnectionChannel(invokerId),
self.air.ourChannel, CLIENTAGENT_EJECT)
dg.addUint16(126)
dg.addString('Magic Words are reserved for administrators only!')
self.air.send(dg)
return
target = self.air.doId2do.get(targetId)
if not target:
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse',
['missing target'])
return
if not hasattr(target, 'isNPC'):
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse',
['invalid target'])
return
if target.isNPC():
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse',
['invalid target'])
return
response = spellbook.process(invoker, target, word)
if response:
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse',
[response])
self.air.writeServerEvent('magic-word', invokerId,
invoker.getAdminAccess(), targetId,
target.getAdminAccess(), word, response)
def dg_update_name(pid, name):
"""
Call when you want to update your name
@param pid: player ID
@type pid: int
@param name: new name
@type name: string
@return: the datagram you need to send
@rtype: datagram
"""
if pid is not None:
dg = PyDatagram()
dg.addUint8(UPDATE_NAME)
dg.addUint16(pid)
dg.addString(name)
return dg
else:
print("!! TRIED TO SEND DATAGRAM WITH NO PID !!")
def sendUserInput(self, inputArr = [], *args):
pkg = PyDatagram()
pkg.addUint16(CLIENT_INPUT)
pkg.addUint64(self.myClock)
pkg.addBool(inputArr[0])
pkg.addBool(inputArr[1])
pkg.addBool(inputArr[2])
pkg.addBool(inputArr[3])
pkg.addBool(inputArr[4])
if inputArr[4]:
pkg.addFloat32(inputArr[5])
pkg.addFloat32(inputArr[6])
pkg.addFloat32(inputArr[7])
pkg.addString(str(inputArr[8]))
pkg.addFloat32(self.gameEngine.players[self.id].playerNP.getH() % 360)
pkg.addFloat32(self.gameEngine.players[self.id].playerSpine.getP() % 360)
# Now lets send the whole thing...
self.send(pkg)
def send(self, pos):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_MOVE)
posNew = pos.split(",")
pkg.addFloat32(float(posNew[0]))
pkg.addFloat32(float(posNew[1]))
pkg.addFloat32(float(posNew[2]))
pkg.addFloat32(float(posNew[3]))
pkg.addInt32(int(posNew[4]))
self.cWriter.send(pkg, self.connection)
#self.log('Sent [' + str(Constants.RAND_STRING) + '] Int Request')
except:
self.log('Bad [' + str(Constants.CMSG_MOVE) + '] Int Request')
print_exc()
def send(self, character=None):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_CREATE_CHARACTER)
characterlist = character.split()
# print "characterlist", characterlist
# print "username ",characterlist[0]
# print "charname ",characterlist[1]
pkg.addString(characterlist[0])
pkg.addString(characterlist[1])
self.cWriter.send(pkg, self.connection)
#self.log('Sent [' + str(Constants.RAND_STRING) + '] Int Request')
except:
self.log('Bad [' + str(Constants.RAND_STRING) + '] Int Request')
print_exc()
def send(self, args=None):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_CREATE_CHARACTER)
pkg.addUint16(args[0]) #TYPE
pkg.addFloat32(args[1]) #x pos
pkg.addFloat32(args[2]) #y pos
pkg.addFloat32(args[3]) #z pos
# print "RequestCreateCharacter - ", args[0], " x:", args[1], " y:", args[2]," z:", args[3]
self.cWriter.send(pkg, self.connection)
#self.log('Sent [' + str(Constants.RAND_STRING) + '] Int Request')
except:
self.log('Bad [' + str(Constants.RAND_STRING) + '] Int Request')
print_exc()
def army_move(self,army_id,tx,ty):
order = PyDatagram()
if base.client == True:
order.addUint16(ARMY_MOVE_REQUEST)
else:
order.addUint16(ARMY_MOVE)
ax = base.armies[army_id].node_path.getX()
ay = base.armies[army_id].node_path.getY()
order.addInt16(army_id)
order.addFloat64(ax)
order.addFloat64(ay)
order.addFloat64(tx)
order.addFloat64(ty)
if base.client == True:
self.cWriter.send(order,base.server_connection)
else:
self.send_package(order)
base.armies[army_id].move_to_point(tx,ty)
def sendMagicWord(self, word, targetId):
invokerId = self.air.getAvatarIdFromSender()
invoker = self.air.doId2do.get(invokerId)
target = self.air.doId2do.get(targetId)
targets = spellbook.getTargets(word)
if targets:
if target is not None and target.__class__.__name__ not in targets:
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', [
'Target is a %s object! Expected: %s' %
(target.__class__.__name__, targets)
])
return
if not invoker:
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse',
['Missing invoker!'])
return
if invoker.getAdminAccess() < MINIMUM_MAGICWORD_ACCESS:
self.air.writeServerEvent(
'suspicious', invokerId,
'Attempted to issue magic word: %s' % word)
dg = PyDatagram()
dg.addServerHeader(self.GetPuppetConnectionChannel(invokerId),
self.air.ourChannel, CLIENTAGENT_EJECT)
dg.addUint16(126)
dg.addString('Magic Words are reserved for administrators only!')
self.air.send(dg)
return
if target is None:
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse',
['Missing target!'])
return
response = spellbook.process(invoker, target, word)
if response:
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse',
[response])
self.air.writeServerEvent('magic-word', invokerId,
invoker.getAdminAccess(), targetId,
target.getAdminAccess(), word, response)
def resendPlayToken(self):
"""
Resends our playToken to the game server while still logged
on. This is necessary when our playTaken has changed
properties in-game, for instance when we enable chat.
"""
assert self.response is not None
assert not self.response.hasKey('errorMsg') # Hey, there was an error
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
datagram = PyDatagram()
# Add message type
datagram.addUint16(CLIENT_SET_SECURITY)
self.__addPlayToken(datagram)
self.__addTokenType(datagram)
# Send the message
cr.send(datagram)
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 sendMagicWord(self, word, targetId):
invokerId = self.air.getAvatarIdFromSender()
invoker = self.air.doId2do.get(invokerId)
if not isinstance(self.air.doId2do.get(targetId), DistributedToonAI):
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse',
['Target is not a toon object!'])
return
if not invoker:
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse',
['missing invoker'])
return
now = time.strftime("%c")
if invoker.getAdminAccess() < MINIMUM_MAGICWORD_ACCESS:
self.air.writeServerEvent(
'suspicious', invokerId,
'Attempted to issue magic word: %s' % word)
dg = PyDatagram()
dg.addServerHeader(self.GetPuppetConnectionChannel(invokerId),
self.air.ourChannel, CLIENTAGENT_EJECT)
dg.addUint16(126)
dg.addString('Magic Words are reserved for administrators only!')
self.air.send(dg)
return
target = self.air.doId2do.get(targetId)
if not target:
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse',
['missing target'])
return
response = spellbook.process(invoker, target, word)
if response:
self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse',
[response])
self.air.writeServerEvent('magic-word', invokerId,
invoker.getAdminAccess(), targetId,
target.getAdminAccess(), word, response)
with open("logs/mw/magic-words.txt", "a") as textFile:
textFile.write("%s | %s : %s\n" % (now, invokerId, word))
print("%s | %s : %s\n" % (now, invokerId, word))
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 sendRequest104(self, task):
if (self.received):
print "->Client request:"
# Send a request to the server
myPyDatagram = PyDatagram()
prot = 104
cname = raw_input('Character Name :')
faction_id_104 = raw_input('press 0 for Red Or 1 for Blue ? :')
classType_104 = raw_input('press 0 for Axe Or 1 for Sword ? :')
myPyDatagram.addUint16(prot)
myPyDatagram.addString(cname)
myPyDatagram.addUint32(faction_id_104)
myPyDatagram.addUint32(classType_104)
self.cWriter.send(myPyDatagram, self.connection)
print "104 sent"
self.received = 0
taskMgr.add(self.receiveResponse104, "characterresponse")
def send(self, forces):
try:
#print "Req Move: ", forces[3], forces[4], forces[5], forces[6], forces[7], forces[8]
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_MOVE)
pkg.addFloat32(forces[0])
pkg.addFloat32(forces[1])
pkg.addFloat32(forces[2])
pkg.addFloat32(forces[3])
pkg.addFloat32(forces[4])
pkg.addFloat32(forces[5])
pkg.addFloat32(forces[6])
pkg.addFloat32(forces[7])
pkg.addFloat32(forces[8])
self.cWriter.send(pkg, self.connection)
except:
self.log('Bad [' + str(Constants.CMSG_MOVE) + '] Move Request')
