Use UUID-based scene object IDs [SYNTH-309] (#1463)

Co-authored-by: Zach Rutman <92497727+rutmanz@users.noreply.github.com>

Author: BrandonPacewic

fission/src/mirabuf/MirabufLoader.ts

@@ -8,7 +8,7 @@ import InitialConfigPanel from "@/panels/configuring/initial-config/InitialConfi
 import { PAUSE_REF_ASSEMBLY_SPAWNING } from "@/systems/physics/PhysicsTypes.ts"
 import { createMirabuf } from "@/mirabuf/MirabufSceneObject.ts"
 import { getTargetControls } from "@/systems/scene/CameraControls.ts"
-import type { EncodedAssembly, LocalSceneObjectId, Message, RemoteSceneObjectId } from "@/systems/multiplayer/types.ts"
+import type { EncodedAssembly, Message } from "@/systems/multiplayer/types.ts"
 import { ProgressHandle } from "@/components/ProgressNotificationData.ts"
 
 const MIRABUF_LOCALSTORAGE_GENERATION_KEY = "Synthesis Nonce Key"
@@ -496,7 +496,7 @@ export async function spawnCachedMira(
                         type: "newObject",
                         timestamp: Date.now(),
                         data: {
-                            sceneObjectKey: mirabufSceneObject.id as RemoteSceneObjectId,
+                            sceneObjectKey: mirabufSceneObject.id,
                             assembly: encodedAssembly,
                             assemblyHash: info.hash,
                             miraType: info.miraType,
@@ -505,7 +505,7 @@ export async function spawnCachedMira(
                         },
                     }
                     await World.multiplayerSystem?.broadcast(message)
-                    World.multiplayerSystem?.registerOwnSceneObject(mirabufSceneObject.id as LocalSceneObjectId)
+                    World.multiplayerSystem?.registerOwnSceneObject(mirabufSceneObject.id)
                 }
 
                 if (targetControls && (info.miraType === MiraType.ROBOT || !targetControls.focusProvider)) {

fission/src/mirabuf/MirabufSceneObject.ts

@@ -1,13 +1,7 @@
 import type Jolt from "@synthesis.adsk/jolt-physics"
 import * as THREE from "three"
 import type { mirabuf } from "@/proto/mirabuf"
-import type {
-    FieldConfiguration,
-    LocalSceneObjectId,
-    RemoteSceneObjectId,
-    RobotConfiguration,
-    UpdateObjectData,
-} from "@/systems/multiplayer/types"
+import type { FieldConfiguration, RobotConfiguration, UpdateObjectData } from "@/systems/multiplayer/types"
 import { BodyAssociate } from "@/systems/physics/BodyAssociate.ts"
 import EventSystem from "@/systems/EventSystem.ts"
 import type Mechanism from "@/systems/physics/Mechanism"
@@ -65,6 +59,7 @@ import ProtectedZoneSceneObject from "./ProtectedZoneSceneObject"
 import ScoringZoneSceneObject from "./ScoringZoneSceneObject"
 import { v4 as uuidV4 } from "uuid"
 import { copyVec3, hexStringToUint8Array, yieldToMain } from "@/util/Utility.ts"
+import type { SceneObjectId } from "@/systems/scene/SceneRenderer.ts"
 
 const DEBUG_BODIES = false
 
@@ -79,15 +74,17 @@ interface RnDebugMeshes {
  * last spawned in, however, systems (such as the configuration UI) can elect
  * assemblies to be in the spotlight when moving from interface to interface.
  */
-let spotlightAssembly: number | undefined
+let spotlightAssembly: SceneObjectId | undefined
 
 export function setSpotlightAssembly(assembly: MirabufSceneObject) {
     spotlightAssembly = assembly.id
 }
 
 // TODO: If nothing is in the spotlight, select last entry before defaulting to undefined
 export function getSpotlightAssembly(): MirabufSceneObject | undefined {
-    return World.sceneRenderer.sceneObjects.get(spotlightAssembly ?? 0) as MirabufSceneObject
+    return spotlightAssembly != null
+        ? (World.sceneRenderer.sceneObjects.get(spotlightAssembly) as MirabufSceneObject)
+        : undefined
 }
 
 type MinMax = { min: number; max: number }
@@ -708,7 +705,7 @@ class MirabufSceneObject extends SceneObject implements ContextSupplier {
     }
 
     private removeSceneObjects(objs: SceneObject[]) {
-        objs.filter(obj => obj.id != -1).forEach(obj => World.sceneRenderer.removeSceneObject(obj.id))
+        objs.forEach(obj => World.sceneRenderer.removeSceneObject(obj.id))
         objs.length = 0
     }
 
@@ -720,7 +717,6 @@ class MirabufSceneObject extends SceneObject implements ContextSupplier {
         if (zoneObject == null) return
 
         World.sceneRenderer.removeSceneObject(zoneObject.id)
-        zoneObject.id = -1
     }
 
     public removeProtectedZoneObject(zone: ProtectedZonePreferences) {
@@ -731,7 +727,6 @@ class MirabufSceneObject extends SceneObject implements ContextSupplier {
         if (zoneObject == null) return
 
         World.sceneRenderer.removeSceneObject(zoneObject.id)
-        zoneObject.id = -1
     }
 
     /**
@@ -1023,7 +1018,7 @@ class MirabufSceneObject extends SceneObject implements ContextSupplier {
         await World.multiplayerSystem.broadcast({
             type: "configureObject",
             data: {
-                sceneObjectKey: this.id as RemoteSceneObjectId,
+                sceneObjectKey: this.id,
                 objectConfigurationData: data,
             },
         })
@@ -1135,8 +1130,8 @@ class MirabufSceneObject extends SceneObject implements ContextSupplier {
     }
 
     public enablePhysics() {
-        if (World.multiplayerSystem?.getOwnSceneObjectIDs().includes(this.id as LocalSceneObjectId)) {
-            World.multiplayerSystem.broadcast({ type: "enableObjectPhysics", data: this.id as RemoteSceneObjectId })
+        if (World.multiplayerSystem?.getOwnSceneObjectIDs().includes(this.id)) {
+            World.multiplayerSystem.broadcast({ type: "enableObjectPhysics", data: this.id })
         }
 
         this.mirabufInstance.parser.rigidNodes.forEach(rn => {
@@ -1146,8 +1141,8 @@ class MirabufSceneObject extends SceneObject implements ContextSupplier {
     }
 
     public disablePhysics() {
-        if (World.multiplayerSystem?.getOwnSceneObjectIDs().includes(this.id as LocalSceneObjectId)) {
-            World.multiplayerSystem.broadcast({ type: "disableObjectPhysics", data: this.id as RemoteSceneObjectId })
+        if (World.multiplayerSystem?.getOwnSceneObjectIDs().includes(this.id)) {
+            World.multiplayerSystem.broadcast({ type: "disableObjectPhysics", data: this.id })
         }
 
         this.mirabufInstance.parser.rigidNodes.forEach(rn => {
@@ -1333,7 +1328,7 @@ class MirabufSceneObject extends SceneObject implements ContextSupplier {
             .filter(n => n != null)
 
         return {
-            sceneObjectKey: this.id as RemoteSceneObjectId,
+            sceneObjectKey: this.id,
             gamePiecesControlled,
             bodies,
         }

fission/src/systems/EventSystem.ts

@@ -8,6 +8,7 @@ import type { CurrentContactData, OnContactValidateData } from "@/systems/physic
 import type TaskStatus from "@/util/TaskStatus.ts"
 import type MirabufSceneObject from "@/mirabuf/MirabufSceneObject.ts"
 import type { CameraPoint } from "@/systems/preferences/PreferenceTypes.ts"
+import type { SceneObjectId } from "@/systems/scene/SceneRenderer.ts"
 
 interface EventDataMap {
     // Mirabuf
@@ -53,7 +54,7 @@ interface EventDataMap {
     CameraModeChangedEvent: { mode: string }
     CameraFocusChangedEvent: { focusProvider: MirabufSceneObject | undefined }
     // Field View: the active camera point changed (the selected point, or undefined when none).
-    CameraViewChangedEvent: { point: CameraPoint | undefined; focusedRobotId?: number }
+    CameraViewChangedEvent: { point: CameraPoint | undefined; focusedRobotId?: SceneObjectId }
     // The active camera control scheme changed (e.g. "Target" or "FieldView").
     CameraControlsTypeChangedEvent: { controlsType: string }
 

fission/src/systems/match_mode/RobotDimensionTracker.ts

@@ -1,16 +1,17 @@
 import World from "@/systems/World"
 import MatchMode from "./MatchMode"
+import type { SceneObjectId } from "@/systems/scene/SceneRenderer.ts"
 
 const BUFFER_HEIGHT = 0.1
 const SIDE_BUFFER = 0.1
 
 class RobotDimensionTracker {
-    private static _robotLastFramePenalty: Map<number, boolean> = new Map()
+    private static _robotLastFramePenalty: Map<SceneObjectId, boolean> = new Map()
     private static _ignoreRotation: boolean = true
     private static _maxHeight: number = Infinity
     private static _heightLimitPenalty: number = 0
     private static _sideExtensionPenalty: number = 0
-    private static _robotSize: Map<number, { width: number; depth: number }> = new Map()
+    private static _robotSize: Map<SceneObjectId, { width: number; depth: number }> = new Map()
     private static _sideMaxExtension: number = 0
 
     public static setConfigValues(

fission/src/systems/multiplayer/MessageHandlers.ts

@@ -11,15 +11,14 @@ import type {
     ClientInfo,
     EncodedAssembly,
     InitObjectData,
-    LocalSceneObjectId,
     MatchModePenalty,
     MatchModeStateData,
     MessageType,
     ObjectPreferences,
-    RemoteSceneObjectId,
     UpdateObjectData,
 } from "./types"
 import EventSystem from "@/systems/EventSystem.ts"
+import type { SceneObjectId } from "@/systems/scene/SceneRenderer.ts"
 
 export const peerMessageHandlers = {
     info: handlePeerInfo,
@@ -44,7 +43,7 @@ export const peerMessageHandlers = {
 }
 
 const pendingOperations: (() => void)[] = []
-const progressHandles: Map<number, ProgressHandle> = new Map()
+const progressHandles: Map<SceneObjectId, ProgressHandle> = new Map()
 
 async function handleMatchModeState(data: MatchModeStateData) {
     console.log(data)
@@ -78,9 +77,7 @@ function handlePeerUpdate(data: UpdateObjectData[], peerId: string, timestamp: n
     clientToUpdateMap.set(peerId, timestamp)
 
     data.forEach(({ sceneObjectKey, gamePiecesControlled, bodies }) => {
-        const sceneObject = World.sceneRenderer.sceneObjects.get(
-            World.multiplayerSystem!.convertSceneObjectId(peerId, sceneObjectKey)
-        )
+        const sceneObject = World.sceneRenderer.sceneObjects.get(sceneObjectKey)
         if (sceneObject == null) {
             console.warn(
                 `Multiplayer SceneObject: ${sceneObjectKey} not found in sceneObjects map. Multiplayer SceneObjects must be initialized before being updated.`
@@ -201,13 +198,9 @@ async function handleNewObject(data: InitObjectData, peerId: string) {
     object.nameOverride = clientToInfoMap.get(peerId)?.displayName ?? peerId
 
     console.log("Registering object", object, data)
-    const localSceneObjectKey = World.sceneRenderer.registerSceneObject(object)
-    console.log("linking object", data.sceneObjectKey, "->", localSceneObjectKey)
-
-    World.multiplayerSystem?.setSceneObjectIdMapping(peerId, data.sceneObjectKey, localSceneObjectKey)
+    World.sceneRenderer.registerSceneObject(object)
 
-    clientToObjectMap.get(peerId)?.push(object.id as LocalSceneObjectId) ||
-        clientToObjectMap.set(peerId, [object.id as LocalSceneObjectId])
+    clientToObjectMap.get(peerId)?.push(object.id) || clientToObjectMap.set(peerId, [object.id])
 
     // Sets bodyMap
     const clientBodyIds = object.getAllBodyIds()
@@ -250,31 +243,28 @@ async function handleAssemblyRequest(data: AssemblyRequestData, peerId: string)
     })
 }
 
-function handleDeleteObject(sceneObjectKey: RemoteSceneObjectId, peerId: string) {
+function handleDeleteObject(sceneObjectKey: SceneObjectId, peerId: string) {
     if (!World.multiplayerSystem) return
     const clientToObjectMap = World.multiplayerSystem._clientToObjectMap
-    const localKey = World.multiplayerSystem!.convertSceneObjectId(peerId, sceneObjectKey)
 
-    const peerClient = [...clientToObjectMap.entries()].find(([_id, keys]) => keys.includes(localKey))
+    const peerClient = [...clientToObjectMap.entries()].find(([_id, keys]) => keys.includes(sceneObjectKey))
     if (peerClient != null) {
         const keys = clientToObjectMap.get(peerClient[0])
-        const index = keys?.indexOf(World.multiplayerSystem.convertSceneObjectId(peerId, sceneObjectKey)) ?? -1
+        const index = keys?.indexOf(sceneObjectKey) ?? -1
         if (index != -1) {
             keys?.splice(index)
         }
     }
 
-    if (!World.sceneRenderer.sceneObjects.has(localKey)) {
+    if (!World.sceneRenderer.sceneObjects.has(sceneObjectKey)) {
         pendingOperations.push(() => handleDeleteObject(sceneObjectKey, peerId))
     }
 
-    World.sceneRenderer.removeSceneObject(localKey)
+    World.sceneRenderer.removeSceneObject(sceneObjectKey)
 }
 
 function handleObjectConfiguration(data: ObjectPreferences, peerId: string) {
-    const sceneObject = World.sceneRenderer.sceneObjects.get(
-        World.multiplayerSystem!.convertSceneObjectId(peerId, data.sceneObjectKey)
-    )
+    const sceneObject = World.sceneRenderer.sceneObjects.get(data.sceneObjectKey)
     if (sceneObject instanceof MirabufSceneObject) {
         if (sceneObject.isOwnObject) {
             console.warn("received config for own object")
@@ -287,10 +277,8 @@ function handleObjectConfiguration(data: ObjectPreferences, peerId: string) {
     }
 }
 
-function disableObjectPhysics(sceneObjectKey: RemoteSceneObjectId, peerId: string) {
-    const sceneObject = World.sceneRenderer.sceneObjects.get(
-        World.multiplayerSystem!.convertSceneObjectId(peerId, sceneObjectKey)
-    )
+function disableObjectPhysics(sceneObjectKey: SceneObjectId, peerId: string) {
+    const sceneObject = World.sceneRenderer.sceneObjects.get(sceneObjectKey)
     if (sceneObject instanceof MirabufSceneObject) {
         if (sceneObject.isOwnObject) {
             console.warn("received disable for own object")
@@ -302,10 +290,8 @@ function disableObjectPhysics(sceneObjectKey: RemoteSceneObjectId, peerId: strin
     }
 }
 
-function enableObjectPhysics(sceneObjectKey: RemoteSceneObjectId, peerId: string) {
-    const sceneObject = World.sceneRenderer.sceneObjects.get(
-        World.multiplayerSystem!.convertSceneObjectId(peerId, sceneObjectKey)
-    )
+function enableObjectPhysics(sceneObjectKey: SceneObjectId, peerId: string) {
+    const sceneObject = World.sceneRenderer.sceneObjects.get(sceneObjectKey)
     if (sceneObject instanceof MirabufSceneObject) {
         if (sceneObject.isOwnObject) {
             console.warn("received enablephysics for own object")
@@ -318,9 +304,7 @@ function enableObjectPhysics(sceneObjectKey: RemoteSceneObjectId, peerId: string
 }
 
 function handleMatchModePenalty(data: MatchModePenalty, peerId: string) {
-    const obj = World.sceneRenderer.sceneObjects.get(
-        World.multiplayerSystem!.convertSceneObjectId(peerId, data.objectId)
-    )
+    const obj = World.sceneRenderer.sceneObjects.get(data.objectId)
     if (!(obj instanceof MirabufSceneObject)) {
         console.warn("can't handle penalty for object", data.objectId, obj)
         pendingOperations.push(() => handleMatchModePenalty(data, peerId))

fission/src/systems/multiplayer/MultiplayerSystem.ts

@@ -7,9 +7,10 @@ import { mirabuf } from "@/proto/mirabuf"
 import PreferencesSystem from "@/systems/preferences/PreferencesSystem.ts"
 import World from "../World"
 import { peerMessageHandlers } from "./MessageHandlers"
-import type { ClientInfo, LocalSceneObjectId, Message, MessageWithTimestamp, RemoteSceneObjectId } from "./types"
+import type { ClientInfo, Message, MessageWithTimestamp } from "./types"
 import { hashBuffer } from "@/util/Utility"
 import EventSystem from "@/systems/EventSystem.ts"
+import type { SceneObjectId } from "@/systems/scene/SceneRenderer.ts"
 
 export const COLLISION_TIMEOUT = 500
 
@@ -22,9 +23,8 @@ class MultiplayerSystem {
 
     public readonly _clientToInfoMap: Map<string, ClientInfo> = new Map()
 
-    public readonly _clientToObjectMap: Map<string, LocalSceneObjectId[]> = new Map()
+    public readonly _clientToObjectMap: Map<string, SceneObjectId[]> = new Map()
     public readonly _clientToBodyMap: Map<string, Map<number, Jolt.BodyID>> = new Map() // Each Map is: peerBodyId -> clientBodyId
-    public readonly _clientToSceneObjectIdMap: Map<string, Map<RemoteSceneObjectId, LocalSceneObjectId>> = new Map() // Each Map is: peerObjectId -> clientObjectId
 
     readonly info: ClientInfo
     private _onDestroyHooks: (() => void)[] = []
@@ -169,7 +169,7 @@ class MultiplayerSystem {
                 await this.send(conn.peer, {
                     type: "newObject",
                     data: {
-                        sceneObjectKey: obj.id as RemoteSceneObjectId,
+                        sceneObjectKey: obj.id,
                         assemblyHash: await hashBuffer(
                             mirabuf.Assembly.encode(obj.mirabufInstance.parser.assembly).finish().buffer as ArrayBuffer
                         ),
@@ -190,13 +190,12 @@ class MultiplayerSystem {
                 this.handlePeerMessage(
                     {
                         type: "deleteObject",
-                        data: this.convertSceneObjectIdReverse(conn.peer, obj)!,
+                        data: obj!,
                         timestamp: Date.now(),
                     },
                     conn.peer
                 ).catch(console.error) // TODO Get actual sceneObjectKey
             })
-            this._clientToSceneObjectIdMap.delete(conn.peer)
 
             this._connections.delete(conn.peer)
             // TODO: handle host transition
@@ -260,16 +259,15 @@ class MultiplayerSystem {
             .filter(obj => obj instanceof MirabufSceneObject)
     }
 
-    registerOwnSceneObject(objectId: LocalSceneObjectId) {
+    registerOwnSceneObject(objectId: SceneObjectId) {
         const list = this._clientToObjectMap.get(this.clientId)
-        this.setSceneObjectIdMapping(this.clientId, objectId as RemoteSceneObjectId, objectId)
         if (list != null) {
             list.push(objectId)
         } else {
             this._clientToObjectMap.set(this.clientId, [objectId])
         }
     }
-    unregisterOwnSceneObject(objectId: LocalSceneObjectId) {
+    unregisterOwnSceneObject(objectId: SceneObjectId) {
         const list = this._clientToObjectMap.get(this.clientId)
         if (!list) return
         const index = list.indexOf(objectId)
@@ -305,29 +303,11 @@ class MultiplayerSystem {
         this._connections.forEach(conn => conn.close())
         this._connections.clear()
         this.client.destroy()
-        this._clientToSceneObjectIdMap.clear()
         this._onDestroyHooks.forEach(hook => {
             hook()
         })
         World.setMultiplayerSystem(undefined)
     }
-
-    public convertSceneObjectId(peerId: string, objectId: RemoteSceneObjectId): LocalSceneObjectId {
-        return this._clientToSceneObjectIdMap.get(peerId)?.get(objectId) ?? (-1 as LocalSceneObjectId)
-    }
-
-    public convertSceneObjectIdReverse(peerId: string, objectId: LocalSceneObjectId): RemoteSceneObjectId | undefined {
-        return [...this._clientToSceneObjectIdMap.get(peerId)!.entries()].find(([_, l]) => objectId == l)?.[0]
-    }
-
-    public setSceneObjectIdMapping(peerId: string, remoteId: RemoteSceneObjectId, localId: LocalSceneObjectId) {
-        let peerMap = World.multiplayerSystem?._clientToSceneObjectIdMap.get(peerId)
-        if (peerMap == null) {
-            peerMap = new Map()
-            World.multiplayerSystem?._clientToSceneObjectIdMap.set(peerId, peerMap)
-        }
-        peerMap.set(remoteId, localId)
-    }
 }
 
 async function generateId(roomId: string, forceRegen: boolean = false): Promise<string> {