def receiveResponse106(self,task):
while self.cReader.dataAvailable():
datagram6 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram6):
myIterator = PyDatagramIterator(datagram6)
print myIterator.getUint16()
msg = myIterator.getString()
if msg is not None:
print "<-Server response:"
print msg
print myIterator.getUint32()
print myIterator.getUint32()
print myIterator.getUint32()
print myIterator.getUint32()
print myIterator.getUint32()
raw_input("Press Enter to continue...")
self.received = 1
# Attack
#raw_input("Press Enter to continue...")
taskMgr.add(self.sendRequest108, 'health')
return task.again
def receiveResponse106(self, task):
while self.cReader.dataAvailable():
datagram6 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram6):
myIterator = PyDatagramIterator(datagram6)
print myIterator.getUint16()
msg = myIterator.getString()
if msg is not None:
print "<-Server response:"
print msg
print myIterator.getUint32()
print myIterator.getUint32()
print myIterator.getUint32()
print myIterator.getUint32()
print myIterator.getUint32()
raw_input("Press Enter to continue...")
self.received = 1
# Attack
#raw_input("Press Enter to continue...")
taskMgr.add(self.sendRequest108, 'health')
return task.again
def begin(self):
if self.cReader.dataAvailable():
datagram = NetDatagram() # catch the incoming data in this instance
# Check the return value; if we were threaded, someone else could have
# snagged this data before we did
if self.cReader.getData(datagram):
myIterator = PyDatagramIterator(datagram)
msgID = myIterator.getUint8()
#If not in our protocol range then we just reject
if msgID < 0 or msgID > 200:
return
self.lastAck[datagram.getAddress()] = datetime.datetime.now()
#TODO Switch to ip address and port
#Order of these will need to be optimized later
#We now pull out the rest of our headers
remotePacketCount = myIterator.getUint8()
ack = myIterator.getUint8()
acks = myIterator.getUint16()
hashID = myIterator.getUint16()
if msgID == protocol.LOGIN:
username = myIterator.getString()
password = myIterator.getString()
if username not in accountEntities:
entity = sandbox.createEntity()
component = AccountComponent()
component.name = username
component.passwordHash = password
if not accountEntities:
component.owner = True
component.address = datagram.getAddress()
entity.addComponent(component)
accountEntities[username] = entity.id
log.info("New player " + username + " logged in.")
#
self.activePlayers.append(component)
self.activeConnections[component.address] = component
ackDatagram = protocol.loginAccepted(entity.id)
self.sendData(ackDatagram, datagram.getAddress())
#TODO: Send initial states?
messenger.send("newPlayerShip", [component, entity])
else:
component = sandbox.entities[accountEntities[username]].get_component(AccountComponent)
if component.passwordHash != password:
log.info("Player " + username + " has the wrong password.")
else:
component.connection = datagram.getConnection()
log.info("Player " + username + " logged in.")
def handle_packet(self, dg):
dgi = PyDatagramIterator(dg)
msg = dgi.getUint16()
self.logger.debug("received message - %d" % msg)
# begin handling messages here
if msg == msg_types.CONTROL_SET_CHANNEL:
channel = dgi.getUint64()
connection = dg.getConnection()
self.register_channel(channel, connection)
elif msg == msg_types.CONTROL_REMOVE_CHANNEL:
channel = dgi.getUint16()
self.unregister_channel(channel)
else:
self.logger.warn("received unimplemented message type - %d" % msg)
def receiveResponse102(self, task):
print "<-Server response:"
while self.cReader.dataAvailable():
datagram2 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram2):
myIterator = PyDatagramIterator(datagram2)
print myIterator.getUint16()
msg = myIterator.getUint16()
print msg, " received"
if msg is not None:
raw_input("Press Enter to continue...")
self.received = 1
# Register
raw_input("Press Enter to continue...")
taskMgr.add(self.communicate301, 'Heartbeat')
def receiveResponse102(self,task):
print "<-Server response:"
while self.cReader.dataAvailable():
datagram2 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram2):
myIterator = PyDatagramIterator(datagram2)
print myIterator.getUint16()
msg = myIterator.getUint16()
print msg, " received"
if msg is not None:
raw_input("Press Enter to continue...")
self.received = 1
# Register
raw_input("Press Enter to continue...")
taskMgr.add(self.communicate301, 'Heartbeat')
def receiveResponse112(self,task):
while self.cReader.dataAvailable():
datagram12 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram12):
myIterator = PyDatagramIterator(datagram12)
print myIterator.getUint16()
msg = myIterator.getUint32()
if msg is not None:
print "<-Server response:"
print msg
print myIterator.getUint32()
raw_input("Press Enter to continue...")
self.received = 1
def check(self):
while self.cReader.dataAvailable():
print "data here"
datagram = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram):
data = PyDatagramIterator(datagram)
responseCode = data.getUint16()
print responseCode
if responseCode == 1:
self.getInt(data)
elif responseCode == 2:
self.getString(data)
elif responseCode == 3:
self.getShort(data)
elif responseCode == 4:
self.getFloat(data)
elif responseCode == 201:
self.getLogin(data)
elif responseCode == 203:
self.getRegistion(data)
elif responseCode == 204:
self.getCharacterCreation(data)
elif responseCode == 205:
self.getChat(data)
elif responseCode == 206:
self.getMove(data)
else:
print "nothing found"
def receiveResponse112(self, task):
while self.cReader.dataAvailable():
datagram12 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram12):
myIterator = PyDatagramIterator(datagram12)
print myIterator.getUint16()
msg = myIterator.getUint32()
if msg is not None:
print "<-Server response:"
print msg
print myIterator.getUint32()
raw_input("Press Enter to continue...")
self.received = 1
def handle_datagram_reciever(self, datagram):
di = PyDatagramIterator(datagram)
reciever_channel = di.getUint64()
sender_channel = di.getUint64()
msg_type = di.getUint16()
if msg_type == STATESERVER_OBJECT_GENERATE_WITH_REQUIRED:
location = (di.getUint32(), di.getUint32())
self.current_reciever = reciever_channel
if location == (0, 0):
print ("Tried to generate an object for an unknown location!")
return
self.do_interest_manager.handleGenerateWithRequired(self.current_reciever, location, di.getUint32())
if msg_type == STATESERVER_OBJECT_GENERATE_WITH_REQUIRED_OTHER:
doId = di.getUint32()
location = (di.getUint32(), di.getUint32())
self.current_reciever = reciever_channel
if location == (0, 0):
print ("Tried to generate an object for an unknown location!")
return
self.do_interest_manager.handleGenerateWithRequiredAndId(self.current_reciever, doId, location, di.getUint32())
else:
print ("Stateserver: Recieved a message that's unknown to the protocol, from %s" % str(sender_channel)) # debug error
return
def handle_datagram_reciever(self, datagram):
di = PyDatagramIterator(datagram)
reciever_channel = di.getUint64()
sender_channel = di.getUint64()
msg_type = di.getUint16()
if msg_type == STATESERVER_OBJECT_GENERATE_WITH_REQUIRED:
location = (di.getUint32(), di.getUint32())
self.current_reciever = reciever_channel
if location == (0, 0):
print("Tried to generate an object for an unknown location!")
return
self.do_interest_manager.handleGenerateWithRequired(
self.current_reciever, location, di.getUint32())
if msg_type == STATESERVER_OBJECT_GENERATE_WITH_REQUIRED_OTHER:
doId = di.getUint32()
location = (di.getUint32(), di.getUint32())
self.current_reciever = reciever_channel
if location == (0, 0):
print("Tried to generate an object for an unknown location!")
return
self.do_interest_manager.handleGenerateWithRequiredAndId(
self.current_reciever, doId, location, di.getUint32())
else:
print(
"Stateserver: Recieved a message that's unknown to the protocol, from %s"
% str(sender_channel)) # debug error
return
def check(self):
while self.cReader.dataAvailable():
print "data here"
datagram = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram):
data = PyDatagramIterator(datagram)
responseCode = data.getUint16()
print responseCode
if responseCode == 1:
self.getInt(data)
elif responseCode == 2:
self.getString(data)
elif responseCode == 3:
self.getShort(data)
elif responseCode == 4:
self.getFloat(data)
elif responseCode == 201:
self.getLogin(data)
elif responseCode == 203:
self.getRegistion(data)
elif responseCode == 204:
self.getCharacterCreation(data)
elif responseCode == 205:
self.getChat(data)
elif responseCode == 206:
self.getMove(data)
else:
print "nothing found"
def makeFromNetString(self, netString):
dataList = []
dg = PyDatagram(netString)
dgi = PyDatagramIterator(dg)
for track in range(0, len(Tracks)):
dataList.append(dgi.getUint16())
return dataList
def makeFromNetString(self, netString):
dataList = []
dg = PyDatagram(netString)
dgi = PyDatagramIterator(dg)
for track in xrange(0, len(Tracks)):
dataList.append(dgi.getUint16())
return dataList
def handleDatagram(self, datagram):
connection = datagram.getConnection()
di = PyDatagramIterator(datagram)
message_type = di.getUint16()
if message_type == CLIENT_AGENT_SET_INTEREST:
self.handleClientAgentSetInterest(
di,
sender=di.getUint64(),
handle=di.getUint16(),
contextId=di.getUint32(),
parentId=di.getUint32(),
zoneId=di.getUint32(),
)
elif message_type == CLIENT_AGENT_REMOVE_INTEREST:
self.handleRemoveInterest(di, sender=di.getUint64(), handle=di.getUint16(), contextId=di.getUint32())
def makeFromNetString(self, netString):
"""makeFromNetString(self)
Make an experience from a network packet
"""
dataList = []
dg = PyDatagram(netString)
dgi = PyDatagramIterator(dg)
for track in range(0, len(Tracks)):
dataList.append(dgi.getUint16())
return dataList
def handleDatagram(self, datagram):
connection = datagram.getConnection()
dgi = PyDatagramIterator(datagram)
message_type = dgi.getUint16()
print message_type
if message_type == CLIENT_HEARTBEAT:
self.handleClientHeartbeat(dgi, connection)
elif message_type == CLIENT_DISCONNECT:
self.handleClientDisconnect(dgi, connection)
def handle_datagram_reciever(self, datagram):
connection = datagram.getConnection()
if not connection:
print("Got an unexpected connection: %s" % str(connection))
return
di = PyDatagramIterator(datagram)
reciever_channel = di.getUint64()
sender_channel = di.getUint64()
msg_type = di.getUint16()
print msg_type
def handle_datagram_reciever(self, datagram):
connection = datagram.getConnection()
if not connection:
print ("Got an unexpected connection: %s" % str(connection))
return
di = PyDatagramIterator(datagram)
reciever_channel = di.getUint64()
sender_channel = di.getUint64()
msg_type = di.getUint16()
print msg_type
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 nonBlockingRead(self, qcr):
if self.cReader.dataAvailable():
datagram = NetDatagram()
if self.cReader.getData(datagram):
data = PyDatagramIterator(datagram)
msgID = data.getUint16()
else:
data = None
msgID = MSG_NONE
else:
datagram = None
data = None
msgID = MSG_NONE
return (datagram, data, msgID)
def handleDatagram(self, datagram): connection = datagram.getConnection() if not connection: return di = PyDatagramIterator(datagram) message_type = di.getUint16() if message_type == CONTROL_SET_CHANNEL: self.registerChannel(di.getUint64(), connection) elif message_type == CONTROL_REMOVE_CHANNEL: self.unregisterChannel(di.getUint64()) elif message_type == CONTROL_MESSAGE: self.routeMessage(di.getUint64(), di.getDatagram())
def nonBlockingRead(self, qcr):
if self.cReader.dataAvailable():
datagram = NetDatagram()
if self.cReader.getData(datagram):
data = PyDatagramIterator(datagram)
msgID = data.getUint16()
else:
data = None
msgID = MSG_NONE
else:
datagram = None
data = None
msgID = MSG_NONE
return (datagram, data, msgID)
def handle_packet(self, dg):
connection = dg.getConnection()
dgi = PyDatagramIterator(dg)
msg = dgi.getUint16()
# begin handling messages here
if msg == msg_types.CLIENT_HEARTBEAT:
self.handle_client_heartbeat(dgi)
elif msg == msg_types.CLIENT_LOGIN_2:
self.handle_client_login(dgi, connection)
elif msg == msg_types.CLIENT_DISCONNECT:
self.handle_client_disconnect(dgi, connection)
else:
self.logger.warn("received unimplemented message type - %d" % msg)
def begin(self):
if self.cReader.dataAvailable():
datagram = NetDatagram() # catch the incoming data in this instance
# Check the return value; if we were threaded, someone else could have
# snagged this data before we did
if self.cReader.getData(datagram):
myIterator = PyDatagramIterator(datagram)
msgID = myIterator.getUint8()
#If not in our protocol range then we just reject
if msgID < 0 or msgID > 200:
return
#Order of these will need to be optimized later
#We now pull out the rest of our headers
remotePacketCount = myIterator.getUint8()
ack = myIterator.getUint8()
acks = myIterator.getUint16()
hashID = myIterator.getUint16()
sourceOfMessage = datagram.getConnection()
if msgID == protocol.NEW_SHIP:
log.info("New ship")
playerPilotID = myIterator.getUint16()
shipID = myIterator.getUint16()
shipName = myIterator.getString()
health = myIterator.getUint8()
position = Point3(myIterator.getFloat32(), myIterator.getFloat32(), myIterator.getFloat32())
linearVelocity = Vec3(myIterator.getFloat32(), myIterator.getFloat32(), myIterator.getFloat32())
rotiation = VBase3(myIterator.getFloat32(), myIterator.getFloat32(), myIterator.getFloat32())
angularVelocity = Vec3(myIterator.getFloat32(), myIterator.getFloat32(), myIterator.getFloat32())
ship = sandbox.addEntity(shipID)
component = ships.PilotComponent()
component.accountEntityID = playerPilotID
ship.addComponent(component)
component = ships.BulletPhysicsComponent()
messenger.send("addSpaceShip", [component, shipName, position, linearVelocity])
ship.addComponent(component)
component = ships.ThrustComponent()
ship.addComponent(component)
component = ships.InfoComponent()
component.health = health
component.name = shipName
ship.addComponent(component)
elif msgID == protocol.PLAYER_MOVED_SHIP:
log.debug("Player moved ship")
accountID = myIterator.getUint16()
shipID = myIterator.getUint16()
print sandbox.components[shipID]
universals.shipNode = sandbox.components[shipID][ships.BulletPhysicsComponent].nodePath
elif msgID == protocol.LOGIN_ACCEPTED:
log.info("Login accepted")
entityID = myIterator.getUint8()
universals.day = myIterator.getFloat32()
elif msgID == protocol.LOGIN_DENIED:
log.info("Login failed")
def handle_datagram(self, datagram):
self.connection = datagram.getConnection()
if not self.connection:
pass # TODO!
di = PyDatagramIterator(datagram)
msg_type = di.getUint16()
print msg_type # debug
if msg_type == CLIENT_HEARTBEAT:
self.handle_client_heartbeat(self.connection, di)
elif msg_type == CLIENT_DISCONNECT:
self.remove_connection_instance(self.connection)
else:
print ("Recieved an unexpected datagram: %s from: %s" % (msg_type, str(self.connection)))
def updateRoutine(self, task):
"""A once-per-frame task used to read packets from the socket."""
while self.cReader.dataAvailable():
# Create a datagram to store all necessary data.
datagram = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram):
# Prepare the datagram to be iterated.
data = PyDatagramIterator(datagram)
# Retrieve a "short" that contains the response code.
responseCode = data.getUint16()
# Pass into another method to execute the response.
if responseCode != Constants.MSG_NONE:
self.handleResponse(responseCode, data)
return task.cont
def updateRoutine(self, task):
"""A once-per-frame task used to read packets from the socket."""
while self.cReader.dataAvailable():
# Create a datagram to store all necessary data.
datagram = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram):
# Prepare the datagram to be iterated.
data = PyDatagramIterator(datagram)
# Retrieve a "short" that contains the response code.
responseCode = data.getUint16()
# Pass into another method to execute the response.
if responseCode != Constants.MSG_NONE:
self.handleResponse(responseCode, data)
return task.cont
def server_processing(self,datagram):
data_iter = PyDatagramIterator(datagram)
msgID = data_iter.getUint16()
if msgID == PRINT_MESSAGE:
messageToPrint = data_iter.getString()
print messageToPrint
if msgID == ARMY_MOVE_REQUEST:
army_id = data_iter.getInt16()
ax = data_iter.getFloat64()
ay = data_iter.getFloat64()
tx = data_iter.getFloat64()
ty = data_iter.getFloat64()
base.armies[army_id].set_target(False,tx,ty)
if msgID == CLIENT_CHAT:
r = data_iter.getInt32()
g = data_iter.getInt32()
b = data_iter.getInt32()
text = data_iter.getString()
self.server_messager("chat_send",[(r,g,b),text])
#base.main_menu.chat_add((r,g,b,1),text)
if msgID == CLIENT_READY:
but_id = data_iter.getInt32()
state = data_iter.getInt32()
self.server_messager("ready_button",[but_id,state])
#base.main_menu.chat_add((r,g,b,1),text)
if msgID == CLIENT_LOADED:
self.server_messager("all_loaded",[])
base.menu_manager.menus["mp-load"].load_complete()
if msgID == CLIENT_INIT_REQUEST:
pn = data_iter.getString()
pk = data_iter.getString()
base.menu_manager.menus["mp-game"].obj_list[6]["text"] = pn
base.menu_manager.menus["mp-game"].obj_list[7]["text"] = pk
self.server_messager("client_update",[base.menu_manager.menus["mp-game"].obj_list[4]["text"],
base.menu_manager.menus["mp-game"].obj_list[5]["text"],
base.menu_manager.menus["mp-game"].obj_list[8]["indicatorValue"],
base.menu_manager.menus["mp-game"].map_selected])
if msgID == BUILD_START_REQUEST:
t_id = data_iter.getInt32()
player = data_iter.getInt32()
type = data_iter.getString()
base.towers[t_id].build_start()
if msgID == BUILD_CANCEL_REQUEST:
t_id = data_iter.getInt32()
player = data_iter.getInt32()
type = data_iter.getString()
base.towers[t_id].build_cancel()
def handle_datagram(self, datagram):
self.connection = datagram.getConnection()
if not self.connection:
pass # TODO!
di = PyDatagramIterator(datagram)
msg_type = di.getUint16()
print "Got Tewtow msgType: %s" % (msg_type) # debug
if msg_type == CLIENT_HEARTBEAT:
print "Server recieved Heartbeat."
self.handle_client_heartbeat(self.connection, di)
elif msg_type == CLIENT_DISCONNECT:
print "A Tewtow User Logged Off the Server: %s" % (
self.connection)
self.remove_connection_instance(self.connection)
elif msg_type == CLIENT_LOGIN_2:
## Client is asking for login... handle it.
##TODO: This should be validated from server.
print "A Tewtow User Logged Onto the Server.: %s" % (
self.connection)
self.handle_client_login(self.connection, di)
elif msg_type == CLIENT_GET_SHARD_LIST:
## Client is asking for our districts.. handle it.
self.handle_get_shard_list(self.connection, di)
elif msg_type == CLIENT_GET_AVATARS:
## Client is asking for his avatars.. handle it.
print "Getting %s Tews.." % (self.connection)
self.handle_get_avatars(self.connection, di)
elif msg_type == CLIENT_SET_AVATAR:
## Client is asking for AVATAR info, handle it.
print "%s Picked A Tew.. Setting Stuff Up." % (self.connection)
self.handle_set_avatar(self.connection, di)
elif msg_type == CLIENT_CREATE_AVATAR:
print "Someone Created a Tew!"
self.CLIENT_CREATE_AVATAR(self.connection, di)
elif msg_type == CLIENT_SET_NAME_PATTERN:
print "Someone Did a name for a Tew!"
self.CLIENT_SET_NAME_PATTERN(self.connection, di)
else:
print("Oh Shit! Recieved an unexpected Datagram: %s from: %s" %
(msg_type, str(self.connection)))
def __readTask(self, Task): ''' This task listens for any messages coming in over any connections. If we get a connection passes it to the datagram handler.''' if self._cReader.dataAvailable(): datagram=NetDatagram() if self._cReader.getData(datagram): data = PyDatagramIterator(datagram) msgID = data.getUint16() else: data = None msgID = MSG_NONE else: datagram = None data = None msgID = MSG_NONE if msgID is not MSG_NONE: self.__handleDatagram(data, msgID, datagram.getConnection()) return Task.cont
def check(self):
while self.cReader.dataAvailable():
datagram = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram):
data = PyDatagramIterator(datagram)
responseCode = data.getUint16()
if responseCode == self.CODE_INT:
self.getInt(data)
elif responseCode == self.CODE_STRING:
self.getString(data)
elif responseCode == self.CODE_SHORT:
self.getShort(data)
elif responseCode == self.CODE_FLOAT:
self.getFloat(data)
else:
for recvAction in self.recvActions:
if(responseCode == recvAction[0]):
recvAction[1](data)
def nonBlockingRead(self, qcr):
"""
Return a datagram iterator and type if data is available on the
queued connection reader
"""
if self.cReader.dataAvailable():
datagram = NetDatagram()
if self.cReader.getData(datagram):
data = PyDatagramIterator(datagram)
msgID = data.getUint16()
else:
data = None
msgID = MSG_NONE
else:
datagram = None
data = None
msgID = MSG_NONE
# Note, return datagram to keep a handle on the data
return (datagram, data, msgID)
def nonBlockingRead(self,qcr):
"""
Return a datagram iterator and type if data is available on the
queued connection reader
"""
if self.cReader.dataAvailable():
datagram = NetDatagram()
if self.cReader.getData(datagram):
data = PyDatagramIterator(datagram)
msgID = data.getUint16()
else:
data = None
msgID = MSG_NONE
else:
datagram = None
data = None
msgID = MSG_NONE
# Note, return datagram to keep a handle on the data
return (datagram, data, msgID)
def handleMessage(self, datagram): # Who sent us the message? connection = datagram.getConnection() dgi = PyDatagramIterator(datagram) messageType = dgi.getUint16() if messageType == CLIENT_HEARTBEAT: self.handleClientHeartbeat(dgi, connection) elif messageType == CLIENT_DISCONNECT: self.handleClientDisconnected(dgi, connection) elif messageType == CLIENT_LOGIN_3: self.handleClientLogin(dgi, connection) elif messageType == CLIENT_ADD_INTEREST: self.handleAddInterest(dgi, connection) elif messageType == CLIENT_OBJECT_UPDATE_FIELD: self.handleUpdateObjectField(dgi, connection) else: self._unimplementedType(messageType)
def __gotOwnerAv(self, db, retcode):
assert (self.notify.debug(
"__gotOwnerAv(%s, %s): %s" %
(list(db.values.keys()), retcode, self.doId)))
if retcode != 0:
self.notify.warning("Avatar %s for house %s does not exist!" %
(self.ownerId, self.doId))
return
# The avatar still exists, so check its properties.
onOrder = None
mailboxContents = None
awardMailboxContents = None
dg = db.values.get('setDeliverySchedule')
if dg:
di = PyDatagramIterator(dg)
blob = di.getString()
onOrder = CatalogItemList.CatalogItemList(
blob,
store=CatalogItem.Customization | CatalogItem.DeliveryDate)
dg = db.values.get('setMailboxContents')
if dg:
di = PyDatagramIterator(dg)
blob = di.getString()
mailboxContents = CatalogItemList.CatalogItemList(
blob, store=CatalogItem.Customization)
dg = db.values.get('setMaxHp')
if dg:
di = PyDatagramIterator(dg)
hp = di.getUint16()
dg = db.values.get('setAwardMailboxContents')
if dg:
di = PyDatagramIterator(dg)
blob = di.getString()
awardMailboxContents = CatalogItemList.CatalogItemList(
blob, store=CatalogItem.Customization)
#self.b_setCannonEnabled(1)
self.__checkMailbox(onOrder, mailboxContents, 0, awardMailboxContents)
def handle_datagram(self, datagram):
self.connection = datagram.getConnection()
if not self.connection:
self.boot_invalid_connection()
di = PyDatagramIterator(datagram)
msg_type = di.getUint16()
if msg_type == REQUEST_FOR_LOGIN:
self.database_mgr.handle_login_request(self, self.connection, account_name=di.getString(), account_password=di.getString())
elif msg_type == REQUEST_FOR_REGISTER:
self.database_mgr.handle_create_account_request(self, self.connection, di.getString(), di.getString())
elif msg_type == REQUEST_FOR_PASSWORD_CHANGE:
return NotImplemented
elif msg_type == REQUEST_FOR_ACCOUNT_DELETE:
return NotImplemented
else:
print ("Database: Recieved an unknown protocol request: %d from %s" % (msg_type, str(self.connection)))
return
def handleDatagram(self, datagram): connection = datagram.getConnection() di = PyDatagramIterator(datagram) message_type = di.getUint16() print message_type # Debug if message_type == CLIENT_HEARTBEAT: self.handleClientHeartbeat(di, connection) elif message_type == CLIENT_DISCONNECT: self.handleClientDisconnected(di, connection) elif message_type == CLIENT_ADD_INTEREST: self.handleClientAddInterest(di, connection) elif message_type == CLIENT_REMOVE_INTEREST: self.handleClientRemoveInterest(di, connection) elif message_type == STATESERVER_BOUNCE_MESSAGE: self.handleStateServerBounceMessage(di, connection) else: return
def __readTask(self, taskdata): ''' This task listens for any messages coming in over any connections. If we get a connection passes it to the datagram handler.''' if self._cReader.dataAvailable(): datagram=NetDatagram() # catch the incoming data in this instance # Check the return value; if we were threaded, someone else could have # snagged this data before we did if self._cReader.getData(datagram): data = PyDatagramIterator(datagram) msgID = data.getUint16() else: data = None msgID = MSG_NONE else: datagram = None data = None msgID = MSG_NONE if msgID is not MSG_NONE: self.__handleDatagram(data, msgID, datagram.getConnection()) return Task.cont
def udpNonBlockingRead(self, qcr):
"""
Return a datagram collection and type if data is available on
the queued connection udpReader
"""
if self.udpReader.dataAvailable():
datagram = NetDatagram()
if self.udpReader.getData(datagram):
data = PyDatagramIterator(datagram)
opcode = data.getUint16()
else:
data = None
opcode = MSG_NONE
else:
datagram = None
data = None
opcode = MSG_NONE
# Return the datagram to keep a handle on the data
return (datagram, data, opcode)
def udpNonBlockingRead(self, qcr):
"""
Return a datagram collection and type if data is available on
the queued connection udpReader.
"""
if self.udpReader.dataAvailable():
datagram = NetDatagram()
if self.udpReader.getData(datagram):
data = PyDatagramIterator(datagram)
opcode = data.getUint16()
else:
data = None
opcode = MSG_NONE
else:
datagram = None
data = None
opcode = MSG_NONE
# Return the datagram to keep a handle on the data
return (datagram, data, opcode)
def tcpNonBlockingRead(self, qcr):
"""
Return a datagram collection and type if data is available on
the queued tcp connection reader.
@param qcr: self.tcpReader
"""
if self.tcpReader.dataAvailable():
datagram = NetDatagram()
if self.tcpReader.getData(datagram):
data = PyDatagramIterator(datagram)
opcode = data.getUint16()
else:
data = None
opcode = MSG_NONE
else:
datagram = None
data = None
opcode = MSG_NONE
return (datagram, data, opcode)
def check(self): while self.cReader.dataAvailable(): print "data here" datagram = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram): data = PyDatagramIterator(datagram) responseCode = data.getUint16() print responseCode if responseCode == 201: self.getPlayer(data) elif responseCode == 202: self.register(data) elif responseCode == 203: self.getOpponent(data) elif responseCode == 214: self.movePlayer(data) elif responseCode == 219: self.dropPlayer(data) else: print "nothing found"
def receiveResponse301(self):
while self.cReader.dataAvailable():
datagram301 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram301):
myIterator = PyDatagramIterator(datagram301)
p = myIterator.getUint16()
if p == 213:
un = myIterator.getString()
cname = myIterator.getString()
ctype = myIterator.getUint32()
cteam = myIterator.getUint32()
if un == MyApp.uname:
abc = 'abc'
else:
print cname + ' just joined a game......!! hurray'
#print msg, " received"
self.received = 1
def receiveResponse301(self):
while self.cReader.dataAvailable():
datagram301 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram301):
myIterator = PyDatagramIterator(datagram301)
p = myIterator.getUint16()
if p == 213:
un = myIterator.getString()
cname = myIterator.getString()
ctype = myIterator.getUint32()
cteam = myIterator.getUint32()
if un == MyApp.uname:
abc = 'abc'
else:
print cname+' just joined a game......!! hurray'
#print msg, " received"
self.received = 1
def tcpNonBlockingRead(self, qcr):
"""
Return a datagram collection and type if data is available on
the queued tcp connection reader.
@param qcr: self.tcpReader
"""
if self.tcpReader.dataAvailable():
datagram = NetDatagram()
if self.tcpReader.getData(datagram):
data = PyDatagramIterator(datagram)
opcode = data.getUint16()
else:
data = None
opcode = MSG_NONE
else:
datagram = None
data = None
opcode = MSG_NONE
return (datagram, data, opcode)
def check(self):
while self.cReader.dataAvailable():
print "data here"
datagram = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram):
data = PyDatagramIterator(datagram)
responseCode = data.getUint16()
print responseCode
if responseCode == 201:
self.getPlayer(data)
elif responseCode == 202:
self.register(data)
elif responseCode == 203:
self.getOpponent(data)
elif responseCode == 214:
self.movePlayer(data)
elif responseCode == 219:
self.dropPlayer(data)
else:
print "nothing found"
def check(self):
while self.cReader.dataAvailable():
datagram = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram):
data = PyDatagramIterator(datagram)
responseCode = data.getUint16()
if responseCode == 212:
print self.getString(data)
self.options()
elif responseCode == 201: #login code
if (self.getString(data)=="Unsuccessful login"): #appears if login unsuccessful
print " "
print "Unsuccessful login"
print " "
self.options()
else:
print "Your are logged in" #appear if login successful
self.login_options()#appears the login options
elif responseCode == 203: #register code
if (self.getString(data)=="Registration successful"): #appear if registration was successful
print "You are now registered"
print "Please login" #user must login
print " "
self.options()
else:
print " "#appear if registration wasn't successful
print "Registration was unsuccessful. Pick a different username and please try again "
print " "
self.options()#user must attempt to register again
elif responseCode == 215:
print self.getString(data)
self.messages()
elif responseCode == 216:
print self.getString(data)
self.messages()
else:
print "nothing found"
def myProcessDataFunction(datagram):
global status, P1NAME, P2NAME, lastResetRequest
global MY_POSITION, kicker, texKicker, texKicker2, mode
if (role == ROLE_SERVER):
sender = activeConnections.index(datagram.getConnection())
data = PyDatagramIterator(datagram)
#try:
if True: #just to keep the indent, in case we need "try" again.
pktType = data.getUint16()
if role == ROLE_SERVER: # packets received only by server
if pktType == PACKET_MOVE:
setOpponentMove(data, sender + 1)
elif pktType == PACKET_MSG:
timer = data.getUint16()
msg = data.getString()
sendMessage(msg, timer) #broadcast to all
elif pktType == PACKET_HELLO:
magic = data.getString()
proto = data.getUint16()
soft = data.getString()
if magic != MAGIC_WORD:
print "Connecting party did not identify as netkickern client."
sys.exit(1)
if proto != PROTOCOL_VERSION:
print "Connecting party used incompatible protocol version " + str(
proto) + "."
print "We are using " + str(PROTOCOL_VERSION) + "."
sys.exit(1)
if soft != SOFTWARE_VERSION:
print "WARNING: Client is using software " + soft + "."
print "Ok, client " + str(sender + 1) + " connected."
status = STATUS_INIT
qpref = PyDatagram() #query for client preferences
qpref.addUint16(PACKET_QPREF)
qpref.addString(SOFTWARE_VERSION)
cWriter.send(qpref, activeConnections[sender])
elif pktType == PACKET_PREF:
if status != STATUS_INIT:
return
prefs = {}
teamname = data.getString()
prefs['team'] = teamname
place = -1
if (mode == MODE_4P):
#assign the last free position, and P1 only if the teamname matches or everything else is given away
if not POSITION[3]:
place = 3
if not POSITION[2]:
place = 2
if (teamname == TEAMNAME) or (place == -1):
if not POSITION[1]:
place = 1
print "placed player ", sender + 1, " at position ", place
POSITION[place] = sender + 1
prefs['pos'] = place
playerPrefs[sender] = prefs
if (mode == MODE_2P) or (0 in playerPrefs and 1 in playerPrefs
and 2 in playerPrefs):
P1NAME = TEAMNAME
P2NAME = playerPrefs[0]['team']
rename = PyDatagram()
rename.addUint16(PACKET_NAME)
rename.addString(P1NAME)
rename.addString(P2NAME)
toAll(rename, activeConnections)
if (mode == MODE_4P
): #inform players of the position they play in
for i in range(0, 3):
placing = PyDatagram()
placing.addUint16(PACKET_PLACE)
placing.addUint16(playerPrefs[i]['pos'])
cWriter.send(placing, activeConnections[i])
resetNames()
welcome = PyDatagram()
welcome.addUint16(PACKET_START)
toAll(welcome, activeConnections)
startGame()
elif pktType == PACKET_PONG:
stime = data.getFloat64()
now = time.time()
deltatime = now - stime # TODO: use this to delay mouse movements by avg(deltatime)/2
print "player " + str(sender) + " network delay: " + str(
deltatime * 500) + "ms " #rtt/2
elif pktType == PACKET_RESET:
lastResetRequest = time.time()
playerPrefs[sender]['lastReset'] = lastResetRequest
if not isResetConfirmed():
resetRequest = PyDatagram() #forward to all clients
resetRequest.addUint16(PACKET_RESET)
#resetRequest.addUint16(sender) # TODO: tell everyone which player sent the request
toAll(resetRequest, activeConnections)
setMessage(
"Player " + str(sender + 1) +
" wishes to reset the ball.\nPress Space to confirm.",
3)
else: # packets received only by clients
if pktType == PACKET_SET:
setGameStatus(data)
elif pktType == PACKET_SCORE:
setScore(data)
elif pktType == PACKET_QPREF:
soft = data.getString()
if soft != SOFTWARE_VERSION:
print "WARNING: Server is using software " + soft + "."
status = STATUS_INIT
pref = PyDatagram()
pref.addUint16(PACKET_PREF)
pref.addString(TEAMNAME)
cWriter.send(pref, serverConnection)
elif pktType == PACKET_START:
print "connection to game host confirmed."
startGame()
elif pktType == PACKET_MSG:
timer = data.getUint16()
msg = data.getString()
setMessage(msg, timer)
elif pktType == PACKET_NAME:
P1NAME = data.getString()
P2NAME = data.getString()
resetNames()
elif pktType == PACKET_PLACE: #4P only
MY_POSITION = data.getUint16()
mode = MODE_4P
resetGameColours(kicker, texKicker, texKicker2)
elif pktType == PACKET_PING:
stime = data.getFloat64()
pong = PyDatagram()
pong.addUint16(PACKET_PONG)
pong.addFloat64(stime)
cWriter.send(pong, serverConnection)
elif pktType == PACKET_RESET:
setMessage(
"Another wishes to reset the ball.\nPress Space to confirm.",
3)
#except Exception, e:
# print e
# sys.exit(1) #wow, this is what I call exception handling..
return
def handleDatagram(self, dg):
if not dg.getLength() > 0:
return None
dgi = PyDatagramIterator(dg)
connection = dg.getConnection()
msgType = dgi.getUint16()
if msgType == CLIENT_HEARTBEAT:
self.notify.debug('Recieved heartbeat.')
elif msgType == CLIENT_DISCONNECT:
if connection in self.connectionList:
self.connectionList.remove(connection)
elif msgType == CLIENT_SET_ZONE:
self.handleSetZone(dgi, connection)
elif msgType == CLIENT_REMOVE_ZONE:
self.handleRemoveZone(dgi, connection)
elif msgType == CLIENT_CREATE_OBJECT_REQUIRED:
self.handleClientCreateObjectRequired(dg, dgi)
elif msgType == CLIENT_OBJECT_UPDATE_FIELD:
doId = dgi.getUint32()
fieldId = dgi.getUint16()
print "DEBUG: Got Toontown field update for Toontown doId = %d and Toontown fieldId = %d" % (doId, fieldId)
elif msgType == CLIENT_OBJECT_DELETE:
self.handleClientDeleteObject(dg, dgi.getUint32())
elif msgType == CLIENT_OBJECT_DISABLE:
self.handleClientDisable(dg, dgi.getUint32())
elif msgType == CLIENT_ADD_INTEREST:
#self.handleClientAddInterest(self, Client, dgi)
handle = dgi.getUint16()
contextId = dgi.getUint32()
parentId = dgi.getUint32()
zoneList = [dgi.getUint32()]
print 'DEBUG: Network :: Interest -> (%d, %d, %d)' % (handle, contextId, parentId)
while True:
remainingData = (dg.getLength() - dgi.getCurrentIndex())
if remainingData == 0:
break
zoneList.append(dgi.getUint32())
if handle == 2: #Aww yeah we found the tewtow shard list interest!
datagram = PyDatagram()
datagram.addUint16(CLIENT_CREATE_OBJECT_REQUIRED_OTHER_RESP)
datagram.addUint32(4618) #parentId
datagram.addUint32(3) #zoneId
datagram.addUint16(58) #ToontownDistrict DClass Field
datagram.addUint32(316000000) #Shard ID (doId)
datagram.addString('Astron is for n00bs') #District name
datagram.addUint8(1) # 1 - Enabled 0 - Disabled
datagram.addBool(0)
self.cw.send(datagram, connection)
if handle == 4:
datagram = PyDatagram()
datagram.addUint16(CLIENT_CREATE_OBJECT_REQUIRED_OTHER_RESP)
datagram.addUint32(4618) #parentId
datagram.addUint32(3) #zoneId
datagram.addUint16(387) #ToontownDistrict DClass Field
datagram.addUint32(900000000) #Shard ID (doId)
datagram.addString("2013-08-22 23:49:46")
self.cw.send(datagram, connection)
datagran2 = PyDatagram()
datagran2.addUint16(CLIENT_CREATE_OBJECT_REQUIRED_OTHER_RESP)
datagran2.addUint32(0)
datagran2.addUint32(0)
datagran2.addUint16(172)
datagran2.addUint32(637100008)
arg = []
datagran2.addUint16(len(arg) << 1)
for i in arg:
datagran2.addInt16(int(i))
datagran2.addUint16(len(arg) << 1)
for i in arg:
datagran2.addInt16(int(i))
datagran2.addUint16(len(arg) << 1)
for i in arg:
datagran2.addInt16(int(i))
datagran2.addUint16(len(arg) << 1)
for i in arg:
datagran2.addInt16(int(i))
#arg = [64, 65, 66, 10, 15]
datagran2.addUint16(len(arg))
for i in arg:
datagran2.addUint16(int(i))
self.cw.send(datagran2, connection)
if handle == 5:
datagram = PyDatagram()
datagram.addUint16(CLIENT_OBJECT_UPDATE_FIELD)
datagram.addUint32(1) #doId
datagram.addUint16(112) #fieldId
datagram.addUint32(316000000)
self.cw.send(datagram, connection)
datagram = PyDatagram()
datagram.addUint16(CLIENT_DONE_INTEREST_RESP)
datagram.addUint16(handle)
datagram.addUint32(contextId)
datagram.addUint32(parentId)
for zoneId in zoneList:
datagram.addUint32(zoneId)
self.cw.send(datagram, connection)
datagram = PyDatagram()
datagram.addUint16(CLIENT_DONE_INTEREST_RESP)
datagram.addUint16(handle)
datagram.addUint32(contextId)
datagram.addUint32(parentId)
for zoneId in zoneList:
datagram.addUint32(zoneId)
self.cw.send(datagram, connection)
elif msgType == CLIENT_REMOVE_INTEREST:
return None
#Lets start with the tewtow specific msgtypes.
elif msgType == CLIENT_LOGIN_TOONTOWN:
self.handleClientLoginToontown(dgi, connection)
elif msgType == CLIENT_GET_AVATARS:
self.handleGetAvatars(dgi, connection)
elif msgType == CLIENT_GET_AVATARS:
self.handleGetAvatars(dgi, connection)
elif msgType == CLIENT_CREATE_AVATAR:
#return None
datagram = PyDatagram()
datagram.addUint16(CLIENT_CREATE_AVATAR_RESP)
datagram.addUint16(0) #echoContext
datagram.addUint8(0) #returnCode
datagram.addUint32(1)
self.cw.send(datagram, connection)
elif msgType == CLIENT_SET_NAME_PATTERN:
datagram = PyDatagram()
datagram.addUint16(CLIENT_SET_NAME_PATTERN_ANSWER)
datagram.addUint32(1)
datagram.addUint8(0)
self.cw.send(datagram, connection)
elif msgType == CLIENT_SET_AVATAR:
packer = DCPacker()
dclass = self.dclassesByName['DistributedToon']
datagram = PyDatagram()
datagram.addUint16(15) #CLIENT_GET_AVATAR_DETAILS_RESP Msgtype
datagram.addUint32(1)
datagram.addUint8(0)
datagram.addString('Infinity') #Toon name
datagram.addString('Unknown')
datagram.addUint32(0)
datagram.addBool(1)
datagram.addString('t\x05\x01\x00\x01\x39\x1b\x33\x1b\31\x1b\x14\x00\x14\x14') #DNA (blob)
datagram.addUint8(1) #GM
datagram.addUint16(2500) #Max Bank
datagram.addUint16(0) #Current Bank
datagram.addUint16(40) #Max Jellybeans
datagram.addUint16(0) #Current Jellybeans
datagram.addUint16(15) #Max Laff
datagram.addUint16(15) #Current Laff
datagram.addUint32(0) #Battle ID
datagram.addString('Unknown') #Experience (blob)
datagram.addUint8(10) #Max Gag Carry
#setTrackAccess
field = dclass.getField(13)
print field
arg = [0, 0, 0, 0, 1, 1, 0]
datagram.addUint16(len(arg) << 1)
for i in arg:
datagram.addInt16(int(i))
datagram.addInt8(3) #Track Progress 1
datagram.addUint32(9) #Track Progress 2
#setTrackBonusLevel
field = dclass.getField(15)
print field
arg = [0, 0, 0, 0, 1, 1, 0]
datagram.addUint16(len(arg))
for i in arg:
datagram.addInt8(int(i))
datagram.addString('') #setInventory
#setMaxNPCFriends (Uint16)
datagram.addUint16(16)
arg = []
datagram.addUint16(len(arg) * 5)
for i in arg:
datagram.addUint32(int(i))
datagram.addUint32(316000000) #setDefaultShard
datagram.addUint32(2000) #setDefaultZone
datagram.addString('')
field = dclass.getField(22)
print field
arg = [1000, 2000 , 3000, 4000, 5000, 6000, 8000, 9000, 10000, 11000, 12000, 13000]
datagram.addUint16(len(arg) << 2)
for i in arg:
datagram.addUint32(int(i))
field = dclass.getField(23)
print field
arg = [1000, 2000 , 3000, 4000, 5000, 6000, 8000, 9000, 10000, 11000, 12000, 13000]
datagram.addUint16(len(arg) << 2)
for i in arg:
datagram.addUint32(int(i))
datagram.addString('') #setInterface
datagram.addUint32(2000) #setLastHood
datagram.addUint8(1) #setTutorialAck
datagram.addUint32(25) #setMaxClothes
#setClothesTopsList(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
#setClothesBottomsList(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
datagram.addUint32(0) #setMaxAccessories
#setHatList(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
#setGlassessList(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
#setBackpackList(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
#setShoesList(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
datagram.addUint8(0) #setHat 1
datagram.addUint8(0) #setHat 2
datagram.addUint8(0) #setHat 3
datagram.addUint8(0) #setGlasses 1
datagram.addUint8(0) #setGlasses 2
datagram.addUint8(0) #setGlasses 3
datagram.addUint8(0) #setBackpack 1
datagram.addUint8(0) #setBackpack 2
datagram.addUint8(0) #setBackpack 3
datagram.addUint8(0) #setShoes 1
datagram.addUint8(0) #setShoes 2
datagram.addUint8(0) #setShoes 3
datagram.addString('')
#setEmoteAccess(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
#setCustomMeeages(uint16array)
arg = []
datagram.addUint16(len(arg) << 1)
for i in arg:
datagram.addUint16(int(i))
datagram.addString('') #setResistanceMessages
#setPetTrickPhrases(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
datagram.addUint16(0) #setCatalogSchedule 1
datagram.addUint32(0) #setVatalogSchedule 2
datagram.addString('') #setCatalog 1
datagram.addString('') #setCatalog 2
datagram.addString('') #setCatalog 3
datagram.addString('') #setMailBoxContents
datagram.addString('') #SetDeliverySchedule
datagram.addString('') #setGiftSchedule
datagram.addString('') #setAwardMailboxContents
datagram.addString('') #setAwardSchedule
datagram.addUint8(0) #setAwardNotify
datagram.addUint8(0) #setCatalogNotify 1
datagram.addUint8(0) #setCatalogNotify 2
datagram.addUint8(0) #setSpeedChatStyleIndex
#setTeleportAccess (uint32array)
arg = [1000, 2000 , 3000, 4000, 5000, 6000, 8000, 9000, 10000, 11000, 12000, 13000]
datagram.addUint16(len(arg) << 2)
for i in arg:
datagram.addUint32(int(i))
#setCogStatus (uint32array)
arg = []
datagram.addUint16(len(arg) << 2)
for i in arg:
datagram.addUint32(int(i))
#setCogCount (uint32array)
arg = []
datagram.addUint16(len(arg) << 2)
for i in arg:
datagram.addUint32(int(i))
#setCogRadar(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
#setBuildingRadar(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
#setCogLevels(uint8array)
arg = [0, 0, 0, 0]
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
#setCogTypes(uint8array)
arg = [0, 0, 0, 0]
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
#setCogParts (uint32array)
arg = [0, 0, 0, 0]
datagram.addUint16(len(arg) << 2)
for i in arg:
datagram.addUint32(int(i))
#setCogMerits(uint16array)
arg = [0, 0, 0, 0]
datagram.addUint16(len(arg) << 1)
for i in arg:
datagram.addUint16(int(i))
datagram.addUint32(0) #setHouseId
#setQuests (uint32array)
arg = []
datagram.addUint16(len(arg) << 2)
for i in arg:
datagram.addUint32(int(i))
#setQuestHistory(uint16array)
arg = []
datagram.addUint16(len(arg) << 1)
for i in arg:
datagram.addUint16(int(i))
datagram.addUint8(0) #setRewardHistory 1
#setRewardHistory 2(uint16array)
arg = []
datagram.addUint16(len(arg) << 1)
for i in arg:
datagram.addUint16(int(i))
datagram.addUint8(1) #setQuestCarryLimit
datagram.addInt16(0) #setCheesyEffect 1
datagram.addUint32(0) #setCheesyEffect 2
datagram.addUint32(0) #setCheesyEffect 3
datagram.addUint8(0) #setPosIndex
#setFishCollection 1(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
#setFishCollection 2(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
#setFishCollection 3(uint16array)
arg = []
datagram.addUint16(len(arg) << 1)
for i in arg:
datagram.addUint16(int(i))
datagram.addUint8(20) #setMaxFishTank
#setFishTank 1(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
#setFishTank 2(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
#setFishTank 3(uint16array)
arg = []
datagram.addUint16(len(arg) << 1)
for i in arg:
datagram.addUint16(int(i))
datagram.addUint8(1) #setFishingRod
#setFishingTrophies(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
#setFlowerCollection 1(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
#setFlowerCollection 2(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
#setFlowerBasket 1(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
#setFlowerBasket 2(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
datagram.addUint8(25) #setMaxFlowerBasket
#setGardenTrophies(uint8array)
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
datagram.addUint8(1) #setShovel
datagram.addUint32(0) #setShovelSkill
datagram.addUint8(1) #setWateringCan
datagram.addUint32(0) #setWateringCanSkill
datagram.addUint32(0) #setPetID
datagram.addUint8(0) #setPetTutorialDone
datagram.addUint8(0) #setFishBingoTutorialDone
datagram.addUint8(0) #setFishBingoMarkTutorialDone
datagram.addInt8(0) #setKartBodyType
datagram.addInt8(0) #setKartBodyColor
datagram.addInt8(0) #setKartAccessoryColor
datagram.addInt8(0) #setKartEngineBlockType
datagram.addInt8(0) #setKartSpoilerType
datagram.addInt8(0) #setKartFrontWheelWellType
datagram.addInt8(0) #setKartBackWheelWellType
datagram.addInt8(0) #setKartRimType
datagram.addInt8(0) #setKartDecalType
datagram.addUint32(100) #setTickets
datagram.addUint8(0) #setKartingHistory 1
datagram.addUint8(0) #setKartingHistory 2
datagram.addUint8(0) #setKartingHistory 3
datagram.addUint8(0) #setKartingHistory 4
datagram.addUint8(0) #setKartingHistory 5
datagram.addUint8(0) #setKartingHistory 6
datagram.addUint8(0) #setKartingHistory 7
datagram.addUint8(0) #setKartingHistory 8
datagram.addUint8(0) #setKartingHistory 9
datagram.addUint8(0) #setKartingHistory 10
datagram.addUint8(0) #setKartingHistory 11
datagram.addUint8(0) #setKartingHistory 12
datagram.addUint8(0) #setKartingHistory 13
datagram.addUint8(0) #setKartingHistory 14
datagram.addUint8(0) #setKartingHistory 15
datagram.addUint8(0) #setKartingHistory 16
datagram.addUint8(0) #setKartingTrophies 1
datagram.addUint8(0) #setKartingTrophies 2
datagram.addUint8(0) #setKartingTrophies 3
datagram.addUint8(0) #setKartingTrophies 4
datagram.addUint8(0) #setKartingTrophies 5
datagram.addUint8(0) #setKartingTrophies 6
datagram.addUint8(0) #setKartingTrophies 7
datagram.addUint8(0) #setKartingTrophies 8
datagram.addUint8(0) #setKartingTrophies 9
datagram.addUint8(0) #setKartingTrophies 11
datagram.addUint8(0) #setKartingTrophies 11
datagram.addUint8(0) #setKartingTrophies 12
datagram.addUint8(0) #setKartingTrophies 13
datagram.addUint8(0) #setKartingTrophies 14
datagram.addUint8(0) #setKartingTrophies 15
datagram.addUint8(0) #setKartingTrophies 16
datagram.addUint8(0) #setKartingTrophies 17
datagram.addUint8(0) #setKartingTrophies 18
datagram.addUint8(0) #setKartingTrophies 19
datagram.addUint8(0) #setKartingTrophies 20
datagram.addUint8(0) #setKartingTrophies 21
datagram.addUint8(0) #setKartingTrophies 22
datagram.addUint8(0) #setKartingTrophies 23
datagram.addUint8(0) #setKartingTrophies 24
datagram.addUint8(0) #setKartingTrophies 25
datagram.addUint8(0) #setKartingTrophies 26
datagram.addUint8(0) #setKartingTrophies 27
datagram.addUint8(0) #setKartingTrophies 28
datagram.addUint8(0) #setKartingTrophies 29
datagram.addUint8(0) #setKartingTrophies 30
datagram.addUint8(0) #setKartingTrophies 31
datagram.addUint8(0) #setKartingTrophies 32
datagram.addUint8(0) #setKartingTrophies 33
datagram.addUint32(0) #setKartingPersonalBest 1
datagram.addUint32(0) #setKartingPersonalBest 2
datagram.addUint32(0) #setKartingPersonalBest 3
datagram.addUint32(0) #setKartingPersonalBest 4
datagram.addUint32(0) #setKartingPersonalBest 5
datagram.addUint32(0) #setKartingPersonalBest 6
datagram.addUint32(0) #setKartingPersonalBest2 1
datagram.addUint32(0) #setKartingPersonalBest2 2
datagram.addUint32(0) #setKartingPersonalBest2 3
datagram.addUint32(0) #setKartingPersonalBest2 4
datagram.addUint32(0) #setKartingPersonalBest2 5
datagram.addUint32(0) #setKartingPersonalBest2 6
datagram.addUint32(0) #setKartingPersonalBest2 7
datagram.addUint32(0) #setKartingPersonalBest2 8
datagram.addUint32(0) #setKartingPersonalBest2 9
datagram.addUint32(0) #setKartingPersonalBest2 10
datagram.addUint32(0) #setKartingPersonalBest2 11
datagram.addUint32(0) #setKartingPersonalBest2 12
#setKartAccessoriesOwned [16]
datagram.addInt8(0)
datagram.addInt8(0)
datagram.addInt8(0)
datagram.addInt8(0)
datagram.addInt8(0)
datagram.addInt8(0)
datagram.addInt8(0)
datagram.addInt8(0)
datagram.addInt8(0)
datagram.addInt8(0)
datagram.addInt8(0)
datagram.addInt8(0)
datagram.addInt8(0)
datagram.addInt8(0)
datagram.addInt8(0)
datagram.addInt8(0)
#setCogSummonsEarned
arg = []
datagram.addUint16(len(arg))
for i in arg:
datagram.addUint8(int(i))
datagram.addUint8(0) #setGardenStart
#setGolfHistory [18]
datagram.addUint16(0)
datagram.addUint16(0)
datagram.addUint16(0)
datagram.addUint16(0)
datagram.addUint16(0)
datagram.addUint16(0)
datagram.addUint16(0)
datagram.addUint16(0)
datagram.addUint16(0)
datagram.addUint16(0)
datagram.addUint16(0)
datagram.addUint16(0)
datagram.addUint16(0)
datagram.addUint16(0)
datagram.addUint16(0)
datagram.addUint16(0)
datagram.addUint16(0)
datagram.addUint16(0)
#setPackedGolfHoleBest [18]
datagram.addUint8(0)
datagram.addUint8(0)
datagram.addUint8(0)
datagram.addUint8(0)
datagram.addUint8(0)
datagram.addUint8(0)
datagram.addUint8(0)
datagram.addUint8(0)
datagram.addUint8(0)
datagram.addUint8(0)
datagram.addUint8(0)
datagram.addUint8(0)
datagram.addUint8(0)
datagram.addUint8(0)
datagram.addUint8(0)
datagram.addUint8(0)
datagram.addUint8(0)
datagram.addUint8(0)
#setGolfCourseBest
datagram.addUint8(0)
datagram.addUint8(0)
datagram.addUint8(0)
datagram.addUint8(0) #setPinkSlips
datagram.addUint8(0) #setNametagStyle
self.cw.send(datagram, connection)
elif msgType == CLIENT_SET_WISHNAME:
#print dgi
avId = dgi.getUint16()
unknown = dgi.getString()
pendingName = dgi.getString()
print pendingName
divide = pendingName.split(' ')
lenStr = len(divide)
s = 0
while s != lenStr:
nameCheck = divide[s]
s += 1
with open ("TewtowBlacklist.txt", "r") as badWordFile:
data=badWordFile.readlines()
for word in data:
chrList = list(word)
if chrList.count('\n') == 1:
chrList.remove('\n')
badWord = ''.join(chrList)
if nameCheck == badWord:
print 'Bad name detected, are you trying to get banned?'
datagram = PyDatagram()
datagram.addUint16(CLIENT_SET_WISHNAME_RESP)
datagram.addUint32(avId)
datagram.addUint16(0)
datagram.addString('NO')
datagram.addString('NO')
datagram.addString('')
message = PyDatagram()
message.addUint16(CLIENT_SYSTEM_MESSAGE)
message.addString('Sorry, That name is not allowed.')
self.cw.send(message, connection)
else:
datagram = PyDatagram()
datagram.addUint16(CLIENT_SET_WISHNAME_RESP)
datagram.addUint32(avId)
datagram.addUint16(0)
datagram.addString('NO')
datagram.addString('')
datagram.addString('NO')
self.cw.send(datagram, connection)
elif msgType == CLIENT_OBJECT_LOCATION:
doId = dgi.getUint32()
parentId = dgi.getUint32()
zoneId = dgi.getUint32()
print 'Network :: Location -> (%d, %d, %d)' % (doId, parentId, zoneId)
if zoneId == 2000:
#DistributedMickey
datagram = PyDatagram()
datagram.addUint16(CLIENT_CREATE_OBJECT_REQUIRED_OTHER_RESP)
datagram.addUint32(316000000) #parentId
datagram.addUint32(2) #zoneId
#datagram.addUint16(83)
datagram.addUint16(65)
datagram.addUint32(433103088)
datagram.addString("a")
datagram.addString("a")
datagram.addInt16(0)
self.cw.send(datagram, connection)
if zoneId == 1000:
datagram = PyDatagram()
datagram.addUint16(CLIENT_CREATE_OBJECT_REQUIRED_OTHER_RESP)
datagram.addUint32(316000000) #parentId
datagram.addUint32(2) #zoneId
#datagram.addUint16(83)
datagram.addUint16(108)
datagram.addUint32(433103088)
datagram.addString("DockedEast")
datagram.addInt16(100)
self.cw.send(datagram, connection)
if zoneId == 5000:
'''
datagram = PyDatagram()
datagram.addUint16(CLIENT_CREATE_OBJECT_REQUIRED_OTHER_RESP)
datagram.addUint32(316000000) #parentId
datagram.addUint32(2) #zoneId
datagram.addUint16(68)
datagram.addUint32(433103088)
datagram.addString("a")
datagram.addString("a")
datagram.addInt16(0)
self.cw.send(datagram, connection)
'''
#self.cw.send(datagram, connection)
if zoneId == 2000:
pass
'''#message = PyDatagram()
#message.addUint16(CLIENT_SYSTEM_MESSAGE)
#message.addString('Surprised? I thought so. :P')
#self.cw.send(message, connection)
datagram = PyDatagram()
datagram.addUint16(CLIENT_CREATE_OBJECT_REQUIRED_OTHER_RESP)
datagram.addUint32(316000000) #parentId
datagram.addUint32(2) #zoneId
#datagram.addUint16(83)
datagram.addUint16(65)
datagram.addUint32(433103088)
datagram.addString("b")
datagram.addString("a")
datagram.addInt16(0)
self.cw.send(datagram, connection)'''
if zoneId == 3000:
datagram = PyDatagram()
datagram.addUint16(CLIENT_CREATE_OBJECT_REQUIRED_OTHER_RESP)
datagram.addUint32(316000000) #parentId
datagram.addUint32(2) #zoneId
#datagram.addUint16(83)
datagram.addUint16(79)
datagram.addUint32(433103089)
datagram.addString("a")
datagram.addString("a")
datagram.addInt16(0)
self.cw.send(datagram, connection)
datagram = PyDatagram()
datagram.addUint16(CLIENT_GET_STATE_RESP)
self.cw.send(datagram, connection)
else:
self.notify.warning('Got a datagram %d; but could not handle it.' % msgType)
def client_processing(self,datagram):
data_iter = PyDatagramIterator(datagram)
msgID = data_iter.getUint16()
if msgID == PRINT_MESSAGE:
messageToPrint = data_iter.getString()
print messageToPrint
if msgID == ARMY_MOVE:
army_id = data_iter.getInt16()
ax = data_iter.getFloat64()
ay = data_iter.getFloat64()
tx = data_iter.getFloat64()
ty = data_iter.getFloat64()
base.armies[army_id].node_path.setX(ax)
base.armies[army_id].node_path.setY(ay)
base.armies[army_id].move_to_point(tx,ty)
if msgID == CLIENT_INIT_UPDATE:
p1_name = data_iter.getString()
p1_kingdom = data_iter.getString()
p1_ready = data_iter.getInt32()
game_map = data_iter.getInt32()
base.menu_manager.menus["mp-game"].client_update(p1_name,p1_kingdom,p1_ready,game_map)
if msgID == SERVER_CHAT:
r = data_iter.getInt32()
g = data_iter.getInt32()
b = data_iter.getInt32()
text = data_iter.getString()
base.menu_manager.menus["mp-game"].chat_add((r,g,b),text)
if msgID == SERVER_READY:
but_id = data_iter.getInt32()
state = data_iter.getInt32()
base.menu_manager.menus["mp-game"].obj_list[but_id]["indicatorValue"]=state
base.menu_manager.menus["mp-game"].start_game_check()
if msgID == SERVER_LOADED:
base.menu_manager.menus["mp-load"].load()
if msgID == ALL_LOADED:
base.menu_manager.menus["mp-load"].load_complete()
if msgID == GAME_START:
base.menu_manager.menu_goto("mp-load")
if msgID == MAP_SET:
map = data_iter.getInt32()
base.menu_manager.menus["mp-game"].map_selected = map
mapname = base.menu_manager.menus["mp-game"].maplist[map]["fullname"]
mapimage = base.menu_manager.menus["mp-game"].maplist[map]["preview"]
base.menu_manager.menus["mp-game"].obj_list[11]["text"]=mapname
base.menu_manager.menus["mp-game"].obj_list[10].setImage(mapimage)
if msgID == BATTLE_TURN:
bat = data_iter.getInt32()
turn = data_iter.getInt32()
base.battles[bat].turn_change(turn)
if msgID == BATTLE_START:
a1 = data_iter.getInt32()
a1_x = data_iter.getFloat32()
a1_y = data_iter.getFloat32()
a2 = data_iter.getInt32()
a2_x = data_iter.getFloat32()
a2_y = data_iter.getFloat32()
army_start = data_iter.getInt32()
base.armies[a1].stop()
base.armies[a2].stop()
base.armies[a1].node_path.setPos(a1_x,a1_y,0)
base.armies[a2].node_path.setPos(a2_x,a2_y,0)
base.battles.append(TimObjects.Battle([base.armies[a1],base.armies[a2]],army_start))
if msgID == BATTLE_CLASH:
battle = data_iter.getInt32()
a1 = data_iter.getInt32()
a2 = data_iter.getInt32()
result = data_iter.getString()
buff = data_iter.getInt8()
base.battles[battle].clash(base.armies[a1],base.armies[a2],result,buff)
if msgID == BATTLE_ARMYADD:
bat = data_iter.getInt32()
army = data_iter.getInt32()
a_x = data_iter.getFloat32()
a_y = data_iter.getFloat32()
base.battles[bat].add_army(base.armies[army])
base.armies[army].node_path.setPos(a_x,a_y,0)
if msgID == BATTLE_END:
bat = data_iter.getInt32()
base.battles[bat].end()
if msgID == BUILD_START:
t_id = data_iter.getInt32()
player = data_iter.getInt8()
type = data_iter.getString()
base.towers[t_id].build_start()
if msgID == TOWER_CAPTURE:
t_id = data_iter.getInt32()
player = data_iter.getInt8()
base.towers[t_id].change_owner(player)
if msgID == BUILD_CANCEL:
t_id = data_iter.getInt32()
base.towers[t_id].build_cancel()
if msgID == BUILD_COMPLETE:
t_id = data_iter.getInt32()
player = data_iter.getInt8()
type = data_iter.getString()
base.towers[t_id].create_counter()
def handleDatagram(self, datagram):
connection = datagram.getConnection()
dgi = PyDatagramIterator(datagram)
message_type = dgi.getUint16()
class MyApp(ShowBase):
uname = None
def __init__(self):
ShowBase.__init__(self)
self.cManager = QueuedConnectionManager()
self.cListener = QueuedConnectionListener(self.cManager, 0)
self.cReader = QueuedConnectionReader(self.cManager, 0)
self.cWriter = ConnectionWriter(self.cManager, 0)
host = "localhost"
port = 6002
self.connection = self.cManager.openTCPClientConnection(
host, port, 10000)
self.received = 1
if self.connection:
self.cReader.addConnection(self.connection)
#taskMgr.add(self.updateRoutine, 'updateRoutine')
# LOGIN Request Starts
self.uname = raw_input('Enter username :'******'Enter password :'******'Login')
if (self.received):
print "->Client request:"
# Send a request to the server
myPyDatagram101 = PyDatagram()
prot = 101
myPyDatagram101.addUint16(prot)
myPyDatagram101.addString(self.uname)
myPyDatagram101.addString(self.password)
self.cWriter.send(myPyDatagram101, self.connection)
self.received = 0
taskMgr.add(self.receiveResponse101, 'Login')
def sendRequest101(self):
if (self.received):
print "->Client request:"
# Send a request to the server
myPyDatagram101 = PyDatagram()
prot = 101
myPyDatagram101.addUint16(prot)
myPyDatagram101.addString(self.uname)
myPyDatagram101.addString(self.password)
self.cWriter.send(myPyDatagram101, self.connection)
self.received = 0
def receiveResponse101(self, task):
while self.cReader.dataAvailable():
datagram = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram):
self.myIterator = PyDatagramIterator(datagram)
print "<-Server response:"
print self.myIterator.getUint16()
self.msg = self.myIterator.getUint32()
self.l = self.myIterator.getUint32()
if self.msg is not None:
if self.l is not 0:
for x in range(0, self.l):
print self.myIterator.getString()
print self.myIterator.getUint32()
print self.myIterator.getUint32()
print self.msg, " received"
#raw_input("Press Enter to continue...")
self.received = 0
taskMgr.remove('Login')
#1-Character creatopm
#taskMgr.add(self.sendRequest104, 'CharacterCreation')
#2-heartbeat of playgame after login
MyApp.sendRequest113(self)
return task.again
# LOGIN Request End
# CHARACTER CREATION Starts
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 receiveResponse104(self, task):
while self.cReader.dataAvailable():
datagram = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram):
self.myIterator1 = PyDatagramIterator(datagram)
print '------'
print self.myIterator1.getUint16()
self.msg = self.myIterator1.getUint32()
if self.msg is not None:
print "<-Server response:"
print self.msg, " received"
raw_input("Press Enter to continue...")
self.received = 0
taskMgr.remove('CharacterCreation')
taskMgr.add(self.sendRequest106, 'move')
return task.again
#CHARACTER CREATION Ends
# Move Starts
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 receiveResponse106(self, task):
while self.cReader.dataAvailable():
datagram6 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram6):
myIterator = PyDatagramIterator(datagram6)
print myIterator.getUint16()
msg = myIterator.getString()
if msg is not None:
print "<-Server response:"
print msg
print myIterator.getUint32()
print myIterator.getUint32()
print myIterator.getUint32()
print myIterator.getUint32()
print myIterator.getUint32()
raw_input("Press Enter to continue...")
self.received = 1
# Attack
#raw_input("Press Enter to continue...")
taskMgr.add(self.sendRequest108, 'health')
return task.again
#Move Ends
#Change Health Starts
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 receiveResponse108(self, task):
while self.cReader.dataAvailable():
datagram8 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram8):
myIterator = PyDatagramIterator(datagram8)
print myIterator.getUint16()
msg = myIterator.getString()
if msg is not None:
print "<-Server response:"
print msg
print myIterator.getUint32()
self.received = 1
# CP State
raw_input("Press Enter to continue...")
taskMgr.add(self.sendRequest107, 'attack')
#Change Health Ends
return task.again
# Attack Starts
def sendRequest107(self, task):
if (self.received):
print "->Client request:"
# Send a request to the server
myPyDatagram107 = PyDatagram()
prot = 107
attackId = raw_input('Attack Id (0 or 1):')
myPyDatagram107.addUint16(prot)
myPyDatagram107.addUint32(attackId)
self.cWriter.send(myPyDatagram107, self.connection)
#print " sent"
self.received = 0
taskMgr.add(self.receiveResponse108, "attackresponse")
def receiveResponse107(self, task):
while self.cReader.dataAvailable():
datagram7 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram7):
myIterator = PyDatagramIterator(datagram7)
print myIterator.getUint16()
msg = myIterator.getString()
if msg is not None:
print "<-Server response:"
print msg
print myIterator.getUint32()
raw_input("Press Enter to continue...")
self.received = 1
# Change Health
taskMgr.add(self.sendRequest112, 'CP Capture')
return task.again
#Attack Ends
#CP Capture Starts
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 receiveResponse112(self, task):
while self.cReader.dataAvailable():
datagram12 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram12):
myIterator = PyDatagramIterator(datagram12)
print myIterator.getUint16()
msg = myIterator.getUint32()
if msg is not None:
print "<-Server response:"
print msg
print myIterator.getUint32()
raw_input("Press Enter to continue...")
self.received = 1
#HeartBeat
#raw_input("Press Enter to continue...")
#taskMgr.add(self.communicate105, 'chat')
#CP Capture Ends
# CHAT Starts
def communicate105(self, task):
#print "communicate"
self.sendRequest105()
self.receiveResponse105(task)
return task.again
def sendRequest105(self):
if (self.received):
print "->Client request:"
# Send a request to the server
myPyDatagram105 = PyDatagram()
prot = 105
chat = raw_input('Insert Chat Message :')
myPyDatagram105.addUint16(prot)
myPyDatagram105.addString(chat)
self.cWriter.send(myPyDatagram105, self.connection)
print " sent"
self.received = 0
def receiveResponse105(self, task):
print "<-Server response:"
while self.cReader.dataAvailable():
datagram5 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram5):
myIterator = PyDatagramIterator(datagram5)
print myIterator.getUint16()
msg = myIterator.getUint16()
print msg, " received"
if msg is not None:
raw_input("Press Enter to continue...")
self.received = 1
# Move
raw_input("Press Enter to continue...")
taskMgr.add(self.communicate111, 'CP state')
#CHAT Ends
#CP State Starts
def communicate111(self, task):
#print "communicate"
self.sendRequest111()
self.receiveResponse111(task)
return task.again
def sendRequest111(self):
if (self.received):
print "->Client request:"
# Send a request to the server
myPyDatagram111 = PyDatagram()
prot = 111
CP_id = raw_input('Control Point ID (1 to 5): ')
CP_state = raw_input('Control Point state (1 red, 2 blue, 3 purple): ')
myPyDatagram111.addUint16(prot)
myPyDatagram111.addUint16(CP_id)
myPyDatagram111.addUint16(CP_state)
self.cWriter.send(myPyDatagram111, self.connection)
print " sent"
self.received = 0
def receiveResponse111(self, task):
print "<-Server response:"
while self.cReader.dataAvailable():
datagram11 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram11):
myIterator = PyDatagramIterator(datagram11)
print myIterator.getUint16()
msg = myIterator.getUint16()
print msg, " received"
if msg is not None:
raw_input("Press Enter to continue...")
self.received = 1
# CP Capture
raw_input("Press Enter to continue...")
taskMgr.add(self.communicate102, 'Logout')
#CP State Ends
# LOGOUT Starts
def communicate102(self, task):
#print "communicate"
self.sendRequest102()
self.receiveResponse102(task)
return task.again
def sendRequest102(self):
if (self.received):
print "->Client request:"
# Send a request to the server
myPyDatagram102 = PyDatagram()
prot = 102
myPyDatagram102.addUint16(prot)
self.cWriter.send(myPyDatagram102, self.connection)
print " sent"
self.received = 0
def receiveResponse102(self, task):
print "<-Server response:"
while self.cReader.dataAvailable():
datagram2 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram2):
myIterator = PyDatagramIterator(datagram2)
print myIterator.getUint16()
msg = myIterator.getUint16()
print msg, " received"
if msg is not None:
raw_input("Press Enter to continue...")
self.received = 1
# Register
raw_input("Press Enter to continue...")
taskMgr.add(self.communicate301, 'Heartbeat')
#LOGOUT Ends
#HeartBeat Starts
def communicate301(self):
#print "communicate"
self.sendRequest301()
self.receiveResponse301()
#return task.again;
def sendRequest301(self, task):
if (self.received):
print "->Client request:"
# Send a request to the server
myPyDatagram301 = PyDatagram()
prot = 301
myPyDatagram301.addUint16(prot)
self.cWriter.send(myPyDatagram301, self.connection)
self.received = 0
return task.again
def receiveResponse301(self):
while self.cReader.dataAvailable():
datagram301 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram301):
myIterator = PyDatagramIterator(datagram301)
p = myIterator.getUint16()
if p == 213:
un = myIterator.getString()
cname = myIterator.getString()
ctype = myIterator.getUint32()
cteam = myIterator.getUint32()
if un == MyApp.uname:
abc = 'abc'
else:
print cname + ' just joined a game......!! hurray'
#print msg, " received"
self.received = 1
#HeartBeat Ends
#heartbeat
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 retrieve113(self):
taskMgr.add(self.updateRoutine, 'update113')
taskMgr.doMethodLater(1, self.sendRequest301, 'HeatBeat')
def updateRoutine(self, task):
self.receiveResponse301()
return task.again
def myProcessDataFunction(datagram):
global status, P1NAME, P2NAME, lastResetRequest
global MY_POSITION, kicker, texKicker, texKicker2, mode
if (role==ROLE_SERVER):
sender = activeConnections.index(datagram.getConnection())
data = PyDatagramIterator(datagram)
#try:
if True: #just to keep the indent, in case we need "try" again.
pktType = data.getUint16()
if role==ROLE_SERVER: # packets received only by server
if pktType==PACKET_MOVE:
setOpponentMove(data, sender+1)
elif pktType==PACKET_MSG:
timer = data.getUint16()
msg = data.getString()
sendMessage(msg, timer) #broadcast to all
elif pktType==PACKET_HELLO:
magic = data.getString()
proto = data.getUint16()
soft = data.getString()
if magic != MAGIC_WORD:
print "Connecting party did not identify as netkickern client."
sys.exit(1)
if proto != PROTOCOL_VERSION:
print "Connecting party used incompatible protocol version "+str(proto)+"."
print "We are using "+str(PROTOCOL_VERSION)+"."
sys.exit(1)
if soft != SOFTWARE_VERSION:
print "WARNING: Client is using software "+soft+"."
print "Ok, client "+str(sender+1)+" connected."
status = STATUS_INIT
qpref = PyDatagram() #query for client preferences
qpref.addUint16(PACKET_QPREF)
qpref.addString(SOFTWARE_VERSION)
cWriter.send(qpref, activeConnections[sender])
elif pktType==PACKET_PREF:
if status != STATUS_INIT:
return
prefs = {}
teamname = data.getString()
prefs['team']=teamname
place = -1
if (mode == MODE_4P):
#assign the last free position, and P1 only if the teamname matches or everything else is given away
if not POSITION[3]:
place = 3
if not POSITION[2]:
place = 2
if (teamname == TEAMNAME) or (place==-1):
if not POSITION[1]:
place = 1
print "placed player ", sender+1, " at position ", place
POSITION[place]=sender+1
prefs['pos'] = place
playerPrefs[sender]=prefs
if (mode == MODE_2P) or (0 in playerPrefs and 1 in playerPrefs and 2 in playerPrefs):
P1NAME = TEAMNAME
P2NAME = playerPrefs[0]['team']
rename = PyDatagram()
rename.addUint16(PACKET_NAME)
rename.addString(P1NAME)
rename.addString(P2NAME)
toAll(rename, activeConnections)
if (mode == MODE_4P): #inform players of the position they play in
for i in range(0,3):
placing = PyDatagram()
placing.addUint16(PACKET_PLACE)
placing.addUint16(playerPrefs[i]['pos'])
cWriter.send(placing, activeConnections[i])
resetNames()
welcome = PyDatagram()
welcome.addUint16(PACKET_START)
toAll(welcome, activeConnections)
startGame()
elif pktType==PACKET_PONG:
stime = data.getFloat64()
now = time.time()
deltatime = now-stime # TODO: use this to delay mouse movements by avg(deltatime)/2
print "player "+str(sender)+" network delay: "+str(deltatime*500)+"ms " #rtt/2
elif pktType==PACKET_RESET:
lastResetRequest = time.time()
playerPrefs[sender]['lastReset']=lastResetRequest
if not isResetConfirmed():
resetRequest=PyDatagram() #forward to all clients
resetRequest.addUint16(PACKET_RESET)
#resetRequest.addUint16(sender) # TODO: tell everyone which player sent the request
toAll(resetRequest, activeConnections)
setMessage("Player "+str(sender+1)+" wishes to reset the ball.\nPress Space to confirm.", 3)
else: # packets received only by clients
if pktType==PACKET_SET:
setGameStatus(data)
elif pktType==PACKET_SCORE:
setScore(data)
elif pktType==PACKET_QPREF:
soft = data.getString()
if soft != SOFTWARE_VERSION:
print "WARNING: Server is using software "+soft+"."
status = STATUS_INIT
pref = PyDatagram()
pref.addUint16(PACKET_PREF)
pref.addString(TEAMNAME)
cWriter.send(pref, serverConnection)
elif pktType==PACKET_START:
print "connection to game host confirmed."
startGame()
elif pktType==PACKET_MSG:
timer = data.getUint16()
msg = data.getString()
setMessage(msg, timer)
elif pktType==PACKET_NAME:
P1NAME = data.getString()
P2NAME = data.getString()
resetNames()
elif pktType==PACKET_PLACE: #4P only
MY_POSITION = data.getUint16()
mode = MODE_4P
resetGameColours(kicker, texKicker, texKicker2)
elif pktType==PACKET_PING:
stime = data.getFloat64()
pong = PyDatagram()
pong.addUint16(PACKET_PONG)
pong.addFloat64(stime)
cWriter.send(pong, serverConnection)
elif pktType==PACKET_RESET:
setMessage("Another wishes to reset the ball.\nPress Space to confirm.", 3)
#except Exception, e:
# print e
# sys.exit(1) #wow, this is what I call exception handling..
return
