In World Purchases (IWP) Start to Finish - by uRocketLife September 08, 2025

// Copyright (c) Dave Mills (RocketTrouble). Released under the MIT License.

import { CodeBlockEvents, Component, Entity, NetworkEvent, Player, WorldInventory } from "horizon/core";

// Persistent Player Variable (PPV) keys
export const PPV_RemainingJumps = "IWP:JumpsRemaining";
// In World Purchase (IWP) Commerce SKU identifiers
export const SKU_addJumps = "3superjumps_181deaf0";
export const SKU_unlockSize = "unlockspeed_05296351";
// Network events to communicate between IWP_Manager and PlayerSkills_Local
export const addJumpsEvent = new NetworkEvent<{ player: Player; jumps: number }>("addJumpsEvent");
export const saveRemainingJumps = new NetworkEvent<{ player: Player; jumpsRemaining: number }>("saveRemainingJumps");
export const unlockSpeedEvent = new NetworkEvent<{ player: Player }>("unlockSpeedEvent");

class IWP_Manager extends Component<typeof IWP_Manager> {
  static propsDefinition = {};

  //region preStart()
  preStart() {
    // Subscribe to item purchase events
    this.connectCodeBlockEvent(this.entity, CodeBlockEvents.OnItemPurchaseComplete, (player, item, success) => {
      if (success) {
        console.log(`Player ${player.name.get()} purchased item ${item}`);
        this.purchase(player, item);
      } else {
        console.log(`Player ${player.name.get()} failed to purchase item ${item}`);
      }
    });

    // Subscribe to item consume events
    this.connectCodeBlockEvent(this.entity, CodeBlockEvents.OnItemConsumeComplete, (player, item, success) => {
      if (success) {
        console.log(`Player ${player.name.get()} consumed item ${item}`);
        this.consume(player, item);
      } else {
        console.log(`Player ${player.name.get()} failed to consume item ${item}`);
      }
    });

    // Listen for players entering the world to load their PPVs and check durable purchases
    this.connectCodeBlockEvent(this.entity, CodeBlockEvents.OnPlayerEnterWorld, (player: Player) => {
      console.log("Player entered world:", player.name.get());
      
      //set a delay to avoid sending data before the PlayerSkills_Local component is ready
      const raceConditionDelay = 1500; // in milliseconds
      this.async.setTimeout(() => {
        //load player persistent variables
        this.loadPersistentPlayerVariables(player);
        this.checkDurablePurchase(player);
      }, raceConditionDelay);
      //check if they have durable purchases here
    });

    // Listen for jumpsRemaining updates to update persistent storage
    this.connectNetworkEvent(this.entity, saveRemainingJumps, (data) => {
      console.log("saveRemainingJumps received:", data.jumpsRemaining);
      this.world.persistentStorage.setPlayerVariable(data.player, PPV_RemainingJumps, data.jumpsRemaining);
    });
  }
  start() {}

  //region IWP Handlers
  //Check if player has durable purchase and send unlock event if they do
  async checkDurablePurchase(player: Player) {
    const hasDurable = await WorldInventory.doesPlayerHaveEntitlement(player, SKU_unlockSize);
    if (hasDurable) {
      console.log(`Player ${player.name.get()} has durable purchase: ${SKU_unlockSize}`);
      this.sendUnlockEventToPlayer(player);
    }
  }

  //Handle item purchases
  purchase(player: Player, item: string) {
    switch (item) {
      case SKU_addJumps:
        //Adding jumps is handled by consume event to ensure they are used
        break;
      case SKU_unlockSize:
        console.log(`Unlocking size for player ${player.name.get()}`);
        this.sendUnlockEventToPlayer(player);
        break;
      default:
        console.warn(`Unknown item purchased: ${item}`);
        break;
    }
  }

  //Handle item consumption
  consume(player: Player, item: string) {
    switch (item) {
      case SKU_addJumps:
        console.log(`Consumed item ${item} for player ${player.name.get()}`);
        this.sendJumpsToPlayer(player, 3);
        break;
        
      default:
        console.warn(`Unknown item consumed: ${item}`);
        break;
    }
  }
  //endregion IWP Handlers

  //region Network Events
  //Send unlock speed event to player
  sendUnlockEventToPlayer(player: Player) {
    const playerSkillsEntity = this.findPlayerSkillsOwnedByPlayer(player);
    if (playerSkillsEntity) {
      console.log(`Sending unlock event to player ${player.name.get()}`);
      this.sendNetworkEvent(playerSkillsEntity, unlockSpeedEvent, { player: player });
    } else {
      console.warn(`No PlayerSkills entity found for player ${player.name.get()}`);
    }
  }

  //Send jumps to player
  sendJumpsToPlayer(player: Player, jumps: number) {
    const playerSkillsEntity = this.findPlayerSkillsOwnedByPlayer(player);
    if (playerSkillsEntity) {
      console.log(`Sending ${jumps} jumps to player ${player.name.get()}`);
      this.sendNetworkEvent(playerSkillsEntity, addJumpsEvent, { player: player, jumps: jumps });
    } else {
      console.warn(`No PlayerSkills entity found for player ${player.name.get()}`);
    }
  }
  //endregion Network Events

  //region Persistent Player Variables
  //Load persistent player variables
  loadPersistentPlayerVariables(player: Player) {
    // Load player persistent variables here
    const remainingJumps = this.world.persistentStorage.getPlayerVariable<number>(player, PPV_RemainingJumps) || 0;
    console.log(`Loaded persistent jumps for ${player.name.get()}: ${remainingJumps}`);
    //Send the result to the PlayerSkills component
    if (remainingJumps > 0) {
      this.sendJumpsToPlayer(player, remainingJumps);
    }
  }
  //endregion Persistent Player Variables

  //region Helper Func
  //Find the PlayerSkills entity owned by the given player
  findPlayerSkillsOwnedByPlayer(player: Player): Entity | undefined {
    const playerSkills = this.world.getEntitiesWithTags(["PlayerSkills"]);
    for (const entity of playerSkills) {
      const owner = entity.owner.get();
      if (owner && owner.index === player.index) {
        return entity;
      }
    }
  }
  //endregion Helper Func
}
Component.register(IWP_Manager);

// Copyright (c) Dave Mills (RocketTrouble). Released under the MIT License.

import {
  ButtonIcon,
  CodeBlockEvents,
  Component,
  Entity,
  Player,
  PlayerControls,
  PlayerInputAction,
  PropTypes,
} from "horizon/core";
import { addJumpsEvent, saveRemainingJumps, unlockSpeedEvent } from "IWP_Manager";

class PlayerSkills_Local extends Component<typeof PlayerSkills_Local> {
  static propsDefinition = {
    // Enable or disable automatic assignment of the component to the world owner
    autoAssignOwner: { type: PropTypes.Boolean, default: false }, // Automatically assign to the world owner
  };

  localOwner!: Player;

  jumpsRemaining: number = 0;
  speedUnlocked: boolean = false;

  iwp_Manager!: Entity;

  preStart() {
     //Auto-assign player entering world as 'Local owner' while developing
    if (this.props.autoAssignOwner) {
      this.connectCodeBlockEvent(this.entity, CodeBlockEvents.OnPlayerEnterWorld, (player) => {
        console.log("Auto-assigning PlayerSkills_Local component to world owner:", player.name.get());
        this.entity.owner.set(player);
      });
    }

    //prevent further action if the server is the local owner
    if (this.entity.owner.get() === this.world.getServerPlayer()) {
      return;
    }

    //receive events from IWP_Manager
    this.connectNetworkEvent(this.entity, addJumpsEvent, (data) => {
      console.log("addJumpsEvent received:", data.jumps);
      if (this.entity.owner.get().index === data.player.index) {
        this.jumpsRemaining += data.jumps;

        //set jump speed to boosted value
        this.localOwner.jumpSpeed.set(10);
      }
    });

    //receive events from IWP_Manager
    this.connectNetworkEvent(this.entity, unlockSpeedEvent, (data) => {
      if(this.entity.owner.get().index === data.player.index) {
        this.speedUnlocked = true;
        const curSpeed = this.localOwner.locomotionSpeed.get();
        this.localOwner.locomotionSpeed.set(curSpeed * 3);
        console.log("Speed unlocked for player:", data.player.name.get());
      }
    });
  }

  start() {
    //prevent further action if the server is the local owner
    if (this.entity.owner.get() === this.world.getServerPlayer()) {
      return;
    }

    this.iwp_Manager = this.world.getEntitiesWithTags(["IWP_Manager"])[0];
    if (!this.iwp_Manager) {
      console.error("IWP_Manager entity not found in the world.");
      return;
    }

    //Assign local owner
    this.localOwner = this.entity.owner.get();
    console.log("PlayerSkills_Local assigned to player:", this.localOwner.name.get());
    //Make sure player has normal jump speed at start
    this.localOwner.jumpSpeed.set(4.5);

    //Subscribe to jump input
    const input = PlayerInputAction.Jump;
    //connect the input to the jump action
    const jumpButton = PlayerControls.connectLocalInput(input, ButtonIcon.Jump, this);
    //Register a callback for when the jump button is pressed
    jumpButton.registerCallback((action, pressed) => {
      if (pressed && this.jumpsRemaining > 0) {
        //reduce jumps remaining
        this.jumpsRemaining--;
        //reset jump speed to normal if no jumps remain
        if (this.jumpsRemaining === 0) {
          console.log(`Player ${this.localOwner.name.get()} jumped. No jumps remaining.`);
          this.localOwner.jumpSpeed.set(4.5);
        } else {
          console.log(`Player ${this.localOwner.name.get()} jumped. Jumps remaining: ${this.jumpsRemaining}`);
          //Local scripts can set PPV so send to IWP_Manager to update persistent storage
        }
      }
      //send initial jumps remaining to IWP_Manager to sync persistent storage
      this.sendNetworkEvent(this.iwp_Manager!, saveRemainingJumps, { player: this.localOwner, jumpsRemaining: this.jumpsRemaining });
    });
  }
}
Component.register(PlayerSkills_Local);