def update(self, task):
while self.reader.dataAvailable():
datagram = NetDatagram()
if self.reader.getData(datagram):
dataIter = PyDatagramIterator(datagram)
pid = dataIter.getInt8()
x = dataIter.getFloat32()
y = dataIter.getFloat32()
if pid not in self.players:
print 'NEW PLAYER', pid
self.players[pid] = Player(pid=pid, draw=True)
self.players[pid].move_to(x, y)
return task.cont
def update(self, task):
while self.reader.dataAvailable():
datagram = NetDatagram()
if self.reader.getData(datagram):
dataIter = PyDatagramIterator(datagram)
pid = dataIter.getInt8()
x = dataIter.getFloat32()
y = dataIter.getFloat32()
if pid not in self.players:
print 'NEW PLAYER', pid
self.players[pid] = Player(pid=pid, draw=True)
self.players[pid].move_to(x, y)
return task.cont
def 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 _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 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
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 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 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()
