def myProcessDataFunction(self, netDatagram):
# check a message and do what it says
myIterator = PyDatagramIterator(netDatagram)
msgID = myIterator.getUint8()
if msgID == PRINT_MESSAGE: # This is a debugging message
messageToPrint = myIterator.getString()
print messageToPrint
elif msgID == CAR_MESSAGE: # This updates a car
carNum = myIterator.getUint8()
for num in self.ignore: # if the car message is out of date, ignore it
if num == carNum:
break
else: # else update the car
carXpos = myIterator.getFloat32()
carYpos = myIterator.getFloat32()
carXvel = myIterator.getFloat32()
carYvel = myIterator.getFloat32()
carHeading = myIterator.getFloat32()
carInput = []
for i in range(5):
carInput.append(myIterator.getBool())
carLights = myIterator.getBool()
carHp = myIterator.getInt32()
self.updatePositions(carNum, (carXpos, carYpos, carXvel, carYvel, carHeading, carInput, carLights, carHp))
elif msgID == NEW_PLAYER_MESSAGE: # This creates a new player
if len(self.carData.carlist) >= self.players:
self.cWriter.send(self.startDatagram(), netDatagram.getConnection())
self.cWriter.send(self.mapDatagram(), netDatagram.getConnection())
self.cWriter.send(self.addNewCar(), netDatagram.getConnection())
self.returnAllCars(netDatagram.getConnection())
elif msgID == COLLIDED_MESSAGE: # This verifies that a car has recieved its collision message and is now up to date
carNum = myIterator.getUint8()
self.ignore.remove(carNum)
elif msgID == END_MESSAGE: # This recieves a player score
self.playerscores.append((myIterator.getString(), myIterator.getInt32()))
def _processData(self, netDatagram):
# convert incoming Datagram to dict
myIterator = PyDatagramIterator(netDatagram)
msg = {}
msg[SEQN] = myIterator.getInt32()
msg[AKN] = myIterator.getInt32()
msg[MSG_TYPE] = myIterator.getInt16()
msg[OOL] = myIterator.getInt8()
msg[OAKN] = self.decode(myIterator.getString())
if not msg[MSG_TYPE] == MULT:
msg[DATA] = self.decode(myIterator.getString())
else:
msg[DATA] = (myIterator.getString())
# msg.append(self.decode(myIterator.getString()))
return msg
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 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 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 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 __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)
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:
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 __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 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 process(self, data):
it = PyDatagramIterator(data)
msgid = it.getUint8()
if msgid == 0:
pass
elif msgid == 1:
command = it.getString()
self.printMessage("new command:", command)
messenger.send(command)
return self.buildReply(0, "ok")
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 _interpretDatagram (self, datagram):
"""
Interprets a received datagram and performs actions based on its
values.
"""
msg = PyDatagramIterator(datagram)
msgType = msg.getUint8()
if msgType == DEBUG_MESSAGE:
print (msg.getString())
elif msgType == UPDATE_PLAYER_INFO:
data = msg.getString()
self._updatePlayerInfoHandler(datagram.getConnection().this, data)
elif msgType == SPAWN_CHARACTER:
data = msg.getString()
dataDict = json.loads(data)
self._onSpawnHandler(dataDict)
elif msgType == SYNC_ACTION:
data = msg.getString()
dataDict = json.loads(data)
self._onActionSyncHandler(dataDict, datagram.getConnection())
elif msgType == SYNC_RESPAWN:
data = msg.getString()
dataDict = json.loads(data)
self._onRespawnRequestReceived(dataDict)
elif msgType == WIN_STATE:
data = msg.getString()
self._onGameWon(data)
def _interpretDatagram(self, datagram):
"""
Interprets a received datagram and performs actions based on
its values.
"""
msg = PyDatagramIterator(datagram)
msgType = msg.getUint8()
if msgType == DEBUG_MESSAGE:
print(msg.getString())
elif msgType == MAP_MESSAGE:
print("[Client Received Map Data]")
if self._gameManager.getTileMap() == None:
data = msg.getString32()
self._gameManager.onClientFirstReceivedMap(data)
elif msgType == UPDATE_PLAYER_INFO:
data = msg.getString()
self._updatePlayerInfoHandler(data)
elif msgType == SPAWN_CHARACTER:
data = msg.getString()
dataDict = json.loads(data)
self._onSpawnHandler(dataDict)
elif msgType == SYNC_ACTION:
data = msg.getString()
dataDict = json.loads(data)
self._onActionSyncHandler(dataDict)
elif msgType == SYNC_HEALTH:
data = msg.getString()
dataDict = json.loads(data)
self._onHealthSyncHandler(dataDict)
elif msgType == SYNC_DEATH:
data = msg.getString()
dataDict = json.loads(data)
self._onDeathSyncHandler(dataDict)
elif msgType == SYNC_RESPAWN:
data = msg.getString()
dataDict = json.loads(data)
self._onRespawnPermissionGranted(dataDict)
elif msgType == SPAWN_ITEM:
data = msg.getString()
dataDict = json.loads(data)
self._onItemSpawned(dataDict)
elif msgType == WIN_STATE:
data = msg.getString()
self._onGameWon(data)
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 process(self, data):
#print "Got some data"
it = PyDatagramIterator(data)
msgid = it.getUint8()
if msgid == 1:
direction['1']=it.getString()
#self.printMessage("Server received:", direction['1'])
if msgid == 23:
print "server got shout out"
update = PyDatagram()
update.addUint8(23)
self.Application.server.broadcast(update)
#standard update
if msgid == 13:
tempID = it.getInt8()
#print "updating position for player ", tempID
self.Application.players[tempID].setX(it.getFloat32())
self.Application.players[tempID].setY(it.getFloat32())
self.Application.players[tempID].setZ(it.getFloat32())
self.Application.players[tempID].setH(it.getFloat32())
self.Application.players[tempID].setP(it.getFloat32())
self.Application.players[tempID].setR(it.getFloat32())
self.Application.players[tempID].setPythonTag("velocity",it.getFloat32())
#self.printMessage("Server received:", direction[2])
elif msgid == 38:
if self.Application.server.isStarted is True:
print "Game over"
data = PyDatagram()
data.addInt8(38)
self.Application.server.broadcast(data)
'''if msgid == 3:
direction['3']=it.getString()
3 self.printMessage("Server received:", direction['3'])
if msgid == 4:
direction['4']=it.getString()
self.printMessage("Server received:", direction['4'])
if msgid == 5:
direction['5']=it.getString()
self.printMessage("Server received:", direction['5'])
'''
return None
def readMsg():
"""Return the message, if any, or None if there was nothing to read"""
if not ClientMsg.myConnection:
return None
if ClientMsg.cReader.dataAvailable():
datagram = NetDatagram()
if ClientMsg.cReader.getData(datagram):
dgi = PyDatagramIterator(datagram)
msg = pickle.loads(dgi.getString())
ClientMsg.notify.info("Client received a message:%s", msg)
return msg
return None
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()
newConnection.setNoDelay(True)
self.connections.append(newConnection)
self.reader.addConnection(newConnection)
self.last_pid += 1
self.players[netAddress.getIpString()] = Player(
self.last_pid, self.world.create_walker())
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[idx]
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_command(dataIter.getString(), dataIter.getBool())
update = PyDatagram()
update.addInt8(len([o for o in self.world.updatables if o.moved]))
for obj in self.world.updatables:
obj.add_update(update)
for conn in self.connections:
self.writer.send(update, conn)
return task.again
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()
newConnection.setNoDelay(True)
self.connections.append(newConnection)
self.reader.addConnection(newConnection)
self.last_pid += 1
self.players[netAddress.getIpString()] = Player(self.last_pid, self.world.create_walker())
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[idx]
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_command(dataIter.getString(), dataIter.getBool())
update = PyDatagram()
update.addInt8(len([o for o in self.world.updatables if o.moved]))
for obj in self.world.updatables:
obj.add_update(update)
for conn in self.connections:
self.writer.send(update, conn)
return task.again
def myProcessDataFunction(self, netDatagram):
myIterator = PyDatagramIterator(netDatagram)
msgID = myIterator.getUint8()
if msgID == PRINT_MESSAGE:
messageToPrint = myIterator.getString()
print messageToPrint
elif msgID == CAR_MESSAGE:
carNum = myIterator.getUint8()
carXpos = myIterator.getFloat32()
carYpos = myIterator.getFloat32()
carXvel = myIterator.getFloat32()
carYvel = myIterator.getFloat32()
carHeading = myIterator.getFloat32()
carInput = []
for i in range(5):
carInput.append(myIterator.getBool())
carHp = myIterator.getInt32()
self.updatePositions(carNum, (carXpos, carYpos, carXvel, carYvel, carHeading, carInput, carHp))
elif msgID == NEW_PLAYER_MESSAGE:
self.cWriter.send(self.addNewCar(), netDatagram.getConnection())
self.returnAllCars(netDatagram.getConnection())
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 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 myProcessDataFunction(self, netDatagram):
myIterator = PyDatagramIterator(netDatagram)
msgID = myIterator.getUint8()
messageToPrint = myIterator.getString().split(',')
#print( messageToPrint)
if msgID == 1: #start
Starttime = float((messageToPrint)[0])
start = float((messageToPrint)[1])
self.RunModel(start, Starttime)
if msgID == 2: #pause
Stoptime = float((messageToPrint)[0])
self.StopModel(Stoptime)
if msgID == 3:
sys.exit()
if msgID == 4:
self.MosaicOverlap = float((messageToPrint)[1])
self.ActivateMosaics()
if msgID == 5:
pos = float(messageToPrint[0])
Pixelx = float(messageToPrint[1])
Pixely = float(messageToPrint[2])
self.get2DPoint(pos, Pixelx, Pixely)
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
class PlayerReg(DirectObject): #This class will regulate the players
def __init__(self):
self.playerList = []
self.numofplayers = 0
def ProcessData(self, datagram, m, chatClass):
#process received data
self.iterator = PyDatagramIterator(datagram)
self.type = self.iterator.getString()
if (self.type == "init"):
print "initializing"
#initialize
m.setPlayerNum(self.iterator.getUint8())
self.num = self.iterator.getFloat64()
for i in range(int(self.num)):
if (i != m.playernum):
self.playerList.append(Player())
self.playerList[i].username = self.iterator.getString()
self.playerList[i].load()
self.playerList[i].currentPos[
'x'] = self.iterator.getFloat64()
self.playerList[i].currentPos[
'y'] = self.iterator.getFloat64()
self.playerList[i].currentPos[
'z'] = self.iterator.getFloat64()
print "player ", str(i), " initialized"
else:
self.playerList.append(Player())
self.numofplayers = self.num
if (self.type == "update"):
self.num = self.iterator.getFloat64()
if (self.num > self.numofplayers):
for i in range(int(self.numofplayers)):
self.playerList[i].currentPos[
'x'] = self.iterator.getFloat64()
self.playerList[i].currentPos[
'y'] = self.iterator.getFloat64()
self.playerList[i].currentPos[
'z'] = self.iterator.getFloat64()
self.playerList[i].currentPos[
'h'] = self.iterator.getFloat64()
self.playerList[i].currentPos[
'p'] = self.iterator.getFloat64()
self.playerList[i].currentPos[
'r'] = self.iterator.getFloat64()
for i in range(int(self.numofplayers), int(self.num)):
if (i != m.playernum):
self.playerList.append(Player())
self.playerList[i].load()
self.playerList[i].currentPos[
'x'] = self.iterator.getFloat64()
self.playerList[i].currentPos[
'y'] = self.iterator.getFloat64()
self.playerList[i].currentPos[
'z'] = self.iterator.getFloat64()
self.playerList[i].currentPos[
'h'] = self.iterator.getFloat64()
self.playerList[i].currentPos[
'p'] = self.iterator.getFloat64()
self.playerList[i].currentPos[
'r'] = self.iterator.getFloat64()
else:
self.playerList.append(Player())
self.numofplayers = self.num
else:
for i in range(int(self.numofplayers)):
self.playerList[i].currentPos[
'x'] = self.iterator.getFloat64()
self.playerList[i].currentPos[
'y'] = self.iterator.getFloat64()
self.playerList[i].currentPos[
'z'] = self.iterator.getFloat64()
self.playerList[i].currentPos[
'h'] = self.iterator.getFloat64()
self.playerList[i].currentPos[
'p'] = self.iterator.getFloat64()
self.playerList[i].currentPos[
'r'] = self.iterator.getFloat64()
if (self.type == "chat"):
self.text = self.iterator.getString()
chatClass.setText(self.text)
def updatePlayers(self, m):
if (self.numofplayers != 0):
for k in range(int(self.numofplayers)):
#As long as the player is not the client put it where the server says
if (k != m.playernum):
self.playerList[k].model.setPosHpr(
self.playerList[k].currentPos['x'],
self.playerList[k].currentPos['y'],
self.playerList[k].currentPos['z'],
self.playerList[k].currentPos['h'],
self.playerList[k].currentPos['p'],
self.playerList[k].currentPos['r'])
return Task.cont
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 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 retrieveStringMessage(self,datagram):
myIterator = PyDatagramIterator(datagram)
msg = myIterator.getString()
print msg, " received"
def myProcessDataFunction(netDatagram): myIterator = PyDatagramIterator(netDatagram) msgID = myIterator.getUnit8() if msgID == 1: msgToPrint = myIterator.getString() print msgToPrint
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 data_process(self, datagram):
it = PyDatagramIterator(datagram)
message = it.getString()
print("Processed: "+message+" from: "+str(datagram.getAddress()))
def processServerMessage(self, netDatagram):
myIterator = PyDatagramIterator(netDatagram)
print myIterator.getString()
def handle_server_message(self, message: str) -> None:
iterator = PyDatagramIterator(message)
print(iterator.getString())
def handle_client_message(self, message: str) -> str:
iterator = PyDatagramIterator(message)
return iterator.getString()
def retrieveStringMessage(self, datagram):
myIterator = PyDatagramIterator(datagram)
msg = myIterator.getString()
print msg, " received"
def process_data(self, datagram):
# process received data
iterator = PyDatagramIterator(datagram)
self.type = iterator.getString()
if self.type == "init":
logging.info("initializing")
me.player_id = iterator.getUint8()
self.num_players = iterator.getUint8()
if self.num_players > 1:
for _ in range(self.num_players):
username = iterator.getString()
self.player_dict[username] = Player()
self.player_dict[username].username = username
self.player_dict[username].load()
self.player_dict[username].position[
'x'] = iterator.getFloat64()
self.player_dict[username].position[
'y'] = iterator.getFloat64()
self.player_dict[username].position[
'z'] = iterator.getFloat64()
logging.info(f"player '{username}' initialized")
datagram = PyDatagram()
datagram.addString("introduce")
datagram.addString(me.username)
world_client.cWriter.send(datagram, world_client.conn)
logging.debug("Send introduction")
elif self.type == "update":
self.num_players = iterator.getInt8()
for _ in range(self.num_players):
username = iterator.getString()
if username == me.username:
for i in range(6):
iterator.getFloat64() # TODO: Implement check
continue
if username not in self.player_dict.keys():
self.player_dict[username] = Player(username)
self.player_dict[username].load()
self.player_dict[username].position['x'] = iterator.getFloat64(
)
self.player_dict[username].position['y'] = iterator.getFloat64(
)
self.player_dict[username].position['z'] = iterator.getFloat64(
)
self.player_dict[username].position['h'] = iterator.getFloat64(
)
self.player_dict[username].position['p'] = iterator.getFloat64(
)
self.player_dict[username].position['r'] = iterator.getFloat64(
)
elif self.type == "remove":
username = iterator.getString()
self.player_dict[username].model.removeNode()
del self.player_dict[username]
elif self.type == "chat":
self.text = iterator.getString()
chat_reg.setText(self.text)
class PlayerReg(DirectObject): #This class will regulate the players
def __init__(self):
self.playerList = []
self.numofplayers = 0
self.win1 = None
def ProcessData(self,datagram, m,chatClass):
#process received data
self.iterator = PyDatagramIterator(datagram)
self.type = self.iterator.getString()
if (self.type == "init"):
print "initializing"
#initialize
m.setPlayerNum(self.iterator.getUint8())
self.num = self.iterator.getUint8()
for i in range(self.num):
if (i != m.playernum):
self.playerList.append(Player())
self.playerList[i].username = self.iterator.getString()
self.playerList[i].load()
self.playerList[i].currentPos['x'] = self.iterator.getFloat64()
self.playerList[i].currentPos['y'] = self.iterator.getFloat64()
self.playerList[i].currentPos['z'] = self.iterator.getFloat64()
print "player ", str(i), " initialized"
else:
self.playerList.append(Player())
self.numofplayers = self.num
print 'draw new'
self.win1.queue_draw()
if (self.type == "update"):
self.num = self.iterator.getUint8()
if (self.num > self.numofplayers):
for i in range(self.numofplayers):
self.playerList[i].currentPos['x'] = self.iterator.getFloat64()
self.playerList[i].currentPos['y'] = self.iterator.getFloat64()
self.playerList[i].currentPos['z'] = self.iterator.getFloat64()
self.playerList[i].currentPos['h'] = self.iterator.getFloat64()
self.playerList[i].currentPos['p'] = self.iterator.getFloat64()
self.playerList[i].currentPos['r'] = self.iterator.getFloat64()
for i in range(self.numofplayers,self.num):
if (i != m.playernum):
self.playerList.append(Player())
self.playerList[i].load()
self.playerList[i].currentPos['x'] = self.iterator.getFloat64()
self.playerList[i].currentPos['y'] = self.iterator.getFloat64()
self.playerList[i].currentPos['z'] = self.iterator.getFloat64()
self.playerList[i].currentPos['h'] = self.iterator.getFloat64()
self.playerList[i].currentPos['p'] = self.iterator.getFloat64()
self.playerList[i].currentPos['r'] = self.iterator.getFloat64()
else:
self.playerList.append(Player())
self.numofplayers = self.num
else:
for i in range(self.numofplayers):
self.playerList[i].currentPos['x'] = self.iterator.getFloat64()
self.playerList[i].currentPos['y'] = self.iterator.getFloat64()
self.playerList[i].currentPos['z'] = self.iterator.getFloat64()
self.playerList[i].currentPos['h'] = self.iterator.getFloat64()
self.playerList[i].currentPos['p'] = self.iterator.getFloat64()
self.playerList[i].currentPos['r'] = self.iterator.getFloat64()
if (self.type == "chat"):
self.text = self.iterator.getString()
chatClass.setText(self.text)
def updatePlayers(self,m):
if (self.numofplayers != 0):
for k in range(self.numofplayers):
#As long as the player is not the client put it where the server says
if(k != m.playernum):
self.playerList[k].model.setPosHpr(self.playerList[k].currentPos['x'],self.playerList[k].currentPos['y'],self.playerList[k].currentPos['z'],self.playerList[k].currentPos['h'],self.playerList[k].currentPos['p'],self.playerList[k].currentPos['r'])
return Task.cont
def processMsgData(self, dataGram):
iterator = PyDatagramIterator(dataGram)
msgID = iterator.getUint8()
if msgID == PRINT_MESSAGE:
msg = iterator.getString()
print msg
def processData(self, netDatagram):
myIterator = PyDatagramIterator(netDatagram)
return self.decode(myIterator.getString())
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 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 myProcessDataFunction(self, netDatagram):
# check a message and do what it says
myIterator = PyDatagramIterator(netDatagram)
msgID = myIterator.getUint8()
if msgID == PRINT_MESSAGE: # This is a debugging message
messageToPrint = myIterator.getString()
print messageToPrint
elif msgID == PLAYER_ASSIGNMENT_MESSAGE: # This assigns the player to a car
playerNum = myIterator.getUint8()
self.carData.index = playerNum
self.playername += " (%d)"%playerNum
carXpos = myIterator.getFloat32()
carYpos = myIterator.getFloat32()
carXvel = myIterator.getFloat32()
carYvel = myIterator.getFloat32()
carHeading = myIterator.getFloat32()
carInput = []
for i in range(5):
carInput.append(myIterator.getBool())
carLights = myIterator.getBool()
carHp = myIterator.getInt32()
self.updatePositions(playerNum, (carXpos, carYpos, carXvel, carYvel, carHeading, carInput, carLights, carHp))
elif msgID == CAR_MESSAGE: # This updates a car
carNum = myIterator.getUint8()
if carNum != self.carData.index:
carXpos = myIterator.getFloat32()
carYpos = myIterator.getFloat32()
carXvel = myIterator.getFloat32()
carYvel = myIterator.getFloat32()
carHeading = myIterator.getFloat32()
carInput = []
for i in range(5):
carInput.append(myIterator.getBool())
carLights = myIterator.getBool()
carHp = myIterator.getInt32()
self.updatePositions(carNum, (carXpos, carYpos, carXvel, carYvel, carHeading, carInput, carLights, carHp))
elif msgID == COLLIDED_MESSAGE: # This runs car-car collisions
collisionFrom = myIterator.getUint8()
if collisionFrom == self.carData.index:
self.carHitSound.play()
self.doCarCollision(myIterator.getUint8())
self.cWriter.send(self.verifyCollisionMessage(), self.myConnection)
elif msgID == MAP_MESSAGE: # This sets the map
map = myIterator.getString()
print map
world_loader = w_loader()
world_loader.load_world(map)
global spawn_locations
self.carData.spos = spawn_locations
elif msgID == BEGIN_MESSAGE: # This starts the game
self.carData.go = True
self.textWaitObject.destroy()
self.startSound.play()
elif msgID == END_MESSAGE: # This ends the game, and then displays the score on the second receipt
self.carData.go = False
num = myIterator.getInt32()
if num == -1:
scoreDatagram = self.scoreDatagram()
self.cWriter.send(scoreDatagram, self.myConnection)
else:
textytext = "Most Numerous Deaths:"
for i in range(num):
textytext += "\n\n%s: %d"%(myIterator.getString(), myIterator.getInt32())
self.textScore = OnscreenText(text=textytext, style=1, fg=(1,1,1,1), pos=(0,0.9), scale = .08)
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
class PlayerReg(DirectObject):
"""Regulate player positions"""
def __init__(self):
self.iterator = None
self.player_dict = {}
self.players = []
self.num_players = 0
self.type = ""
def process_data(self, datagram):
assert datagram
self.iterator = PyDatagramIterator(datagram)
self.type = self.iterator.getString()
if self.type == "init":
self.process_init()
elif self.type == "update":
self.process_update()
elif self.type == "remove":
self.process_remove()
elif self.type == "chat":
self.process_chat()
else:
logging.warning("Datagram not recognized")
def process_init(self):
it = self.iterator
logging.info("initializing")
me.player_id = it.getUint8()
self.num_players = it.getUint8()
if self.num_players > 1:
for _ in range(self.num_players):
username = it.getString()
self.player_dict[username] = Player()
self.player_dict[username].username = username
self.player_dict[username].load()
self.player_dict[username].position['x'] = it.getFloat64()
self.player_dict[username].position['y'] = it.getFloat64()
self.player_dict[username].position['z'] = it.getFloat64()
logging.info(f"player '{username}' initialized")
datagram = PyDatagram()
datagram.addString("introduce")
datagram.addString(me.username)
world_client.cWriter.send(datagram, world_client.conn)
logging.debug("Send introduction")
def process_update(self):
it = self.iterator
self.num_players = it.getInt8()
for _ in range(self.num_players):
username = it.getString()
if username == me.username:
for i in range(6):
it.getFloat64() # TODO: Implement check
continue
if username not in self.player_dict.keys():
self.player_dict[username] = Player(username)
self.player_dict[username].load()
self.player_dict[username].position['x'] = it.getFloat64()
self.player_dict[username].position['y'] = it.getFloat64()
self.player_dict[username].position['z'] = it.getFloat64()
self.player_dict[username].position['h'] = it.getFloat64()
self.player_dict[username].position['p'] = it.getFloat64()
self.player_dict[username].position['r'] = it.getFloat64()
def process_remove(self):
username = self.iterator.getString()
self.player_dict[username].model.removeNode()
del self.player_dict[username]
def process_chat(self):
self.text = self.iterator.getString()
chat_reg.setText(self.text)
def update_players(self, arg):
if self.num_players != 0:
for k in self.player_dict.keys():
# As long as the player is not the client put it where the server says
if k != me.username:
self.player_dict[k].model.setPosHpr(self.player_dict[k].position['x'],
self.player_dict[k].position['y'],
self.player_dict[k].position['z'],
self.player_dict[k].position['h'],
self.player_dict[k].position['p'],
self.player_dict[k].position['r'])
return Task.cont
class PlayerReg(DirectObject): #This class will hold anything that is related to regulating clients
def __init__(self):
self.PlayerList = []
self.active = 0
self.timeSinceLastUpdate = 0
self.elapsed = 0
def updatePlayers(self,serverClass,data,type):
if (type == "positions"):
#keep players updated on their position
#self.elapsed = globalClock.getDt()
self.elapsed = 0.0001
self.timeSinceLastUpdate += self.elapsed
if (self.timeSinceLastUpdate > 0.1):
self.timeSinceLastUpdate = 0
if (self.active):
self.datagram = PyDatagram()
self.datagram.addString("update")
#add the number of players
self.datagram.addFloat64(self.active)
#add every players current position
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)
return Task.cont
if(type == "chat"):
#Keep players up to date with all the chat thats goin on
self.iterator = data
self.datagram = PyDatagram()
self.datagram.addString("chat")
self.text = self.iterator.getString()
self.datagram.addString(self.text)
print self.text,' ',str(serverClass)
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): #Initialize the new Player
self.con = self.PlayerList[i].connectionID #set the connection to the player's connection
self.datagram = PyDatagram() #create a datagram instance
self.datagram.addString("init") #specify to the client that this is an init type packet
self.datagram.addUint8(self.active) #specify the player's number (not sure why this is here)
self.datagram.addFloat64(i) #specify number of players (same as player's number)
for k in self.PlayerList: #Add the current position of everyone in the game world and send it
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)
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;
class PlayerReg(
DirectObject
): #This class will hold anything that is related to regulating clients
def __init__(self):
self.PlayerList = []
self.active = 0
self.timeSinceLastUpdate = 0
def updatePlayers(self, serverClass, data, type):
if (type == "positions"):
#keep players updated on their position
self.elapsed = globalClock.getDt()
self.timeSinceLastUpdate += self.elapsed
if (self.timeSinceLastUpdate > 0.1):
if (self.active):
self.datagram = PyDatagram()
self.datagram.addString("update")
#add the number of players
self.datagram.addFloat64(self.active)
#add every players current position
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"):
#Keep players up to date with all the chat thats goin on
self.iterator = data
self.datagram = PyDatagram()
self.datagram.addString("chat")
self.text = self.iterator.getString()
self.datagram.addString(self.text)
print self.text, ' ', str(serverClass)
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): #Initialize the new Player
self.con = self.PlayerList[
i].connectionID #set the connection to the player's connection
self.datagram = PyDatagram() #create a datagram instance
self.datagram.addString(
"init") #specify to the client that this is an init type packet
self.datagram.addUint8(
self.active
) #specify the player's number (not sure why this is here)
self.datagram.addFloat64(
i) #specify number of players (same as player's number)
for k in self.PlayerList: #Add the current position of everyone in the game world and send it
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 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()
