mirror of
https://github.com/Dingo-Shenanigans/ReSkate.git
synced 2026-10-17 17:27:19 +02:00
AyeZeeBB
a1621ee19e
Dedicated servers: roles, with their tags, commands and permissions A dedicated server had one list of admins who could do everything, and everyone else could do nothing. It now has roles, kept in data/roles.json beside the bans: each a name, the tag its players wear in the game, the server commands it may use, what it may do besides commands, and a rank. A server starts with five: player (everyone given no role: chat, votes, parties, private messages), vip (a reserved slot), moderator (kick, ban, messages, giving out lower roles), admin (everything) and muted. The default role is whoever was given none; a role has what the default has as well as its own unless it says it does not inherit. A reserved slot is a permission, so a role's players have one without being listed. Nobody kicks, bans or changes the role of a player whose rank is theirs or higher, or gives out a role that is; the console is above every role. "*" is every command but role and reserved, which a role has only when it lists them. New commands: role <player or SteamID64> <role>|none, roles, and roles reload. "admin add|remove" and "admins" are gone: the admins an older config lists are moved into the admin role the first time the server starts, and leave the config. In the game, a player's role tag and colour show in chat and on their nametag, and each control in the Multiplayer menu, the map, time of day, world layers and parks follows the command it needs rather than one admin flag, as do the commands chat offers. Protocol 48: the roster carries each player's tag, and a new permissions packet tells a player what their role gives them. Older games and servers do not connect to newer ones. Also fixes a name clash that kept the server config tests from compiling.
154 lines
7.1 KiB
Markdown
154 lines
7.1 KiB
Markdown
# ReSkate dedicated server on Linux
|
|
|
|
Native x86_64 build. Same lobby protocol as `ReSkateServer.exe`; needs no game install.
|
|
A release build updates itself, like the Windows server: see [Updating](#updating).
|
|
|
|
## Requirements
|
|
|
|
- 64-bit Linux (tested: CachyOS/Arch, Ubuntu 22.04+ should work).
|
|
- `cmake >= 3.24`, `g++ >= 12` (C++20), `libssl-dev` (OpenSSL), `libcurl` headers optional (not needed for V1).
|
|
- `curl` on the machine that runs the server: it is how the server reads the ReSkate team's
|
|
global ban list (`api.reskate.dev`) and how it downloads its own updates. Without it the
|
|
server says so in its log, enforces only its own bans and stays on its version.
|
|
- `tar` (with gzip) on that machine too, to unpack an update.
|
|
- Steam shared libs beside the binary: `libsteam_api.so` + `steamclient.so`
|
|
(Valve proprietary, not in git — but bundled in the CI/release assets,
|
|
like the Windows zip bundles its DLLs; otherwise fetch them, see below).
|
|
|
|
## Where the Steam `.so` files come from
|
|
|
|
Same split as Windows (`steam_api64.dll` + `steamclient64.dll`/`tier0_s64.dll`/`vstdlib_s64.dll`):
|
|
the release ZIP is expected to ship them; this repo never vendors Valve binaries
|
|
(see `External/README.md`, `External/manifest.json`).
|
|
|
|
- `libsteam_api.so`: from the Steamworks SDK `redistributable_bin/linux64/`
|
|
(official download via `partner.steamgames.com`; any recent 1.x works — the server
|
|
tries `SteamGameServerNetworkingSockets_SteamAPI_v013` then `v012`, and uses
|
|
stable flat exports `SteamGameServer015`/`SteamNetworkingUtils004`).
|
|
It is generic; the app is selected at runtime via `SteamAppId=3354750`.
|
|
- `steamclient.so` (+ `tier0`/`vstdlib` if present): **not** in the SDK.
|
|
Get it from SteamCMD or a Steam client install, e.g.:
|
|
```sh
|
|
steamcmd +@sSteamCmdForcePlatformType linux +login anonymous +app_update 1007 +quit
|
|
# then copy steamapps/common/Steamworks\ SDK\ Redist/linux64/steamclient.so
|
|
# next to ReSkateServer (same folder as libsteam_api.so)
|
|
```
|
|
or copy/symlink an existing client copy (`~/.steam/steam/linux64/steamclient.so`,
|
|
Valve also documents `~/.steam/sdk64/steamclient.so` — the server looks there,
|
|
so `ln -s <folder>/steamclient.so ~/.steam/sdk64/steamclient.so` works).
|
|
The server `dlopen`s `libsteam_api.so`, which in turn loads `steamclient.so`; either adjacent or
|
|
`LD_LIBRARY_PATH` works.
|
|
|
|
Arch/CachyOS:
|
|
|
|
```sh
|
|
sudo pacman -S base-devel cmake openssl
|
|
```
|
|
|
|
Ubuntu/Debian:
|
|
|
|
```sh
|
|
sudo apt install build-essential cmake libssl-dev
|
|
```
|
|
|
|
## Build
|
|
|
|
```sh
|
|
cmake --preset linux-x64
|
|
cmake --build --preset linux-release -j$(nproc)
|
|
./build/linux/ReSkateServer
|
|
```
|
|
|
|
Binary: `build/linux/ReSkateServer` (ELF, `OUTPUT_NAME ReSkateServer`).
|
|
|
|
Portable tests:
|
|
|
|
```sh
|
|
cmake --preset linux-x64 -DDINGOSDK_BUILD_MULTIPLAYER_TESTS=ON
|
|
cmake --build --preset linux-release -j$(nproc)
|
|
ctest --test-dir build/linux --output-on-failure
|
|
```
|
|
|
|
Expected: 10 passed (`multiplayer_parties`, `server_activity`, `server_speed_check`,
|
|
`server_board_check`, `server_config`, `server_global_bans`, `word_filter`, `multiplayer_bandwidth`, `multiplayer_lanes`,
|
|
`multiplayer_prediction`). Windows-only tests (voice, lobbies, UI) stay `WIN32`-gated.
|
|
|
|
## Run
|
|
|
|
1. Put `ReSkateServer` in its own folder, then fetch the Steam libs
|
|
(shipped as `setup-linux-server-libs.sh` beside the binary):
|
|
```sh
|
|
./setup-linux-server-libs.sh # uses the folder it sits in; or --server-dir DIR
|
|
```
|
|
Or do it by hand, see below.
|
|
2. First run writes `ReSkateServer.json`; edit `name` + `admins`, restart.
|
|
3. Optional: `world-layers.json` for time-of-day / world layers.
|
|
Normal server runs only *read* this file (`world_layer_scan::read`, JSON only)
|
|
and work on Linux — verified. Get it by either:
|
|
- Windows export once: `ReSkateServer.exe --export-world-layers "<Skate folder>" world-layers.json`,
|
|
then copy to the Linux folder; or
|
|
- copy from a Windows player's cache `%LOCALAPPDATA%\ReSkate\cache\<build>\world-layers.json`
|
|
(same game build; the server tells admins this path in `layer-sync` errors).
|
|
Without it every player keeps their own layers; with it + `world_layer_sync` the server forces them.
|
|
4. No ports need opening (Steam relay). Optional UDP `27015-27016` (`port`,
|
|
`query_port`) for browser ping + faster joins.
|
|
|
|
Without `libsteam_api.so` the server exits 1 with:
|
|
`Cannot load .../libsteam_api.so. Put libsteam_api.so (Steamworks SDK) next to the server.`
|
|
|
|
Full command list: `Server/README.txt` (same on Linux; binary name differs). Roles and what each
|
|
permission and command gives: `Server/README-roles.txt`.
|
|
|
|
## systemd
|
|
|
|
See `contrib/reskate-server.service`. Install:
|
|
|
|
```sh
|
|
sudo cp contrib/reskate-server.service /etc/systemd/system/
|
|
sudo systemctl daemon-reload
|
|
sudo systemctl enable --now reskate-server
|
|
```
|
|
|
|
The server writes its own `ReSkateServer.log` next to the binary; the console
|
|
output goes to the journal (`journalctl -u reskate-server -f`).
|
|
|
|
## Pterodactyl
|
|
|
|
`contrib/pterodactyl/egg-reskate-server.json` is an egg for Pterodactyl (and Pelican): it installs
|
|
the server from the latest release and keeps the panel's ports and `steam_token` in
|
|
`ReSkateServer.json`. See `contrib/pterodactyl/README.md`.
|
|
|
|
## Updating
|
|
|
|
A server from a release tarball updates itself the way the Windows one does: at startup and
|
|
every half hour it asks GitHub for the latest release, and when that holds a newer Linux
|
|
server it installs it once nobody is on, then carries on as the new version. `update` in
|
|
the console does it straight away. `"auto_update": false` in `ReSkateServer.json`, or
|
|
`--no-update`, turns it off. A server you built yourself never replaces itself.
|
|
|
|
- The release's `launcher.json` pins the tarball and the `ReSkateServer` inside it by
|
|
SHA-256; nothing else is installed. The download is `curl` over HTTPS and the unpacking
|
|
is `tar`, so both must be on the machine.
|
|
- Everything in the tarball is replaced in the server's folder (the server, the Steam
|
|
libraries, the readmes, `world-layers.json`). Your own files are not in it and are kept:
|
|
`ReSkateServer.json`, `Mods`, the logs.
|
|
- The user the server runs as must be able to write to the server's folder. With the
|
|
systemd unit below that is `reskate` and `/opt/reskate-server`:
|
|
`sudo chown -R reskate: /opt/reskate-server`.
|
|
- The updated server takes over the same process, so systemd (or your terminal) keeps the
|
|
server it started; nothing restarts the service.
|
|
- A release made before this (1.1.3 and older) has no Linux entry in `launcher.json`: the
|
|
server logs that the latest release has no Linux server and stays as it is. To get onto
|
|
a self-updating version from one of those, replace the files once by hand.
|
|
|
|
## Notes / limits (V1)
|
|
|
|
- `--export-world-layers` on Linux: the reader works, the scanner needs the
|
|
Windows game (`Data/layout.toc` + CAS) and `oo2core_9_win64.dll` (Oodle).
|
|
Oodle blocks throw `Oodle CAS data is only supported on Windows` (caught,
|
|
exit 1, no crash). Export on Windows, copy the JSON over — no game needed
|
|
on the server itself.
|
|
- `content_cache` dir: `%LOCALAPPDATA%` on Windows, `$XDG_CACHE_HOME`/`~/.cache` on Linux.
|
|
- Crypto interop verified: OpenSSL `PKCS5_PBKDF2_HMAC(SHA256, 100k)` +
|
|
`HMAC-SHA256` matches Windows `BCrypt` (checked against Python `hashlib`).
|