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 setReward(self, reward):
dg = PyDatagram(reward)
dgi = PyDatagramIterator(dg)
def _unpackList(method, numItems=4):
list = []
for i in xrange(numItems):
size = dgi.getUint8()
if not size:
list.append([])
continue
x = []
for i in xrange(size):
x.append(method())
list.append(x)
return list
self.trophiesList = _unpackList(dgi.getUint8)
self.rankingsList = _unpackList(dgi.getInt8, 1)[0]
self.holeBestList = _unpackList(dgi.getUint8)
self.courseBestList = _unpackList(dgi.getUint8)
self.cupList = _unpackList(dgi.getUint8)
self.tieBreakWinner = dgi.getUint32()
self.aimTimesList = [dgi.getUint32() / 100.0 for _ in xrange(4)]
if self.state not in ['Cleanup']:
self.demand('WaitReward')
def server_task(self, task):
if self.listener.newConnectionAvailable():
rendezvous = PointerToConnection()
netAddress = NetAddress()
newConnection = PointerToConnection()
if self.listener.getNewConnection(rendezvous, netAddress, newConnection):
print 'GOT CONNECTION FROM', netAddress
newConnection = newConnection.p()
self.connections.append(newConnection)
self.reader.addConnection(newConnection)
self.last_pid += 1
self.players[netAddress.getIpString()] = Player(pid=self.last_pid, draw=False)
while self.manager.resetConnectionAvailable():
connPointer = PointerToConnection()
self.manager.getResetConnection(connPointer)
connection = connPointer.p()
print 'LOST CONNECTION FROM', connection
# Remove the connection we just found to be "reset" or "disconnected"
self.reader.removeConnection(connection)
# Loop through the activeConnections till we find the connection we just deleted
# and remove it from our activeConnections list
for idx in range(0, len(self.connections)):
if self.connections[idx] == connection:
del self.connections[c]
break
while self.reader.dataAvailable():
datagram = NetDatagram()
if self.reader.getData(datagram):
conn = datagram.getConnection()
dataIter = PyDatagramIterator(datagram)
addr = conn.getAddress()
player = self.players[addr.getIpString()]
player.handle_move(dataIter.getString(), dataIter.getBool())
return task.cont
def process(self, data):
it = PyDatagramIterator(data)
msgid = it.getUint8()
conn = data.getConnection()
sendingPlayer = None
for p in self.server.players:
if p.connection == conn:
sendingPlayer = p
break
else:
logging.error("No sendingPlayer found")
if msgid == ServerMsgId.keepAlive:
return None
elif msgid == ServerMsgId.registration:
return self.handleRegistration(it, sendingPlayer)
elif msgid == ServerMsgId.chatMsg:
return self.handleChatMsg(it, sendingPlayer)
elif msgid == ServerMsgId.tryPlayCard:
return self.handleTryPlayCard(it, sendingPlayer)
elif msgid == ServerMsgId.tryPutInBattleground:
return self.handleTryPutInBattleground(it, sendingPlayer)
def process(self, data):
it = PyDatagramIterator(data)
vel = it.getFloat32()
z = it.getFloat32()
diff = z - self.smiley.getZ()
self.smiley.setPythonTag("velocity", vel + diff * 0.03)
return None
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, string):
dg = PyDatagram(string)
dgi = PyDatagramIterator(dg)
self.type = dgi.getFixedString(1)
if self.type == 'c':
self.name = sgi.getFixedString(2)
else:
notify.error('unknown avatar type: ', self.type)
def makeNetString(self):
dataList = self.experience
datagram = PyDatagram()
for track in range(0, len(Tracks)):
datagram.addUint16(dataList[track])
dgi = PyDatagramIterator(datagram)
return dgi.getRemainingBytes()
def makeFromNetString(self, netString):
dataList = []
dg = PyDatagram(netString)
dgi = PyDatagramIterator(dg)
for track in range(0, len(Tracks)):
dataList.append(dgi.getUint16())
return dataList
def makeNetString(self):
dataList = self.inventory
datagram = PyDatagram()
for track in range(0, len(Tracks)):
for level in range(0, len(Levels[track])):
datagram.addUint8(dataList[track][level])
dgi = PyDatagramIterator(datagram)
return dgi.getRemainingBytes()
def process(self, data):
it = PyDatagramIterator(data)
msgid = it.getUint8()
if msgid == 0:
return self.handleHello(it)
elif msgid == 1:
return self.handleQuestion(it)
elif msgid == 2:
return self.handleBye(it)
def handle_datagram(self, datagram):
connection = datagram.getConnection()
if not connection:
self.dump_invalid_connection(connection)
di = PyDatagramIterator(datagram)
if di.getUint8() == 1:
self.handle_incoming(di, connection, datagram)
elif di.getUint8() == BAD_CHANNEL_ID:
self.handle_bad_channel(di)
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):
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):
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 process(self, data):
print "Got some data"
it = PyDatagramIterator(data)
msgid = it.getUint8()
if msgid == 0:
print "Got 0 key mssg"
return self.handleHello(it)
elif msgid == 1:
return self.handleQuestion(it)
elif msgid == 2:
return self.handleBye(it)
def __makeList(self, store):
list = []
if self.__blob:
dg = PyDatagram(self.__blob)
di = PyDatagramIterator(dg)
versionNumber = di.getUint8()
while di.getRemainingSize() > 0:
item = CatalogItem.decodeCatalogItem(di, versionNumber, store)
list.append(item)
return list
def getItem(blob, store = 0):
dg = PyDatagram(blob)
di = PyDatagramIterator(dg)
try:
versionNumber = di.getUint8()
return decodeCatalogItem(di, versionNumber, store)
except Exception, e:
CatalogItem.notify.warning('Invalid catalog item: %s, %s' % (sys.exc_info()[0], e))
dg.dumpHex(Notify.out())
import CatalogInvalidItem
return CatalogInvalidItem.CatalogInvalidItem()
def makeFromNetString(self, string):
dg = PyDatagram(string)
dgi = PyDatagramIterator(dg)
self.type = dgi.getFixedString(1)
if self.type == 's':
self.name = dgi.getFixedString(3)
self.dept = dgi.getFixedString(1)
self.body = getSuitBodyType(self.name)
elif self.type == 'b':
self.dept = dgi.getFixedString(1)
else:
notify.error('unknown avatar type: ', self.type)
def update(self, task):
while self.reader.dataAvailable():
datagram = NetDatagram()
if self.reader.getData(datagram):
dataIter = PyDatagramIterator(datagram)
pid = dataIter.getInt8()
x = dataIter.getFloat32()
y = dataIter.getFloat32()
if pid not in self.players:
print 'NEW PLAYER', pid
self.players[pid] = Player(pid=pid, draw=True)
self.players[pid].move_to(x, y)
return task.cont
def createGardenFromData(self, gardenData):
dg = PyDatagram(gardenData)
gardenData = PyDatagramIterator(dg)
plotCount = gardenData.getUint8()
for _ in xrange(plotCount):
occupier = gardenData.getUint8()
if occupier not in occupier2Class:
continue
plot = occupier2Class[occupier](self.air, self, self.house.housePos)
plot.construct(gardenData)
plot.generateWithRequired(self.house.zoneId)
self.plots.append(plot)
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 load_file(self):
self.is_loading = True
file = open(self.filepath, 'rb')
data = file.read()
file.close()
dg = PyDatagram(data)
data = PyDatagramIterator(dg)
for _ in xrange(data.get_uint8()):
self.load_button(data)
self.is_loading = False
def TCPPacketListenTask(self, task):
if self.tcpReader.dataAvailable():
datagram = NetDatagram()
if self.tcpReader.getData(datagram):
data = PyDatagramIterator(datagram)
ip = datagram.getAddress().getIpString()
port = datagram.getAddress().getPort()
peerAddr = NetAddress()
peerAddr.setHost(ip, port)
packetType = data.getUint8()
if(packetType == Packet.PC_TCP_PACKET):
self.tcpPacketController.OnPacketReceived(data, peerAddr)
return task.cont
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 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 makeFromNetStringForceSize(self, netString, numTracks, numLevels):
dataList = []
dg = PyDatagram(netString)
dgi = PyDatagramIterator(dg)
for track in range(0, numTracks):
subList = []
for level in range(0, numLevels):
if dgi.getRemainingSize() > 0:
value = dgi.getUint8()
else:
value = 0
subList.append(value)
dataList.append(subList)
return dataList
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
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 makeFromNetString(self, netString):
dataList = []
dg = PyDatagram(netString)
dgi = PyDatagramIterator(dg)
for track in xrange(0, len(Tracks)):
subList = []
for level in xrange(0, len(Levels[track])):
if dgi.getRemainingSize() > 0:
value = dgi.getUint8()
else:
value = 0
subList.append(value)
dataList.append(subList)
return dataList
def loadDNAFileBase(self, dnaStorage, file):
self.dnaStorage = dnaStorage
dnaFile = open(file, 'rb')
dnaData = dnaFile.read()
dg = PyDatagram(dnaData)
dgi = PyDatagramIterator(dg)
dnaFile.close()
header = dgi.extractBytes(5)
if header != 'PDNA\n':
raise DNAError.DNAError('Invalid header: %s' % (header))
compressed = dgi.getBool()
dgi.skipBytes(1)
if compressed:
data = dgi.getRemainingBytes()
data = zlib.decompress(data)
dg = PyDatagram(data)
dgi = PyDatagramIterator(dg)
self.handleStorageData(dgi)
self.handleCompData(dgi)
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 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 == 215:
self.stopPlayer(data)
elif responseCode == 219:
self.dropPlayer(data)
else:
print "nothing found"
def fromNetString(self, netString):
self.tracks.clear()
dg = PyDatagram(netString)
dgi = PyDatagramIterator(dg)
avDoId = dgi.getUint32()
favGagId = dgi.getUint8()
self.avatar = base.cr.doId2do.get(avDoId, None)
self.avatarName = None if not self.avatar else self.avatar.getName()
self.favoriteGag = base.cr.attackMgr.getAttackName(favGagId)
while dgi.getRemainingSize() > 0:
track = GagGlobals.TrackNameById.get(dgi.getUint8())
exp = dgi.getInt16()
maxExp = dgi.getInt16()
increment = dgi.getInt16()
self.tracks[track] = Track(track, exp, maxExp, increment)
return avDoId
def check_for_message(self, taskdata):
"""
Called repeatedly to check if there's any new messages
"""
if self.cReader.dataAvailable():
dg = NetDatagram()
if self.cReader.getData(dg):
iterator = PyDatagramIterator(dg)
connection = dg.getConnection()
try:
msg_id = iterator.getUint8()
except AssertionError:
self.notify.warning("[check_for_message] No message ID")
return Task.cont
# check if real msg_id
if msg_id in self.mapping:
self.mapping[msg_id](self, iterator)
else:
self.notify.warning(
"[check_for_message] Invalid msg_id: {}".format(
msg_id))
return Task.cont
def tcpNonBlockingRead(self, qcr):
"""
Return a datagram collection and type if data is available on
the queued connection tcpReader
@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 the datagram to keep a handle on the data
return (datagram, data, opcode)
def server_task(self, task):
if self.listener.newConnectionAvailable():
rendezvous = PointerToConnection()
netAddress = NetAddress()
newConnection = PointerToConnection()
if self.listener.getNewConnection(rendezvous, netAddress,
newConnection):
print 'GOT CONNECTION FROM', netAddress
newConnection = newConnection.p()
self.connections.append(newConnection)
self.reader.addConnection(newConnection)
self.last_pid += 1
self.players[netAddress.getIpString()] = Player(
pid=self.last_pid, draw=False)
while self.manager.resetConnectionAvailable():
connPointer = PointerToConnection()
self.manager.getResetConnection(connPointer)
connection = connPointer.p()
print 'LOST CONNECTION FROM', connection
# Remove the connection we just found to be "reset" or "disconnected"
self.reader.removeConnection(connection)
# Loop through the activeConnections till we find the connection we just deleted
# and remove it from our activeConnections list
for idx in range(0, len(self.connections)):
if self.connections[idx] == connection:
del self.connections[c]
break
while self.reader.dataAvailable():
datagram = NetDatagram()
if self.reader.getData(datagram):
conn = datagram.getConnection()
dataIter = PyDatagramIterator(datagram)
addr = conn.getAddress()
player = self.players[addr.getIpString()]
player.handle_move(dataIter.getString(), dataIter.getBool())
return task.cont
def check_for_message(self, taskdata):
"""
Called repeatedly to check if any new messages from server
This gets the information from said datagram and calls whatever function necessary
@param self
@param taskdata
"""
if self.cReader.dataAvailable():
dg = NetDatagram()
if self.cReader.getData(dg):
iterator = PyDatagramIterator(dg)
try:
msg_id = iterator.getUint8()
except AssertionError:
self.notify.warning("[check_for_message] Invalid msg_id!")
return Task.cont
if msg_id in self.mapping:
self.mapping[msg_id](self, iterator)
else:
self.notify.warning(
f"[check_for_message] Unknown msg_id: {msg_id}")
return Task.cont
def constructTree(self, plotIndex, gagTrack, gagLevel):
dg = PyDatagram()
dg.addUint8(plotIndex)
dg.addUint8(GardenGlobals.getTreeTypeIndex(gagTrack, gagLevel)) # Type Index
dg.addInt8(0) # Water Level
dg.addInt8(0) # Growth Level
dg.addUint32(self.getTimestamp())
dg.addUint8(0) # Wilted State (False)
gardenData = PyDatagramIterator(dg)
plot = occupier2Class[GardenGlobals.TreePlot](self.air, self, self.house.housePos)
plot.construct(gardenData)
self.plots[plotIndex] = plot
self.updateGardenData()
def __init__(self,
connectMethod,
config,
hasOwnerView=False,
threadedNet=None,
dcStream=None):
if threadedNet is None:
threadedNet = config.GetBool('threaded-net', False)
self.dcStream = dcStream
CConnectionRepository.__init__(self, hasOwnerView, threadedNet)
self.setWantMessageBundling(config.GetBool('want-message-bundling', 1))
DoInterestManager.__init__(self)
DoCollectionManagerOR.__init__(self)
self.setPythonRepository(self)
self.uniqueId = hash(self)
self.accept(self._getLostConnectionEvent(), self.lostConnection)
self.config = config
if self.config.GetBool('verbose-repository'):
self.setVerbose(1)
userConnectMethod = self.config.GetString('connect-method', 'default')
if userConnectMethod == 'http':
connectMethod = self.CM_HTTP
elif userConnectMethod == 'net':
connectMethod = self.CM_NET
elif userConnectMethod == 'native':
connectMethod = self.CM_NATIVE
self.connectMethod = connectMethod
if self.connectMethod == self.CM_HTTP:
self.notify.info("Using connect method 'http'")
elif self.connectMethod == self.CM_NET:
self.notify.info("Using connect method 'net'")
elif self.connectMethod == self.CM_NATIVE:
self.notify.info("Using connect method 'native'")
self.connectHttp = None
self.http = None
self.private__di = PyDatagramIterator()
self.recorder = None
self.readerPollTaskObj = None
self.dcSuffix = ''
self._serverAddress = ''
if self.config.GetBool('gc-save-all', 1):
gc.set_debug(gc.DEBUG_SAVEALL)
if self.config.GetBool('want-garbage-collect-task', 1):
taskMgr.add(self._garbageCollect, self.GarbageCollectTaskName, 200)
taskMgr.doMethodLater(
self.config.GetFloat('garbage-threshold-adjust-delay', 300.0),
self._adjustGcThreshold, self.GarbageThresholdTaskName)
self._gcDefaultThreshold = gc.get_threshold()
def __init__(self, config, hasOwnerView=False):
BaseDOManager.__init__(self, hasOwnerView)
self.netSys = NetworkSystem()
self.netCallbacks = NetworkCallbacks()
self.netCallbacks.setCallback(self.__handleNetCallback)
self.connected = False
self.connectionHandle = None
self.connectSuccessCallback = None
self.connectFailureCallback = None
self.msgType = 0
self.config = config
# Accept this hook so that we can respond to lost-connection
# events in the main thread, instead of within the network
# thread (if there is one).
self.accept(self._getLostConnectionEvent(), self.lostConnection)
# This DatagramIterator is constructed once, and then re-used
# each time we read a datagram.
self.private__di = PyDatagramIterator()
self._serverAddress = ''
self.readerPollTaskObj = None
if self.config.GetBool('gc-save-all', 1):
# set gc to preserve every object involved in a cycle, even ones that
# would normally be freed automatically during garbage collect
# allows us to find and fix these cycles, reducing or eliminating the
# need to run garbage collects
# garbage collection CPU usage is O(n), n = number of Python objects
gc.set_debug(gc.DEBUG_SAVEALL)
if self.config.GetBool('want-garbage-collect-task', 1):
# manual garbage-collect task
taskMgr.add(self._garbageCollect, self.GarbageCollectTaskName, 200)
# periodically increase gc threshold if there is no garbage
taskMgr.doMethodLater(
self.config.GetFloat('garbage-threshold-adjust-delay',
5 * 60.), self._adjustGcThreshold,
self.GarbageThresholdTaskName)
self._gcDefaultThreshold = gc.get_threshold()
def handle_data(self, datagram: PyDatagram) -> None:
"""
Handling new data.
First, message is obtained, then correct message handler is called
"""
iterator = PyDatagramIterator(datagram)
# parse message
try:
message = self.message_parser(iterator, MessageType.response)
response = self.handle_message(message)
self.handle_response(response)
except KeyError as e:
log.exception(e)
log.error("Unsupported message.")
return
def constructFlower(self, plotIndex, species, variety):
dg = PyDatagram()
dg.addUint8(plotIndex)
dg.addUint8(species)
dg.addUint16(variety)
dg.addInt8(0) # Water Level
dg.addInt8(0) # Growth Level
dg.addUint32(self.getTimestamp())
dg.addUint8(0) # Wilted State (False)
gardenData = PyDatagramIterator(dg)
plot = occupier2Class[GardenGlobals.FlowerPlot](self.air, self,
self.house.housePos)
plot.construct(gardenData)
self.plots[plotIndex] = plot
self.updateGardenData()
def 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 constructStatuary(self, plotIndex, typeIndex):
dg = PyDatagram()
dg.addUint8(plotIndex)
dg.addUint8(typeIndex)
gardenData = PyDatagramIterator(dg)
occupier = GardenGlobals.StatuaryPlot
if typeIndex in GardenGlobals.ChangingStatuaryTypeIndices:
occupier = GardenGlobals.ChangingStatuaryPlot
elif typeIndex in GardenGlobals.AnimatedStatuaryTypeIndices:
occupier = GardenGlobals.AnimatedStatuaryPlot
plot = occupier2Class[occupier](self.air, self, self.house.housePos)
plot.construct(gardenData)
self.plots[plotIndex] = plot
self.updateGardenData()
def handle_data(self, datagram, connection, session):
"""
Handling new data.
First, message is obtained, then correct message handler is called
"""
iterator = PyDatagramIterator(datagram)
# parse message
try:
message = self.message_parser(iterator, MessageType.request)
except KeyError as e:
log.exception(e)
log.error("unsuppoerted message")
return
# produce response
response = self.handle_message(session, message)
# send response
self.handle_response(connection, response)
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
def update(self, task):
while self.reader.dataAvailable():
datagram = NetDatagram()
if self.reader.getData(datagram):
update = PyDatagramIterator(datagram)
num_objects = update.getInt8()
for i in range(num_objects):
name = update.getString()
x = update.getFloat32()
y = update.getFloat32()
z = update.getFloat32()
h = update.getFloat32()
p = update.getFloat32()
r = update.getFloat32()
if name.startswith(
'Walker') and name not in self.world.objects:
self.world.create_walker(name)
obj = self.world.objects.get(name)
if obj:
obj.move((x, y, z))
obj.rotate(h, p, r)
return task.cont
def setDNAString(self, dnaStr):
data = PyDatagram(dnaStr)
iter = PyDatagramIterator(data)
self.setShapeStyle(int(iter.getUint8()))
bgData = [0] * len(self.bgData)
layoutData = [0] * len(self.layoutData)
for x in range(len(bgData)):
bgData[x] = int(iter.getUint8())
self.setBackground(*bgData)
for x in range(len(layoutData)):
layoutData[x] = int(iter.getUint8())
self.setLayout(*layoutData)
self.emblems = {}
eCount = 0
while iter.getRemainingSize() >= len(self.DefaultEmblemData):
edata = self.DefaultEmblemData[:]
for x in range(0, len(edata)):
edata[x] = int(iter.getUint8())
self.setEmblem(eCount, *edata)
eCount += 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 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
class Server(QueuedConnectionManager):
"""Handles new connections and the incomming of packages"""
def __init__(self, p, b):
self.cManager = QueuedConnectionManager()
self.cListener = QueuedConnectionListener(self.cManager, 0)
self.cReader = QueuedConnectionReader(self.cManager, 0)
self.cWriter = ConnectionWriter(self.cManager, 0)
self.port = p
self.backlog = b
self.socket = self.cManager.openTCPServerRendezvous(
self.port, self.backlog)
self.cListener.addConnection(self.socket)
self.player_list = []
self.iterator = None
self.num_count = self.active_players = self.Δt_update = self.Δt = 0
def reader_polling_task(self, arg):
if self.cReader.dataAvailable():
datagram = NetDatagram()
if self.cReader.getData(datagram):
self.process_data(datagram.getConnection(), datagram)
return Task.cont
def listener_polling_task(self, arg):
if self.cListener.newConnectionAvailable():
rendezvous = PointerToConnection()
net_address = NetAddress()
new_connection = PointerToConnection()
if self.cListener.getNewConnection(rendezvous, net_address,
new_connection):
self.active_players += 1
new_connection = new_connection.p()
self.player_list.append(player(self.num_count))
find_player(self.player_list, "player_id",
self.num_count).conn_id = new_connection
logging.debug(self.active_players)
self.initialize_player()
self.num_count += 1
self.cReader.addConnection(
new_connection) # Begin reading connection
logging.info('connection received')
return Task.cont
def initialize_player(self):
conn = self.player_list[-1].conn_id
datagram = PyDatagram()
datagram.addString("init")
newest = self.player_list[-1].player_id
datagram.addUint8(newest)
logging.debug(
f"{self.active_players} players and {newest} is the newest player")
datagram.addUint8(self.active_players)
if len(self.player_list) > 1:
for k in self.player_list:
datagram.addString(k.username)
datagram.addFloat64(k.pos_and_or['x'])
datagram.addFloat64(k.pos_and_or['y'])
datagram.addFloat64(k.pos_and_or['z'])
self.cWriter.send(datagram, conn)
def update_positions(self, data): # send
self.Δt = globalClock.getDt()
self.Δt_update += self.Δt
if self.Δt_update > 0.05:
if self.active_players > 1:
datagram = PyDatagram()
datagram.addString("update")
datagram.addInt8(self.active_players)
for p in self.player_list:
datagram.addString(p.username)
datagram.addFloat64(p.pos_and_or['x'])
datagram.addFloat64(p.pos_and_or['y'])
datagram.addFloat64(p.pos_and_or['z'])
datagram.addFloat64(p.pos_and_or['h'])
datagram.addFloat64(p.pos_and_or['p'])
datagram.addFloat64(p.pos_and_or['r'])
for p in self.player_list:
self.cWriter.send(datagram, p.conn_id)
self.Δt_update = 0
return Task.cont
def update_chat(self, msg):
datagram = PyDatagram()
datagram.addString("chat")
datagram.addString(msg)
logging.info(f"{msg}") # TODO make this useful
for p in self.player_list:
self.cWriter.send(datagram, p.conn_id)
def process_data(self, connection, datagram):
self.iterator = PyDatagramIterator(datagram)
msg_type = self.iterator.getString()
if msg_type == "position":
self.process_position(connection)
elif msg_type == "chat":
self.update_chat(self.iterator.getString())
elif msg_type == "introduce":
username = self.iterator.getString()
logging.info(f"User {username} introduced himself")
cls = find_player(self.player_list, "conn_id", connection)
cls.username = username
elif msg_type == "quit":
self.process_quit()
def process_position(self, connection):
it = self.iterator
pos_and_or = find_player(self.player_list, "conn_id",
connection).pos_and_or
pos_and_or['x'] = it.getFloat64()
pos_and_or['y'] = it.getFloat64()
pos_and_or['z'] = it.getFloat64()
pos_and_or['h'] = it.getFloat64()
pos_and_or['p'] = it.getFloat64()
pos_and_or['r'] = it.getFloat64()
def process_quit(self):
logging.debug("Player has quit")
self.active_players -= 1
player_num = self.iterator.getInt8()
player_cls = find_player(self.player_list, "player_id", player_num)
player_id = self.player_list.index(player_cls)
player_name = player_cls.username
del self.player_list[player_id]
datagram = PyDatagram()
datagram.addString("remove")
datagram.addString(player_name)
for p in self.player_list:
self.cWriter.send(datagram, p.conn_id)
logging.info(f"Player {player_name} has left the game")
def handle_client_message(self, message: str) -> str:
iterator = PyDatagramIterator(message)
return iterator.getString()
def __gotOwnerAv(self, db, retcode):
assert (self.notify.debug("__gotOwnerAv(%s, %s): %s" %
(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 processData(self, netDatagram):
myIterator = PyDatagramIterator(netDatagram)
return self.decode(myIterator.getString())
class PlayerReg(DirectObject):
def __init__(self):
self.PlayerList = []
self.active = 0
self.timeSinceLastUpdate = 0
def updatePlayers(self, serverClass, data, type):
if (type == "positions"):
self.elapsed = globalClock.getDt()
self.timeSinceLastUpdate += self.elapsed
if (self.timeSinceLastUpdate > 0.1):
if (self.active):
self.datagram = PyDatagram()
self.datagram.addString("update")
self.datagram.addFloat64(self.active)
for k in range(self.active):
self.datagram.addFloat64(
self.PlayerList[k].currentPos['x'])
self.datagram.addFloat64(
self.PlayerList[k].currentPos['y'])
self.datagram.addFloat64(
self.PlayerList[k].currentPos['z'])
self.datagram.addFloat64(
self.PlayerList[k].currentPos['h'])
self.datagram.addFloat64(
self.PlayerList[k].currentPos['p'])
self.datagram.addFloat64(
self.PlayerList[k].currentPos['r'])
for k in self.PlayerList:
self.conn = k.connectionID
serverClass.cWriter.send(self.datagram, self.conn)
self.timeSinceLastUpdate = 0
return Task.cont
if (type == "chat"):
self.iterator = data
self.datagram = PyDatagram()
self.datagram.addString("chat")
self.text = self.iterator.getString()
self.datagram.addString(self.text)
for k in self.PlayerList:
serverClass.cWriter.send(self.datagram, k.connectionID)
def updateData(self, connection, datagram, serverClass):
self.iterator = PyDatagramIterator(datagram)
self.type = self.iterator.getString()
if (self.type == "positions"):
for k in self.PlayerList:
if (k.connectionID == connection):
k.currentPos['x'] = self.iterator.getFloat64()
k.currentPos['y'] = self.iterator.getFloat64()
k.currentPos['z'] = self.iterator.getFloat64()
k.currentPos['h'] = self.iterator.getFloat64()
k.currentPos['p'] = self.iterator.getFloat64()
k.currentPos['r'] = self.iterator.getFloat64()
if (self.type == "chat"):
self.updatePlayers(serverClass, self.iterator, "chat")
def sendInitialInfo(self, i, server):
self.con = self.PlayerList[i].connectionID
self.datagram = PyDatagram()
self.datagram.addString("init")
self.datagram.addUint8(self.active)
self.datagram.addFloat64(i)
for k in self.PlayerList:
self.datagram.addString(k.username)
self.datagram.addFloat64(k.currentPos['x'])
self.datagram.addFloat64(k.currentPos['y'])
self.datagram.addFloat64(k.currentPos['z'])
server.cWriter.send(self.datagram, self.con)
def readHeader(self, datagram):
dgi = PyDatagramIterator(datagram)
number = dgi.getUint32()
dtype = dgi.getUint8()
self.notify.debug("Packet %d type %d received" % (number, dtype))
return (dgi, dtype)
def processPacket(self, packet, backend, sender=None):
iterator = PyDatagramIterator(packet)
lastId = "None"
lastController = "None"
try:
rebroadcast = True
while iterator.getRemainingSize() > 0:
type = net.Uint8.getFrom(iterator)
if type == constants.PACKET_CONTROLLER:
rebroadcast = True
id = net.Uint8.getFrom(iterator)
entity = backend.entityGroup.getEntity(id)
if entity is not None:
lastId = str(id)
lastController = entity.controller
entity.controller.clientUpdate(backend.aiWorld,
backend.entityGroup,
iterator)
else:
engine.log.warning(
"Received controller packet with no matching entity. ID: "
+ str(id) + " Last entity updated: " + lastId +
" - controller: " + str(lastController))
# Only send a request once every two seconds
if sender is not None and (
(id not in list(self.requestedEntitySpawns.keys()))
or (engine.clock.time -
self.requestedEntitySpawns[id] > 2.0)):
p = net.Packet()
p.add(
net.Uint8(constants.PACKET_REQUESTSPAWNPACKET))
p.add(net.Uint8(id))
net.context.send(p, sender)
self.requestedEntitySpawns[id] = engine.clock.time
engine.log.info(
"Sending request for missing entity spawn packet. Entity ID: "
+ str(id))
return rebroadcast
elif type == constants.PACKET_SPAWN:
controllerType = net.Uint8.getFrom(iterator)
entity = controllers.types[controllerType].readSpawnPacket(
backend.aiWorld, backend.entityGroup, iterator)
if entity.getId() in list(
self.requestedEntitySpawns.keys()):
del self.requestedEntitySpawns[entity.getId()]
if entity is not None and backend.entityGroup.getEntity(
entity.getId()) is None:
backend.entityGroup.addEntity(entity)
elif entity is not None:
engine.log.warning(
"Spawned entity " + str(entity.getId()) +
" already exists. Cancelling spawn.")
entity.delete(backend.entityGroup,
killed=False,
localDelete=False)
rebroadcast = True
elif type == constants.PACKET_DELETE:
id = net.Uint8.getFrom(iterator)
entity = backend.entityGroup.getEntity(id)
killed = net.Boolean.getFrom(iterator)
if entity is not None:
if killed: # The boolean indicates that the entity was not only deleted, it was killed. Also, let the entity know this was a remote delete packet.
entity.kill(backend.aiWorld, backend.entityGroup,
False)
else:
entity.delete(backend.entityGroup, False, False)
rebroadcast = True
elif type == constants.PACKET_REQUESTSPAWNPACKET:
self.clientSpawnPacketRequests.append(
(net.Uint8.getFrom(iterator), sender))
rebroadcast = False
elif type == constants.PACKET_SETUP:
if net.netMode == net.MODE_CLIENT:
messenger.send("client-setup", [iterator])
else:
return False
rebroadcast = False
elif type == constants.PACKET_CHAT:
# Username and message
messenger.send("chat-incoming", [
net.String.getFrom(iterator),
net.String.getFrom(iterator)
])
rebroadcast = True
elif type == constants.PACKET_ENDMATCH:
engine.log.info("Received match end packet.")
messenger.send("end-match", [iterator])
rebroadcast = True
elif type == constants.PACKET_NEWCLIENT:
# Sender address and username
messenger.send(
"server-new-connection",
[sender, net.String.getFrom(iterator)])
rebroadcast = False
elif type == constants.PACKET_DISCONNECT:
engine.log.info(
net.addressToString(sender) + " disconnected.")
messenger.send("disconnect", [sender])
rebroadcast = False
elif type == constants.PACKET_SERVERFULL:
messenger.send("server-full")
elif type == constants.PACKET_CONFIRMREGISTER:
messenger.send("lobby-confirm-register")
rebroadcast = False
elif type == constants.PACKET_EMPTY:
rebroadcast = False
elif type == constants.PACKET_CLIENTREADY:
rebroadcast = False
messenger.send("client-ready", [sender])
elif type == constants.PACKET_NEWCLIENTNOTIFICATION:
address = net.String.getFrom(iterator)
port = net.Uint16.getFrom(iterator)
# Make sure we get all the data out of the packet to ensure proper processing.
# This packet has already been handled by the NetContext.
rebroadcast = False
elif type == constants.PACKET_ENTITYCHECKSUM:
# Number of active entities we're supposed to have
checksum = net.Uint8.getFrom(iterator)
if net.netMode == net.MODE_CLIENT and checksum != len([
x
for x in list(backend.entityGroup.entities.values(
)) if x.active and x.getId() < 256
]):
# We don't have the right number of entities
p = net.Packet()
p.add(net.Uint8(constants.PACKET_REQUESTENTITYLIST))
net.context.send(p, sender)
engine.log.info(
"Entity checksum failed. Requesting full entity list."
)
rebroadcast = False
elif type == constants.PACKET_REQUESTENTITYLIST:
p = net.Packet()
p.add(net.Uint8(constants.PACKET_ENTITYLIST))
entityList = [
x for x in list(backend.entityGroup.entities.values())
if x.active and x.getId() < 256
]
p.add(net.Uint8(len(entityList)))
for entity in entityList:
p.add(net.Uint8(entity.getId()))
net.context.send(p, sender)
engine.log.info("Sending entity list to " +
net.addressToString(sender))
rebroadcast = False
elif type == constants.PACKET_ENTITYLIST:
total = net.Uint8.getFrom(iterator)
entities = []
missingEntities = []
for _ in range(total):
id = net.Uint8.getFrom(iterator)
if id not in list(backend.entityGroup.entities.keys()):
missingEntities.append(id)
entities.append(id)
# Delete any extra entities, assuming they aren't ones that
# we just spawned on our end.
for entity in (x for x in list(
backend.entityGroup.entities.values())
if x.active and x.getId() < 256):
if entity.getId(
) not in entities and engine.clock.time - entity.spawnTime > 5.0:
entity.delete(backend.entityGroup, False, False)
if len(missingEntities) > 0:
# Request spawn packets for any missing entities
p = net.Packet()
for id in missingEntities:
p.add(
net.Uint8(constants.PACKET_REQUESTSPAWNPACKET))
p.add(net.Uint8(id))
self.requestedEntitySpawns[id] = engine.clock.time
engine.log.info(
"Sending request for missing entity spawn packet. Entity ID: "
+ str(id))
net.context.send(p, sender)
rebroadcast = False
else:
rebroadcast = False
except AssertionError:
engine.log.warning("Packet iteration failed. Discarding packet.")
rebroadcast = False
return rebroadcast
def __gotHouse(self, db, retcode):
assert (self.notify.debug(
"__gotHouse(%s, %s): %s" %
(list(db.values.keys()), retcode, self.doId)))
if retcode != 0:
self.notify.warning("House %s for avatar %s does not exist!" %
(self.av.houseId, self.av.doId))
self.sendCatalog(0)
return
atticItems = []
atticWallpaper = []
atticWindows = []
interiorItems = []
dg = db.values.get('setAtticItems')
if dg:
di = PyDatagramIterator(dg)
blob = di.getString()
atticItems = CatalogItemList.CatalogItemList(
blob, store=CatalogItem.Customization)
dg = db.values.get('setAtticWallpaper')
if dg:
di = PyDatagramIterator(dg)
blob = di.getString()
atticWallpaper = CatalogItemList.CatalogItemList(
blob, store=CatalogItem.Customization)
dg = db.values.get('setAtticWindows')
if dg:
di = PyDatagramIterator(dg)
blob = di.getString()
atticWindows = CatalogItemList.CatalogItemList(
blob, store=CatalogItem.Customization)
dg = db.values.get('setInteriorItems')
if dg:
di = PyDatagramIterator(dg)
blob = di.getString()
interiorItems = CatalogItemList.CatalogItemList(
blob, store=CatalogItem.Location | CatalogItem.Customization)
# Finally we're ready to tell the user what he needs to know.
numAtticItems = len(atticItems) + len(atticWallpaper) + len(
atticWindows)
numHouseItems = numAtticItems + len(interiorItems)
self.sendCatalog(numHouseItems)
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
