Use encoding="CP1251" for lua plugins;

I hate cobalt: cobaltSysChar!!!!!!!!!
Pretty errors
2026-02-16 10:30:57 +00:00 · 2023-07-24 04:58:08 +03:00 · 2023-07-24 04:54:55 +03:00 · 2023-07-24 04:54:36 +03:00 · 2023-07-24 01:30:11 +03:00 · 2023-07-24 00:03:04 +03:00
54 changed files with 3040 additions and 436 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -137,4 +137,6 @@ dmypy.json
 /src/plugins
 /test/
 *test.py
-logs/
+logs/
+*.yml
+*.toml
--- a/README.md
+++ b/README.md
@@ -1,57 +1,72 @@
 # KuiToi-Server

 ## About
-**_[Status: Alpha]_** \
+**_[Status: Beta]_** \
 BeamingDrive Multiplayer (BeamMP) server compatible with BeamMP clients.

 ## TODOs

- [ ] Server core
-  - [x] BeamMP System
+- [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
-  - [x] Plugins support
-    - [ ] KuiToi class
-    - [x] Load Python plugins
-    - [x] Async support
-    - [ ] Load Lua plugins (Original BeamMP compatibility)
+    - [ ] Add all events
+  - [x] Plugins supports
+    - [x] Python part:
+      - [x] Load Python plugins
+      - [x] Async support
+      - [x] KuiToi class
+      - [x] Client (Player) class
+    - [x] Lua part: (Original BeamMP compatibility)
+      - [x] Load Lua plugins
+      - [x] MP Class
+      - [x] Util class
+      - [x] FS class
  - [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
--- a/docs/cn/multilanguage/example.json
+++ b/docs/cn/multilanguage/example.json
@@ -0,0 +1,48 @@
+{
+  "": "基础阶段",
+  "hello": "来自KuiToi服务器的问候！",
+  "config_path": "使用{}进行配置。",
+  "init_ok": "初始化完成。",
+  "start": "服务器已启动！",
+  "stop": "服务器已停止！",
+
+  "": "服务器认证",
+  "auth_need_key": "需要BeamMP密钥才能启动！",
+  "auth_empty_key": "BeamMP密钥为空！",
+  "auth_cannot_open_browser": "无法打开浏览器：{}",
+  "auth_use_link": "使用此链接：{}",
+
+  "": "GUI阶段",
+  "GUI_yes": "是",
+  "GUI_no": "否",
+  "GUI_ok": "确定",
+  "GUI_cancel": "取消",
+  "GUI_need_key_message": "需要BeamMP密钥才能启动！\n是否在浏览器中打开链接以获取密钥？",
+  "GUI_enter_key_message": "请输入密钥：",
+  "GUI_cannot_open_browser": "无法打开浏览器。\n请使用此链接：{}",
+
+  "": "Web阶段",
+  "web_start": "WebAPI已启动{}（CTRL+C停止）",
+
+  "": "命令：man",
+  "man_message_man": "man - 显示COMMAND的帮助页面。\n用法：man COMMAND",
+  "help_message_man": "显示COMMAND的帮助页面。",
+  "man_for": "帮助页面",
+  "man_message_not_found": "man：找不到帮助页面。",
+  "man_command_not_found": "man：找不到\"{}\"命令！",
+
+  "": "命令：help",
+  "man_message_help": "help - 显示命令的名称和简短描述。\n用法：help [--raw]\n命令`help`列出所有可用的命令，并为每个命令提供简短描述。",
+  "help_message_help": "显示命令的名称和简短描述。",
+  "help_command": "命令",
+  "help_message": "文本",
+  "help_message_not_found": "无文本",
+
+  "": "命令：stop",
+  "man_message_stop": "stop - 关闭服务器。\n用法：stop",
+  "help_message_stop": "关闭服务器。",
+
+  "": "命令：exit",
+  "man_message_exit": "exit - 关闭服务器。\n用法：exit",
+  "help_message_exit": "关闭服务器。"
+}
--- a/docs/cn/multilanguage/readme.md
+++ b/docs/cn/multilanguage/readme.md
@@ -0,0 +1,3 @@
+# MultiLanguage - i18n支持
+
+在 [example.json](./example.json) 中是 [src/modules/i18n/files/ru.json](../../../src/modules/i18n/files/ru.json) 的副本。如果你想将其翻译成以前未翻译过的语言，或者更新现有的翻译，我将很高兴接受你的拉取请求。
--- a/docs/cn/plugins/classes.md
+++ b/docs/cn/plugins/classes.md
@@ -0,0 +1,174 @@
+# 传递的类
+
+## 值得一读
+
+1. 什么是“*args”和“**kwargs”？ -> [habr上的文章 ↗](https://habr.com/ru/companies/ruvds/articles/482464/)
+
+## KuiToi 
+_`kt = KuiToi("PluginName"")`_
+
+### kt.log
+_常量_\
+返回预配置的记录器
+
+### kt.name
+_常量_\
+返回插件名称
+
+### kt.dir
+_常量_\
+返回插件文件夹
+
+### kt.open()
+_与open()参数相同_\
+在kt.dir中打开文件
+
+### kt.register_event(event_name: str, event_func: function)
+_`event_name: str` -> 作为`event_func`调用的事件名称._\
+_`event_func: function` -> 要调用的函数._
+
+在`event_func`中，可以传递普通函数或async - 不需要提前进行await。\
+您也可以创建自己的事件，并使用自己的名称注册任意数量的事件。
+
+### kt.call_event(event_name: str, *args, **kwargs) -> list:
+_`event_name: str` -> 要调用的事件名称._\
+_`*args, **kwargs` -> 要传递给函数的参数._
+
+### **async** kt.call_async_event(event_name: str, *args, **kwargs) -> list:
+_`event_name: str` -> 要调用的事件名称._\
+_`*args, **kwargs` -> 要传递给函数的参数._\
+_需要用`await`调用_
+
+###### _建议阅读*args, **kwargs，链接在开头_
+所有事件的数据都以以下格式传递：`{"event_name": event_name, "args": args, "kwargs": kwargs}`\
+`args: list` -> 表示传递到事件中的数据数组\
+`kwargs: dict` -> 表示传递到事件中的数据字典
+数据将以数组形式从所有成功的波动中返回。
+
+### kt.call_lua_event(event_name: str, *args) -> list:
+_`event_name: str` -> 要调用的事件名称._\
+_`*args` -> 要传递给函数的参数._
+
+添加用于向后兼容性。\
+lua函数使用直接传递参数`lua_func(*args)`进行调用。
+
+### kt.get_player([pid: int], [nick: str]) -> Player | None:
+_`pid: int` -> Player ID - 玩家标识符._\
+_`nick: str` -> Player Nick - 玩家昵称._
+
+该方法通过其`pid`或`nick`返回玩家对象。\
+如果无法找到玩家，则返回 `None`。
+
+### kt.get_players() -> List[Player] | list:
+
+该方法返回所有玩家的数组。\
+如果没有玩家，则数组将为空。
+
+### kt.players_counter() -> int:
+
+该方法返回在线的玩家数量。
+
+### kt.is_player_connected([pid: int], [nick: str]) -> bool:
+_`pid: int` -> Player ID - 玩家标识符._\
+_`nick: str` -> Player Nick - 玩家昵称._
+
+该方法通过其`pid`或`nick`返回玩家对象。
+
+## Player (或 Client)
+_`pl = kt.get_player()`_\
+_`pl = event_data['kwargs']['player']`_
+
+### pl.log -> Logger
+_常量_\
+返回预配置的记录器
+
+### pl.addr -> str
+_常量_\
+返回玩家的 IP 地址
+
+### pl.pid -> int
+### pl.cid -> int
+_常量_\
+返回客户端的 ID _(pid: PlayerId = cid: ClientId)_
+
+### pl.key -> str
+_常量_\
+返回在身份验证期间传递的密钥
+
+### pl.nick -> str
+_变量_\
+从 BeamMP 服务器传递的昵称，可以更改，后果未知
+
+### pl.roles -> str
+_变量_\
+从 BeamMP 服务器传递的角色，可以更改（如果设置了不正确的角色，可能会发生意外情况。）
+
+### pl.guest -> bool
+_常量_\
+返回玩家是否为游客，从 BeamMP 服务器传递
+
+### pl.identifiers -> dict
+_常量_\
+标识符，从 BeamMP 服务器传递。
+
+### pl.ready -> bool
+_常量，由核心更改_\
+返回布尔值，如果为 True-> 玩家已下载所有资源，在地图上加载
+
+### pl.cars -> dict
+_常量，由核心更改_\
+按类型返回汽车字典：
+
+```python
+{
+    1: {
+        "packet": car_packet,
+        "json": car_json,
+        "json_ok": bool(car_json),
+        "snowman": snowman,
+        "over_spawn": (snowman and allow_snowman) or over_spawn,
+        "pos": {
+            "pos":[0,0,0],
+            "rvel":[0,0,0],
+            "rot":[0,0,0],
+            "vel":[0,0,0],
+            "tim":0,
+            "ping":0
+        }
+    },
+    2: ...
+}
+```
+其中 `1` - car_id\
+其中 `pkt` - 未处理的从客户端收到的数据包（仅供非常有经验的用户使用）\
+其中 `json` - 以 dict 形式存储的已处理的数据包\
+其中 `json_ok` - 核心是否能够处理数据包\
+其中 `snowman` - 车辆是否为雪人\
+其中 `over_spawn` - 车辆是否超过了生成限制（通过插件允许）\
+其中 `pos` - 车辆位置（通过 UDP 传递）
+
+### pl.last_position -> dict
+_常量，由核心更改_
+返回玩家的最后位置
+
+
+### **async** pl.kick([reason: str = "Kicked!"]) -> None
+_`reason: str` -> 踢出理由，参数可选，默认值为 `Kicked!`_
+将玩家踢出服务器
+
+### **async** pl.send_message(message: str, [to_all: bool = True]) -> None
+_`message: str` -> 消息文本，不带 "Server:"_
+_`to_all: bool` -> 是否向所有人发送此消息？参数可选，默认值为 `True`_
+向玩家或所有人发送消息
+
+### **async** pl.send_event(event_name: str, event_data: Any, [to_all: bool = True]) -> None
+_`event_name: str` -> 要调用的事件名称_
+_`event_data: Any` -> 发送到事件的数据。_
+_`to_all: bool` -> 是否向所有人发送此消息？参数可选，默认值为 `True`_
+将事件发送到客户端。\
+如果 event_data 是 tuple、list、dict，则核心会通过 json.dumps(event_data) 将其转换为 json，然后再发送。\
+否则，数据将是字符串，不受限制；
+
+### **async** pl.delete_car(self, car_id: int) -> None
+_`car_id: int` -> 要删除的车辆的 ID_
+删除玩家的车辆
--- a/docs/cn/plugins/events_list.md
+++ b/docs/cn/plugins/events_list.md
@@ -0,0 +1,3 @@
+# 所有可用事件列表
+
+大多数事件将包含`pl = data ['kwargs'] ['player']`，可以在[这里](./classes.md)找到描述。
--- a/docs/cn/plugins/examples/async_example.py
+++ b/docs/cn/plugins/examples/async_example.py
--- a/docs/cn/plugins/examples/example.py
+++ b/docs/cn/plugins/examples/example.py
--- a/docs/cn/plugins/lua/example.lua
+++ b/docs/cn/plugins/lua/example.lua
@@ -0,0 +1,27 @@
+print("example.lua")
+
+--CreateTimer Testing
+local mytimer = MP.CreateTimer()
+--.--.--.--.--.--.--.
+
+--GetOSName Testing
+print("OS Name: "..MP.GetOSName())
+--.--.--.--.--.--.-
+
+--GetServerVersion Testing
+local major, minor, patch = MP.GetServerVersion()
+print("Server Version: "..major.."."..minor.."."..patch)
+--.--.--.--.--.--.--.--.--
+
+--Events Testing--
+function handleChat(player_id, player_name, message)
+    print("Lua handleChat:", player_id, player_name, message, "; Uptime: "..mytimer:GetCurrent())
+    return 1
+end
+
+MP.RegisterEvent("onChatMessage", "handleChat")
+--.--.--.--.--.--.
+
+function onInit()
+    print("Initializing ready!")
+end
--- a/docs/cn/plugins/lua/readme.md
+++ b/docs/cn/plugins/lua/readme.md
@@ -0,0 +1,24 @@
+# BeamMP Lua反馈支持
+
+KiuToi几乎完全支持BeamMP的lua插件，所有必要的方法都已经创建，测试显示以下细节：
+
+在KiuToi中没有支持:`MP.Set()`
+
+#### Economic Rework V2.0（付费，Discord（RU）：[Hlebushek](https://discordapp.com/users/449634697593749516)）
+
+1. 要获取`pluginPath`，需要：`debug.getinfo(1).source:gsub("\\","/")` => `debug.getinfo(1).source:gsub("\\","/"):gsub("@", "")`，因为路径返回值中包含`@`，这破坏了插件。
+
+#### Cobalt Essentials V1.7.5（免费，[github ↗](https://github.com/prestonelam2003/CobaltEssentials/)）
+
+1. 要获取`pluginPath`，需要：`debug.getinfo(1).source:gsub("\\","/")` => `debug.getinfo(1).source:gsub("\\","/"):gsub("@", "")`，因为路径返回值中包含`@`，这破坏了插件。
+2. `cobaltSysChar` 
+
+### 工作原理
+
+插件加载经过几个阶段：
+
+1. 扫描`plugins/`文件夹
+2. 如果文件夹不在PyPlugins中，并且文件夹中存在`*.lua`，则添加它，例如`plugins/LuaPlugin`
+3. 然后从该文件夹中进行`lua.loadfile({filename})`（这是lua中的标准方法）
+4. 最后调用事件和函数`onInit()`
+5. 如果在执行`onInit()`期间没有发生错误，则可以通过`lua_plugins`命令看到这样的消息：`Lua plugins: LuaPlugin:ok`
--- a/docs/cn/plugins/readme.md
+++ b/docs/cn/plugins/readme.md
@@ -0,0 +1,97 @@
+# 插件系统
+
+### 事件：[这里](./events_list.md)
+### 类：[这里](./classes.md)
+
+## 使用带有“Dummy”的库
+###### （这意味着它没有服务器无法工作，但IDE将指导API）
+###### （库还在开发中）
+
+* 使用pip：\
+    `$ pip install KuiToi`
+* 从源代码安装：\
+    `git clone https://github.com/KuiToi/KuiToi-PyLib`
+
+## 示例
+
+```python
+try:
+    import KuiToi
+except ImportError:
+    pass
+
+kt = KuiToi("ExamplePlugin")
+log = kt.log
+
+def my_event_handler(event_data):
+    log.info(f"{event_data}")
+
+def load():
+    # 初始化插件
+    ev.register_event("my_event", my_event_handler)
+    log.info("插件已成功加载。")
+
+    
+def start():
+    # 启动插件进程
+    ev.call_event("my_event")
+    ev.call_event("my_event", "一些数据", data="一些数据也是")
+    log.info("插件已成功启动。")
+
+
+def unload():
+    # 结束所有进程的代码
+    log.info("插件已成功卸载。")
+```
+
+您还可以在[example.py](examples/example.py)中找到更广泛的示例。
+
+* 建议在`load()`后使用`open()`，否则应使用`kt.load()`-在`plugin/<plugin_name>/<filename>`文件夹中创建一个文件
+* 创建自己的事件：`kt.register_event("my_event", my_event_function)`-
+* 调用事件：`kt.call_event("my_event")`
+* 使用数据调用事件：`kt.call_event("my_event", data, data2=data2)`
+* 基本事件：_稍后会写_
+
+## 异步函数
+
+支持async
+
+```python
+try:
+    import KuiToi
+except ImportError:
+    pass
+
+kt = KuiToi("Example")
+log = kt.log
+
+
+async def my_event_handler(event_data):
+    log.info(f"{event_data}")
+
+    
+async def load():
+    # 初始化插件
+    ev.register_event("my_event", my_event_handler)
+    log.info("插件已成功加载。")
+
+
+async def start():
+    # 启动插件进程
+    await ev.call_async_event("my_event")
+    await ev.call_async_event("my_event", "一些数据", data="一些数据也是")
+    log.info("插件已成功启动。")
+
+
+async def unload():
+    # 结束所有进程的代码
+    log.info("插件已成功卸载。")
+
+```
+
+您还可以在[async_example.py](examples/async_example.py)中找到更广泛的示例。
+
+* 创建自己的事件：`kt.register_event("my_event", my_event_function)`（在register_event中检查函数）
+* 调用async事件：`kt.call_async_event("my_event")`
+* 使用数据调用async事件：`kt.call_async_event("my_event", data, data2=data2)`
+* 基本的async事件：_稍后会写_
--- a/docs/cn/readme.md
+++ b/docs/cn/readme.md
@@ -0,0 +1,10 @@
+# KuiToi服务器文档
+
+### 文档尚未完善，但终有一天会完善
+
+1. 服务器设置和启动 - [这里](./setup)
+2. 插件和事件系统 - [这里](./plugins)
+3. Lua的细微差别 - [这里](./plugins/lua)
+4. 多语言支持 - [这里](./multilanguage)
+5. KuiToi WebAPI - [这里](./web)
+6. 将会有新的内容...
--- a/docs/cn/setup/readme.md
+++ b/docs/cn/setup/readme.md
@@ -0,0 +1,88 @@
+# 来自 KuiToi 服务器的问候
+
+## 好的，让我们开始吧
+
+###### _(这里是 Linux 的命令)_
+
+* 运行它需要 **Python 3.10.x**！只有这个版本才能运行，Python 3.11 不支持...
+* 您可以像这样检查 Python 版本（你要在这里笑）：
+```bash
+python3 --version  # Python 3.10.6
+```
+* 克隆存储库并导航到它
+* 安装所有必需的内容
+* 然后，使用我的“脚本”，删除所有不必要的文件并移动到核心源
+```bash
+git clone -b Stable https://github.com/kuitoi/KuiToi-Server.git && cd KuiToi-Server
+pip install -r requirements.txt
+mv ./src/ $HOME/ktsrc/ && rm -rf ./* && mv $HOME/ktsrc/* . && rm -rf $HOME/ktsrc
+```
+* 这是如何检查服务器信息并启动它的方法：
+```bash
+python3 main.py --help  # 显示所有可用命令
+python3 main.py # 启动服务器
+```
+
+## 配置
+
+* 启动后，将创建 `kuitoi.yaml`
+* 默认情况下，它如下所示：
+```yaml
+!!python/object:modules.ConfigProvider.config_provider.Config
+Auth:
+  key: null
+  private: true
+Game:
+  map: gridmap_v2
+  max_cars: 1
+  players: 8
+Options:
+  debug: false
+  encoding: utf-8
+  language: en
+  log_chat: true
+  speed_limit: 0
+  use_lua: true
+  use_queue: false
+Server:
+  description: Welcome to KuiToi Server!
+  name: KuiToi-Server
+  server_ip: 0.0.0.0
+  server_port: 30814
+WebAPI:
+  enabled: false
+  secret_key: 3838ccb03c86cdb386b67fbfdcba62d0
+  server_ip: 127.0.0.1
+  server_port: 8433
+```
+### Auth
+
+* 如果您将 `private: false` 并且不设置 `key`，服务器将请求一个 BeamMP 密钥，没有它无法启动。
+* 输入 BeamMP 密钥后，服务器将出现在启动器列表中。
+* 您可以在此处获取密钥：[https://beammp.com/k/keys ↗](https://beammp.com/k/keys)
+
+### Game
+
+* `map` 仅为地图名称，即打开具有地图的 mod 在 `map.zip/levels` - 地图名称将在那里，那就是我们插入的地方。
+* `max_cars` - 每个玩家的最大汽车数量
+* `players` - 最大玩家数
+
+### Options
+
+* `debug` - 是否输出调试消息（仅适用于有经验的用户，会略微降低性能）
+* `encoding` - 使用哪种编码打开文件
+* `language` - 服务器将使用哪种语言启动（当前可用：en，ru）
+* `log_chat` - 是否将聊天输出到控制台
+* `speed_limit` - 下载 mod 的下载速度限制（以 MB/s 为单位）
+* `use_lua` - 启用 lua 支持
+* `use_queue` - 按队列下载 mod，即一次只能下载一个客户端
+
+### Server
+
+* `description` - BeamMP 启动器的服务器描述
+* `name` - BeamMP 启动器的服务器名称
+* `server_ip` - 分配给服务器的 IP 地址（仅适用于有经验的用户，默认为 0.0.0.0）
+* `server_port` - 服务器将在哪个端口上工作
+
+### WebAPI
+##### _文档尚未准备好_
--- a/docs/cn/web/readme.md
+++ b/docs/cn/web/readme.md
@@ -0,0 +1,13 @@
+# 服务器的 WebAPI
+
+## 可用的端点
+
+* `/stop`:
+  * 必需参数：
+    * `secret_key` - 在服务器配置中指定的密钥
+
+
+* `/event.get`
+  * 这个端点还没有准备好
+  * 必需参数：
+    * `secret_key` - 在服务器配置中指定的密钥
--- a/docs/en/plugins/classes.md
+++ b/docs/en/plugins/classes.md
@@ -0,0 +1,298 @@
+Sure, here's a translation of the text:
+
+# Passed Classes
+
+## Worth looking at
+
+1. What are `*args` and `**kwargs`? -> [Post on Habr (RU)](https://habr.com/ru/companies/ruvds/articles/482464/)
+
+## KuiToi 
+_`kt = KuiToi("PluginName"")`_
+
+### kt.log
+_Constant_\
+Returns a pre-configured logger
+
+### kt.name
+_Constant_\
+Returns the name of the plugin
+
+### kt.dir
+_Constant_\
+Returns the directory of the plugin
+
+### kt.open()
+_Parameters are the same as for open()_\
+Opens a file in kt.dir
+
+### kt.register_event(event_name: str, event_func: function)
+_`event_name: str` -> The name of the event that `event_func` will be called on._\
+_`event_func: function` -> The function that will be called._
+
+In `event_func`, you can pass both regular functions and async functions - you don't need to make them async beforehand.\
+You can also create your own events with your own names.\
+You can register an unlimited number of events.
+
+### kt.call_event(event_name: str, *args, **kwargs) -> list:
+_`event_name: str` -> The name of the event to call._\
+_`*args, **kwargs` -> Arguments to be passed to the function._
+
+### **async** kt.call_async_event(event_name: str, *args, **kwargs) -> list:
+_`event_name: str` -> The name of the event to call._\
+_`*args, **kwargs` -> Arguments to be passed to the function._\
+_Must be called with `await`_
+
+###### _I recommend familiarizing yourself with *args, **kwargs_, there is a link at the beginning
+Data is passed to all events in the form of: `{"event_name": event_name, "args": args, "kwargs": kwargs}`\
+`args: list` -> Represents an array of data passed to the event\
+`kwargs: dict` -> Represents a dictionary of data passed to the event
+The data will be returned from all successful attempts in an array.
+
+### kt.call_lua_event(event_name: str, *args) -> list:
+_`event_name: str` -> The name of the event to call._\
+_`*args` -> Arguments to be passed to the function._
+
+Added to support backward compatibility.\
+The lua function is called with a direct transmission of arguments `lua_func(*args)`
+
+### kt.get_player([pid: int], [nick: str]) -> Player | None:
+_`pid: int` -> Player ID - The identifier of the player._\
+_`nick: str` -> Player Nickname - The name of the player._
+
+The method returns a player object by their `pid` or `nick`.\
+If the player cannot be found, `None` will be returned.
+
+### kt.get_players() -> List[Player] | list:
+
+The method returns an array with all players.\
+The array will be empty if there are no players.
+
+### kt.players_counter() -> int:
+
+The method returns the number of players currently online.
+
+### kt.is_player_connected([pid: int], [nick: str]) -> bool:
+_`pid: int` -> Player ID - The identifier of the player._\
+_`nick: str` -> Player Nickname - The name of the player._
+
+The method returns a player object by their `pid` or `nick`.
+
+## Player (or Client) 
+_`pl = kt.get_player()`_\
+_`pl = event_data['kwargs']['player']`_
+
+### pl.log -> Logger
+_Constant_\
+Returns a pre-configured logger
+
+### pl.addr -> str
+_Constant_\
+Returns the IP address of the player
+
+### pl.pid -> int
+### pl.cid -> int
+_Constant_\
+Returns the client ID _(pid: PlayerId = cid: ClientId)_
+
+### pl.key -> str
+_Constant_\
+Returns the key passed during authentication
+
+### pl.nick -> str
+_Variable_\
+The nickname passed during authentication from the BeamMP server, can be changed, consequences are untested
+
+### pl.roles -> str
+_Variable_\
+The role passed during authentication from the BeamMP server, can be changed (if an incorrect role is set, unexpected things may happen.)
+
+### pl.guest -> bool
+_Constant_\
+Returns whether the player is a guest, passed during authentication from the BeamMP server
+
+### pl.identifiers -> dict
+_Constant_\
+Identifiers passed during authentication from the BeamMP server.
+
+### pl.ready -> bool
+_Constant, changed by the core_\
+Returns a bool value, if True -> the player has downloaded all resources, loaded on the map
+
+### pl.cars -> dict
+_Constant, changed by the core_\
+Returns a dictionary of cars like thisSure, here's the translation:
+
+# Passed Classes
+
+## Worth looking at
+
+1. What are `*args` and `**kwargs`? -> [Post on Habr ↗](https://habr.com/ru/companies/ruvds/articles/482464/)
+
+## KuiToi 
+_`kt = KuiToi("PluginName"")`_
+
+### kt.log
+_Constant_\
+Returns a pre-configured logger
+
+### kt.name
+_Constant_\
+Returns the name of the plugin
+
+### kt.dir
+_Constant_\
+Returns the directory of the plugin
+
+### kt.open()
+_Parameters are the same as for open()_\
+Opens a file in kt.dir
+
+### kt.register_event(event_name: str, event_func: function)
+_`event_name: str` -> The name of the event that `event_func` will be called on._\
+_`event_func: function` -> The function that will be called._
+
+In `event_func`, you can pass both regular functions and async functions - you don't need to make them async beforehand.\
+You can also create your own events with your own names.\
+You can register an unlimited number of events.
+
+### kt.call_event(event_name: str, *args, **kwargs) -> list:
+_`event_name: str` -> The name of the event to call._\
+_`*args, **kwargs` -> Arguments to be passed to the function._
+
+### **async** kt.call_async_event(event_name: str, *args, **kwargs) -> list:
+_`event_name: str` -> The name of the event to call._\
+_`*args, **kwargs` -> Arguments to be passed to the function._\
+_Must be called with `await`_
+
+###### _I recommend familiarizing yourself with *args, **kwargs_, there is a link at the beginning
+Data is passed to all events in the form of: `{"event_name": event_name, "args": args, "kwargs": kwargs}`\
+`args: list` -> Represents an array of data passed to the event\
+`kwargs: dict` -> Represents a dictionary of data passed to the event
+The data will be returned from all successful attempts in an array.
+
+### kt.call_lua_event(event_name: str, *args) -> list:
+_`event_name: str` -> The name of the event to call._\
+_`*args` -> Arguments to be passed to the function._
+
+Added to support backward compatibility.\
+The lua function is called with a direct transmission of arguments `lua_func(*args)`
+
+### kt.get_player([pid: int], [nick: str]) -> Player | None:
+_`pid: int` -> Player ID - The identifier of the player._\
+_`nick: str` -> Player Nickname - The name of the player._
+
+The method returns a player object by their `pid` or `nick`.\
+If the player cannot be found, `None` will be returned.
+
+### kt.get_players() -> List[Player] | list:
+
+The method returns an array with all players.\
+The array will be empty if there are no players.
+
+### kt.players_counter() -> int:
+
+The method returns the number of players currently online.
+
+### kt.is_player_connected([pid: int], [nick: str]) -> bool:
+_`pid: int` -> Player ID - The identifier of the player._\
+_`nick: str` -> Player Nickname - The name of the player._
+
+The method returns a player object by their `pid` or `nick`.
+
+## Player (or Client)
+_`pl = kt.get_player()`_\
+_`pl = event_data['kwargs']['player']`_
+
+### pl.log -> Logger
+_Constant_\
+Returns a preconfigured logger.
+
+### pl.addr -> str
+_Constant_\
+Returns the player's IP address.
+
+### pl.pid -> int
+### pl.cid -> int
+_Constant_\
+Returns the client ID _(pid: PlayerId = cid: ClientId)_.
+
+### pl.key -> str
+_Constant_\
+Returns the key passed during authorization.
+
+### pl.nick -> str
+_Variable_\
+Nickname passed during authorization from the BeamMP server, can be changed, consequences are not tested.
+
+### pl.roles -> str
+_Variable_\
+Role passed during authorization from the BeamMP server, can be changed (If the wrong role is set, unexpected behavior may occur.)
+
+### pl.guest -> bool
+_Constant_\
+Returns whether the player is a guest, passed during authorization from the BeamMP server.
+
+### pl.identifiers -> dict
+_Constant_\
+Identifiers passed during authorization from the BeamMP server.
+
+### pl.ready -> bool
+_Constant, changed by the core_\
+Returns a bool value, if True -> player has downloaded all resources and loaded on the map.
+
+### pl.cars -> dict
+_Constant, changed by the core_\
+Returns a dictionary of cars by type:
+
+```python
+{
+    1: {
+        "packet": car_packet,
+        "json": car_json,
+        "json_ok": bool(car_json),
+        "snowman": snowman,
+        "over_spawn": (snowman and allow_snowman) or over_spawn,
+        "pos": {
+            "pos":[0,0,0],
+            "rvel":[0,0,0],
+            "rot":[0,0,0],
+            "vel":[0,0,0],
+            "tim":0,
+            "ping":0
+        }
+    },
+    2: ...
+}
+```
+Where `1` - car_id\
+Where `pkt` - Unprocessed packet that came from the client (For very experienced users)\
+Where `json` - Processed packet stored as dict\
+Where `json_ok` - Whether the core was able to process the packet\
+Where `snowman` - Is the car a snowman\
+Where `over_spawn` - Is the car spawned over the limit (Allowed through plugins)\
+Where `pos` - Car position (Passed through UDP)
+
+### pl.last_position -> dict
+_Constant, changed by the core_\
+Returns the player's last position
+
+### **async** pl.kick([reason: str = "Kicked!"]) -> None
+_`reason: str` -> Kick reason. Parameter is optional, by default: `Kicked!`_\
+Kicks the player from the server.
+
+### **async** pl.send_message(message: str, [to_all: bool = True]) -> None
+_`message: str` -> Message text, sent without "Server:"_\
+_`to_all: bool` -> Should this message be sent to everyone? Parameter is optional, by default: `True`_\
+Sends a message to the player or everyone.
+
+### **async** pl.send_event(event_name: str, event_data: Any, [to_all: bool = True]) -> None
+_`event_name: str` -> Name of the event that will be called_\
+_`event_data: Any` -> Data sent to the event._\
+_`to_all: bool` -> Should this message be sent to everyone? Parameter is optional, by default: `True`_\
+Sends an event to the client.\
+If event_data is a tuple, list, dict, then before sending the core converts it to JSON via json.dumps(event_data)\
+Otherwise, the data will be a string without regulation.
+
+### **async** pl.delete_car(self, car_id: int) -> None
+_`car_id: int` -> Car ID_\
+Deletes the player's car.
--- a/docs/en/plugins/events_list.md
+++ b/docs/en/plugins/events_list.md
@@ -0,0 +1,4 @@
+# List of available events
+
+Most events will receive `pl = data['kwargs']['player']`, you can find a description [here](./classes.md)
+
--- a/docs/en/plugins/examples/async_example.py
+++ b/docs/en/plugins/examples/async_example.py
--- a/docs/en/plugins/examples/example.py
+++ b/docs/en/plugins/examples/example.py
--- a/docs/en/plugins/lua/example.lua
+++ b/docs/en/plugins/lua/example.lua
@@ -0,0 +1,27 @@
+print("example.lua")
+
+--CreateTimer Testing
+local mytimer = MP.CreateTimer()
+--.--.--.--.--.--.--.
+
+--GetOSName Testing
+print("OS Name: "..MP.GetOSName())
+--.--.--.--.--.--.-
+
+--GetServerVersion Testing
+local major, minor, patch = MP.GetServerVersion()
+print("Server Version: "..major.."."..minor.."."..patch)
+--.--.--.--.--.--.--.--.--
+
+--Events Testing--
+function handleChat(player_id, player_name, message)
+    print("Lua handleChat:", player_id, player_name, message, "; Uptime: "..mytimer:GetCurrent())
+    return 1
+end
+
+MP.RegisterEvent("onChatMessage", "handleChat")
+--.--.--.--.--.--.
+
+function onInit()
+    print("Initializing ready!")
+end
--- a/docs/en/plugins/lua/readme.md
+++ b/docs/en/plugins/lua/readme.md
@@ -0,0 +1,24 @@
+# Providing Backward Compatibility for BeamMP Lua
+
+KiuToi provides almost full support for lua plugins with BeamMP. All necessary methods have been created, and testing has revealed the following nuances:
+
+KiuToi does not support: `MP.Set()`
+
+#### Economic Rework V2.0 (Paid, Discord (RU): [Hlebushek](https://discordapp.com/users/449634697593749516))
+
+1. To obtain `pluginPath`, use: `debug.getinfo(1).source:gsub("\\","/")` => `debug.getinfo(1).source:gsub("\\","/"):gsub("@", "")` as the path returns with `@`, which broke the plugin.
+
+#### Cobalt Essentials V1.7.5 (Free, [github](https://github.com/prestonelam2003/CobaltEssentials/))
+
+1. To obtain `pluginPath`, use: `debug.getinfo(1).source:gsub("\\","/")` => `debug.getinfo(1).source:gsub("\\","/"):gsub("@", "")` as the path returns with `@`, which broke the plugin.
+2. `cobaltSysChar` 
+
+### A Little About How it Works
+
+Plugin loading goes through several stages:
+
+1. The `plugins/` folder is scanned.
+2. If the folder is not in PyPlugins and there are `*.lua` files in the folder, then it is added as a plugin folder, let's say it will be `plugins/LuaPlugin`
+3. Next, `lua.loadfile({filename})` is performed from this folder (this is the standard method in lua).
+4. Finally, the `onInit()` function is called, and an event is triggered.
+5. If no errors occur during the execution of `onInit()`, you can see the message `Lua plugins: LuaPlugin:ok` through the `lua_plugins` command.
--- a/docs/en/plugins/readme.md
+++ b/docs/en/plugins/readme.md
@@ -1,12 +1,18 @@
-# Plugin System
+Это описание системы плагинов для KuiToi сервера на Python:

-## Installing the Library with "Stubs"
-###### (This means that it will not work without a server, but the IDE will suggest the API)
-###### (The library is still under development)
+## Events
+### Events list: [here](./events_list.md)
+
+## Classes
+### Classes list: [here](./classes.md)
+
+## Installing the library with "stubs"
+###### (This means it won't work without the server, but your IDE will suggest the API)
+###### (The library is still in development)

 * Using pip:\
    `$ pip install KuiToi`
-* From source code:\
+* From source:\
    `git clone https://github.com/KuiToi/KuiToi-PyLib`

 ## Example
@@ -17,7 +23,7 @@ try:
 except ImportError:
    pass

-kt = KuiToi("Example")
+kt = KuiToi("ExamplePlugin")
 log = kt.log

 def my_event_handler(event_data):
@@ -25,14 +31,14 @@ def my_event_handler(event_data):

 def load():
    # Plugin initialization
-    ev.register_event("my_event", my_event_handler)
+    kt.register_event("my_event", my_event_handler)
    log.info("Plugin loaded successfully.")

    
 def start():
-    # Running plugin processes
-    ev.call_event("my_event")
-    ev.call_event("my_event", "Some data", data="some data too")
+    # Starting plugin processes
+    kt.call_event("my_event")
+    kt.call_event("my_event", "Some data", data="some data too")
    log.info("Plugin started successfully.")


@@ -41,15 +47,17 @@ def unload():
    log.info("Plugin unloaded successfully.")
 ```

-* It is recommended to use `open()` after `load()`. Otherwise, use `kt.load()` - creates a file in the `plugin/<plugin_name>/<filename>` folder.
-* Creating your own event: `kt.register_event("my_event", my_event_function)`
+A more comprehensive example can also be found in [example.py](examples/example.py)
+
+* It is recommended to use `open()` after `load()`, otherwise use `kt.load()` - It creates a file in the `plugin/<plugin_name>/<filename>` folder.
+* Creating your own event: `kt.register_event("my_event", my_event_function)` - 
 * Calling an event: `kt.call_event("my_event")`
 * Calling an event with data: `kt.call_event("my_event", data, data2=data2)`
-* Basic events: _Will write later_
+* Base events: _To be added later_

-## Async Functions
+## Async functions

-Async support is available.
+Async support is available

 ```python
 try:
@@ -64,17 +72,17 @@ log = kt.log
 async def my_event_handler(event_data):
    log.info(f"{event_data}")

-
+    
 async def load():
    # Plugin initialization
-    ev.register_event("my_event", my_event_handler)
+    kt.register_event("my_event", my_event_handler)
    log.info("Plugin loaded successfully.")


 async def start():
-    # Running plugin processes
-    await ev.call_async_event("my_event")
-    await ev.call_async_event("my_event", "Some data", data="some data too")
+    # Starting plugin processes
+    await kt.call_async_event("my_event")
+    await kt.call_async_event("my_event", "Some data", data="some data too")
    log.info("Plugin started successfully.")


@@ -84,9 +92,9 @@ async def unload():

 ```

-A more extensive example can also be found in [async_example.py](./async_example.py).
+A more comprehensive example can also be found in [async_example.py](examples/async_example.py)

-* Creating your own event: `kt.register_event("my_event", my_event_function)` (register_event checks for function)
+* Creating your own event: `kt.register_event("my_event", my_event_function)` (register_event has a function check)
 * Calling an async event: `kt.call_async_event("my_event")`
 * Calling an async event with data: `kt.call_async_event("my_event", data, data2=data2)`
-* Basic async events: _Will write later_
+* Base async events: _To be added later_
--- a/docs/en/readme.md
+++ b/docs/en/readme.md
@@ -1,9 +1,10 @@
 # Documentation for KuiToi Server

-### The documentation is not perfect yet, but it will be one day
-    
-1. Setup and Start server - [here](setup)
-2. Plugins and Events system - [here](plugins)
-3. MultiLanguage - [here](./multilanguage)
-4. KuiToi WebAPI - [here](./web)
-5. Something new...
+### The documentation is not yet perfect, but someday it will be.
+
+1. Setup and Launching the Server - [here](./setup)
+2. Plugins and Event System - [here](./plugins)
+3. Nuances of Working with Lua - [here](./plugins/lua)
+4. Multilanguage Support - [here](./multilanguage)
+5. KuiToi WebAPI - [here](./web)
+6. Something new will be added here soon...
--- a/docs/en/setup/readme.md
+++ b/docs/en/setup/readme.md
@@ -1,31 +1,31 @@
 # Greetings from KuiToi Server

-## Well, let's begin
+## Well, let's start

 ###### _(Here are the commands for Linux)_

-* **Python 3.10.x** is required to run the server! It won't work on Python 3.11...
-* You can check the version of your Python installation with the following command:
+* **Python 3.10.x** is required to run it! Only this version works, it won't work on Python 3.11...
+* You can check your Python version like this (you have to laugh here):
 ```bash
 python3 --version  # Python 3.10.6
 ```
-* Clone the repository and navigate to it.
-* Install everything that's needed.
-* Then, using my "script", remove all unnecessary files and move to the core source code.
+* Clone the repository and navigate to it
+* Install everything necessary
+* Then, using my "script", remove all unnecessary files and move to the core source
 ```bash
 git clone -b Stable https://github.com/kuitoi/KuiToi-Server.git && cd KuiToi-Server
 pip install -r requirements.txt
 mv ./src/ $HOME/ktsrc/ && rm -rf ./* && mv $HOME/ktsrc/* . && rm -rf $HOME/ktsrc
 ```
-* Here's how to view information about the server and start it:
+* Here's how you can check server info and start it:
 ```bash
-python3 main.py --help  # Displays all available commands
+python3 main.py --help  # Shows all available commands
 python3 main.py # Starts the server
 ```

 ## Configuration

-* After starting the server, a `kuitoi.yaml` file will be created.
+* After starting, `kuitoi.yaml` will be created
 * By default, it looks like this:
 ```yaml
 !!python/object:modules.ConfigProvider.config_provider.Config
@@ -36,40 +36,53 @@ Game:
  map: gridmap_v2
  max_cars: 1
  players: 8
-Server:
+Options:
  debug: false
-  description: Welcome to KuiToi Server!
+  encoding: utf-8
  language: en
+  log_chat: true
+  speed_limit: 0
+  use_lua: true
+  use_queue: false
+Server:
+  description: Welcome to KuiToi Server!
  name: KuiToi-Server
  server_ip: 0.0.0.0
-  server_port: 30813
+  server_port: 30814
 WebAPI:
  enabled: false
-  secret_key: <random_key>
+  secret_key: 3838ccb03c86cdb386b67fbfdcba62d0
  server_ip: 127.0.0.1
  server_port: 8433
-
 ```
 ### Auth

-* If you set `private: false` and do not set a `key`, the server will request a BeamMP key and will not start without it.
-* By entering a BeamMP key, the server will appear in the launcher list.
-* You can get a key here: [https://beammp.com/k/keys ↗](https://beammp.com/k/keys)
+* If you set `private: false` and don't set a `key`, the server will request a BeamMP key and won't start without it.
+* After entering a BeamMP key, the server will appear in the launcher list.
+* You can get the key here: [https://beammp.com/k/keys ↗](https://beammp.com/k/keys)

 ### Game

-* `map` specifies only the name of the map. That is, open the mod with the map in `map.zip/levels` - the name of the map will be there, and that's what you need to insert.
-* `max_cars` - the maximum number of cars per player
-* `players` - the maximum number of players
+* `map` is only the name of the map, i.e. open the mod with the map in `map.zip/levels` - the name of the map will be there, that's what we insert.
+* `max_cars` - Maximum number of cars per player
+* `players` - Maximum number of players
+
+### Options
+
+* `debug` - Whether to output debug messages (for experienced users only, slightly reduces performance)
+* `encoding` - Which encoding to use to open files
+* `language` - Which language the server will start with (currently available: en, ru)
+* `log_chat` - Whether to output chat to the console
+* `speed_limit` - Download speed limit for mods (in MB/s)
+* `use_lua` - Enable lua support
+* `use_queue` - Download mods in queue, i.e. only 1 client can download at a time

 ### Server

-* `debug` - should debug messages be displayed (for experienced users only; slightly affects performance)
-* `description` - server description for the BeamMP launcher
-* `language` - the language in which the server will run (currently available: en, ru)
-* `name` - server name for the BeamMP launcher
-* `server_ip` - the IP address to be used by the server (for experienced users only; defaults to 0.0.0.0)
-* `server_port` - the port on which the server will run
+* `description` - Server description for the BeamMP launcher
+* `name` - Server name for the BeamMP launcher
+* `server_ip` - IP address to assign to the server (for experienced users only, defaults to 0.0.0.0)
+* `server_port` - On which port the server will work

 ### WebAPI
-##### _Docs are not ready yet_
+##### _Docs are not ready_
--- a/docs/readme.md
+++ b/docs/readme.md
@@ -1,4 +1,5 @@
 # Choose your language

-### [English](./en)
 ### [Русский](./ru)
+### [English](./en) (AI translation)
+### [Chinese](./cn) (AI translation)
--- a/docs/ru/plugins/classes.md
+++ b/docs/ru/plugins/classes.md
@@ -0,0 +1,175 @@
+# Передаваемые классы
+
+## Стоит ознакомится
+
+1. Что такое `*args` и `**kwargs`? -> [Пост на habr](https://habr.com/ru/companies/ruvds/articles/482464/)
+
+## KuiToi 
+_`kt = KuiToi("PluginName"")`_
+
+### kt.log
+_Константа_\
+Вернёт преднастроенный логгер
+
+### kt.name
+_Константа_\
+Вернёт имя плагина
+
+### kt.dir
+_Константа_\
+Вернёт папку плагина
+
+### kt.open()
+_Параметры как у open()_\
+Открывает файл в kt.dir
+
+### kt.register_event(event_name: str, event_func: function)
+_`event_name: str` -> Имя ивента, по которому будет вызвана `event_func`._\
+_`event_func: function` -> Функция, которая будет вызвана._
+
+В `event_func` можно передавать как обычную функцию, так и async - await не нужно делать заранее.\
+Ивенты можно создавать так же свои, со своим именем.\
+Зарегистрировать можно не ограниченное кол-во ивентов.
+
+### kt.call_event(event_name: str, *args, **kwargs) -> list:
+_`event_name: str` -> Имя ивента, который будет вызван._\
+_`*args, **kwargs` -> Аргументы, передаваемые во функции._
+
+### **async** kt.call_async_event(event_name: str, *args, **kwargs) -> list:
+_`event_name: str` -> Имя ивента, который будет вызван._\
+_`*args, **kwargs` -> Аргументы, передаваемые во функции._\
+_Необходимо вызывать с `await`_
+
+###### _Советую ознакомиться с *args, **kwargs_, ссылка есть в начале
+Данные во все ивенты приходят по типу: `{"event_name": event_name, "args": args, "kwargs": kwargs}`\
+`args: list` -> Представляет из себя массив данных, которые переданы в ивент\
+`kwargs: dict` -> Представляет из себя словарь данных, которые переданы в ивент
+Данные вернутся от всех удачных волнений в массиве.
+
+### kt.call_lua_event(event_name: str, *args) -> list:
+_`event_name: str` -> Имя ивента, который будет вызван._\
+_`*args` -> Аргументы, передаваемые во функции._
+
+Добавлено для поддержки обратной совместимости.\
+lua функция вызывается с прямой передачей аргументов `lua_func(*args)`
+
+### kt.get_player([pid: int], [nick: str]) -> Player | None:
+_`pid: int` -> Player ID - Идентификатор игрока._\
+_`nick: str` -> Player Nick - Ник игрока._
+
+Метод возвращает объект игрока по его `pid` или `nick`.\
+Если не удалось найти игрока вернётся `None`.
+
+### kt.get_players() -> List[Player] | list:
+
+Метод возвращает массив со всеми игроками.\
+Массив будет пустой, если игроков нет.
+
+### kt.players_counter() -> int:
+
+Метод возвращает количество игроков, которые сейчас онлайн.
+
+### kt.is_player_connected([pid: int], [nick: str]) -> bool:
+_`pid: int` -> Player ID - Идентификатор игрока._\
+_`nick: str` -> Player Nick - Ник игрока._
+
+Метод возвращает объект игрока по его `pid`, `nick`.
+
+## Player (или Client) 
+_`pl = kt.get_player()`_\
+_`pl = event_data['kwargs']['player']`_
+
+### pl.log -> Logger
+_Константа_\
+Вернёт преднастроенный логгер
+
+### pl.addr -> str
+_Константа_\
+Вернёт IP адрес игрока
+
+### pl.pid -> int
+### pl.cid -> int
+_Константа_\
+Вернёт id клиента _(pid: PlayerId = cid: ClientId)_
+
+### pl.key -> str
+_Константа_\
+Вернёт ключ, переданный при авторизации
+
+### pl.nick -> str
+_Переменная_\
+Ник, переданные при авторизации от сервера BeamMP, можно изменить, последствия не проверенны
+
+### pl.roles -> str
+_Переменная_\
+Роль, переданная при авторизации от сервера BeamMP, можно изменить (Если установить не верную роль, могут происходить неожиданности.)
+
+### pl.guest -> bool
+_Константа_\
+Вернёт является ли игрок гостем, передаётся при авторизации от сервера BeamMP
+
+### pl.identifiers -> dict
+_Константа_\
+Идентификаторы, передаются при авторизации от сервера BeamMP.
+
+### pl.ready -> bool
+_Константа, меняется ядром_\
+Вернёт bool значение, если True -> игрок скачал все ресурсы, прогрузился на карте
+
+### pl.cars -> dict
+_Константа, меняется ядром_\
+Возвращает словарь автомобилей по типу:
+
+```python
+{
+    1: {
+        "packet": car_packet,
+        "json": car_json,
+        "json_ok": bool(car_json),
+        "snowman": snowman,
+        "over_spawn": (snowman and allow_snowman) or over_spawn,
+        "pos": {
+            "pos":[0,0,0],
+            "rvel":[0,0,0],
+            "rot":[0,0,0],
+            "vel":[0,0,0],
+            "tim":0,
+            "ping":0
+        }
+    },
+    2: ...
+}
+```
+Где `1` - car_id\
+Где `pkt` - Необработанный пакет который пришел от клиента (Для очень опытных пользователй) \
+Где `json` - Обработанный пакет, хранящийся в виде dict\
+Где `json_ok` - Смогло ли ядро обработать пакет\
+Где `snowman` - Снеговик ли машина\
+Где `over_spawn` - Заспавнена ли машина сверх лимита (Разрешается через плагины)\
+Где `pos` - Позиция машины (Передаётся через udp)
+
+### pl.last_position -> dict
+_Константа, меняется ядром_
+Возвращает последнюю позицию игрока
+
+
+### **async** pl.kick([reason: str = "Kicked!"]) -> None
+_`reason: str` -> Причина кика. Параметр не обязателен, по дефолту: `Kicked!`_
+Кикает игрока с сервера
+
+### **async** pl.send_message(message: str, [to_all: bool = True]) -> None
+_`message: str` -> Текст сообщения, отправляется без "Server:"_
+_`to_all: bool` -> Нужно ли отправить это сообщение всем? Параметр не обязателен, по дефолту: `True`_
+Отправляет сообщение игроку или всем сразу
+
+### **async** pl.send_event(event_name: str, event_data: Any, [to_all: bool = True]) -> None
+_`event_name: str` -> Имя ивента, который будет вызван_
+_`event_data: Any` -> Отправляемые данные в ивент._
+_`to_all: bool` -> Нужно ли отправить это сообщение всем? Параметр не обязателен, по дефолту: `True`_
+Отправляет ивент на клиент.\
+Если event_data будет tuple, list, dict, то перед отправкой ядро конвертирует в json через json.dumps(event_data)
+Иначе данные будут строкой, без регуляции;
+
+### **async** pl.delete_car(self, car_id: int) -> None
+_`car_id: int` -> Идентификатор машины_
+Удалят машину у игрока
--- a/docs/ru/plugins/events_list.md
+++ b/docs/ru/plugins/events_list.md
@@ -0,0 +1,5 @@
+# Список ивентов
+
+В большинство ивентов будет приходить `pl = data['kwargs']['player']`, описание можно найти [тут](./classes.md)
+
+### 
--- a/docs/ru/plugins/examples/async_example.py
+++ b/docs/ru/plugins/examples/async_example.py
@@ -0,0 +1,37 @@
+import json
+
+try:
+    import KuiToi
+except ImportError:
+    pass
+
+kt = KuiToi("Example")
+log = kt.log
+config = {"config_version": 0.1, "sql": {"enabled": False, "host": "127.0.0.1", "port": 3363, "database": "fucklua"}}
+cfg_file = "config.json"
+
+
+async def my_event_handler(event_data):
+    log.info(f"{event_data}")
+
+
+async def load():
+    # Инициализация плагина
+    with open(cfg_file, 'w') as f:
+        json.dump(config, f)
+        cgf = config
+    log.info(cgf)
+    ev.register_event("my_event", my_event_handler)
+    log.info("Плагин загружен успешно.")
+
+
+async def start():
+    # Запуск процессов плагина
+    await ev.call_async_event("my_event")
+    await ev.call_async_event("my_event", "Some data", data="some data too")
+    log.info("Плагин запустился успешно.")
+
+
+async def unload():
+    # Код завершающий все процессы
+    log.info("Плагин выгружен успешно.")
--- a/docs/ru/plugins/examples/example.py
+++ b/docs/ru/plugins/examples/example.py
@@ -0,0 +1,37 @@
+import json
+
+try:
+    import KuiToi
+except ImportError:
+    pass
+
+kt = KuiToi("Example")
+log = kt.log
+config = {"config_version": 0.1, "sql": {"enabled": False, "host": "127.0.0.1", "port": 3363, "database": "fucklua"}}
+cfg_file = "config.json"
+
+
+def my_event_handler(event_data):
+    log.info(f"{event_data}")
+
+
+def load():
+    # Инициализация плагина
+    with open(cfg_file, 'w') as f:
+        json.dump(config, f)
+        cgf = config
+    log.info(cgf)
+    ev.register_event("my_event", my_event_handler)
+    log.info("Плагин загружен успешно.")
+
+
+def start():
+    # Запуск процессов плагина
+    ev.call_event("my_event")
+    ev.call_event("my_event", "Some data", data="some data too")
+    log.info("Плагин запустился успешно.")
+
+
+def unload():
+    # Код завершающий все процессы
+    log.info("Плагин выгружен успешно.")
--- a/docs/ru/plugins/lua/example.lua
+++ b/docs/ru/plugins/lua/example.lua
@@ -0,0 +1,27 @@
+print("example.lua")
+
+--CreateTimer Testing
+local mytimer = MP.CreateTimer()
+--.--.--.--.--.--.--.
+
+--GetOSName Testing
+print("OS Name: "..MP.GetOSName())
+--.--.--.--.--.--.-
+
+--GetServerVersion Testing
+local major, minor, patch = MP.GetServerVersion()
+print("Server Version: "..major.."."..minor.."."..patch)
+--.--.--.--.--.--.--.--.--
+
+--Events Testing--
+function handleChat(player_id, player_name, message)
+    print("Lua handleChat:", player_id, player_name, message, "; Uptime: "..mytimer:GetCurrent())
+    return 1
+end
+
+MP.RegisterEvent("onChatMessage", "handleChat")
+--.--.--.--.--.--.
+
+function onInit()
+    print("Initializing ready!")
+end
--- a/docs/ru/plugins/lua/readme.md
+++ b/docs/ru/plugins/lua/readme.md
@@ -0,0 +1,24 @@
+# Обеспечение обратной поддержки BeamMP Lua
+
+В KiuToi есть практически полная поддержка lua плагинов с BeamMP, все необходимые методы созданы, тестирование показало следующие нюансы:
+
+В KiuToi не будет поддержки: `MP.Set()`
+
+#### Economic Rework V2.0 (Платный, Discord (RU): [Hlebushek](https://discordapp.com/users/449634697593749516))
+
+1. Для получения `pluginPath` нужно: `debug.getinfo(1).source:gsub("\\","/")` => `debug.getinfo(1).source:gsub("\\","/"):gsub("@", "")` так как пусть возвращается с `@`, что сломало плагин.
+
+#### Cobalt Essentials V1.7.5 (Бесплатный, [github](https://github.com/prestonelam2003/CobaltEssentials/))
+
+1. Для получения `pluginPath` нужно: `debug.getinfo(1).source:gsub("\\","/")` => `debug.getinfo(1).source:gsub("\\","/"):gsub("@", "")` так как пусть возвращается с `@`, что сломало плагин.
+2. `cobaltSysChar` 
+
+### Немного о принципе работы
+
+Загрузка плагина проходит в несколько этапов:
+
+1. Сканируется папка `plugins/`
+2. Если папки нет в PyPlugins и в папке есть `*.lua`, то она добавляется, допустим это будет `plugins/LuaPlugin`
+3. Далее из этой папки проходит `lua.loadfile({filename})` (Это стандартный метод в lua)
+4. И в конце вызывается ивент и функция `onInit()`
+5. Если во время выполнения `onInit()` не произошло ошибок, можно будет увидеть через команду `lua_plugins` такое сообщение: `Lua plugins: LuaPlugin:ok`
--- a/docs/ru/plugins/readme.md
+++ b/docs/ru/plugins/readme.md
@@ -1,5 +1,8 @@
 # Система плагинов

+### Ивенты: [тут](./events_list.md)
+### Классы: [тут](./classes.md)
+
 ## Установка библиотеки с "Заглушками"
 ###### (Это значит, что не будет работать без сервера, но IDE подскажет API)
 ###### (Библиотека ещё в разработке)
@@ -17,7 +20,7 @@ try:
 except ImportError:
    pass

-kt = KuiToi("Example")
+kt = KuiToi("ExamplePlugin")
 log = kt.log

 def my_event_handler(event_data):
@@ -40,6 +43,7 @@ def unload():
    # Код завершающий все процессы
    log.info("Плагин выгружен успешно.")
 ```
+Так же более обширный пример можно найти в [example.py](examples/example.py)

 * Рекомендуется использовать `open()` после `load()`, иначе стоит использовать `kt.load()` - Создаёт файл в папке `plugin/<plugin_name>/<filename>`
 * Создание своего ивента : `kt.register_event("my_event", my_event_function)` - 
@@ -84,7 +88,7 @@ async def unload():

 ```

-Так же более обширный пример можно найти в [async_example.py](./async_example.py)
+Так же более обширный пример можно найти в [async_example.py](examples/async_example.py)

 * Создание своего ивента: `kt.register_event("my_event", my_event_function)` (в register_event стоит проверка на функцию)
 * Вызов async ивента: `kt.call_async_event("my_event")`
--- a/docs/ru/readme.md
+++ b/docs/ru/readme.md
@@ -4,6 +4,7 @@

 1. Настройка и Запуск сервера - [тута](./setup)
 2. Плагины и Ивент система - [тута](./plugins)
-3. Мультиязычность - [тута](./multilanguage)
-4. KuiToi WebAPI - [тута](./web)
-5. Тут будет что-то ново....
+3. Ньансы работы Lua - [тута](./plugins/lua)
+4. Мультиязычность - [тута](./multilanguage)
+5. KuiToi WebAPI - [тута](./web)
+6. Тут будет что-то новое....
--- a/docs/ru/setup/readme.md
+++ b/docs/ru/setup/readme.md
@@ -36,19 +36,24 @@ Game:
  map: gridmap_v2
  max_cars: 1
  players: 8
-Server:
+Options:
  debug: false
-  description: Welcome to KuiToi Server!
+  encoding: utf-8
  language: en
+  log_chat: true
+  speed_limit: 0
+  use_lua: true
+  use_queue: false
+Server:
+  description: Welcome to KuiToi Server!
  name: KuiToi-Server
  server_ip: 0.0.0.0
-  server_port: 30813
+  server_port: 30814
 WebAPI:
  enabled: false
-  secret_key: <random_key>
+  secret_key: 3838ccb03c86cdb386b67fbfdcba62d0
  server_ip: 127.0.0.1
  server_port: 8433
-
 ```
 ### Auth

@@ -62,11 +67,19 @@ WebAPI:
 * `max_cars` - Максимальное количество машин на игрока
 * `players` - Максимально количество игроков

-### Server
+### Options

 * `debug` - Нужно ли выводить debug сообщения (только для опытных пользователей, немного теряется в производительности)
-* `description` - Описания сервера для лаунчера BeamMP
+* `encoding` - С какой кодировкой открывать файлы
 * `language` - С каким языком запустится сервер (Доступные на данный момент: en, ru)
+* `log_chat` - Нужно-ли выводить чат в консоль
+* `speed_limit` - Ограничение скорости на скачивание модов (В Мб/с)
+* `use_lua` - Включить ли поддержку lua
+* `use_queue` - Скачивать по очереди, т.е. в один момент может скачивать только 1 клиент
+
+### Server
+
+* `description` - Описания сервера для лаунчера BeamMP
 * `name` - Названия сервер для лаунчера BeamMP
 * `server_ip` - Какой IP адрес занять серверу (только для опытных пользователей, по умолчанию 0.0.0.0)
 * `server_port` - На каком порту будет работать сервер
--- a/requirements.txt
+++ b/requirements.txt
@@ -5,4 +5,6 @@ uvicorn~=0.22.0
 fastapi~=0.100.0
 starlette~=0.27.0
 pydantic~=2.0.2
-click~=8.1.4
+click~=8.1.4
+lupa~=2.0
+toml~=0.10.2
--- a/src/core/Client.py
+++ b/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,12 @@ class Client:
        self.roles = None
        self._guest = True
        self._ready = False
-        self._cars = []
+        self._identifiers = []
+        self._cars = [None] * 21  # Max 20 cars per player + 1 snowman
+        self._focus_car = -1
+        self._snowman = {"id": -1, "packet": ""}
+        self._connect_time = 0
+        self._last_position = {}

    @property
    def _writer(self):
@@ -40,12 +50,16 @@ class Client:

    @property
    def addr(self):
-        return self._addr
+        return self._addr[0]

    @property
    def cid(self):
        return self._cid

+    @property
+    def pid(self):
+        return self._cid
+
    @property
    def key(self):
        return self._key
@@ -58,9 +72,21 @@ class Client:
    def ready(self):
        return self._ready

+    @property
+    def identifiers(self):
+        return self._identifiers
+
    @property
    def cars(self):
-        return self.cars
+        return {i: v for i, v in enumerate(self._cars) if v is not None}
+
+    @property
+    def focus_car(self):
+        return self._focus_car
+
+    @property
+    def last_position(self):
+        return self._last_position

    def _update_logger(self):
        self._log = utils.get_logger(f"{self.nick}:{self.cid}")
@@ -69,25 +95,43 @@ 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

-    async def kick(self, reason):
+    async def kick(self, reason=None):
+        if not reason:
+            reason = "Kicked!"
+        else:
+            reason = f"{reason}"
        if not self.__alive:
            self.log.debug(f"{self.nick}.kick('{reason}') skipped: Not alive;")
            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):
+        if not message:
+            message = "no message"
+            to_all = False
+        await self._send(f"C:{message!r}", to_all=to_all)
+
+    async def send_event(self, event_name, event_data, to_all=True):
+        if isinstance(event_data, (list, tuple, dict)):
+            event_data = json.dumps(event_data, separators=(',', ':'))
+        else:
+            event_data = f"{event_data!r}"
+        if len(event_data) > 104857599:
+            self.log.error("Client data too big! >=104857599")
+            return
+        await self._send(f"E:{event_name}:{event_data}", to_all=to_all)
+
    async def _send(self, data, to_all=False, to_self=True, to_udp=False, writer=None):

        # TNetwork.cpp; Line: 383
@@ -97,10 +141,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 +149,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 +289,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 +324,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,108 +339,353 @@ 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
+        lua_data = ev.call_lua_event("onVehicleSpawn", self.cid, car_id, car_data[car_data.find("{"):])
+        if 1 in lua_data:
+            allow = 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._focus_car = 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,
+                "pos": {}
+            }
+            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, car_id):
+        await self._delete_car(car_id=car_id)
+
+    async def _delete_car(self, raw_data=None, car_id=None):
+
+        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]:
+
+            ev.call_lua_event("onVehicleDeleted", self.cid, 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
+                lua_data = ev.call_lua_event("onVehicleEdited", self.cid, car_id, data[data.find("{"):])
+                if 1 in lua_data:
+                    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_lua_event("onVehicleReset", self.cid, car_id, raw_data[raw_data.find("{"):])
+            car_json = {}
+            try:
+                car_json = json.loads(raw_data[raw_data.find("{"):])
+            except Exception as e:
+                self.log.debug(f"Invalid new_car_json: Error: {e}; Data: {raw_data}")
+            ev.call_event("onCarReset", car=car_json, car_id=car_id, player=self)
+            await ev.call_async_event("onCarReset", car=car_json, 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 car
+                self.log.debug(f"Move focus to: {raw_data}")
+                cid, car_id = self._get_cid_vid(raw_data[5:])
+                if car_id != -1 and cid == self.cid and self._cars[car_id]:
+                    self._focus_car = car_id
+                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
+
+        for client in self.__Core.clients:
+            if not client:
+                continue
+            for car in client._cars:
+                if not car:
+                    continue
+                await self._send(car['packet'])
+
+        self._ready = True
+
+    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}
+        lua_data = ev.call_lua_event("onChatMessage", self.cid, self.nick, msg)
+        if 1 in lua_data:
+            if config.Options['log_chat']:
+                self.log.info(f"{self.nick}: {msg}")
+            return
+        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
+                if config.Options['log_chat']:
+                    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:
+            if config.Options['log_chat']:
+                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):
+        ev.call_lua_event("onPlayerConnecting", self.cid)
+        self._connect_time = time.monotonic()
+        await self._send(f"P{self.cid}")  # Send clientID
+        await self._sync_resources()
+        ev.call_lua_event("onPlayerJoining", self.cid)
+        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")
+            ev.call_lua_event("onPlayerDisconnect", self.cid)
+            ev.call_event("onPlayerDisconnect", player=self)
+            await ev.call_async_event("onPlayerDisconnect", player=self)
+
            # 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)
+            del self.__Core.clients_by_id[self.cid]
+            del self.__Core.clients_by_nick[self.nick]
        else:
            self.log.debug(f"Removing client; Closing connection...")
        try:
@@ -353,7 +694,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:
--- a/src/core/Client.pyi
+++ b/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, Any

 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,12 @@ class Client:
        self._guest = True
        self.__alive = True
        self._ready = False
+        self._focus_car = -1
+        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
@@ -37,18 +47,40 @@ class Client:
    def addr(self) -> Tuple[str, int]: ...
    @property
    def cid(self) -> int: ...
+    def pid(self) -> int: ...
    @property
    def key(self) -> str: ...
    @property
    def guest(self) -> bool: ...
    @property
    def ready(self) -> bool: ...
+    @property
+    def identifiers(self) -> list: ...
+    @property
+    def cars(self) -> dict: ...
+    @property
+    def focus_car(self):
+        return self._focus_car
+    @property
+    def last_position(self) -> dict: ...
    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: Any, to_all: bool = True) -> 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, car_id: int) -> None: ...
+    async def _delete_car(self, raw_data: str = None, car_id: int = None) -> 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: ...
--- a/src/core/init.py
+++ b/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__ = 1925  # Я это считаю лог файлами
 __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...")
--- a/src/core/core.py
+++ b/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,15 +41,20 @@ 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)
+        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']))

-    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'])
+    def get_client(self, cid=None, nick=None):
+        if cid is None and nick is None:
+            return None
        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)
@@ -85,7 +91,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 +101,26 @@ 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)
+
+    async def __gracefully_kick(self):
+        for client in self.clients:
+            if not client:
+                continue
+            await client.kick("Server shutdown!")

    @staticmethod
    def start_web():
@@ -141,13 +157,12 @@ 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}")

                # Sentry?
                ok = False
@@ -159,7 +174,6 @@ class Core:
                            async with session.post(url, data=data, headers={"api-v": "2"}) as response:
                                code = response.status
                                body = await response.json()
-                                self.log.debug(f"Auth: code {code}, body {body}")
                                ok = True
                        break
                    except Exception as e:
@@ -173,28 +187,30 @@ class Core:
                        self.log.error("Missing/invalid json members in backend response")
                        raise KeyboardInterrupt

-                    if test:
-                        status = body.get("status")
-                        msg = body.get("msg")
-                        if status == "2000":
+                    status = body.get("status")
+                    msg = body.get("msg")
+                    if status == "2000":
+                        if test:
                            # TODO: i18n
                            self.log.info(f"Authenticated! {msg}")
-                        elif status == "200":
+                    elif status == "200":
+                        if test:
                            self.log.info(f"Resumed authenticated session. {msg}")
-                        else:
-                            self.log.error(f"Backend REFUSED the auth key. Reason: "
-                                           f"{msg or 'Backend did not provide a reason'}")
-                            self.log.info(f"Server still runnig, but only in Direct connect mode.")
-                            self.direct = True
+                    else:
+                        self.log.debug(f"Auth: data {data}")
+                        self.log.debug(f"Auth: code {code}, body {body}")
+                        self.log.error(f"Backend REFUSED the auth key. Reason: "
+                                       f"{msg or 'Backend did not provide a reason'}")
+                        self.log.info(f"Server still runnig, but only in Direct connect mode.")
+                        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
@@ -211,11 +227,16 @@ class Core:
            lambda x: f"Players list: {self.get_clients_list(True)}"
        )

-        self.log.debug("Initializing PluginsLoader...")
-        if not os.path.exists("plugins"):
-            os.mkdir("plugins")
-        pl = PluginsLoader("plugins")
+        pl_dir = "plugins"
+        self.log.debug("Initializing PluginsLoaders...")
+        if not os.path.exists(pl_dir):
+            os.mkdir(pl_dir)
+        pl = PluginsLoader(pl_dir)
        await pl.load()
+        if config.Options['use_lua']:
+            from modules.PluginsLoader.lua_plugins_loader import LuaPluginsLoader
+            lpl = LuaPluginsLoader(pl_dir)
+            lpl.load()

        try:
            # WebApi Start
@@ -251,17 +272,18 @@ 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)

            await ev.call_async_event("_plugins_start")
+            # await ev.call_async_event("_lua_plugins_start")

            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,16 +293,19 @@ 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_lua_event("onShutdown")
+        ev.call_event("onServerStopped")
+        await ev.call_async_event("onServerStopped")
+        await self.__gracefully_kick()
        await ev.call_async_event("_plugins_unload")
+        ev.call_event("_lua_plugins_unload")
        self.run = False
        self.log.info(i18n.stop)
        if config.WebAPI["enabled"]:
--- a/src/core/core.pyi
+++ b/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: ...
@@ -39,6 +40,7 @@ class Core:
    def create_client(self, *args, **kwargs) -> Client: ...
    def get_clients_list(self, need_cid=False) -> str: ...
    async def check_alive(self) -> None: ...
+    async def __gracefully_kick(self): ...
    @staticmethod
    def start_web() -> None: ...
    def stop_me(self) -> None: ...
--- a/src/core/tcp_server.py
+++ b/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,9 +53,10 @@ 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"]
+            client._identifiers = {k: v for s in res["identifiers"] for k, v in [s.split(':')]}
            # noinspection PyProtectedMember
            client._update_logger()
        except Exception as e:
@@ -71,7 +73,21 @@ class TCPServer:
                await client.kick('Stale Client (replaced by new client)')
                return False, client

-        ev.call_event("auth_ok", player=client)
+        allow = True
+        reason = "You are not allowed on the server!"
+
+        lua_data = ev.call_lua_event("onPlayerAuth", client.nick, client.roles, client.guest, client.identifiers)
+        for data in lua_data:
+            if 1 == data:
+                allow = True
+            elif isinstance(data, str):
+                allow = True
+                reason = data
+        if not allow:
+            await client.kick(reason)
+            return False, client
+
+        ev.call_event("onPlayerAuthenticated", player=client)

        if len(self.Core.clients_by_id) > config.Game["players"]:
            # TODO: i18n
@@ -89,7 +105,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 +149,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 +159,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:
--- a/src/core/tcp_server.pyi
+++ b/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
--- a/src/core/udp_server.py
+++ b/src/core/udp_server.py
@@ -1,18 +1,21 @@
 # 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
+import json

 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 +23,90 @@ 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, *args, **kwargs): ...
+    def pause_writing(self, *args, **kwargs): ...
+    def resume_writing(self, *args, **kwargs): ...

-    async def start(self):
-        self.log.debug("Starting UDP server.")
-        self.run = True
+    async def handle_datagram(self, data, addr):
        try:
-            pass
-        except OSError as e:
-            self.log.error("Cannot bind port or other error")
-            raise e
-        except BaseException as e:
-            self.log.error(f"Error: {e}")
-            raise e
-        finally:
-            self.run = False
-            self.Core.run = False
+            cid = data[0] - 1
+            code = data[2:3].decode()
+            data = data[2:].decode()

-    def stop(self):
+            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", data=data)
+                        sub = data.find("{", 1)
+                        last_pos_data = data[sub:]
+                        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:
+                self.log.debug(f"[{cid}] Client not found.")
+
+        except Exception as e:
+
+            self.log.error(f"Error handle_datagram: {e}")
+
+    def datagram_received(self, *args, **kwargs):
+        self.loop.create_task(self.handle_datagram(*args, **kwargs))
+
+    def connection_lost(self, exc):
+        if exc is not None and exc != KeyboardInterrupt:
+            self.log.debug(f'Connection raised: {exc}')
+        self.log.debug(f'Disconnected.')
+
+    def error_received(self, exc):
+        self.log.debug(f'error_received: {exc}')
+        self.log.exception(exc)
+        self.connection_lost(exc)
+        self.transport.close()
+
+    async def _start(self):
+        self.log.debug("Starting UDP server.")
+        while self.Core.run:
+            try:
+
+                await asyncio.sleep(0.2)
+
+                d = UDPServer
+                self.transport, p = await self.loop.create_datagram_endpoint(
+                    lambda: d(self.Core),
+                    local_addr=(self.host, self.port)
+                )
+                d.transport = self.transport
+
+                self.log.debug(f"UDP server started on {self.transport.get_extra_info('sockname')}")
+
+                self.run = True
+                while not self.transport.is_closing():
+                    await asyncio.sleep(0.2)
+
+            except OSError as e:
+                self.run = False
+                self.Core.run = False
+                self.log.error(f"Cannot bind port or other error: {e}")
+            except Exception as e:
+                self.log.error(f"Error: {e}")
+                self.log.exception(e)
+
+    def _stop(self):
        self.log.debug("Stopping UDP server")
+        self.transport.close()
--- a/src/core/udp_server.pyi
+++ b/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: ...
--- a/src/core/utils.py
+++ b/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
--- a/src/modules/ConfigProvider/config_provider-builtins.pyi
+++ b/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): ...
--- a/src/modules/ConfigProvider/config_provider.py
+++ b/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
@@ -13,11 +12,13 @@ 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, "use_lua": False, "log_chat": True}
        self.WebAPI = web or {"enabled": False, "server_ip": "127.0.0.1", "server_port": 8433,
                              "secret_key": secrets.token_hex(16)}

--- a/src/modules/EventsSystem/events_system.py
+++ b/src/modules/EventsSystem/events_system.py
@@ -22,28 +22,63 @@ 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
+            "onPlayerDisconnect": [],
+            "onServerStopped": [],
        }
        self.__async_events = {
-            "server_started": [],
-            "_plugins_start": [],
-            "_plugins_unload": [],
-            "player_join": [],
-            "chat_receive": [],
-            "server_stopped": []
+            "onServerStarted": [],
+            "onPlayerJoin": [],
+            "onChatReceive": [],
+            "onCarSpawn": [],
+            "onCarDelete": [],
+            "onCarEdited": [],
+            "onCarReset": [],
+            "onPlayerDisconnect": [],
+            "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):
-        self.log.debug(f"register_event({event_name}, {event_func}):")
+    def register_event(self, event_name, event_func, async_event=False, lua=None):
+        self.log.debug(f"register_event(event_name='{event_name}', event_func='{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): [{"func_name": event_func, "lua": lua}]})
+            else:
+                self.__lua_events[event_name].append({"func_name": event_func, "lua": lua})
+            self.log.debug("Register ok")
+            return
+
        if not callable(event_func):
            # TODO: i18n
            self.log.error(f"Cannot add event '{event_name}'. "
@@ -54,11 +89,13 @@ 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}'")
@@ -80,7 +117,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():
@@ -97,3 +135,32 @@ 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 data in self.__lua_events[event_name]:
+                lua = data['lua']
+                func_name = data["func_name"]
+                try:
+                    func = lua.globals()[func_name]
+                    if not func:
+                        self.log.warning(f"Cannot trigger local event: '{func_name}' not found!")
+                        continue
+                    fd = func(*args)
+                    funcs_data.append(fd)
+                except Exception as e:
+                    # TODO: i18n
+                    self.log.error(f'Error: "{e}" - while calling lua event "{event_name}" with arguments: {args} - '
+                                   f'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
+
+
+
--- a/src/modules/EventsSystem/events_systems-builtins.pyi
+++ b/src/modules/EventsSystem/events_systems-builtins.pyi
@@ -3,9 +3,11 @@ from typing import Any

 class EventsSystem:
    @staticmethod
-    def register_event(event_name, event_func): ...
+    def register_event(event_name, event_func, async_event: bool = False, lua: bool | object = None): ...
    @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): ...
--- a/src/modules/PluginsLoader/add_in.lua
+++ b/src/modules/PluginsLoader/add_in.lua
@@ -0,0 +1,100 @@
+package.path = package.path..";modules/PluginsLoader/lua_libs/?.lua"
+
+MP.CallStrategy = {
+    BestEffort = 0,
+    Precise = 1
+}
+
+MP.Settings = {
+    Debug = 0,
+    Private = 1,
+    MaxCars = 2,
+    MaxPlayers = 3,
+    Map = 4,
+    Name = 5,
+    Description = 6
+}
+
+function MP.CreateTimer()
+  MP.log.debug("request MP.CreateTimer()")
+  local timer = {}
+  timer.start_time = os.clock()
+
+  function timer:GetCurrent()
+    return os.clock() - self.start_time
+  end
+
+  function timer:Start()
+    self.start_time = os.clock()
+  end
+
+  return timer
+end
+
+----Timer object for event timers
+--local TimedEvent = {}
+--TimedEvent.__index = TimedEvent
+--
+--function TimedEvent:new(interval_ms, event_name, strategy)
+--  local o = {}
+--  setmetatable(o, self)
+--  o.interval = interval_ms
+--  o.event_name = event_name
+--  o.strategy = strategy or MP.CallStrategy.BestEffort
+--  o.last_trigger_time = 0
+--  o.timer = MP.CreateTimer()
+--  return o
+--end
+--
+--function TimedEvent:trigger()
+--  MP.TriggerLocalEvent(self.event_name)
+--  self.last_trigger_time = self.timer:GetCurrent()
+--end
+--
+--function TimedEvent:is_ready()
+--  local elapsed_time = self.timer:GetCurrent() - self.last_trigger_time
+--  return elapsed_time * 1000 >= self.interval
+--end
+--
+---- Event timer management functions
+--MP.event_timers = {}
+--MP.event_timers_mutex = {}
+--
+--function MP.CreateEventTimer(event_name, interval_ms, strategy)
+--  MP.log.debug("request MP.CreateEventTimer()")
+--  strategy = strategy or MP.CallStrategy.BestEffort
+--  local timer = TimedEvent:new(interval_ms, event_name, strategy)
+--  table.insert(MP.event_timers, timer)
+--  MP.log.debug("created event timer for \"" .. event_name .. "\" with " .. interval_ms .. "ms interval")
+--end
+--
+--function MP.CancelEventTimer(event_name)
+--  MP.log.debug("request MP.CancelEventTimer()")
+--  for i, timer in ipairs(MP.event_timers) do
+--    if timer.event_name == event_name then
+--      table.remove(MP.event_timers, i)
+--    end
+--  end
+--  MP.log.debug("cancelled event timer for \"" .. event_name .. "\"")
+--end
+--
+--function MP.run_event_timers()
+--  MP.log.debug("request MP.run_event_timers()")
+--  while true do
+--    -- Wait for some time before checking timers
+--    MP.Sleep(100)
+--
+--    -- Check each timer and trigger events as necessary
+--    for _, timer in ipairs(MP.event_timers) do
+--      if timer:is_ready() then
+--        if timer.strategy == MP.CallStrategy.Precise then
+--          while timer:is_ready() do
+--            timer:trigger()
+--          end
+--        else
+--          timer:trigger()
+--        end
+--      end
+--    end
+--  end
+--end
--- a/src/modules/PluginsLoader/lua_plugins_loader.py
+++ b/src/modules/PluginsLoader/lua_plugins_loader.py
@@ -0,0 +1,672 @@
+import asyncio
+import json
+import os
+import platform
+import random
+import shutil
+import threading
+import time
+
+import toml
+from lupa.lua53 import LuaRuntime
+
+from core import get_logger
+
+
+class EventTimer:
+    def __init__(self, event_name, interval_ms, mp, strategy=None):
+        self.log = get_logger(f"EventTimer | {mp.name}")
+        self.mp = mp
+        self.event_name = event_name
+        self.interval_ms = interval_ms
+        self.strategy = strategy
+        self.timer = None
+        self.stopped = False
+
+    def start(self):
+        def callback():
+            if not self.stopped:
+                self.start()
+            self.trigger_event()
+
+        self.timer = threading.Timer(self.interval_ms / 1000.0, callback)
+        self.timer.start()
+
+    def stop(self):
+        self.stopped = True
+        if self.timer is not None:
+            self.timer.cancel()
+
+    def trigger_event(self):
+        self.log.debug(f"Event '{self.event_name}' triggered")
+        self.mp.TriggerLocalEvent(self.event_name)
+
+
+# noinspection PyPep8Naming
+class MP:
+
+    def __init__(self, name: str, lua: LuaRuntime):
+        self.loaded = False
+        self._event_waiters = []
+        self.loop = asyncio.get_event_loop()
+        self.log = get_logger(f"LuaPlugin | {name}")
+        self.name = name
+        self.tasks = []
+        self._lua = lua
+        self._local_events = {
+            "onInit": [], "onShutdown": [], "onPlayerAuth": [], "onPlayerConnecting": [], "onPlayerJoining": [],
+            "onPlayerJoin": [], "onPlayerDisconnect": [], "onChatMessage": [], "onVehicleSpawn": [],
+            "onVehicleEdited": [], "onVehicleDeleted": [], "onVehicleReset": [], "onFileChanged": []
+        }
+        self._event_timers = {}
+
+    def _print(self, *args):
+        args = list(args)
+        for i, arg in enumerate(args):
+            if "LuaTable" in str(type(arg)):
+                args[i] = self._lua.globals().Util.JsonEncode(arg)
+        s = " ".join(map(str, args))
+        self.log.info(s)
+
+    def GetOSName(self) -> str:
+        self.log.debug("request MP.GetOSName()")
+        pl = platform.system()
+        if pl in ["Linux", "Windows"]:
+            return pl
+        return "Other"
+
+    def GetServerVersion(self) -> tuple[int, int, int]:
+        self.log.debug("request MP.GetServerVersion()")
+        return ev.call_event("_get_BeamMP_version")[0]
+
+    def RegisterEvent(self, event_name: str, function_name: str) -> None:
+        self.log.debug("request MP.RegisterEvent()")
+        ev.register_event(event_name, function_name, lua=self._lua)
+        if event_name not in self._local_events:
+            self._local_events.update({str(event_name): [function_name]})
+        else:
+            self._local_events[event_name].append(function_name)
+        self.log.debug("Register ok (local)")
+
+    def CreateEventTimer(self, event_name: str, interval_ms: int, strategy: int = None):
+        self.log.debug("request CreateEventTimer()")
+        event_timer = EventTimer(event_name, interval_ms, self, strategy)
+        self._event_timers[event_name] = event_timer
+        event_timer.start()
+
+    def CancelEventTimer(self, event_name: str):
+        self.log.debug("request CancelEventTimer()")
+        if event_name in self._event_timers:
+            event_timer = self._event_timers[event_name]
+            event_timer.stop()
+            del self._event_timers[event_name]
+
+    def TriggerLocalEvent(self, event_name, *args):
+        self.log.debug("request TriggerLocalEvent()")
+        self.log.debug(f"Calling local lua event: '{event_name}'")
+        funcs_data = []
+        if event_name in self._local_events.keys():
+            for func_name in self._local_events[event_name]:
+                try:
+                    func = self._lua.globals()[func_name]
+                    if not func:
+                        self.log.warning(f"Cannot trigger local event: '{func_name}' not found!")
+                        continue
+                    fd = func(*args)
+                    funcs_data.append(fd)
+                except Exception as e:
+                    # TODO: i18n
+                    self.log.error(f'Error: "{e}" - while calling lua event "{event_name}" with arguments: {args} - '
+                                   f'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 self._lua.table_from(funcs_data)
+
+    def TriggerGlobalEvent(self, event_name, *args):
+        self.log.debug("request TriggerGlobalEvent()")
+        return self._lua.table(
+            IsDone=lambda: True,
+            GetResults=lambda: self._lua.table_from(ev.call_lua_event(event_name, *args))
+        )
+
+    def Sleep(self, time_ms):
+        self.log.debug(f"request Sleep(); Thread: {threading.current_thread().name}")
+        time.sleep(time_ms * 0.001)
+
+    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):
+        self.log.debug("request TriggerClientEvent()")
+        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 event_name and data:
+            t = self.loop.create_task(client.send_event(event_name, data, to_all=to_all))
+            self.tasks.append(t)
+            return True, None
+        elif not client:
+            return False, "Client expired"
+        else:
+            return False, "Can't found event_name or data"
+
+    def TriggerClientEventJson(self, player_id, event_name, data):
+        self.log.debug("request TriggerClientEventJson()")
+        data = self._lua.globals().Util.JsonEncode(data)
+        self.TriggerClientEvent(player_id, event_name, data)
+
+    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()")
+        if player_id < 0:
+            return self._lua.table(), "Bad client"
+        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()")
+        if player_id < 0:
+            return False
+        return bool(ev.call_event("_get_player", cid=player_id)[0])
+
+    def GetPlayerName(self, player_id):
+        self.log.debug("request GetPlayerName()")
+        if player_id < 0:
+            return None
+        client = ev.call_event("_get_player", cid=player_id)[0]
+        if client:
+            return client.nick
+        return
+
+    def GetPlayerIDByName(self, player_name):
+        self.log.debug("request GetPlayerIDByName()")
+        if not isinstance(player_name, str):
+            return None
+        client = ev.call_event("_get_player", nick=player_name)[0]
+        if client:
+            return client.cid
+        return
+
+    def RemoveVehicle(self, player_id, vehicle_id):
+        self.log.debug("request RemoveVehicle()")
+        if player_id < 0:
+            return
+        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()")
+        if player_id < 0:
+            return self._lua.table()
+        client = ev.call_event("_get_player", cid=player_id)[0]
+        if client:
+            return self._lua.table_from([f'{v["json"]}' for d in [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(clients)
+
+    def IsPlayerGuest(self, player_id) -> bool:
+        self.log.debug("request IsPlayerGuest()")
+        if player_id < 0:
+            return True
+        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()")
+        if player_id < 0:
+            return
+        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, *_):
+        self.log.debug("request Set")
+        self.log.warning("KuiToi cannot support this: MP.Set()")
+
+
+# noinspection PyPep8Naming
+class Util:
+    def __init__(self, name, lua):
+        self.log = get_logger(f"LuaPlugin | Util | {name}")
+        self.name = name
+        self._lua = lua
+
+    def _recursive_list_encode(self, table):
+        new_list = list(table.values())
+        for i, v in enumerate(list(table.values())):
+            if not isinstance(v, (int, float, bool, str, dict, list)) and "LuaTable" not in str(type(v)):
+                new_list[i] = None
+                continue
+            if "LuaTable" in str(type(v)):
+                d = dict(v)
+                if all(isinstance(ii, int) for ii in d.keys()):
+                    new_list[i] = self._recursive_list_encode(d)
+                    continue
+                else:
+                    new_list[i] = self._recursive_dict_encode(d)
+        return [i for i in new_list if i is not None]
+
+    def _recursive_dict_encode(self, table):
+        new_dict = dict(table)
+        for k, v in table.items():
+            if not isinstance(v, (int, float, bool, str, dict, list)) and "LuaTable" not in str(type(v)):
+                new_dict[k] = None
+                continue
+            if "LuaTable" in str(type(v)):
+                d = dict(v)
+                if all(isinstance(i, int) for i in d.keys()):
+                    new_dict[k] = self._recursive_list_encode(d)
+                    continue
+                else:
+                    new_dict[k] = self._recursive_dict_encode(d)
+        return {k: v for k, v in new_dict.items() if v is not None}
+
+    def JsonEncode(self, table):
+        self.log.debug("requesting JsonEncode()")
+        if all(isinstance(k, int) for k in table.keys()):
+            data = self._recursive_list_encode(table)
+        else:
+            data = self._recursive_dict_encode(table)
+        return json.dumps(data)
+
+    def JsonDecode(self, string):
+        self.log.debug("requesting JsonDecode()")
+        return self._lua.table_from(json.loads(string))
+
+    def JsonPrettify(self, string):
+        self.log.debug("requesting JsonPrettify()")
+        data = json.loads(string)
+        return json.dumps(data, indent=4, sort_keys=True)
+
+    def JsonMinify(self, string):
+        self.log.debug("requesting JsonMinify()")
+        data = json.loads(string)
+        return json.dumps(data, separators=(',', ':'))
+
+    def JsonFlatten(self, json_str):
+        self.log.debug("request JsonFlatten()")
+        json_obj = json.loads(json_str)
+        flat_obj = {}
+
+        def flatten(obj, path=''):
+            if isinstance(obj, dict):
+                for key in obj:
+                    flatten(obj[key], path + '/' + key)
+            elif isinstance(obj, list):
+                for i in range(len(obj)):
+                    flatten(obj[i], path + '/' + str(i))
+            else:
+                flat_obj[path] = obj
+
+        flatten(json_obj)
+        flat_json = json.dumps(flat_obj)
+        return flat_json
+
+    def JsonUnflatten(self, flat_json):
+        self.log.debug("request JsonUnflatten")
+        flat_obj = json.loads(flat_json)
+
+        def unflatten(obj):
+            result = {}
+            for key in obj:
+                parts = key.split('/')
+                d = result
+                for part in parts[:-1]:
+                    if part not in d:
+                        # create a new node in the dictionary
+                        # if the path doesn't exist
+                        d[part] = {}
+                    d = d[part]
+                # assign the value to the last part of the path
+                d[parts[-1]] = obj[key]
+            return result
+
+        json_obj = unflatten(flat_obj)
+        return json.dumps(json_obj)
+
+    def JsonDiff(self, a: str, b: str) -> str:
+        self.log.debug("requesting JsonDiff()")
+        a_obj = json.loads(a)
+        b_obj = json.loads(b)
+        diff = []
+        for k, v in b_obj.items():
+            if k not in a_obj:
+                diff.append({"op": "add", "path": "/" + k, "value": v})
+            elif a_obj[k] != v:
+                diff.append({"op": "replace", "path": "/" + k, "value": v})
+        for k in a_obj.keys() - b_obj.keys():
+            diff.append({"op": "remove", "path": "/" + k})
+        return json.dumps(diff)
+
+    @staticmethod
+    def _apply_patch(base_obj, patch_obj):
+        for patch in patch_obj:
+            op = patch['op']
+            path = patch['path']
+            value = patch.get('value', None)
+            tokens = path.strip('/').split('/')
+            obj = base_obj
+            for i, token in enumerate(tokens):
+                if isinstance(obj, list):
+                    token = int(token)
+                if i == len(tokens) - 1:
+                    if op == 'add':
+                        if isinstance(obj, list):
+                            obj.insert(int(token), value)
+                        else:
+                            obj[token] = value
+                    elif op == 'replace':
+                        obj[token] = value
+                    elif op == 'remove':
+                        if isinstance(obj, list):
+                            obj.pop(int(token))
+                        else:
+                            del obj[token]
+                else:
+                    obj = obj[token]
+        return base_obj
+
+    def JsonDiffApply(self, base: str, diff: str) -> str:
+        self.log.debug("requesting JsonDiffApply()")
+        base_obj = json.loads(base)
+        diff_obj = json.loads(diff)
+        result = self._apply_patch(base_obj, diff_obj)
+        return json.dumps(result)
+
+    def Random(self) -> float:
+        self.log.debug("requesting Random()")
+        return random.random()
+
+    def RandomIntRange(self, min_v, max_v) -> int:
+        self.log.debug("requesting RandomIntRange()")
+        return random.randint(min_v, max_v)
+
+    def RandomRange(self, min_v, max_v) -> float:
+        self.log.debug("requesting RandomRange()")
+        return random.uniform(min_v, max_v)
+
+
+# noinspection PyPep8Naming
+class FS:
+
+    def __init__(self, name: str, lua: LuaRuntime):
+        self.log = get_logger(f"LuaPlugin | FP | {name}")
+        self.name = name
+        self._lua = lua
+
+    def CreateDirectory(self, path):
+        self.log.debug("requesting CreateDirectory()")
+        try:
+            os.makedirs(path)
+            return True, None
+        except FileExistsError:
+            return True, None
+        except FileNotFoundError | NotADirectoryError as e:
+            return False, f"{e}"
+        except PermissionError as e:
+            return False, f"{e}"
+        except OSError as e:
+            return False, f"{e}"
+        except TypeError as e:
+            return False, f"{e}"
+        except ValueError as e:
+            return False, f"{e}"
+
+    def Remove(self, path):
+        self.log.debug("requesting Remove()")
+        try:
+            if os.path.isdir(path):
+                os.rmdir(path)
+            else:
+                os.remove(path)
+            return True, None
+        except (FileNotFoundError, NotADirectoryError) as e:
+            return False, f"{e}"
+        except PermissionError as e:
+            return False, f"{e}"
+        except OSError as e:
+            return False, f"{e}"
+        except TypeError as e:
+            return False, f"{e}"
+
+    def Rename(self, path_from, path_to):
+        self.log.debug("requesting Rename()")
+        try:
+            os.rename(path_from, path_to)
+            return True, None
+        except (FileNotFoundError, NotADirectoryError) as e:
+            return False, f"{e}"
+        except PermissionError as e:
+            return False, f"{e}"
+        except OSError as e:
+            return False, f"{e}"
+        except TypeError as e:
+            return False, f"{e}"
+
+    def Copy(self, path_from, path_to):
+        self.log.debug("requesting Copy()")
+        try:
+            if os.path.isfile(path_from):
+                shutil.copy2(path_from, path_to)
+            elif os.path.isdir(path_from):
+                shutil.copytree(path_from, path_to)
+            else:
+                raise ValueError("Invalid path: {}".format(path_from))
+            return True, None
+        except (FileNotFoundError, NotADirectoryError, shutil.Error) as e:
+            return False, f"{e}"
+        except PermissionError as e:
+            return False, f"{e}"
+        except OSError as e:
+            return False, f"{e}"
+        except TypeError as e:
+            return False, f"{e}"
+
+    def GetFilename(self, path):
+        self.log.debug("requesting GetFilename()")
+        return os.path.basename(path)
+
+    def GetExtension(self, path):
+        self.log.debug("requesting GetExtension()")
+        return os.path.splitext(path)[1]
+
+    def GetParentFolder(self, path):
+        self.log.debug("requesting GetParentFolder()")
+        return os.path.dirname(path)
+
+    def Exists(self, path):
+        self.log.debug("requesting Exists()")
+        return os.path.exists(path)
+
+    def IsDirectory(self, path):
+        self.log.debug("requesting IsDirectory()")
+        return os.path.isdir(path)
+
+    def IsFile(self, path):
+        self.log.debug("requesting IsFile()")
+        return os.path.isfile(path)
+
+    def ListDirectories(self, path):
+        self.log.debug("requesting ListDirectories()")
+        directories = []
+        for item in os.listdir(path):
+            item_path = os.path.join(path, item)
+            if os.path.isdir(item_path):
+                directories.append(item)
+        return self._lua.table_from(directories)
+
+    def ListFiles(self, path):
+        self.log.debug("requesting ListFiles()")
+        files = []
+        for item in os.listdir(path):
+            item_path = os.path.join(path, item)
+            if os.path.isfile(item_path):
+                files.append(item)
+        return self._lua.table_from(files)
+
+    def ConcatPaths(self, *args):
+        self.log.debug("requesting ConcatPaths()")
+        return os.path.join(*args)
+
+
+class LuaPluginsLoader:
+
+    def __init__(self, plugins_dir):
+        self.loop = asyncio.get_event_loop()
+        self.plugins_dir = plugins_dir
+        self.lua_plugins = {}
+        self.lua_plugins_tasks = []
+        self.lua_dirs = set()
+        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_unload", self.unload)
+        console.add_command("lua_plugins", lambda x: self.loaded_str[:-2])
+        console.add_command("lua_pl", lambda x: self.loaded_str[:-2])
+
+    def load(self):
+        self.log.debug("Loading Lua plugins...")
+        # TODO: i18n
+        self.log.info("You have enabled support for Lua plugins.")
+        self.log.warning("There are some nuances to working with KuiToi. "
+                         "If you have a proposal for their solution, and it is related to KuiToi, "
+                         "please contact the developer.")
+        self.log.warning("Some BeamMP plugins require a correctly configured ServerConfig.toml file to function.")
+        self.log.info("Creating it.")
+        data = {
+            "info": "ServerConfig.toml is created solely for backward compatibility support. "
+                    "This file will be updated every time the program is launched.",
+            "General": {
+                "Name": config.Server['name'],
+                "Port": config.Server['server_port'],
+                "AuthKey": config.Auth['key'],
+                "LogChat": config.Options['log_chat'],
+                "Debug": config.Options['debug'],
+                "Private": config.Auth['private'],
+                "MaxCars": config.Game['max_cars'],
+                "MaxPlayers": config.Game['players'],
+                "Map": f"/levels/{config.Game['map']}/info.json",
+                "Description": config.Server['description'],
+                "ResourceFolder": "plugins/"
+            },
+            "Misc": {
+                "ImScaredOfUpdates": False,
+                "SendErrorsShowMessage": False,
+                "SendErrors": False
+            },
+            "HTTP": {
+                "HTTPServerIP": config.WebAPI['server_ip'],
+                "HTTPServerPort": config.WebAPI['server_port'],
+                "SSLKeyPath": None,
+                "SSLCertPath": None,
+                "UseSSL": False,
+                "HTTPServerEnabled": config.WebAPI['enabled'],
+            }
+        }
+        with open("ServerConfig.toml", "w") as f:
+            toml.dump(data, f)
+        self.log.warning("KuiToi will not support at all: MP.Set()")
+        py_folders = ev.call_event("_plugins_get")[0]
+        for name in os.listdir(self.plugins_dir):
+            path = os.path.join(self.plugins_dir, name)
+            if os.path.isdir(path) and name not in py_folders and name not in "__pycache__":
+                plugin_path = os.path.join(self.plugins_dir, name)
+                for file in os.listdir(plugin_path):
+                    path = f"plugins/{name}/{file}"
+                    if os.path.isfile(path) and path.endswith(".lua"):
+                        self.lua_dirs.add(name)
+
+        self.log.debug(f"py_folders {py_folders}, lua_dirs {self.lua_dirs}")
+
+        for name in self.lua_dirs:
+            # noinspection PyArgumentList
+            lua = LuaRuntime(encoding="CP1251", source_encoding=config.enc, unpack_returned_tuples=True)
+            lua_globals = lua.globals()
+            lua_globals.printRaw = lua.globals().print
+            lua_globals.exit = lambda x: self.log.info(f"KuiToi: You can't disable server..")
+            mp = MP(name, lua)
+            lua_globals.MP = mp
+            lua_globals.print = mp._print
+            lua_globals.Util = Util(name, lua)
+            lua_globals.FS = FS(name, lua)
+            pa = os.path.abspath(self.plugins_dir)
+            p0 = os.path.join(pa, name, "?.lua")
+            p1 = os.path.join(pa, name, "lua", "?.lua")
+            lua_globals.package.path += f';{p0};{p1}'
+            with open("modules/PluginsLoader/add_in.lua", "r") as f:
+                lua.execute(f.read())
+            self.lua_plugins.update({name: {"lua": lua, "ok": False}})
+            plugin_path = os.path.join(self.plugins_dir, name)
+            for file in os.listdir(plugin_path):
+                path = f"plugins/{name}/{file}"
+                if os.path.isfile(path) and path.endswith(".lua"):
+                    try:
+                        lua_globals.loadfile(path)()
+                    except Exception as e:
+                        self.loaded_str += f"{name}:no, "
+                        self.log.error(f"Cannot load lua plugin from `{path}`: {e}")
+            try:
+                lua_globals.MP.loaded = True
+                lua_globals.MP.TriggerLocalEvent("onInit")
+                lua_globals.onInit()
+                self.lua_plugins[name]['ok'] = True
+                self.loaded_str += f"{name}:ok, "
+            except Exception as e:
+                self.loaded_str += f"{name}:no, "
+                self.log.error(f"Exception onInit from `{name}`: {e}")
+                self.log.exception(e)
+
+    def unload(self, _):
+        self.log.debug("Unloading lua plugins")
+        for name, data in self.lua_plugins.items():
+            if data['ok']:
+                self.log.info(f"Unloading lua plugin: {name}")
+                for _, timer in data['lua'].globals().MP._event_timers.items():
+                    timer.stop()
--- a/src/modules/PluginsLoader/plugins-builtins.pyi
+++ b/src/modules/PluginsLoader/plugins-builtins.pyi
--- a/src/modules/PluginsLoader/plugins_loader.py
+++ b/src/modules/PluginsLoader/plugins_loader.py
@@ -16,41 +16,35 @@ from threading import Thread
 from core import get_logger


-# TODO: call_client_event, get_player, get_players, GetPlayerCount
 class KuiToi:
    _plugins_dir = ""

-    def __init__(self, name=None):
+    def __init__(self, name):
        if name is None:
            raise AttributeError("KuiToi: Name is required")
-        self.log = get_logger(f"Plugin | {name}")
+        self.__log = get_logger(f"Plugin | {name}")
        self.__name = name
        self.__dir = os.path.join(self._plugins_dir, self.__name)
        if not os.path.exists(self.__dir):
            os.mkdir(self.__dir)

+    @property
+    def log(self):
+        return self.__log
+
    @property
    def name(self):
        return self.__name

-    @name.setter
-    def name(self, value):
-        # You chell not pass
-        pass
-
    @property
    def dir(self):
        return self.__dir

-    @dir.setter
-    def dir(self, value):
-        # You chell not pass
-        pass
-
    @contextmanager
    def open(self, file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None):
        path = os.path.join(self.__dir, file)
        self.log.debug(f'Trying to open "{path}" with mode "{mode}"')
+        # Really need?
        # if not os.path.exists(path):
        #     with open(path, 'x'): ...
        f = None
@@ -67,9 +61,35 @@ class KuiToi:
        self.log.debug(f"Registering event {event_name}")
        ev.register_event(event_name, event_func)

-    def call_event(self, event_name, *data, **kwargs):
+    def call_event(self, event_name, *args, **kwargs):
        self.log.debug(f"Called event {event_name}")
-        ev.call_event(event_name, *data, **kwargs)
+        return ev.call_event(event_name, *args, **kwargs)
+
+    async def call_async_event(self, event_name, *args, **kwargs):
+        self.log.debug(f"Called async event {event_name}")
+        return await ev.call_async_event(event_name, *args, **kwargs)
+
+    def call_lua_event(self, event_name, *args):
+        self.log.debug(f"Called lua event {event_name}")
+        return ev.call_lua_event(event_name, *args)
+
+    def get_player(self, pid=None, nick=None, cid=None):
+        self.log.debug("Requests get_player")
+        return ev.call_event("_get_player", cid=cid or pid, nick=nick)[0]
+
+    def get_players(self):
+        self.log.debug("Requests get_players")
+        return self.get_player(-1)
+
+    def players_counter(self):
+        self.log.debug("Requests players_counter")
+        return len(self.get_players())
+
+    def is_player_connected(self, pid=None, nick=None):
+        self.log.debug("Requests is_player_connected")
+        if pid < 0:
+            return False
+        return bool(self.get_player(cid=pid, nick=nick))


 class PluginsLoader:
@@ -83,36 +103,36 @@ class PluginsLoader:
        self.loaded_str = "Plugins: "
        ev.register_event("_plugins_start", self.start)
        ev.register_event("_plugins_unload", self.unload)
+        ev.register_event("_plugins_get", lambda x: list(self.plugins.keys()))
        console.add_command("plugins", lambda x: self.loaded_str[:-2])
        console.add_command("pl", lambda x: self.loaded_str[:-2])

    async def load(self):
        self.log.debug("Loading plugins...")
-        files = os.listdir(self.plugins_dir)
-        for file in files:
-            if file.endswith(".py"):
+        for file in os.listdir(self.plugins_dir):
+            file_path = os.path.join(self.plugins_dir, file)
+            if os.path.isfile(file_path) and file.endswith(".py"):
                try:
                    self.log.debug(f"Loading plugin: {file[:-3]}")
                    plugin = types.ModuleType(file[:-3])
                    plugin.KuiToi = KuiToi
                    plugin.KuiToi._plugins_dir = self.plugins_dir
                    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__)

                    ok = True
                    try:
-                        isfunc = inspect.isfunction
-                        if not isfunc(plugin.load):
+                        is_func = inspect.isfunction
+                        if not is_func(plugin.load):
                            self.log.error('Function "def load():" not found.')
                            ok = False
-                        if not isfunc(plugin.start):
+                        if not is_func(plugin.start):
                            self.log.error('Function "def start():" not found.')
                            ok = False
-                        if not isfunc(plugin.unload):
+                        if not is_func(plugin.unload):
                            self.log.error('Function "def unload():" not found.')
                            ok = False
                        if type(plugin.kt) != KuiToi:
@@ -130,22 +150,22 @@ class PluginsLoader:
                                        f'Plugin name: "{pl_name}"; Plugin file "{file_path}"')

                    plugin.open = plugin.kt.open
-                    iscorfunc = inspect.iscoroutinefunction
+                    is_coro_func = inspect.iscoroutinefunction
                    self.plugins.update(
                        {
                            pl_name: {
                                "plugin": plugin,
                                "load": {
                                    "func": plugin.load,
-                                    "async": iscorfunc(plugin.load)
+                                    "async": is_coro_func(plugin.load)
                                },
                                "start": {
                                    "func": plugin.start,
-                                    "async": iscorfunc(plugin.start)
+                                    "async": is_coro_func(plugin.start)
                                },
                                "unload": {
                                    "func": plugin.unload,
-                                    "async": iscorfunc(plugin.unload)
+                                    "async": is_coro_func(plugin.unload)
                                }
                            }
                        }
--- a/src/modules/i18n/files/cn.json
+++ b/src/modules/i18n/files/cn.json
@@ -0,0 +1,48 @@
+{
+  "": "基础阶段",
+  "hello": "来自KuiToi服务器的问候！",
+  "config_path": "使用{}进行配置。",
+  "init_ok": "初始化完成。",
+  "start": "服务器已启动！",
+  "stop": "服务器已停止！",
+
+  "": "服务器认证",
+  "auth_need_key": "需要BeamMP密钥才能启动！",
+  "auth_empty_key": "BeamMP密钥为空！",
+  "auth_cannot_open_browser": "无法打开浏览器：{}",
+  "auth_use_link": "使用此链接：{}",
+
+  "": "GUI阶段",
+  "GUI_yes": "是",
+  "GUI_no": "否",
+  "GUI_ok": "确定",
+  "GUI_cancel": "取消",
+  "GUI_need_key_message": "需要BeamMP密钥才能启动！\n是否在浏览器中打开链接以获取密钥？",
+  "GUI_enter_key_message": "请输入密钥：",
+  "GUI_cannot_open_browser": "无法打开浏览器。\n请使用此链接：{}",
+
+  "": "Web阶段",
+  "web_start": "WebAPI已启动{}（CTRL+C停止）",
+
+  "": "命令：man",
+  "man_message_man": "man - 显示COMMAND的帮助页面。\n用法：man COMMAND",
+  "help_message_man": "显示COMMAND的帮助页面。",
+  "man_for": "帮助页面",
+  "man_message_not_found": "man：找不到帮助页面。",
+  "man_command_not_found": "man：找不到\"{}\"命令！",
+
+  "": "命令：help",
+  "man_message_help": "help - 显示命令的名称和简短描述。\n用法：help [--raw]\n命令`help`列出所有可用的命令，并为每个命令提供简短描述。",
+  "help_message_help": "显示命令的名称和简短描述。",
+  "help_command": "命令",
+  "help_message": "文本",
+  "help_message_not_found": "无文本",
+
+  "": "命令：stop",
+  "man_message_stop": "stop - 关闭服务器。\n用法：stop",
+  "help_message_stop": "关闭服务器。",
+
+  "": "命令：exit",
+  "man_message_exit": "exit - 关闭服务器。\n用法：exit",
+  "help_message_exit": "关闭服务器。"
+}
--- a/src/modules/i18n/i18n.py
+++ b/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 = {}
Author	SHA1	Message	Date
SantaSpeen	4276eb0fdb	Use encoding="CP1251" for lua plugins;	2023-07-24 04:58:08 +03:00
SantaSpeen	d92aae7c47	I hate cobalt: cobaltSysChar!!!!!!!!!	2023-07-24 04:54:55 +03:00
SantaSpeen	6ccbe99d47	Pretty errors	2023-07-24 04:54:36 +03:00
SantaSpeen	a50decb470	Lua...	2023-07-24 01:30:11 +03:00
SantaSpeen	9079750576	__gracefully_kick	2023-07-24 00:03:04 +03:00
SantaSpeen	e440cdf022	Minor updates; Memory fix.. :) UDP Fix;	2023-07-24 00:02:23 +03:00
SantaSpeen	43fd56f327	Minor updates..	2023-07-23 23:06:29 +03:00
SantaSpeen	2368fec501	Update TODOs	2023-07-23 04:29:52 +03:00
SantaSpeen	ecb9886882	Fix focus_car	2023-07-23 02:37:15 +03:00
SantaSpeen	9a8bcbfae0	Add player.focus_car	2023-07-23 01:57:01 +03:00
SantaSpeen	ddcfa56467	cn.json	2023-07-23 00:26:07 +03:00
SantaSpeen	9e1017609c	Add cn translations	2023-07-23 00:25:42 +03:00
SantaSpeen	d76262fc43	Fix	2023-07-23 00:17:32 +03:00
SantaSpeen	9253f24421	Update setup page	2023-07-23 00:10:07 +03:00
SantaSpeen	8435b00617	Add cn translation	2023-07-23 00:01:33 +03:00
SantaSpeen	847fe68417	Update en translation	2023-07-22 23:59:21 +03:00
SantaSpeen	5f32bf8423	Update TODOs	2023-07-22 23:31:24 +03:00
SantaSpeen	139143c517	Add логику	2023-07-22 23:28:41 +03:00
SantaSpeen	4bd2e28a21	md...	2023-07-22 23:28:05 +03:00
SantaSpeen	28203c5836	Заглушка	2023-07-22 23:26:58 +03:00
SantaSpeen	7de5837db4	Player class	2023-07-22 23:26:47 +03:00
SantaSpeen	cb00829ae7	client.cars -> client._cars; Add some handlers;	2023-07-22 23:26:30 +03:00
SantaSpeen	59b0e58801	links fix	2023-07-22 23:14:47 +03:00
SantaSpeen	5b814efbb9	Minor update	2023-07-22 21:34:52 +03:00
SantaSpeen	17b8be1b9d	Update KuiToi Class docs	2023-07-22 21:33:46 +03:00
SantaSpeen	25ac16c300	Add new Methods	2023-07-22 21:33:33 +03:00
SantaSpeen	1fac1d5ae9	Minor get_client update	2023-07-22 21:20:44 +03:00
SantaSpeen	d6021ddc2d	Add pid (PlayerId)	2023-07-22 21:13:57 +03:00
SantaSpeen	8e8c66c3bf	Optimize imports	2023-07-22 20:58:26 +03:00
SantaSpeen	4273571d97	call_lua_event	2023-07-22 20:45:36 +03:00
SantaSpeen	71df291391	Add KuiTio docs	2023-07-22 20:45:22 +03:00
SantaSpeen	cf0f397465	Move to examples	2023-07-22 18:15:54 +03:00
SantaSpeen	7b579d2916	Lua example	2023-07-22 18:14:57 +03:00
SantaSpeen	a3386339d0	Ньансы работы Lua	2023-07-22 17:59:29 +03:00
SantaSpeen	bf0a3f3feb	Update TODOs;	2023-07-22 07:56:55 +03:00
SantaSpeen	5e071c5705	EventTimer Ready; Unload lua plugins;	2023-07-22 07:56:23 +03:00
SantaSpeen	132beb0dd6	Add MP.CreateTimer(), MP.CreateEventTimer(), MP.CancelEventTimer()	2023-07-22 07:48:35 +03:00
SantaSpeen	33f2d2ba72	Add call_lua_events()	2023-07-22 06:28:08 +03:00
SantaSpeen	90113179d7	Add ServerConfig.toml generation;	2023-07-22 06:00:48 +03:00
SantaSpeen	cd178b815a	Add log_chat;	2023-07-22 05:49:52 +03:00
SantaSpeen	c1f3983856	Minor	2023-07-22 05:23:56 +03:00
SantaSpeen	96cc4b08db	Add warnings to lua; Add MP.Settings;	2023-07-22 05:23:02 +03:00
SantaSpeen	d13a319f39	Remove LuaPluginsLoader from imports; Add use_lua to config;	2023-07-22 05:05:15 +03:00
SantaSpeen	f24ae23eac	Some fixes;	2023-07-22 05:01:11 +03:00
SantaSpeen	b31b01d137	Update build	2023-07-22 05:00:44 +03:00
SantaSpeen	e7be3c88be	Configs	2023-07-22 04:44:23 +03:00
SantaSpeen	2dd8b5f5eb	_event_waiters; Recreate loading lua plugins;	2023-07-22 04:16:16 +03:00
SantaSpeen	84c45d321a	Minor update;	2023-07-22 03:51:58 +03:00
SantaSpeen	b1162af681	Update TODOs	2023-07-22 02:53:28 +03:00
SantaSpeen	91c9cd8454	CreateTimer	2023-07-22 02:52:57 +03:00
SantaSpeen	b8326ecdf8	Refactored for pretty view error;	2023-07-22 02:49:13 +03:00
SantaSpeen	c068629c83	Add calling lua events	2023-07-22 02:48:42 +03:00
SantaSpeen	905c0a361d	Add GetPlayerIDByName (Non docs...);	2023-07-22 02:48:23 +03:00
SantaSpeen	d7073d9124	New print (Now print tables as json); Fix _recursive_dict_encode; Fix lua.globals().onInit();	2023-07-22 01:48:55 +03:00
SantaSpeen	1b5ddbdd45	Refactor package.path; Fix: Now .lua run from loadfrom(file);	2023-07-22 00:20:24 +03:00
SantaSpeen	0d3699bfee	Fix lpl.load();	2023-07-21 22:55:56 +03:00
SantaSpeen	b3dffe74ec	Lau plugins now run in thread; Remove unused event; Add event from to Lua;	2023-07-21 22:51:22 +03:00
SantaSpeen	2992c9cbab	Update TODOs	2023-07-21 22:34:06 +03:00
SantaSpeen	43518ac57c	Update TODOs	2023-07-21 22:33:57 +03:00
SantaSpeen	a96e8111e3	Add TriggerClientEventJson,JsonDecode, JsonPrettify, JsonMinify, JsonFlatten, JsonUnflatten, JsonDiff;	2023-07-21 22:33:44 +03:00
SantaSpeen	ecf06bf1c9	Fix Util.JsonEncode	2023-07-21 20:11:46 +03:00
SantaSpeen	8d57db4a23	Add Util.JsonEncode	2023-07-21 20:06:38 +03:00
SantaSpeen	3d9e08d05d	Util.Random*	2023-07-21 18:37:42 +03:00
SantaSpeen	ac5f5ee894	Update TODOs	2023-07-21 18:28:27 +03:00
SantaSpeen	92880a94df	TriggerClientEvent	2023-07-21 18:28:00 +03:00
SantaSpeen	dcc1f14b17	Update TODOs	2023-07-21 17:42:19 +03:00
SantaSpeen	f9f4df7438	Add TriggerLocalEvent, TriggerGlobalEvent	2023-07-21 17:42:00 +03:00
SantaSpeen	4f7e83a00f	TODO CreateEventTimer, CreateEventTimer	2023-07-21 15:53:47 +03:00
SantaSpeen	aa6716fa75	Update TODOs	2023-07-21 15:53:30 +03:00
SantaSpeen	6fa07f3e07	Add FP class; Add Util class (WIP);	2023-07-21 15:49:22 +03:00
SantaSpeen	9ae200d48a	Fix reg and add call_lua_event(); Add call_lua_event("onChatMessage"); New MP.RegisterEvent(); Add GetPositionRaw();	2023-07-21 05:22:32 +03:00
SantaSpeen	3b5324d115	__gracefully_kick; _last_position; car position - client.cars[car_id]['pos'];	2023-07-21 04:55:25 +03:00
SantaSpeen	f181a82e0e	Update warnings	2023-07-21 02:45:09 +03:00
SantaSpeen	b271c80e39	Update TODOs	2023-07-21 02:42:56 +03:00
SantaSpeen	ef9a55c407	MP Class +- ready..	2023-07-21 02:42:04 +03:00
SantaSpeen	98b4878339	Add client.identifiers;	2023-07-21 02:41:45 +03:00
SantaSpeen	b345588c02	Prepare for lua events; Add _get_player for info; client.send_message();	2023-07-21 01:15:31 +03:00
SantaSpeen	c8fea133ba	Add Lua API: GetOSName, GetServerVersion	2023-07-20 15:15:26 +03:00
SantaSpeen	b80d519c8d	Update TODOs	2023-07-20 06:48:08 +03:00
SantaSpeen	2ace3fcd17	Update TODOs	2023-07-20 06:47:26 +03:00
SantaSpeen	dbe8b14d7f	Add lua loading; Not supporting for now...	2023-07-20 06:44:23 +03:00
SantaSpeen	752e981462	Is this LUAAAAA? No...	2023-07-20 05:21:00 +03:00
SantaSpeen	744a7347a3	Prepare for lua support; Minor update;	2023-07-20 04:59:12 +03:00
SantaSpeen	8139cbf8bc	0.4.0 -> 0.4.1	2023-07-20 04:10:51 +03:00
SantaSpeen	eec7c8129d	Add snowman support (Only one per player); Optimize getting car_id; Minor fixes;	2023-07-20 04:07:39 +03:00
SantaSpeen	158599dfc5	Debug t and m codes	2023-07-20 02:22:20 +03:00
SantaSpeen	06bd50f0fa	Add UDP events: onChangePosition, onSentPing	2023-07-20 01:59:30 +03:00
SantaSpeen	e086fea2e9	Update __build__;	2023-07-20 01:56:36 +03:00
SantaSpeen	b6038ee6d0	Move code from case to func; Add events for cars: onCarDelete, onCarReset; Minor updates;	2023-07-20 01:54:52 +03:00
SantaSpeen	147e76e089	Remove some debug info; Optimize code.	2023-07-20 01:38:56 +03:00
SantaSpeen	56b9049dcb	BeamMP_version	2023-07-20 01:37:52 +03:00
SantaSpeen	78d323644d	Remove some debug data!	2023-07-20 01:34:39 +03:00
SantaSpeen	310c47162c	FIX config.enc	2023-07-20 01:27:01 +03:00
SantaSpeen	27d49cf5cc	Update TODOs	2023-07-20 01:15:32 +03:00
SantaSpeen	a5a7a5dfc9	Add events onCarSpawn, onCarEdited	2023-07-19 22:59:30 +03:00
SantaSpeen	f6ff018b03	connect_time	2023-07-19 21:53:08 +03:00
SantaSpeen	1829113ae5	Add upload use_queue	2023-07-19 21:22:29 +03:00
SantaSpeen	e72c371e20	Minor updates	2023-07-19 21:10:26 +03:00
SantaSpeen	57b7cebeca	Minor updates	2023-07-19 21:10:04 +03:00
SantaSpeen	2a2d55946e	Update config_provider	2023-07-19 21:04:05 +03:00
SantaSpeen	ea2d715cae	DO Speed limiter; Minor fixes;	2023-07-19 20:23:16 +03:00
SantaSpeen	102891c8e8	0.3.0 -> 0.4.0	2023-07-19 03:53:27 +03:00
SantaSpeen	46b0419340	Update TODOs	2023-07-19 03:50:33 +03:00
SantaSpeen	47cca3a0d8	Add UDP send; Remove rights to spawn unicycle (For now); Minor updates;	2023-07-19 03:48:57 +03:00
SantaSpeen	77ee76c0c0	UDP Part ready!	2023-07-19 03:45:02 +03:00
SantaSpeen	852e977a75	Fix set udp sock	2023-07-18 22:59:12 +03:00
SantaSpeen	407127ec97	Typing update	2023-07-18 22:58:34 +03:00
SantaSpeen	7dd3faac12	Update TODOs	2023-07-18 22:43:49 +03:00
SantaSpeen	ef69df10d6	Compress DATA	2023-07-18 22:40:35 +03:00
SantaSpeen	a226b17612	Compress DATA	2023-07-18 22:40:27 +03:00
SantaSpeen	69348e9339	Some fixes in onChatReceive	2023-07-18 22:33:49 +03:00
SantaSpeen	31d8cf7842	try to check_alive	2023-07-18 22:33:15 +03:00
SantaSpeen	45d45a820c	Update TODOs	2023-07-18 22:31:41 +03:00
SantaSpeen	aa440a1e3d	Update TODOs	2023-07-18 22:31:14 +03:00
SantaSpeen	63c9515e86	Add UDP part	2023-07-18 22:08:00 +03:00
SantaSpeen	cfeb2e9823	heartbeat fix	2023-07-18 19:53:02 +03:00
SantaSpeen	85b85114b5	heartbeat fix	2023-07-18 19:52:44 +03:00
SantaSpeen	792884d7b0	Disable __handle_packet...; Fix "Invalid packet - header negative"; Fix _get_cid_vid; Add dta to _handle_vehicle_codes; Fix disconnected message.	2023-07-18 05:35:34 +03:00
SantaSpeen	a5b087f8b4	Disable __handle_packet...; Fix "Invalid packet - header negative"; Fix _get_cid_vid; Add dta to _handle_vehicle_codes; Fix disconnected message.	2023-07-18 05:35:17 +03:00
SantaSpeen	a01567c89a	Auto removing cars after disconnect	2023-07-18 04:14:46 +03:00
SantaSpeen	041883644c	UDP...	2023-07-18 04:10:56 +03:00
SantaSpeen	3d33eec5fd	Minor fix	2023-07-18 04:10:42 +03:00
SantaSpeen	3f2c5b24f9	Add Disconnected message	2023-07-17 22:26:42 +03:00
SantaSpeen	b7ea7ff362	Beta!!!	2023-07-17 21:28:25 +03:00
SantaSpeen	07ec15170b	0.2.3 -> 0.3.0	2023-07-17 21:26:28 +03:00
SantaSpeen	eb88af247c	Add reset and edit for cars	2023-07-17 21:23:40 +03:00
SantaSpeen	6dedf518e2	Update TODOs	2023-07-17 21:22:58 +03:00
SantaSpeen	69ee180128	Fix	2023-07-17 19:42:56 +03:00
SantaSpeen	98f86b2248	Minor update	2023-07-17 18:16:07 +03:00
SantaSpeen	98ef332193	Update TODOs	2023-07-17 17:11:59 +03:00
SantaSpeen	642c91d59c	Packets handled (Recursive finding second packet)	2023-07-17 17:04:25 +03:00
SantaSpeen	acdb32d900	Update TODOs	2023-07-17 14:25:07 +03:00
SantaSpeen	50b1e7b176	Recreate cars system; Move code "O" to client._handle_vehicle_codes();	2023-07-17 14:18:52 +03:00
SantaSpeen	c9e6a0a9cd	Change evens naming semantic	2023-07-16 16:14:16 +03:00
SantaSpeen	cd098571d9	Change evens naming semantic	2023-07-16 16:14:00 +03:00
SantaSpeen	a73b14f9b4	Fix car spawning	2023-07-16 10:42:34 +03:00
SantaSpeen	e3e5c6ecbb	Update TODOs	2023-07-16 09:50:02 +03:00
SantaSpeen	5953923368	DO Sync cars; DO Create cars;	2023-07-16 09:48:53 +03:00
SantaSpeen	580b836e39	Minor fixes	2023-07-16 09:37:38 +03:00