def getData(self):
data = self.passedData
self.passedData = []
while self.cReader.dataAvailable():
datagram = NetDatagram()
if self.cReader.getData(datagram):
data.append(
(datagram.getConnection(), self.processData(datagram)))
return 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
#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 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 on_frame(self):
if not self.c_reader.data_available():
return
datagram = NetDatagram()
if not self.c_reader.get_data(datagram):
return
_iter = PyDatagramIterator(datagram)
meths = {
'B': _iter.get_bool,
'I': _iter.get_int64,
'F': _iter.get_float64,
'S': _iter.get_string
}
msg = [meths[c]() for c in _iter.get_string()]
self.reader_cb(msg, datagram.get_connection())
def listen_for_new_data(self):
"""
Listens for new data from active connections
"""
while True:
if self.reader.data_available():
datagram = NetDatagram()
if self.reader.get_data(datagram):
connection = datagram.getConnection()
session = self.session_manager.for_connection(connection)
self.handler.handle_data(
datagram,
connection,
session,
)
time.sleep(0.01)
def check(self):
while self.cReader.dataAvailable():
print "data here"
datagram = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram):
data = PyDatagramIterator(datagram)
responseCode = data.getUint16()
print responseCode
if responseCode == 1:
self.getInt(data)
elif responseCode == 2:
self.getString(data)
elif responseCode == 3:
self.getShort(data)
elif responseCode == 4:
self.getFloat(data)
elif responseCode == 201:
self.getLogin(data)
elif responseCode == 203:
self.getRegistion(data)
elif responseCode == 204:
self.getCharacterCreation(data)
elif responseCode == 205:
self.getChat(data)
elif responseCode == 206:
self.getMove(data)
else:
print "nothing found"
def read_data(self, task):
if self.cReader.dataAvailable():
dg = NetDatagram()
if self.cReader.getData(dg):
self.handle_data(dg)
return task.cont
def get_main_section_state(self) -> WorldState:
"""
Fetch current world model from the server.
"""
# send datagram asking for current world data (player's location, other player names, positions etc.)
data = PyDatagram()
data.add_uint8(WorldStateRequest.ID)
self.net_client.writer.send(data, self.net_client.server_connection)
# wait for datagram from the server
self.net_client.manager.wait_for_readers(self.net_client.timeout /
1000)
if not self.net_client.reader.data_available():
raise Exception(
"No response from the server about the main section model.")
datagram = NetDatagram()
if not self.net_client.reader.get_data(datagram):
raise Exception("Main section model response unavailable.")
iterator = PyDatagramIterator(datagram)
world_state_message = self.message_parser(iterator,
MessageType.response)
return world_state_message.data
def tcpNonBlockingRead(self, qcr):
"""
Return a datagram collection and type if data is available on
the queued connection tcpReader
"""
if self.connectionManager.tcpReader.dataAvailable():
datagram = NetDatagram()
if self.connectionManager.tcpReader.getData(datagram):
data = DatagramIterator(datagram)
opcode = data.getUint8()
managerCode = data.getUint8()
else:
data = None
opcode = MSG_NONE
managerCode = None
else:
datagram = None
data = None
opcode = MSG_NONE
managerCode = None
# Return the datagram to keep a handle on the data
return (datagram, data, opcode, managerCode)
def receiveResponse101(self, task):
while self.cReader.dataAvailable():
datagram = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram):
self.myIterator = PyDatagramIterator(datagram)
print "<-Server response:"
print self.myIterator.getUint16()
self.msg = self.myIterator.getUint32()
self.l = self.myIterator.getUint32()
if self.msg is not None:
if self.l is not 0:
for x in range(0, self.l):
print self.myIterator.getString()
print self.myIterator.getUint32()
print self.myIterator.getUint32()
print self.msg, " received"
#raw_input("Press Enter to continue...")
self.received = 0
taskMgr.remove('Login')
#1-Character creatopm
#taskMgr.add(self.sendRequest104, 'CharacterCreation')
#2-heartbeat of playgame after login
MyApp.sendRequest113(self)
return task.again
def 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 tskReaderPolling(taskdata):
if 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 cReader.getData(datagram):
myProcessDataFunction(datagram)
return Task.cont
def _socketReader(self, task):
if self.cReader.dataAvailable():
datagram = NetDatagram()
if self.cReader.getData(datagram):
base.messageManager.handleMessage(datagram)
return Task.cont
def receiveResponse(self):
print "<-Server response:"
while self.cReader.dataAvailable():
datagram = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram):
self.retrieveStringMessage(datagram)
self.received = 1
def tsk_reader_pol(self, taskdata): if self.c_reader.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.c_reader.getData(datagram): self.data_process(datagram) return Task.cont
def requestLogin(self, username, password):
sender = self.air.getMsgSender()
dg = self.air.getDatagram(Datagram())
ip = NetDatagram(dg).getAddress()
if self.isValidAccount(username, password):
self.d_loginAccepted(sender, ip)
else:
self.d_loginRejected(sender)
def listen_for_updates(self, task):
"""
Listen for any incoming packets from the server.
"""
if self.reader.data_available():
datagram = NetDatagram()
if self.reader.get_data(datagram):
self.handler.handle_data(datagram)
return Task.cont
def handle_connection_data(self, task_data: Task) -> Task:
if self.reader.dataAvailable():
# Catch the incoming data
datagram = NetDatagram()
if self.reader.getData(datagram):
name = self.handle_client_message(datagram)
broadcast = f"Everyone, welcome {name} to the game!"
self.broadcast_message(broadcast)
return Task.cont
def _onReaderPoll (self, taskdata):
"""
Called on an interval to interpret messages from the reader.
"""
if self._connReader.dataAvailable():
newDatagram = NetDatagram()
# Double check to make sure (Multithreading safety):
if self._connReader.getData(newDatagram):
self._interpretDatagram(newDatagram)
return Task.cont # Repeat this call on an interval
def tskReaderPolling(self, taskdata):
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):
if base.client == True:
self.client_processing(datagram)
else:
self.server_processing(datagram)
return Task.cont
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 receiveResponse102(self, task):
print "<-Server response:"
while self.cReader.dataAvailable():
datagram2 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram2):
myIterator = PyDatagramIterator(datagram2)
print myIterator.getUint16()
msg = myIterator.getUint16()
print msg, " received"
if msg is not None:
raw_input("Press Enter to continue...")
self.received = 1
# Register
raw_input("Press Enter to continue...")
taskMgr.add(self.communicate301, 'Heartbeat')
def receiveResponse112(self, task):
while self.cReader.dataAvailable():
datagram12 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram12):
myIterator = PyDatagramIterator(datagram12)
print myIterator.getUint16()
msg = myIterator.getUint32()
if msg is not None:
print "<-Server response:"
print msg
print myIterator.getUint32()
raw_input("Press Enter to continue...")
self.received = 1
def tskReaderPolling(self, taskdata):
# reader callback
if not self.cReader.dataAvailable():
return Task.cont
# 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
datagram = NetDatagram()
if not self.cReader.getData(datagram):
return Task.cont
for callback in self.readerCallbacks:
callback(datagram)
return Task.cont
def updateRoutine(self, task):
"""A once-per-frame task used to read packets from the socket."""
while self.cReader.dataAvailable():
# Create a datagram to store all necessary data.
datagram = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram):
# Prepare the datagram to be iterated.
data = PyDatagramIterator(datagram)
# Retrieve a "short" that contains the response code.
responseCode = data.getUint16()
# Pass into another method to execute the response.
if responseCode != Constants.MSG_NONE:
self.handleResponse(responseCode, data)
return task.cont
def tskReaderPolling(self, taskdata):
# reader callback
if not self.cReader.dataAvailable():
# print( "tskReaderPolling(): no data available!" )
return Task.cont
datagram = NetDatagram()
if not self.cReader.getData(datagram):
print("tskReaderPolling(): cannot claim data!")
return Task.cont
if self.readerCallback:
print("tskReaderPolling():readerCallback()")
self.readerCallback(datagram)
return Task.cont
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
def check(self):
while self.cReader.dataAvailable():
print "data here"
datagram = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram):
data = PyDatagramIterator(datagram)
responseCode = data.getUint16()
print responseCode
if responseCode == 201:
self.getPlayer(data)
elif responseCode == 202:
self.register(data)
elif responseCode == 203:
self.getOpponent(data)
elif responseCode == 214:
self.movePlayer(data)
elif responseCode == 219:
self.dropPlayer(data)
else:
print "nothing found"
def receiveResponse301(self):
while self.cReader.dataAvailable():
datagram301 = NetDatagram()
# Retrieve the contents of the datagram.
if self.cReader.getData(datagram301):
myIterator = PyDatagramIterator(datagram301)
p = myIterator.getUint16()
if p == 213:
un = myIterator.getString()
cname = myIterator.getString()
ctype = myIterator.getUint32()
cteam = myIterator.getUint32()
if un == MyApp.uname:
abc = 'abc'
else:
print cname + ' just joined a game......!! hurray'
#print msg, " received"
self.received = 1
def requestLogin(self, token, username):
username = username.lower()
sender = self.air.getMsgSender()
print sender
self.air.getDatagram(self.private__dg)
ip = str(NetDatagram(self.private__dg).getAddress())
if sender >> 32:
self.air.eject(sender, EC_MULTIPLE_LOGINS, 'You are already logged in.')
return
if not self.air.isValidToken(token, ip):
self.air.eject(sender, EC_BAD_TOKEN, 'I have rejected your token.')
return
accountId = int(self.dbm.get(str(username), 0))
if str(username) not in self.dbm:
self.createAccount(username, accountId, sender)
self.notify.info("Creating a new account...")
else:
self.setAccount(sender, accountId)
self.notify.info("Account already exists!")
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
