0.4.0 -> 0.4.1

Optimize getting car_id;
Minor fixes;

README.md

@@ -1,57 +1,67 @@
 # KuiToi-Server
 
 ## About
-**_[Status: Alpha]_** \
+**_[Status: Beta]_** \
 BeamingDrive Multiplayer (BeamMP) server compatible with BeamMP clients.
 
 ## TODOs
 
-- [ ] Server core
+- [x] Server core
   - [x] BeamMP System
     - [x] Private access (Without key, Direct connect)
     - [x] Public access  (With key, listing in Launcher)
     - [X] Player authentication
-  - [ ] KuiToi System
-    - [ ] Servers counter
-    - [ ] Players counter
-    - [ ] Etc.
-  - [ ] TCP Server part:
+  - [x] TCP Server part:
     - [x] Handle code
     - [x] Understanding BeamMP header
     - [x] Upload mods
     - [x] Connecting to the world
     - [x] Chat
     - [x] Players online counter
-    - [ ] Car state synchronizations _(Codes: We, Vi)_
-    - [ ] "ABG:" (compressed data)
+    - [x] Packets handled (Recursive finding second packet)
+    - [ ] Client events
+    - [x] Car synchronizations:
+      - [x] State packets
+      - [x] Spawn cars
+      - [x] Delete cars
+      - [x] Edit cars
+      - [x] Reset cars
+    - [x] "ABG:" (compressed data)
       - [x] Decompress data
-      - [ ] Vehicle data _(Code: Os)_
-  - [ ] UDP Server part:
-    - [ ] Players synchronizations _(Code: Zp)_
-    - [ ] Ping _(Code: p)_
+      - [x] Compress data
+  - [x] UDP Server part:
+    - [x] Ping
+    - [x] Position synchronizations
 - [x] Additional:
+  - [ ] KuiToi System
+    - [ ] Servers counter
+    - [ ] Players counter
+    - [ ] Etc.
   - [x] Logger
     - [x] Just logging
     - [x] Log in file
     - [x] Log history (.1.log, .2.log, ...)
   - [x] Console:
     - [x] Tabulation
-    - [x] _~~(By design)~~_ Static text (bug)
+    - [x] History
+    - [x] Autocomplete
   - [x] Events System
     - [x] Call events
     - [x] Create custom events
     - [x] Return from events
     - [x] Async support
+    - [ ] Add all events
   - [x] Plugins support
     - [ ] KuiToi class
+    - [ ] Client (Player) class
     - [x] Load Python plugins
     - [x] Async support
     - [ ] Load Lua plugins (Original BeamMP compatibility)
   - [x] MultiLanguage (i18n support)
-    - [x] Core
+    - [ ] Core
     - [x] Console
     - [x] WebAPI
-  - [x] HTTP API Server (fastapi)
+  - [ ] HTTP API Server (fastapi)
     - [x] Stop and Start with core
     - [x] Configure FastAPI logger
     - [ ] Sync with event system

src/core/Client.py

@@ -1,11 +1,13 @@
 # Developed by KuiToi Dev
 # File core.tcp_server.py
 # Written by: SantaSpeen
-# Core version: 0.2.3
+# Core version: 0.4.1
 # Licence: FPA
 # (c) kuitoi.su 2023
 import asyncio
+import json
 import math
+import time
 import zlib
 
 from core import utils
@@ -16,11 +18,14 @@ class Client:
     def __init__(self, reader, writer, core):
         self.__reader = reader
         self.__writer = writer
-        self._down_rw = (None, None)
         self.__Core = core
         self.__alive = True
+        self.__packets_queue = []
+        self.__tasks = []
+        self._down_sock = (None, None)
+        self._udp_sock = (None, None)
         self._loop = asyncio.get_event_loop()
-        self._log = utils.get_logger("client(None:0)")
+        self._log = utils.get_logger("player(None:0)")
         self._addr = writer.get_extra_info("sockname")
         self._cid = -1
         self._key = None
@@ -28,7 +33,9 @@ class Client:
         self.roles = None
         self._guest = True
         self._ready = False
-        self._cars = []
+        self._cars = [None] * 21  # Max 20 cars per player + 1 snowman
+        self._snowman = {"id": -1, "packet": ""}
+        self._connect_time = 0
 
     @property
     def _writer(self):
@@ -60,7 +67,7 @@ class Client:
 
     @property
     def cars(self):
-        return self.cars
+        return self._cars
 
     def _update_logger(self):
         self._log = utils.get_logger(f"{self.nick}:{self.cid}")
@@ -69,13 +76,11 @@ class Client:
     def is_disconnected(self):
         if not self.__alive:
             return True
-        res = self.__writer.is_closing()
-        if res:
-            self.log.debug(f"Disconnected.")
+        if self.__writer.is_closing():
+            self.log.debug(f"is_d: Disconnected.")
             self.__alive = False
             return True
         else:
-            self.log.debug(f"Alive.")
             self.__alive = True
             return False
 
@@ -85,9 +90,15 @@ class Client:
             return
         # TODO: i18n
         self.log.info(f"Kicked with reason: \"{reason}\"")
-        await self._send(b"K" + bytes(reason, "utf-8"))
+        await self._send(f"K{reason}")
         self.__alive = False
 
+    async def send_message(self, message, to_all=True):
+        pass
+
+    async def send_event(self, event_name, event_data):
+        pass
+
     async def _send(self, data, to_all=False, to_self=True, to_udp=False, writer=None):
 
         # TNetwork.cpp; Line: 383
@@ -97,10 +108,7 @@ class Client:
         #  size     data
 
         if type(data) == str:
-            data = bytes(data, "utf-8")
-
-        if writer is None:
-            writer = self.__writer
+            data = bytes(data, config.enc)
 
         if to_all:
             code = chr(data[0])
@@ -108,89 +116,129 @@ class Client:
                 if not client or (client is self and not to_self):
                     continue
                 if not to_udp or code in ['V', 'W', 'Y', 'E']:
-                    if code in ['O', 'T'] or len(data) > 1000:
-                        # TODO: Compress data
-                        await client._send(data)
-                    else:
-                        await client._send(data)
+                    await client._send(data)
                 else:
-                    # TODO: UDP send
-                    self.log.debug(f"UDP Part not ready: {code}")
+                    await client._send(data, to_udp=to_udp)
+            return
+
+        if not self.__alive:
+            return False
+
+        if writer is None:
+            writer = self.__writer
+
+        if len(data) > 400:
+            data = b"ABG:" + zlib.compress(data, level=zlib.Z_BEST_COMPRESSION)
+
+        if to_udp:
+            udp_sock = self._udp_sock[0]
+            udp_addr = self._udp_sock[1]
+            # self.log.debug(f'[UDP] len: {len(data)}; send: {data!r}')
+            if udp_sock and udp_addr:
+                try:
+                    if not udp_sock.is_closing():
+                        # self.log.debug(f'[UDP] {data!r}')
+                        udp_sock.sendto(data, udp_addr)
+                except OSError:
+                    self.log.debug("[UDP] Error sending")
+                except Exception as e:
+                    self.log.debug(f"[UDP] Error sending: {e}")
+                    self.log.exception(e)
             return
 
         header = len(data).to_bytes(4, "little", signed=True)
-        self.log.debug(f'len: {len(data)}; send: {header + data!r}')
+        # self.log.debug(f'[TCP] {header + data!r}')
         try:
             writer.write(header + data)
             await writer.drain()
+            return True
+
         except ConnectionError:
-            self.log.debug('tcp_send: Disconnected')
+            self.log.debug('[TCP] Disconnected')
             self.__alive = False
+            await self._remove_me()
+            return False
 
-    async def _recv(self):
-        try:
-            header = await self.__reader.read(4)
+    async def _recv(self, one=False):
+        while self.__alive:
+            try:
+                header = await self.__reader.read(4)
 
-            int_header = 0
-            for i in range(len(header)):
-                int_header += header[i]
+                int_header = int.from_bytes(header, byteorder='little', signed=True)
 
-            if int_header <= 0:
-                await asyncio.sleep(0.1)
-                self.is_disconnected()
-                if self.__alive:
-                    self.log.debug(f"Header: {header}")
-                    await self.kick("Invalid packet - header negative")
-                return b""
+                if int_header <= 0:
+                    await asyncio.sleep(0.1)
+                    self.is_disconnected()
+                    if self.__alive:
+                        if header == b"":
+                            self.__packets_queue.append(None)
+                            self.__alive = False
+                            continue
+                        self.log.error(f"Header: {header}")
+                        await self.kick("Invalid packet - header negative")
+                    self.__packets_queue.append(None)
+                    continue
 
-            if int_header > 100 * MB:
-                await self.kick("Header size limit exceeded")
-                self.log.warn(f"Client {self.nick}:{self.cid} sent header of >100MB - "
-                              f"assuming malicious intent and disconnecting the client.")
-                return b""
+                if int_header > 100 * MB:
+                    await self.kick("Header size limit exceeded")
+                    self.log.warning("Client sent header of >100MB - "
+                                     "assuming malicious intent and disconnecting the client.")
+                    self.log.error(f"Last recv: {await self.__reader.read(100 * MB)}")
+                    self.__packets_queue.append(None)
+                    continue
 
-            data = await self.__reader.read(100 * MB)
-            self.log.debug(f"header: `{header}`; int_header: `{int_header}`; data: `{data}`;")
+                data = await self.__reader.read(int_header)
 
-            if len(data) != int_header:
-                self.log.debug(f"WARN Expected to read {int_header} bytes, instead got {len(data)}")
+                # self.log.debug(f"int_header: {int_header}; data: `{data}`;")
+                abg = b"ABG:"
+                if len(data) > len(abg) and data.startswith(abg):
+                    data = zlib.decompress(data[len(abg):])
+                    # self.log.debug(f"ABG Packet: {len(data)}")
 
-            abg = b"ABG:"
-            if len(data) > len(abg) and data.startswith(abg):
-                data = zlib.decompress(data[len(abg):])
-                self.log.debug(f"ABG: {data}")
-                return data
-            return data
-        except ConnectionError:
-            self.__alive = False
-            return b""
+                if one:
+                    return data
+                self.__packets_queue.append(data)
 
-    async def _split_load(self, start, end, d_sock, filename):
-        # TODO: Speed  limiter
+            except ConnectionError:
+                self.__alive = False
+                self.__packets_queue.append(None)
+
+    async def _split_load(self, start, end, d_sock, filename, speed_limit=None):
         real_size = end - start
-        writer = self._down_rw[1] if d_sock else self.__writer
+        writer = self._down_sock[1] if d_sock else self.__writer
         who = 'dwn' if d_sock else 'srv'
-        if config.Server["debug"]:
-            self.log.debug(f"[{who}] Real size: {real_size / MB}mb; {real_size == end}, {real_size * 2 == end}")
+        self.log.debug(f"[{who}] Real size: {real_size / MB}mb; {real_size == end}, {real_size * 2 == end}")
 
         with open(filename, 'rb') as f:
             f.seek(start)
-            data = f.read(end)
-            try:
-                writer.write(data)
-                await writer.drain()
-                self.log.debug(f"[{who}] File sent.")
-            except ConnectionError:
-                self.__alive = False
-                self.log.debug(f"[{who}] Disconnected.")
-        return real_size
+            total_sent = 0
+            start_time = time.monotonic()
+            while total_sent < real_size:
+                data = f.read(min(MB, real_size - total_sent))  # read data in chunks of 1MB or less
+                try:
+                    writer.write(data)
+                    await writer.drain()
+                    self.log.debug(f"[{who}] Sent {len(data)} bytes.")
+                except ConnectionError:
+                    self.__alive = False
+                    self.log.debug(f"[{who}] Disconnected.")
+                    break
+                total_sent += len(data)
+
+                # Calculate delay based on speed limit
+                if speed_limit:
+                    elapsed_time = time.monotonic() - start_time
+                    expected_time = total_sent / (speed_limit * MB)
+                    if expected_time > elapsed_time:
+                        await asyncio.sleep(expected_time - elapsed_time)
+
+        return total_sent
 
     async def _sync_resources(self):
         while self.__alive:
-            data = await self._recv()
-            self.log.debug(f"data: {data!r}")
+            data = await self._recv(True)
             if data.startswith(b"f"):
-                file = data[1:].decode("utf-8")
+                file = data[1:].decode(config.enc)
                 # TODO: i18n
                 self.log.info(f"Requested mode: {file!r}")
                 size = -1
@@ -208,19 +256,34 @@ class Client:
                     return
                 await self._send(b"AG")
                 t = 0
-                while not self._down_rw[0]:
+                while not self._down_sock[0]:
                     await asyncio.sleep(0.1)
                     t += 1
                     if t > 50:
                         await self.kick("Missing download socket")
                         return
-
+                if config.Options['use_queue']:
+                    while self.__Core.lock_upload:
+                        await asyncio.sleep(.2)
+                    self.__Core.lock_upload = True
+                speed = config.Options["speed_limit"]
+                if speed:
+                    speed = speed / 2
                 half_size = math.floor(size / 2)
+                t = time.monotonic()
                 uploads = [
-                    self._split_load(0, half_size, False, file),
-                    self._split_load(half_size, size, True, file)
+                    self._split_load(0, half_size, False, file, speed),
+                    self._split_load(half_size, size, True, file, speed)
                 ]
                 sl0, sl1 = await asyncio.gather(*uploads)
+                tr = time.monotonic() - t
+                if self.__Core.lock_upload:
+                    self.__Core.lock_upload = False
+                # TODO: i18n
+                msg = f"Mod sent: Size {round(size / MB, 3)}mb Speed {math.ceil(size / tr / MB)}Mb/s ({int(tr)}s)"
+                if speed:
+                    msg += f" of limit {int(speed * 2)}Mb/s"
+                self.log.info(msg)
                 sent = sl0 + sl1
                 ok = sent == size
                 lost = size - sent
@@ -228,7 +291,7 @@ class Client:
                 if not ok:
                     self.__alive = False
                     # TODO: i18n
-                    self.log.error(f"Error while sending.")
+                    self.log.error(f"Error while sending: {file!r}")
                     return
             elif data.startswith(b"SR"):
                 path_list = ''
@@ -243,105 +306,309 @@ class Client:
                 if len(mod_list) == 0:
                     await self._send(b"-")
                 else:
-                    await self._send(bytes(mod_list, "utf-8"))
+                    await self._send(mod_list)
             elif data == b"Done":
-                await self._send(b"M/levels/" + bytes(config.Game['map'], 'utf-8') + b"/info.json")
+                await self._send(f"M/levels/{config.Game['map']}/info.json")
                 break
         return
 
-    async def _looper(self):
-        await self._send(b"P" + bytes(f"{self.cid}", "utf-8"))  # Send clientID
-        await self._sync_resources()
-        while self.__alive:
-            data = await self._recv()
-            if not data:
-                self.__alive = False
-                break
+    def _get_cid_vid(self, data: str):
+        sep = data.find(":", 1) + 1
+        s = data[sep:sep + 3]
+        id_sep = s.find('-')
+        if id_sep == -1:
+            self.log.debug(
+                f"Invalid packet: Could not parse pid/vid from packet, as there is no '-' separator: '{data}'")
+            return -1, -1
+        cid = s[:id_sep]
+        vid = s[id_sep + 1:]
+        if cid.isdigit() and vid.isdigit():
+            try:
+                cid = int(cid)
+                vid = int(vid)
+                return cid, vid
+            except ValueError:
+                self.log.debug(f"Invalid packet: Could not parse cid/vid from packet, as one or both are not valid "
+                               f"numbers: '{s}'")
+                return -1, -1
+        self.log.debug(f"Invalid packet: Could not parse pid/vid from packet: '{data}'")
+        return -1, -1
 
-            # V to Y
-            if 89 >= data[0] >= 86:
+    async def _spawn_car(self, data):
+        car_data = data[2:]
+        car_id = next((i for i, car in enumerate(self.cars) if car is None), len(self.cars))
+        cars_count = len(self.cars) - self.cars.count(None)
+        if self._snowman['id'] != -1:
+            cars_count -= 1  # -1 for unicycle
+        self.log.debug(f"car_id={car_id}, cars_count={cars_count}")
+        car_json = {}
+        try:
+            car_json = json.loads(car_data[car_data.find("{"):])
+        except Exception as e:
+            self.log.debug(f"Invalid car_json: Error: {e}; Data: {car_data}")
+        allow = True
+        allow_snowman = True
+        over_spawn = False
+        ev_data_list = ev.call_event("onCarSpawn", car=car_json, car_id=car_id, player=self)
+        d2 = await ev.call_async_event("onCarSpawn", car=car_json, car_id=car_id, player=self)
+        ev_data_list.extend(d2)
+        for ev_data in ev_data_list:
+            # TODO: handle event onCarSpawn
+            pass
+        pkt = f"Os:{self.roles}:{self.nick}:{self.cid}-{car_id}:{car_data}"
+        snowman = car_json.get("jbm") == "unicycle"
+        if allow and config.Game['max_cars'] > cars_count or (snowman and allow_snowman) or over_spawn:
+            if snowman:
+                unicycle_id = self._snowman['id']
+                if unicycle_id != -1:
+                    self.log.debug(f"Delete old unicycle: unicycle_id={unicycle_id}")
+                    self._cars[unicycle_id] = None
+                    await self._send(f"Od:{self.cid}-{unicycle_id}", to_all=True, to_self=True)
+                self._snowman = {"id": car_id, "packet": pkt}
+                self.log.debug(f"Unicycle spawn accepted: car_id={car_id}")
+            else:
+                self.log.debug(f"Car spawn accepted: car_id={car_id}")
+            self._cars[car_id] = {
+                "packet": pkt,
+                "json": car_json,
+                "json_ok": bool(car_json),
+                "snowman": snowman,
+                "over_spawn": (snowman and allow_snowman) or over_spawn
+            }
+            await self._send(pkt, to_all=True, to_self=True)
+        else:
+            await self._send(pkt)
+            des = f"Od:{self.cid}-{car_id}"
+            await self._send(des)
+
+    async def _delete_car(self, raw_data):
+        cid, car_id = self._get_cid_vid(raw_data)
+
+        if car_id != -1 and self.cars[car_id]:
+
+            admin_allow = False  # Delete from admin, for example...
+            ev_data_list = ev.call_event("onCarDelete", car=self.cars[car_id], car_id=car_id, player=self)
+            d2 = await ev.call_async_event("onCarDelete", car=self.cars[car_id], car_id=car_id, player=self)
+            ev_data_list.extend(d2)
+            for ev_data in ev_data_list:
+                # TODO: handle event onCarDelete
+                pass
+
+            if cid == self.cid or admin_allow:
+                await self._send(raw_data, to_all=True, to_self=True)
+                car = self.cars[car_id]
+                if car['snowman']:
+                    self.log.debug(f"Snowman found")
+                    unicycle_id = self._snowman['id']
+                    self._snowman['id'] = -1
+                    self._cars[unicycle_id] = None
+                self._cars[car_id] = None
+                await self._send(f"Od:{self.cid}-{car_id}", to_all=True, to_self=True)
+                self.log.debug(f"Deleted car: car_id={car_id}")
+
+        else:
+            self.log.debug(f"Invalid car: car_id={car_id}")
+
+    async def _edit_car(self, raw_data, data):
+        cid, car_id = self._get_cid_vid(raw_data)
+        if car_id != -1 and self.cars[car_id]:
+            client = self.__Core.get_client(cid=cid)
+            if client:
+                car = client.cars[car_id]
+                new_car_json = {}
+                try:
+                    new_car_json = json.loads(data[data.find("{"):])
+                except Exception as e:
+                    self.log.debug(f"Invalid new_car_json: Error: {e}; Data: {data}")
+
+                allow = False
+                admin_allow = False
+                ev_data_list = ev.call_event("onCarEdited", car=new_car_json, car_id=car_id, player=self)
+                d2 = await ev.call_async_event("onCarEdited", car=new_car_json, car_id=car_id, player=self)
+                ev_data_list.extend(d2)
+                for ev_data in ev_data_list:
+                    # TODO: handle event onCarEdited
+                    pass
+
+                if cid == self.cid or allow or admin_allow:
+                    if car['snowman']:
+                        unicycle_id = self._snowman['id']
+                        self._snowman['id'] = -1
+                        self.log.debug(f"Delete snowman")
+                        await self._send(f"Od:{self.cid}-{unicycle_id}", to_all=True, to_self=True)
+                        self._cars[unicycle_id] = None
+                    else:
+                        await self._send(raw_data, to_all=True, to_self=False)
+                        if car['json_ok']:
+                            old_car_json = car['json']
+                            old_car_json.update(new_car_json)
+                            car['json'] = old_car_json
+                        self.log.debug(f"Updated car: car_id={car_id}")
+        else:
+            self.log.debug(f"Invalid car: car_id={car_id}")
+
+    async def _reset_car(self, raw_data):
+        cid, car_id = self._get_cid_vid(raw_data)
+        if car_id != -1 and cid == self.cid and self.cars[car_id]:
+            await self._send(raw_data, to_all=True, to_self=False)
+            ev.call_event("onCarReset", car=self.cars[car_id], car_id=car_id, player=self)
+            await ev.call_async_event("onCarReset", car=self.cars[car_id], car_id=car_id, player=self)
+            self.log.debug(f"Car reset: car_id={car_id}")
+        else:
+            self.log.debug(f"Invalid car: car_id={car_id}")
+
+    async def _handle_car_codes(self, raw_data):
+        if len(raw_data) < 6:
+            return
+        sub_code = raw_data[1]
+        data = raw_data[3:]
+        match sub_code:
+            case "s":  # Spawn car
+                self.log.debug("Trying to spawn car")
+                if data[0] == "0":
+                    await self._spawn_car(data)
+
+            case "d":  # Delete car
+                self.log.debug("Trying to delete car")
+                await self._delete_car(raw_data)
+
+            case "c":  # Edit car
+                self.log.debug("Trying to edit car")
+                await self._edit_car(raw_data, data)
+
+            case "r":  # Reset car
+                self.log.debug("Trying to reset car")
+                await self._reset_car(raw_data)
+
+            case "t":  # Broken details
+                self.log.debug(f"Something changed/broken: {raw_data}")
+                await self._send(raw_data, to_all=True, to_self=False)
+
+            case "m":  # Move focus cat
+                self.log.debug(f"Move focus to: {raw_data}")
+                await self._send(raw_data, to_all=True, to_self=True)
+
+    async def _connected_handler(self):
+        self.log.info(f"Syncing time: {round(time.monotonic() - self._connect_time, 2)}s")
+        # Client connected
+        ev.call_event("onPlayerJoin", player=self)
+        await ev.call_async_event("onPlayerJoin", player=self)
+
+        await self._send(f"Sn{self.nick}", to_all=True)  # I don't know for what it
+        await self._send(f"JWelcome {self.nick}!", to_all=True)  # Hello message
+        self._ready = True
+
+        for client in self.__Core.clients:
+            if not client:
+                continue
+            for car in client.cars:
+                if not car:
+                    continue
+                await self._send(car['packet'])
+
+    async def _chat_handler(self, data):
+        sup = data.find(":", 2)
+        if sup == -1:
+            await self._send("C:Server: Invalid message.")
+        msg = data[sup + 2:]
+        if not msg:
+            self.log.debug("Tried to send an empty event, ignoring")
+            return
+        to_ev = {"message": msg, "player": self}
+        ev_data_list = ev.call_event("onChatReceive", **to_ev)
+        d2 = await ev.call_async_event("onChatReceive", **to_ev)
+        ev_data_list.extend(d2)
+        need_send = True
+        for ev_data in ev_data_list:
+            try:
+                message = ev_data["message"]
+                to_all = ev_data.get("to_all")
+                if to_all is None:
+                    to_all = True
+                to_self = ev_data.get("to_self")
+                if to_self is None:
+                    to_self = True
+                to_client = ev_data.get("to_client")
+                writer = None
+                if to_client:
+                    # noinspection PyProtectedMember
+                    writer = to_client._writer
+                self.log.info(f"{message}" if to_all else f"{self.nick}: {msg}")
+                await self._send(f"C:{message}", to_all=to_all, to_self=to_self, writer=writer)
+                need_send = False
+            except KeyError | AttributeError:
+                self.log.error(f"Returns invalid data: {ev_data}")
+        if need_send:
+            self.log.info(f"{self.nick}: {msg}")
+            await self._send(data, to_all=True)
+
+    async def _handle_codes(self, data):
+        if not data:
+            self.__alive = False
+            return
+
+        # Codes: V W X Y
+        if 89 >= data[0] >= 86:
+            await self._send(data, to_all=True, to_self=False)
+            return
+
+        try:
+            data = data.decode()
+        except UnicodeDecodeError:
+            self.log.error(f"UnicodeDecodeError: {data}")
+            return
+
+        # Codes: p, Z in udp_server.py
+        match data[0]:  # At data[0] code
+            case "H":  # Map load, client ready
+                await self._connected_handler()
+
+            case "C":  # Chat handler
+                await self._chat_handler(data)
+
+            case "O":  # Cars handler
+                await self._handle_car_codes(data)
+
+            case "E":  # Client events handler
+                # TODO: Handle events from client
+                pass
+
+            case "N":
                 await self._send(data, to_all=True, to_self=False)
 
-            code = chr(data[0])
-            self.log.debug(f"Received code: {code}, data: {data}")
-            match code:
-                case "H":
-                    # Client connected
-
-                    ev.call_event("player_join", player=self)
-                    await ev.call_async_event("player_join", player=self)
-
-                    await self._send(f"Sn{self.nick}", to_all=True)  # I don't know for what it
-                    await self._send(f"JWelcome {self.nick}!", to_all=True)  # Hello message
-                    self._ready = True
-
-                    # TODO: Sync cars
-                    # for client in self.__Core.clients:
-                    #     for car in client.cars:
-                    #         await self._tcp_send(car)
-
-                case "C":
-                    # Chat
-                    msg = data.decode()[4 + len(self.nick):]
-                    if not msg:
-                        self.log.debug("Tried to send an empty event, ignoring")
-                        continue
-                    self.log.info(f"Received message: {msg}")
-                    # TODO: Handle chat event
-                    to_ev = {"message": msg, "player": self}
-                    ev_data_list = ev.call_event("chat_receive", **to_ev)
-                    d2 = await ev.call_async_event("chat_receive", **to_ev)
-                    ev_data_list.extend(d2)
-                    need_send = True
-                    for ev_data in ev_data_list:
-                        try:
-                            message = ev_data["message"]
-                            to_all = ev_data.get("to_all")
-                            if to_all is None:
-                                if need_send:
-                                    need_send = False
-                                to_all = True
-                            if to_all:
-                                if need_send:
-                                    need_send = False
-                            to_self = ev_data.get("to_self")
-                            if to_self is None:
-                                to_self = True
-                            to_client = ev_data.get("to_client")
-                            writer = None
-                            if to_client:
-                                writer = to_client._writer
-                            await self._send(f"C:{message}", to_all=to_all, to_self=to_self, writer=writer)
-                        except KeyError | AttributeError:
-                            self.log.error(f"Returns invalid data: {ev_data}")
-                    if need_send:
-                        await self._send(data, to_all=True)
-
-                case "O":
-                    # TODO: ParseVehicle
-                    pass
-
-                case "E":
-                    # TODO: HandleEvent
-                    pass
-
-                case "N":
-                    # TODO: N
-                    pass
-
-                case _:
-                    pass
+    async def _looper(self):
+        self._connect_time = time.monotonic()
+        await self._send(f"P{self.cid}")  # Send clientID
+        await self._sync_resources()
+        tasks = self.__tasks
+        recv = asyncio.create_task(self._recv())
+        tasks.append(recv)
+        while self.__alive:
+            if len(self.__packets_queue) > 0:
+                for index, packet in enumerate(self.__packets_queue):
+                    # self.log.debug(f"Packet: {packet}")
+                    del self.__packets_queue[index]
+                    task = self._loop.create_task(self._handle_codes(packet))
+                    tasks.append(task)
+            else:
+                await asyncio.sleep(0.1)
+        await asyncio.gather(*tasks)
 
     async def _remove_me(self):
         await asyncio.sleep(0.3)
         self.__alive = False
         if (self.cid > 0 or self.nick is not None) and \
                 self.__Core.clients_by_nick.get(self.nick):
-            # if self.ready:
-            #     await self.tcp_send(b"", to_all=True)  # I'm disconnected.
-            self.log.debug(f"Removing client {self.nick}:{self.cid}")
+            for i, car in enumerate(self.cars):
+                if not car:
+                    continue
+                self.log.debug(f"Removing car: car_id={i}")
+                await self._send(f"Od:{self.cid}-{i}", to_all=True, to_self=False)
+            if self.ready:
+                await self._send(f"J{self.nick} disconnected!", to_all=True, to_self=False)  # I'm disconnected.
+            self.log.debug(f"Removing client")
             # TODO: i18n
-            self.log.info("Disconnected")
+            self.log.info(f"Disconnected, online time: {round((time.monotonic() - self._connect_time) / 60, 2)}min.")
             self.__Core.clients[self.cid] = None
             self.__Core.clients_by_id.pop(self.cid)
             self.__Core.clients_by_nick.pop(self.nick)
@@ -353,7 +620,7 @@ class Client:
         except Exception as e:
             self.log.debug(f"Error while closing writer: {e}")
         try:
-            _, down_w = self._down_rw
+            _, down_w = self._down_sock
             if down_w and not down_w.is_closing():
                 down_w.close()
         except Exception as e:

src/core/Client.pyi

@@ -1,13 +1,13 @@
 # Developed by KuiToi Dev
 # File core.tcp_server.py
 # Written by: SantaSpeen
-# Core version: 0.2.3
+# Core version: 0.4.1
 # Licence: FPA
 # (c) kuitoi.su 2023
 import asyncio
-from asyncio import StreamReader, StreamWriter
+from asyncio import StreamReader, StreamWriter, DatagramTransport
 from logging import Logger
-from typing import Tuple
+from typing import Tuple, List, Dict, Optional, Union
 
 from core import Core, utils
 
@@ -15,13 +15,17 @@ from core import Core, utils
 class Client:
 
     def __init__(self, reader: StreamReader, writer: StreamWriter, core: Core) -> "Client":
+        self._connect_time: float = 0.0
+        self.__tasks = []
         self.__reader = reader
         self.__writer = writer
-        self._down_rw: Tuple[StreamReader, StreamWriter] | Tuple[None, None] = (None, None)
+        self.__packets_queue = []
+        self._udp_sock: Tuple[DatagramTransport | None, Tuple[str, int] | None] = (None, None)
+        self._down_sock: Tuple[StreamReader | None, StreamWriter | None] = (None, None)
         self._log = utils.get_logger("client(id: )")
-        self._addr = writer.get_extra_info("sockname")
+        self._addr: Tuple[str, int] = writer.get_extra_info("sockname")
         self._loop = asyncio.get_event_loop()
-        self.__Core = core
+        self.__Core: Core = core
         self._cid: int = -1
         self._key: str = None
         self.nick: str = None
@@ -29,6 +33,9 @@ class Client:
         self._guest = True
         self.__alive = True
         self._ready = False
+        self._cars: List[Optional[Dict[str, int]]] = []
+        self._snowman: Dict[str, Union[int, str]]  = {"id": -1, "packet": ""}
+
     @property
     def _writer(self) -> StreamWriter: ...
     @property
@@ -43,12 +50,25 @@ class Client:
     def guest(self) -> bool: ...
     @property
     def ready(self) -> bool: ...
+    @property
+    def cars(self) -> List[dict | None]: ...
     def is_disconnected(self) -> bool: ...
     async def kick(self, reason: str) -> None: ...
+    async def send_message(self, message: str | bytes, to_all: bool = True) -> None:...
+    async def send_event(self, event_name: str, event_data: str) -> None: ...
     async def _send(self, data: bytes | str, to_all: bool = False, to_self: bool = True, to_udp: bool = False, writer: StreamWriter = None) -> None: ...
     async def _sync_resources(self) -> None: ...
-    async def _recv(self) -> bytes: ...
-    async def _split_load(self, start: int, end: int, d_sock: bool, filename: str) -> None: ...
+    async def _recv(self, one=False) -> bytes | None: ...
+    async def _split_load(self, start: int, end: int, d_sock: bool, filename: str, sl: float) -> None: ...
+    async def _get_cid_vid(self, s: str) -> Tuple[int, int]: ...
+    async def _spawn_car(self, data: str) -> None: ...
+    async def _delete_car(self, raw_data: str) -> None: ...
+    async def _edit_car(self, raw_data: str, data: str) -> None: ...
+    async def _reset_car(self, raw_data: str) -> None: ...
+    async def _handle_car_codes(self, data: str) -> None: ...
+    async def _connected_handler(self) -> None: ...
+    async def _chat_handler(self, data: str) -> None: ...
+    async def _handle_codes(self, data: bytes) -> None: ...
     async def _looper(self) -> None: ...
     def _update_logger(self) -> None: ...
     async def _remove_me(self) -> None: ...

src/core/__init__.py

@@ -2,7 +2,7 @@
 # File core.__init__.py
 # Written by: SantaSpeen
 # Version 1.3
-# Core version: 0.2.3
+# Core version: 0.4.1
 # Licence: FPA
 # (c) kuitoi.su 2023
 # Special thanks to: AI Sage(https://poe.com/Sage), AI falcon-40b-v7(https://OpenBuddy.ai)
@@ -10,8 +10,8 @@
 __title__ = 'KuiToi-Server'
 __description__ = 'BeamingDrive Multiplayer server compatible with BeamMP clients.'
 __url__ = 'https://github.com/kuitoi/kuitoi-Server'
-__version__ = '0.2.3'
-__build__ = 1208  # Я это считаю лог файлами
+__version__ = '0.4.1'
+__build__ = 1486  # Я это считаю лог файлами
 __author__ = 'SantaSpeen'
 __author_email__ = 'admin@kuitoi.su'
 __license__ = "FPA"
@@ -46,17 +46,17 @@ if args.config:
 config_provider = ConfigProvider(config_path)
 config = config_provider.open_config()
 builtins.config = config
-if config.Server['debug'] is True:
+config.enc = config.Options['encoding']
+if config.Options['debug'] is True:
     utils.set_debug_status()
     log.info("Debug enabled!")
     log = get_logger("core.init")
     log.debug("Debug mode enabled!")
     log.debug(f"Server config: {config}")
-
 # i18n init
 log.debug("Initializing i18n...")
 ml = MultiLanguage()
-ml.set_language(args.language or config.Server['language'])
+ml.set_language(args.language or config.Options['language'])
 ml.builtins_hook()
 
 log.debug("Initializing EventsSystem...")

src/core/core.py

@@ -1,7 +1,7 @@
 # Developed by KuiToi Dev
 # File core.core.py
 # Written by: SantaSpeen
-# Version: 0.2.3
+# Version: 0.4.1
 # Licence: FPA
 # (c) kuitoi.su 2023
 import asyncio
@@ -20,6 +20,7 @@ from modules import PluginsLoader
 from modules.WebAPISystem import app as webapp
 
 
+# noinspection PyProtectedMember
 class Core:
 
     def __init__(self):
@@ -40,8 +41,10 @@ class Core:
         self.web_pool = webapp.data_pool
         self.web_stop = None
 
+        self.lock_upload = False
+
         self.client_major_version = "2.0"
-        self.BeamMP_version = "3.2.0"
+        self.BeamMP_version = "3.1.1"  # 20.07.2023
 
         ev.register_event("get_player", self.get_client)
 
@@ -85,7 +88,7 @@ class Core:
         for client in self.clients:
             if not client:
                 continue
-            out += f"{client._nick}"
+            out += f"{client.nick}"
             if need_cid:
                 out += f":{client.cid}"
             out += ","
@@ -95,16 +98,20 @@ class Core:
 
     async def check_alive(self):
         maxp = config.Game['players']
-        while self.run:
-            await asyncio.sleep(1)
-            ca = f"Ss{len(self.clients_by_id)}/{maxp}:{self.get_clients_list()}"
-            for client in self.clients:
-                if not client:
-                    continue
-                if not client.ready:
-                    client.is_disconnected()
-                    continue
-                await client._send(bytes(ca, "utf-8"))
+        try:
+            while self.run:
+                await asyncio.sleep(1)
+                ca = f"Ss{len(self.clients_by_id)}/{maxp}:{self.get_clients_list()}"
+                for client in self.clients:
+                    if not client:
+                        continue
+                    if not client.ready:
+                        client.is_disconnected()
+                        continue
+                    await client._send(ca)
+        except Exception as e:
+            self.log.error("Error in check_alive.")
+            self.log.exception(e)
 
     @staticmethod
     def start_web():
@@ -141,10 +148,10 @@ class Core:
         modstotal = len(self.mods_list) - 1
         while self.run:
             try:
-                data = {"uuid": config.Auth["key"], "players": len(self.clients), "maxplayers": config.Game["players"],
-                        "port": config.Server["server_port"], "map": f"/levels/{config.Game['map']}/info.json",
-                        "private": config.Auth['private'], "version": self.BeamMP_version,
-                        "clientversion": self.client_major_version,
+                data = {"uuid": config.Auth["key"], "players": len(self.clients_by_id),
+                        "maxplayers": config.Game["players"], "port": config.Server["server_port"],
+                        "map": f"/levels/{config.Game['map']}/info.json", "private": config.Auth['private'],
+                        "version": self.BeamMP_version, "clientversion": self.client_major_version,
                         "name": config.Server["name"], "modlist": modlist, "modstotalsize": modstotalsize,
                         "modstotal": modstotal, "playerslist": "", "desc": config.Server['description'], "pass": False}
                 self.log.debug(f"Auth: data {data}")
@@ -188,13 +195,12 @@ class Core:
                             self.direct = True
                 else:
                     self.direct = True
-                    if test:
-                        self.log.error("Cannot auth...")
-                    if not config.Auth['private']:
-                        raise KeyboardInterrupt
                     if test:
                         # TODO: i18n
+                        self.log.error("Cannot authenticate server.")
                         self.log.info(f"Server still runnig, but only in Direct connect mode.")
+                    # if not config.Auth['private']:
+                    #     raise KeyboardInterrupt
 
                 if test:
                     return ok
@@ -251,7 +257,7 @@ class Core:
                 self.clients.append(None)
             tasks = []
             # self.udp.start,
-            f_tasks = [self.tcp.start, console.start, self.stop_me, self.heartbeat, self.check_alive]
+            f_tasks = [self.tcp.start, self.udp._start, console.start, self.stop_me, self.heartbeat, self.check_alive]
             for task in f_tasks:
                 tasks.append(asyncio.create_task(task()))
             t = asyncio.wait(tasks, return_when=asyncio.FIRST_EXCEPTION)
@@ -260,8 +266,8 @@ class Core:
 
             self.run = True
             self.log.info(i18n.start)
-            ev.call_event("server_started")
-            await ev.call_async_event("server_started")
+            ev.call_event("onServerStarted")
+            await ev.call_async_event("onServerStarted")
             await t  # Wait end.
         except KeyboardInterrupt:
             pass
@@ -271,15 +277,15 @@ class Core:
         finally:
             self.run = False
             self.tcp.stop()
-            # self.udp.stop()
+            self.udp._stop()
             await self.stop()
 
     def start(self):
         asyncio.run(self.main())
 
     async def stop(self):
-        ev.call_event("server_stopped")
-        await ev.call_async_event("server_stopped")
+        ev.call_event("onServerStopped")
+        await ev.call_async_event("onServerStopped")
         await ev.call_async_event("_plugins_unload")
         self.run = False
         self.log.info(i18n.stop)

src/core/core.pyi

@@ -1,7 +1,7 @@
 # Developed by KuiToi Dev
 # File core.core.pyi
 # Written by: SantaSpeen
-# Version 0.2.3
+# Version 0.4.1
 # Licence: FPA
 # (c) kuitoi.su 2023
 import asyncio
@@ -32,6 +32,7 @@ class Core:
         self.udp = UDPServer
         self.web_thread: Thread = None
         self.web_stop: Callable = lambda: None
+        self.lock_upload = False
         self.client_major_version = "2.0"
         self.BeamMP_version = "3.2.0"
     def get_client(self, cid=None, nick=None) -> Client | None: ...

src/core/tcp_server.py

@@ -1,7 +1,7 @@
 # Developed by KuiToi Dev
 # File core.tcp_server.py
 # Written by: SantaSpeen
-# Core version: 0.2.3
+# Core version: 0.4.1
 # Licence: FPA
 # (c) kuitoi.su 2023
 import asyncio
@@ -12,6 +12,7 @@ import aiohttp
 from core import utils
 
 
+# noinspection PyProtectedMember
 class TCPServer:
     def __init__(self, core, host, port):
         self.log = utils.get_logger("TCPServer")
@@ -25,7 +26,7 @@ class TCPServer:
         client = self.Core.create_client(reader, writer)
         # TODO: i18n
         self.log.info(f"Identifying new ClientConnection...")
-        data = await client._recv()
+        data = await client._recv(True)
         self.log.debug(f"Version: {data}")
         if data.decode("utf-8") != f"VC{self.Core.client_major_version}":
             # TODO: i18n
@@ -34,14 +35,14 @@ class TCPServer:
         else:
             await client._send(b"S")  # Accepted client version
 
-        data = await client._recv()
+        data = await client._recv(True)
         self.log.debug(f"Key: {data}")
         if len(data) > 50:
             # TODO: i18n
             await client.kick("Invalid Key (too long)!")
             return False, client
         client._key = data.decode("utf-8")
-        ev.call_event("auth_sent_key", player=client)
+        ev.call_event("onPlayerSentKey", player=client)
         try:
             async with aiohttp.ClientSession() as session:
                 url = 'https://auth.beammp.com/pkToUser'
@@ -52,8 +53,8 @@ class TCPServer:
                 # TODO: i18n
                 await client.kick('Invalid key! Please restart your game.')
                 return False, client
-            client._nick = res["username"]
-            client._roles = res["roles"]
+            client.nick = res["username"]
+            client.roles = res["roles"]
             client._guest = res["guest"]
             # noinspection PyProtectedMember
             client._update_logger()
@@ -71,7 +72,7 @@ class TCPServer:
                 await client.kick('Stale Client (replaced by new client)')
                 return False, client
 
-        ev.call_event("auth_ok", player=client)
+        ev.call_event("onPlayerAuthenticated", player=client)
 
         if len(self.Core.clients_by_id) > config.Game["players"]:
             # TODO: i18n
@@ -89,7 +90,7 @@ class TCPServer:
             cid = (await reader.read(1))[0]
             client = self.Core.get_client(cid=cid)
             if client:
-                client._down_rw = (reader, writer)
+                client._down_sock = (reader, writer)
                 self.log.debug(f"Client: {client.nick}:{cid} - HandleDownload!")
             else:
                 writer.close()
@@ -133,7 +134,7 @@ class TCPServer:
                 break
             except Exception as e:
                 # TODO: i18n
-                self.log.error("Error while connecting..")
+                self.log.error("Error while handling connection...")
                 self.log.exception(e)
                 traceback.print_exc()
                 break
@@ -143,7 +144,7 @@ class TCPServer:
         self.run = True
         try:
             server = await asyncio.start_server(self.handle_client, self.host, self.port,
-                                                backlog=int(config.Game["players"] * 1.3))
+                                                backlog=int(config.Game["players"] * 2.3))
             self.log.debug(f"TCP server started on {server.sockets[0].getsockname()!r}")
             while True:
                 async with server:

src/core/tcp_server.pyi

@@ -1,7 +1,7 @@
 # Developed by KuiToi Dev
 # File core.tcp_server.pyi
 # Written by: SantaSpeen
-# Core version: 0.2.3
+# Core version: 0.4.1
 # Licence: FPA
 # (c) kuitoi.su 2023
 import asyncio

src/core/udp_server.py

@@ -1,18 +1,20 @@
 # Developed by KuiToi Dev
 # File core.udp_server.py
 # Written by: SantaSpeen
-# Core version: 0.2.3
+# Core version: 0.4.1
 # Licence: FPA
 # (c) kuitoi.su 2023
 import asyncio
-import traceback
 
 from core import utils
 
 
-class UDPServer:
+# noinspection PyProtectedMember
+class UDPServer(asyncio.DatagramTransport):
+    transport = None
 
-    def __init__(self, core, host, port):
+    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
@@ -20,41 +22,77 @@ class UDPServer:
         self.port = port
         self.run = False
 
-    async def handle_client(self, reader, writer):
-        while True:
-            try:
-                data = await reader.read(1)
-                if not data:
-                    break
-                code = data.decode()
-                self.log.debug(f"Received {code!r} from {writer.get_extra_info('sockname')!r}")
-                # await self.handle_code(code, reader, writer)
-                # task = asyncio.create_task(self.handle_code(code, reader, writer))
-                # await asyncio.wait([task], return_when=asyncio.FIRST_EXCEPTION)
-                if not writer.is_closing():
-                    writer.close()
-                self.log.debug("Disconnected.")
-                break
-            except Exception as e:
-                self.log.error("Error while connecting..")
-                self.log.error(f"Error: {e}")
-                traceback.print_exc()
-                break
+    def connection_made(self, transport): ...
 
-    async def start(self):
-        self.log.debug("Starting UDP server.")
-        self.run = True
+    async def handle_datagram(self, data, addr):
         try:
-            pass
+            cid = data[0] - 1
+            code = data[2:3].decode()
+
+            client = self.Core.get_client(cid=cid)
+            if client:
+                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")
+                        if client:
+                            await client._send(data[2:], to_all=True, to_self=False, to_udp=True)
+                    case _:
+                        self.log.debug(f"[{cid}] Unknown code: {code}")
+            else:
+                self.log.debug(f"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.")
+        try:
+            while self.Core.run:
+                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
+
+                if not self.run:
+                    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.log.error("Cannot bind port or other error")
-            raise e
-        except BaseException as e:
+            self.log.exception(e)
+        except Exception as e:
             self.log.error(f"Error: {e}")
-            raise e
+            self.log.exception(e)
         finally:
             self.run = False
             self.Core.run = False
 
-    def stop(self):
+    def _stop(self):
         self.log.debug("Stopping UDP server")
+        self.transport.close()

src/core/udp_server.pyi

@@ -1,24 +1,30 @@
 # Developed by KuiToi Dev
 # File core.udp_server.py
 # Written by: SantaSpeen
-# Core version: 0.2.3
+# Core version: 0.4.1
 # Licence: FPA
 # (c) kuitoi.su 2023
 import asyncio
+from asyncio import DatagramTransport
+from typing import Tuple, List
 
 from core import utils
+from core.core import Core
 
 
-class UDPServer:
+class UDPServer(asyncio.DatagramTransport):
+    transport: DatagramTransport = None
 
-    def __init__(self, core, host, port):
+    def __init__(self, core: Core, host=None, port=None, transport=None):
         self.log = utils.get_logger("UDPServer")
         self.loop = asyncio.get_event_loop()
         self.Core = core
         self.host = host
         self.port = port
         self.run = False
-    async def handle_client(self, srv_sock) -> None: ...
-    async def start(self) -> None: ...
-
-    async def stop(self) -> None: ...
+        # self.transport: DatagramTransport = None
+    def connection_made(self, transport: DatagramTransport): ...
+    async def handle_datagram(self, data: bytes, addr: Tuple[str, int]):
+    def datagram_received(self, data: bytes, addr: Tuple[str, int]): ...
+    async def _start(self) -> None: ...
+    async def _stop(self) -> None: ...

src/core/utils.py

@@ -2,7 +2,7 @@
 # File core.utils.py
 # Written by: SantaSpeen
 # Version 1.1
-# Core version: 0.2.3
+# Core version: 0.4.1
 # Licence: FPA
 # (c) kuitoi.su 2023
 import datetime
@@ -20,8 +20,8 @@ logging.basicConfig(level=log_level, format=log_format)
 if not os.path.exists(log_dir):
     os.mkdir(log_dir)
 if os.path.exists(log_file):
-    mtime = os.path.getmtime(log_file)
-    gz_path = log_dir + datetime.datetime.fromtimestamp(mtime).strftime('%d.%m.%Y') + "-%s.tar.gz"
+    ftime = os.path.getmtime(log_file)
+    gz_path = log_dir + datetime.datetime.fromtimestamp(ftime).strftime('%d.%m.%Y') + "-%s.tar.gz"
     index = 1
     while True:
         if not os.path.exists(gz_path % index):
@@ -33,11 +33,15 @@ if os.path.exists(log_file):
             if os.path.exists(file):
                 tar.add(file, os.path.basename(file))
                 os.remove(file)
-fh = logging.FileHandler(log_file, encoding='utf-8')
+fh = logging.FileHandler(log_file, encoding="utf-8")
 fh.setFormatter(logging.Formatter(log_format))
 
 
 def get_logger(name):
+    try:
+        fh.encoding = config.enc
+    except NameError:
+        fh.encoding = "utf-8"
     log = logging.getLogger(name=name)
     log.addHandler(fh)
     log.level = log_level

src/modules/ConfigProvider/config_provider-builtins.pyi

@@ -1,8 +1,17 @@
+import secrets
+
+
 class Config:
-    Auth: dict
-    Game: dict
-    Server: dict
-    WebAPI: dict
+    def __init__(self, auth=None, game=None, server=None, options=None, web=None):
+        self.Auth = auth or {"key": None, "private": True}
+        self.Game = game or {"map": "gridmap_v2", "players": 8, "max_cars": 1}
+        self.Server = server or {"name": "KuiToi-Server", "description": "Welcome to KuiToi Server!",
+                                 "server_ip": "0.0.0.0", "server_port": 30814}
+        self.Options = options or {"language": "en", "encoding": "utf8", "speed_limit": 0, "use_queue": False,
+                                   "debug": False}
+        self.WebAPI = web or {"enabled": False, "server_ip": "127.0.0.1", "server_port": 8433,
+                              "secret_key": secrets.token_hex(16)}
+
     def __repr__(self):
         return "%s(Auth=%r, Game=%r, Server=%r)" % (self.__class__.__name__, self.Auth, self.Game, self.Server)
 class config (Config): ...

src/modules/ConfigProvider/config_provider.py

@@ -1,9 +1,8 @@
 # -*- coding: utf-8 -*-
-
 # Developed by KuiToi Dev
 # File modules.config_provider.config_provider.py
 # Written by: SantaSpeen
-# Version 1.0
+# Version 1.1
 # Licence: FPA
 # (c) kuitoi.su 2023
 import os
@@ -11,13 +10,14 @@ import secrets
 
 import yaml
 
-
 class Config:
-    def __init__(self, auth=None, game=None, server=None, web=None):
+    def __init__(self, auth=None, game=None, server=None, options=None, web=None):
         self.Auth = auth or {"key": None, "private": True}
         self.Game = game or {"map": "gridmap_v2", "players": 8, "max_cars": 1}
-        self.Server = server or {"name": "KuiToi-Server", "description": "Welcome to KuiToi Server!", "language": "en",
-                                 "server_ip": "0.0.0.0", "server_port": 30814, "debug": False}
+        self.Server = server or {"name": "KuiToi-Server", "description": "Welcome to KuiToi Server!",
+                                 "server_ip": "0.0.0.0", "server_port": 30814}
+        self.Options = options or {"language": "en", "encoding": "utf-8", "speed_limit": 0, "use_queue": False,
+                                   "debug": False}
         self.WebAPI = web or {"enabled": False, "server_ip": "127.0.0.1", "server_port": 8433,
                               "secret_key": secrets.token_hex(16)}
 

src/modules/EventsSystem/events_system.py

@@ -22,20 +22,28 @@ class EventsSystem:
         self.loop = asyncio.get_event_loop()
         self.as_tasks = []
         self.__events = {
-            "server_started": [],
-            "auth_sent_key": [],  # Only sync
-            "auth_ok": [],  # Only sync
-            "player_join": [],
-            "chat_receive": [],
-            "server_stopped": [],
+            "onServerStarted": [],
+            "onPlayerSentKey": [],  # Only sync
+            "onPlayerAuthenticated": [],  # Only sync
+            "onPlayerJoin": [],
+            "onChatReceive": [],
+            "onCarSpawn": [],
+            "onCarDelete": [],
+            "onCarEdited": [],
+            "onCarReset": [],
+            "onSentPing": [],  # Only sync
+            "onChangePosition": [],  # Only sync
+            "onServerStopped": [],
         }
         self.__async_events = {
-            "server_started": [],
-            "_plugins_start": [],
-            "_plugins_unload": [],
-            "player_join": [],
-            "chat_receive": [],
-            "server_stopped": []
+            "onServerStarted": [],
+            "onPlayerJoin": [],
+            "onChatReceive": [],
+            "onCarSpawn": [],
+            "onCarDelete": [],
+            "onCarEdited": [],
+            "onCarReset": [],
+            "onServerStopped": []
         }
 
     def builtins_hook(self):
@@ -80,7 +88,8 @@ class EventsSystem:
         return funcs_data
 
     def call_event(self, event_name, *args, **kwargs):
-        self.log.debug(f"Calling sync event: '{event_name}'")
+        if event_name not in ["onChangePosition", "onSentPing"]:  # UDP events
+            self.log.debug(f"Calling sync event: '{event_name}'")
         funcs_data = []
 
         if event_name in self.__events.keys():

src/modules/PluginsLoader/plugins_loader.py

@@ -99,7 +99,7 @@ class PluginsLoader:
                     plugin.print = print
                     file_path = os.path.join(self.plugins_dir, file)
                     plugin.__file__ = file_path
-                    with open(f'{file_path}', 'r', encoding="utf-8") as f:
+                    with open(f'{file_path}', 'r', encoding=config.enc) as f:
                         code = f.read()
                         exec(code, plugin.__dict__)
 

src/modules/i18n/i18n.py

@@ -68,7 +68,9 @@ class i18n:
 
 class MultiLanguage:
 
-    def __init__(self, language: str = None, files_dir="modules/i18n/files/", encoding="utf-8"):
+    def __init__(self, language: str = None, files_dir="modules/i18n/files/", encoding=None):
+        if encoding is None:
+            encoding = config.enc
         if language is None:
             language = "en"
         self.__data = {}