653 lines
31 KiB
Python
653 lines
31 KiB
Python
import os
|
|
|
|
from .packet import Packet
|
|
from .EnumQuery import EnumQuery
|
|
from .EnumResponse import EnumResponse
|
|
from .CFrame import CFrame
|
|
from .DFrame import DFrame
|
|
from giants.masterserver import MasterServer
|
|
from .session import Session
|
|
import socket
|
|
import threading
|
|
import traceback
|
|
import uuid
|
|
import struct
|
|
from _datetime import datetime
|
|
from utils.logger import setup_logger
|
|
from giants.player import Player, PlayerPhases
|
|
import time
|
|
from giants import APPLICATION_GUID
|
|
import random
|
|
from .DN_MSG_INTERNAL_SEND_CONNECT_INFO import DN_MSG_INTERNAl_SEND_CONNECT_INFO
|
|
import asyncio
|
|
|
|
logger = setup_logger(__name__)
|
|
|
|
|
|
class Netserver(asyncio.DatagramProtocol):
|
|
def __init__(self, server):
|
|
self.remotesocket = None
|
|
self.statssocket = None
|
|
self.server = server
|
|
self.addrs = []
|
|
self.guid = uuid.uuid4().bytes
|
|
self.incoming_packets = []
|
|
super().__init__()
|
|
|
|
def connection_made(self, transport):
|
|
logger.debug("Connection made")
|
|
self.remotesocket = transport
|
|
|
|
def run(self):
|
|
logger.debug("Run")
|
|
return
|
|
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
|
self.socket.bind((self.server.listen_ip, self.server.listen_port))
|
|
logger.debug("Listening to %s:%s", self.server.listen_ip, self.server.listen_port)
|
|
networkthread = threading.Thread(target=self.handle_packets)
|
|
networkthread.start()
|
|
|
|
if self.server.register_with_ms:
|
|
ms = MasterServer(self.server)
|
|
ms.register()
|
|
|
|
while self.server.running:
|
|
start = datetime.now()
|
|
self.read_packets()
|
|
self.server.update()
|
|
self.send_packets()
|
|
sleep_ms = (start-datetime.now()).total_seconds()+1/self.server.ticks
|
|
if sleep_ms > 0:
|
|
time.sleep(sleep_ms)
|
|
|
|
networkthread.join()
|
|
|
|
def read_packets(self):
|
|
pass
|
|
|
|
def send_packets(self):
|
|
pass
|
|
|
|
def datagram_received(self, data, addr):
|
|
loop = asyncio.get_event_loop()
|
|
loop.create_task(self.handle_new_packet(addr, data))
|
|
|
|
async def handle_new_packet(self, addr, bData):
|
|
pPacket = Packet(bData)
|
|
first = pPacket.getByte()
|
|
if len(bData) >= 4 and first & DFrame.PACKET_COMMAND_DATA:
|
|
await self.handle_new_dframe(addr, pPacket)
|
|
elif len(bData) >= 12 and first & CFrame.PACKET_COMMAND_FRAME:
|
|
await self.handle_new_cframe(addr, pPacket)
|
|
elif first == EnumQuery.LEAD or first == EnumResponse.LEAD:
|
|
logger.debug("%s:%s > %s (ENUM)", addr[0], addr[1], bData.hex())
|
|
await self.handle_new_enum(addr, pPacket)
|
|
else:
|
|
logger.error("Unknown frame received")
|
|
return
|
|
|
|
async def handle_new_enum(self, addr, data):
|
|
# EnumQuery or EnumResponse
|
|
second = data.getByte()
|
|
if second == EnumQuery.COMMAND:
|
|
# EnumQuery
|
|
try:
|
|
eq = EnumQuery(data)
|
|
#logger.debug("Got EnumQuery, sending EnumResponse")
|
|
er = EnumResponse()
|
|
er.Payload = eq.Payload
|
|
er.ApplicationDescSize = 0x50
|
|
er.ApplicationDescFlags = 0x41
|
|
er.MaxPlayers = self.server.maxplayers
|
|
er.CurrentPlayers = len(self.server.players)
|
|
er.SessionName = self.server.name
|
|
er.ApplicationInstanceGUID = self.guid
|
|
er.ApplicationGUID = eq.ApplicationGUID
|
|
'''er.ApplicationReservedData = b'\xff' # Map ID
|
|
er.ApplicationReservedData += b'\x00\x04\x00' # game type and teams
|
|
er.ApplicationReservedData += struct.pack("<L", int(self.server.version*1000)) # game version
|
|
er.ApplicationReservedData += b'\x02\x92\x05\x00\x01\x00\x00\x00\x00\x00' # Unknown
|
|
er.ApplicationReservedData += b'\x9c\x53\xf4\xdd' # Seems to be a checksum of current map
|
|
# \x00\x00\x00\x00: [None]
|
|
# \x00\x00\x00\x01: <custom map>
|
|
# \x9c\x53\xf4\xdd: Three Way Island - Canyons
|
|
# \x1e\xe9\x39\xe1: Still Winter
|
|
# \x9f\xb2\x42\xec: test
|
|
er.ApplicationReservedData += self.server.currentmap.mapname.encode("ascii")'''
|
|
|
|
appdata = Packet()
|
|
appdata.putByte(0xff) # map ID
|
|
appdata.putByte(self.server.game_type) # game type
|
|
appdata.putByte(self.server.teams) # teams
|
|
appdata.write(b'\x00') # original: 0x00 - does not seem to affect client
|
|
appdata.putShort(int(self.server.version * 1000))
|
|
appdata.write(b'\x02\x92') # original: 0292 - does not seem to affect client
|
|
appdata.putShort(self.server.points_per_capture)
|
|
appdata.putShort(self.server.points_per_kill)
|
|
appdata.write(b'\x00\x00') # original: 0000 - does not seem to affect client
|
|
appdata.putShort(self.server.detente_time)
|
|
appdata.write(self.server.currentmap.checksum) # Seems to be a checksum of current map OR linked to the number of chars in the map name
|
|
appdata.write(self.server.currentmap.mapname.encode("ascii"))
|
|
appdata.write(b'\x00' * (32 - len(self.server.currentmap.mapname)))
|
|
er.ApplicationReservedData = appdata.getvalue()
|
|
|
|
logger.debug("Current map: %s, checksum: %s", self.server.currentmap.mapname, self.server.currentmap.checksum)
|
|
er.ApplicationReservedData += b'\x00' * (32 - len(self.server.currentmap.mapname))
|
|
self.send_packet(addr, er.to_packet())
|
|
except Exception:
|
|
logger.error("Could not parse EnumQuery or forge EnumResponse: ")
|
|
traceback.print_exc()
|
|
return
|
|
elif second == EnumResponse.COMMAND:
|
|
# wait what? ignore that shit
|
|
return
|
|
else:
|
|
logger.error("Unknown DPLHP command: %s", second)
|
|
|
|
async def handle_new_cframe(self, addr, data):
|
|
try:
|
|
cframe = CFrame(data)
|
|
session = self.get_session(addr)
|
|
player = self.get_player(session) if session else None
|
|
if cframe.ExtOpCode == CFrame.FRAME_EXOPCODE_CONNECT:
|
|
logger.debug("%s:%s > %s (CFRAME CONNECT)", addr[0], addr[1], data.getvalue().hex())
|
|
# CONNECT CFRAME
|
|
if session and session.Full:
|
|
if False:
|
|
logger.error("Session %s:%s was already fully connected. Ignoring.", session.ip, session.port)
|
|
return
|
|
else:
|
|
logger.error("Session %s:%s was already fully connected. Kicking the old one.", session.ip, session.port)
|
|
player = self.get_player(session)
|
|
if player:
|
|
self.server.remove_player(self.get_player(session))
|
|
self.addrs.remove(session)
|
|
elif session and not session.Full and session.SessID == cframe.SessID:
|
|
# send CONNECTED
|
|
logger.debug("Already partially established connection. Sending a CFRAME CONNECTED again.")
|
|
session.send_cframe_connected(cframe)
|
|
#session.setup_Connect_Retry_Timer()
|
|
return
|
|
if not self.server.accept_new_players:
|
|
# ignore new players
|
|
return
|
|
else:
|
|
logger.debug("New connection. Sending a CFRAME CONNECTED.")
|
|
session = Session(self.remotesocket)
|
|
session.SessID = cframe.SessID
|
|
session.ip = addr[0]
|
|
session.port = addr[1]
|
|
await session.lock.acquire()
|
|
self.addrs.append(session)
|
|
session.send_cframe_connected(cframe)
|
|
player = Player("Unknown", session)
|
|
|
|
def bxor(b1, b2): # use xor for bytes
|
|
result = bytearray()
|
|
for b1, b2 in zip(b1, b2):
|
|
result.append(b1 ^ b2)
|
|
return result
|
|
#player.id = struct.unpack(">L", bxor(struct.pack("<L", len(self.server.players)), self.guid[0:4]))[0]
|
|
logger.debug("Value for connected player: %s", player.id)
|
|
player.phase = PlayerPhases.CFRAME_CONNECT
|
|
self.server.create_temp_player(player)
|
|
#session.setup_Connect_Retry_Timer()
|
|
elif cframe.ExtOpCode == CFrame.FRAME_EXOPCODE_CONNECTED:
|
|
logger.debug("%s:%s > %s (CFRAME CONNECTED)", addr[0], addr[1], data.getvalue().hex())
|
|
# CONNECTED CFRAME
|
|
# check if already sent a CONNECT packet
|
|
logger.debug("%s:%s sent back a CONNECTED CFrame.", session.ip, session.port)
|
|
if not session:
|
|
logger.error("%s sent a CONNECTED opcode without having sent a CONNECT before. GTFO.", addr)
|
|
return
|
|
|
|
if not cframe.SessID == session.SessID or cframe.Command & CFrame.PACKET_COMMAND_POLL:
|
|
logger.error("Sent a CONNECTED packet with incorrect SessID or had COMMAND_POLL")
|
|
return
|
|
session.Full = True # fully connected
|
|
session.cancel_Connect_Retry_Timer()
|
|
player.phase = PlayerPhases.CFRAME_CONNECTED
|
|
session.send_dframe_keepalive()
|
|
|
|
elif cframe.ExtOpCode == CFrame.FRAME_EXOPCODE_SACK:
|
|
logger.debug("%s:%s > %s (CFRAME SACK)", addr[0], addr[1], data.getvalue().hex())
|
|
if not session or not session.Full:
|
|
logger.error("Received a SACK packet for a non fully connected session")
|
|
return
|
|
|
|
sack_sent = False
|
|
if not cframe.NSeq == session.next_expected_seq:
|
|
logger.error("Received CFRAME (%s) does not have the same NSeq (%s). Did we miss a packet?", cframe.NSeq, session.next_expected_seq)
|
|
if not sack_sent:
|
|
session.send_cframe_sack()
|
|
sack_sent = True
|
|
|
|
if not session.next_send == cframe.NRecv:
|
|
logger.error("Received CFRAME (%s) does not have same NRcv (%s). One sent packet might have been lost.", cframe.NRecv, session.next_send)
|
|
if not sack_sent:
|
|
session.send_cframe_sack()
|
|
sack_sent = True
|
|
|
|
# release lock for new packet to be sent
|
|
if session.lock.locked():
|
|
session.lock.release()
|
|
|
|
# WIP: The bNSeq, bNRcv, optional selective acknowledgment (SACK), and optional send mask fields are then processed by using the standard rules in sections 3.1.5.2.1 through 3.1.5.2.4
|
|
# TODO: A successfully validated SACK packet SHOULD count as a valid receive and thus restart the KeepAlive timer
|
|
|
|
if cframe.Command & CFrame.PACKET_COMMAND_POLL:
|
|
if not session:
|
|
logger.error("Received a POLL packet for a non fully connected session")
|
|
return
|
|
#logger.debug("Got a CFrame POLL. Replying with a SACK.")
|
|
# must send back a ACK
|
|
|
|
session.send_cframe_sack()
|
|
except Exception:
|
|
logger.error("Should have been a CFRAME but could not parse it")
|
|
traceback.print_exc()
|
|
return
|
|
|
|
async def handle_new_dframe(self, addr, data):
|
|
try:
|
|
dframe = DFrame(data)
|
|
#logger.debug("Received DFRAME")
|
|
session = next((x for x in self.addrs if x.ip == addr[0] and x.port == addr[1]), None)
|
|
if not session and not dframe.Control & DFrame.PACKET_CONTROL_END_STREAM:
|
|
logger.debug("%s sent a DFRAME without having sent a CONNECT before. GTFO.", addr)
|
|
logger.debug("%s:%s > %s (DFRAME)", addr[0], addr[1], data.getvalue().hex())
|
|
return
|
|
|
|
if dframe.Control & DFrame.PACKET_CONTROL_END_STREAM:
|
|
logger.debug("%s:%s > %s (END_STREAM)", addr[0], addr[1], data.getvalue().hex())
|
|
if not session:
|
|
logger.error("Received a END STREAM packet for a non fully connected session")
|
|
session = Session(self.remotesocket)
|
|
session.ip = addr[0]
|
|
session.port = addr[1]
|
|
session.SessID = dframe.SessID
|
|
session.next_send = dframe.NRcv
|
|
session.next_expected_seq = dframe.Seq+1
|
|
|
|
session.send_cframe_sack()
|
|
resp = DFrame()
|
|
resp.Command = DFrame.PACKET_COMMAND_DATA | DFrame.PACKET_COMMAND_NEW_MSG | DFrame.PACKET_COMMAND_END_MSG | DFrame.PACKET_COMMAND_RELIABLE | DFrame.PACKET_COMMAND_SEQUENTIAL
|
|
resp.Control = DFrame.PACKET_CONTROL_END_STREAM
|
|
resp.Seq = dframe.NRcv
|
|
resp.NRcv = session.next_send
|
|
logger.debug(" %s:%s < %s (END_STREAM)", session.ip, session.port, resp.to_packet().getvalue().hex())
|
|
session.send(resp)
|
|
|
|
# TODO: broadcast session has disconnected
|
|
if self.get_session(addr):
|
|
self.addrs.remove(session)
|
|
|
|
return
|
|
|
|
if not dframe.Seq == session.next_expected_seq:
|
|
logger.error("%s unexpected SEQ. Got %s, expected %s", addr, dframe.Seq, session.next_expected_seq)
|
|
#return
|
|
|
|
|
|
if dframe.Control & DFrame.PACKET_CONTROL_KEEPALIVE_OR_CORRELATE:
|
|
pass
|
|
#session.send_dframe_keepalive()
|
|
|
|
if dframe.Command & DFrame.PACKET_COMMAND_POLL:
|
|
#logger.debug("Sending SACK")
|
|
session.send_cframe_sack()
|
|
pass
|
|
|
|
if session.next_expected_seq == 255:
|
|
session.next_expected_seq = 0
|
|
else:
|
|
session.next_expected_seq += 1
|
|
if dframe.Payload:
|
|
await self.handle_game_packet(session, dframe.Payload)
|
|
else:
|
|
pass
|
|
except Exception as e:
|
|
logger.error("Could not parse DFRAME: ")
|
|
traceback.print_exc()
|
|
return
|
|
|
|
async def handle_game_packet(self, session, payload):
|
|
player = self.get_temp_player(session)
|
|
logger.debug("%s:%s > %s (GAMEDATA)", session.ip, session.port, payload.hex())
|
|
#logger.debug("OPCODE: %s VALUES: %s", struct.pack("<B", payload[0]).hex(), payload[1:].hex())
|
|
#await self.server.broadcast_message("SENT OPCODE: %s VALUES: %s" % (struct.pack("<B", payload[0]).hex(), payload[1:].hex()))
|
|
|
|
if payload[0] == 0xc1:
|
|
if not player or not player.phase == PlayerPhases.CFRAME_CONNECTED:
|
|
logger.error("Fuck you. Playerphase was %s", player.phase)
|
|
return
|
|
# DN_INTERNAL_MESSAGE_PLAYER_CONNECT_INFO_EX
|
|
ppayload = Packet(payload)
|
|
dwPacketType = ppayload.getULong()
|
|
dwFlags = ppayload.getULong()
|
|
dwDNETVersion = ppayload.getULong()
|
|
dwNameOffset = ppayload.getULong()
|
|
dwNameSize = ppayload.getULong()
|
|
dwDataOffset = ppayload.getULong()
|
|
dwDataSize = ppayload.getULong()
|
|
dwPasswordOffset = ppayload.getULong()
|
|
dwPasswordSize = ppayload.getULong()
|
|
dwConnectDataOffset = ppayload.getULong()
|
|
dwConnectDataSize = ppayload.getULong()
|
|
dwURLOffset = ppayload.getULong()
|
|
dwURLSize = ppayload.getULong()
|
|
guidInstance = payload[52:68]
|
|
guidApplication = payload[68:84]
|
|
name = payload[dwNameOffset+4:dwNameOffset+2+dwNameSize]
|
|
name = name.decode("utf-16-le")
|
|
logger.debug("%s connected!", name)
|
|
player.name = name
|
|
#session.send_dframe_keepalive()
|
|
|
|
# Response: DN_MSG_INTERNAL_SEND_CONNECT_INFO
|
|
d = DN_MSG_INTERNAl_SEND_CONNECT_INFO(self, player)
|
|
d.Seq = session.next_send
|
|
d.NRcv = session.next_expected_seq
|
|
|
|
appdata = Packet()
|
|
appdata.putByte(0xff) # map ID
|
|
appdata.putByte(self.server.game_type) # game type
|
|
appdata.putByte(self.server.teams) # teams
|
|
appdata.write(b'\x00') # original: 0x00 - does not seem to affect client
|
|
appdata.putShort(int(self.server.version * 1000))
|
|
appdata.write(b'\x03\x90') # original: 0292 - does not seem to affect client
|
|
appdata.putShort(self.server.points_per_capture)
|
|
appdata.putShort(self.server.points_per_kill)
|
|
appdata.write(b'\x00\x00') # original: 0000 - does not seem to affect client
|
|
appdata.putShort(self.server.detente_time)
|
|
appdata.write(self.server.currentmap.checksum) # Seems to be a checksum of current map OR linked to the number of chars in the map name
|
|
appdata.write(self.server.currentmap.mapname.encode("ascii"))
|
|
appdata.write(b'\x00' * (32 - len(self.server.currentmap.mapname)))
|
|
d.ApplicationReservedData = appdata.getvalue()
|
|
session.send(d)
|
|
logger.debug("%s:%s > %s (GAMEDATA)", session.ip, session.port, appdata.getvalue().hex())
|
|
player.phase = PlayerPhases.DN_SEND_CONNECT_INFO
|
|
|
|
elif payload[0] == 0xc3:
|
|
player = self.get_temp_player(session)
|
|
if not player or not player.phase == PlayerPhases.DN_SEND_CONNECT_INFO:
|
|
return
|
|
|
|
player.phase = PlayerPhases.DN_ACK_CONNECT_INFO
|
|
await self.server.add_player(player)
|
|
await player.session.send_gamedata(b'\x3c'+struct.pack("<L", player.id)+b"\x00", acknow=True)
|
|
|
|
p1 = b'\x01' + struct.pack("<B", len(self.server.players))
|
|
for pplayer in self.server.players:
|
|
p1 += struct.pack("<L", pplayer.id)
|
|
for pplayer in self.server.players:
|
|
if pplayer.name == "[Server]":
|
|
continue
|
|
p1 += b'\x0e'
|
|
p1 += b"\x01\x00"
|
|
for pplayer in self.server.players:
|
|
if pplayer == player or pplayer.name == "[Server]":
|
|
continue
|
|
p1 += struct.pack("<B", pplayer.team)
|
|
p1 += b'\x00\x00'
|
|
|
|
await player.session.send_gamedata(p1, acknow=False)
|
|
#await player.session.send_gamedata(b'\x3d\x00\x5b\x53\x65\x72\x76\x65\x72\x5d'+b"\x00"*25, acknow=True) # [SERVER]
|
|
plid=0
|
|
for pplayer in self.server.players:
|
|
await player.session.send_gamedata(b'\x3d'+struct.pack("<B", plid)+pplayer.name.encode("ascii")+b"\x00"*(33-len(pplayer.name.encode("ascii"))), acknow=True) # playername
|
|
plid+=1
|
|
elif payload[0] == 0x0f:
|
|
player = self.get_player(session)
|
|
if not player:
|
|
logger.debug("Fuck that no player wtf man")
|
|
return
|
|
inc = Packet(payload)
|
|
opcode = inc.getByte()
|
|
playerid = inc.getULong()
|
|
status = inc.getULong()
|
|
padding = inc.getShort()
|
|
|
|
out = Packet()
|
|
out.putByte(opcode)
|
|
out.putULong(playerid)
|
|
out.putULong(status)
|
|
out.putShort(padding)
|
|
await player.session.send_gamedata(out.getvalue(), acknow=False)
|
|
|
|
elif payload[0] == 0x2c: # CMSG_CHANGE_TEAM: team (byte), player id (int), unknown (byte)
|
|
player = self.get_player(session)
|
|
if not player:
|
|
logger.debug("Fuck that no player wtf man")
|
|
return
|
|
|
|
p = Packet(payload)
|
|
opcode = p.getByte()
|
|
team = p.getByte()
|
|
playerid = p.getULong()
|
|
unknown = p.getByte()
|
|
|
|
await player.change_team(team % 128)
|
|
await self.server.broadcast_event("on_player_change_team", player, player.team)
|
|
elif payload[0] == 0x35: # CMSG_SEND_CHAT_MESSAGE: messagetype? (byte), team? (byte), message (string)
|
|
player = self.get_player(session)
|
|
if not player:
|
|
logger.debug("Fuck that no player wtf man")
|
|
return
|
|
|
|
p = Packet(payload)
|
|
opcode = p.getByte()
|
|
type = p.getByte()
|
|
team = p.getByte()
|
|
message = p.read().decode("utf8").replace("\x00", "")
|
|
await self.server.broadcast_event("on_player_chat", player, type, team, message)
|
|
|
|
elif payload[0] == 0x2a:
|
|
player = self.get_player(session)
|
|
if not player:
|
|
logger.debug("Fuck that no player wtf man")
|
|
return
|
|
# winning condition time limit
|
|
time_limit_minutes = 60 # 1 hour
|
|
await player.session.send_gamedata(b"\x29"+struct.pack("<H", time_limit_minutes)+b"\x00\x80"+(b"\x00"*17), acknow=True)
|
|
|
|
await player.session.send_gamedata(b"\x39"+(b"\x00"*21), acknow=False) # acknow=True
|
|
await player.session.send_gamedata(b"\x39\x01\x01\x01\x01"+(b"\x00"*17), acknow=True)
|
|
elif payload[0] == 0x0c:
|
|
player = self.get_player(session)
|
|
if not player:
|
|
logger.debug("Fuck that no player wtf man")
|
|
return
|
|
playerping = 1
|
|
await player.session.send_gamedata(b"\x2f\x02\x00\x00" + struct.pack("<H", playerping) + b"\x00", acknow=False) # acknow=True
|
|
for i in range(0x06):
|
|
ack = (i % 2 == 0)
|
|
await player.session.send_gamedata(b"\x04" + struct.pack("<B", i) + b"\x00\x00\x00\x00" + struct.pack("<B", i+0x07) + b"\x00\x00\x00",acknow=ack)
|
|
|
|
# needed to avoid crash after Loading textures
|
|
await player.session.send_gamedata(b"\x1a\xee\x02\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x83\x5f\xa4\x44\x00\xf9\xa3\xc2\x00\x00\x00\x00\xff\xff\x33\x43\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x9e\xdc\x07\x00", acknow=True)
|
|
|
|
# has something to do with the base build
|
|
await player.session.send_gamedata(b"\x19\x96\x03\x00\x10\x00\x00\x04\x00\x0d\x00\x00\x83\x5f\xa4\x44\x00\xf9\xa3\xc2\x00\x00\x00\x00\xff\xff\x33\x43\x00\x00\x7a\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00", acknow=False)
|
|
|
|
# useless?
|
|
await player.session.send_gamedata(b"\x39"+b"\x00"*21, acknow=True)
|
|
|
|
# useless? can be game status
|
|
await player.session.send_gamedata(b"\x39"+b"\x01"*4+b"\x00"*17, acknow=False)
|
|
|
|
# useless? can be game status
|
|
await player.session.send_gamedata(b"\x2e"+b"\x00"*9, acknow=True)
|
|
|
|
# useless? can be game status
|
|
await player.session.send_gamedata(b"\x3b\x00\x04\x00\x00\x00\x04\x00\x00\x00", acknow=False)
|
|
|
|
# useless?
|
|
await player.session.send_gamedata(b"\x3e\x00\x00\x00\x00\x00", acknow=True)
|
|
|
|
# useless?
|
|
await player.session.send_gamedata(b"\x3f\x00\x00", acknow=False)
|
|
|
|
# stuck in awaiting snapshot if not sent (could be the packet to go ingame?)
|
|
await player.session.send_gamedata(b"\x0e\x00", acknow=True)
|
|
|
|
# change team packet
|
|
await player.session.send_gamedata(b"\x10" + struct.pack("<B", player.team) + struct.pack("<L", player.id) + b"\x00\x00", acknow=False)
|
|
|
|
# spawn server as mecc
|
|
await player.session.send_gamedata(bytes.fromhex("05007300000200000000"), acknow=False)
|
|
await player.session.send_gamedata(bytes.fromhex("0a320000000073000001020000000000000000000000000000000000000000000000000000000000000000000000000000000a120000000073000003020000000000000000"), acknow=False)
|
|
|
|
# spawn Bot 1 as kab
|
|
#await player.session.send_gamedata(bytes.fromhex("05017400000100000000"), acknow=False)
|
|
#await player.session.send_gamedata(bytes.fromhex("0a320000000174000001010000000000000000000000000000000000000000000000000000000000000000000000000000000a120000000174000003020000000000000000"), acknow=False)
|
|
|
|
# spawn Bot 2 as reap
|
|
await player.session.send_gamedata(bytes.fromhex("05027500000300000000"), acknow=False)
|
|
await player.session.send_gamedata(bytes.fromhex("0a320000000275000001030000000000000000000000000000000000000000000000000000000000000000000000000000000a120000000275000003020000000000000000"), acknow=False)
|
|
|
|
# spawn Bot 3 as <id>
|
|
objid = "75"
|
|
plix = "01"
|
|
model = "4b"
|
|
#async def spawn(objid, plix, model):
|
|
# await player.session.send_gamedata(bytes.fromhex("05"+plix+objid+"0000"+model+"00000000"), acknow=False)
|
|
# await player.session.send_gamedata(bytes.fromhex("0a32000000"+plix+objid+"000001"+model+"0000000000000000000000000000000000000000000000000000000000000000000000000000000a12000000"+plix+objid+"0000"+model+"020000000000000000"), acknow=False)
|
|
#await spawn(objid, plix, model)
|
|
|
|
# makes one player change team
|
|
#await player.session.send_gamedata(bytes.fromhex("0f1c49e2450e0000000000"), acknow=False)
|
|
#await player.session.send_gamedata(bytes.fromhex("0f1e"+struct.pack("<L", player.id)+"0000000000"), acknow=False)
|
|
#await player.session.send_gamedata(bytes.fromhex("0f1e123456780000000000"), acknow=False)
|
|
|
|
await player.session.send_gamedata(bytes.fromhex("090f000000015500000a02000000ff090f000000015500000a0200000001090f000000015500000a020000000300"), acknow=False)
|
|
await player.session.send_gamedata(bytes.fromhex("2b0000000066fe954400"), acknow=False)
|
|
|
|
player.phase = PlayerPhases.INGAME
|
|
|
|
elif payload[0] == 0x0a and payload[1] == 0x32:
|
|
player = self.get_player(session)
|
|
if not player:
|
|
logger.debug("Fuck that no player wtf man")
|
|
return
|
|
p = Packet(payload)
|
|
opcode = p.getByte()
|
|
length = p.getByte() # length?
|
|
unknown1 = p.getByte()
|
|
unknown2 = p.getByte()
|
|
unknown3 = p.getByte()
|
|
playerindex = p.getByte()
|
|
objid = p.getShort()
|
|
unknown5 = p.getByte()
|
|
unknown6 = p.getByte()
|
|
model = p.getULong()
|
|
playerx = p.getFloat()
|
|
playery = p.getFloat()
|
|
playerz = p.getFloat()
|
|
unknown4 = p.getULong()
|
|
unknown5 = p.getULong()
|
|
unknown6 = p.getULong()
|
|
unknown7 = p.getULong()
|
|
orientation = p.getULong() # orientation
|
|
unknown9 = p.getULong()
|
|
|
|
player.x = playerx
|
|
player.y = playery
|
|
player.z = playerz
|
|
player.oid = objid
|
|
player.o = orientation
|
|
|
|
#logger.info("%s is now at coords (%s,%s,%s)", player.name, player.x, player.y, player.z)
|
|
await self.server.broadcast_message("%s is now at coords (%s,%s,%s, %s). Model: %s" % (player.name, player.x, player.y, player.z, player.o, model))
|
|
#await self.server.broadcast_message("(%s,%s,%s, %s,%s)" % (unknown4, unknown5, unknown6, unknown7, unknown9))
|
|
|
|
elif payload[0] == 0x3a:
|
|
# CLIENT EXITED
|
|
player = self.get_player(session)
|
|
if not player:
|
|
logger.debug("Fuck that no player wtf man")
|
|
return
|
|
|
|
await self.server.broadcast_event("on_player_left", player)
|
|
await self.server.remove_player(player)
|
|
elif payload[0] == 0x4d:
|
|
# CLIENT DOWNLOAD MAP
|
|
player = self.get_player(session)
|
|
if not player:
|
|
logger.debug("Fuck that no player wtf man")
|
|
return
|
|
|
|
payload = Packet()
|
|
payload.putByte(0x4e) # packet opcode
|
|
#payload.putByte(0x9d) # packet opcode?
|
|
|
|
mapsize = os.stat("maps/"+self.server.currentmap.mappath).st_size
|
|
payload.putULong(mapsize) # map size
|
|
payload.putBytes((self.server.currentmap.mapname+"\x00"*(128-len(self.server.currentmap.mapname))).encode("ascii"))
|
|
|
|
await player.session.send_gamedata(payload.getvalue())
|
|
|
|
with open("maps/"+self.server.currentmap.mappath, "rb") as fh:
|
|
data = fh.read(512)
|
|
while data != b"":
|
|
if len(data) == 512:
|
|
# full packet
|
|
mapdl = Packet()
|
|
mapdl.putByte(0x4f) # opcode
|
|
mapdl.putByte(0x00) # unknown
|
|
mapdl.putByte(0x02) # unknown
|
|
mapdl.putByte(0x00) # unknown
|
|
mapdl.putByte(0x00) # unknown
|
|
mapdl.putBytes(data)
|
|
mapdl.putByte(0x00) # ending
|
|
await player.session.send_gamedata(mapdl.getvalue(), acknow=False) # map chunk
|
|
else:
|
|
# last packet
|
|
mapdl = Packet()
|
|
mapdl.putByte(0x4f) # opcode
|
|
mapdl.putULong(len(data)) # map end length
|
|
mapdl.putBytes(data)
|
|
# fill with crap at the end
|
|
mapdl.putBytes(b"\x00"*(512-len(data)))
|
|
mapdl.putByte(0x00) # ending
|
|
await player.session.send_gamedata(mapdl.getvalue(), acknow=False) # map chunk
|
|
data = fh.read(512)
|
|
|
|
|
|
def send_packet(self, addr, packet):
|
|
self.remotesocket.sendto(packet.getvalue(), addr)
|
|
#logger.debug("%s:%s < %s", addr[0], addr[1], packet.getvalue().hex())
|
|
|
|
def get_session(self, iporaddr, port=None):
|
|
if not port:
|
|
return next((x for x in self.addrs if x.ip == iporaddr[0] and x.port == iporaddr[1]), None)
|
|
else:
|
|
return next((x for x in self.addrs if x.ip == iporaddr and x.port == port), None)
|
|
|
|
def get_player(self, iporaddr, port=None):
|
|
if type(iporaddr) == Session:
|
|
a = next((x for x in self.server.players if x.session.ip == iporaddr.ip and x.session.port == iporaddr.port), None)
|
|
if a:
|
|
return a
|
|
else:
|
|
return next((x for x in self.server.tempplayers if x.session.ip == iporaddr.ip and x.session.port == iporaddr.port),None)
|
|
if not port:
|
|
a = next((x for x in self.server.players if x.session.ip == iporaddr[0] and x.session.port == iporaddr[1]), None)
|
|
if a:
|
|
return a
|
|
else:
|
|
return next((x for x in self.server.tempplayers if x.session.ip == iporaddr[0] and x.session.port == iporaddr[1]),None)
|
|
else:
|
|
a = next((x for x in self.server.players if x.session.ip == iporaddr and x.session.port == port), None)
|
|
if a:
|
|
return a
|
|
else:
|
|
return next((x for x in self.server.tempplayers if x.session.ip == iporaddr and x.session.port == port), None)
|
|
|
|
def get_temp_player(self, iporaddr, port=None):
|
|
if type(iporaddr) == Session:
|
|
return next((x for x in self.server.tempplayers if x.session.ip == iporaddr.ip and x.session.port == iporaddr.port), None)
|
|
if not port:
|
|
return next((x for x in self.server.tempplayers if x.session.ip == iporaddr[0] and x.session.port == iporaddr[1]), None)
|
|
else:
|
|
return next((x for x in self.server.tempplayers if x.session.ip == iporaddr and x.session.port == port), None) |