Words you will meet below

Read this once and everything after will make sense. Every term is explained in plain language, with an example.

How to install it when a mod asks for PaxNet

1. Download PaxNet Core from the Workshop

   Open the Pax Universe launcher → Workshop, find "PaxNet Core" and click "Download".

2. Enable it in the "Mods" section

   Launcher → Mods → tick "PaxNet Core" and the mod that asked for it. The game applies mods on the next launch.

Your first network mod, step by step

All code on this page is tested: it compiles in Godot 4.7 with strict typing, as in the game, and passes the sandbox check.

1. Create the mod folder

   In the game's mods folder, create a folder hello_net. Folder name = mod id: Latin letters, digits and _. Here is what it will contain at the end:

   folder layoutCopy

   mods/
   └── hello_net/
       ├── mod.json            ← the mod's passport: name, version, dependencies
       ├── main.gd             ← mod code, first line: extends PaxMod
       └── data/
           └── lang/
               ├── ru.json     ← Russian texts
               └── en.json     ← English texts

2. Write mod.json, the mod's passport

   The key line is "depends": ["paxnet_core"]. It tells the game: "this mod does not work without PaxNet, load the library before me".

   mod.jsonCopy

   {
   	"api": 1.0,
   	"id": "hello_net",
   	"name": {"en": "Hello Net", "ru": "Привет, сеть"},
   	"description": {"en": "Smallest PaxNet example: chat between players.", "ru": "Самый маленький пример PaxNet: чат между игроками."},
   	"version": "1.0.0",
   	"entry": "main.gd",
   	"game_version": ">=0.9.0",
   	"authors": ["You"],
   	"depends": ["paxnet_core"],
   	"load_after": ["paxnet_core"],
   	"tags": []
   }

   Common mistakeForgetting depends. Then your mod may load before the library and fail to find it.

3. Add texts to data/lang

   In Pax Universe you may not write player-facing text directly in code: everything the player sees lives in translation files (a game rule). In code you write a key, for example tr_key("hello_net_me"), and the game substitutes the text in the player's language. Start keys with your mod id so they do not clash with other mods.

   data/lang/en.jsonCopy

   {
   	"hello_net_no_lib": "Enable the PaxNet Core mod and restart the game.",
   	"hello_net_me": "Player",
   	"hello_net_wait": "Opening the room… In a couple of seconds type: hello code",
   	"hello_net_line": "%s: %s",
   	"hello_net_joined": "%s joined the game",
   	"hello_net_help": "hello host | hello code | hello join CODE | hello say TEXT | hello leave"
   }

   The ru.json file has the same keys in Russian. At least these two languages are required.

   data/lang/ru.jsonCopy

   {
   	"hello_net_no_lib": "Включите мод PaxNet Core и перезапустите игру.",
   	"hello_net_me": "Игрок",
   	"hello_net_wait": "Комната открывается… Через пару секунд наберите: hello code",
   	"hello_net_line": "%s: %s",
   	"hello_net_joined": "%s вошёл в партию",
   	"hello_net_help": "hello host | hello code | hello join КОД | hello say ТЕКСТ | hello leave"
   }

4. Write main.gd, the mod itself

   The first line is always extends PaxMod. Read the comments: they say what each piece does.

   main.gdCopy

   extends PaxMod
   ## The smallest network mod on PaxNet: chat between players via the console (F8).
   
   ## Our message type. Start it with your mod id so types from different mods never mix.
   const MSG_SAY: String = "hello_net.say"
   
   ## The online game (the net/Session.gd node from the library). null if not created yet.
   var net: Node = null
   
   
   func _mod_loaded() -> void:
   	Pax.register_command("hello", Callable(self, "_cmd"), tr_key("hello_net_help"))
   
   
   ## The PaxNet library: the node it stores in the root's metadata. null if the library is not enabled.
   func _lib() -> Node:
   	var v: Variant = Pax.get_tree().root.get_meta("paxnet_lib", null)
   	return v as Node if v is Node else null
   
   
   ## The session is created once and lives as long as the game runs.
   func _net() -> Node:
   	if net != null and is_instance_valid(net):
   		return net
   	var lib: Node = _lib()
   	if lib == null:
   		return null
   	net = lib.call("new_session")
   	net.connect("message", _on_message)
   	net.connect("event", _on_event)
   	net.connect("failed", _on_failed)
   	return net
   
   
   func _cmd(args0: Variant = []) -> String:
   	var args: Array = []
   	if args0 is String:
   		args = Array((args0 as String).split(" ", false))
   	elif args0 is Array:
   		args = args0
   	var n: Node = _net()
   	if n == null:
   		return tr_key("hello_net_no_lib")
   	var what: String = str(args[0]) if args.size() > 0 else ""
   	match what:
   		"host":
   			var err: String = str(n.call("host", tr_key("hello_net_me")))
   			return err if err != "" else tr_key("hello_net_wait")
   		"code":
   			return str(n.call("invite_link"))
   		"join":
   			if args.size() < 2:
   				return tr_key("hello_net_help")
   			var err2: String = str(n.call("join", str(args[1]), tr_key("hello_net_me")))
   			return err2 if err2 != "" else "ok"
   		"say":
   			var text: String = " ".join(PackedStringArray(args.slice(1)))
   			n.call("broadcast", MSG_SAY, text)
   			return tr_key("hello_net_line") % [tr_key("hello_net_me"), text]
   		"leave":
   			n.call("leave")
   			return "ok"
   	return tr_key("hello_net_help")
   
   
   ## A message arrived from another player.
   func _on_message(from_id: int, type: String, data: Variant) -> void:
   	if type == MSG_SAY:
   		var who: String = str(net.call("player_name", from_id))
   		_toast(tr_key("hello_net_line") % [who, str(data)])
   
   
   ## Session events: here only "someone joined" (the host sees it).
   func _on_event(kind: String, data: Dictionary) -> void:
   	if kind == "peer_joined":
   		_toast(tr_key("hello_net_joined") % str(data.get("name", "?")))
   
   
   ## Error: show a clear reason from the library's translations.
   func _on_failed(code: String) -> void:
   	_toast(tr_key("paxnet_err_" + code) + " " + tr_key("paxnet_err_" + code + "_do"))
   
   
   func _toast(text: String) -> void:
   	var g: Variant = Pax.get("game")
   	if g is Object and (g as Object).has_method("toast"):
   		(g as Object).call("toast", text)
   	else:
   		print(text)

   What matters here _lib() fetches the library. new_session() creates a session. host() opens a room, join() enters one. broadcast() sends to everyone. The message signal fires when a message reaches you.

5. Check the mod

   Run this command in the game folder. Exit code 0 means no errors:

   TerminalCopy

   godot --headless --path <game folder> -- --check-mods hello_net

6. Enable both mods and run the game on two computers

   Launcher → Mods → tick "PaxNet Core" and "Hello Net". Restart.

7. Play

   Press F8 to open the console.

   Who	What to type	What happens
   Host	hello host	"Opening the room…". The room is ready in 1–2 seconds.
   Host	hello code	An invite link, for example https://mp.paxuniverse.ru/j/D3EF5YXQ. Send it to a friend.
   Friend	hello join D3EF5YXQ	The friend enters the room; the host sees "Player joined the game". Pasting the whole link works too.
   Anyone	hello say Hi!	Everyone else sees "Player: Hi!".
   Anyone	hello leave	Leave. If the host leaves, guests see "The host closed the game".

   DoneThis is a complete online game: dropped connections, ordering and duplicates are already handled for you. Next come the reference and the recipes: real-time movement, turn-based play, shared dice, a room of the day.

How a single message travels

A guest called send(1, "my_mod.chat", "Hi"). Here is what happens next, top to bottom. You do not need to know this, but it makes errors easier to understand.

Who can message whom

Status: where your game is right now

A session has a status field. It changes by itself, and every change fires the changed signal. Look at the status to decide what to show the player.

There is also "" (empty string): no game; the session was just created or left with leave().

PaxNetLib: the library's entry point

The library creates the /root/PaxNetLib node and immediately, before it even enters the tree, stores it in the root's metadata. So fetch it like this; it works even in _mod_loaded:

## Fetch the library. Works already in _mod_loaded: the node lives in the root's metadata.
func get_paxnet() -> Node:
	var v: Variant = Pax.get_tree().root.get_meta("paxnet_lib", null)
	if v is Node:
		return v as Node
	return null   # library not enabled: show the player a hint

Call methods with lib.call("name", …) or simply lib.name(…): GDScript allows calling by name on a Node. The result of such a call is untyped, so give the variable an explicit type: var net: Node = lib.new_session(). The game will not compile var net := lib.new_session().

Session: your online game

The node returned by lib.new_session(). It is already in the tree and keeps processing even while the game is paused. One session is one game; after leave() the same session can be reused.

Tags: host works only on the host, guest only on a guest, both on everyone.

Open, join, leave

Messages

Lobby

Game time

Querying state

Signals

Events (event)

Readable fields

Room settings

The third argument of host(name, adapter, cfg) is a dictionary. Everything is optional: any key you omit takes its default.

net.host("Anna", null, {"max_players": 4, "time_mode": "vote", "join_in_progress": false})

What you can send

Put only plain values in data. Objects (nodes, resources, scripts) never travel over the network: that way another player cannot send you a malicious object.

Limits

Errors and what to do about them

An error arrives as a string code: from host() or join() (if it failed immediately), in the failed(code) signal and in last_notice.code. For every code the library ships two ready texts in Russian and English: paxnet_err_CODE (what happened) and paxnet_err_CODE_do (what to click).

func _on_failed(code: String) -> void:
	var what: String = tr_key("paxnet_err_" + code)        # "No such code, or the invite has expired."
	var todo: String = tr_key("paxnet_err_" + code + "_do") # "Check the code with your friend…"
	game.toast(what + " " + todo)

Ready-made solutions: copy and adapt

In the examples lib is the library and net is a session from lib.new_session(). Message types start with my_mod.: replace it with your mod id.

1. Real-time player positions

Each player tells everyone where they are 10 times per second. That is enough for smooth motion: between messages, smooth the position locally, for example with lerp.

const MSG_POS: String = "my_mod.pos"
var _pos_timer: float = 0.0
## Where the other players are now: player id → position.
var others: Dictionary = {}

## Call every frame from your _process: broadcasts your position 10 times per second.
func send_my_position(delta: float, my_pos: Vector2) -> void:
	_pos_timer += delta
	if _pos_timer < 0.1 or not bool(net.call("active")):
		return
	_pos_timer = 0.0
	net.call("broadcast", MSG_POS, my_pos)   # to everyone except yourself

## From the message signal handler.
func on_position(from_id: int, data: Variant) -> void:
	if data is Vector2:
		others[from_id] = data

2. Turn-based play: the host is the judge

The most robust scheme for turn-based games and anything where cheating is possible. A guest only asks to make a move. The host checks the rules and broadcasts the new state. Guests trust only the host.

const MSG_MOVE: String = "my_mod.move"     # guest → host: "I want to move"
const MSG_STATE: String = "my_mod.state"   # host → all: "here is the board now"
var board: Dictionary = {"turn": 0, "cells": {}}

## The player clicked a cell.
func try_move(cell: Vector2i) -> void:
	if bool(net.call("is_host")):
		_judge(1, cell)                          # the host judges its own moves too
	else:
		net.call("send", 1, MSG_MOVE, cell)      # a guest only asks

func on_judge_message(from_id: int, type: String, data: Variant) -> void:
	if type == MSG_MOVE and bool(net.call("is_host")) and data is Vector2i:
		_judge(from_id, data)
	elif type == MSG_STATE and from_id == 1 and data is Dictionary:
		board = data                             # a guest trusts only the host

func _judge(player_id: int, cell: Vector2i) -> void:
	var cells: Dictionary = board["cells"]
	var key: String = "%d,%d" % [cell.x, cell.y]
	if cells.has(key):
		return                                   # cell taken: move rejected
	cells[key] = player_id
	board["turn"] = int(board["turn"]) + 1
	net.call("broadcast", MSG_STATE, board)      # all guests get the new board

3. Shared dice: randomness that is the same for everyone

A plain randi() gives each player something different. lib.rng(seed, step, "stream") gives everyone the same result when all three inputs match: on any computer and any engine version.

## A die that rolls the same for every player. The host hands out seed once at the start
## of the game (for example in a "my_mod.seed" message); turn is the turn number.
func roll_dice(seed: int, turn: int) -> int:
	var r: RefCounted = lib.call("rng", seed, turn, "my_mod/dice")
	return int(r.call("irange", 1, 6))

Generator methods: next_u32(), frand() (0 to 1), irange(a, b) (an integer from a to b inclusive), chance(p), pick(array).

4. Room of the day

Everyone playing today lands in the same room without exchanging codes: the code is computed from the day number.

## Room of the day: every player gets the same code today. The first to arrive opens it,
## the rest join.
var _daily_code: String = ""

func enter_daily_room(my_name: String) -> void:
	_daily_code = str(lib.call("shared_code", int(lib.call("utc_day")), "my_mod/daily", "MM"))
	net.connect("failed", _on_daily_failed, CONNECT_ONE_SHOT)
	net.call("join", _daily_code, my_name)

func _on_daily_failed(code: String) -> void:
	if code == "code":
		# no such room yet: open it ourselves with this code
		net.call("host", "Daily", null, {"want_code": _daily_code, "max_players": 16})

5. On-screen status line

One line at the top of the screen with the code, players and ping. On an error a window appears with an explanation and a "Rejoin" or "OK" button. The library takes the texts from its own translations.

## Status line at the top of the screen: code, players, ping, a clear error with a "Rejoin" button.
func show_status_line(game: PaxGame) -> void:
	lib.call("overlay", net, game.hud_layer())

6. Raw channel: your own protocol end to end

If PaxNet sessions do not suit you (doom_2 is built this way), use the relay channel directly. Then ordering, duplicates and reconnection become your job. The game channel is already reliable and ordered, but on a disconnect everything in flight is lost.

## Raw relay channel without PaxNet sessions: the whole protocol is on you
## (doom_2 is built this way). In the channel the host is 1, guests are 2, 3…; 0 means "all guests".
var pipe: Object = null
var RP: Script = null

func open_raw_room() -> void:
	RP = lib.call("script_of", "RelayPipe")
	pipe = lib.call("open_pipe", {"op": "host", "name": "my room", "public": false, "max": 4,
		"ai": "", "preset": "my_mod", "host_name": "Host", "code": ""})
	if pipe == null:
		push_warning("relay: " + str(lib.call("pipe_detail")))
		return
	RP.call("wire", pipe, self, "_raw_")      # channel signals → _raw_lobby_ready etc.

func _raw_lobby_ready(code: Variant, _rules: Variant = null) -> void:
	print("room code: ", code)

func poll_raw() -> void:                          # every frame
	RP.call("poll", pipe)
	while true:
		var pk: Array = RP.call("recv", pipe)     # [sender, bytes] or []
		if pk.is_empty():
			break
		var d: Dictionary = lib.call("decode", pk[1])
		if bool(d["ok"]):
			print("from ", pk[0], ": ", d["v"])

func raw_send_all(value: Variant) -> void:
	RP.call("send", pipe, 0, lib.call("encode", value))

Your own world: checks and healing

The idea

The world is split into sections, named dictionaries ("score", "map", "units"). Each section gets a checksum. The host broadcasts its checksums. A guest compares them with its own. If section "map" does not match, the guest quietly asks the host for that section only. The host sends it, the guest inserts it, and the world is identical again; the game never stopped.

Two modes

The adapter: your world for PaxNet

The adapter is an object with methods PaxNet calls by name. You do not need to inherit anything from the library (and you cannot: the sandbox rejects a foreign extends). What matters is that all the methods exist. Here is a complete working example: a world with scores and a flag. It is covered by the network test: the world is delivered and changes arrive.

extends RefCounted
## A world for sync checks: player scores and a flag on the map. The PaxNet core calls these
## methods by name, so you do not need to inherit the library's Adapter.gd: it is enough that all methods exist.
## The host computes the world (cfg "authority": true): guests receive changes as diffs and compare checksums.

## World sections: name → plain data (numbers, strings, arrays, dictionaries).
var sections: Dictionary = {"score": {}, "flag": {"owner": "", "x": 0, "y": 0}}
var day: int = 0
## Where the mod reports changes (optional).
var on_changed: Callable = Callable()


# ---------- the world as a set of sections ----------

func section_names() -> Array:
	return ["flag", "score"]


func section_period(_name: String) -> int:
	return 1


func hashes(_tick: int, _all: bool = false) -> Dictionary:
	var h: Dictionary = {}
	for n in sections:
		h[n] = _hash(sections[n])
	return h


func hashes_view(_view: Variant, tick: int, all: bool = false) -> Dictionary:
	return hashes(tick, all)


func section_data(names: Array) -> Dictionary:
	var out: Dictionary = {}
	for n in names:
		if sections.has(n):
			out[n] = (sections[n] as Dictionary).duplicate(true)
	return out


func section_data_view(_view: Variant, names: Array) -> Dictionary:
	return section_data(names)


func apply_sections(data: Dictionary) -> void:
	for n in data:
		sections[n] = data[n]
	if on_changed.is_valid():
		on_changed.call()


func world_snapshot_view(_view: Variant) -> PackedByteArray:
	return var_to_bytes({"s": sections, "d": day})


func install_world(bytes: PackedByteArray) -> bool:
	var v: Variant = bytes_to_var(bytes)
	if not (v is Dictionary) or not (v as Dictionary).has("s"):
		return false
	sections = (v as Dictionary)["s"]
	day = int((v as Dictionary)["d"])
	if on_changed.is_valid():
		on_changed.call()
	return true


func view_of(_seat: int) -> Variant:
	return ""


func begin_views(_tick: int) -> void:
	pass


# ---------- game flow ----------

func current_day() -> int:
	return day


func advance(days: int, _tick: int, _world_seed: int) -> void:
	day += days


func action_policy(_kind: String) -> String:
	return "free"


func execute_action(_actor: Dictionary, _action: Dictionary, _ctx: Dictionary) -> Dictionary:
	return {"ok": false, "code": "illegal", "text": ""}


func apply_event(_ev: Dictionary) -> void:
	pass


func apply_deal(_kind: String, _from_seat: int, _to_seat: int, _terms: Dictionary) -> Dictionary:
	return {"ok": true}


func auto_reply(_kind: String, _from_seat: int, _to_seat: int, _terms: Dictionary) -> bool:
	return false


func countries() -> Array:
	return [{"id": 0, "name": "red"}, {"id": 1, "name": "blue"}]


# ---------- player-facing output (does not affect the world) ----------

func on_news(_e: Dictionary) -> void:
	pass


func on_ai_result(_e: Dictionary) -> void:
	pass


func on_action_result(_actor: Dictionary, _action: Dictionary, _result: Dictionary) -> void:
	pass


func on_chat(_from_id: int, _name: String, _text: String) -> void:
	pass


func on_notice(_code: String, _args: Dictionary) -> void:
	pass


func on_roster_changed(_players: Array) -> void:
	pass


func on_progress(_what: String, _ratio: float) -> void:
	pass


func on_time_state(_state: Dictionary) -> void:
	pass


# A hash that does not depend on dictionary key order (custom, because hash() of a dictionary does).
static func _hash(v: Variant) -> int:
	if v is Dictionary:
		var sum: int = 13
		for k in v:
			sum += hash(str(k)) * 31 + _hash((v as Dictionary)[k])
		return sum & 0xFFFFFFFF
	return hash(v) & 0xFFFFFFFF

How to use it

var world: RefCounted = load("res://mods/my_mod/ScoreWorld.gd").new()

func host_world() -> void:
	net.host("Anna", world, {"authority": true, "external_time": true})

func join_world(code: String) -> void:
	var my_world: RefCounted = load("res://mods/my_mod/ScoreWorld.gd").new()
	net.join(code, "Boris", my_world)          # the guest has its own instance; PaxNet fills it

# The host changed something in the world: record a step, guests receive the changes.
# Works only after net.start(): in the lobby record_step does nothing.
func add_point(player: String) -> void:
	var score: Dictionary = world.sections["score"]
	score[player] = int(score.get(player, 0)) + 1
	var core: Object = net.session
	core.record_step(0)                         # 0 days: a step with changes only

Adapter methods: what each must do

A game in the world of Pax Universe itself

The library includes ready-made world sync for the Pax Universe strategy game, the reason PaxNet was created. It is lib.world_service(): a session with the GameAdapter adapter. Sections are the keys of the game's save record. The world is projected for each guest's country. Province owners are healed through the stable API.

In such a game each player runs their own country, so its sections (orders, laws, treasury) are not healed from the host; otherwise the guest's actions would be rolled back. Consistency is kept by the shared sections: date, powers, province owners, armies, wars, chronicle, market.

Not working? Frequently asked questions

The sandbox: why things work the way they do

Pax Universe checks every mod before launch and refuses to run a mod that breaks the security rules. This protects players from harmful mods. PaxNet and your mod must follow the same rules.

What changed compared to the original PaxNet

The original PaxNet replaced the game's network service and opened a UDP port itself. That is impossible inside the mod sandbox, so it was reworked into a library.

For the sandbox

• No custom sockets any more. Removed UdpSocket, WsSocket, UPnP, NAT punch-through and joining by ip:port. Traffic goes through the game channel Network.relay_pipe(), the same way as in doom_2. The new PipeHost and PipeGuest give the core its old interface, so sessions, sync checks and world transfer were not rewritten.
• The game's network service is not replaced. A library must not silently change online play for everyone who enabled it, and cannot take away the channel the game itself uses.
• All paths are full literals res://mods/paxnet_core/…, without ...
• FileAccess.COMPRESSION_ZSTD replaced with the number 2 (verified against Godot 4.7).

Other

• The shared random generator mixes the stream name with FNV-1a instead of hash(). The result is identical on any engine version, but the sequences differ from the old PaxNet.
• Translation keys renamed to paxnet_…; all text moved out of code.
• The link on top of the reliable channel retransmits less: retries no sooner than 400 ms, a keep-alive every 500 ms, disconnect after 15 s of silence.
• The host says goodbye to everyone when leaving. Guests see "The host closed the game" and do not try to return.

MPL 2.0 in plain words

PaxNet is distributed under the Mozilla Public License 2.0. The full text is in the LICENSE file inside the mod and in the GitHub repository; a short notice sits at the top of every code file.

This is a summary, not legal advice. If it matters, read the full license text.

Protocol

You do not need to know this to use the library. The core protocol is unchanged (Proto.VERSION = 1). Link packets now travel as datagrams of the game channel instead of UDP. In the channel the host is number 1, guests are 2 and up. To the core, a guest's address looks like pipe#number.

0xA7 | conn u32 | flags u8 (bit 0: ack valid) | seq u16 | ack u16 | ack_bits u32 | records… | HMAC-SHA256 (8 bytes)
record: 1 reliable : varint id | u8 type | varint length | body
        2 slot     : u8 type | varint length | body   ("latest value")
        3 oneshot  : u8 type | varint length | body   (no retries: transfer chunks)

guest → HELLO(version, nonce_c)                 padded to 96 bytes
host  → CHALLENGE(nonce_c, window, cookie)      cookie = HMAC(host secret, address | nonce_c | window)
guest → CONNECT(nonce_c, window, cookie, info)  info: name, player key, mods, has world, last step, checksum
host  → ACCEPT(conn_id, welcome) | REJECT(code)
frame: 0xA6 | type | body | CRC32;  link key = HMAC(cookie | nonce_c, "pax-link")

How it was tested

What the network test covers: room and code; joining via link and via PAX-…; the roster on everyone; 60 messages in order without duplicates; a private A→B message reaching only B; 300 KB byte for byte; ready and start; a guest channel drop with return under the same number, with everything sent during the drop arriving exactly once and in order; the host leaving. For the world: 10 steps as diffs, healing a corrupted section without resending the world, returning to the same seat after a restart, the ScoreWorld adapter from this page. Plus join errors.

Run it yourself

The tests come as a separate archive for developers. Download it and unpack it so you get a paxnet-tests folder; in the commands below replace /paxnet_core/paxnet-tests with your path to it.

godot --headless --path /paxnet_core/paxnet-tests res://tests/compile.tscn   # compile all scripts
godot --headless --path /paxnet_core/paxnet-tests res://tests/net.tscn       # network test
python3 /paxnet_core/paxnet-tests/sandbox_scan.py /paxnet_core/paxnet-tests/mods/paxnet_core paxnet_core # sandbox scanner

What to check in the game itself

1. godot --headless --path <game folder> -- --check-mods paxnet_core: make sure the real check agrees with the scanner.
2. That your game version has Network.relay_pipe(). If not, lib.pipe_detail() and the log ([paxnet] relay_pipe not found) show what was found.
3. A game in the game world: console F8, paxnet host Name on one computer and paxnet join CODE Name on another.

Help PaxNet grow

PaxNet is free and open, and it will stay that way. If the library helped your mod, or you simply want it to keep growing, you can support its development. The money pays for time spent on new features, testing on fresh game versions and this documentation.