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 setDNAString(self, dnaStr):
data = PyDatagram(dnaStr)
iter = PyDatagramIterator(data)
self.setShapeStyle(int(iter.getUint8()))
bgData = [
0] * len(self.bgData)
layoutData = [
0] * len(self.layoutData)
for x in range(len(bgData)):
bgData[x] = int(iter.getUint8())
self.setBackground(*bgData)
for x in range(len(layoutData)):
layoutData[x] = int(iter.getUint8())
self.setLayout(*layoutData)
self.emblems = { }
eCount = 0
while iter.getRemainingSize() >= len(self.DefaultEmblemData):
edata = self.DefaultEmblemData[:]
for x in range(0, len(edata)):
edata[x] = int(iter.getUint8())
self.setEmblem(eCount, *edata)
eCount += 1
def 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):
connection = datagram.getConnection()
if not connection:
self.dump_invalid_connection(connection)
di = PyDatagramIterator(datagram)
if di.getUint8() == 1:
self.handle_incoming(di, connection, datagram)
elif di.getUint8() == BAD_CHANNEL_ID:
self.handle_bad_channel(di)
def createGardenFromData(self, gardenData):
dg = PyDatagram(gardenData)
gardenData = PyDatagramIterator(dg)
plotCount = gardenData.getUint8()
for _ in xrange(plotCount):
occupier = gardenData.getUint8()
if occupier not in occupier2Class:
continue
plot = occupier2Class[occupier](self.air, self, self.house.housePos)
plot.construct(gardenData)
plot.generateWithRequired(self.house.zoneId)
self.plots.append(plot)
def 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):
it = PyDatagramIterator(data)
mssgID = it.getUint8()
if mssgID == 42:
return None
vel = it.getFloat32()
z = it.getFloat32()
x = it.getFloat32()
y = it.getFloat32()
checksum = it.getFloat32()
#print "velocity:" , vel ,
#" Z position:" , z , " Checksum " , checksum
newx = x
zdiff = z - self.smiley.getZ()
self.smiley.setPythonTag("velocity", vel + zdiff * 0.03)
#self.smiley.setX(x)
#self.smiley.setZ(z)
#self.smiley.setY(y)
data = PyDatagram()
data.addUint8(0)
data.addString("w") #change this to key being pressed forward
data.addString("OH HI MARTK!!")
return data
def process(self, data):
it = PyDatagramIterator(data)
msgid = it.getUint8()
conn = data.getConnection()
sendingPlayer = None
for p in self.server.players:
if p.connection == conn:
sendingPlayer = p
break
else:
logging.error("No sendingPlayer found")
if msgid == ServerMsgId.keepAlive:
return None
elif msgid == ServerMsgId.registration:
return self.handleRegistration(it, sendingPlayer)
elif msgid == ServerMsgId.chatMsg:
return self.handleChatMsg(it, sendingPlayer)
elif msgid == ServerMsgId.tryPlayCard:
return self.handleTryPlayCard(it, sendingPlayer)
elif msgid == ServerMsgId.tryPutInBattleground:
return self.handleTryPutInBattleground(it, sendingPlayer)
def process(self, data):
it = PyDatagramIterator(data)
msgid = it.getUint8()
if msgid == 0:
return self.handleHello(it)
elif msgid == 1:
return self.handleQuestion(it)
elif msgid == 2:
return self.handleBye(it)
def receiveData(self, dg):
dg = PyDatagramIterator(dg)
fr = (dg.getUint8(), dg.getUint8())
to = (dg.getUint8(), dg.getUint8())
print "Received move %s -> %s" % (fr, to)
def indicate():
self.turnIndicator['text'] = 'Your turn!'
self.sfx = loader.loadSfx('audio/ding.wav')
self.sfx.play()
seq = Sequence()
seq.append(self.showPathIfVisible(fr, to))
seq.append(self.makeMove(fr, to))
seq.append(Func(indicate))
seq.append(Func(self.showVisibleSquares))
seq.start()
def process(self, data):
print "Got some data"
it = PyDatagramIterator(data)
msgid = it.getUint8()
if msgid == 0:
print "Got 0 key mssg"
return self.handleHello(it)
elif msgid == 1:
return self.handleQuestion(it)
elif msgid == 2:
return self.handleBye(it)
def __makeList(self, store):
list = []
if self.__blob:
dg = PyDatagram(self.__blob)
di = PyDatagramIterator(dg)
versionNumber = di.getUint8()
while di.getRemainingSize() > 0:
item = CatalogItem.decodeCatalogItem(di, versionNumber, store)
list.append(item)
return list
def getItem(blob, store = 0):
dg = PyDatagram(blob)
di = PyDatagramIterator(dg)
try:
versionNumber = di.getUint8()
return decodeCatalogItem(di, versionNumber, store)
except Exception, e:
CatalogItem.notify.warning('Invalid catalog item: %s, %s' % (sys.exc_info()[0], e))
dg.dumpHex(Notify.out())
import CatalogInvalidItem
return CatalogInvalidItem.CatalogInvalidItem()
def 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 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 TCPPacketListenTask(self, task):
if self.tcpReader.dataAvailable():
datagram = NetDatagram()
if self.tcpReader.getData(datagram):
data = PyDatagramIterator(datagram)
ip = datagram.getAddress().getIpString()
port = datagram.getAddress().getPort()
peerAddr = NetAddress()
peerAddr.setHost(ip, port)
packetType = data.getUint8()
if(packetType == Packet.PC_TCP_PACKET):
self.tcpPacketController.OnPacketReceived(data, peerAddr)
return task.cont
def makeFromNetString(self, netString):
dataList = []
dg = PyDatagram(netString)
dgi = PyDatagramIterator(dg)
for track in xrange(0, len(Tracks)):
subList = []
for level in xrange(0, len(Levels[track])):
if dgi.getRemainingSize() > 0:
value = dgi.getUint8()
else:
value = 0
subList.append(value)
dataList.append(subList)
return dataList
def makeFromNetStringForceSize(self, netString, numTracks, numLevels):
dataList = []
dg = PyDatagram(netString)
dgi = PyDatagramIterator(dg)
for track in range(0, numTracks):
subList = []
for level in range(0, numLevels):
if dgi.getRemainingSize() > 0:
value = dgi.getUint8()
else:
value = 0
subList.append(value)
dataList.append(subList)
return dataList
def makeFromNetString(self, netString):
dataList = []
dg = PyDatagram(netString)
dgi = PyDatagramIterator(dg)
for track in xrange(0, len(Tracks)):
subList = []
for level in xrange(0, len(Levels[track])):
if dgi.getRemainingSize() > 0:
value = dgi.getUint8()
else:
value = 0
subList.append(value)
dataList.append(subList)
return dataList
def makeFromNetStringForceSize(self, netString, numTracks, numLevels):
"""makeFromNetString(self)
Make an inventory from a network packet
"""
dataList = []
dg = PyDatagram(netString)
dgi = PyDatagramIterator(dg)
for track in range(0, numTracks):
subList = []
for level in range(0, numLevels):
if dgi.getRemainingSize() > 0:
value = dgi.getUint8()
else:
value = 0
subList.append(value)
dataList.append(subList)
return dataList
def _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 UDPPacketListenTask(self, task):
while self.cReader.dataAvailable():
datagram = NetDatagram()
if self.cReader.getData(datagram):
#print 'PACKET', datagram
data = PyDatagramIterator(datagram)
ip = datagram.getAddress().getIpString()
port = datagram.getAddress().getPort()
peerAddr = NetAddress()
peerAddr.setHost(ip, port)
packetType = data.getUint8()
if(packetType == Packet.PC_RELIABLE_PACKET):
self.reliablePacketController.OnPacketReceived(data, peerAddr)
elif(packetType == Packet.PC_UNRELIABLE_PACKET):
self.unreliablePacketController.OnPacketReceived(data, peerAddr)
elif(packetType == Packet.PC_ENVIRONMENT_PACKET):
self.dataHandler.OnDataReceived(data, peerAddr, Packet.PC_ENVIRONMENT_PACKET)
return Task.cont
def UDPPacketListenTask(self, task = None):
while self.cReader.dataAvailable():
datagram = NetDatagram()
if self.cReader.getData(datagram):
data = PyDatagramIterator(datagram)
ip = datagram.getAddress().getIpString()
port = datagram.getAddress().getPort()
peerAddr = NetAddress()
peerAddr.setHost(ip, port)
#print 'GOT UDP PACKET FROM', peerAddr.getIpString(), peerAddr.getPort()
isReliable = data.getUint8()
if(isReliable == Packet.PC_RELIABLE_PACKET):
self.reliablePacketController.OnPacketReceived(data, peerAddr)
elif(isReliable == Packet.PC_UNRELIABLE_PACKET):
self.unreliablePacketController.OnPacketReceived(data, peerAddr)
if(self.ClientIsConnected(peerAddr)):
self.GetActiveClient(peerAddr).timestamp = GameTime.time
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 check_for_message(self, taskdata):
"""
Called repeatedly to check if any new messages from server
This gets the information from said datagram and calls whatever function necessary
@param self
@param taskdata
"""
if self.cReader.dataAvailable():
dg = NetDatagram()
if self.cReader.getData(dg):
iterator = PyDatagramIterator(dg)
try:
msg_id = iterator.getUint8()
except AssertionError:
self.notify.warning("[check_for_message] Invalid msg_id!")
return Task.cont
if msg_id in self.mapping:
self.mapping[msg_id](self, iterator)
else:
self.notify.warning(
f"[check_for_message] Unknown msg_id: {msg_id}")
return Task.cont
def process(self, data):
it = PyDatagramIterator(data)
msgid = it.getUint8()
if msgid == ClientMsgId.keepAlive:
return None
elif msgid == ClientMsgId.joinAccepted:
return self.handleJoinAccepted(it)
elif msgid == ClientMsgId.playerConnected:
return self.handleConnect(it)
elif msgid == ClientMsgId.playerDisconnected:
return self.handleDisconnect(it)
elif msgid == ClientMsgId.chatMsg:
return self.handleChatMsg(it)
elif msgid == ClientMsgId.gameStarted:
return self.handleGameStarted(it)
elif msgid == ClientMsgId.nextTurn:
return self.handleNextTurn(it)
elif msgid == ClientMsgId.playCard:
return self.handlePlayCard(it)
elif msgid == ClientMsgId.sendHand:
return self.handleSendHand(it)
elif msgid == ClientMsgId.sendTurnTime:
return self.handleSendTurnTime(it)
elif msgid == ClientMsgId.sendUpdateBattleground:
return self.handleUpdateBattleground(it)
def check_for_message(self, taskdata):
"""
Called repeatedly to check if there's any new messages
"""
if self.cReader.dataAvailable():
dg = NetDatagram()
if self.cReader.getData(dg):
iterator = PyDatagramIterator(dg)
connection = dg.getConnection()
try:
msg_id = iterator.getUint8()
except AssertionError:
self.notify.warning("[check_for_message] No message ID")
return Task.cont
# check if real msg_id
if msg_id in self.mapping:
self.mapping[msg_id](self, iterator)
else:
self.notify.warning(
"[check_for_message] Invalid msg_id: {}".format(
msg_id))
return Task.cont
def 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 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
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 readHeader(self, datagram):
dgi = PyDatagramIterator(datagram)
number = dgi.getUint32()
dtype = dgi.getUint8()
self.notify.debug("Packet %d type %d received" % (number, dtype))
return (dgi, dtype)
def makeFromNetString(self, string):
dg = PyDatagram(string)
dgi = PyDatagramIterator(dg)
self.type = dgi.getFixedString(1)
if self.type == "t":
headIndex = dgi.getUint8()
torsoIndex = dgi.getUint8()
legsIndex = dgi.getUint8()
self.head = toonHeadTypes[headIndex]
self.torso = toonTorsoTypes[torsoIndex]
self.legs = toonLegTypes[legsIndex]
gender = dgi.getUint8()
if gender == 1:
self.gender = "m"
else:
self.gender = "f"
self.topTex = dgi.getUint8()
self.topTexColor = dgi.getUint8()
self.sleeveTex = dgi.getUint8()
self.sleeveTexColor = dgi.getUint8()
self.botTex = dgi.getUint8()
self.botTexColor = dgi.getUint8()
self.armColor = dgi.getUint8()
self.gloveColor = dgi.getUint8()
self.legColor = dgi.getUint8()
self.headColor = dgi.getUint8()
else:
notify.error("unknown avatar type: ", self.type)
def makeFromNetString(self, string):
dg = PyDatagram(string)
dgi = PyDatagramIterator(dg)
self.type = dgi.getFixedString(1)
if self.type == 't':
headIndex = dgi.getUint8()
torsoIndex = dgi.getUint8()
legsIndex = dgi.getUint8()
self.head = toonHeadTypes[headIndex]
self.torso = toonTorsoTypes[torsoIndex]
self.legs = toonLegTypes[legsIndex]
gender = dgi.getUint8()
if gender == 1:
self.gender = 'm'
else:
self.gender = 'f'
self.topTex = dgi.getUint8()
self.topTexColor = dgi.getUint8()
self.sleeveTex = dgi.getUint8()
self.sleeveTexColor = dgi.getUint8()
self.botTex = dgi.getUint8()
self.botTexColor = dgi.getUint8()
self.armColor = dgi.getUint8()
self.gloveColor = dgi.getUint8()
self.legColor = dgi.getUint8()
self.headColor = dgi.getUint8()
else:
notify.error('unknown avatar type: ', self.type)
def readHeader(self, datagram):
dgi = PyDatagramIterator(datagram)
number = dgi.getUint32()
type = dgi.getUint8()
self.notify.debug("Packet %d type %d received" % (number, type))
return (dgi, type)
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)
def processMsgData(self, dataGram):
iterator = PyDatagramIterator(dataGram)
msgID = iterator.getUint8()
if msgID == PRINT_MESSAGE:
msg = iterator.getString()
print msg
