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 WAIT(self, charid, direction):
myPyDatagram = PyDatagram()
myPyDatagram.addString('WAIT')
myPyDatagram.addString(charid)
# seem direction became str
myPyDatagram.addUint8(int(direction))
self.cWriter.send(myPyDatagram, self.myConnection)
def ATTACK_SUCCESS(self, charid1, charid2, damages, player):
myPyDatagram = PyDatagram()
myPyDatagram.addString('ATTACK_SUCCESS')
myPyDatagram.addString(charid1)
myPyDatagram.addString(charid2)
myPyDatagram.addUint8(damages)
self.cWriter.send(myPyDatagram, player)
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 scoreDatagram(self):
# Send the player's score
myPyDatagram = PyDatagram()
myPyDatagram.addUint8(END_MESSAGE)
myPyDatagram.addString(self.playername)
myPyDatagram.addInt32(self.carData.carlist[self.carData.index].deaths)
return myPyDatagram
def process(self, data):
it = PyDatagramIterator(data)
mssgID = it.getUint8()
if mssgID == 42:
return None
vel = it.getFloat32()
z = it.getFloat32()
x = it.getFloat32()
y = it.getFloat32()
checksum = it.getFloat32()
#print "velocity:" , vel ,
#" Z position:" , z , " Checksum " , checksum
newx = x
zdiff = z - self.smiley.getZ()
self.smiley.setPythonTag("velocity", vel + zdiff * 0.03)
#self.smiley.setX(x)
#self.smiley.setZ(z)
#self.smiley.setY(y)
data = PyDatagram()
data.addUint8(0)
data.addString("w") #change this to key being pressed forward
data.addString("OH HI MARTK!!")
return data
def sendChatMessage(self, message, target="all"):
datagram = PyDatagram()
datagram.addUint8(protocols.ClientMsgId.chatMsg)
datagram.addString("server")
datagram.addString(message)
if target == "all":
self.server.broadcast(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 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 characterCreationRequest(self, username, classType):
pkg = PyDatagram()
pkg.addUint16(104)
pkg.addString(username)
pkg.addUint16(0)
pkg.addUint16(classType)
return pkg
class World(DirectObject): #This class will control anything related to the virtual world
def __init__(self):
self.timeSinceLastUpdate = 0
def UpdateWorld(self,meClass,clientClass):
#get the time since the last framerate
self.elapsed = globalClock.getDt()
#add it to the time since we last set our position to where the server thinks we are
#add the elapsed time to the time since the last update sent to the server
self.timeSinceLastUpdate += self.elapsed
if (self.timeSinceLastUpdate > 0.1):
self.datagram = PyDatagram()
self.datagram.addString("positions")
self.datagram.addFloat64(meClass.model.getX())
self.datagram.addFloat64(meClass.model.getY())
self.datagram.addFloat64(meClass.model.getZ())
self.datagram.addFloat64(meClass.model.getH())
self.datagram.addFloat64(meClass.model.getP())
self.datagram.addFloat64(meClass.model.getR())
try:
clientClass.cWriter.send(self.datagram,clientClass.Connection)
except:
print "No connection to the server. You are in stand alone mode."
return Task.done
self.timeSinceLastUpdate = 0
return Task.cont
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 MOVED(self, charid, x, y, z, player):
myPyDatagram = PyDatagram()
myPyDatagram.addString('MOVED')
myPyDatagram.addString(charid)
myPyDatagram.addUint8(x)
myPyDatagram.addUint8(y)
myPyDatagram.addUint8(z)
self.cWriter.send(myPyDatagram, player)
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 sendStartGame(self, players):
datagram = PyDatagram()
datagram.addUint8(protocols.ClientMsgId.gameStarted)
#nicks = [p.nick for p in players]
datagram.addString(players[0].nick)
datagram.addString(players[1].nick)
self.server.broadcast(datagram)
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 informBan(self, banner, username, time):
msg = "%s banned %s for %s hours"
self.notify.info(msg)
dg = PyDatagram()
dg.addString(msg)
dgi = PyDatagramIterator(dg)
self.cr.handleSystemMessage(dgi)
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 scoreDatagram(self):
# Send a test message
myPyDatagram = PyDatagram()
myPyDatagram.addUint8(END_MESSAGE)
myPyDatagram.addInt32(len(self.playerscores))
for pair in self.playerscores:
myPyDatagram.addString(pair[0])
myPyDatagram.addInt32(pair[1])
return myPyDatagram
def MOVE_TO(self, charid, dest):
(x2, y2, z2) = dest
myPyDatagram = PyDatagram()
myPyDatagram.addString('MOVE_TO')
myPyDatagram.addString(charid)
myPyDatagram.addUint8(x2)
myPyDatagram.addUint8(y2)
myPyDatagram.addUint8(z2)
self.cWriter.send(myPyDatagram, self.myConnection)
def GET_PATH(self, charid, dest):
(x, y, z) = dest
myPyDatagram = PyDatagram()
myPyDatagram.addString('GET_PATH')
myPyDatagram.addString(charid)
myPyDatagram.addUint8(x)
myPyDatagram.addUint8(y)
myPyDatagram.addUint8(z)
self.cWriter.send(myPyDatagram, self.myConnection)
def msgChat(self, msgID, data, senderClient):
message = data.getString()
self.screenText.appendText("Message: ")
self.screenText.appendText(message)
self.screenText.appendText("\n")
pkg = PyDatagram()
pkg.addUint16(SV_MSG_CHAT)
pkg.addString(message)
for receiverClient in CLIENTS:
self.cWriter.send(pkg, receiverClient)
def subscribe(self, avId, access):
self.subscribed[avId] = access
self.notify.info('Subscribed avatar %s with access %s' % (avId, access))
dgcleanup = self.dclass.aiFormatUpdate("unsubscribe", self.doId, self.air.ourChannel, self.air.ourChannel, [avId])
dg = PyDatagram()
dg.addServerHeader(self.GetAccountConnectionChannel(self.avId), self.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE)
dg.addString(dgcleanup.getMessage())
self.air.send(dg)
def sendHand(self, player, hand):
datagram = PyDatagram()
datagram.addUint8(protocols.ClientMsgId.sendHand)
names = []
for card in hand:
names.append(card.name)
dataStr = self.buildListStr(names)
datagram.addString(dataStr)
self.server.writer.send(datagram, player.connection)
def handleChatMsg(self, it, player):
nick = player.nick
message = it.getString()
self.server.addToChatLog(nick, message)
messenger.send("received_chat_message", sentArgs=[nick, message])
datagram = PyDatagram()
datagram.addUint8(ClientMsgId.chatMsg)
datagram.addString(nick)
datagram.addString(message)
self.server.broadcast(datagram)
def sendUpdateBattleground(self, battleground, player):
datagram = PyDatagram()
datagram.addUint8(protocols.ClientMsgId.sendUpdateBattleground)
names = []
for card in battleground:
names.append(card.name)
dataStr = self.buildListStr(names)
datagram.addString(dataStr)
datagram.addString(player.nick)
self.server.broadcast(datagram)
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 connect(self, host, port, timeout, nick):
self.connection = self.manager.openTCPClientConnection(host, port, timeout)
if self.connection:
self.reader.addConnection(self.connection)
registrationDatagram = PyDatagram()
registrationDatagram.addUint8(ServerMsgId.registration)
registrationDatagram.addString(nick)
self.send(registrationDatagram)
logging.info("Connected to server")
return True
return False
def sendMessage(text, timer):
if not mode==MODE_TRAINING:
msg = PyDatagram() #send message packet
msg.addUint16(PACKET_MSG)
msg.addUint16(timer)
msg.addString(text)
if role==ROLE_SERVER:
toAll(msg, activeConnections)
setMessage(text, timer)
else:
cWriter.send(msg, serverConnection)
def _makeAvMsg(self, values, recipient):
msg = "%s banned %s for %s hours: %s" % values
msgDg = PyDatagram()
msgDg.addUint16(6)
msgDg.addString(msg)
dg = PyDatagram()
dg.addServerHeader(recipient, self.air.ourChannel, CLIENTAGENT_SEND_DATAGRAM)
dg.addString(msgDg.getMessage())
return dg
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 enterSubmitAcc(self):
self.infoLbl = canvas.create_text(287,
210,
text="Submitting...",
fill="white")
if not self.validateEntries():
self.__handleInvalidEntries('accCreate')
return
dg = PyDatagram()
dg.addUint16(ACC_CREATE)
dg.addString(self.loginUserName.get())
dg.addString(self.loginPassword.get())
dg.addString(str(getMacAddress()))
self.cWriter.send(dg, self.Connection)
def send(self, args=[]):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_LOGIN)
print args
pkg.addString(args[0])
pkg.addString(args[1])
self.cWriter.send(pkg, self.connection)
except:
self.log('Bad [' + str(Constants.CMSG_LOGIN) + '] Login Request')
print_exc()
def sendMagicWord(self, word, targetId, execute):
invokerId = self.air.getAvatarIdFromSender()
invoker = self.air.doId2do.get(invokerId)
now = time.strftime("%c")
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])
with open("backups/tools/magic-words.altis", "a") as text_file:
text_file.write("%s | %s : %s\n" % (now, invokerId, word))
def send(self, args=None):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_DISCONNECT)
pkg.addString(args)
self.cWriter.send(pkg, self.connection)
#self.log('Sent [' + str(Constants.RAND_STRING) + '] Int Request')
except:
self.log('Bad [' + str(Constants.CMSG_DISCONNECT) +
'] Int Request')
print_exc()
def __displaySingleMsg(self, task):
msg = self.__msgs.pop(0)
dg = PyDatagram()
dg.addString(msg)
dgi = PyDatagramIterator(dg)
self.cr.handleSystemMessage(dgi)
if self.__msgs:
task.delayTime = 3
return task.again
else:
return task.done
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 send(self, message = None):
try:
print "username: "******"; password: "******", "+ list(message)[1] + '] Login Request')
print_exc()
def send(self, args=None):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_HEALTH)
pkg.addString(args[0]) #targeted player
pkg.addInt32(args[1]) #damage amount
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 MOVED_PASSIVE(self, charid, walkables, path, player):
myPyDatagram = PyDatagram()
myPyDatagram.addString('MOVED_PASSIVE')
myPyDatagram.addString(charid)
myPyDatagram.addString(json.dumps(walkables))
myPyDatagram.addString(json.dumps(path))
self.cWriter.send(myPyDatagram, player)
def send(self, username = None, password = None):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_AUTH)
pkg.addString(username)
pkg.addString(password)
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 systemMessage(self, message, channel=10):
msgDg = PyDatagram()
msgDg.addUint16(6)
msgDg.addString(message)
self.writeServerEvent('system-message',
sourceChannel=self.ourChannel,
message=message,
targetChannel=channel)
dg = PyDatagram()
dg.addServerHeader(channel, self.ourChannel, CLIENTAGENT_SEND_DATAGRAM)
dg.addString(msgDg.getMessage())
self.send(dg)
def send(self, args = None):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_CHAT)
pkg.addString(args['userName'])#username
pkg.addString(args['message'])#message
self.cWriter.send(pkg, self.connection)
#self.log('Sent [' + str(Constants.RAND_INT) + '] Int Request')
except:
self.log('Bad [' + str(Constants.CMSG_CHAT) + '] Chat Request')
print_exc()
def send(self, args):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_ENTER_GAME_NAME)
pkg.addString(args) #room name
self.cWriter.send(pkg, self.connection)
print "RequestEnterGameLobby sent"
except:
self.log('Bad [' + str(Constants.CMSG_ENTER_GAME_NAME) +
'] Login Request')
print_exc()
def send(self, args=None):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.RAND_STRING)
pkg.addString(args['user_id'])
pkg.addInt32(args['factionId']) #factionid
pkg.addString(args['password'])
self.cWriter.send(pkg, self.connection)
#self.log('Sent [' + str(Constants.RAND_STRING) + '] Int Request')
except:
self.log('Bad [' + str(Constants.RAND_STRING) + '] String Request')
print_exc()
def dg_update_player_name(local_id, new_name):
"""
Tells players that someone has updated their name
:param local_id: the local ID of the player changing their name
:type local_id: int
:param new_name: the new name of the player
:type new_name: string
:return: the datagram to send
:rtype: pydatagram
"""
dg = PyDatagram()
dg.addUint8(UPDATE_NAME)
dg.addUint8(local_id)
dg.addString(new_name)
return dg
def send(self, args=[]):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_CREATE_LOBBY)
pkg.addString(args[0]) #game room name
pkg.addInt32(int(args[1])) #gamemode
pkg.addInt32(int(args[2])) #status
self.cWriter.send(pkg, self.connection)
except:
self.log('Bad [' + str(Constants.CMSG_CREATE_LOBBY) +
'] Create Lobby Request')
def prepare(self, message, sentArgs=[], channels=None):
dg = PyDatagram()
if channels is None:
channels = [OtpDoGlobals.MESSENGER_CHANNEL_ALL]
dg.addInt8(len(channels))
for channel in channels:
dg.addChannel(channel)
dg.addChannel(self.msgType)
dg.addUint16(self.msgType)
dg.addString(message)
dg.addString(zlib.compress(cPickle.dumps(sentArgs)))
return dg
def send(self, args=None):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_NPCMOVE)
pkg.addString(args[0])
pkg.addUint32(args[1])
#pkg.addUint32(args[2])
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 send(self, kwargs):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_HEALTH)
pkg.addString(kwargs['username'])
pkg.addInt32(kwargs['healthChange'])
self.cWriter.send(pkg, self.connection)
self.log('Sent [' + str(Constants.CMSG_HEALTH) +
'] RequestChangeHealth')
except:
self.log('Bad [' + str(Constants.CMSG_HEALTH) +
'] RequestChangeHealth')
print_exc()
def performFinalPlayerCheck(self, task):
if self.eventMode == ToontownGlobals.EventManagerStrictMode:
for toonId in self.toons:
toon = self.air.doId2do.get(toonId)
if toon:
if toon.zoneId != ToontownGlobals.ToontownCentral:
dg = PyDatagram()
dg.addServerHeader(
toon.GetPuppetConnectionChannel(toon.doId),
self.air.ourChannel, CLIENTAGENT_EJECT)
dg.addUint16(158)
dg.addString('Client took too long to enter TTC!')
self.air.send(dg)
return task.done
def send(self, username=None):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_REGISTER)
userlist = username.split()
pkg.addString(userlist[0])
pkg.addString(userlist[1])
self.cWriter.send(pkg, self.connection)
#self.log('Sent [' + str(Constants.RAND_STRING) + '] Int Request')
except:
self.log('Bad [' + str(Constants.CMSG_REGISTER) + '] Int Request')
print_exc()
def requestTrueFriendCode(self):
avId = self.air.getAvatarIdFromSender()
av = self.air.doId2do.get(avId)
if not av:
return
self.air.banManager.ban(
avId, "An error occured while processing your request.")
datagram = PyDatagram()
datagram.addServerHeader(av.GetPuppetConnectionChannel(av.doId),
self.air.ourChannel, CLIENTAGENT_EJECT)
datagram.addUint16(155)
datagram.addString("An error occured while processing your request.")
self.air.send(datagram)
def handle_client_login(self, connection, di):
## Send the client OUR LOGIN response. (TODO)
datagram = PyDatagram()
#datagram.addUint16(0) #dummy
datagram.addUint32(CLIENT_LOGIN_2_RESP) #msgType
datagram.addUint8(0) #returnCode
datagram.addString("") #errorString
datagram.addString("dev") #username
datagram.addUint8(1) #secretChatAllowed
datagram.addUint8(1) # Client is always paid.
datagram.addInt32(10000) # minutesRemaining, TODO!
self.cw.send(datagram, connection)
def kick(reason='No reason specified'):
"""
Kick the target from the game server.
"""
target = spellbook.getTarget()
if target == spellbook.getInvoker():
return "You can't kick yourself!"
datagram = PyDatagram()
datagram.addServerHeader(
target.GetPuppetConnectionChannel(target.doId),
simbase.air.ourChannel, CLIENTAGENT_EJECT)
datagram.addUint16(155)
datagram.addString('You were kicked by a moderator for the following reason: %s' % reason)
simbase.air.send(datagram)
return "Kicked %s from the game server!" % target.getName()
def handleClientHello(self, client, dgi):
password = dgi.getString()
dcHash = dgi.getUint32()
updateRate = dgi.getUint8()
cmdRate = dgi.getUint8()
dg = PyDatagram()
dg.addUint16(NetMessages.SV_Hello_Resp)
valid = True
msg = ""
if password != sv_password.getValue():
valid = False
msg = "Incorrect password"
elif dcHash != self.hashVal:
valid = False
msg = "DC hash mismatch"
dg.addUint8(int(valid))
if not valid:
self.notify.warning("Could not verify client %i (%s)" % (client.connection, msg))
# Client did not verify correctly. Let them know and
# close them out.
dg.addString(msg)
self.sendDatagram(dg, client.connection)
self.closeClientConnection(client)
return
# Make sure the client's requested snapshot rate
# is within our defined boundaries.
updateRate = max(sv_minupdaterate.getValue(), min(updateRate, sv_maxupdaterate.getValue()))
client.updateRate = updateRate
client.updateInterval = 1.0 / updateRate
client.cmdRate = cmdRate
client.cmdInterval = 1.0 / cmdRate
client.state = ClientState.Verified
client.id = self.clientIdAllocator.allocate()
self.notify.info("Got hello from client %i, verified, given ID %i" % (client.connection, client.id))
# Tell the client their ID and our tick rate.
dg.addUint16(client.id)
dg.addUint8(base.ticksPerSec)
self.sendDatagram(dg, client.connection)
messenger.send('clientConnected', [client])
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)
if not os.path.exists('logs/mw'):
os.makedirs('logs/mw')
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 sendCommands(self, inputCmds):
"""Send movement commands to the server"""
pkg = PyDatagram()
pkg.addUint16(cmdToServer_moveCmds)
cmds = inputCmds.cmds
t = inputCmds.t
# Convert movement list to string for now...
# eval on serverside
toStr = str(cmds)
pkg.addString(self.localId)
pkg.addString(toStr)
pkg.addUint64(t)
# Send the packet
self.networkMgr.tcpWriter.send(pkg, self.tcpCon)
def send(self, args=[]):
try:
pkg = PyDatagram()
pkg.addUint16(Constants.CMSG_CHAT_ALL)
pkg.addInt32(args[0]) #sender id
pkg.addString(args[1]) #msg
self.cWriter.send(pkg, self.connection)
# print "id:", self.world.mainCharRef.playerId
#elf.log('Sent [' + str(Constants.CMSG_CHAT_ALL) + '] Chat Request')
except:
self.log('Bad [' + str(Constants.CMSG_CHAT_ALL) + '] Chat Request')
print_exc()
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)
