mirror of
https://github.com/kuitoi/kuitoi-Server.git
synced 2026-02-16 02:20:52 +00:00
santaspeen
a923dbea1f
[+] Recreate config (if empty) [+] Hidden config [!] FIX rl [!] Update getting loop [-] core_player_set_id [~] Update copyrights [~] Minor
118 lines
4.3 KiB
Python
118 lines
4.3 KiB
Python
# Developed by KuiToi Dev
|
|
# File core.udp_server.py
|
|
# Written by: SantaSpeen
|
|
# Core version: 0.4.5
|
|
# Licence: FPA
|
|
# (c) kuitoi.su 2024
|
|
import asyncio
|
|
import json
|
|
|
|
from core import utils
|
|
|
|
|
|
# noinspection PyProtectedMember
|
|
class UDPServer(asyncio.DatagramTransport):
|
|
transport = None
|
|
|
|
def __init__(self, core, host=None, port=None):
|
|
super().__init__()
|
|
self.log = utils.get_logger("UDPServer")
|
|
self.loop = asyncio.get_event_loop()
|
|
self._core = core
|
|
self.host = host
|
|
self.port = port
|
|
self.run = False
|
|
|
|
def connection_made(self, *args, **kwargs): ...
|
|
def pause_writing(self, *args, **kwargs): ...
|
|
def resume_writing(self, *args, **kwargs): ...
|
|
|
|
async def handle_datagram(self, data, addr):
|
|
try:
|
|
cid = data[0] - 1
|
|
code = data[2:3].decode()
|
|
data = data[2:].decode()
|
|
|
|
client = self._core.get_client(cid=cid)
|
|
if client:
|
|
if not client.alive:
|
|
self.log.debug(f"{client.nick}:{cid} still sending UDP data: {data}")
|
|
match code:
|
|
case "p": # Ping packet
|
|
ev.call_event("onSentPing")
|
|
self.transport.sendto(b"p", addr)
|
|
case "Z": # Position packet
|
|
if client._udp_sock != (self.transport, addr):
|
|
client._udp_sock = (self.transport, addr)
|
|
self.log.debug(f"Set UDP Sock for CID: {cid}")
|
|
ev.call_event("onChangePosition", data=data)
|
|
sub = data.find("{", 1)
|
|
last_pos = data[sub:]
|
|
try:
|
|
_, car_id = client._get_cid_vid(data)
|
|
if client._cars[car_id]:
|
|
last_pos = json.loads(last_pos)
|
|
client._last_position = last_pos
|
|
client._cars[car_id]['pos'] = last_pos
|
|
except Exception as e:
|
|
self.log.warning(f"Cannot parse position packet: {e}")
|
|
self.log.debug(f"data: '{data}', sup: {sub}")
|
|
self.log.debug(f"last_pos ({type(last_pos)}): {last_pos}")
|
|
await client._send(data, to_all=True, to_self=False, to_udp=True)
|
|
case "X":
|
|
await client._send(data, to_all=True, to_self=False, to_udp=True)
|
|
case _:
|
|
self.log.warning(f" UDP [{cid}] Unknown code: {code}; {data}")
|
|
else:
|
|
self.log.debug(f"[{cid}] Client not found.")
|
|
|
|
except Exception as e:
|
|
self.log.error(f"Error handle_datagram: {e}")
|
|
|
|
def datagram_received(self, *args, **kwargs):
|
|
self.loop.create_task(self.handle_datagram(*args, **kwargs))
|
|
|
|
def connection_lost(self, exc):
|
|
if exc is not None and exc != KeyboardInterrupt:
|
|
self.log.debug(f'Connection raised: {exc}')
|
|
self.log.debug(f'Disconnected.')
|
|
|
|
def error_received(self, exc):
|
|
self.log.debug(f'error_received: {exc}')
|
|
self.log.exception(exc)
|
|
self.connection_lost(exc)
|
|
self.transport.close()
|
|
|
|
async def _start(self):
|
|
self.log.debug("Starting UDP server.")
|
|
while self._core.run:
|
|
try:
|
|
|
|
await asyncio.sleep(0.2)
|
|
|
|
d = UDPServer
|
|
self.transport, p = await self.loop.create_datagram_endpoint(
|
|
lambda: d(self._core),
|
|
local_addr=(self.host, self.port)
|
|
)
|
|
d.transport = self.transport
|
|
|
|
self.log.debug(f"UDP server started on {self.transport.get_extra_info('sockname')}")
|
|
|
|
self.run = True
|
|
while not self.transport.is_closing():
|
|
await asyncio.sleep(0.2)
|
|
|
|
except OSError as e:
|
|
# self.run = False
|
|
# self.Core.run = False
|
|
self.log.error(f"Cannot bind port or other error: {e}")
|
|
except Exception as e:
|
|
self.log.error(f"Error: {e}")
|
|
self.log.exception(e)
|
|
|
|
def _stop(self):
|
|
self.log.debug("Stopping UDP server")
|
|
if self.transport:
|
|
self.transport.close()
|