server/player_state.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+import math
+from collections.abc import Callable
+from typing import Any
+
+MAX_CHARACTER_NAME_CHARS = 128
+MAX_EQUIPPED_ITEMS = 32
+MAX_EQUIPMENT_SLOT_CHARS = 64
+MAX_HEAD_PARTS = 64
+MAX_MORPHS = 128
+MAX_MORPH_REGIONS = 128
+MAX_FACIAL_BONE_MORPHS = 128
+MAX_TINTS = 128
+
+
+def _is_int(value: Any, minimum: int = 0, maximum: int = 0xFFFFFFFF) -> bool:
+    return isinstance(value, int) and not isinstance(value, bool) and minimum <= value <= maximum
+
+
+def _is_finite_number(value: Any, minimum: float, maximum: float) -> bool:
+    return (
+        isinstance(value, (int, float))
+        and not isinstance(value, bool)
+        and math.isfinite(float(value))
+        and minimum <= float(value) <= maximum
+    )
+
+
+def _normalize_form_id(value: Any, *, allow_empty: bool = True) -> str | None:
+    if not isinstance(value, str):
+        return None
+    if allow_empty and value == "":
+        return ""
+    if not 1 <= len(value) <= 8:
+        return None
+    if any(character not in "0123456789abcdefABCDEF" for character in value):
+        return None
+    return value.upper().zfill(8)
+
+
+def _normalize_vec3(value: Any, minimum: float, maximum: float) -> list[float] | None:
+    if not isinstance(value, list) or len(value) != 3:
+        return None
+    if not all(_is_finite_number(component, minimum, maximum) for component in value):
+        return None
+    return [float(component) for component in value]
+
+
+def _normalize_appearance(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+
+    clean: dict[str, Any] = {}
+    version = value.get("version", 4)
+    if not _is_int(version, 1, 1000):
+        return None
+    clean["version"] = int(version)
+
+    for name in ("raceFormId", "hairColorFormId", "facialHairColorFormId", "complexionFormId"):
+        if name in value:
+            form_id = _normalize_form_id(value[name])
+            if form_id is None:
+                return None
+            clean[name] = form_id
+
+    if "height" in value:
+        if not _is_finite_number(value["height"], 0.25, 4.0):
+            return None
+        clean["height"] = float(value["height"])
+
+    if "isFemale" in value:
+        if not isinstance(value["isFemale"], bool):
+            return None
+        clean["isFemale"] = value["isFemale"]
+
+    if "morphWeight" in value:
+        weight = value["morphWeight"]
+        if not isinstance(weight, dict):
+            return None
+        clean_weight: dict[str, float] = {}
+        for name in ("thin", "muscular", "large"):
+            if not _is_finite_number(weight.get(name), -100.0, 100.0):
+                return None
+            clean_weight[name] = float(weight[name])
+        clean["morphWeight"] = clean_weight
+
+    if "bodyTintColor" in value:
+        color = value["bodyTintColor"]
+        if not isinstance(color, dict):
+            return None
+        clean_color: dict[str, int] = {}
+        for name in ("r", "g", "b", "a"):
+            if not _is_int(color.get(name), 0, 255):
+                return None
+            clean_color[name] = int(color[name])
+        clean["bodyTintColor"] = clean_color
+
+    if "headParts" in value:
+        head_parts = value["headParts"]
+        if not isinstance(head_parts, list) or len(head_parts) > MAX_HEAD_PARTS:
+            return None
+        clean_head_parts: list[str] = []
+        for form_id in head_parts:
+            normalized = _normalize_form_id(form_id, allow_empty=False)
+            if normalized is None:
+                return None
+            clean_head_parts.append(normalized)
+        clean["headParts"] = clean_head_parts
+
+    if "morphs" in value:
+        morphs = value["morphs"]
+        if not isinstance(morphs, list) or len(morphs) > MAX_MORPHS:
+            return None
+        clean_morphs: list[dict[str, Any]] = []
+        for morph in morphs:
+            if not isinstance(morph, dict):
+                return None
+            morph_id = _normalize_form_id(morph.get("id"), allow_empty=False)
+            if morph_id is None or not _is_finite_number(morph.get("value"), -1000.0, 1000.0):
+                return None
+            clean_morphs.append({"id": morph_id, "value": float(morph["value"])})
+        clean["morphs"] = clean_morphs
+
+    if "morphRegions" in value:
+        regions = value["morphRegions"]
+        if not isinstance(regions, list) or len(regions) > MAX_MORPH_REGIONS:
+            return None
+        if not all(_is_finite_number(region, -1000.0, 1000.0) for region in regions):
+            return None
+        clean["morphRegions"] = [float(region) for region in regions]
+
+    if "facialBoneMorphs" in value:
+        morphs = value["facialBoneMorphs"]
+        if not isinstance(morphs, list) or len(morphs) > MAX_FACIAL_BONE_MORPHS:
+            return None
+        clean_bones: list[dict[str, Any]] = []
+        for morph in morphs:
+            if not isinstance(morph, dict):
+                return None
+            morph_id = _normalize_form_id(morph.get("id"), allow_empty=False)
+            position = _normalize_vec3(morph.get("position"), -10000.0, 10000.0)
+            rotation = _normalize_vec3(morph.get("rotation"), -10000.0, 10000.0)
+            scale = _normalize_vec3(morph.get("scale"), -100.0, 100.0)
+            if morph_id is None or position is None or rotation is None or scale is None:
+                return None
+            clean_bones.append(
+                {
+                    "id": morph_id,
+                    "position": position,
+                    "rotation": rotation,
+                    "scale": scale,
+                }
+            )
+        clean["facialBoneMorphs"] = clean_bones
+
+    if "tints" in value:
+        tints = value["tints"]
+        if not isinstance(tints, list) or len(tints) > MAX_TINTS:
+            return None
+        clean_tints: list[dict[str, Any]] = []
+        for tint in tints:
+            if not isinstance(tint, dict):
+                return None
+            if not _is_int(tint.get("id"), 0, 0xFFFF):
+                return None
+            if not _is_int(tint.get("type"), 0, 0xFFFFFFFF):
+                return None
+            if not _is_int(tint.get("value"), 0, 255):
+                return None
+            clean_tint: dict[str, Any] = {
+                "id": int(tint["id"]),
+                "type": int(tint["type"]),
+                "value": int(tint["value"]),
+            }
+            if "color" in tint:
+                color = _normalize_form_id(tint["color"], allow_empty=False)
+                if color is None or not _is_int(tint.get("swatch", 0), 0, 0xFFFF):
+                    return None
+                clean_tint["color"] = color
+                clean_tint["swatch"] = int(tint.get("swatch", 0))
+            clean_tints.append(clean_tint)
+        clean["tints"] = clean_tints
+
+    return clean
+
+
+def normalize_player_state_packet(
+    packet: dict[str, Any],
+    normalize_action_events: Callable[[Any], list[dict[str, Any]]],
+) -> dict[str, Any] | None:
+    clean: dict[str, Any] = {"type": "playerState"}
+    has_state = False
+
+    if "equippedItems" in packet:
+        items = packet["equippedItems"]
+        if not isinstance(items, list) or len(items) > MAX_EQUIPPED_ITEMS:
+            return None
+        clean_items: list[dict[str, str]] = []
+        for item in items:
+            if not isinstance(item, dict):
+                return None
+            slot = item.get("slot")
+            if not isinstance(slot, str) or not 1 <= len(slot) <= MAX_EQUIPMENT_SLOT_CHARS:
+                return None
+            form_id = _normalize_form_id(item.get("formId", ""))
+            if form_id is None:
+                return None
+            clean_items.append({"slot": slot, "formId": form_id})
+        clean["equippedItems"] = clean_items
+        has_state = True
+
+    if "appearance" in packet:
+        appearance = _normalize_appearance(packet["appearance"])
+        if appearance is None:
+            return None
+        clean["appearance"] = appearance
+        has_state = True
+
+    if "actionEvents" in packet:
+        action_events = packet["actionEvents"]
+        if not isinstance(action_events, list):
+            return None
+        normalized_actions = normalize_action_events(action_events)
+        if len(normalized_actions) != len(action_events):
+            return None
+        clean["actionEvents"] = normalized_actions
+        has_state = True
+
+    if "characterName" in packet:
+        name = packet["characterName"]
+        if not isinstance(name, str) or len(name) > MAX_CHARACTER_NAME_CHARS:
+            return None
+        clean["characterName"] = name
+        has_state = True
+
+    return clean if has_state else None