Beta!!!

Move code "O" to client._handle_vehicle_codes();

README.md

@@ -1,7 +1,7 @@
 # KuiToi-Server
 
 ## About
-**_[Status: Alpha]_** \
+**_[Status: Beta]_** \
 BeamingDrive Multiplayer (BeamMP) server compatible with BeamMP clients.
 
 ## TODOs
@@ -11,32 +11,39 @@ BeamingDrive Multiplayer (BeamMP) server compatible with BeamMP clients.
     - [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)
+    - [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)_
+      - [ ] Compress data
   - [ ] UDP Server part:
     - [ ] Players synchronizations _(Code: Zp)_
     - [ ] Ping _(Code: p)_
 - [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

src/core/Client.py

@@ -1,10 +1,11 @@
 # Developed by KuiToi Dev
 # File core.tcp_server.py
 # Written by: SantaSpeen
-# Core version: 0.2.3
+# Core version: 0.3.0
 # Licence: FPA
 # (c) kuitoi.su 2023
 import asyncio
+import json
 import math
 import zlib
 
@@ -16,9 +17,11 @@ 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_rw = (None, None)
         self._loop = asyncio.get_event_loop()
         self._log = utils.get_logger("client(None:0)")
         self._addr = writer.get_extra_info("sockname")
@@ -60,7 +63,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}")
@@ -109,8 +112,11 @@ class Client:
                     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)
+                        if len(data) > 400:
+                            # TODO: Compress data
+                            await client._send(data)
+                        else:
+                            await client._send(data)
                     else:
                         await client._send(data)
                 else:
@@ -124,46 +130,65 @@ class Client:
             writer.write(header + data)
             await writer.drain()
         except ConnectionError:
-            self.log.debug('tcp_send: Disconnected')
+            self.log.debug('_send: Disconnected')
             self.__alive = False
+            await self._remove_me()
 
-    async def _recv(self):
-        try:
-            header = await self.__reader.read(4)
+    async def __handle_packet(self, data, int_header):
+        self.log.debug(f"int_header: {int_header}; data: {data};")
+        if len(data) != int_header:
+            self.log.debug(f"WARN Expected to read {int_header} bytes, instead got {len(data)}")
 
-            int_header = 0
-            for i in range(len(header)):
-                int_header += header[i]
+            recv2 = data[int_header:]
+            header2 = recv2[:4]
+            data2 = recv2[4:]
+            int_header2 = int.from_bytes(header2, byteorder='little', signed=True)
+            t = asyncio.create_task(self.__handle_packet(data2, int_header2))
+            self.__tasks.append(t)
+            data = data[:4 + int_header]
 
-            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""
+        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)}")
 
-            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""
+        self.__packets_queue.append(data)
+        self.log.debug(f"Packets in queue: {len(self.__packets_queue)}")
 
-            data = await self.__reader.read(100 * MB)
-            self.log.debug(f"header: `{header}`; int_header: `{int_header}`; data: `{data}`;")
+    async def _recv(self, one=False):
+        while self.__alive:
+            try:
+                header = await self.__reader.read(4)
 
-            if len(data) != int_header:
-                self.log.debug(f"WARN Expected to read {int_header} bytes, instead got {len(data)}")
+                int_header = int.from_bytes(header, byteorder='little', signed=True)
 
-            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 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")
+                    self.__packets_queue.append(None)
+                    continue
+
+                if int_header > 100 * MB:
+                    await self.kick("Header size limit exceeded")
+                    self.log.warning(f"Client {self.nick}:{self.cid} sent header of >100MB - "
+                                     f"assuming malicious intent and disconnecting the client.")
+                    self.__packets_queue.append(None)
+                    continue
+
+                data = await self.__reader.read(100 * MB)
+                if one:
+                    self.log.debug(f"int_header: `{int_header}`; data: `{data}`;")
+                    return data
+                else:
+                    t = asyncio.create_task(self.__handle_packet(data, int_header))
+                    self.__tasks.append(t)
+
+            except ConnectionError:
+                self.__alive = False
+                self.__packets_queue.append(None)
 
     async def _split_load(self, start, end, d_sock, filename):
         # TODO: Speed  limiter
@@ -187,8 +212,7 @@ class Client:
 
     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")
                 # TODO: i18n
@@ -245,92 +269,219 @@ class Client:
                 else:
                     await self._send(bytes(mod_list, "utf-8"))
             elif data == b"Done":
+                for c in range(config.Game['max_cars']):
+                    self._cars.append(None)
                 await self._send(b"M/levels/" + bytes(config.Game['map'], 'utf-8') + b"/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):
+        s = data[:data.find(":", 1)]
+        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 _handle_vehicle_codes(self, data):
+        if len(data) < 6:
+            return
+        sub_code = data[1]
+        data = data[3:]
+        match sub_code:
+            case "s":  # Spawn car
+                self.log.debug("Trying to spawn car")
+                if data[0] == "0":
+                    car_id = 0
+                    for c in self.cars:
+                        if c is None:
+                            break
+                        car_id += 1
+                    self.log.debug(f"Created a car: car_id={car_id}")
+                    car_data = data[2:]
+                    car_json = {}
+                    try:
+                        car_json = json.loads(data[data.find("{"):])
+                    except Exception as e:
+                        self.log.debug(f"Invalid car_json: Error: {e}; Data: {car_data}")
+                    allow = True
+                    over_spawn = False
+                    # TODO: Call event onCarSpawn
+                    pkt = f"Os:{self.roles}:{self.nick}:{self.cid}-{car_id}:{car_data}"
+                    unicycle = car_json.get("jbm") == "unicycle"
+                    if (allow and (config.Game['max_cars'] > car_id or unicycle)) or over_spawn:
+                        self.log.debug(f"Car spawn accepted.")
+                        self._cars[car_id] = {
+                            "packet": pkt,
+                            "json": car_json,
+                            "json_ok": bool(car_json),
+                            "unicycle": unicycle,
+                            "over_spawn": over_spawn or unicycle
+                        }
+                        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)
+            case "d":  # Delete car
+                self.log.debug("Trying to delete car")
+                cid, car_id = self._get_cid_vid(data)
+                if car_id != -1 and cid == self.cid:
+                    # TODO: Call event onCarDelete
+                    await self._send(data, to_all=True, to_self=True)
+                    try:
+                        car = self.cars[car_id]
+                        if car['unicycle']:
+                            self._cars.pop(car_id)
+                        else:
+                            self._cars[car_id] = None
+                        await self._send(f"Od:{self.cid}-{car_id}")
+                        self.log.debug(f"Deleted car: car_id={car_id}")
+                    except IndexError:
+                        self.log.debug(f"Unknown car: car_id={car_id}")
+            case "c":  # Edit car
+                self.log.debug("Trying to edit car")
+                allow = True
+                # TODO: Call event onCarEdited
+                cid, car_id = self._get_cid_vid(data)
+                if car_id != -1 and cid == self.cid:
+                    try:
+                        car = self.cars[car_id]
+                        if car['unicycle']:
+                            self._cars.pop(car_id)
+                            await self._send(f"Od:{self.cid}-{car_id}", to_all=True, to_self=True)
+                        elif allow:
+                            await self._send(data, to_all=True, to_self=False)
+                            if car['json_ok']:
+                                old_car_json = car['json']
+                                try:
+                                    new_car_json = json.loads(data[data.find("{"):])
+                                    old_car_json.update(new_car_json)
+                                    car['json'] = new_car_json
+                                    self.log.debug(f"Updated car: car_id={car_id}")
+                                except Exception as e:
+                                    self.log.debug(f"Invalid new_car_json: Error: {e}; Data: {data}")
+
+                    except IndexError:
+                        self.log.debug(f"Unknown car: car_id={car_id}")
+            case "r":  # Reset car
+                self.log.debug("Trying to reset car")
+                cid, car_id = self._get_cid_vid(data)
+                if car_id != -1 and cid == self.cid:
+                    # TODO: Call event onCarReset
+                    await self._send(data, to_all=True, to_self=False)
+                    self.log.debug(f"Car reset: car_id={car_id}")
+            case "t":
+                self.log.debug(f"Received 'Ot' packet: {data}")
+                await self._send(data, to_all=True, to_self=False)
+            case "m":
+                await self._send(data, to_all=True, to_self=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)
+        try:
+            data = data.decode()
+        except UnicodeDecodeError:
+            self.log.debug(f"UnicodeDecodeError: {data}")
+
+        code = data[0]
+        match code:
+            case "H":
+                # 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'])
+
+            case "C":  # Chat handler
+                msg = data[4 + len(self.nick):]
+                if not msg:
+                    self.log.debug("Tried to send an empty event, ignoring")
+                    return
+                self.log.info(f"{self.nick}: {msg}")
+                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:
+                            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":  # Cars handler
+                await self._handle_vehicle_codes(data)
+
+            case "E":  # Client events handler
+                # TODO: HandleEvent
+                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):
+        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)

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.3.0
 # Licence: FPA
 # (c) kuitoi.su 2023
 import asyncio
 from asyncio import StreamReader, StreamWriter
 from logging import Logger
-from typing import Tuple
+from typing import Tuple, List, Dict
 
 from core import Core, utils
 
@@ -15,8 +15,10 @@ from core import Core, utils
 class Client:
 
     def __init__(self, reader: StreamReader, writer: StreamWriter, core: Core) -> "Client":
+        self.__tasks = []
         self.__reader = reader
         self.__writer = writer
+        self.__packets_queue = []
         self._down_rw: Tuple[StreamReader, StreamWriter] | Tuple[None, None] = (None, None)
         self._log = utils.get_logger("client(id: )")
         self._addr = writer.get_extra_info("sockname")
@@ -29,6 +31,7 @@ class Client:
         self._guest = True
         self.__alive = True
         self._ready = False
+        self._cars: List[dict | None] = []
     @property
     def _writer(self) -> StreamWriter: ...
     @property
@@ -43,12 +46,18 @@ 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(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 __handle_packet(self, data, int_header): ...
+    async def _recv(self, one=False) -> bytes | None: ...
     async def _split_load(self, start: int, end: int, d_sock: bool, filename: str) -> None: ...
+    async def _get_cid_vid(self, s: str) -> Tuple[int, int]: ...
+    async def _handle_vehicle_codes(self, data) -> None: ...
+    async def _handle_codes(self, data) -> 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.3.0
 # 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.3.0'
+__build__ = 1257  # Я это считаю лог файлами
 __author__ = 'SantaSpeen'
 __author_email__ = 'admin@kuitoi.su'
 __license__ = "FPA"

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.3.0
 # Licence: FPA
 # (c) kuitoi.su 2023
 import asyncio
@@ -85,7 +85,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 += ","
@@ -260,8 +260,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
@@ -278,8 +278,8 @@ class Core:
         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.3.0
 # Licence: FPA
 # (c) kuitoi.su 2023
 import asyncio

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.3.0
 # Licence: FPA
 # (c) kuitoi.su 2023
 import asyncio
@@ -25,7 +25,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 +34,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 +52,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 +71,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
@@ -133,7 +133,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

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.3.0
 # Licence: FPA
 # (c) kuitoi.su 2023
 import asyncio

src/core/udp_server.py

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

src/core/udp_server.pyi

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

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.3.0
 # Licence: FPA
 # (c) kuitoi.su 2023
 import datetime

src/modules/EventsSystem/events_system.py

@@ -22,20 +22,18 @@ 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": [],
+            "onServerStopped": [],
         }
         self.__async_events = {
-            "server_started": [],
-            "_plugins_start": [],
-            "_plugins_unload": [],
-            "player_join": [],
-            "chat_receive": [],
-            "server_stopped": []
+            "onServerStarted": [],
+            "onPlayerJoin": [],
+            "onChatReceive": [],
+            "onServerStopped": []
         }
 
     def builtins_hook(self):