feat: Implement synchronizer logic as servers

addons/netfox.extras/plugin.cfg

@@ -3,5 +3,5 @@
 name="netfox.extras"
 description="Game-specific utilities for Netfox"
 author="Tamas Galffy and contributors"
-version="1.39.0"
+version="1.40.0"
 script="netfox-extras.gd"

addons/netfox.internals/bitset.gd

@@ -0,0 +1,95 @@
+extends RefCounted
+class_name _Bitset
+
+# Stores a list of booleans, representing them efficiently as a PackedByteArray
+
+var _data: PackedByteArray
+var _bit_count: int
+
+static func of_bools(values: Array) -> _Bitset:
+	var result := _Bitset.new(values.size())
+	for i in values.size():
+		if values[i]:
+			result.set_bit(i)
+	return result
+
+func _init(bit_count: int):
+	var bytes := bit_count / 8
+	if bit_count % 8 > 0:
+		bytes += 1
+
+	_data = PackedByteArray()
+	_data.resize(bytes)
+
+	_bit_count = bit_count
+
+func bit_count() -> int:
+	return _bit_count
+
+func is_empty() -> bool:
+	return _bit_count == 0
+
+func is_not_empty() -> bool:
+	return _bit_count != 0
+
+func get_bit(idx: int) -> bool:
+	assert(idx < _bit_count, "Accessing bit %d on bitset of size %d!" % [idx, _bit_count])
+	var byte_idx := idx / 8
+	var bit_idx := idx % 8
+
+	return (_data[byte_idx] >> bit_idx) & 0x1 != 0
+
+func set_bit(idx: int) -> void:
+	assert(idx < _bit_count, "Accessing bit %d on bitset of size %d!" % [idx, _bit_count])
+	var byte_idx := idx / 8
+	var bit_idx := idx % 8
+
+	_data[byte_idx] |= 0x1 << bit_idx
+
+func clear_bit(idx: int) -> void:
+	assert(idx < _bit_count, "Accessing bit %d on bitset of size %d!" % [idx, _bit_count])
+	var byte_idx := idx / 8
+	var bit_idx := idx % 8
+
+	_data[byte_idx] &= ~(0x1 << bit_idx)
+
+func toggle_bit(idx: int) -> void:
+	assert(idx < _bit_count, "Accessing bit %d on bitset of size %d!" % [idx, _bit_count])
+	var byte_idx := idx / 8
+	var bit_idx := idx % 8
+
+	_data[byte_idx] ^= 0x1 << bit_idx
+
+func get_set_indices() -> Array[int]:
+	var result := [] as Array[int]
+	for i in _data.size():
+		var byte := _data[i]
+
+		if byte & 0x01: result.append(i * 8 + 0)
+		if byte & 0x02: result.append(i * 8 + 1)
+		if byte & 0x04: result.append(i * 8 + 2)
+		if byte & 0x08: result.append(i * 8 + 3)
+
+		if byte & 0x10: result.append(i * 8 + 4)
+		if byte & 0x20: result.append(i * 8 + 5)
+		if byte & 0x40: result.append(i * 8 + 6)
+		if byte & 0x80: result.append(i * 8 + 7)
+	return result
+
+func equals(other) -> bool:
+	if other is _Bitset:
+		return other._bit_count == _bit_count and other._data == _data
+	else:
+		return false
+
+func _to_string() -> String:
+	if is_empty():
+		return "Bitset(n=0)"
+	else:
+		var body := ""
+		for i in _bit_count:
+			if i != 0 and i % 4 == 0:
+				body += " "
+			if get_bit(i): body += "1"
+			else: body += "0"
+		return "Bitset(n=%d, %s)" % [_bit_count, body]

addons/netfox.internals/bitset.gd.uid

@@ -0,0 +1 @@
+uid://c46ub48lgga12

addons/netfox.internals/graph.gd

@@ -0,0 +1,57 @@
+extends RefCounted
+class_name _Graph
+
+# Represents a graph, in the sense of a set of nodes, arbitrarily connected by
+# links
+
+var _links_from := {} # `from` to `to[]`
+var _links_to := {} # `to` to `from[]`
+
+func link(from: Variant, to: Variant) -> void:
+	if has_link(from, to):
+		return
+
+	_append(_links_from, from, to)
+	_append(_links_to, to, from)
+
+func unlink(from: Variant, to: Variant) -> void:
+	_erase(_links_from, from, to)
+	_erase(_links_to, to, from)
+
+func erase(node: Variant) -> void:
+	var links_to := _links_from.get(node, [])
+	var links_from := _links_to.get(node, [])
+
+	_links_from.erase(node)
+	_links_to.erase(node)
+
+	for link in links_to:
+		_erase(_links_to, link, node)
+
+	for link in links_from:
+		_erase(_links_from, link, node)
+
+func get_linked_from(from: Variant) -> Array:
+	return _links_from.get(from, [])
+
+func get_linked_to(to: Variant) -> Array:
+	return _links_to.get(to, [])
+
+func has_link(from: Variant, to: Variant) -> bool:
+	return get_linked_from(from).has(to)
+
+func _append(pool: Dictionary, key: Variant, value: Variant) -> void:
+	if not pool.has(key):
+		pool[key] = [value]
+	else:
+		pool[key].append(value)
+
+func _erase(pool: Dictionary, key: Variant, value: Variant) -> void:
+	if not pool.has(key):
+		return
+
+	var values := pool[key] as Array
+	values.erase(value)
+
+	if values.is_empty():
+		pool.erase(key)

addons/netfox.internals/graph.gd.uid

@@ -0,0 +1 @@
+uid://djknl4n6akxue

addons/netfox.internals/history-buffer.gd

@@ -1,70 +1,134 @@
 extends RefCounted
 class_name _HistoryBuffer
 
-# Maps ticks (int) to arbitrary data
-var _buffer: Dictionary = {}
+# Maps ticks (int) to arbitrary data, stored in a sliding ring buffer
+
+var _capacity := 64
+var _buffer := []
+var _previous := []
+
+var _tail := 0
+var _head := 0
+
+static func of(capacity: int, data: Dictionary) -> _HistoryBuffer:
+	var history_buffer := _HistoryBuffer.new(capacity)
+	for idx in data:
+		history_buffer.set_at(idx, data[idx])
+	return history_buffer
+
+func _init(capacity: int = 64):
+	_capacity = capacity
+	_buffer.resize(_capacity)
+	_previous.resize(_capacity)
+
+func duplicate(deep: bool = false) -> _HistoryBuffer:
+	var buffer := _HistoryBuffer.new(_capacity)
+
+	buffer._buffer = _buffer.duplicate(deep)
+	buffer._previous = _previous.duplicate()
+	buffer._tail = _tail
+	buffer._head = _head
+
+	return buffer
+
+func push(value: Variant) -> void:
+	_buffer[_head % _capacity] = value
+	_previous[_head % _capacity] = _head
+	_head += 1
+	_tail += maxi(0, size() - capacity())
+
+func pop() -> Variant:
+	assert(is_not_empty(), "History buffer is empty!")
+
+	var value = _buffer[_tail % _capacity]
+	_tail += 1
+	return value
+
+func set_at(at: int, value: Variant) -> void:
+	# Why does this need so many branches?
+	if is_empty():
+		# Buffer is empty, jump to specified index
+		_tail = at
+		_head = at
+		push(value)
+	elif at < _head - capacity():
+		# Trying to set something that would wrap back around and overwrite
+		# current data
+		return
+	elif at == _head:
+		# Simply adding a new item
+		push(value)
+	elif at < _head:
+		_buffer[at % _capacity] = value
+		# Update prev-buffer
+		for i in range(at, _head):
+			if _previous[i % _capacity] == i:
+				break
+			_previous[i % _capacity] = at
+		_tail = mini(_tail, at)
+	elif at >= _head + _capacity:
+		# We're leaving all data behind
+		_tail = at
+		_head = at
+
+		_previous.fill(null)
+		_buffer.fill(null)
+
+		push(value)
+	elif at >= _head:
+		# Skipping forward a bit
+		var previous := _head - 1
+		while _head < at:
+			_previous[_head % _capacity] = previous
+			_head += 1
+		_tail += maxi(0, size() - _capacity)
+
+		push(value)
+
+func has_at(at: int) -> bool:
+	if is_empty(): return false
+	if at < _head - capacity(): return false
+	if at >= _head: return false
+	return _previous[at % _capacity] == at
+
+func get_at(at: int, default: Variant = null) -> Variant:
+	if not has_at(at):
+		return default
+	return _buffer[at % _capacity]
+
+func has_latest_at(at: int) -> bool:
+	if is_empty(): return false
+	if at < _tail: return false
+	return true
 
-func get_snapshot(tick: int):
-	if _buffer.has(tick):
-		return _buffer[tick]
-	else:
-		return null
-
-func set_snapshot(tick: int, data):
-	_buffer[tick] = data
-
-func get_buffer() -> Dictionary:
-	return _buffer
+func size() -> int:
+	return _head - _tail
 
-func get_earliest_tick() -> int:
-	return _buffer.keys().min()
+func capacity() -> int:
+	return _capacity
 
-func get_latest_tick() -> int:
-	return _buffer.keys().max()
+func get_earliest_index() -> int:
+	return _tail
 
-func get_closest_tick(tick: int) -> int:
-	if _buffer.has(tick):
-		return tick
+func get_latest_index() -> int:
+	return _head - 1
 
-	if _buffer.is_empty():
+func get_latest_index_at(at: int) -> int:
+	if not has_latest_at(at):
 		return -1
+	if at >= _head:
+		return get_latest_index()
 
-	var earliest_tick = get_earliest_tick()
-	if tick < earliest_tick:
-		return earliest_tick
-
-	var latest_tick = get_latest_tick()
-	if tick > latest_tick:
-		return latest_tick
-
-	return _buffer.keys() \
-		.filter(func (key): return key < tick) \
-		.max()
+	return _previous[at % _capacity]
 
-func get_history(tick: int):
-	var closest_tick = get_closest_tick(tick)
-	return _buffer.get(closest_tick)
-
-func trim(earliest_tick_to_keep: int):
-	var ticks := _buffer.keys()
-	for tick in ticks:
-		if tick < earliest_tick_to_keep:
-			_buffer.erase(tick)
+func get_latest_at(at: int) -> Variant:
+	return get_at(get_latest_index_at(at))
 
 func clear():
-	_buffer.clear()
-
-func size() -> int:
-	return _buffer.size()
+	_tail = _head
 
 func is_empty() -> bool:
-	return _buffer.is_empty()
-
-func has(tick) -> bool:
-	return _buffer.has(tick)
-
-func ticks() -> Array:
-	return _buffer.keys()
+	return size() == 0
 
-func erase(tick):
-	_buffer.erase(tick)
+func is_not_empty() -> bool:
+	return not is_empty()

addons/netfox.internals/interval-scheduler.gd

@@ -0,0 +1,22 @@
+extends RefCounted
+class_name _IntervalScheduler
+
+# Returns true on every nth `is_now()` call
+
+var interval := 1
+var _idx := 0
+
+func _init(p_interval: int = 1):
+	interval = p_interval
+
+func is_now() -> bool:
+	if interval <= 0:
+		return false
+	elif interval == 1:
+		return true
+	elif _idx + 1 >= interval:
+		_idx = 0
+		return true
+	else:
+		_idx += 1
+		return false

addons/netfox.internals/interval-scheduler.gd.uid

@@ -0,0 +1 @@
+uid://egfuyvoj0r2s

addons/netfox.internals/plugin.cfg

@@ -3,5 +3,5 @@
 name="netfox.internals"
 description="Shared internals for netfox addons"
 author="Tamas Galffy and contributors"
-version="1.39.0"
+version="1.40.0"
 script="plugin.gd"