431 lines
20 KiB
Python
431 lines
20 KiB
Python
#!/usr/bin/env python3
|
|
"""Authoritative world mutation policy for Pixel Island.
|
|
|
|
The browser may preview local changes, but shared worlds should apply only the
|
|
server events produced here. This module focuses on ownership and destructive
|
|
mutation safety; rotation and moderation policy remain separate.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import time
|
|
from copy import deepcopy
|
|
from typing import Any, Dict, Iterable, List, MutableMapping, Optional, Tuple
|
|
|
|
ACTIVE = "active"
|
|
VIOLATION_HIDDEN = "violation_hidden"
|
|
|
|
OBJECT_KEYS = {"static": "placed", "dynamic": "dynamicSummons"}
|
|
DAY_MS = 10 * 60 * 1000
|
|
|
|
|
|
def now_ms() -> int:
|
|
return int(time.time() * 1000)
|
|
|
|
|
|
def account_id(account: MutableMapping[str, Any] | None) -> str:
|
|
return str((account or {}).get("id") or "")
|
|
|
|
|
|
def is_admin(account: MutableMapping[str, Any] | None) -> bool:
|
|
return bool((account or {}).get("admin") or (account or {}).get("role") == "admin")
|
|
|
|
|
|
def normalize_tombstones(state: MutableMapping[str, Any]) -> MutableMapping[str, Any]:
|
|
tombstones = state.setdefault("tombstones", {})
|
|
tombstones.setdefault("assets", {})
|
|
tombstones.setdefault("objects", {})
|
|
return tombstones
|
|
|
|
|
|
def iter_objects(state: MutableMapping[str, Any]) -> Iterable[Tuple[str, MutableMapping[str, Any]]]:
|
|
for kind, key in OBJECT_KEYS.items():
|
|
for obj in state.get(key) or []:
|
|
if isinstance(obj, MutableMapping) and obj.get("id"):
|
|
yield kind, obj
|
|
|
|
|
|
def find_object(state: MutableMapping[str, Any], object_id: str, kind: Optional[str] = None) -> Tuple[Optional[str], Optional[MutableMapping[str, Any]]]:
|
|
kinds = [kind] if kind in OBJECT_KEYS else list(OBJECT_KEYS)
|
|
for item_kind in kinds:
|
|
for obj in state.get(OBJECT_KEYS[item_kind]) or []:
|
|
if str(obj.get("id") or "") == str(object_id):
|
|
return item_kind, obj
|
|
return None, None
|
|
|
|
|
|
def find_asset(state: MutableMapping[str, Any], asset_id: str) -> Optional[MutableMapping[str, Any]]:
|
|
for asset in state.get("assets") or []:
|
|
if isinstance(asset, MutableMapping) and str(asset.get("id") or "") == str(asset_id):
|
|
return asset
|
|
return None
|
|
|
|
|
|
def owner_of_object(state: MutableMapping[str, Any], obj: MutableMapping[str, Any]) -> str:
|
|
if obj.get("ownerAccountId"):
|
|
return str(obj.get("ownerAccountId"))
|
|
asset = find_asset(state, str(obj.get("assetId") or ""))
|
|
return str((asset or {}).get("ownerAccountId") or "")
|
|
|
|
|
|
def can_modify_object(state: MutableMapping[str, Any], account: MutableMapping[str, Any] | None, object_id: str) -> Tuple[bool, Dict[str, Any]]:
|
|
actor = account_id(account)
|
|
if not actor:
|
|
return False, {"reason": "account_required"}
|
|
kind, obj = find_object(state, object_id)
|
|
if not obj:
|
|
return False, {"reason": "object_not_found"}
|
|
owner = owner_of_object(state, obj)
|
|
if actor == owner or is_admin(account):
|
|
return True, {"reason": None, "kind": kind, "ownerAccountId": owner}
|
|
return False, {"reason": "not_object_owner", "ownerAccountId": owner}
|
|
|
|
|
|
def can_delete_asset(state: MutableMapping[str, Any], account: MutableMapping[str, Any] | None, asset_id: str) -> Tuple[bool, Dict[str, Any]]:
|
|
actor = account_id(account)
|
|
if not actor:
|
|
return False, {"reason": "account_required"}
|
|
asset = find_asset(state, asset_id)
|
|
if not asset:
|
|
return False, {"reason": "asset_not_found"}
|
|
owner = str(asset.get("ownerAccountId") or "")
|
|
return True, {"reason": None, "ownerAccountId": owner}
|
|
|
|
|
|
def is_object_tombstoned(state: MutableMapping[str, Any], object_id: str, version: int = 0) -> bool:
|
|
tomb = normalize_tombstones(state)["objects"].get(str(object_id))
|
|
return bool(tomb and int(tomb.get("version") or 0) >= int(version or 0))
|
|
|
|
|
|
def is_asset_tombstoned(state: MutableMapping[str, Any], asset_id: str, version: int = 0) -> bool:
|
|
tomb = normalize_tombstones(state)["assets"].get(str(asset_id))
|
|
return bool(tomb and int(tomb.get("version") or 0) >= int(version or 0))
|
|
|
|
|
|
def _server_event(event_type: str, actor: str, payload: Dict[str, Any], at: Optional[int] = None) -> Dict[str, Any]:
|
|
stamp = at or now_ms()
|
|
return {
|
|
"serverEventId": f"sev_{stamp}_{event_type.replace('.', '_')}",
|
|
"serverAt": stamp,
|
|
"actorAccountId": actor,
|
|
"type": event_type,
|
|
**payload,
|
|
}
|
|
|
|
|
|
def _accepted(event: Dict[str, Any]) -> Dict[str, Any]:
|
|
return {"accepted": True, "event": event}
|
|
|
|
|
|
def phase_key_for_time(world_time_ms: int, day_ms: int = DAY_MS) -> str:
|
|
progress = (int(world_time_ms) % int(day_ms or DAY_MS)) / float(day_ms or DAY_MS)
|
|
if progress < 0.10:
|
|
return "pre_dawn"
|
|
if progress < 0.20:
|
|
return "sunrise"
|
|
if progress < 0.60:
|
|
return "day"
|
|
if progress < 0.72:
|
|
return "sunset"
|
|
return "night"
|
|
|
|
|
|
def make_world_phase_event(at: Optional[int] = None, day_ms: int = DAY_MS) -> Dict[str, Any]:
|
|
"""Create the authoritative day/night clock event emitted by the server."""
|
|
stamp = at or now_ms()
|
|
cycle = int(day_ms or DAY_MS)
|
|
world_time_ms = int(stamp)
|
|
progress = (world_time_ms % cycle) / float(cycle)
|
|
return _server_event(
|
|
"world.phase",
|
|
"server",
|
|
{
|
|
"worldTimeMs": world_time_ms,
|
|
"dayMs": cycle,
|
|
"phase": {"key": phase_key_for_time(world_time_ms, cycle), "progress": progress},
|
|
},
|
|
stamp,
|
|
)
|
|
|
|
|
|
def make_dynamic_move_event(
|
|
state: MutableMapping[str, Any],
|
|
object_id: str,
|
|
x: float,
|
|
y: float,
|
|
target_x: Optional[float] = None,
|
|
target_y: Optional[float] = None,
|
|
at: Optional[int] = None,
|
|
actor: str = "server",
|
|
) -> Optional[Dict[str, Any]]:
|
|
"""Create an authoritative dynamic-object movement event.
|
|
|
|
Clients may ask for a target, but shared-world dynamic positions are only
|
|
changed after this server event is applied.
|
|
"""
|
|
stamp = at or now_ms()
|
|
kind, obj = find_object(state, object_id, "dynamic")
|
|
if kind != "dynamic" or not obj:
|
|
return None
|
|
next_object = deepcopy(dict(obj))
|
|
target = {
|
|
"objectId": str(object_id),
|
|
"x": float(x),
|
|
"y": float(y),
|
|
"targetX": float(target_x if target_x is not None else x),
|
|
"targetY": float(target_y if target_y is not None else y),
|
|
"homeX": float(next_object.get("homeX", x)),
|
|
"homeY": float(next_object.get("homeY", y)),
|
|
"serverAt": stamp,
|
|
}
|
|
next_object["serverState"] = target
|
|
next_object["version"] = int(next_object.get("version") or 0) + 1
|
|
return _server_event(
|
|
"dynamic.move",
|
|
actor or "server",
|
|
{
|
|
"objectId": str(object_id),
|
|
"object": next_object,
|
|
"x": target["x"],
|
|
"y": target["y"],
|
|
"targetX": target["targetX"],
|
|
"targetY": target["targetY"],
|
|
"homeX": target["homeX"],
|
|
"homeY": target["homeY"],
|
|
"objectVersion": next_object["version"],
|
|
},
|
|
stamp,
|
|
)
|
|
|
|
|
|
def _rejected(reason: str, **extra: Any) -> Dict[str, Any]:
|
|
return {"accepted": False, "reason": reason, **extra}
|
|
|
|
|
|
def _copy_owned_asset(asset: MutableMapping[str, Any], owner: str) -> Dict[str, Any]:
|
|
copied = deepcopy(dict(asset))
|
|
copied["ownerAccountId"] = owner
|
|
copied.setdefault("author", owner)
|
|
copied.setdefault("version", 1)
|
|
return copied
|
|
|
|
|
|
def _copy_owned_object(obj: MutableMapping[str, Any], owner: str) -> Dict[str, Any]:
|
|
copied = deepcopy(dict(obj))
|
|
copied["ownerAccountId"] = owner
|
|
copied["version"] = int(copied.get("version") or 0) + 1
|
|
copied.setdefault("status", ACTIVE)
|
|
return copied
|
|
|
|
|
|
def apply_command(state: MutableMapping[str, Any], account: MutableMapping[str, Any] | None, command: MutableMapping[str, Any], at: Optional[int] = None) -> Dict[str, Any]:
|
|
"""Validate a client command and return a server event without mutating state."""
|
|
actor = account_id(account)
|
|
if not actor:
|
|
return _rejected("account_required")
|
|
command_type = str(command.get("type") or "")
|
|
|
|
if command_type == "asset.create":
|
|
asset = command.get("asset")
|
|
if not isinstance(asset, MutableMapping) or not asset.get("id"):
|
|
return _rejected("invalid_asset")
|
|
if is_asset_tombstoned(state, str(asset["id"]), int(asset.get("version") or 1)):
|
|
return _rejected("asset_tombstoned")
|
|
return _accepted(_server_event("asset.upsert", actor, {"asset": _copy_owned_asset(asset, actor)}, at))
|
|
|
|
if command_type in {"object.publish", "object.move"}:
|
|
kind = str(command.get("kind") or "static")
|
|
obj = command.get("object")
|
|
if kind not in OBJECT_KEYS or not isinstance(obj, MutableMapping) or not obj.get("id"):
|
|
return _rejected("invalid_object")
|
|
asset = find_asset(state, str(obj.get("assetId") or ""))
|
|
if not asset:
|
|
return _rejected("asset_not_found")
|
|
_, existing = find_object(state, str(obj["id"]), kind)
|
|
if existing:
|
|
allowed, meta = can_modify_object(state, account, str(obj["id"]))
|
|
if not allowed:
|
|
return _rejected(meta["reason"], **{k: v for k, v in meta.items() if k != "reason"})
|
|
owner = owner_of_object(state, existing)
|
|
else:
|
|
if str(asset.get("ownerAccountId") or "") != actor and not is_admin(account):
|
|
return _rejected("not_asset_owner", ownerAccountId=asset.get("ownerAccountId"))
|
|
owner = actor
|
|
next_object = _copy_owned_object(obj, owner)
|
|
if is_object_tombstoned(state, str(next_object["id"]), int(next_object.get("version") or 1)):
|
|
return _rejected("object_tombstoned")
|
|
return _accepted(_server_event("object.upsert", actor, {"kind": kind, "object": next_object, "objectVersion": next_object["version"]}, at))
|
|
|
|
if command_type == "object.delete":
|
|
object_id = str(command.get("objectId") or "")
|
|
kind = str(command.get("kind") or "")
|
|
allowed, meta = can_modify_object(state, account, object_id)
|
|
if not allowed:
|
|
return _rejected(meta["reason"], **{k: v for k, v in meta.items() if k != "reason"})
|
|
found_kind, obj = find_object(state, object_id, kind if kind in OBJECT_KEYS else None)
|
|
version = int((obj or {}).get("version") or 0) + 1
|
|
tombstone = {"id": object_id, "deletedAt": at or now_ms(), "deletedBy": actor, "version": version}
|
|
return _accepted(_server_event("object.delete", actor, {"kind": found_kind, "objectId": object_id, "objectVersion": version, "tombstone": tombstone}, at))
|
|
|
|
if command_type == "asset.delete":
|
|
asset_id = str(command.get("assetId") or "")
|
|
allowed, meta = can_delete_asset(state, account, asset_id)
|
|
if not allowed:
|
|
return _rejected(meta["reason"], **{k: v for k, v in meta.items() if k != "reason"})
|
|
asset = find_asset(state, asset_id) or {}
|
|
version = int(asset.get("version") or 0) + 1
|
|
object_tombstones: List[Dict[str, Any]] = []
|
|
for _, obj in iter_objects(state):
|
|
if str(obj.get("assetId") or "") == asset_id:
|
|
object_tombstones.append({"id": str(obj["id"]), "deletedAt": at or now_ms(), "deletedBy": actor, "version": int(obj.get("version") or 0) + 1})
|
|
tombstone = {"id": asset_id, "deletedAt": at or now_ms(), "deletedBy": actor, "version": version}
|
|
return _accepted(_server_event("asset.delete", actor, {"assetId": asset_id, "assetVersion": version, "tombstone": tombstone, "objectTombstones": object_tombstones}, at))
|
|
|
|
if command_type == "admin.hide_violation":
|
|
if not is_admin(account):
|
|
return _rejected("admin_required")
|
|
object_id = str(command.get("objectId") or "")
|
|
kind, obj = find_object(state, object_id)
|
|
if not obj:
|
|
return _rejected("object_not_found")
|
|
next_object = deepcopy(dict(obj))
|
|
next_object["status"] = VIOLATION_HIDDEN
|
|
next_object["permanentHidden"] = True
|
|
next_object["hiddenReason"] = "moderation_violation"
|
|
next_object["version"] = int(next_object.get("version") or 0) + 1
|
|
return _accepted(_server_event("object.upsert", actor, {"kind": kind, "object": next_object, "objectVersion": next_object["version"]}, at))
|
|
|
|
return _rejected("unknown_command")
|
|
|
|
|
|
def apply_server_event(state: MutableMapping[str, Any], event: MutableMapping[str, Any]) -> bool:
|
|
"""Apply only server-issued events. Returns True when state changed."""
|
|
if not event or not event.get("serverEventId") or not event.get("serverAt"):
|
|
return False
|
|
normalize_tombstones(state)
|
|
event_type = str(event.get("type") or "")
|
|
|
|
if event_type == "world.phase":
|
|
clock = state.setdefault("serverSync", {}).setdefault("clock", {})
|
|
day_ms = int(event.get("dayMs") or DAY_MS)
|
|
world_time_ms = int(event.get("worldTimeMs") or event.get("serverNow") or event.get("serverAt") or now_ms())
|
|
clock.clear()
|
|
clock.update({
|
|
"worldTimeMs": world_time_ms,
|
|
"syncedAt": int(event.get("serverAt") or now_ms()),
|
|
"dayMs": day_ms,
|
|
"phase": event.get("phase") or {"key": phase_key_for_time(world_time_ms, day_ms), "progress": (world_time_ms % day_ms) / float(day_ms)},
|
|
"serverEventId": event["serverEventId"],
|
|
})
|
|
state["serverSync"]["lastServerEventId"] = event["serverEventId"]
|
|
return True
|
|
|
|
if event_type == "dynamic.move":
|
|
object_id = str(event.get("objectId") or event.get("dynamicId") or "")
|
|
obj = event.get("object")
|
|
if not object_id and isinstance(obj, MutableMapping):
|
|
object_id = str(obj.get("id") or "")
|
|
if not object_id:
|
|
return False
|
|
object_version = int((obj or {}).get("version") or event.get("objectVersion") or 1) if isinstance(obj, MutableMapping) else int(event.get("objectVersion") or 1)
|
|
if is_object_tombstoned(state, object_id, object_version):
|
|
return False
|
|
target = {
|
|
"objectId": object_id,
|
|
"x": float(event.get("x", (obj or {}).get("serverState", {}).get("x", (obj or {}).get("homeX", 0))) if isinstance(obj, MutableMapping) else event.get("x", 0)),
|
|
"y": float(event.get("y", (obj or {}).get("serverState", {}).get("y", (obj or {}).get("homeY", 0))) if isinstance(obj, MutableMapping) else event.get("y", 0)),
|
|
"targetX": float(event.get("targetX", event.get("x", 0))),
|
|
"targetY": float(event.get("targetY", event.get("y", 0))),
|
|
"homeX": float(event.get("homeX", (obj or {}).get("homeX", 0)) if isinstance(obj, MutableMapping) else event.get("homeX", 0)),
|
|
"homeY": float(event.get("homeY", (obj or {}).get("homeY", 0)) if isinstance(obj, MutableMapping) else event.get("homeY", 0)),
|
|
"serverAt": int(event.get("serverAt") or now_ms()),
|
|
}
|
|
server_sync = state.setdefault("serverSync", {})
|
|
server_sync.setdefault("dynamicTargets", {})[object_id] = target
|
|
if isinstance(obj, MutableMapping) and obj.get("id"):
|
|
rows = state.setdefault("dynamicSummons", [])
|
|
next_object = deepcopy(dict(obj))
|
|
next_object["serverState"] = target
|
|
index = next((i for i, item in enumerate(rows) if str(item.get("id") or "") == object_id), -1)
|
|
if index >= 0:
|
|
rows[index] = next_object
|
|
else:
|
|
rows.append(next_object)
|
|
server_sync["lastServerEventId"] = event["serverEventId"]
|
|
return True
|
|
|
|
if event_type == "asset.upsert":
|
|
asset = event.get("asset")
|
|
if not isinstance(asset, MutableMapping) or not asset.get("id"):
|
|
return False
|
|
if is_asset_tombstoned(state, str(asset["id"]), int(asset.get("version") or 1)):
|
|
return False
|
|
assets = state.setdefault("assets", [])
|
|
index = next((i for i, item in enumerate(assets) if item.get("id") == asset.get("id")), -1)
|
|
if index >= 0:
|
|
assets[index] = deepcopy(dict(asset))
|
|
else:
|
|
assets.insert(0, deepcopy(dict(asset)))
|
|
state.setdefault("serverSync", {})["lastServerEventId"] = event["serverEventId"]
|
|
return True
|
|
|
|
if event_type == "object.upsert":
|
|
obj = event.get("object")
|
|
kind = str(event.get("kind") or "static")
|
|
if kind not in OBJECT_KEYS or not isinstance(obj, MutableMapping) or not obj.get("id"):
|
|
return False
|
|
if is_object_tombstoned(state, str(obj["id"]), int(obj.get("version") or event.get("objectVersion") or 1)):
|
|
return False
|
|
rows = state.setdefault(OBJECT_KEYS[kind], [])
|
|
index = next((i for i, item in enumerate(rows) if item.get("id") == obj.get("id")), -1)
|
|
if index >= 0:
|
|
rows[index] = deepcopy(dict(obj))
|
|
else:
|
|
rows.append(deepcopy(dict(obj)))
|
|
state.setdefault("serverSync", {})["lastServerEventId"] = event["serverEventId"]
|
|
return True
|
|
|
|
if event_type == "object.delete":
|
|
object_id = str(event.get("objectId") or "")
|
|
kind = str(event.get("kind") or "")
|
|
if not object_id or kind not in OBJECT_KEYS:
|
|
return False
|
|
tombstone = event.get("tombstone") or {"id": object_id, "deletedAt": event["serverAt"], "deletedBy": event.get("actorAccountId"), "version": event.get("objectVersion") or 1}
|
|
state["tombstones"]["objects"][object_id] = tombstone
|
|
state[OBJECT_KEYS[kind]] = [obj for obj in state.get(OBJECT_KEYS[kind]) or [] if str(obj.get("id") or "") != object_id]
|
|
state.setdefault("objectVotes", {}).pop(object_id, None)
|
|
state.setdefault("hiddenObjects", {}).pop(object_id, None)
|
|
state.setdefault("serverSync", {}).setdefault("dynamicTargets", {}).pop(object_id, None)
|
|
state["moderationReports"] = [report for report in state.get("moderationReports") or [] if report.get("objectId") != object_id]
|
|
state.setdefault("serverSync", {})["lastServerEventId"] = event["serverEventId"]
|
|
return True
|
|
|
|
if event_type == "asset.delete":
|
|
asset_id = str(event.get("assetId") or "")
|
|
if not asset_id:
|
|
return False
|
|
state["tombstones"]["assets"][asset_id] = event.get("tombstone") or {"id": asset_id, "deletedAt": event["serverAt"], "deletedBy": event.get("actorAccountId"), "version": event.get("assetVersion") or 1}
|
|
for tombstone in event.get("objectTombstones") or []:
|
|
if tombstone.get("id"):
|
|
state["tombstones"]["objects"][str(tombstone["id"])] = tombstone
|
|
removed_object_ids = {str(t.get("id")) for t in event.get("objectTombstones") or [] if t.get("id")}
|
|
state["assets"] = [asset for asset in state.get("assets") or [] if str(asset.get("id") or "") != asset_id]
|
|
for key in OBJECT_KEYS.values():
|
|
state[key] = [obj for obj in state.get(key) or [] if str(obj.get("id") or "") not in removed_object_ids]
|
|
state.setdefault("assetVotes", {}).pop(asset_id, None)
|
|
state.setdefault("hiddenAssets", {}).pop(asset_id, None)
|
|
dynamic_targets = state.setdefault("serverSync", {}).setdefault("dynamicTargets", {})
|
|
for object_id in removed_object_ids:
|
|
state.setdefault("objectVotes", {}).pop(object_id, None)
|
|
state.setdefault("hiddenObjects", {}).pop(object_id, None)
|
|
dynamic_targets.pop(object_id, None)
|
|
state["moderationReports"] = [report for report in state.get("moderationReports") or [] if report.get("objectId") not in removed_object_ids]
|
|
state.setdefault("serverSync", {})["lastServerEventId"] = event["serverEventId"]
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
def can_import_full_state(state: MutableMapping[str, Any], account: MutableMapping[str, Any] | None) -> Tuple[bool, Dict[str, Any]]:
|
|
if state.get("worldMode") == "shared":
|
|
return False, {"reason": "shared_full_import_disabled"}
|
|
return True, {"reason": None}
|