README.md

@@ -63,7 +63,7 @@ BeamingDrive Multiplayer (BeamMP) server compatible with BeamMP clients.
       - [ ] Client (Player) class
     - [ ] Lua part: (Original BeamMP compatibility)
       - [x] Load Lua plugins
-      - [x] MP Class 
+      - [ ] MP Class 
       - [ ] Util class
       - [ ] FS class
   - [x] MultiLanguage (i18n support)

src/core/Client.py

@@ -33,16 +33,9 @@ class Client:
         self.roles = None
         self._guest = True
         self._ready = False
-        self._identifiers = []
         self._cars = [None] * 21  # Max 20 cars per player + 1 snowman
         self._snowman = {"id": -1, "packet": ""}
         self._connect_time = 0
-        self._last_position = {}
-
-        ev.register_event("onServerStopped", self.__gracefully_kick)
-
-    async def __gracefully_kick(self, _):
-        await self.kick("Server shutdown!")
 
     @property
     def _writer(self):
@@ -72,18 +65,10 @@ class Client:
     def ready(self):
         return self._ready
 
-    @property
-    def identifiers(self):
-        return self._identifiers
-
     @property
     def cars(self):
         return self._cars
 
-    @property
-    def last_position(self):
-        return self._last_position
-
     def _update_logger(self):
         self._log = utils.get_logger(f"{self.nick}:{self.cid}")
         self.log.debug(f"Update logger")
@@ -109,7 +94,7 @@ class Client:
         self.__alive = False
 
     async def send_message(self, message, to_all=True):
-        await self._send(f"C:{message}", to_all=to_all)
+        pass
 
     async def send_event(self, event_name, event_data):
         pass
@@ -388,8 +373,7 @@ class Client:
                 "json": car_json,
                 "json_ok": bool(car_json),
                 "snowman": snowman,
-                "over_spawn": (snowman and allow_snowman) or over_spawn,
+                "over_spawn": (snowman and allow_snowman) or over_spawn
-                "pos": {}
             }
             await self._send(pkt, to_all=True, to_self=True)
         else:
@@ -397,13 +381,8 @@ class Client:
             des = f"Od:{self.cid}-{car_id}"
             await self._send(des)
 
-    async def _delete_car(self, raw_data=None, car_id=None):
+    async def _delete_car(self, raw_data):
-
+        cid, car_id = self._get_cid_vid(raw_data)
-        if not car_id and raw_data:
-            cid, car_id = self._get_cid_vid(raw_data)
-        else:
-            cid = self.cid
-            raw_data = f"Od:{self.cid}-{car_id}"
 
         if car_id != -1 and self.cars[car_id]:
 
@@ -536,7 +515,6 @@ class Client:
             self.log.debug("Tried to send an empty event, ignoring")
             return
         to_ev = {"message": msg, "player": self}
-        ev.call_lua_event("onChatMessage", self.cid, self.nick, msg)
         ev_data_list = ev.call_event("onChatReceive", **to_ev)
         d2 = await ev.call_async_event("onChatReceive", **to_ev)
         ev_data_list.extend(d2)

src/core/Client.pyi

@@ -33,11 +33,9 @@ class Client:
         self._guest = True
         self.__alive = True
         self._ready = False
-        self._identifiers = []
         self._cars: List[Optional[Dict[str, int]]] = []
         self._snowman: Dict[str, Union[int, str]]  = {"id": -1, "packet": ""}
-        self._last_position = {}
+
-    async def __gracefully_kick(self): ...
     @property
     def _writer(self) -> StreamWriter: ...
     @property
@@ -53,11 +51,7 @@ class Client:
     @property
     def ready(self) -> bool: ...
     @property
-    def identifiers(self) -> list: ...
-    @property
     def cars(self) -> List[dict | None]: ...
-    @property
-    def last_position(self): ...
     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:...
@@ -68,7 +62,7 @@ class Client:
     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, car_id : int =None) -> 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: ...

src/core/core.py

@@ -47,12 +47,12 @@ class Core:
         self.BeamMP_version = "3.1.1"  # 20.07.2023
 
         ev.register_event("_get_BeamMP_version", lambda x: tuple([int(i) for i in self.BeamMP_version.split(".")]))
-        ev.register_event("_get_player", lambda x: self.get_client(**x['kwargs']))
+        ev.register_event("_get_player", self.get_client)
 
-    def get_client(self, cid=None, nick=None):
+    def get_client(self, cid=None, nick=None, from_ev=None):
+        if from_ev is not None:
+            return self.get_client(*from_ev['args'], **from_ev['kwargs'])
         if cid is not None:
-            if cid == -1:
-                return [i for i in self.clients if i is not None]
             return self.clients_by_id.get(cid)
         if nick:
             return self.clients_by_nick.get(nick)

src/core/tcp_server.py

@@ -56,7 +56,6 @@ class TCPServer:
             client.nick = res["username"]
             client.roles = res["roles"]
             client._guest = res["guest"]
-            client._identifiers = {k: v for s in res["identifiers"] for k, v in [s.split(':')]}
             # noinspection PyProtectedMember
             client._update_logger()
         except Exception as e:

src/core/udp_server.py

@@ -5,7 +5,6 @@
 # Licence: FPA
 # (c) kuitoi.su 2023
 import asyncio
-import json
 
 from core import utils
 
@@ -23,14 +22,12 @@ class UDPServer(asyncio.DatagramTransport):
         self.port = port
         self.run = False
 
-    def connection_made(self, transport):
+    def connection_made(self, transport): ...
-        ...
 
     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:
@@ -42,19 +39,9 @@ class UDPServer(asyncio.DatagramTransport):
                         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)
+                        ev.call_event("onChangePosition")
-                        sub = data.find("{", 1)
+                        if client:
-                        last_pos_data = data[sub:]
+                            await client._send(data[2:], to_all=True, to_self=False, to_udp=True)
-                        try:
-                            last_pos = json.loads(last_pos_data)
-                            client._last_position = last_pos
-                            _, car_id = client._get_cid_vid(data)
-                            client._cars[car_id]['pos'] = last_pos
-                        except Exception as e:
-                            self.log.debug(f"Cannot parse position packet: {e}")
-                            self.log.debug(f"data: {data}, sup: {sub}")
-                            self.log.debug(f"last_pos_data: {last_pos_data}")
-                        await client._send(data, to_all=True, to_self=False, to_udp=True)
                     case _:
                         self.log.debug(f"[{cid}] Unknown code: {code}")
             else:

src/modules/EventsSystem/events_system.py

@@ -46,37 +46,12 @@ class EventsSystem:
             "onServerStopped": []
         }
 
-        self.__lua_events = {
-            "onInit": [],  # onServerStarted
-            "onShutdown": [],  # onServerStopped
-            "onPlayerAuth": [],  # onPlayerAuthenticated
-            "onPlayerConnecting": [],  # TODO lua onPlayerConnecting
-            "onPlayerJoining": [],  # TODO lua onPlayerJoining
-            "onPlayerJoin": [],  # onPlayerJoin
-            "onPlayerDisconnect": [],  # TODO lua onPlayerDisconnect
-            "onChatMessage": [],  # onChatReceive
-            "onVehicleSpawn": [],  # "onCarSpawn
-            "onVehicleEdited": [],  # onCarEdited
-            "onVehicleDeleted": [],  # onCarDelete
-            "onVehicleReset": [],  # onCarReset
-            "onFileChanged": [],  # TODO lua onFileChanged
-        }
-
     def builtins_hook(self):
         self.log.debug("used builtins_hook")
         builtins.ev = self
 
-    def register_event(self, event_name, event_func, async_event=False, lua=None):
+    def register_event(self, event_name, event_func, async_event=False):
-        self.log.debug(f"register_event(event_name='{event_name}', event_func='{event_func}', "
+        self.log.debug(f"register_event({event_name}, {event_func}):")
-                       f"async_event={async_event}, lua_event={lua}):")
-        if lua:
-            if event_name not in self.__lua_events:
-                self.__lua_events.update({str(event_name): [event_func]})
-            else:
-                self.__lua_events[event_name].append(event_func)
-            self.log.debug("Register ok")
-            return
-
         if not callable(event_func):
             # TODO: i18n
             self.log.error(f"Cannot add event '{event_name}'. "
@@ -87,13 +62,11 @@ class EventsSystem:
                 self.__async_events.update({str(event_name): [event_func]})
             else:
                 self.__async_events[event_name].append(event_func)
-            self.log.debug("Register ok")
         else:
             if event_name not in self.__events:
                 self.__events.update({str(event_name): [event_func]})
             else:
                 self.__events[event_name].append(event_func)
-            self.log.debug("Register ok")
 
     async def call_async_event(self, event_name, *args, **kwargs):
         self.log.debug(f"Calling async event: '{event_name}'")
@@ -133,24 +106,3 @@ class EventsSystem:
             self.log.warning(f"Event {event_name} does not exist, maybe ev.call_async_event()?. Just skipping it...")
 
         return funcs_data
-
-    def call_lua_event(self, event_name, *args):
-        self.log.debug(f"Calling lua event: '{event_name}'")
-        funcs_data = []
-        if event_name in self.__lua_events.keys():
-            for func in self.__lua_events[event_name]:
-                try:
-                    funcs_data.append(func(*args))
-                except Exception as e:
-                    # TODO: i18n
-                    self.log.error(f'Error while calling "{event_name}"; In function: "{func.__name__}"')
-                    self.log.exception(e)
-        else:
-            # TODO: i18n
-            self.log.warning(f"Event {event_name} does not exist, maybe ev.call_lua_event() or MP.Trigger<>Event()?. "
-                             f"Just skipping it...")
-
-        return funcs_data
-
-
-

src/modules/EventsSystem/events_systems-builtins.pyi

@@ -3,11 +3,9 @@ from typing import Any
 
 class EventsSystem:
     @staticmethod
-    def register_event(event_name, event_func, async_event: bool = False, lua: bool | object = None): ...
+    def register_event(event_name, event_func): ...
     @staticmethod
     async def call_async_event(event_name, *args, **kwargs) -> list[Any]: ...
     @staticmethod
     def call_event(event_name, *data, **kwargs) -> list[Any]: ...
-    @staticmethod
-    def call_lua_event(event_name, *data) -> list[Any]: ...
 class ev(EventsSystem): ...

src/modules/PluginsLoader/add_in.lua

@@ -1,26 +1,4 @@
-package.path = package.path..";modules/PluginsLoader/lua_libs/?.lua"
+function MP:GetServerVersion()
-
+    ver = MP:_GetServerVersion()
-MP.Timer = {}
+    return ver[0], ver[1], ver[2]
-function MP.CreateTimer()
-    local newObj = {
-        startTime = os.clock()
-    }
-    setmetatable(newObj, { __index = MP.Timer })
-    return newObj
 end
-function MP.Timer:GetCurrent()
-    return os.clock() - self.startTime
-end
-function MP.Timer:Start()
-    self.startTime = os.clock()
-end
-
-function MP.Sleep(time_ms)
-    local start = getTickCount()
-    while getTickCount() - start < time_ms do end
-end
-
-MP.CallStrategy = {
-    BestEffort = 0,
-    Precise = 1
-}

src/modules/PluginsLoader/lua_plugins_loader.py

@@ -1,7 +1,10 @@
 import asyncio
 import os
 import platform
+from typing import Tuple, List, Any
 
+# noinspection PyUnresolvedReferences
+import lupa.lua53
 from lupa.lua53 import LuaRuntime
 
 from core import get_logger
@@ -10,147 +13,24 @@ from core import get_logger
 # noinspection PyPep8Naming
 class MP:
 
-    # In ./in_lua.lua
+    def __init__(self, name):
-    # MP.CreateTimer
-    # MP.Sleep
-
-    def __init__(self, name: str, lua: LuaRuntime):
-        self.loop = asyncio.get_event_loop()
-        self.tasks = []
         self.name = name
         self.log = get_logger(f"LuaPlugin | {name}")
-        self._lua = lua
 
-    def _print(self, *args):
+    def _print_log(self, *args):
-        s = " ".join(map(str, args))
+        s = ""
+        for i in args:
+            s += f" {i}"
         self.log.info(s)
 
+    def CreateTimer(self): ...
+
     def GetOSName(self) -> str:
-        self.log.debug("request MP.GetOSName()")
+        return platform.system()
-        pl = platform.system()
-        if pl in ["Linux", "Windows"]:
-            return pl
-        return "Other"
 
-    def GetServerVersion(self) -> tuple[int, int, int]:
+    def _GetServerVersion(self) -> tuple[int, int, int]:
-        self.log.debug("request MP.GetServerVersion()")
+        major, minor, patch = ev.call_event("_get_BeamMP_version")[0]
-        return ev.call_event("_get_BeamMP_version")[0]
+        return major, minor, patch
-
-    def RegisterEvent(self, event_name: str, function_name: str) -> None:
-        self.log.debug("request MP.RegisterEvent()")
-        ev.register_event(event_name, self._lua.globals()[function_name], lua=True)
-
-    def TriggerLocalEvent(self, event_name, *args):
-        self.log.debug("request TriggerLocalEvent()")
-        # TODO: TriggerLocalEvent
-        return self._lua.table()
-
-    def TriggerGlobalEvent(self, event_name, *args):
-        self.log.debug("request TriggerGlobalEvent()")
-        # TODO: TriggerGlobalEvent
-        return self._lua.table(IsDone=lambda: True, GetResults=lambda: "somedata")
-
-    def SendChatMessage(self, player_id, message):
-        self.log.debug("request SendChatMessage()")
-        client = ev.call_event("_get_player", cid=player_id)[0]
-        to_all = False
-        if player_id < 0:
-            to_all = True
-            client = client[0]
-        if client and message:
-            t = self.loop.create_task(client.send_message(f"Server: {message}", to_all=to_all))
-            self.tasks.append(t)
-
-    def TriggerClientEvent(self, player_id, event_name, data):
-        # TODO: TriggerClientEvent
-        self.log.debug("request TriggerClientEvent()")
-
-    def TriggerClientEventJson(self, player_id, event_name, data):
-        # TODO: TriggerClientEventJson
-        self.log.debug("request TriggerClientEventJson()")
-
-    def GetPlayerCount(self):
-        self.log.debug("request GetPlayerCount()")
-        return len(ev.call_event("_get_player", cid=-1)[0])
-
-    def GetPositionRaw(self, player_id, car_id):
-        self.log.debug("request GetPositionRaw()")
-        client = ev.call_event("_get_player", cid=player_id)[0]
-        if client:
-            car = client.cars[car_id]
-            if car:
-                return self._lua.table_from(car['pos'])
-            return self._lua.table(), "Vehicle not found"
-        return self._lua.table(), "Client expired"
-
-    def IsPlayerConnected(self, player_id):
-        self.log.debug("request IsPlayerConnected()")
-        return bool(ev.call_event("_get_player", cid=player_id)[0])
-
-    def GetPlayerName(self, player_id):
-        self.log.debug("request GetPlayerName()")
-        client = ev.call_event("_get_player", cid=player_id)[0]
-        if client:
-            return client.nick
-        return
-
-    def RemoveVehicle(self, player_id, vehicle_id):
-        self.log.debug("request GetPlayerName()")
-        client = ev.call_event("_get_player", cid=player_id)[0]
-        if client:
-            t = self.loop.create_task(client._delete_car(car_id=vehicle_id))
-            self.tasks.append(t)
-
-    def GetPlayerVehicles(self, player_id):
-        self.log.debug("request GetPlayerVehicles()")
-        client = ev.call_event("_get_player", cid=player_id)[0]
-        if client:
-            return self._lua.table_from(
-                {i: f'{v["json"]}' for i, d in enumerate([i for i in client.cars if i is not None]) for k, v in
-                 d.items() if k == "json"})
-
-    def GetPlayers(self):
-        self.log.debug("request GetPlayers()")
-        clients = ev.call_event("_get_players", cid=-1)
-        return self._lua.table_from({i: n for i, n in enumerate(clients)})
-
-    def IsPlayerGuest(self, player_id) -> bool:
-        self.log.debug("request IsPlayerGuest()")
-        client = ev.call_event("_get_player", cid=player_id)[0]
-        if client:
-            return client.guest
-        return False
-
-    def DropPlayer(self, player_id, reason="Kicked"):
-        self.log.debug("request DropPlayer()")
-        client = ev.call_event("_get_player", cid=player_id)[0]
-        if client:
-            t = self.loop.create_task(client.kick(reason))
-            self.tasks.append(t)
-
-    def GetStateMemoryUsage(self):
-        self.log.debug("request GetStateMemoryUsage()")
-        return self._lua.get_memory_used()
-
-    def GetLuaMemoryUsage(self):
-        self.log.debug("request GetStateMemoryUsage()")
-        lua_plugins = ev.call_event("_lua_plugins_get")[0]
-        return sum(pl['lua'].get_memory_used() for pls in lua_plugins.values() for pl in pls.values())
-
-    def GetPlayerIdentifiers(self, player_id):
-        self.log.debug("request GetStateMemoryUsage()")
-        client = ev.call_event("_get_player", cid=player_id)[0]
-        if client:
-            return self._lua.table_from(client.identifiers)
-        return self._lua.table()
-
-    def Set(self, *args):
-        self.log.debug("request Set")
-        self.log.warning("KuiToi cannot support this: MP.Set()")
-
-    def Settings(self, *args):
-        self.log.debug("request Set")
-        self.log.warning("KuiToi cannot support this: MP.Settings()")
 
 
 class LuaPluginsLoader:
@@ -163,7 +43,6 @@ class LuaPluginsLoader:
         self.lua_dirs = []
         self.log = get_logger("LuaPluginsLoader")
         self.loaded_str = "Lua plugins: "
-        ev.register_event("_lua_plugins_get", lambda x: self.lua_plugins)
         ev.register_event("_lua_plugins_start", self.start)
         ev.register_event("_lua_plugins_unload", self.unload)
         console.add_command("lua_plugins", lambda x: self.loaded_str[:-2])
@@ -182,27 +61,21 @@ class LuaPluginsLoader:
 
         for path, obj in self.lua_dirs:
             # noinspection PyArgumentList
-            lua = LuaRuntime(encoding=config.enc, source_encoding=config.enc, unpack_returned_tuples=True)
+            lua = LuaRuntime(encoding=config.enc, source_encoding=config.enc)
-            lua.globals().printRaw = lua.globals().print
+            mp = MP(obj)
-            lua.globals().exit = lambda x: self.log.info(f"{obj}: You can't disable server..")
-            mp = MP(obj, lua)
             lua.globals().MP = mp
-            lua.globals().print = mp._print
+            lua.globals().printRaw = lua.globals().print
+            lua.globals().print = mp._print_log
+            lua.globals().exit = lambda x: self.log.info(f"{obj}: You can't disable server..")
             code = f'package.path = package.path.."' \
                    f';{self.plugins_dir}/{obj}/?.lua' \
-                   f';{self.plugins_dir}/{obj}/lua/?.lua"\n'
+                   f';{self.plugins_dir}/{obj}/lua/?.lua' \
+                   f';modules/PluginsLoader/lua_libs/?.lua"\n'
             with open("modules/PluginsLoader/add_in.lua", "r") as f:
                 code += f.read()
             with open(os.path.join(path, "main.lua"), 'r', encoding=config.enc) as f:
                 code += f.read()
-            try:
+            lua.execute(code)
-                lua.execute(code)
-                self.loaded_str += f"{obj}:ok, "
-                self.lua_plugins.update({obj: {"mp": mp, "lua": lua}})
-            except Exception as e:
-                self.log.error(f"Cannot load lua plugin from `{obj}/main.lua`")
-                self.log.exception(e)
-                self.loaded_str += f"{obj}:no, "
 
     async def start(self, _):
         ...