@hellpig/anarchy-engine 21.3.1 → 22.0.0

package/dist/Space/Utils/CreateLoopsUtils.js

@@ -0,0 +1,2 @@
+import{LOOPS_DEFAULT_SETTINGS}from"../../Loop/Constants/LoopsDefaultSettings.js";import{milliseconds}from"../../Measurements/Utils/MeasurementsUtils.js";import{LoopType}from"../../Loop/Constants/LoopType.js";import{getMainLoopNameByType}from"../../Loop/Utils/LoopUtils.js";import{LoopUpdatePriority}from"../../Loop/Constants/LoopUpdatePriority.js";function createLoops({create:create},spaceSettings={}){const{Audio:Audio,Render:Render,Intersections:Intersections,Spatial:Spatial,Mouse:Mouse,Text:Text,Kinematic:Kinematic,Collisions:Collisions,Controls:Controls,Transform:Transform,Physics:Physics}=LoopType,settings={...LOOPS_DEFAULT_SETTINGS,...spaceSettings.loopsSettings},{audioLoopStep:audioLoopStep,physicsLoopStep:physicsLoopStep,collisionsLoopStep:collisionsLoopStep,kinematicLoopStep:kinematicLoopStep,spatialLoopStep:spatialLoopStep,transformLoopStep:transformLoopStep,textLoopStep:textLoopStep,mouseLoopStep:mouseLoopStep,intersectionsLoopStep:intersectionsLoopStep,controlsLoopStep:controlsLoopStep,isAudioParallel:isAudioParallel,isPhysicsParallel:isPhysicsParallel,isCollisionsParallel:isCollisionsParallel,isKinematicParallel:isKinematicParallel,isSpatialParallel:isSpatialParallel,isTransformParallel:isTransformParallel,isTextParallel:isTextParallel,isMouseParallel:isMouseParallel,isIntersectionsParallel:isIntersectionsParallel,isControlsParallel:isControlsParallel}=settings;return{renderLoop:create({name:getMainLoopNameByType(Render),type:Render,trigger:requestAnimationFrame}),audioLoop:create({name:getMainLoopNameByType(Audio),type:Audio,trigger:milliseconds(audioLoopStep),isParallelMode:isAudioParallel,maxPriority:LoopUpdatePriority.ASAP}),physicsLoop:create({name:getMainLoopNameByType(Physics),type:Physics,trigger:milliseconds(physicsLoopStep),isParallelMode:isPhysicsParallel}),collisionsLoop:create({name:getMainLoopNameByType(Collisions),type:Collisions,trigger:milliseconds(collisionsLoopStep),isParallelMode:isCollisionsParallel,maxPriority:LoopUpdatePriority.ASAP}),kinematicLoop:create({name:getMainLoopNameByType(Kinematic),type:Kinematic,trigger:milliseconds(kinematicLoopStep),isParallelMode:isKinematicParallel}),spatialLoop:create({name:getMainLoopNameByType(Spatial),type:Spatial,trigger:milliseconds(spatialLoopStep),isParallelMode:isSpatialParallel,maxPriority:LoopUpdatePriority.ASAP}),transformLoop:create({name:getMainLoopNameByType(Transform),type:Transform,trigger:milliseconds(transformLoopStep),isParallelMode:isTransformParallel}),textLoop:create({name:getMainLoopNameByType(Text),type:Text,trigger:milliseconds(textLoopStep),isParallelMode:isTextParallel}),mouseLoop:create({name:getMainLoopNameByType(Mouse),type:Mouse,trigger:milliseconds(mouseLoopStep),isParallelMode:isMouseParallel}),intersectionsLoop:create({name:getMainLoopNameByType(Intersections),type:Intersections,trigger:milliseconds(intersectionsLoopStep),isParallelMode:isIntersectionsParallel}),controlsLoop:create({name:getMainLoopNameByType(Controls),type:Controls,trigger:milliseconds(controlsLoopStep),isParallelMode:isControlsParallel})}}export{createLoops};
+//# sourceMappingURL=CreateLoopsUtils.js.map

package/dist/Space/Utils/CreateLoopsUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateLoopsUtils.js","sources":["../../../src/Space/Utils/CreateLoopsUtils.ts"],"sourcesContent":["import type { TAudioLoop } from '@Anarchy/Engine/Audio';\nimport type { TCollisionsLoop } from '@Anarchy/Engine/Collisions';\nimport type { TControlsLoop } from '@Anarchy/Engine/Controls';\nimport type { TIntersectionsLoop } from '@Anarchy/Engine/Intersections';\nimport type { TKinematicLoop } from '@Anarchy/Engine/Kinematic';\nimport type { TLoopService, TLoopsSettings } from '@Anarchy/Engine/Loop';\nimport { getMainLoopNameByType, LOOPS_DEFAULT_SETTINGS, LoopType, LoopUpdatePriority } from '@Anarchy/Engine/Loop';\nimport { milliseconds } from '@Anarchy/Engine/Measurements';\nimport type { TMouseLoop } from '@Anarchy/Engine/Mouse';\nimport type { TPhysicsLoop } from '@Anarchy/Engine/Physics';\nimport type { TRenderLoop, TSpaceLoops, TSpaceSettings } from '@Anarchy/Engine/Space/Models';\nimport type { TSpatialLoop } from '@Anarchy/Engine/Spatial';\nimport type { TTextLoop } from '@Anarchy/Engine/Text';\nimport type { TTransformLoop } from '@Anarchy/Engine/TransformDrive';\n\nexport function createLoops({ create }: TLoopService, spaceSettings: TSpaceSettings = {}): TSpaceLoops {\n  const { Audio, Render, Intersections, Spatial, Mouse, Text, Kinematic, Collisions, Controls, Transform, Physics } = LoopType;\n\n  const settings: TLoopsSettings = { ...LOOPS_DEFAULT_SETTINGS, ...spaceSettings.loopsSettings };\n\n  const {\n    audioLoopStep,\n    physicsLoopStep,\n    collisionsLoopStep,\n    kinematicLoopStep,\n    spatialLoopStep,\n    transformLoopStep,\n    textLoopStep,\n    mouseLoopStep,\n    intersectionsLoopStep,\n    controlsLoopStep,\n    isAudioParallel,\n    isPhysicsParallel,\n    isCollisionsParallel,\n    isKinematicParallel,\n    isSpatialParallel,\n    isTransformParallel,\n    isTextParallel,\n    isMouseParallel,\n    isIntersectionsParallel,\n    isControlsParallel\n  } = settings;\n\n  // You could use testTickRate() to test the tick rate of the loop in the main stream and in \"parallel mode\" (in the worker),\n  // cause usually loops in workers fires a way faster due to the fact that the worker is not blocked by the main thread (rendering and etc)\n  // TL;DR: If you use parallel mode, set the \"trigger\" time higher.\n  return {\n    renderLoop: create({ name: getMainLoopNameByType(Render), type: Render, trigger: requestAnimationFrame }) as TRenderLoop,\n\n    audioLoop: create({\n      name: getMainLoopNameByType(Audio),\n      type: Audio,\n      trigger: milliseconds(audioLoopStep),\n      isParallelMode: isAudioParallel,\n      maxPriority: LoopUpdatePriority.ASAP\n    }) as TAudioLoop,\n\n    physicsLoop: create({\n      name: getMainLoopNameByType(Physics),\n      type: Physics,\n      trigger: milliseconds(physicsLoopStep),\n      isParallelMode: isPhysicsParallel\n    }) as TPhysicsLoop,\n\n    collisionsLoop: create({\n      name: getMainLoopNameByType(Collisions),\n      type: Collisions,\n      trigger: milliseconds(collisionsLoopStep),\n      isParallelMode: isCollisionsParallel,\n      maxPriority: LoopUpdatePriority.ASAP\n    }) as TCollisionsLoop,\n\n    kinematicLoop: create({\n      name: getMainLoopNameByType(Kinematic),\n      type: Kinematic,\n      trigger: milliseconds(kinematicLoopStep),\n      isParallelMode: isKinematicParallel\n    }) as TKinematicLoop,\n\n    spatialLoop: create({\n      name: getMainLoopNameByType(Spatial),\n      type: Spatial,\n      trigger: milliseconds(spatialLoopStep),\n      isParallelMode: isSpatialParallel,\n      maxPriority: LoopUpdatePriority.ASAP\n    }) as TSpatialLoop,\n\n    transformLoop: create({\n      name: getMainLoopNameByType(Transform),\n      type: Transform,\n      trigger: milliseconds(transformLoopStep),\n      isParallelMode: isTransformParallel\n    }) as TTransformLoop,\n\n    textLoop: create({\n      name: getMainLoopNameByType(Text),\n      type: Text,\n      trigger: milliseconds(textLoopStep),\n      isParallelMode: isTextParallel\n    }) as TTextLoop,\n\n    mouseLoop: create({\n      name: getMainLoopNameByType(Mouse),\n      type: Mouse,\n      trigger: milliseconds(mouseLoopStep),\n      isParallelMode: isMouseParallel\n    }) as TMouseLoop,\n\n    intersectionsLoop: create({\n      name: getMainLoopNameByType(Intersections),\n      type: Intersections,\n      trigger: milliseconds(intersectionsLoopStep),\n      isParallelMode: isIntersectionsParallel\n    }) as TIntersectionsLoop,\n\n    controlsLoop: create({\n      name: getMainLoopNameByType(Controls),\n      type: Controls,\n      trigger: milliseconds(controlsLoopStep),\n      isParallelMode: isControlsParallel\n    }) as TControlsLoop\n  };\n}\n"],"names":["createLoops","create","spaceSettings","Audio","Render","Intersections","Spatial","Mouse","Text","Kinematic","Collisions","Controls","Transform","Physics","LoopType","settings","LOOPS_DEFAULT_SETTINGS","loopsSettings","audioLoopStep","physicsLoopStep","collisionsLoopStep","kinematicLoopStep","spatialLoopStep","transformLoopStep","textLoopStep","mouseLoopStep","intersectionsLoopStep","controlsLoopStep","isAudioParallel","isPhysicsParallel","isCollisionsParallel","isKinematicParallel","isSpatialParallel","isTransformParallel","isTextParallel","isMouseParallel","isIntersectionsParallel","isControlsParallel","renderLoop","name","getMainLoopNameByType","type","trigger","requestAnimationFrame","audioLoop","milliseconds","isParallelMode","maxPriority","LoopUpdatePriority","ASAP","physicsLoop","collisionsLoop","kinematicLoop","spatialLoop","transformLoop","textLoop","mouseLoop","intersectionsLoop","controlsLoop"],"mappings":"4VAeO,SAASA,aAAYC,OAAEA,QAAwBC,cAAgC,CAAA,GACpF,MAAMC,MAAEA,MAAAC,OAAOA,OAAAC,cAAQA,cAAAC,QAAeA,QAAAC,MAASA,MAAAC,KAAOA,KAAAC,UAAMA,UAAAC,WAAWA,WAAAC,SAAYA,SAAAC,UAAUA,UAAAC,QAAWA,SAAYC,SAE9GC,SAA2B,IAAKC,0BAA2Bd,cAAce,gBAEzEC,cACJA,cAAAC,gBACAA,gBAAAC,mBACAA,mBAAAC,kBACAA,kBAAAC,gBACAA,gBAAAC,kBACAA,kBAAAC,aACAA,aAAAC,cACAA,cAAAC,sBACAA,sBAAAC,iBACAA,iBAAAC,gBACAA,gBAAAC,kBACAA,kBAAAC,qBACAA,qBAAAC,oBACAA,oBAAAC,kBACAA,kBAAAC,oBACAA,oBAAAC,eACAA,eAAAC,gBACAA,gBAAAC,wBACAA,wBAAAC,mBACAA,oBACEtB,SAKJ,MAAO,CACLuB,WAAYrC,OAAO,CAAEsC,KAAMC,sBAAsBpC,QAASqC,KAAMrC,OAAQsC,QAASC,wBAEjFC,UAAW3C,OAAO,CAChBsC,KAAMC,sBAAsBrC,OAC5BsC,KAAMtC,MACNuC,QAASG,aAAa3B,eACtB4B,eAAgBlB,gBAChBmB,YAAaC,mBAAmBC,OAGlCC,YAAajD,OAAO,CAClBsC,KAAMC,sBAAsB3B,SAC5B4B,KAAM5B,QACN6B,QAASG,aAAa1B,iBACtB2B,eAAgBjB,oBAGlBsB,eAAgBlD,OAAO,CACrBsC,KAAMC,sBAAsB9B,YAC5B+B,KAAM/B,WACNgC,QAASG,aAAazB,oBACtB0B,eAAgBhB,qBAChBiB,YAAaC,mBAAmBC,OAGlCG,cAAenD,OAAO,CACpBsC,KAAMC,sBAAsB/B,WAC5BgC,KAAMhC,UACNiC,QAASG,aAAaxB,mBACtByB,eAAgBf,sBAGlBsB,YAAapD,OAAO,CAClBsC,KAAMC,sBAAsBlC,SAC5BmC,KAAMnC,QACNoC,QAASG,aAAavB,iBACtBwB,eAAgBd,kBAChBe,YAAaC,mBAAmBC,OAGlCK,cAAerD,OAAO,CACpBsC,KAAMC,sBAAsB5B,WAC5B6B,KAAM7B,UACN8B,QAASG,aAAatB,mBACtBuB,eAAgBb,sBAGlBsB,SAAUtD,OAAO,CACfsC,KAAMC,sBAAsBhC,MAC5BiC,KAAMjC,KACNkC,QAASG,aAAarB,cACtBsB,eAAgBZ,iBAGlBsB,UAAWvD,OAAO,CAChBsC,KAAMC,sBAAsBjC,OAC5BkC,KAAMlC,MACNmC,QAASG,aAAapB,eACtBqB,eAAgBX,kBAGlBsB,kBAAmBxD,OAAO,CACxBsC,KAAMC,sBAAsBnC,eAC5BoC,KAAMpC,cACNqC,QAASG,aAAanB,uBACtBoB,eAAgBV,0BAGlBsB,aAAczD,OAAO,CACnBsC,KAAMC,sBAAsB7B,UAC5B8B,KAAM9B,SACN+B,QAASG,aAAalB,kBACtBmB,eAAgBT,qBAGtB"}

package/dist/Space/Utils/LoadResourcesUtils.js

@@ -0,0 +1,2 @@
+async function loadResourcesFromConfig(resources,{animationsService:animationsService,audioService:audioService,models3dService:models3dService,envMapService:envMapService,textureService:textureService}){const{animations:animations,audio:audio,models3d:models3d,envMaps:envMaps,textures:textures}=resources,envMapTexturePromise=envMapService.loadFromConfigAsync(envMaps);return await textureService.loadFromConfigAsync(textures),await animationsService.loadFromConfigAsync(animations),await Promise.all([models3dService.loadFromConfigAsync(models3d),audioService.loadFromConfigAsync(audio),envMapTexturePromise])}export{loadResourcesFromConfig};
+//# sourceMappingURL=LoadResourcesUtils.js.map

package/dist/Space/Utils/LoadResourcesUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoadResourcesUtils.js","sources":["../../../src/Space/Utils/LoadResourcesUtils.ts"],"sourcesContent":["import type { TEnvMapTexture } from '@Anarchy/Engine/EnvMap/Models';\nimport type { TSpaceConfigResources, TSpaceServices } from '@Anarchy/Engine/Space/Models';\n\nexport async function loadResourcesFromConfig(resources: TSpaceConfigResources, { animationsService, audioService, models3dService, envMapService, textureService }: TSpaceServices): Promise<unknown> {\n  const { animations, audio, models3d, envMaps, textures } = resources;\n\n  // EnvMaps could be loaded async, no need to wait\n  const envMapTexturePromise: Promise<ReadonlyArray<TEnvMapTexture>> = envMapService.loadFromConfigAsync(envMaps);\n\n  // Textures should be loaded before materials and models\n  await textureService.loadFromConfigAsync(textures);\n\n  await animationsService.loadFromConfigAsync(animations);\n\n  return await Promise.all([\n    // A \"Models3d\" has two parts: \"entities\" and \"resources\". Here we only load model resources. And create \"entities\" them lately (in the other place).\n    models3dService.loadFromConfigAsync(models3d),\n    audioService.loadFromConfigAsync(audio),\n    envMapTexturePromise\n  ]);\n}\n"],"names":["async","loadResourcesFromConfig","resources","animationsService","audioService","models3dService","envMapService","textureService","animations","audio","models3d","envMaps","textures","envMapTexturePromise","loadFromConfigAsync","Promise","all"],"mappings":"AAGAA,eAAsBC,wBAAwBC,WAAkCC,kBAAEA,kBAAAC,aAAmBA,6BAAcC,gBAAAC,cAAiBA,cAAAC,eAAeA,iBACjJ,MAAMC,WAAEA,WAAAC,MAAYA,MAAAC,SAAOA,SAAAC,QAAUA,QAAAC,SAASA,UAAaV,UAGrDW,qBAA+DP,cAAcQ,oBAAoBH,SAOvG,aAJMJ,eAAeO,oBAAoBF,gBAEnCT,kBAAkBW,oBAAoBN,kBAE/BO,QAAQC,IAAI,CAEvBX,gBAAgBS,oBAAoBJ,UACpCN,aAAaU,oBAAoBL,OACjCI,sBAEJ"}

package/dist/Space/Utils/PrepareServicesUtils.js

@@ -0,0 +1,2 @@
+import{AudioMetaInfoRegistry}from"../../Audio/Registries/AudioMetaInfoRegistry.js";import{EnvMapMetaInfoRegistry}from"../../EnvMap/Registries/EnvMapMetaInfoRegistry.js";import{FsmSourceFactory}from"../../Fsm/Factories/FsmSourceFactory.js";import{FsmService}from"../../Fsm/Services/FsmService.js";import{ScenesService}from"../../Scene/Services/ScenesService.js";import{SceneRegistry}from"../../Scene/Registries/SceneRegistry.js";import{SceneFactory}from"../../Scene/Factories/SceneFactory.js";import{LoopService}from"../../Loop/Services/LoopService.js";import{LoopRegistry}from"../../Loop/Registries/LoopRegistry.js";import{LoopFactory}from"../../Loop/Factories/LoopFactory.js";import{LoadingManagerService}from"../../LoadingManager/Services/LoadingManagerService.js";import{LoadingManagerRegistry}from"../../LoadingManager/Registries/LoadingManagerRegistry.js";import{LoadingManagerFactory}from"../../LoadingManager/Factories/LoadingManagerFactory.js";import{TextureService}from"../../Texture/Services/TextureService.js";import{TextureMetaInfoRegistry}from"../../Texture/Registries/TextureMetaInfoRegistry.js";import{TextureResourceAsyncRegistry}from"../../Texture/Registries/TextureResourceAsyncRegistry.js";import{MaterialService}from"../../Material/Services/MaterialService.js";import{MaterialRegistry}from"../../Material/Registries/MaterialRegistry.js";import{MaterialFactory}from"../../Material/Factories/MaterialFactory.js";import{PhysicsWorldService}from"../../Physics/Services/PhysicsWorldService.js";import{PhysicsBodyService}from"../../Physics/Services/PhysicsBodyService.js";import{PhysicsBodyRegistry}from"../../Physics/Registries/PhysicsBodyRegistry.js";import{PhysicsBodyFactory}from"../../Physics/Factories/PhysicsBodyFactory.js";import{SpatialGridService}from"../../Spatial/Services/SpatialGridService.js";import{SpatialGridRegistry}from"../../Spatial/Registries/SpatialGridRegistry.js";import{SpatialGridFactory}from"../../Spatial/Factories/SpatialGridFactory.js";import{CollisionsService}from"../../Collisions/Services/CollisionsService.js";import{AnimationsService}from"../../Animations/Services/AnimationsService.js";import{AnimationsMetaInfoRegistry}from"../../Animations/Registries/AnimationsMetaInfoRegistry.js";import{AnimationsResourceAsyncRegistry}from"../../Animations/Registries/AnimationsResourceAsyncRegistry.js";import{Model3dToActorConnectionRegistry}from"../../Actor/Registries/Model3dToActorConnectionRegistry.js";import{Model3dRawToModel3dConnectionRegistry}from"../../Models3d/Registries/Model3dRawToModel3dConnectionRegistry.js";import{Models3dService}from"../../Models3d/Services/Models3dService.js";import{Models3dMetaInfoRegistry}from"../../Models3d/Registries/Models3dMetaInfoRegistry.js";import{Models3dResourceAsyncRegistry}from"../../Models3d/Registries/Models3dResourceAsyncRegistry.js";import{Models3dRegistry}from"../../Models3d/Registries/Models3dRegistry.js";import{Models3dFactory}from"../../Models3d/Factories/Models3dFactory.js";import{FsmSourceRegistry}from"../../Fsm/Registries/FsmSourceRegistry.js";import{FsmInstanceRegistry}from"../../Fsm/Registries/FsmInstanceRegistry.js";import{FsmInstanceFactory}from"../../Fsm/Factories/FsmInstanceFactory.js";import{TransformDriveService}from"../../TransformDrive/Services/TransformDriveService.js";import{TransformDriveRegistry}from"../../TransformDrive/Registries/TransformDriveRegistry.js";import{TransformDriveFactory}from"../../TransformDrive/Factories/TransformDriveFactory.js";import{AudioService}from"../../Audio/Services/AudioService.js";import{AudioListenersRegistry}from"../../Audio/Registries/AudioListenersRegistry.js";import{AudioResourceAsyncRegistry}from"../../Audio/Registries/AudioResourceAsyncRegistry.js";import{AudioRegistry}from"../../Audio/Registries/AudioRegistry.js";import{AudioFactory}from"../../Audio/Factories/AudioFactory.js";import{CameraService}from"../../Camera/Services/CameraService.js";import{CameraRegistry}from"../../Camera/Registries/CameraRegistry.js";import{CameraFactory}from"../../Camera/Factories/CameraFactory.js";import{TextService}from"../../Text/Services/TextService.js";import{Text3dRendererRegistry}from"../../Text/Registries/Text3dRendererRegistry.js";import{Text2dRendererRegistry}from"../../Text/Registries/Text2dRendererRegistry.js";import{Text3dTextureRegistry}from"../../Text/Registries/Text3dTextureRegistry.js";import{Text3dRegistry}from"../../Text/Registries/Text3dRegistry.js";import{Text2dRegistry}from"../../Text/Registries/Text2dRegistry.js";import{TextFactory}from"../../Text/Factories/TextFactory.js";import{RendererService}from"../../Renderer/Services/RendererService.js";import{RendererRegistry}from"../../Renderer/Registries/RendererRegistry.js";import{RendererFactory}from"../../Renderer/Factories/RendererFactory.js";import{ParticlesService}from"../../Particles/Services/ParticlesService.js";import{ParticlesRegistry}from"../../Particles/Registries/ParticlesRegistry.js";import{ParticlesFactory}from"../../Particles/Factories/ParticlesFactory.js";import{MouseService}from"../../Mouse/Services/MouseService.js";import{MousePositionWatcherRegistry}from"../../Mouse/Registries/MousePositionWatcherRegistry.js";import{MousePositionWatcherFactory}from"../../Mouse/Factories/MousePositionWatcherFactory.js";import{MouseClickWatcherRegistry}from"../../Mouse/Registries/MouseClickWatcherRegistry.js";import{MouseClickWatcherFactory}from"../../Mouse/Factories/MouseClickWatcherFactory.js";import{LightService}from"../../Light/Services/LightService.js";import{LightRegistry}from"../../Light/Registries/LightRegistry.js";import{LightFactory}from"../../Light/Factories/LightFactory.js";import{KeyboardService}from"../../Keyboard/Services/KeyboardService.js";import{KeyWatcherRegistry}from"../../Keyboard/Registries/KeyWatcherRegistry.js";import{KeyWatcherFactory}from"../../Keyboard/Factories/KeyWatcherFactory.js";import{IntersectionsWatcherService}from"../../Intersections/Services/IntersectionsWatcherService.js";import{IntersectionsWatcherRegistry}from"../../Intersections/Registries/IntersectionsWatcherRegistry.js";import{IntersectionsWatcherFactory}from"../../Intersections/Factories/IntersectionsWatcherFactory.js";import{FogService}from"../../Fog/Services/FogService.js";import{FogRegistry}from"../../Fog/Registries/FogRegistry.js";import{FogFactory}from"../../Fog/Factories/FogFactory.js";import{EnvMapService}from"../../EnvMap/Services/EnvMapService.js";import{EnvMapTextureAsyncRegistry}from"../../EnvMap/Registries/EnvMapTextureAsyncRegistry.js";import{EnvMapRegistry}from"../../EnvMap/Registries/EnvMapRegistry.js";import{EnvMapFactory}from"../../EnvMap/Factories/EnvMapFactory.js";import{ControlService}from"../../Controls/Services/ControlsService.js";import{ControlsRegistry}from"../../Controls/Registries/ControlsRegistry.js";import{ControlsFactory}from"../../Controls/Factories/ControlsFactory.js";import{ActorService}from"../../Actor/Services/ActorService.js";import{ActorRegistry}from"../../Actor/Registries/ActorRegistry.js";import{ActorFactory}from"../../Actor/Factories/ActorFactory.js";import{DEFAULT_SPACE_LOADING_MANAGER_NAME}from"../../LoadingManager/Constants/DefaultSpaceLoadingManagerName.js";function buildBaseServices(){const scenesService=ScenesService(SceneFactory(),SceneRegistry());return{loopService:LoopService(LoopFactory(),LoopRegistry()),scenesService:scenesService}}function buildEntitiesServices(sceneW,canvas,container,loops,{loopService:loopService,scenesService:scenesService},settings){const loadingManagerService=LoadingManagerService(LoadingManagerFactory(),LoadingManagerRegistry()),loadingManagerW=loadingManagerService.create({name:DEFAULT_SPACE_LOADING_MANAGER_NAME}),textureService=TextureService(TextureResourceAsyncRegistry(),TextureMetaInfoRegistry(),loadingManagerW),materialService=MaterialService(MaterialFactory(),MaterialRegistry(),{textureService:textureService}),physicsWorldService=PhysicsWorldService(sceneW,loops),physicsBodyService=PhysicsBodyService(PhysicsBodyFactory(),PhysicsBodyRegistry(),physicsWorldService),spatialGridService=SpatialGridService(SpatialGridFactory(),SpatialGridRegistry()),collisionsService=CollisionsService(),animationsService=AnimationsService(AnimationsResourceAsyncRegistry(),AnimationsMetaInfoRegistry(),loops,loadingManagerW,settings),model3dToActorConnectionRegistry=Model3dToActorConnectionRegistry(),model3dRawToModel3dConnectionRegistry=Model3dRawToModel3dConnectionRegistry(),models3dService=Models3dService(Models3dFactory(),Models3dRegistry(),Models3dResourceAsyncRegistry(),Models3dMetaInfoRegistry(),{materialService:materialService,animationsService:animationsService,model3dRawToModel3dConnectionRegistry:model3dRawToModel3dConnectionRegistry},loadingManagerW,settings),fsmService=FsmService(FsmInstanceFactory(),FsmSourceFactory(),FsmInstanceRegistry(),FsmSourceRegistry()),transformDriveService=TransformDriveService(TransformDriveFactory(),TransformDriveRegistry(),{loopService:loopService}),audioService=AudioService(AudioFactory(),AudioRegistry(),AudioResourceAsyncRegistry(),AudioListenersRegistry(),AudioMetaInfoRegistry(),{transformDriveService:transformDriveService},loops,loadingManagerW),cameraService=CameraService(CameraFactory(),CameraRegistry(),sceneW,{audioService:audioService,transformDriveService:transformDriveService,container:container});return{actorService:ActorService(ActorFactory(),ActorRegistry(),{collisionsService:collisionsService,fsmService:fsmService,loopService:loopService,model3dToActorConnectionRegistry:model3dToActorConnectionRegistry,models3dService:models3dService,physicsBodyService:physicsBodyService,spatialGridService:spatialGridService,transformDriveService:transformDriveService},sceneW),audioService:audioService,cameraService:cameraService,controlsService:ControlService(ControlsFactory(),ControlsRegistry(),loops,{cameraService:cameraService},canvas),collisionsService:collisionsService,scenesService:scenesService,envMapService:EnvMapService(EnvMapFactory(),EnvMapRegistry(),EnvMapTextureAsyncRegistry(),EnvMapMetaInfoRegistry(),sceneW,loadingManagerW),fogService:FogService(FogFactory(),FogRegistry(),sceneW),fsmService:fsmService,intersectionsWatcherService:IntersectionsWatcherService(IntersectionsWatcherFactory(),IntersectionsWatcherRegistry()),keyboardService:KeyboardService(container,KeyWatcherFactory(),KeyWatcherRegistry()),lightService:LightService(LightFactory(),LightRegistry(),{transformDriveService:transformDriveService},sceneW),loadingManagerService:loadingManagerService,loopService:loopService,materialService:materialService,models3dService:models3dService,animationsService:animationsService,mouseService:MouseService(container,MouseClickWatcherFactory(),MouseClickWatcherRegistry(),MousePositionWatcherFactory(),MousePositionWatcherRegistry(),loops),particlesService:ParticlesService(ParticlesFactory(),ParticlesRegistry(),{transformDriveService:transformDriveService,materialService:materialService},sceneW),physicsBodyService:physicsBodyService,physicsWorldService:physicsWorldService,rendererService:RendererService(RendererFactory(),RendererRegistry(),loops,{cameraService:cameraService,container:container},sceneW),spatialGridService:spatialGridService,textService:TextService(TextFactory(),Text2dRegistry(),Text3dRegistry(),Text3dTextureRegistry(),Text2dRendererRegistry(),Text3dRendererRegistry(),loops,{loopService:loopService,physicsBodyService:physicsBodyService,cameraService:cameraService,transformDriveService:transformDriveService},sceneW),textureService:textureService,transformDriveService:transformDriveService}}export{buildBaseServices,buildEntitiesServices};
+//# sourceMappingURL=PrepareServicesUtils.js.map

package/dist/Space/Utils/PrepareServicesUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrepareServicesUtils.js","sources":["../../../src/Space/Utils/PrepareServicesUtils.ts"],"sourcesContent":["import type { TModel3dToActorConnectionRegistry } from '@Anarchy/Engine/Actor';\nimport { ActorFactory, ActorRegistry, ActorService, Model3dToActorConnectionRegistry } from '@Anarchy/Engine/Actor';\nimport type { TAnimationsService } from '@Anarchy/Engine/Animations';\nimport { AnimationsMetaInfoRegistry, AnimationsResourceAsyncRegistry, AnimationsService } from '@Anarchy/Engine/Animations';\nimport type { TAudioService } from '@Anarchy/Engine/Audio';\nimport { AudioFactory, AudioListenersRegistry, AudioRegistry, AudioResourceAsyncRegistry, AudioService } from '@Anarchy/Engine/Audio';\nimport { AudioMetaInfoRegistry } from '@Anarchy/Engine/Audio/Registries/AudioMetaInfoRegistry';\nimport type { TCameraService } from '@Anarchy/Engine/Camera';\nimport { CameraFactory, CameraRegistry, CameraService } from '@Anarchy/Engine/Camera';\nimport type { TCollisionsService } from '@Anarchy/Engine/Collisions';\nimport { CollisionsService } from '@Anarchy/Engine/Collisions';\nimport { ControlService, ControlsFactory, ControlsRegistry } from '@Anarchy/Engine/Controls';\nimport { EnvMapFactory, EnvMapRegistry, EnvMapService, EnvMapTextureAsyncRegistry } from '@Anarchy/Engine/EnvMap';\nimport { EnvMapMetaInfoRegistry } from '@Anarchy/Engine/EnvMap/Registries/EnvMapMetaInfoRegistry';\nimport { FogFactory, FogRegistry, FogService } from '@Anarchy/Engine/Fog';\nimport type { TFsmService } from '@Anarchy/Engine/Fsm';\nimport { FsmInstanceFactory, FsmInstanceRegistry, FsmSourceRegistry } from '@Anarchy/Engine/Fsm';\nimport { FsmSourceFactory } from '@Anarchy/Engine/Fsm/Factories/FsmSourceFactory';\nimport { FsmService } from '@Anarchy/Engine/Fsm/Services/FsmService';\nimport type { TContainerDecorator } from '@Anarchy/Engine/Global';\nimport { IntersectionsWatcherFactory, IntersectionsWatcherRegistry, IntersectionsWatcherService } from '@Anarchy/Engine/Intersections';\nimport { KeyboardService, KeyWatcherFactory, KeyWatcherRegistry } from '@Anarchy/Engine/Keyboard';\nimport { LightFactory, LightRegistry, LightService } from '@Anarchy/Engine/Light';\nimport type { TLoadingManagerService, TLoadingManagerWrapper } from '@Anarchy/Engine/LoadingManager';\nimport { DEFAULT_SPACE_LOADING_MANAGER_NAME, LoadingManagerFactory, LoadingManagerRegistry, LoadingManagerService } from '@Anarchy/Engine/LoadingManager';\nimport type { TLoopService } from '@Anarchy/Engine/Loop';\nimport { LoopFactory, LoopRegistry, LoopService } from '@Anarchy/Engine/Loop';\nimport type { TMaterialService } from '@Anarchy/Engine/Material';\nimport { MaterialFactory, MaterialRegistry, MaterialService } from '@Anarchy/Engine/Material';\nimport type { TModel3dRawToModel3dConnectionRegistry, TModels3dService } from '@Anarchy/Engine/Models3d';\nimport { Model3dRawToModel3dConnectionRegistry, Models3dFactory, Models3dMetaInfoRegistry, Models3dRegistry, Models3dResourceAsyncRegistry, Models3dService } from '@Anarchy/Engine/Models3d';\nimport { MouseClickWatcherFactory, MouseClickWatcherRegistry, MousePositionWatcherFactory, MousePositionWatcherRegistry, MouseService } from '@Anarchy/Engine/Mouse';\nimport { ParticlesFactory, ParticlesRegistry, ParticlesService } from '@Anarchy/Engine/Particles';\nimport type { TPhysicsBodyService, TPhysicsWorldService } from '@Anarchy/Engine/Physics';\nimport { PhysicsBodyFactory, PhysicsBodyRegistry, PhysicsBodyService, PhysicsWorldService } from '@Anarchy/Engine/Physics';\nimport { RendererFactory, RendererRegistry, RendererService } from '@Anarchy/Engine/Renderer';\nimport type { TScenesService, TSceneWrapper } from '@Anarchy/Engine/Scene';\nimport { SceneFactory, SceneRegistry, ScenesService } from '@Anarchy/Engine/Scene';\nimport type { TSpaceBaseServices, TSpaceCanvas, TSpaceLoops, TSpaceServices, TSpaceSettings } from '@Anarchy/Engine/Space/Models';\nimport type { TSpatialGridService } from '@Anarchy/Engine/Spatial';\nimport { SpatialGridFactory, SpatialGridRegistry, SpatialGridService } from '@Anarchy/Engine/Spatial';\nimport { Text2dRegistry, Text2dRendererRegistry, Text3dRegistry, Text3dRendererRegistry, Text3dTextureRegistry, TextFactory, TextService } from '@Anarchy/Engine/Text';\nimport type { TTextureService } from '@Anarchy/Engine/Texture';\nimport { TextureMetaInfoRegistry, TextureResourceAsyncRegistry, TextureService } from '@Anarchy/Engine/Texture';\nimport type { TTransformDriveService } from '@Anarchy/Engine/TransformDrive';\nimport { TransformDriveFactory, TransformDriveRegistry, TransformDriveService } from '@Anarchy/Engine/TransformDrive';\n\nexport function buildBaseServices(): TSpaceBaseServices {\n  const scenesService: TScenesService = ScenesService(SceneFactory(), SceneRegistry());\n  const loopService: TLoopService = LoopService(LoopFactory(), LoopRegistry());\n\n  return { loopService, scenesService };\n}\n\nexport function buildEntitiesServices(\n  sceneW: TSceneWrapper,\n  canvas: TSpaceCanvas,\n  container: TContainerDecorator,\n  loops: TSpaceLoops,\n  { loopService, scenesService }: TSpaceBaseServices,\n  settings: TSpaceSettings\n): TSpaceServices {\n  const loadingManagerService: TLoadingManagerService = LoadingManagerService(LoadingManagerFactory(), LoadingManagerRegistry());\n  const loadingManagerW: TLoadingManagerWrapper = loadingManagerService.create({ name: DEFAULT_SPACE_LOADING_MANAGER_NAME });\n\n  const textureService: TTextureService = TextureService(TextureResourceAsyncRegistry(), TextureMetaInfoRegistry(), loadingManagerW);\n  const materialService: TMaterialService = MaterialService(MaterialFactory(), MaterialRegistry(), { textureService });\n  const physicsWorldService: TPhysicsWorldService = PhysicsWorldService(sceneW, loops);\n  const physicsBodyService: TPhysicsBodyService = PhysicsBodyService(PhysicsBodyFactory(), PhysicsBodyRegistry(), physicsWorldService);\n  const spatialGridService: TSpatialGridService = SpatialGridService(SpatialGridFactory(), SpatialGridRegistry());\n  const collisionsService: TCollisionsService = CollisionsService();\n  const animationsService: TAnimationsService = AnimationsService(AnimationsResourceAsyncRegistry(), AnimationsMetaInfoRegistry(), loops, loadingManagerW, settings);\n  const model3dToActorConnectionRegistry: TModel3dToActorConnectionRegistry = Model3dToActorConnectionRegistry();\n  const model3dRawToModel3dConnectionRegistry: TModel3dRawToModel3dConnectionRegistry = Model3dRawToModel3dConnectionRegistry();\n  const models3dService: TModels3dService = Models3dService(\n    Models3dFactory(),\n    Models3dRegistry(),\n    Models3dResourceAsyncRegistry(),\n    Models3dMetaInfoRegistry(),\n    {\n      materialService,\n      animationsService,\n      model3dRawToModel3dConnectionRegistry\n    },\n    loadingManagerW,\n    settings\n  );\n  const fsmService: TFsmService = FsmService(FsmInstanceFactory(), FsmSourceFactory(), FsmInstanceRegistry(), FsmSourceRegistry());\n  const transformDriveService: TTransformDriveService = TransformDriveService(TransformDriveFactory(), TransformDriveRegistry(), { loopService });\n  const audioService: TAudioService = AudioService(\n    AudioFactory(),\n    AudioRegistry(),\n    AudioResourceAsyncRegistry(),\n    AudioListenersRegistry(),\n    AudioMetaInfoRegistry(),\n    { transformDriveService },\n    loops,\n    loadingManagerW\n  );\n  const cameraService: TCameraService = CameraService(CameraFactory(), CameraRegistry(), sceneW, { audioService, transformDriveService, container });\n\n  return {\n    actorService: ActorService(\n      ActorFactory(),\n      ActorRegistry(),\n      {\n        collisionsService,\n        fsmService,\n        loopService,\n        model3dToActorConnectionRegistry,\n        models3dService,\n        physicsBodyService,\n        spatialGridService,\n        transformDriveService\n      },\n      sceneW\n    ),\n    audioService,\n    cameraService,\n    controlsService: ControlService(ControlsFactory(), ControlsRegistry(), loops, { cameraService }, canvas),\n    collisionsService,\n    scenesService,\n    envMapService: EnvMapService(EnvMapFactory(), EnvMapRegistry(), EnvMapTextureAsyncRegistry(), EnvMapMetaInfoRegistry(), sceneW, loadingManagerW),\n    fogService: FogService(FogFactory(), FogRegistry(), sceneW),\n    fsmService,\n    intersectionsWatcherService: IntersectionsWatcherService(IntersectionsWatcherFactory(), IntersectionsWatcherRegistry()),\n    keyboardService: KeyboardService(container, KeyWatcherFactory(), KeyWatcherRegistry()),\n    lightService: LightService(LightFactory(), LightRegistry(), { transformDriveService }, sceneW),\n    loadingManagerService,\n    loopService,\n    materialService,\n    models3dService,\n    animationsService,\n    mouseService: MouseService(container, MouseClickWatcherFactory(), MouseClickWatcherRegistry(), MousePositionWatcherFactory(), MousePositionWatcherRegistry(), loops),\n    particlesService: ParticlesService(ParticlesFactory(), ParticlesRegistry(), { transformDriveService, materialService }, sceneW),\n    physicsBodyService,\n    physicsWorldService,\n    rendererService: RendererService(RendererFactory(), RendererRegistry(), loops, { cameraService, container }, sceneW),\n    spatialGridService,\n    textService: TextService(\n      TextFactory(),\n      Text2dRegistry(),\n      Text3dRegistry(),\n      Text3dTextureRegistry(),\n      Text2dRendererRegistry(),\n      Text3dRendererRegistry(),\n      loops,\n      { loopService, physicsBodyService, cameraService, transformDriveService },\n      sceneW\n    ),\n    textureService,\n    transformDriveService\n  };\n}\n"],"names":["buildBaseServices","scenesService","ScenesService","SceneFactory","SceneRegistry","loopService","LoopService","LoopFactory","LoopRegistry","buildEntitiesServices","sceneW","canvas","container","loops","settings","loadingManagerService","LoadingManagerService","LoadingManagerFactory","LoadingManagerRegistry","loadingManagerW","create","name","DEFAULT_SPACE_LOADING_MANAGER_NAME","textureService","TextureService","TextureResourceAsyncRegistry","TextureMetaInfoRegistry","materialService","MaterialService","MaterialFactory","MaterialRegistry","physicsWorldService","PhysicsWorldService","physicsBodyService","PhysicsBodyService","PhysicsBodyFactory","PhysicsBodyRegistry","spatialGridService","SpatialGridService","SpatialGridFactory","SpatialGridRegistry","collisionsService","CollisionsService","animationsService","AnimationsService","AnimationsResourceAsyncRegistry","AnimationsMetaInfoRegistry","model3dToActorConnectionRegistry","Model3dToActorConnectionRegistry","model3dRawToModel3dConnectionRegistry","Model3dRawToModel3dConnectionRegistry","models3dService","Models3dService","Models3dFactory","Models3dRegistry","Models3dResourceAsyncRegistry","Models3dMetaInfoRegistry","fsmService","FsmService","FsmInstanceFactory","FsmSourceFactory","FsmInstanceRegistry","FsmSourceRegistry","transformDriveService","TransformDriveService","TransformDriveFactory","TransformDriveRegistry","audioService","AudioService","AudioFactory","AudioRegistry","AudioResourceAsyncRegistry","AudioListenersRegistry","AudioMetaInfoRegistry","cameraService","CameraService","CameraFactory","CameraRegistry","actorService","ActorService","ActorFactory","ActorRegistry","controlsService","ControlService","ControlsFactory","ControlsRegistry","envMapService","EnvMapService","EnvMapFactory","EnvMapRegistry","EnvMapTextureAsyncRegistry","EnvMapMetaInfoRegistry","fogService","FogService","FogFactory","FogRegistry","intersectionsWatcherService","IntersectionsWatcherService","IntersectionsWatcherFactory","IntersectionsWatcherRegistry","keyboardService","KeyboardService","KeyWatcherFactory","KeyWatcherRegistry","lightService","LightService","LightFactory","LightRegistry","mouseService","MouseService","MouseClickWatcherFactory","MouseClickWatcherRegistry","MousePositionWatcherFactory","MousePositionWatcherRegistry","particlesService","ParticlesService","ParticlesFactory","ParticlesRegistry","rendererService","RendererService","RendererFactory","RendererRegistry","textService","TextService","TextFactory","Text2dRegistry","Text3dRegistry","Text3dTextureRegistry","Text2dRendererRegistry","Text3dRendererRegistry"],"mappings":"ygOA+CO,SAASA,oBACd,MAAMC,cAAgCC,cAAcC,eAAgBC,iBAGpE,MAAO,CAAEC,YAFyBC,YAAYC,cAAeC,gBAEvCP,4BACxB,CAEO,SAASQ,sBACdC,OACAC,OACAC,UACAC,OACAR,YAAEA,YAAAJ,cAAaA,eACfa,UAEA,MAAMC,sBAAgDC,sBAAsBC,wBAAyBC,0BAC/FC,gBAA0CJ,sBAAsBK,OAAO,CAAEC,KAAMC,qCAE/EC,eAAkCC,eAAeC,+BAAgCC,0BAA2BP,iBAC5GQ,gBAAoCC,gBAAgBC,kBAAmBC,mBAAoB,CAAEP,gCAC7FQ,oBAA4CC,oBAAoBtB,OAAQG,OACxEoB,mBAA0CC,mBAAmBC,qBAAsBC,sBAAuBL,qBAC1GM,mBAA0CC,mBAAmBC,qBAAsBC,uBACnFC,kBAAwCC,oBACxCC,kBAAwCC,kBAAkBC,kCAAmCC,6BAA8BjC,MAAOM,gBAAiBL,UACnJiC,iCAAsEC,mCACtEC,sCAAgFC,wCAChFC,gBAAoCC,gBACxCC,kBACAC,mBACAC,gCACAC,2BACA,CACE7B,gCACAgB,oCACAM,6EAEF9B,gBACAL,UAEI2C,WAA0BC,WAAWC,qBAAsBC,mBAAoBC,sBAAuBC,qBACtGC,sBAAgDC,sBAAsBC,wBAAyBC,yBAA0B,CAAE7D,0BAC3H8D,aAA8BC,aAClCC,eACAC,gBACAC,6BACAC,yBACAC,wBACA,CAAEV,6CACFlD,MACAM,iBAEIuD,cAAgCC,cAAcC,gBAAiBC,iBAAkBnE,OAAQ,CAAEyD,0BAAcJ,4CAAuBnD,sBAEtI,MAAO,CACLkE,aAAcC,aACZC,eACAC,gBACA,CACExC,oCACAgB,sBACApD,wBACA0C,kEACAI,gCACAlB,sCACAI,sCACA0B,6CAEFrD,QAEFyD,0BACAO,4BACAQ,gBAAiBC,eAAeC,kBAAmBC,mBAAoBxE,MAAO,CAAE6D,6BAAiB/D,QACjG8B,oCACAxC,4BACAqF,cAAeC,cAAcC,gBAAiBC,iBAAkBC,6BAA8BC,yBAA0BjF,OAAQS,iBAChIyE,WAAYC,WAAWC,aAAcC,cAAerF,QACpD+C,sBACAuC,4BAA6BC,4BAA4BC,8BAA+BC,gCACxFC,gBAAiBC,gBAAgBzF,UAAW0F,oBAAqBC,sBACjEC,aAAcC,aAAaC,eAAgBC,gBAAiB,CAAE5C,6CAAyBrD,QACvFK,4CACAV,wBACAsB,gCACAwB,gCACAR,oCACAiE,aAAcC,aAAajG,UAAWkG,2BAA4BC,4BAA6BC,8BAA+BC,+BAAgCpG,OAC9JqG,iBAAkBC,iBAAiBC,mBAAoBC,oBAAqB,CAAEtD,4CAAuBpC,iCAAmBjB,QACxHuB,sCACAF,wCACAuF,gBAAiBC,gBAAgBC,kBAAmBC,mBAAoB5G,MAAO,CAAE6D,4BAAe9D,qBAAaF,QAC7G2B,sCACAqF,YAAaC,YACXC,cACAC,iBACAC,iBACAC,wBACAC,yBACAC,yBACApH,MACA,CAAER,wBAAa4B,sCAAoByC,4BAAeX,6CAClDrD,QAEFa,8BACAwC,4CAEJ"}

package/dist/Space/Utils/SchemaValidationUtils.js

@@ -0,0 +1,2 @@
+import{findDuplicateString}from"../../packages/anarchy-shared/src/Utils/ArrayUtils.js";import{isDefined,isNotDefined}from"../../packages/anarchy-shared/src/Utils/CheckUtils.js";import{isPrimitiveModel3dSource,isPrimitiveModel3dResourceConfig}from"../../Models3d/Utils/UtilsPrimitiveModels3d.js";const validateNames=entities=>entities.every(validateName),validateName=entity=>validateField(entity,"name"),validateCameraNames=entities=>entities.every(validateCameraName),validateCameraName=entity=>validateField(entity,"cameraName"),validateActorNamesForEveryEntity=entities=>entities.every(validateActorNames),validateActorNames=entity=>validateArrayField(entity,"actorNames"),validateTagsForEveryEntity=entities=>entities.every(e=>validateTags(e.tags)),validateTags=tags=>!tags||tags.every(validate),validateField=(obj,field)=>validate(obj[field]),validateArrayField=(obj,field)=>obj[field].every(validate),validate=str=>!isDefined(str)||str.length>0&&/^[A-z0-9_]+$/gm.test(str);function validateAllActorsHasModel3d(actors,models3d){const sources=models3d?.map(v=>v.name)??[];return actors.every(actor=>!!isNotDefined(models3d)||sources.includes(actor.model3dSource))}function validateAllActorsWithPhysicsHasRelatedPhysicsBody(actors,physics){if(isNotDefined(physics.bodies))return!0;const{bodies:bodies}=physics;return 0===bodies.length||actors.every(actor=>!!isNotDefined(actor.physicsBodyName)||bodies.some(body=>body.name===actor.physicsBodyName))}function validateNoSameName(entities){const duplicate=findDuplicateString(entities.map(e=>e.name));return duplicate?`Name "${duplicate}" is duplicated`:void 0}function validateAllModel3dEntityHasValidResource(entities,resources){return entities.every(entity=>!!isPrimitiveModel3dSource(entity.model3dSource)||resources.some(resource=>resource.name===entity.model3dSource))}function validateAllAudioEntityHasValidResource(entities,resources){return entities.every(entity=>resources.some(resource=>resource.name===entity.audioSource))}function validateModel3dFileUrls(configs){return configs.every(config=>!!isPrimitiveModel3dResourceConfig(config)||validateFileUrl(config.url))}function validateFileUrls(configs){return configs.every(({url:url})=>validateFileUrl(url))}function validateFileUrl(url){return/^(\/?|[a-zA-Z]:\\)[a-zA-Z0-9_\-/\\]+\.([A-z0-9]{1,4})$/.test(url)}export{validate,validateActorNames,validateActorNamesForEveryEntity,validateAllActorsHasModel3d,validateAllActorsWithPhysicsHasRelatedPhysicsBody,validateAllAudioEntityHasValidResource,validateAllModel3dEntityHasValidResource,validateArrayField,validateCameraName,validateCameraNames,validateField,validateFileUrl,validateFileUrls,validateModel3dFileUrls,validateName,validateNames,validateNoSameName,validateTags,validateTagsForEveryEntity};
+//# sourceMappingURL=SchemaValidationUtils.js.map

package/dist/Space/Utils/SchemaValidationUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaValidationUtils.js","sources":["../../../src/Space/Utils/SchemaValidationUtils.ts"],"sourcesContent":["import type { TAbstractResourceConfig } from '@Anarchy/Engine/Abstract';\nimport type { TActorConfig } from '@Anarchy/Engine/Actor';\nimport type { TAnyAudioConfig, TAudioResourceConfig } from '@Anarchy/Engine/Audio';\nimport type { TWithName, TWithNameOptional, TWithTags } from '@Anarchy/Engine/Mixins';\nimport type { TModel3dConfig, TModel3dResourceConfig } from '@Anarchy/Engine/Models3d';\nimport { isPrimitiveModel3dResourceConfig, isPrimitiveModel3dSource } from '@Anarchy/Engine/Models3d';\nimport type { TPhysicsBodyConfig, TPhysicsConfig } from '@Anarchy/Engine/Physics';\nimport { findDuplicateString, isDefined, isNotDefined } from '@Anarchy/Shared/Utils';\n\nexport const validateNames = (entities: ReadonlyArray<TWithNameOptional>): boolean => entities.every(validateName);\nexport const validateName = (entity: TWithNameOptional): boolean => validateField(entity, 'name');\nexport const validateCameraNames = (\n  entities: ReadonlyArray<\n    Readonly<{\n      cameraName: string;\n    }>\n  >\n): boolean => entities.every(validateCameraName);\nexport const validateCameraName = (entity: Readonly<{ cameraName: string }>): boolean => validateField(entity, 'cameraName');\n\nexport const validateActorNamesForEveryEntity = (\n  entities: ReadonlyArray<\n    Readonly<{\n      actorNames: ReadonlyArray<string>;\n    }>\n  >\n): boolean => entities.every(validateActorNames);\n\nexport const validateActorNames = (\n  entity: Readonly<{\n    actorNames: ReadonlyArray<string>;\n  }>\n): boolean => validateArrayField(entity, 'actorNames');\n\nexport const validateTagsForEveryEntity = (entities: ReadonlyArray<TWithTags>): boolean => entities.every((e: TWithTags): boolean => validateTags(e.tags));\nexport const validateTags = (tags: ReadonlyArray<string> | undefined): boolean => (tags ? tags.every(validate) : true);\n\nexport const validateField = <T extends Record<string, any>>(obj: T, field: keyof T): boolean => validate(obj[field]);\nexport const validateArrayField = <T extends Record<string, any>>(obj: T, field: keyof T): boolean => obj[field].every(validate);\n\nexport const validate = (str: string | undefined): boolean => (isDefined(str) ? str.length > 0 && /^[A-z0-9_]+$/gm.test(str) : true);\n\nexport function validateAllActorsHasModel3d(actors: ReadonlyArray<TActorConfig>, models3d: ReadonlyArray<TModel3dConfig> | undefined): boolean {\n  const sources: ReadonlyArray<string> = models3d?.map((v: TModel3dConfig): string => v.name) ?? [];\n  return actors.every((actor: TActorConfig): boolean => (isNotDefined(models3d) ? true : sources.includes(actor.model3dSource)));\n}\n\nexport function validateAllActorsWithPhysicsHasRelatedPhysicsBody(actors: ReadonlyArray<TActorConfig>, physics: TPhysicsConfig): boolean {\n  if (isNotDefined(physics.bodies)) return true;\n  const { bodies } = physics;\n  if (bodies.length === 0) return true;\n\n  return actors.every((actor: TActorConfig): boolean => {\n    if (isNotDefined(actor.physicsBodyName)) return true;\n    return bodies.some((body: TPhysicsBodyConfig): boolean => body.name === actor.physicsBodyName);\n  });\n}\n\nexport function validateNoSameName(entities: ReadonlyArray<TWithName>): string | undefined {\n  const duplicate: string | undefined = findDuplicateString(entities.map((e: TWithName): string => e.name));\n  return duplicate ? `Name \"${duplicate}\" is duplicated` : undefined;\n}\n\n// TODO would be nice to check all the resources and relations (e.g. materials)\nexport function validateAllModel3dEntityHasValidResource(entities: ReadonlyArray<TModel3dConfig>, resources: ReadonlyArray<TModel3dResourceConfig>): boolean {\n  return entities.every((entity: TModel3dConfig): boolean => {\n    if (isPrimitiveModel3dSource(entity.model3dSource)) return true;\n    return resources.some((resource: TModel3dResourceConfig): boolean => resource.name === entity.model3dSource);\n  });\n}\n\nexport function validateAllAudioEntityHasValidResource(entities: ReadonlyArray<TAnyAudioConfig>, resources: ReadonlyArray<TAudioResourceConfig>): boolean {\n  return entities.every((entity: TAnyAudioConfig): boolean => {\n    return resources.some((resource: TAudioResourceConfig): boolean => resource.name === entity.audioSource);\n  });\n}\n\nexport function validateModel3dFileUrls(configs: ReadonlyArray<TModel3dResourceConfig>): boolean {\n  return configs.every((config: TModel3dResourceConfig): boolean => {\n    if (isPrimitiveModel3dResourceConfig(config)) return true;\n    return validateFileUrl(config.url);\n  });\n}\n\nexport function validateFileUrls(configs: ReadonlyArray<TAbstractResourceConfig>): boolean {\n  return configs.every(({ url }: TAbstractResourceConfig): boolean => validateFileUrl(url));\n}\n\nexport function validateFileUrl(url: string): boolean {\n  const regex = /^(\\/?|[a-zA-Z]:\\\\)[a-zA-Z0-9_\\-/\\\\]+\\.([A-z0-9]{1,4})$/;\n  return regex.test(url);\n}\n"],"names":["validateNames","entities","every","validateName","entity","validateField","validateCameraNames","validateCameraName","validateActorNamesForEveryEntity","validateActorNames","validateArrayField","validateTagsForEveryEntity","e","validateTags","tags","validate","obj","field","str","isDefined","length","test","validateAllActorsHasModel3d","actors","models3d","sources","map","v","name","actor","isNotDefined","includes","model3dSource","validateAllActorsWithPhysicsHasRelatedPhysicsBody","physics","bodies","physicsBodyName","some","body","validateNoSameName","duplicate","findDuplicateString","validateAllModel3dEntityHasValidResource","resources","isPrimitiveModel3dSource","resource","validateAllAudioEntityHasValidResource","audioSource","validateModel3dFileUrls","configs","config","isPrimitiveModel3dResourceConfig","validateFileUrl","url","validateFileUrls"],"mappings":"uSASO,MAAMA,cAAiBC,UAAwDA,SAASC,MAAMC,cACxFA,aAAgBC,QAAuCC,cAAcD,OAAQ,QAC7EE,oBACXL,UAKYA,SAASC,MAAMK,oBAChBA,mBAAsBH,QAAsDC,cAAcD,OAAQ,cAElGI,iCACXP,UAKYA,SAASC,MAAMO,oBAEhBA,mBACXL,QAGYM,mBAAmBN,OAAQ,cAE5BO,2BAA8BV,UAAgDA,SAASC,MAAOU,GAA0BC,aAAaD,EAAEE,OACvID,aAAgBC,OAAsDA,MAAOA,KAAKZ,MAAMa,UAExFV,cAAgB,CAAgCW,IAAQC,QAA4BF,SAASC,IAAIC,QACjGP,mBAAqB,CAAgCM,IAAQC,QAA4BD,IAAIC,OAAOf,MAAMa,UAE1GA,SAAYG,MAAsCC,UAAUD,MAAOA,IAAIE,OAAS,GAAK,iBAAiBC,KAAKH,KAEjH,SAASI,4BAA4BC,OAAqCC,UAC/E,MAAMC,QAAiCD,UAAUE,IAAKC,GAA8BA,EAAEC,OAAS,GAC/F,OAAOL,OAAOrB,MAAO2B,SAAkCC,aAAaN,WAAmBC,QAAQM,SAASF,MAAMG,eAChH,CAEO,SAASC,kDAAkDV,OAAqCW,SACrG,GAAIJ,aAAaI,QAAQC,QAAS,OAAO,EACzC,MAAMA,OAAEA,QAAWD,QACnB,OAAsB,IAAlBC,OAAOf,QAEJG,OAAOrB,MAAO2B,SACfC,aAAaD,MAAMO,kBAChBD,OAAOE,KAAMC,MAAsCA,KAAKV,OAASC,MAAMO,iBAElF,CAEO,SAASG,mBAAmBtC,UACjC,MAAMuC,UAAgCC,oBAAoBxC,SAASyB,IAAKd,GAAyBA,EAAEgB,OACnG,OAAOY,UAAY,SAASA,gCAA6B,CAC3D,CAGO,SAASE,yCAAyCzC,SAAyC0C,WAChG,OAAO1C,SAASC,MAAOE,UACjBwC,yBAAyBxC,OAAO4B,gBAC7BW,UAAUN,KAAMQ,UAA8CA,SAASjB,OAASxB,OAAO4B,eAElG,CAEO,SAASc,uCAAuC7C,SAA0C0C,WAC/F,OAAO1C,SAASC,MAAOE,QACduC,UAAUN,KAAMQ,UAA4CA,SAASjB,OAASxB,OAAO2C,aAEhG,CAEO,SAASC,wBAAwBC,SACtC,OAAOA,QAAQ/C,MAAOgD,UAChBC,iCAAiCD,SAC9BE,gBAAgBF,OAAOG,KAElC,CAEO,SAASC,iBAAiBL,SAC/B,OAAOA,QAAQ/C,MAAM,EAAGmD,WAA4CD,gBAAgBC,KACtF,CAEO,SAASD,gBAAgBC,KAE9B,MADc,yDACDhC,KAAKgC,IACpB"}

package/dist/Space/Validators/SchemasValidator.js

@@ -0,0 +1,2 @@
+import TSpaceConfigSchema from"../Schemas/TSpaceConfig.json.js";import{isDefined}from"../../packages/anarchy-shared/src/Utils/CheckUtils.js";import{Validator}from"../../node_modules/@cfworker/json-schema/dist/esm/validator.js";import{SpaceSchemaVersion}from"../Constants/SpaceSchemaVersion.js";import{validateTags,validate,validateAllActorsHasModel3d,validateAllActorsWithPhysicsHasRelatedPhysicsBody,validateAllModel3dEntityHasValidResource,validateAllAudioEntityHasValidResource,validateCameraNames,validateActorNamesForEveryEntity,validateNames,validateTagsForEveryEntity,validateNoSameName,validateModel3dFileUrls,validateFileUrls}from"../Utils/SchemaValidationUtils.js";import isArray from"../../node_modules/lodash-es/isArray.js";import{isIntersectionsCameraWatcherConfig}from"../../Intersections/Utils/IntersectionsWatcherUtils.js";function validSpaceConfig(config){const jsonResult=function(config){const validator=new Validator(TSpaceConfigSchema,"7"),{valid:valid,errors:errors}=validator.validate(config);return{isValid:valid,errors:errors}}(config),dataResult=function({name:name,version:version,scenes:scenes,resources:resources,entities:entities,canvasSelector:canvasSelector,tags:tags}){const{models3d:models3dResources,audio:audioResources,envMaps:envMaps,textures:textures}=resources,{actors:actors,audio:audio,cameras:cameras,spatialGrids:spatialGrids,controls:controls,intersections:intersections,lights:lights,materials:materials,models3d:models3dEntities,physics:physics,fogs:fogs,texts:texts}=entities,basicErrors=function(name,version,scenes,canvasSelector,tags){let errors=[];return version!==SpaceSchemaVersion.V1&&(errors=[...errors,`Unsupported schema's version(${version}). Supported version is: ${SpaceSchemaVersion.V2}`]),0===scenes.length&&(errors=[...errors,"No scenes are defined"]),/^[a-zA-Z0-9\s.#\-_>[\]='"*^$~|(),:]+$/.test(canvasSelector)||(errors=[...errors,"Canvas selector must be defined and contain only allowed characters (a normal css selector)"]),validateTags(tags)||(errors=[...errors,"Space config tags must contain only letters, numbers and underscores"]),validate(name)||(errors=[...errors,"Space config name must be defined and contain only letters, numbers and underscores"]),errors}(name,version,scenes,canvasSelector,tags),activeErrors=function(entities){let errors=[];return Object.entries(entities).forEach(list=>{const[,key]=Object.entries(list)[0],[,value]=Object.entries(list)[1];value.filter(v=>v.isActive).length>1&&(errors=[...errors,`Must be only one active entity of "${key}", but multiple are active`])}),errors}({cameras:cameras,scenes:scenes,controls:controls}),relationsErrors=function(controls,cameras,actors,models3dEntities,models3dResources,audioResources,audio,intersections,physics){let errors=[];return controls.length>0&&0===cameras.length&&(errors=[...errors,"Controls cannot be defined without at least one camera, but there are no cameras"]),controls.every(control=>cameras.some(camera=>camera.name===control.cameraName))||(errors=[...errors,"Not every control has a camera"]),validateAllActorsHasModel3d(actors,models3dEntities)||(errors=[...errors,"Not every actor has a defined model3dSource (check actors model3dSource against models3d entities)"]),validateAllActorsWithPhysicsHasRelatedPhysicsBody(actors,physics)||(errors=[...errors,"Not every actor has a defined model3dSource (check actors model3dSource against models3d entities)"]),validateAllModel3dEntityHasValidResource(models3dEntities,models3dResources)||(errors=[...errors,"Not every model3d entity has a valid resource (must be a primitive or an url)"]),validateAllAudioEntityHasValidResource(audio,audioResources)||(errors=[...errors,"Not every audio entity has a valid resource (must be a primitive or an url)"]),validateCameraNames(intersections.filter(isIntersectionsCameraWatcherConfig))||(errors=[...errors,"Not every intersection camera name is valid"]),validateActorNamesForEveryEntity(intersections)||(errors=[...errors,"Not every intersection actor name is valid"]),errors}(controls,cameras,actors,models3dEntities,models3dResources,audioResources,audio,intersections,physics),namesErrors=function(entities){let errors=[];return Object.entries(entities).forEach(list=>{const[,key]=Object.entries(list)[0],[,value]=Object.entries(list)[1];validateNames(value)||(errors=[...errors,`Entity ("${key}") names must be defined and contain only letters, numbers and underscores`])}),errors}({scenes:scenes,spatialGrids:spatialGrids,actors:actors,cameras:cameras,intersections:intersections,lights:lights,fogs:fogs,texts:texts,controls:controls,models3dResources:models3dResources,materials:materials,envMaps:envMaps,textures:textures}),tagsErrors=function(entities){let errors=[];return Object.entries(entities).forEach(list=>{const[,key]=Object.entries(list)[0],[,value]=Object.entries(list)[1];validateTagsForEveryEntity(value)||(errors=[...errors,`Entity ("${key}") tags must contain only letters, numbers and underscores`])}),errors}({scenes:scenes,spatialGrids:spatialGrids,actors:actors,cameras:cameras,intersections:intersections,lights:lights,fogs:fogs,texts:texts,controls:controls,models3dResources:models3dResources,materials:materials,envMaps:envMaps,textures:textures}),duplicationErrors=function(entities,resources){const bodies=entities.physics?.bodies??[];return[...Object.values(entities).filter(isArray).map(validateNoSameName),validateNoSameName(bodies),...Object.values(resources).map(validateNoSameName)].filter(isDefined)}(entities,resources),urlsErrors=function(models3dResources,withFileUrls){let errors=[];return Object.entries(models3dResources).forEach(configs=>{const[,key]=Object.entries(configs)[0],[,value]=Object.entries(configs)[1];validateModel3dFileUrls(value)||(errors=[...errors,`Entity ("${key}") URLs must contain only letters, numbers and underscores`])}),Object.entries(withFileUrls).forEach(configs=>{const[,key]=Object.entries(configs)[0],[,value]=Object.entries(configs)[1];validateFileUrls(value)||(errors=[...errors,`Entity ("${key}") URLs must contain only letters, numbers and underscores`])}),errors}({models3dResources:models3dResources},{envMaps:envMaps,textures:textures}),errors=[...basicErrors,...activeErrors,...relationsErrors,...namesErrors,...tagsErrors,...duplicationErrors,...urlsErrors];return{isValid:0===errors.length,errors:errors}}(config);return{isValid:jsonResult.isValid&&dataResult.isValid,errors:[...jsonResult.errors??[],...dataResult.errors??[]]}}export{validSpaceConfig};
+//# sourceMappingURL=SchemasValidator.js.map

package/dist/Space/Validators/SchemasValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemasValidator.js","sources":["../../../src/Space/Validators/SchemasValidator.ts"],"sourcesContent":["import type { TAbstractResourceConfig } from '@Anarchy/Engine/Abstract';\nimport type { TActorConfig } from '@Anarchy/Engine/Actor';\nimport type { TAnyAudioConfig, TAudioResourceConfig } from '@Anarchy/Engine/Audio';\nimport type { TAnyCameraConfig } from '@Anarchy/Engine/Camera';\nimport type { TControlsConfig } from '@Anarchy/Engine/Controls';\nimport type { TAnyIntersectionsWatcherConfig } from '@Anarchy/Engine/Intersections';\nimport { isIntersectionsCameraWatcherConfig } from '@Anarchy/Engine/Intersections';\nimport type { TActive, TWithName, TWithNameOptional, TWithTags } from '@Anarchy/Engine/Mixins';\nimport type { TModel3dConfig, TModel3dResourceConfig } from '@Anarchy/Engine/Models3d';\nimport type { TPhysicsBodyConfig, TPhysicsConfig } from '@Anarchy/Engine/Physics';\nimport type { TSceneConfig } from '@Anarchy/Engine/Scene/Models';\nimport { SpaceSchemaVersion } from '@Anarchy/Engine/Space/Constants';\nimport type { TSpaceConfig, TSpaceConfigEntities, TSpaceConfigResources } from '@Anarchy/Engine/Space/Models';\nimport TSpaceConfigSchema from '@Anarchy/Engine/Space/Schemas/TSpaceConfig.json';\nimport {\n  validate,\n  validateActorNamesForEveryEntity,\n  validateAllActorsHasModel3d,\n  validateAllActorsWithPhysicsHasRelatedPhysicsBody,\n  validateAllAudioEntityHasValidResource,\n  validateAllModel3dEntityHasValidResource,\n  validateCameraNames,\n  validateFileUrls,\n  validateModel3dFileUrls,\n  validateNames,\n  validateNoSameName,\n  validateTags,\n  validateTagsForEveryEntity\n} from '@Anarchy/Engine/Space/Utils';\nimport { isDefined } from '@Anarchy/Shared/Utils';\nimport type { Schema } from '@cfworker/json-schema';\nimport { Validator } from '@cfworker/json-schema';\nimport { isArray } from 'lodash-es';\n\ntype TSchemaValidationResult = Readonly<{ isValid: boolean; errors: ReadonlyArray<any> | null | undefined }>;\n\nexport function validSpaceConfig(config: TSpaceConfig): TSchemaValidationResult {\n  const jsonResult = validateJsonSchema(config);\n  const dataResult = validateData(config);\n  const jsonErrors: ReadonlyArray<any> = jsonResult.errors ?? [];\n  const dataErrors: ReadonlyArray<any> = dataResult.errors ?? [];\n\n  return { isValid: jsonResult.isValid && dataResult.isValid, errors: [...jsonErrors, ...dataErrors] };\n}\n\nfunction validateJsonSchema(config: TSpaceConfig): TSchemaValidationResult {\n  const validator = new Validator(TSpaceConfigSchema as Schema, '7');\n  const { valid, errors } = validator.validate(config);\n  return { isValid: valid, errors };\n}\n\nfunction validateData({ name, version, scenes, resources, entities, canvasSelector, tags }: TSpaceConfig): TSchemaValidationResult {\n  const { models3d: models3dResources, audio: audioResources, envMaps, textures } = resources;\n  const { actors, audio, cameras, spatialGrids, controls, intersections, lights, materials, models3d: models3dEntities, physics, fogs, texts } = entities;\n\n  const basicErrors: ReadonlyArray<string> = validateConfigBasics(name, version, scenes, canvasSelector, tags);\n  const activeErrors: ReadonlyArray<string> = validateActiveEntities({ cameras, scenes, controls });\n  const relationsErrors: ReadonlyArray<string> = validateRelations(controls, cameras, actors, models3dEntities, models3dResources, audioResources, audio, intersections, physics);\n  const namesErrors: ReadonlyArray<string> = validateEntityNames({\n    scenes,\n    spatialGrids,\n    actors,\n    cameras,\n    intersections,\n    lights,\n    fogs,\n    texts,\n    controls,\n    models3dResources,\n    materials,\n    envMaps,\n    textures\n  });\n  const tagsErrors: ReadonlyArray<string> = validateEntityTags({\n    scenes,\n    spatialGrids,\n    actors,\n    cameras,\n    intersections,\n    lights,\n    fogs,\n    texts,\n    controls,\n    models3dResources,\n    materials,\n    envMaps,\n    textures\n  });\n  const duplicationErrors: ReadonlyArray<string> = validateNamesDuplication(entities, resources);\n  const urlsErrors: ReadonlyArray<string> = validateUrls({ models3dResources }, { envMaps, textures });\n\n  const errors: ReadonlyArray<string> = [...basicErrors, ...activeErrors, ...relationsErrors, ...namesErrors, ...tagsErrors, ...duplicationErrors, ...urlsErrors];\n\n  return { isValid: errors.length === 0, errors };\n}\n\nfunction validateConfigBasics(name: string, version: SpaceSchemaVersion, scenes: ReadonlyArray<TSceneConfig>, canvasSelector: string, tags?: ReadonlyArray<string>): ReadonlyArray<string> {\n  let errors: ReadonlyArray<string> = [];\n\n  if (version !== SpaceSchemaVersion.V1) errors = [...errors, `Unsupported schema's version(${version}). Supported version is: ${SpaceSchemaVersion.V2}`];\n  if (scenes.length === 0) errors = [...errors, 'No scenes are defined'];\n  if (!/^[a-zA-Z0-9\\s.#\\-_>[\\]='\"*^$~|(),:]+$/.test(canvasSelector)) errors = [...errors, 'Canvas selector must be defined and contain only allowed characters (a normal css selector)'];\n  if (!validateTags(tags)) errors = [...errors, 'Space config tags must contain only letters, numbers and underscores'];\n  if (!validate(name)) errors = [...errors, 'Space config name must be defined and contain only letters, numbers and underscores'];\n\n  return errors;\n}\n\nfunction validateActiveEntities(entities: Record<string, ReadonlyArray<TActive>>): ReadonlyArray<string> {\n  let errors: ReadonlyArray<string> = [];\n\n  Object.entries(entities).forEach((list): void => {\n    const [, key] = Object.entries(list)[0];\n    const [, value] = Object.entries(list)[1];\n\n    if ((value as ReadonlyArray<TActive>).filter((v: TActive): boolean => v.isActive).length > 1) errors = [...errors, `Must be only one active entity of \"${key}\", but multiple are active`];\n  });\n\n  return errors;\n}\n\nfunction validateRelations(\n  controls: ReadonlyArray<TControlsConfig>,\n  cameras: ReadonlyArray<TAnyCameraConfig>,\n  actors: ReadonlyArray<TActorConfig>,\n  models3dEntities: ReadonlyArray<TModel3dConfig>,\n  models3dResources: ReadonlyArray<TModel3dResourceConfig>,\n  audioResources: ReadonlyArray<TAudioResourceConfig>,\n  audio: ReadonlyArray<TAnyAudioConfig>,\n  intersections: ReadonlyArray<TAnyIntersectionsWatcherConfig>,\n  physics: TPhysicsConfig\n): ReadonlyArray<string> {\n  let errors: ReadonlyArray<string> = [];\n\n  if (controls.length > 0 && cameras.length === 0) errors = [...errors, 'Controls cannot be defined without at least one camera, but there are no cameras'];\n  if (!controls.every((control: TControlsConfig): boolean => cameras.some((camera: TAnyCameraConfig): boolean => camera.name === control.cameraName)))\n    errors = [...errors, 'Not every control has a camera'];\n  if (!validateAllActorsHasModel3d(actors, models3dEntities)) errors = [...errors, 'Not every actor has a defined model3dSource (check actors model3dSource against models3d entities)'];\n  if (!validateAllActorsWithPhysicsHasRelatedPhysicsBody(actors, physics)) errors = [...errors, 'Not every actor has a defined model3dSource (check actors model3dSource against models3d entities)'];\n  if (!validateAllModel3dEntityHasValidResource(models3dEntities, models3dResources)) errors = [...errors, 'Not every model3d entity has a valid resource (must be a primitive or an url)'];\n  if (!validateAllAudioEntityHasValidResource(audio, audioResources)) errors = [...errors, 'Not every audio entity has a valid resource (must be a primitive or an url)'];\n  if (!validateCameraNames(intersections.filter(isIntersectionsCameraWatcherConfig))) errors = [...errors, 'Not every intersection camera name is valid'];\n  if (!validateActorNamesForEveryEntity(intersections)) errors = [...errors, 'Not every intersection actor name is valid'];\n\n  return errors;\n}\n\nfunction validateEntityNames(entities: Record<string, ReadonlyArray<TWithNameOptional | TWithName>>): ReadonlyArray<string> {\n  let errors: ReadonlyArray<string> = [];\n\n  Object.entries(entities).forEach((list): void => {\n    const [, key] = Object.entries(list)[0];\n    const [, value] = Object.entries(list)[1];\n\n    const isValid: boolean = validateNames(value as ReadonlyArray<TWithNameOptional | TWithName>);\n    if (!isValid) errors = [...errors, `Entity (\"${key}\") names must be defined and contain only letters, numbers and underscores`];\n  });\n\n  return errors;\n}\n\nfunction validateEntityTags(entities: Record<string, ReadonlyArray<TWithTags>>): ReadonlyArray<string> {\n  let errors: ReadonlyArray<string> = [];\n\n  Object.entries(entities).forEach((list): void => {\n    const [, key] = Object.entries(list)[0];\n    const [, value] = Object.entries(list)[1];\n\n    const isValid: boolean = validateTagsForEveryEntity(value as ReadonlyArray<Record<string, TWithTags>>);\n    if (!isValid) errors = [...errors, `Entity (\"${key}\") tags must contain only letters, numbers and underscores`];\n  });\n\n  return errors;\n}\n\nfunction validateNamesDuplication(entities: TSpaceConfigEntities, resources: TSpaceConfigResources): ReadonlyArray<string> {\n  const bodies: ReadonlyArray<TPhysicsBodyConfig> = entities.physics?.bodies ?? [];\n\n  return [\n    //\"physics\" is not an array, but we could check the bodies\n    ...Object.values(entities).filter(isArray).map(validateNoSameName),\n    validateNoSameName(bodies),\n    ...Object.values(resources).map(validateNoSameName)\n  ].filter(isDefined);\n}\n\nfunction validateUrls(models3dResources: Record<string, ReadonlyArray<TModel3dResourceConfig>>, withFileUrls: Record<string, ReadonlyArray<TAbstractResourceConfig>>): ReadonlyArray<string> {\n  let errors: ReadonlyArray<string> = [];\n\n  Object.entries(models3dResources).forEach((configs): void => {\n    const [, key] = Object.entries(configs)[0];\n    const [, value] = Object.entries(configs)[1];\n    const isValid: boolean = validateModel3dFileUrls(value as ReadonlyArray<TModel3dResourceConfig>);\n    if (!isValid) errors = [...errors, `Entity (\"${key}\") URLs must contain only letters, numbers and underscores`];\n  });\n\n  Object.entries(withFileUrls).forEach((configs): void => {\n    const [, key] = Object.entries(configs)[0];\n    const [, value] = Object.entries(configs)[1];\n    const isValid: boolean = validateFileUrls(value as ReadonlyArray<TAbstractResourceConfig>);\n    if (!isValid) errors = [...errors, `Entity (\"${key}\") URLs must contain only letters, numbers and underscores`];\n  });\n\n  return errors;\n}\n"],"names":["validSpaceConfig","config","jsonResult","validator","Validator","TSpaceConfigSchema","valid","errors","validate","isValid","validateJsonSchema","dataResult","name","version","scenes","resources","entities","canvasSelector","tags","models3d","models3dResources","audio","audioResources","envMaps","textures","actors","cameras","spatialGrids","controls","intersections","lights","materials","models3dEntities","physics","fogs","texts","basicErrors","SpaceSchemaVersion","V1","V2","length","test","validateTags","validateConfigBasics","activeErrors","Object","entries","forEach","list","key","value","filter","v","isActive","validateActiveEntities","relationsErrors","every","control","some","camera","cameraName","validateAllActorsHasModel3d","validateAllActorsWithPhysicsHasRelatedPhysicsBody","validateAllModel3dEntityHasValidResource","validateAllAudioEntityHasValidResource","validateCameraNames","isIntersectionsCameraWatcherConfig","validateActorNamesForEveryEntity","validateRelations","namesErrors","validateNames","validateEntityNames","tagsErrors","validateTagsForEveryEntity","validateEntityTags","duplicationErrors","bodies","values","isArray","map","validateNoSameName","isDefined","validateNamesDuplication","urlsErrors","withFileUrls","configs","validateModel3dFileUrls","validateFileUrls","validateUrls","validateData"],"mappings":"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"}

package/dist/Space/Validators/ValidateConfig.js

@@ -0,0 +1,2 @@
+import{validSpaceConfig}from"./SchemasValidator.js";function validateConfig(config){const{isValid:isValid,errors:errors}=validSpaceConfig(config);if(!isValid)throw console.error(errors),new Error("Failed to launch a space: invalid data format")}export{validateConfig};
+//# sourceMappingURL=ValidateConfig.js.map

package/dist/Space/Validators/ValidateConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidateConfig.js","sources":["../../../src/Space/Validators/ValidateConfig.ts"],"sourcesContent":["import type { TSpaceConfig } from '@Anarchy/Engine/Space/Models';\nimport { validSpaceConfig } from '@Anarchy/Engine/Space/Validators/SchemasValidator';\n\nexport function validateConfig(config: TSpaceConfig): void | never {\n  const { isValid, errors } = validSpaceConfig(config);\n  if (!isValid) {\n    // TODO LOGGER: should be forwarded to the errors hub (which is not implemented yet)\n    console.error(errors);\n    throw new Error('Failed to launch a space: invalid data format');\n  }\n}\n"],"names":["validateConfig","config","isValid","errors","validSpaceConfig","console","error","Error"],"mappings":"oDAGO,SAASA,eAAeC,QAC7B,MAAMC,QAAEA,QAAAC,OAASA,QAAWC,iBAAiBH,QAC7C,IAAKC,QAGH,MADAG,QAAQC,MAAMH,QACR,IAAII,MAAM,gDAEpB"}

package/dist/Space/Validators/ValidateSpace.js

@@ -0,0 +1,2 @@
+import{isNotDefined}from"../../packages/anarchy-shared/src/Utils/CheckUtils.js";function validateSpacesDoNotUseSameCanvas(registry,space){const duplicates=registry.find(s=>Object.is(s.getCanvasElement(),space.getCanvasElement()));return isNotDefined(duplicates)}export{validateSpacesDoNotUseSameCanvas};
+//# sourceMappingURL=ValidateSpace.js.map

package/dist/Space/Validators/ValidateSpace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidateSpace.js","sources":["../../../src/Space/Validators/ValidateSpace.ts"],"sourcesContent":["import type { TSpace, TSpaceRegistry } from '@Anarchy/Engine/Space/Models';\nimport { isNotDefined } from '@Anarchy/Shared/Utils';\n\nexport function validateSpacesDoNotUseSameCanvas(registry: TSpaceRegistry, space: TSpace): boolean {\n  const duplicates: TSpace | undefined = registry.find((s: TSpace): boolean => Object.is(s.getCanvasElement(), space.getCanvasElement()));\n  return isNotDefined(duplicates);\n}\n"],"names":["validateSpacesDoNotUseSameCanvas","registry","space","duplicates","find","s","Object","is","getCanvasElement","isNotDefined"],"mappings":"gFAGO,SAASA,iCAAiCC,SAA0BC,OACzE,MAAMC,WAAiCF,SAASG,KAAMC,GAAuBC,OAAOC,GAAGF,EAAEG,mBAAoBN,MAAMM,qBACnH,OAAOC,aAAaN,WACtB"}

package/dist/Spatial/Adapters/ConfigToParams.js

@@ -0,0 +1,2 @@
+function configToParamsSpatial(config){return{...config}}export{configToParamsSpatial};
+//# sourceMappingURL=ConfigToParams.js.map

package/dist/Spatial/Adapters/ConfigToParams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigToParams.js","sources":["../../../src/Spatial/Adapters/ConfigToParams.ts"],"sourcesContent":["import type { TSpatialGridConfig, TSpatialGridParams } from '@Anarchy/Engine/Spatial/Models';\n\nexport function configToParamsSpatial(config: TSpatialGridConfig): TSpatialGridParams {\n  return {\n    ...config\n  };\n}\n"],"names":["configToParamsSpatial","config"],"mappings":"AAEO,SAASA,sBAAsBC,QACpC,MAAO,IACFA,OAEP"}

package/dist/Spatial/Adapters/ConfigToParamsSpatialData.js

@@ -0,0 +1,2 @@
+function configToParamsSpatialData(config,{spatialGridRegistry:spatialGridRegistry}){return{...config,grid:config.grid?spatialGridRegistry.getByName(config.grid):void 0}}export{configToParamsSpatialData};
+//# sourceMappingURL=ConfigToParamsSpatialData.js.map

package/dist/Spatial/Adapters/ConfigToParamsSpatialData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigToParamsSpatialData.js","sources":["../../../src/Spatial/Adapters/ConfigToParamsSpatialData.ts"],"sourcesContent":["import type { TSpatialConfigToParamsSpatialDataDependencies, TSpatialDataConfig, TSpatialDataParams } from '@Anarchy/Engine/Spatial/Models';\n\nexport function configToParamsSpatialData(config: TSpatialDataConfig, { spatialGridRegistry }: TSpatialConfigToParamsSpatialDataDependencies): TSpatialDataParams {\n  return {\n    ...config,\n    grid: config.grid ? spatialGridRegistry.getByName(config.grid) : undefined\n  };\n}\n"],"names":["configToParamsSpatialData","config","spatialGridRegistry","grid","getByName"],"mappings":"AAEO,SAASA,0BAA0BC,QAA4BC,oBAAEA,sBACtE,MAAO,IACFD,OACHE,KAAMF,OAAOE,KAAOD,oBAAoBE,UAAUH,OAAOE,WAAQ,EAErE"}

package/dist/Spatial/Adapters/EntityToConfig.js

@@ -0,0 +1,2 @@
+import{filterOutEmptyFields}from"../../packages/anarchy-shared/src/Utils/ObjectUtils.js";import{extractSerializableRegistrableFields}from"../../Mixins/Generics/ExtractSerializableRegistrableFields.js";function entityToConfigSpatialGrid(entity){return filterOutEmptyFields({...entity.getParams(),...extractSerializableRegistrableFields(entity)})}function entityToConfigSpatialCell(entity){const{minX:minX,minY:minY,maxX:maxX,maxY:maxY}=entity,objects=entity.getObjects().map(v=>v.id);return filterOutEmptyFields({id:entity.id,minX:minX,minY:minY,maxX:maxX,maxY:maxY,objects:objects,version:entity.getVersion()})}export{entityToConfigSpatialCell,entityToConfigSpatialGrid};
+//# sourceMappingURL=EntityToConfig.js.map

package/dist/Spatial/Adapters/EntityToConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityToConfig.js","sources":["../../../src/Spatial/Adapters/EntityToConfig.ts"],"sourcesContent":["import type { TActor } from '@Anarchy/Engine/Actor';\nimport { extractSerializableRegistrableFields } from '@Anarchy/Engine/Mixins';\nimport type { TSpatialCellId, TSpatialCellSerializedData, TSpatialCellWrapper, TSpatialGridConfig, TSpatialGridWrapper } from '@Anarchy/Engine/Spatial/Models';\nimport { filterOutEmptyFields } from '@Anarchy/Shared/Utils';\n\nexport function entityToConfigSpatialGrid(entity: TSpatialGridWrapper): TSpatialGridConfig {\n  return filterOutEmptyFields({\n    ...entity.getParams(),\n    ...extractSerializableRegistrableFields(entity)\n  });\n}\n\nexport function entityToConfigSpatialCell(entity: TSpatialCellWrapper): TSpatialCellSerializedData {\n  const { minX, minY, maxX, maxY } = entity;\n  const objects: ReadonlyArray<string> = entity.getObjects().map((v: TActor): string => v.id);\n  const id: TSpatialCellId = entity.id as TSpatialCellId;\n  return filterOutEmptyFields({ id, minX, minY, maxX, maxY, objects, version: entity.getVersion() });\n}\n"],"names":["entityToConfigSpatialGrid","entity","filterOutEmptyFields","getParams","extractSerializableRegistrableFields","entityToConfigSpatialCell","minX","minY","maxX","maxY","objects","getObjects","map","v","id","version","getVersion"],"mappings":"yMAKO,SAASA,0BAA0BC,QACxC,OAAOC,qBAAqB,IACvBD,OAAOE,eACPC,qCAAqCH,SAE5C,CAEO,SAASI,0BAA0BJ,QACxC,MAAMK,KAAEA,KAAAC,KAAMA,KAAAC,KAAMA,KAAAC,KAAMA,MAASR,OAC7BS,QAAiCT,OAAOU,aAAaC,IAAKC,GAAsBA,EAAEC,IAExF,OAAOZ,qBAAqB,CAAEY,GADHb,OAAOa,GACAR,UAAMC,UAAMC,UAAMC,UAAMC,gBAASK,QAASd,OAAOe,cACrF"}

package/dist/Spatial/Factories/SpatialGridFactory.js

@@ -0,0 +1,2 @@
+import{ReactiveFactory}from"../../Abstract/Factories/ReactiveFactory.js";import{FactoryType}from"../../Abstract/Constants/FactoryType.js";import{configToParamsSpatial}from"../Adapters/ConfigToParams.js";import{SpatialGridWrapper}from"../Wrappers/SpatialGridWrapper.js";function SpatialGridFactory(){const factory=ReactiveFactory(FactoryType.SpatialGrid,SpatialGridWrapper);return Object.assign(factory,{configToParams:configToParamsSpatial})}export{SpatialGridFactory};
+//# sourceMappingURL=SpatialGridFactory.js.map

package/dist/Spatial/Factories/SpatialGridFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpatialGridFactory.js","sources":["../../../src/Spatial/Factories/SpatialGridFactory.ts"],"sourcesContent":["import type { TReactiveFactory } from '@Anarchy/Engine/Abstract';\nimport { FactoryType, ReactiveFactory } from '@Anarchy/Engine/Abstract';\nimport { configToParamsSpatial as configToParams } from '@Anarchy/Engine/Spatial/Adapters';\nimport type { TSpatialGridFactory, TSpatialGridParams, TSpatialGridWrapper } from '@Anarchy/Engine/Spatial/Models';\nimport { SpatialGridWrapper } from '@Anarchy/Engine/Spatial/Wrappers';\n\nexport function SpatialGridFactory(): TSpatialGridFactory {\n  const factory: TReactiveFactory<TSpatialGridWrapper, TSpatialGridParams> = ReactiveFactory(FactoryType.SpatialGrid, SpatialGridWrapper);\n\n  // eslint-disable-next-line functional/immutable-data\n  return Object.assign(factory, { configToParams });\n}\n"],"names":["SpatialGridFactory","factory","ReactiveFactory","FactoryType","SpatialGrid","SpatialGridWrapper","Object","assign","configToParams"],"mappings":"6QAMO,SAASA,qBACd,MAAMC,QAAqEC,gBAAgBC,YAAYC,YAAaC,oBAGpH,OAAOC,OAAOC,OAAON,QAAS,CAAAO,eAAEA,uBAClC"}

package/dist/Spatial/Mixins/WithReactivePosition.js

@@ -0,0 +1,2 @@
+import{Vector3}from"three";import{Subject}from"../../node_modules/rxjs/dist/esm5/internal/Subject.js";function withReactivePosition(entity){const position$=new Subject;let prevPosition=new Vector3;return{value$:position$,update:function(){if(prevPosition.equals(entity.position))return;const newPosition=entity.position.clone();position$.next(newPosition),prevPosition=newPosition}}}export{withReactivePosition};
+//# sourceMappingURL=WithReactivePosition.js.map

package/dist/Spatial/Mixins/WithReactivePosition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WithReactivePosition.js","sources":["../../../src/Spatial/Mixins/WithReactivePosition.ts"],"sourcesContent":["import type { TWithReactivePosition } from '@Anarchy/Engine/Spatial/Models';\nimport { Subject } from 'rxjs';\nimport type { Group, Mesh, Object3D } from 'three';\nimport { Vector3 } from 'three';\n\nexport function withReactivePosition(entity: Mesh | Group | Object3D): TWithReactivePosition {\n  const position$: Subject<Vector3> = new Subject<Vector3>();\n  let prevPosition: Vector3 = new Vector3();\n\n  function update(): void {\n    if (prevPosition.equals(entity.position)) return;\n\n    const newPosition: Vector3 = entity.position.clone();\n    position$.next(newPosition);\n    prevPosition = newPosition;\n  }\n\n  return { value$: position$, update };\n}\n"],"names":["withReactivePosition","entity","position$","Subject","prevPosition","Vector3","value$","update","equals","position","newPosition","clone","next"],"mappings":"sGAKO,SAASA,qBAAqBC,QACnC,MAAMC,UAA8B,IAAIC,QACxC,IAAIC,aAAwB,IAAIC,QAUhC,MAAO,CAAEC,OAAQJ,UAAWK,OAR5B,WACE,GAAIH,aAAaI,OAAOP,OAAOQ,UAAW,OAE1C,MAAMC,YAAuBT,OAAOQ,SAASE,QAC7CT,UAAUU,KAAKF,aACfN,aAAeM,WACjB,EAGF"}

package/dist/Spatial/Mixins/WithReactiveRotation.js

@@ -0,0 +1,2 @@
+import{Euler}from"three";import{Subject}from"../../node_modules/rxjs/dist/esm5/internal/Subject.js";function withReactiveRotation(entity){const rotation$=new Subject;let prevRotation=new Euler;return{value$:rotation$,update:function(){if(prevRotation.equals(entity.rotation))return;const newRotation=entity.rotation.clone();rotation$.next(newRotation),prevRotation=newRotation}}}export{withReactiveRotation};
+//# sourceMappingURL=WithReactiveRotation.js.map

package/dist/Spatial/Mixins/WithReactiveRotation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WithReactiveRotation.js","sources":["../../../src/Spatial/Mixins/WithReactiveRotation.ts"],"sourcesContent":["import type { TWithReactiveRotation } from '@Anarchy/Engine/Spatial/Models';\nimport { Subject } from 'rxjs';\nimport type { Group, Mesh, Object3D } from 'three';\nimport { Euler } from 'three';\n\nexport function withReactiveRotation(entity: Mesh | Group | Object3D): TWithReactiveRotation {\n  const rotation$: Subject<Euler> = new Subject<Euler>();\n  let prevRotation: Euler = new Euler();\n\n  function update(): void {\n    if (prevRotation.equals(entity.rotation)) return;\n\n    const newRotation: Euler = entity.rotation.clone();\n    rotation$.next(newRotation);\n    prevRotation = newRotation;\n  }\n\n  return { value$: rotation$, update };\n}\n"],"names":["withReactiveRotation","entity","rotation$","Subject","prevRotation","Euler","value$","update","equals","rotation","newRotation","clone","next"],"mappings":"oGAKO,SAASA,qBAAqBC,QACnC,MAAMC,UAA4B,IAAIC,QACtC,IAAIC,aAAsB,IAAIC,MAU9B,MAAO,CAAEC,OAAQJ,UAAWK,OAR5B,WACE,GAAIH,aAAaI,OAAOP,OAAOQ,UAAW,OAE1C,MAAMC,YAAqBT,OAAOQ,SAASE,QAC3CT,UAAUU,KAAKF,aACfN,aAAeM,WACjB,EAGF"}

package/dist/Spatial/Mixins/WithSpatial.js

@@ -0,0 +1,2 @@
+import{BehaviorSubject}from"../../node_modules/rxjs/dist/esm5/internal/BehaviorSubject.js";import{Subject}from"../../node_modules/rxjs/dist/esm5/internal/Subject.js";import{LoopUpdatePriority}from"../../Loop/Constants/LoopUpdatePriority.js";import{destroyableMixin}from"../../Mixins/Generics/DestroyableMixin.js";function withSpatial(params){const autoUpdate$=new BehaviorSubject(params.spatial.isAutoUpdate),cellsChanged$=new Subject,destroyable=destroyableMixin(),result={spatial:{data:{updatePriority:params.spatial.updatePriority??LoopUpdatePriority.LOW,grid:params.spatial.grid||void 0,cells:[]},setData({updatePriority:updatePriority,cells:cells}){this.setSpatialUpdatePriority(updatePriority),this.setSpatialCells(cells)},getData(){return this.data},setSpatialUpdatePriority(value){this.data.updatePriority=value},getSpatialUpdatePriority(){return this.data.updatePriority},setGrid(grid){this.data.grid=grid},getGrid(){return this.data.grid},resetGrid(){this.setGrid(void 0)},getSpatialCells(){return this.data.cells},setSpatialCells(cells){this.data.cells=cells,cellsChanged$.next(cells)},resetSpatialCells(){this.setSpatialCells([])},...destroyable,autoUpdate$:autoUpdate$,cellsChanged$:cellsChanged$.asObservable()}},destroySub$=destroyable.destroy$.subscribe(()=>{destroySub$.unsubscribe(),result.spatial.resetGrid(),result.spatial.resetSpatialCells(),cellsChanged$.complete()});return result}export{withSpatial};
+//# sourceMappingURL=WithSpatial.js.map

package/dist/Spatial/Mixins/WithSpatial.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WithSpatial.js","sources":["../../../src/Spatial/Mixins/WithSpatial.ts"],"sourcesContent":["import type { TActorParams } from '@Anarchy/Engine/Actor';\nimport { LoopUpdatePriority } from '@Anarchy/Engine/Loop';\nimport type { TDestroyable } from '@Anarchy/Engine/Mixins';\nimport { destroyableMixin } from '@Anarchy/Engine/Mixins';\nimport type { TSpatialCellWrapper, TSpatialData, TSpatialGridWrapper, TWithSpatial } from '@Anarchy/Engine/Spatial/Models';\nimport type { TWriteable } from '@Anarchy/Shared/Utils';\nimport type { Subscription } from 'rxjs';\nimport { BehaviorSubject, Subject } from 'rxjs';\n\nexport function withSpatial(params: TActorParams): TWithSpatial {\n  const autoUpdate$: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(params.spatial.isAutoUpdate);\n  const cellsChanged$: Subject<ReadonlyArray<TSpatialCellWrapper>> = new Subject<ReadonlyArray<TSpatialCellWrapper>>();\n\n  const destroyable: TDestroyable = destroyableMixin();\n\n  const result: TWithSpatial = {\n    spatial: {\n      data: {\n        updatePriority: params.spatial.updatePriority ?? LoopUpdatePriority.LOW,\n        grid: params.spatial.grid || undefined,\n        cells: []\n      },\n      setData({ updatePriority, cells }: TSpatialData): void {\n        this.setSpatialUpdatePriority(updatePriority);\n        this.setSpatialCells(cells);\n      },\n      getData(): TSpatialData {\n        return this.data;\n      },\n      setSpatialUpdatePriority(value: LoopUpdatePriority): void {\n        // eslint-disable-next-line functional/immutable-data\n        (this.data as TWriteable<TSpatialData>).updatePriority = value;\n      },\n      getSpatialUpdatePriority(): LoopUpdatePriority {\n        return this.data.updatePriority;\n      },\n      setGrid(grid: TSpatialGridWrapper): void {\n        // eslint-disable-next-line functional/immutable-data\n        (this.data as TWriteable<TSpatialData>).grid = grid;\n      },\n      getGrid(): TSpatialGridWrapper | undefined {\n        return this.data.grid;\n      },\n      resetGrid(): void {\n        this.setGrid(undefined as unknown as TSpatialGridWrapper);\n      },\n      getSpatialCells(): ReadonlyArray<TSpatialCellWrapper> {\n        return this.data.cells;\n      },\n      setSpatialCells(cells: ReadonlyArray<TSpatialCellWrapper>): void {\n        // eslint-disable-next-line functional/immutable-data\n        (this.data as TWriteable<TSpatialData>).cells = cells;\n        cellsChanged$.next(cells);\n      },\n      resetSpatialCells(): void {\n        this.setSpatialCells([]);\n      },\n      ...destroyable,\n      autoUpdate$,\n      cellsChanged$: cellsChanged$.asObservable()\n    }\n  };\n\n  const destroySub$: Subscription = destroyable.destroy$.subscribe((): void => {\n    destroySub$.unsubscribe();\n\n    result.spatial.resetGrid();\n    result.spatial.resetSpatialCells();\n    cellsChanged$.complete();\n  });\n\n  return result;\n}\n"],"names":["withSpatial","params","autoUpdate$","BehaviorSubject","spatial","isAutoUpdate","cellsChanged$","Subject","destroyable","destroyableMixin","result","data","updatePriority","LoopUpdatePriority","LOW","grid","cells","setData","this","setSpatialUpdatePriority","setSpatialCells","getData","value","getSpatialUpdatePriority","setGrid","getGrid","resetGrid","getSpatialCells","next","resetSpatialCells","asObservable","destroySub$","destroy$","subscribe","unsubscribe","complete"],"mappings":"yTASO,SAASA,YAAYC,QAC1B,MAAMC,YAAwC,IAAIC,gBAAyBF,OAAOG,QAAQC,cACpFC,cAA6D,IAAIC,QAEjEC,YAA4BC,mBAE5BC,OAAuB,CAC3BN,QAAS,CACPO,KAAM,CACJC,eAAgBX,OAAOG,QAAQQ,gBAAkBC,mBAAmBC,IACpEC,KAAMd,OAAOG,QAAQW,WAAQ,EAC7BC,MAAO,IAET,OAAAC,EAAQL,eAAEA,eAAAI,MAAgBA,QACxBE,KAAKC,yBAAyBP,gBAC9BM,KAAKE,gBAAgBJ,MACvB,EACA,OAAAK,GACE,OAAOH,KAAKP,IACd,EACA,wBAAAQ,CAAyBG,OAEtBJ,KAAKP,KAAkCC,eAAiBU,KAC3D,EACA,wBAAAC,GACE,OAAOL,KAAKP,KAAKC,cACnB,EACA,OAAAY,CAAQT,MAELG,KAAKP,KAAkCI,KAAOA,IACjD,EACA,OAAAU,GACE,OAAOP,KAAKP,KAAKI,IACnB,EACA,SAAAW,GACER,KAAKM,eACP,EACA,eAAAG,GACE,OAAOT,KAAKP,KAAKK,KACnB,EACA,eAAAI,CAAgBJ,OAEbE,KAAKP,KAAkCK,MAAQA,MAChDV,cAAcsB,KAAKZ,MACrB,EACA,iBAAAa,GACEX,KAAKE,gBAAgB,GACvB,KACGZ,YACHN,wBACAI,cAAeA,cAAcwB,iBAI3BC,YAA4BvB,YAAYwB,SAASC,UAAU,KAC/DF,YAAYG,cAEZxB,OAAON,QAAQsB,YACfhB,OAAON,QAAQyB,oBACfvB,cAAc6B,aAGhB,OAAOzB,MACT"}

package/dist/Spatial/Mixins/WithUpdateSpatialCell.js

@@ -0,0 +1,2 @@
+import{isNotDefined,isDefined}from"../../packages/anarchy-shared/src/Utils/CheckUtils.js";function withUpdateSpatialCell(){let prevCells=[];return{updateSpatialCells:function(newPosition){const grid=this.spatial.getGrid();if(isNotDefined(grid))throw new Error(`Grid is not defined for Actor name: "${this.name}", id: "${this.id}"`);const cells=this.spatial.getSpatialCells();if(0===prevCells.length)return void(prevCells=cells.map(({maxX:maxX,maxY:maxY,minX:minX,minY:minY})=>({maxX:maxX,maxY:maxY,minX:minX,minY:minY})));const isOutside=({minX:minX,minY:minY,maxX:maxX,maxY:maxY},newPosition2)=>newPosition2.x<minX||newPosition2.x>maxX||newPosition2.z<minY||newPosition2.z>maxY;for(let index=0;index<cells.length;index++)if(isDefined(prevCells[index])&&isOutside(prevCells[index],newPosition)){if(isNotDefined(grid))throw new Error(`Cannot update actor's (id: "${this.id}") spatial grid's cell: grid is not defined`);grid.updateActorCell(this)}prevCells=cells.map(({maxX:maxX,maxY:maxY,minX:minX,minY:minY})=>({maxX:maxX,maxY:maxY,minX:minX,minY:minY}))}}}export{withUpdateSpatialCell};
+//# sourceMappingURL=WithUpdateSpatialCell.js.map

package/dist/Spatial/Mixins/WithUpdateSpatialCell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WithUpdateSpatialCell.js","sources":["../../../src/Spatial/Mixins/WithUpdateSpatialCell.ts"],"sourcesContent":["import type { TActor } from '@Anarchy/Engine/Actor';\nimport type { TSpatialCell, TSpatialCellWrapper, TSpatialGridWrapper, TWithUpdateSpatialCell } from '@Anarchy/Engine/Spatial/Models';\nimport type { TReadonlyVector3 } from '@Anarchy/Engine/ThreeLib';\nimport { isDefined, isNotDefined } from '@Anarchy/Shared/Utils';\n\nexport function withUpdateSpatialCell(): TWithUpdateSpatialCell {\n  let prevCells: ReadonlyArray<Pick<TSpatialCell, 'maxX' | 'maxY' | 'minX' | 'minY'>> = [];\n\n  function updateSpatialCells(this: TActor, newPosition: TReadonlyVector3): void | never {\n    const grid: TSpatialGridWrapper | undefined = this.spatial.getGrid();\n    if (isNotDefined(grid)) throw new Error(`Grid is not defined for Actor name: \"${this.name}\", id: \"${this.id}\"`);\n    const cells: ReadonlyArray<TSpatialCellWrapper> = this.spatial.getSpatialCells();\n\n    //first run\n    if (prevCells.length === 0) {\n      prevCells = cells.map(({ maxX, maxY, minX, minY }: TSpatialCellWrapper): Pick<TSpatialCell, 'maxX' | 'maxY' | 'minX' | 'minY'> => ({ maxX, maxY, minX, minY }));\n      return;\n    }\n\n    const isOutside = ({ minX, minY, maxX, maxY }: Pick<TSpatialCell, 'maxX' | 'maxY' | 'minX' | 'minY'>, newPosition: TReadonlyVector3): boolean => {\n      return newPosition.x < minX || newPosition.x > maxX || newPosition.z < minY || newPosition.z > maxY;\n    };\n\n    // eslint-disable-next-line functional/no-loop-statements\n    for (let index: number = 0; index < cells.length; index++) {\n      if (isDefined(prevCells[index]) && isOutside(prevCells[index], newPosition)) {\n        if (isNotDefined(grid)) throw new Error(`Cannot update actor's (id: \"${this.id}\") spatial grid's cell: grid is not defined`);\n        grid.updateActorCell(this);\n      }\n    }\n\n    prevCells = cells.map(({ maxX, maxY, minX, minY }: TSpatialCellWrapper) => ({ maxX, maxY, minX, minY }));\n  }\n\n  return {\n    updateSpatialCells\n  };\n}\n"],"names":["withUpdateSpatialCell","prevCells","updateSpatialCells","newPosition","grid","this","spatial","getGrid","isNotDefined","Error","name","id","cells","getSpatialCells","length","map","maxX","maxY","minX","minY","isOutside","x","z","index","isDefined","updateActorCell"],"mappings":"0FAKO,SAASA,wBACd,IAAIC,UAAkF,GA4BtF,MAAO,CACLC,mBA3BF,SAA0CC,aACxC,MAAMC,KAAwCC,KAAKC,QAAQC,UAC3D,GAAIC,aAAaJ,MAAO,MAAM,IAAIK,MAAM,wCAAwCJ,KAAKK,eAAeL,KAAKM,OACzG,MAAMC,MAA4CP,KAAKC,QAAQO,kBAG/D,GAAyB,IAArBZ,UAAUa,OAEZ,YADAb,UAAYW,MAAMG,IAAI,EAAGC,UAAMC,UAAMC,UAAMC,cAAK,CAAqFH,UAAMC,UAAMC,UAAMC,cAIzJ,MAAMC,UAAY,EAAGF,UAAMC,UAAMH,UAAMC,WAA+Dd,eAC7FA,aAAYkB,EAAIH,MAAQf,aAAYkB,EAAIL,MAAQb,aAAYmB,EAAIH,MAAQhB,aAAYmB,EAAIL,KAIjG,IAAA,IAASM,MAAgB,EAAGA,MAAQX,MAAME,OAAQS,QAChD,GAAIC,UAAUvB,UAAUsB,SAAWH,UAAUnB,UAAUsB,OAAQpB,aAAc,CAC3E,GAAIK,aAAaJ,MAAO,MAAM,IAAIK,MAAM,+BAA+BJ,KAAKM,iDAC5EP,KAAKqB,gBAAgBpB,KACvB,CAGFJ,UAAYW,MAAMG,IAAI,EAAGC,UAAMC,UAAMC,UAAMC,cAAK,CAA8BH,UAAMC,UAAMC,UAAMC,YAClG,EAKF"}

package/dist/Spatial/Registries/SpatialGridRegistry.js

@@ -0,0 +1,2 @@
+import{AbstractEntityRegistry}from"../../Abstract/Registries/AbstractEntityRegistry.js";import{RegistryType}from"../../Abstract/Constants/RegistryType.js";function SpatialGridRegistry(){return AbstractEntityRegistry(RegistryType.SpatialGrid)}export{SpatialGridRegistry};
+//# sourceMappingURL=SpatialGridRegistry.js.map

package/dist/Spatial/Registries/SpatialGridRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpatialGridRegistry.js","sources":["../../../src/Spatial/Registries/SpatialGridRegistry.ts"],"sourcesContent":["import { RegistryType } from '@Anarchy/Engine/Abstract/Constants';\nimport { AbstractEntityRegistry } from '@Anarchy/Engine/Abstract/Registries';\nimport type { TSpatialGridRegistry, TSpatialGridWrapper } from '@Anarchy/Engine/Spatial/Models';\n\nexport function SpatialGridRegistry(): TSpatialGridRegistry {\n  return AbstractEntityRegistry<TSpatialGridWrapper>(RegistryType.SpatialGrid);\n}\n"],"names":["SpatialGridRegistry","AbstractEntityRegistry","RegistryType","SpatialGrid"],"mappings":"2JAIO,SAASA,sBACd,OAAOC,uBAA4CC,aAAaC,YAClE"}

package/dist/Spatial/Services/SpatialGridService.js

@@ -0,0 +1,2 @@
+import{withCreateFromConfigServiceMixin}from"../../Mixins/Services/WithCreateFromConfigService.js";import{withFactoryService}from"../../Mixins/Services/WithFactoryService.js";import{withRegistryService}from"../../Mixins/Services/WithRegistryService.js";import{withSerializableEntities}from"../../Mixins/Services/WithSerializableEntities.js";import{AbstractService}from"../../Abstract/Services/AbstractService.js";import{mergeAll}from"../../Utils/ObjectUtils.js";import{withCreateServiceMixin}from"../../Mixins/Services/WithCreateService.js";function SpatialGridService(factory,registry){const factorySub$=factory.entityCreated$.subscribe(spatialGrid=>registry.add(spatialGrid)),abstractService=AbstractService([registry,factory,factorySub$]),withCreateService=withCreateServiceMixin(factory,void 0),withCreateFromConfigService=withCreateFromConfigServiceMixin(withCreateService.create,factory.configToParams,void 0),withFactory=withFactoryService(factory),withRegistry=withRegistryService(registry);return mergeAll(abstractService,withCreateService,withCreateFromConfigService,withFactory,withRegistry,withSerializableEntities(registry))}export{SpatialGridService};
+//# sourceMappingURL=SpatialGridService.js.map

package/dist/Spatial/Services/SpatialGridService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpatialGridService.js","sources":["../../../src/Spatial/Services/SpatialGridService.ts"],"sourcesContent":["import type { TAbstractService } from '@Anarchy/Engine/Abstract';\nimport { AbstractService } from '@Anarchy/Engine/Abstract';\nimport type { TDisposable } from '@Anarchy/Engine/Mixins';\nimport { withCreateServiceMixin, withSerializableEntities } from '@Anarchy/Engine/Mixins';\nimport { withCreateFromConfigServiceMixin } from '@Anarchy/Engine/Mixins/Services/WithCreateFromConfigService';\nimport { withFactoryService } from '@Anarchy/Engine/Mixins/Services/WithFactoryService';\nimport { withRegistryService } from '@Anarchy/Engine/Mixins/Services/WithRegistryService';\nimport type {\n  TSpatialGridConfig,\n  TSpatialGridFactory,\n  TSpatialGridRegistry,\n  TSpatialGridService,\n  TSpatialGridServiceWithCreate,\n  TSpatialGridServiceWithCreateFromConfig,\n  TSpatialGridServiceWithFactory,\n  TSpatialGridServiceWithRegistry,\n  TSpatialGridWrapper\n} from '@Anarchy/Engine/Spatial/Models';\nimport { mergeAll } from '@Anarchy/Engine/Utils';\nimport type { Subscription } from 'rxjs';\n\nexport function SpatialGridService(factory: TSpatialGridFactory, registry: TSpatialGridRegistry): TSpatialGridService {\n  const factorySub$: Subscription = factory.entityCreated$.subscribe((spatialGrid: TSpatialGridWrapper): void => registry.add(spatialGrid));\n  const disposable: ReadonlyArray<TDisposable> = [registry, factory, factorySub$];\n  const abstractService: TAbstractService = AbstractService(disposable);\n\n  const withCreateService: TSpatialGridServiceWithCreate = withCreateServiceMixin(factory, undefined);\n  const withCreateFromConfigService: TSpatialGridServiceWithCreateFromConfig = withCreateFromConfigServiceMixin(withCreateService.create, factory.configToParams, undefined);\n  const withFactory: TSpatialGridServiceWithFactory = withFactoryService(factory);\n  const withRegistry: TSpatialGridServiceWithRegistry = withRegistryService(registry);\n\n  return mergeAll(abstractService, withCreateService, withCreateFromConfigService, withFactory, withRegistry, withSerializableEntities<TSpatialGridWrapper, TSpatialGridConfig, undefined>(registry));\n}\n"],"names":["SpatialGridService","factory","registry","factorySub$","entityCreated$","subscribe","spatialGrid","add","abstractService","AbstractService","withCreateService","withCreateServiceMixin","withCreateFromConfigService","withCreateFromConfigServiceMixin","create","configToParams","withFactory","withFactoryService","withRegistry","withRegistryService","mergeAll","withSerializableEntities"],"mappings":"6hBAqBO,SAASA,mBAAmBC,QAA8BC,UAC/D,MAAMC,YAA4BF,QAAQG,eAAeC,UAAWC,aAA2CJ,SAASK,IAAID,cAEtHE,gBAAoCC,gBADK,CAACP,SAAUD,QAASE,cAG7DO,kBAAmDC,uBAAuBV,gBAC1EW,4BAAuEC,iCAAiCH,kBAAkBI,OAAQb,QAAQc,uBAC1IC,YAA8CC,mBAAmBhB,SACjEiB,aAAgDC,oBAAoBjB,UAE1E,OAAOkB,SAASZ,gBAAiBE,kBAAmBE,4BAA6BI,YAAaE,aAAcG,yBAA6EnB,UAC3L"}

package/dist/Spatial/Services/SpatialHelper.js

@@ -0,0 +1,2 @@
+import{Box3,PlaneGeometry,MeshBasicMaterial,Mesh}from"three";import{Line2}from"three/examples/jsm/lines/Line2";import{LineGeometry}from"three/examples/jsm/lines/LineGeometry";import{LineMaterial}from"three/examples/jsm/lines/LineMaterial";import{meters}from"../../Measurements/Utils/MeasurementsUtils.js";function createLine(color,width,positions){const material=new LineMaterial({color:color,linewidth:meters(width),worldUnits:!0,alphaToCoverage:!0}),geometry=new LineGeometry;return geometry.setPositions(positions),new Line2(geometry,material)}function createOutline(actor,color,lineWidth){const boundingBox=(new Box3).setFromObject(actor.model3d.getRawModel3d());var min,max;return createLine(color,lineWidth,[(min=boundingBox.min).x,min.y,min.z,(max=boundingBox.max).x,min.y,min.z,max.x,min.y,min.z,max.x,min.y,max.z,max.x,min.y,max.z,min.x,min.y,max.z,min.x,min.y,max.z,min.x,min.y,min.z,min.x,max.y,min.z,max.x,max.y,min.z,max.x,max.y,min.z,max.x,max.y,max.z,max.x,max.y,max.z,min.x,max.y,max.z,min.x,max.y,max.z,min.x,max.y,min.z,min.x,min.y,min.z,min.x,max.y,min.z,max.x,min.y,min.z,max.x,max.y,min.z,max.x,min.y,max.z,max.x,max.y,max.z,min.x,min.y,max.z,min.x,max.y,max.z])}function createBoundingBox(minX,minZ,maxX,maxZ,color="#00ff00",wireframe=!0,height=0){const geometry=new PlaneGeometry(maxX-minX,maxZ-minZ),material=new MeshBasicMaterial({color:color,wireframe:wireframe}),plane=new Mesh(geometry,material);return plane.position.set((minX+maxX)/2,height,(minZ+maxZ)/2),plane.rotation.x=-Math.PI/2,plane}export{createBoundingBox,createLine,createOutline};
+//# sourceMappingURL=SpatialHelper.js.map

package/dist/Spatial/Services/SpatialHelper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpatialHelper.js","sources":["../../../src/Spatial/Services/SpatialHelper.ts"],"sourcesContent":["import type { TActor } from '@Anarchy/Engine/Actor';\nimport { meters } from '@Anarchy/Engine/Measurements/Utils';\nimport type { ColorRepresentation, Vector3 } from 'three';\nimport { Box3, Mesh, MeshBasicMaterial, PlaneGeometry } from 'three';\nimport { Line2 } from 'three/examples/jsm/lines/Line2';\nimport { LineGeometry } from 'three/examples/jsm/lines/LineGeometry';\nimport { LineMaterial } from 'three/examples/jsm/lines/LineMaterial';\n\nexport function createLine(color: ColorRepresentation, width: number, positions: Array<number>): Line2 {\n  const material = new LineMaterial({\n    color,\n    linewidth: meters(width),\n    worldUnits: true,\n    alphaToCoverage: true\n  });\n  const geometry: LineGeometry = new LineGeometry();\n  geometry.setPositions(positions);\n\n  return new Line2(geometry, material);\n}\n\nexport function createOutline(actor: TActor, color: ColorRepresentation, lineWidth: number): Line2 {\n  const boundingBox = new Box3().setFromObject(actor.model3d.getRawModel3d());\n  const min: Vector3 = boundingBox.min;\n  const max: Vector3 = boundingBox.max;\n  const positions = getBoxEdges(min, max);\n\n  return createLine(color, lineWidth, positions);\n}\n\nfunction getBoxEdges(min: Vector3, max: Vector3): Array<number> {\n  return [\n    // Bottom edges\n    min.x,\n    min.y,\n    min.z,\n    max.x,\n    min.y,\n    min.z,\n    max.x,\n    min.y,\n    min.z,\n    max.x,\n    min.y,\n    max.z,\n    max.x,\n    min.y,\n    max.z,\n    min.x,\n    min.y,\n    max.z,\n    min.x,\n    min.y,\n    max.z,\n    min.x,\n    min.y,\n    min.z,\n\n    // Top edges\n    min.x,\n    max.y,\n    min.z,\n    max.x,\n    max.y,\n    min.z,\n    max.x,\n    max.y,\n    min.z,\n    max.x,\n    max.y,\n    max.z,\n    max.x,\n    max.y,\n    max.z,\n    min.x,\n    max.y,\n    max.z,\n    min.x,\n    max.y,\n    max.z,\n    min.x,\n    max.y,\n    min.z,\n\n    // Vertical edges\n    min.x,\n    min.y,\n    min.z,\n    min.x,\n    max.y,\n    min.z,\n    max.x,\n    min.y,\n    min.z,\n    max.x,\n    max.y,\n    min.z,\n    max.x,\n    min.y,\n    max.z,\n    max.x,\n    max.y,\n    max.z,\n    min.x,\n    min.y,\n    max.z,\n    min.x,\n    max.y,\n    max.z\n  ];\n}\n\nexport function createBoundingBox(minX: number, minZ: number, maxX: number, maxZ: number, color: ColorRepresentation = '#00ff00', wireframe: boolean = true, height: number = 0): Mesh {\n  const geometry: PlaneGeometry = new PlaneGeometry(maxX - minX, maxZ - minZ);\n  const material: MeshBasicMaterial = new MeshBasicMaterial({ color, wireframe });\n  const plane: Mesh = new Mesh(geometry, material);\n  plane.position.set((minX + maxX) / 2, height, (minZ + maxZ) / 2);\n  // eslint-disable-next-line functional/immutable-data\n  plane.rotation.x = -Math.PI / 2;\n  return plane;\n}\n"],"names":["createLine","color","width","positions","material","LineMaterial","linewidth","meters","worldUnits","alphaToCoverage","geometry","LineGeometry","setPositions","Line2","createOutline","actor","lineWidth","boundingBox","Box3","setFromObject","model3d","getRawModel3d","min","max","x","y","z","createBoundingBox","minX","minZ","maxX","maxZ","wireframe","height","PlaneGeometry","MeshBasicMaterial","plane","Mesh","position","set","rotation","Math","PI"],"mappings":"iTAQO,SAASA,WAAWC,MAA4BC,MAAeC,WACpE,MAAMC,SAAW,IAAIC,aAAa,CAChCJ,YACAK,UAAWC,OAAOL,OAClBM,YAAY,EACZC,iBAAiB,IAEbC,SAAyB,IAAIC,aAGnC,OAFAD,SAASE,aAAaT,WAEf,IAAIU,MAAMH,SAAUN,SAC7B,CAEO,SAASU,cAAcC,MAAed,MAA4Be,WACvE,MAAMC,aAAc,IAAIC,MAAOC,cAAcJ,MAAMK,QAAQC,iBAQ7D,IAAqBC,IAAcC,IAHjC,OAAOvB,WAAWC,MAAOe,UAIlB,EADYM,IAPEL,YAAYK,KAU3BE,EACJF,IAAIG,EACJH,IAAII,GAL2BH,IANZN,YAAYM,KAY3BC,EACJF,IAAIG,EACJH,IAAII,EACJH,IAAIC,EACJF,IAAIG,EACJH,IAAII,EACJH,IAAIC,EACJF,IAAIG,EACJF,IAAIG,EACJH,IAAIC,EACJF,IAAIG,EACJF,IAAIG,EACJJ,IAAIE,EACJF,IAAIG,EACJF,IAAIG,EACJJ,IAAIE,EACJF,IAAIG,EACJF,IAAIG,EACJJ,IAAIE,EACJF,IAAIG,EACJH,IAAII,EAGJJ,IAAIE,EACJD,IAAIE,EACJH,IAAII,EACJH,IAAIC,EACJD,IAAIE,EACJH,IAAII,EACJH,IAAIC,EACJD,IAAIE,EACJH,IAAII,EACJH,IAAIC,EACJD,IAAIE,EACJF,IAAIG,EACJH,IAAIC,EACJD,IAAIE,EACJF,IAAIG,EACJJ,IAAIE,EACJD,IAAIE,EACJF,IAAIG,EACJJ,IAAIE,EACJD,IAAIE,EACJF,IAAIG,EACJJ,IAAIE,EACJD,IAAIE,EACJH,IAAII,EAGJJ,IAAIE,EACJF,IAAIG,EACJH,IAAII,EACJJ,IAAIE,EACJD,IAAIE,EACJH,IAAII,EACJH,IAAIC,EACJF,IAAIG,EACJH,IAAII,EACJH,IAAIC,EACJD,IAAIE,EACJH,IAAII,EACJH,IAAIC,EACJF,IAAIG,EACJF,IAAIG,EACJH,IAAIC,EACJD,IAAIE,EACJF,IAAIG,EACJJ,IAAIE,EACJF,IAAIG,EACJF,IAAIG,EACJJ,IAAIE,EACJD,IAAIE,EACJF,IAAIG,GAhFR,CAoFO,SAASC,kBAAkBC,KAAcC,KAAcC,KAAcC,KAAc9B,MAA6B,UAAW+B,WAAqB,EAAMC,OAAiB,GAC5K,MAAMvB,SAA0B,IAAIwB,cAAcJ,KAAOF,KAAMG,KAAOF,MAChEzB,SAA8B,IAAI+B,kBAAkB,CAAElC,YAAO+B,sBAC7DI,MAAc,IAAIC,KAAK3B,SAAUN,UAIvC,OAHAgC,MAAME,SAASC,KAAKX,KAAOE,MAAQ,EAAGG,QAASJ,KAAOE,MAAQ,GAE9DK,MAAMI,SAAShB,GAAKiB,KAAKC,GAAK,EACvBN,KACT"}

package/dist/Spatial/Wrappers/SpatialCellWrapper.js

@@ -0,0 +1,2 @@
+import{AbstractWrapper}from"../../Abstract/Wrappers/AbstractWrapper.js";import{WrapperType}from"../../Abstract/Constants/WrapperType.js";import{Subject}from"../../node_modules/rxjs/dist/esm5/internal/Subject.js";import{entityToConfigSpatialCell}from"../Adapters/EntityToConfig.js";function SpatialCellWrapper(params){const entity={minX:params.minX,minY:params.minZ,maxX:params.maxX,maxY:params.maxZ,id:`spatial_cell_${params.x}_${params.z}`,version:0,objects:[]},wrapper=AbstractWrapper(entity,WrapperType.SpatialCell,params),update$=new Subject,sub$=wrapper.destroy$.subscribe(()=>{sub$.unsubscribe(),entity.objects.length=0,update$.complete()}),getObjects=()=>entity.objects,result=Object.assign(wrapper,{name:params.name??entity.id,get minX(){return entity.minX},get minY(){return entity.minY},get maxX(){return entity.maxX},get maxY(){return entity.maxY},getVersion:()=>entity.version,findObject:id=>entity.objects.find(o=>o.id===id),addObject:function(object){entity.objects.push(object),entity.version++,update$.next(entity)},getObjects:getObjects,removeObject:actor=>{const index=getObjects().indexOf(actor);if(-1===index)throw new Error(`Cannot remove actor (id: "${actor.id}", name: "${actor.name}") from spatial cell (id: "${entity.id}"). Such actor is not in the cell`);entity.objects.splice(index,1),entity.version++,update$.next(entity)},update$:update$.asObservable(),serialize:()=>entityToConfigSpatialCell(result)});return result}export{SpatialCellWrapper};
+//# sourceMappingURL=SpatialCellWrapper.js.map

package/dist/Spatial/Wrappers/SpatialCellWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpatialCellWrapper.js","sources":["../../../src/Spatial/Wrappers/SpatialCellWrapper.ts"],"sourcesContent":["import type { TAbstractWrapper } from '@Anarchy/Engine/Abstract';\nimport { AbstractWrapper, WrapperType } from '@Anarchy/Engine/Abstract';\nimport type { TActor } from '@Anarchy/Engine/Actor';\nimport { entityToConfigSpatialCell } from '@Anarchy/Engine/Spatial/Adapters';\nimport type { TSpatialCell, TSpatialCellParams, TSpatialCellSerializedData, TSpatialCellWrapper } from '@Anarchy/Engine/Spatial/Models';\nimport type { Subscription } from 'rxjs';\nimport { Subject } from 'rxjs';\n\nexport function SpatialCellWrapper(params: TSpatialCellParams): TSpatialCellWrapper {\n  const entity: TSpatialCell = {\n    minX: params.minX,\n    minY: params.minZ,\n    maxX: params.maxX,\n    maxY: params.maxZ,\n    id: `spatial_cell_${params.x}_${params.z}`,\n    version: 0,\n    objects: []\n  };\n\n  const wrapper: TAbstractWrapper<TSpatialCell> = AbstractWrapper(entity, WrapperType.SpatialCell, params as any);\n  const update$: Subject<TSpatialCell> = new Subject<TSpatialCell>();\n\n  const sub$: Subscription = wrapper.destroy$.subscribe((): void => {\n    sub$.unsubscribe();\n\n    // eslint-disable-next-line functional/immutable-data\n    entity.objects.length = 0;\n\n    update$.complete();\n  });\n\n  const findObject = (id: string): TActor | undefined => entity.objects.find((o: TActor): boolean => o.id === id);\n\n  function addObject(object: TActor): void {\n    // eslint-disable-next-line functional/immutable-data\n    entity.objects.push(object);\n    // eslint-disable-next-line functional/immutable-data\n    entity.version++;\n    update$.next(entity);\n  }\n\n  const getObjects = (): ReadonlyArray<TActor> => entity.objects;\n\n  const removeObject = (actor: TActor): void => {\n    const index: number = getObjects().indexOf(actor);\n    if (index === -1) throw new Error(`Cannot remove actor (id: \"${actor.id}\", name: \"${actor.name}\") from spatial cell (id: \"${entity.id}\"). Such actor is not in the cell`);\n\n    // eslint-disable-next-line functional/immutable-data\n    entity.objects.splice(index, 1);\n    // eslint-disable-next-line functional/immutable-data\n    entity.version++;\n    update$.next(entity);\n  };\n\n  // eslint-disable-next-line functional/immutable-data\n  const result = Object.assign(wrapper, {\n    name: params.name ?? entity.id,\n    // eslint-disable-next-line no-restricted-syntax\n    get minX(): number {\n      return entity.minX;\n    },\n    // eslint-disable-next-line no-restricted-syntax\n    get minY(): number {\n      return entity.minY;\n    },\n    // eslint-disable-next-line no-restricted-syntax\n    get maxX(): number {\n      return entity.maxX;\n    },\n    // eslint-disable-next-line no-restricted-syntax\n    get maxY(): number {\n      return entity.maxY;\n    },\n    getVersion: (): number => entity.version,\n    findObject,\n    addObject,\n    getObjects,\n    removeObject,\n    update$: update$.asObservable(),\n    serialize: (): TSpatialCellSerializedData => entityToConfigSpatialCell(result)\n  });\n\n  return result;\n}\n"],"names":["SpatialCellWrapper","params","entity","minX","minY","minZ","maxX","maxY","maxZ","id","x","z","version","objects","wrapper","AbstractWrapper","WrapperType","SpatialCell","update$","Subject","sub$","destroy$","subscribe","unsubscribe","length","complete","getObjects","result","Object","assign","name","getVersion","findObject","find","o","addObject","object","push","next","removeObject","actor","index","indexOf","Error","splice","asObservable","serialize","entityToConfigSpatialCell"],"mappings":"yRAQO,SAASA,mBAAmBC,QACjC,MAAMC,OAAuB,CAC3BC,KAAMF,OAAOE,KACbC,KAAMH,OAAOI,KACbC,KAAML,OAAOK,KACbC,KAAMN,OAAOO,KACbC,GAAI,gBAAgBR,OAAOS,KAAKT,OAAOU,IACvCC,QAAS,EACTC,QAAS,IAGLC,QAA0CC,gBAAgBb,OAAQc,YAAYC,YAAahB,QAC3FiB,QAAiC,IAAIC,QAErCC,KAAqBN,QAAQO,SAASC,UAAU,KACpDF,KAAKG,cAGLrB,OAAOW,QAAQW,OAAS,EAExBN,QAAQO,aAaJC,WAAa,IAA6BxB,OAAOW,QAcjDc,OAASC,OAAOC,OAAOf,QAAS,CACpCgB,KAAM7B,OAAO6B,MAAQ5B,OAAOO,GAE5B,QAAIN,GACF,OAAOD,OAAOC,IAChB,EAEA,QAAIC,GACF,OAAOF,OAAOE,IAChB,EAEA,QAAIE,GACF,OAAOJ,OAAOI,IAChB,EAEA,QAAIC,GACF,OAAOL,OAAOK,IAChB,EACAwB,WAAY,IAAc7B,OAAOU,QACjCoB,WA3CkBvB,IAAmCP,OAAOW,QAAQoB,KAAMC,GAAuBA,EAAEzB,KAAOA,IA4C1G0B,UA1CF,SAAmBC,QAEjBlC,OAAOW,QAAQwB,KAAKD,QAEpBlC,OAAOU,UACPM,QAAQoB,KAAKpC,OACf,EAqCEwB,sBACAa,aAlCoBC,QACpB,MAAMC,MAAgBf,aAAagB,QAAQF,OAC3C,IAAc,IAAVC,MAAc,MAAM,IAAIE,MAAM,6BAA6BH,MAAM/B,eAAe+B,MAAMV,kCAAkC5B,OAAOO,uCAGnIP,OAAOW,QAAQ+B,OAAOH,MAAO,GAE7BvC,OAAOU,UACPM,QAAQoB,KAAKpC,SA2BbgB,QAASA,QAAQ2B,eACjBC,UAAW,IAAkCC,0BAA0BpB,UAGzE,OAAOA,MACT"}

package/dist/Spatial/Wrappers/SpatialGridWrapper.js

@@ -0,0 +1,2 @@
+import{entityToConfigSpatialGrid}from"../Adapters/EntityToConfig.js";import{createOutline,createBoundingBox}from"../Services/SpatialHelper.js";import{SpatialCellWrapper}from"./SpatialCellWrapper.js";import{isDefined,isNotDefined}from"../../packages/anarchy-shared/src/Utils/CheckUtils.js";import RBush from"../../node_modules/rbush/index.js";import{Box3,Vector3}from"three";import{Subject}from"../../node_modules/rxjs/dist/esm5/internal/Subject.js";import{AbstractWrapper}from"../../Abstract/Wrappers/AbstractWrapper.js";import{WrapperType}from"../../Abstract/Constants/WrapperType.js";function SpatialGridWrapper(params){const entity=function({mapWidth:mapWidth,mapHeight:mapHeight,cellSize:cellSize,centerX:centerX,centerZ:centerZ}){const startX=centerX-Math.floor(mapWidth/cellSize/2)*cellSize,startZ=centerZ-Math.floor(mapHeight/cellSize/2)*cellSize,grid=new RBush;for(let x=0;x<mapWidth;x+=cellSize)for(let z=0;z<mapHeight;z+=cellSize){const cellW=SpatialCellWrapper({minX:startX+x,minZ:startZ+z,maxX:startX+x+cellSize,maxZ:startZ+z+cellSize,x:x,z:z});grid.insert(cellW)}return grid}(params);let _debugOutlines=[];const _debugOutlinesIds=[],update$=new Subject,wrapper=AbstractWrapper(entity,WrapperType.SpatialGrid,params);function getBoundingBox(mesh){const box=new Box3;return box.setFromObject(mesh),box}function addActor(actor){isNotDefined(actor.spatial.getGrid())&&function(actor,gridW){actor.spatial.setGrid(gridW)}(actor,this);const boundingBox=getBoundingBox(actor.model3d.getRawModel3d()),min=boundingBox.min,max=boundingBox.max,cells=entity.search({minX:min.x,minY:min.z,maxX:max.x,maxY:max.z});for(const cell of cells)isNotDefined(cell.findObject(actor.id))&&(cell.addObject(actor),update$.next(cell));actor.spatial.setSpatialCells(cells)}const getAllCells=()=>entity.all();function getAllInCell(x,z){const cells=entity.search({minX:x,minY:z,maxX:x,maxY:z});return 1===cells.length?cells[0].getObjects():cells.length>1?cells.flatMap(cell=>cell.getObjects()):[]}function removeFromGrid(actor){const cells=actor.spatial.getSpatialCells();for(const cell of cells)cell.removeObject(actor),update$.next(cell);actor.spatial.resetSpatialCells()}const findCellsForBox=({minX:minX,minZ:minZ,maxX:maxX,maxZ:maxZ})=>entity.search({minX:minX,minY:minZ,maxX:maxX,maxY:maxZ}),destroySub$=wrapper.destroy$.subscribe(()=>{_debugOutlines.length=0,_debugOutlinesIds.length=0,destroySub$.unsubscribe(),update$.complete(),getAllCells().forEach(cell=>{cell.destroy$.next()}),entity.clear()}),_debugVisualizeCellsBoxList=[],result=Object.assign(wrapper,{entity:entity,addActor:addActor,getAllCells:getAllCells,getAllInCell:getAllInCell,getAllInCellByCellId:function(cellId){const{x:x,z:z}=(cellId=>{const[x,z]=cellId.split("_").slice(-2).map(Number);return new Vector3(x,0,z)})(cellId);return getAllInCell(x,z)},findCellsForPoint:(x,z)=>entity.search({minX:x,minY:z,maxX:x,maxY:z}),findCellsForBox:findCellsForBox,findCellsByActorBox:function(actor){const actorBox=getBoundingBox(actor.model3d.getRawModel3d());return findCellsForBox({minX:actorBox.min.x,minZ:actorBox.min.z,maxX:actorBox.max.x,maxZ:actorBox.max.z})},findCellById:function(id){return entity.all().filter(cell=>cell.id===id)[0]},removeFromGrid:removeFromGrid,clearGrid:function(){throw new Error("SpatialGrid clearGrid not implemented, just a placeholder: test and fix before usage")},_debugVisualizeCells:function(sceneW,color="#00ff00",wireframe=!0,height=.1){entity.all().forEach(cell=>{const box=createBoundingBox(cell.minX,cell.minY,cell.maxX,cell.maxY,color,wireframe,height);sceneW.entity.add(box),_debugVisualizeCellsBoxList.push(box)})},_removeDebugVisualizeCells:function(sceneW){_debugVisualizeCellsBoxList.forEach(box=>{sceneW.entity.remove(box),box.geometry.dispose()}),_debugVisualizeCellsBoxList.length=0},_debugHighlightObjects:function(sceneW,x,z,color="#0000ff"){_debugOutlines.forEach(outline=>{sceneW.entity.remove(outline)}),_debugOutlines=[],_debugOutlinesIds.forEach(id=>{const obj=sceneW.entity.getObjectById(id);isDefined(obj)&&sceneW.entity.remove(obj)}),_debugOutlinesIds.length=0,getAllInCell(x,z).forEach(actor=>{const outline=createOutline(actor,color,.1);sceneW.entity.add(outline),_debugOutlines.push(outline),_debugOutlinesIds.push(outline.id)})},updateActorCell:function(actor){removeFromGrid(actor),addActor.call(this,actor)},getParams:()=>params,update$:update$.asObservable(),serialize:()=>entityToConfigSpatialGrid(result)});return result}export{SpatialGridWrapper};
+//# sourceMappingURL=SpatialGridWrapper.js.map

package/dist/Spatial/Wrappers/SpatialGridWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpatialGridWrapper.js","sources":["../../../src/Spatial/Wrappers/SpatialGridWrapper.ts"],"sourcesContent":["import type { TAbstractWrapper } from '@Anarchy/Engine/Abstract';\nimport { AbstractWrapper, WrapperType } from '@Anarchy/Engine/Abstract';\nimport type { TActor } from '@Anarchy/Engine/Actor';\nimport type { TSceneWrapper } from '@Anarchy/Engine/Scene';\nimport { entityToConfigSpatialGrid } from '@Anarchy/Engine/Spatial/Adapters/EntityToConfig';\nimport type { TSpatialCellId, TSpatialCellParams, TSpatialCellWrapper, TSpatialGrid, TSpatialGridConfig, TSpatialGridParams, TSpatialGridWrapper } from '@Anarchy/Engine/Spatial/Models';\nimport { createBoundingBox, createOutline } from '@Anarchy/Engine/Spatial/Services/SpatialHelper';\nimport { SpatialCellWrapper } from '@Anarchy/Engine/Spatial/Wrappers/SpatialCellWrapper';\nimport { isDefined, isNotDefined } from '@Anarchy/Shared/Utils';\nimport RBush from 'rbush';\nimport type { Subscription } from 'rxjs';\nimport { Subject } from 'rxjs';\nimport type { ColorRepresentation, Group, Mesh, Object3D } from 'three';\nimport { Box3, Vector3 } from 'three';\nimport type { Line2 } from 'three/examples/jsm/lines/Line2';\n\nexport function SpatialGridWrapper(params: TSpatialGridParams): TSpatialGridWrapper {\n  const entity: TSpatialGrid = createEntity(params);\n  let _debugOutlines: Array<Line2> = [];\n  const _debugOutlinesIds: Array<number> = [];\n  const update$: Subject<TSpatialCellWrapper> = new Subject<TSpatialCellWrapper>();\n\n  function createEntity({ mapWidth, mapHeight, cellSize, centerX, centerZ }: TSpatialGridParams): TSpatialGrid {\n    const startX: number = centerX - Math.floor(mapWidth / cellSize / 2) * cellSize;\n    const startZ: number = centerZ - Math.floor(mapHeight / cellSize / 2) * cellSize;\n\n    const grid: TSpatialGrid = new RBush();\n\n    // eslint-disable-next-line functional/no-loop-statements\n    for (let x: number = 0; x < mapWidth; x += cellSize) {\n      // eslint-disable-next-line functional/no-loop-statements\n      for (let z: number = 0; z < mapHeight; z += cellSize) {\n        const cell: TSpatialCellParams = { minX: startX + x, minZ: startZ + z, maxX: startX + x + cellSize, maxZ: startZ + z + cellSize, x, z };\n        const cellW: TSpatialCellWrapper = SpatialCellWrapper(cell);\n        grid.insert(cellW);\n      }\n    }\n\n    return grid;\n  }\n\n  const wrapper: TAbstractWrapper<TSpatialGrid> = AbstractWrapper(entity, WrapperType.SpatialGrid, params);\n\n  function getBoundingBox(mesh: Mesh | Group | Object3D): Box3 {\n    const box: Box3 = new Box3();\n    box.setFromObject(mesh);\n    return box;\n  }\n\n  function registerActorToGrid(actor: TActor, gridW: TSpatialGridWrapper): void {\n    actor.spatial.setGrid(gridW);\n  }\n\n  function addActor(this: TSpatialGridWrapper, actor: TActor): void | never {\n    if (isNotDefined(actor.spatial.getGrid())) registerActorToGrid(actor, this);\n\n    const boundingBox: Box3 = getBoundingBox(actor.model3d.getRawModel3d());\n    const min: Vector3 = boundingBox.min;\n    const max: Vector3 = boundingBox.max;\n\n    const cells: ReadonlyArray<TSpatialCellWrapper> = entity.search({ minX: min.x, minY: min.z, maxX: max.x, maxY: max.z });\n    // eslint-disable-next-line functional/no-loop-statements\n    for (const cell of cells) {\n      if (isNotDefined(cell.findObject(actor.id))) {\n        cell.addObject(actor);\n        update$.next(cell);\n      }\n    }\n    actor.spatial.setSpatialCells(cells);\n  }\n\n  const getAllCells = (): ReadonlyArray<TSpatialCellWrapper> => entity.all();\n\n  function getAllInCell(x: number, z: number): ReadonlyArray<TActor> {\n    const cells: ReadonlyArray<TSpatialCellWrapper> = entity.search({ minX: x, minY: z, maxX: x, maxY: z });\n    if (cells.length === 1) return cells[0].getObjects();\n    if (cells.length > 1) return cells.flatMap((cell: TSpatialCellWrapper): ReadonlyArray<TActor> => cell.getObjects());\n    return [];\n  }\n\n  const getCoordsFromGridId = (cellId: TSpatialCellId): Vector3 => {\n    const [x, z] = cellId.split('_').slice(-2).map(Number);\n    return new Vector3(x, 0, z);\n  };\n\n  function getAllInCellByCellId(cellId: TSpatialCellId): ReadonlyArray<TActor> {\n    // const cells: ReadonlyArray<TSpatialCellWrapper> = entity.all().filter((cell) => cell.id === cellId);\n    const { x, z } = getCoordsFromGridId(cellId);\n    return getAllInCell(x, z);\n  }\n\n  function removeFromGrid(actor: TActor): void | never {\n    const cells: ReadonlyArray<TSpatialCellWrapper> = actor.spatial.getSpatialCells();\n\n    // eslint-disable-next-line functional/no-loop-statements\n    for (const cell of cells) {\n      cell.removeObject(actor);\n      update$.next(cell);\n    }\n\n    actor.spatial.resetSpatialCells();\n  }\n\n  function clearGrid(): void {\n    // TODO should be tested before usage\n    throw new Error('SpatialGrid clearGrid not implemented, just a placeholder: test and fix before usage');\n    // entity.clear();\n    // getAllCells().forEach((cell: TSpatialCellWrapper): void => {\n    //   // eslint-disable-next-line functional/immutable-data\n    //   cell.version++;\n    //   update$.next(cell);\n    // });\n  }\n\n  function updateActorCell(this: TSpatialGridWrapper, actor: TActor): void {\n    removeFromGrid(actor);\n    addActor.call(this, actor);\n  }\n\n  const findCellsForPoint = (x: number, z: number): ReadonlyArray<TSpatialCellWrapper> => entity.search({ minX: x, minY: z, maxX: x, maxY: z });\n\n  const findCellsForBox = ({\n    minX,\n    minZ,\n    maxX,\n    maxZ\n  }: Readonly<{\n    minX: number;\n    minZ: number;\n    maxX: number;\n    maxZ: number;\n  }>): ReadonlyArray<TSpatialCellWrapper> => entity.search({ minX, minY: minZ, maxX, maxY: maxZ });\n\n  // TODO test this function\n  function findCellsByActorBox(actor: TActor): ReadonlyArray<TSpatialCellWrapper> {\n    const actorBox: Box3 = getBoundingBox(actor.model3d.getRawModel3d());\n    return findCellsForBox({ minX: actorBox.min.x, minZ: actorBox.min.z, maxX: actorBox.max.x, maxZ: actorBox.max.z });\n  }\n\n  function findCellById(id: TSpatialCellId): TSpatialCellWrapper | undefined {\n    return entity.all().filter((cell: TSpatialCellWrapper): boolean => cell.id === id)[0];\n  }\n\n  const destroySub$: Subscription = wrapper.destroy$.subscribe((): void => {\n    // eslint-disable-next-line functional/immutable-data\n    _debugOutlines.length = 0;\n    // eslint-disable-next-line functional/immutable-data\n    _debugOutlinesIds.length = 0;\n    destroySub$.unsubscribe();\n\n    update$.complete();\n    getAllCells().forEach((cell: TSpatialCellWrapper): void => void cell.destroy$.next());\n    entity.clear();\n  });\n\n  const _debugVisualizeCellsBoxList: Array<Mesh> = [];\n\n  // this visualization is for debugging purposes only\n  function _debugVisualizeCells(sceneW: TSceneWrapper, color: ColorRepresentation = '#00ff00', wireframe: boolean = true, height: number = 0.1): void {\n    entity.all().forEach((cell: TSpatialCellWrapper): void => {\n      const box: Mesh = createBoundingBox(cell.minX, cell.minY, cell.maxX, cell.maxY, color, wireframe, height);\n      sceneW.entity.add(box);\n      // eslint-disable-next-line functional/immutable-data\n      _debugVisualizeCellsBoxList.push(box);\n    });\n  }\n\n  function _removeDebugVisualizeCells(sceneW: TSceneWrapper): void {\n    _debugVisualizeCellsBoxList.forEach((box: Mesh): void => {\n      sceneW.entity.remove(box);\n      box.geometry.dispose();\n    });\n    // eslint-disable-next-line functional/immutable-data\n    _debugVisualizeCellsBoxList.length = 0;\n  }\n\n  // this highlight is for debugging purposes only (only adds outlines to scene, might not remove them afterward!!!).\n  // Also doesn't represent actor's rotation, so the outline might not be accurate for rotated objects\n  function _debugHighlightObjects(sceneW: TSceneWrapper, x: number, z: number, color: ColorRepresentation = '#0000ff'): void {\n    _debugOutlines.forEach((outline: Line2): void => void sceneW.entity.remove(outline));\n    _debugOutlines = [];\n    _debugOutlinesIds.forEach((id: number): void => {\n      const obj: Object3D | undefined = sceneW.entity.getObjectById(id);\n      if (isDefined(obj)) sceneW.entity.remove(obj);\n    });\n    // eslint-disable-next-line functional/immutable-data\n    _debugOutlinesIds.length = 0;\n\n    const actorsList: ReadonlyArray<TActor> = getAllInCell(x, z);\n\n    actorsList.forEach((actor: TActor): void => {\n      const outline: Line2 = createOutline(actor, color, 0.1);\n      sceneW.entity.add(outline);\n      // eslint-disable-next-line functional/immutable-data\n      _debugOutlines.push(outline);\n      // eslint-disable-next-line functional/immutable-data\n      _debugOutlinesIds.push(outline.id);\n    });\n  }\n\n  // eslint-disable-next-line functional/immutable-data\n  const result = Object.assign(wrapper, {\n    entity,\n    addActor,\n    getAllCells,\n    getAllInCell,\n    getAllInCellByCellId,\n    findCellsForPoint,\n    findCellsForBox,\n    findCellsByActorBox,\n    findCellById,\n    removeFromGrid,\n    clearGrid,\n    _debugVisualizeCells,\n    _removeDebugVisualizeCells,\n    _debugHighlightObjects,\n    updateActorCell,\n    getParams: (): TSpatialGridParams => params,\n    update$: update$.asObservable(),\n    serialize: (): TSpatialGridConfig => entityToConfigSpatialGrid(result)\n  });\n\n  return result;\n}\n"],"names":["SpatialGridWrapper","params","entity","mapWidth","mapHeight","cellSize","centerX","centerZ","startX","Math","floor","startZ","grid","RBush","x","z","cellW","SpatialCellWrapper","minX","minZ","maxX","maxZ","insert","createEntity","_debugOutlines","_debugOutlinesIds","update$","Subject","wrapper","AbstractWrapper","WrapperType","SpatialGrid","getBoundingBox","mesh","box","Box3","setFromObject","addActor","actor","isNotDefined","spatial","getGrid","gridW","setGrid","registerActorToGrid","this","boundingBox","model3d","getRawModel3d","min","max","cells","search","minY","maxY","cell","findObject","id","addObject","next","setSpatialCells","getAllCells","all","getAllInCell","length","getObjects","flatMap","removeFromGrid","getSpatialCells","removeObject","resetSpatialCells","findCellsForBox","destroySub$","destroy$","subscribe","unsubscribe","complete","forEach","clear","_debugVisualizeCellsBoxList","result","Object","assign","getAllInCellByCellId","cellId","split","slice","map","Number","Vector3","getCoordsFromGridId","findCellsForPoint","findCellsByActorBox","actorBox","findCellById","filter","clearGrid","Error","_debugVisualizeCells","sceneW","color","wireframe","height","createBoundingBox","add","push","_removeDebugVisualizeCells","remove","geometry","dispose","_debugHighlightObjects","outline","obj","getObjectById","isDefined","createOutline","updateActorCell","call","getParams","asObservable","serialize","entityToConfigSpatialGrid"],"mappings":"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"}

package/dist/Text/Adapters/ConfigToParams.js

@@ -0,0 +1,2 @@
+import{isDefined}from"../../packages/anarchy-shared/src/Utils/CheckUtils.js";import{Vector2}from"three";import{configToParams as configToParams$1}from"../../Kinematic/Adapters/ConfigToParams.js";import{configToParamsObject3d}from"../../ThreeLib/Utils/Object3dUtils.js";function configToParams(config,dependencies){const{position:position,center:center,rotation:rotation,scale:scale,layers:layers,physicsBodyName:physicsBodyName,kinematic:kinematic,...rest}=config;let result={...rest,physicsBody:isDefined(physicsBodyName)?dependencies.physicsBodyService.getRegistry().getByName(physicsBodyName):void 0,...configToParamsObject3d({position:position,rotation:rotation,scale:scale,layers:layers}),kinematic:kinematic?configToParams$1(kinematic):void 0};return isDefined(center)&&(result={...result,center:new Vector2(center.x,center.y)}),result}export{configToParams};
+//# sourceMappingURL=ConfigToParams.js.map

package/dist/Text/Adapters/ConfigToParams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigToParams.js","sources":["../../../src/Text/Adapters/ConfigToParams.ts"],"sourcesContent":["import { kinematicConfigToParams } from '@Anarchy/Engine/Kinematic';\nimport type { TTextConfig, TTextParams, TTextServiceDependencies } from '@Anarchy/Engine/Text/Models';\nimport { configToParamsObject3d } from '@Anarchy/Engine/ThreeLib';\nimport { isDefined } from '@Anarchy/Shared/Utils';\nimport { Vector2 } from 'three';\n\nexport function configToParams(config: TTextConfig, dependencies: TTextServiceDependencies): TTextParams {\n  const { position, center, rotation, scale, layers, physicsBodyName, kinematic, ...rest } = config;\n\n  let result: TTextParams = {\n    ...rest,\n    physicsBody: isDefined(physicsBodyName) ? dependencies.physicsBodyService.getRegistry().getByName(physicsBodyName) : undefined,\n    ...configToParamsObject3d({ position, rotation, scale, layers }),\n    kinematic: kinematic ? kinematicConfigToParams(kinematic) : undefined\n  };\n\n  if (isDefined(center)) result = { ...result, center: new Vector2(center.x, center.y) };\n\n  return result;\n}\n"],"names":["configToParams","config","dependencies","position","center","rotation","scale","layers","physicsBodyName","kinematic","rest","result","physicsBody","isDefined","physicsBodyService","getRegistry","getByName","configToParamsObject3d","kinematicConfigToParams","Vector2","x","y"],"mappings":"6QAMO,SAASA,eAAeC,OAAqBC,cAClD,MAAMC,SAAEA,SAAAC,OAAUA,OAAAC,SAAQA,SAAAC,MAAUA,MAAAC,OAAOA,uBAAQC,gBAAAC,UAAiBA,aAAcC,MAAST,OAE3F,IAAIU,OAAsB,IACrBD,KACHE,YAAaC,UAAUL,iBAAmBN,aAAaY,mBAAmBC,cAAcC,UAAUR,sBAAmB,KAClHS,uBAAuB,CAAEd,kBAAUE,kBAAUC,YAAOC,gBACvDE,UAAWA,UAAYS,iBAAwBT,gBAAa,GAK9D,OAFII,UAAUT,UAASO,OAAS,IAAKA,OAAQP,OAAQ,IAAIe,QAAQf,OAAOgB,EAAGhB,OAAOiB,KAE3EV,MACT"}

package/dist/Text/Adapters/EntityToConfig.js

@@ -0,0 +1,2 @@
+import{isNotDefined}from"../../packages/anarchy-shared/src/Utils/CheckUtils.js";import{filterOutEmptyFields}from"../../packages/anarchy-shared/src/Utils/ObjectUtils.js";import{kebabToCamel}from"../../packages/anarchy-shared/src/Utils/StringUtils.js";import{extractSerializableRegistrableFields}from"../../Mixins/Generics/ExtractSerializableRegistrableFields.js";import{vector2ToXy}from"../../Utils/TransformUtils.js";function textToConfig(entity){const{drive:drive}=entity,center=entity.entity.center;return filterOutEmptyFields({text:entity.getText(),type:entity.type,cssProps:extractInlineStyles(entity.getElement())??entity.getPropsAsCss(),elementType:entity.getElement()?.tagName,center:center?vector2ToXy(center):void 0,receiveShadow:entity.getReceiveShadow(),frustumCulled:entity.getFrustumCulled(),renderOrder:entity.getRenderOrder(),visible:entity.getVisible(),castShadow:entity.getCastShadow(),...extractSerializableRegistrableFields(entity),...drive.serialize()})}function extractInlineStyles(element){if(isNotDefined(element))return;const result={};for(let i=0;i<element.style.length;i++){const prop=element.style[i];result[kebabToCamel(prop)]=element.style.getPropertyValue(prop)}return 0!==Object.keys(result).length?filterOutEmptyFields(result):void 0}export{textToConfig};
+//# sourceMappingURL=EntityToConfig.js.map

package/dist/Text/Adapters/EntityToConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityToConfig.js","sources":["../../../src/Text/Adapters/EntityToConfig.ts"],"sourcesContent":["import { extractSerializableRegistrableFields } from '@Anarchy/Engine/Mixins';\nimport type { TText2dWrapper, TText3dTextureWrapper, TTextAnyWrapper, TTextConfig, TTextCssProps } from '@Anarchy/Engine/Text/Models';\nimport { vector2ToXy } from '@Anarchy/Engine/Utils';\nimport { filterOutEmptyFields, isNotDefined, kebabToCamel } from '@Anarchy/Shared/Utils';\nimport type { Vector2 } from 'three';\n\nexport function textToConfig(entity: TTextAnyWrapper): TTextConfig {\n  const { drive } = entity;\n\n  const center: Vector2 | undefined = (entity as TText2dWrapper).entity.center;\n\n  return filterOutEmptyFields({\n    text: entity.getText(),\n    type: entity.type,\n    cssProps: extractInlineStyles((entity as TText2dWrapper).getElement()) ?? (entity as TText3dTextureWrapper).getPropsAsCss(),\n    elementType: (entity as TText2dWrapper).getElement()?.tagName,\n    center: center ? vector2ToXy(center) : undefined,\n    receiveShadow: entity.getReceiveShadow(),\n    frustumCulled: entity.getFrustumCulled(),\n    renderOrder: entity.getRenderOrder(),\n    visible: entity.getVisible(),\n    castShadow: entity.getCastShadow(),\n    ...extractSerializableRegistrableFields(entity),\n    ...drive.serialize()\n  });\n}\n\nfunction extractInlineStyles(element: HTMLElement | undefined): TTextCssProps | undefined {\n  if (isNotDefined(element)) return undefined;\n\n  const result: Record<string, string> = {};\n  // eslint-disable-next-line functional/no-loop-statements\n  for (let i: number = 0; i < element.style.length; i++) {\n    const prop: string = element.style[i];\n    const propName: string = kebabToCamel(prop);\n    // eslint-disable-next-line functional/immutable-data\n    result[propName] = element.style.getPropertyValue(prop);\n  }\n  if (Object.keys(result).length === 0) return undefined;\n  return filterOutEmptyFields(result);\n}\n"],"names":["textToConfig","entity","drive","center","filterOutEmptyFields","text","getText","type","cssProps","extractInlineStyles","getElement","getPropsAsCss","elementType","tagName","vector2ToXy","receiveShadow","getReceiveShadow","frustumCulled","getFrustumCulled","renderOrder","getRenderOrder","visible","getVisible","castShadow","getCastShadow","extractSerializableRegistrableFields","serialize","element","isNotDefined","result","i","style","length","prop","kebabToCamel","getPropertyValue","Object","keys"],"mappings":"iaAMO,SAASA,aAAaC,QAC3B,MAAMC,MAAEA,OAAUD,OAEZE,OAA+BF,OAA0BA,OAAOE,OAEtE,OAAOC,qBAAqB,CAC1BC,KAAMJ,OAAOK,UACbC,KAAMN,OAAOM,KACbC,SAAUC,oBAAqBR,OAA0BS,eAAkBT,OAAiCU,gBAC5GC,YAAcX,OAA0BS,cAAcG,QACtDV,OAAQA,OAASW,YAAYX,aAAU,EACvCY,cAAed,OAAOe,mBACtBC,cAAehB,OAAOiB,mBACtBC,YAAalB,OAAOmB,iBACpBC,QAASpB,OAAOqB,aAChBC,WAAYtB,OAAOuB,mBAChBC,qCAAqCxB,WACrCC,MAAMwB,aAEb,CAEA,SAASjB,oBAAoBkB,SAC3B,GAAIC,aAAaD,SAAU,OAE3B,MAAME,OAAiC,CAAA,EAEvC,IAAA,IAASC,EAAY,EAAGA,EAAIH,QAAQI,MAAMC,OAAQF,IAAK,CACrD,MAAMG,KAAeN,QAAQI,MAAMD,GAGnCD,OAFyBK,aAAaD,OAEnBN,QAAQI,MAAMI,iBAAiBF,KACpD,CACA,OAAmC,IAA/BG,OAAOC,KAAKR,QAAQG,OACjB5B,qBAAqByB,aAD5B,CAEF"}

package/dist/Text/Constants/RelatedEntityAttribute.js

@@ -0,0 +1,2 @@
+const RelatedEntityAttribute="data-ref";export{RelatedEntityAttribute};
+//# sourceMappingURL=RelatedEntityAttribute.js.map

package/dist/Text/Constants/RelatedEntityAttribute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RelatedEntityAttribute.js","sources":["../../../src/Text/Constants/RelatedEntityAttribute.ts"],"sourcesContent":["export const RelatedEntityAttribute: string = 'data-ref';\n"],"names":["RelatedEntityAttribute"],"mappings":"AAAO,MAAMA,uBAAiC"}

package/dist/Text/Constants/TextAlign.js

@@ -0,0 +1,2 @@
+var TextAlign=(TextAlign2=>(TextAlign2.Center="center",TextAlign2.Justify="justify",TextAlign2.Left="left",TextAlign2.Right="right",TextAlign2))(TextAlign||{});export{TextAlign};
+//# sourceMappingURL=TextAlign.js.map

package/dist/Text/Constants/TextAlign.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextAlign.js","sources":["../../../src/Text/Constants/TextAlign.ts"],"sourcesContent":["export enum TextAlign {\n  Center = 'center',\n  Justify = 'justify',\n  Left = 'left',\n  Right = 'right'\n}\n"],"names":["TextAlign"],"mappings":"AAAO,IAAKA,WAAAA,aACVA,WAAA,OAAS,SACTA,WAAA,QAAU,UACVA,WAAA,KAAO,OACPA,WAAA,MAAQ,QAJEA,aAAAA,WAAA,CAAA"}

package/dist/Text/Constants/TextCssClass.js

@@ -0,0 +1,2 @@
+var TextCssClass=(TextCssClass2=>(TextCssClass2.RendererText2d="renderer-text-2d",TextCssClass2.RendererText3d="renderer-text-3d",TextCssClass2.Text2d="text-2d",TextCssClass2.Text3d="text-3d",TextCssClass2))(TextCssClass||{});export{TextCssClass};
+//# sourceMappingURL=TextCssClass.js.map

package/dist/Text/Constants/TextCssClass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextCssClass.js","sources":["../../../src/Text/Constants/TextCssClass.ts"],"sourcesContent":["export enum TextCssClass {\n  RendererText2d = 'renderer-text-2d',\n  RendererText3d = 'renderer-text-3d',\n  Text2d = 'text-2d',\n  Text3d = 'text-3d'\n}\n"],"names":["TextCssClass"],"mappings":"AAAO,IAAKA,cAAAA,gBACVA,cAAA,eAAiB,mBACjBA,cAAA,eAAiB,mBACjBA,cAAA,OAAS,UACTA,cAAA,OAAS,UAJCA,gBAAAA,cAAA,CAAA"}

package/dist/Text/Constants/TextDirection.js

@@ -0,0 +1,2 @@
+var TextDirection=(TextDirection2=>(TextDirection2.Auto="auto",TextDirection2.LTR="ltr",TextDirection2.RTL="rtl",TextDirection2))(TextDirection||{});export{TextDirection};
+//# sourceMappingURL=TextDirection.js.map

package/dist/Text/Constants/TextDirection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextDirection.js","sources":["../../../src/Text/Constants/TextDirection.ts"],"sourcesContent":["export enum TextDirection {\n  Auto = 'auto',\n  LTR = 'ltr',\n  RTL = 'rtl'\n}\n"],"names":["TextDirection"],"mappings":"AAAO,IAAKA,eAAAA,iBACVA,eAAA,KAAO,OACPA,eAAA,IAAM,MACNA,eAAA,IAAM,MAHIA,iBAAAA,eAAA,CAAA"}

package/dist/Text/Constants/TextFontStyle.js

@@ -0,0 +1,2 @@
+var TextFontStyle=(TextFontStyle2=>(TextFontStyle2.Italic="italic",TextFontStyle2.Normal="normal",TextFontStyle2))(TextFontStyle||{});export{TextFontStyle};
+//# sourceMappingURL=TextFontStyle.js.map

package/dist/Text/Constants/TextFontStyle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextFontStyle.js","sources":["../../../src/Text/Constants/TextFontStyle.ts"],"sourcesContent":["export enum TextFontStyle {\n  Italic = 'italic',\n  Normal = 'normal'\n}\n"],"names":["TextFontStyle"],"mappings":"AAAO,IAAKA,eAAAA,iBACVA,eAAA,OAAS,SACTA,eAAA,OAAS,SAFCA,iBAAAA,eAAA,CAAA"}

package/dist/Text/Constants/TextFontWeight.js

@@ -0,0 +1,2 @@
+var TextFontWeight=(TextFontWeight2=>(TextFontWeight2.Bold="bold",TextFontWeight2.Normal="normal",TextFontWeight2))(TextFontWeight||{});export{TextFontWeight};
+//# sourceMappingURL=TextFontWeight.js.map

package/dist/Text/Constants/TextFontWeight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextFontWeight.js","sources":["../../../src/Text/Constants/TextFontWeight.ts"],"sourcesContent":["export enum TextFontWeight {\n  Bold = 'bold',\n  Normal = 'normal'\n}\n"],"names":["TextFontWeight"],"mappings":"AAAO,IAAKA,gBAAAA,kBACVA,gBAAA,KAAO,OACPA,gBAAA,OAAS,SAFCA,kBAAAA,gBAAA,CAAA"}

package/dist/Text/Constants/TextOverflowWrap.js

@@ -0,0 +1,2 @@
+var TextOverflowWrap=(TextOverflowWrap2=>(TextOverflowWrap2.BreakWord="break-word",TextOverflowWrap2.Normal="normal",TextOverflowWrap2))(TextOverflowWrap||{});export{TextOverflowWrap};
+//# sourceMappingURL=TextOverflowWrap.js.map

package/dist/Text/Constants/TextOverflowWrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextOverflowWrap.js","sources":["../../../src/Text/Constants/TextOverflowWrap.ts"],"sourcesContent":["export enum TextOverflowWrap {\n  BreakWord = 'break-word',\n  Normal = 'normal'\n}\n"],"names":["TextOverflowWrap"],"mappings":"AAAO,IAAKA,kBAAAA,oBACVA,kBAAA,UAAY,aACZA,kBAAA,OAAS,SAFCA,oBAAAA,kBAAA,CAAA"}

package/dist/Text/Constants/TextRendererType.js

@@ -0,0 +1,2 @@
+var TextRendererType=(TextRendererType2=>(TextRendererType2.Text2dRenderer="text_2d_renderer",TextRendererType2.Text3dRenderer="text_3d_renderer",TextRendererType2))(TextRendererType||{});export{TextRendererType};
+//# sourceMappingURL=TextRendererType.js.map