connected-spaces-platform.web 6.20.0 → 6.22.0

package/connectedspacesplatform.ts

@@ -410,6 +410,14 @@ function csp_multiplayer_ErrorCodeFactory(
 ProxyClassFactories["csp_multiplayer_ErrorCode"] =
   csp_multiplayer_ErrorCodeFactory;
 
+function csp_multiplayer_ModifiableStatusFactory(
+  nativePointer: NativePointer,
+): Multiplayer.ModifiableStatus {
+  return nativePointer.pointer as Multiplayer.ModifiableStatus;
+}
+ProxyClassFactories["csp_multiplayer_ModifiableStatus"] =
+  csp_multiplayer_ModifiableStatusFactory;
+
 function csp_systems_EThirdPartyPlatformFactory(
   nativePointer: NativePointer,
 ): Systems.EThirdPartyPlatform {
@@ -3643,6 +3651,17 @@ export namespace Multiplayer {
   }
 }
 
+export namespace Multiplayer {
+  /**
+   * @description Enum representing the failure reason of an entity modification operation returned from IRealtimeEngine::IsEntityModifiable.
+   */
+  export enum ModifiableStatus {
+    Modifiable,
+    EntityLocked,
+    EntityNotOwnedAndUntransferable,
+  }
+}
+
 export namespace Systems {
   /**
    * @description Indicates special handling for any thirdparty platform
@@ -24218,6 +24237,32 @@ export namespace Common {
         [this.pointer, _callbackPtr, 0],
       );
     }
+
+    /**
+     * @description Checks if the given entity can be modified by this client.  
+    @details Modification in this context can mean any of the following:
+     * - Updating an entity property  
+     * - Sending an entity patch  
+     * - Creating a component  
+     * - Deleting a component  
+     * - Updating a component property  
+     * @param spaceEntity - The entity we are checking can be modified.
+     * @return The result of this operation signifying if the entity can be modified.
+     * Will return ModifiableStatus::Modifiable if the entity can be modified.  
+     */
+
+    isEntityModifiable(
+      spaceEntity: Multiplayer.SpaceEntity,
+    ): Multiplayer.ModifiableStatus {
+      let _result = Module.ccall(
+        "csp_common_IRealtimeEngine_IsEntityModifiableC_ModifiableStatus_SpaceEntityPC",
+        "number",
+        ["number", "number"],
+        [this.pointer, spaceEntity.pointer],
+      );
+
+      return _result;
+    }
   }
 }
 
@@ -26249,15 +26294,15 @@ export namespace Multiplayer {
     }
 
     /**
-     * @description Checks if the entity can be modified.
-     * Specifically whether the local client already owns the entity or can take ownership of the entity.
-     * @return True if the entity can be modified, False if not.
+     * Checks if the entity can be modified, with a failure reason if the entity isn't modifiable.
+     * The criteria for failures can be found on specific RealtimeEngine IsEntityModifiable overridden functions.
+     * @return ModifiableStatus::Modifiable on success.
      */
 
-    isModifiable(): boolean {
+    isModifiable(): Multiplayer.ModifiableStatus {
       let _result = Module.ccall(
-        "csp_multiplayer_SpaceEntity_IsModifiableC_bool",
-        "boolean",
+        "csp_multiplayer_SpaceEntity_IsModifiableC_ModifiableStatus",
+        "number",
         ["number"],
         [this.pointer],
       );
@@ -32100,7 +32145,7 @@ export namespace Systems {
 export namespace Systems {
   /**
 @ingroup HotspotSequence System
- * @description A basic class abstraction for a Hot Spot Group, including name, and items within the group.  
+ * @description A basic class abstraction for a Hotspot Group, including the Name and Items within the group.  
  */
   export class HotspotGroup
     extends NativeClassWrapper
@@ -36595,6 +36640,26 @@ export namespace Multiplayer {
       return _nPtr;
     }
 
+    /**
+     * @description Returns a ModifiableStatus enum containing ModifiableStatus::Modifiable if the entity can be modified.  
+    @details This result will contain ModifiableStatus::EntityLocked if the given entities LockType is equal to UserAgnostic.
+     * @param spaceEntity - The space entity to check its modfiable state.
+     * @return This will contain a failure reason if the entity isn't modifiable.
+     */
+
+    isEntityModifiable(
+      spaceEntity: Multiplayer.SpaceEntity,
+    ): Multiplayer.ModifiableStatus {
+      let _result = Module.ccall(
+        "csp_multiplayer_OfflineRealtimeEngine_IsEntityModifiableC_ModifiableStatus_SpaceEntityPC",
+        "number",
+        ["number", "number"],
+        [this.pointer, spaceEntity.pointer],
+      );
+
+      return _result;
+    }
+
     /**
      * @description The client ID of the local client. An arbitrary unchanging value.
      * @return INT53_MAX, the maximum number expressible in all our interop languages (you can thank javascript for the weird sizing).
@@ -37131,6 +37196,28 @@ export namespace Multiplayer {
       return _nPtr;
     }
 
+    /**
+     * @description Returns a ModifiableStatus enum containing ModifiableStatus::Modifiable if the entity can be modified.  
+    @detail This entity is considered non-modifiable in the following circumstances:
+     * - The given entities LockType is equal to UserAgnostic, and we dont have an unprocessed patch updating the lock type.  
+     * - The entities owner id doesn't match this clients id, and the entity is not transferable.  
+     * @param spaceEntity - The space entity to check its modfiable state.
+     * @return This will contain a failure reason if the entity isn't modifiable.
+     */
+
+    isEntityModifiable(
+      spaceEntity: Multiplayer.SpaceEntity,
+    ): Multiplayer.ModifiableStatus {
+      let _result = Module.ccall(
+        "csp_multiplayer_OnlineRealtimeEngine_IsEntityModifiableC_ModifiableStatus_SpaceEntityPC",
+        "number",
+        ["number", "number"],
+        [this.pointer, spaceEntity.pointer],
+      );
+
+      return _result;
+    }
+
     /**
      * @description Adds an entity to a list of entities to be updated when ProcessPendingEntityOperations is called.
      * From a client perspective, ProcessPendingEntityOperations is normally called via the CSPFoundation::Tick method.
@@ -56276,6 +56363,51 @@ export namespace Systems {
       return _promise;
     }
 
+    /**
+     * @description Set the tier of the user. Tiers effect things such as limits of users inside spaces, among other quota restrictions  
+     * @param tier - Tier to set.
+     * @param userId - Id of the user to set the tier for.
+     * @param callback - Callback when asynchronous task finishes.
+    @pre This method should only be called when logged in as an administrator tier account.
+     * If called when not an administrator, you will receive a 403 error (Forbidden)  
+     */
+
+    async setUserTier(
+      tier: Systems.TierNames,
+      userId: string,
+    ): Promise<Systems.UserTierResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.UserTierResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, result) => {
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.UserTierResult(_resultPtr);
+
+        if (_resultInstance.getResultCode() == Systems.EResultCode.InProgress) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_QuotaSystem_SetUserTier_void_TierNames_StringRC_UserTierCallback",
+        "void",
+        ["number", "number", "string", "number", "number"],
+        [this.pointer, tier, userId, _callbackPtr, 0],
+      );
+
+      return _promise;
+    }
+
     /**
      * @description Get current users tier information
      * @param callback - Callback when asynchronous task finishes

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "connected-spaces-platform.web",
   "displayName": "connected-spaces-platform.web",
-  "version": "6.20.0",
+  "version": "6.22.0",
   "description": "This package provides the binaries required to interface with the Connected Spaces Platform API.",
   "license": "Apache-2.0",
   "dependencies": {