@hytopia.com/examples 1.0.3 → 1.0.4

package/frontiers-rpg-game/src/systems/ItemInventory.ts

@@ -0,0 +1,332 @@
+import type { Player } from 'hytopia';
+import BaseItem from '../items/BaseItem';
+import ItemRegistry from '../items/ItemRegistry';
+import { ItemUIDataHelper } from '../items/ItemUIDataHelper';
+
+export type SerializedItem = {
+  position: number;
+  itemId: string;
+  quantity?: number;
+};
+
+export type SerializedItemInventoryData = {
+  items: SerializedItem[];
+};
+
+export default class ItemInventory {
+  private _gridWidth: number;
+  private _itemPositions: Map<BaseItem, number> = new Map();
+  private _positionItems: Map<number, BaseItem> = new Map();
+  private _size: number;
+  private _tag: string;
+
+  public constructor(size: number, gridWidth: number, tag: string) {
+    if (size <= 0 || gridWidth <= 0) {
+      throw new Error('Size and gridWidth must be positive numbers');
+    }
+    
+    this._size = size;
+    this._gridWidth = gridWidth;
+    this._tag = tag;
+  }
+
+  public get gridWidth(): number { return this._gridWidth; }
+  public get items(): MapIterator<BaseItem> { return this._positionItems.values(); }
+  public get isFull(): boolean { return this._itemPositions.size >= this._size; }
+  public get rows(): number { return Math.ceil(this._size / this._gridWidth); }
+  public get size(): number { return this._size; }
+  public get tag(): string { return this._tag; }
+  public get totalEmptySlots(): number { return this._size - this._itemPositions.size; }
+
+  public addItem(item: BaseItem, position?: number): boolean {
+    if (this._itemPositions.has(item)) {
+      return false;
+    }
+
+    // Check if item is stackable and an item of the same type already exists
+    if (item.stackable) {
+      for (const existingItem of this._itemPositions.keys()) {
+        if (
+          existingItem.constructor === item.constructor && 
+          existingItem.name === item.name && 
+          existingItem.stackable
+        ) {
+          existingItem.adjustQuantity(item.quantity);
+          this.onSlotChanged(this._itemPositions.get(existingItem)!, existingItem);
+          return true;
+        }
+      }
+    }
+
+    // If not stackable, attempt to find an empty position
+    const targetPosition = position ?? this._findEmptyPosition();
+    
+    if (targetPosition < 0 || targetPosition >= this._size) {
+      return false;
+    }
+
+    if (this._positionItems.has(targetPosition)) {
+      return false;
+    }
+
+    this._itemPositions.set(item, targetPosition);
+    this._positionItems.set(targetPosition, item);
+    this.onSlotChanged(targetPosition, item);
+    
+    return true;
+  }
+
+  // Adjust quantity of item in inventory with UI update
+  // Use this instead of item.adjustQuantity() for items in inventory to trigger UI updates
+  public adjustItemQuantity(position: number, quantity: number): boolean {
+    const item = this._positionItems.get(position);
+    if (!item || !item.stackable) {
+      return false;
+    }
+
+    const newQuantity = item.quantity + quantity;
+    if (newQuantity <= 0) {
+      this.removeItem(position);
+      return true;
+    }
+
+    item.adjustQuantity(quantity);
+    this.onSlotChanged(position, item);
+    return true;
+  }
+
+  // Adjust quantity of item in inventory by reference with UI update
+  // Use this instead of item.adjustQuantity() for items in inventory to trigger UI updates
+  public adjustItemQuantityByReference(item: BaseItem, quantity: number): boolean {
+    const position = this._itemPositions.get(item);
+    if (position === undefined) {
+      return false;
+    }
+    return this.adjustItemQuantity(position, quantity);
+  }
+
+  public coordinatesToPosition(x: number, y: number): number | null {
+    if (x < 0 || x >= this._gridWidth || y < 0 || y >= this.rows) {
+      return null;
+    }
+    return y * this._gridWidth + x;
+  }
+
+  public expandSize(newSize: number): boolean {
+    if (newSize <= this._size) {
+      return false;
+    }
+
+    this._size = newSize;
+    
+    return true;
+  }
+
+  public getItemAt(position: number): BaseItem | null {
+    return this._positionItems.get(position) ?? null;
+  }
+
+  public getItemByClass(itemClass: typeof BaseItem): BaseItem | null {
+    for (const [ item ] of this._itemPositions) {
+      if (item instanceof itemClass) {
+        return item;
+      }
+    }
+
+    return null;
+  }
+
+  public getItemsByClass(itemClass: typeof BaseItem): BaseItem[] {
+    const items: BaseItem[] = [];
+
+    for (const [ item ] of this._itemPositions) {
+      if (item instanceof itemClass) {
+        items.push(item);
+      }
+    }
+
+    return items;
+  }
+
+  public getItemPosition(item: BaseItem): number | null {
+    return this._itemPositions.get(item) ?? null;
+  }
+
+  public getItemPositionByClass(itemClass: typeof BaseItem): number | null {
+    for (const [ item, position ] of this._itemPositions) {
+      if (item instanceof itemClass) {
+        return position;
+      }
+    }
+
+    return null;
+  }
+
+  public getItemQuantityByClass(itemClass: typeof BaseItem): number {
+    let quantity = 0;
+    
+    for (const item of this.getItemsByClass(itemClass)) {
+      quantity += item.quantity;
+    }
+    
+    return quantity;
+  }
+
+  public isEmpty(position: number): boolean {
+    return !this._positionItems.has(position);
+  }
+
+  public moveItem(fromPosition: number, toPosition: number): boolean {
+    if (fromPosition < 0 || fromPosition >= this._size || toPosition < 0 || toPosition >= this._size) {
+      return false;
+    }
+
+    if (fromPosition === toPosition) {
+      return true;
+    }
+
+    const itemToMove = this._positionItems.get(fromPosition);
+    if (!itemToMove) {
+      return false;
+    }
+
+    const itemAtDestination = this._positionItems.get(toPosition);
+
+    if (itemAtDestination) {
+      // Swap items
+      this._itemPositions.set(itemToMove, toPosition);
+      this._itemPositions.set(itemAtDestination, fromPosition);
+      this._positionItems.set(toPosition, itemToMove);
+      this._positionItems.set(fromPosition, itemAtDestination);
+      this.onSlotChanged(fromPosition, itemAtDestination);
+      this.onSlotChanged(toPosition, itemToMove);
+    } else {
+      // Move to empty slot
+      this._itemPositions.set(itemToMove, toPosition);
+      this._positionItems.delete(fromPosition);
+      this._positionItems.set(toPosition, itemToMove);
+      this.onSlotChanged(fromPosition, null);
+      this.onSlotChanged(toPosition, itemToMove);
+    }
+
+    return true;
+  }
+
+  public moveItemByReference(item: BaseItem, newPosition: number): boolean {
+    const currentPosition = this._itemPositions.get(item);
+    if (currentPosition === undefined) {
+      return false;
+    }
+    return this.moveItem(currentPosition, newPosition);
+  }
+
+  public removeItem(position: number): BaseItem | null {
+    if (position < 0 || position >= this._size) {
+      return null;
+    }
+
+    const item = this._positionItems.get(position);
+    if (!item) {
+      return null;
+    }
+
+    this._itemPositions.delete(item);
+    this._positionItems.delete(position);
+    this.onSlotChanged(position, null);
+    return item;
+  }
+
+  public removeItemByReference(item: BaseItem): boolean {
+    const position = this._itemPositions.get(item);
+    if (position === undefined) {
+      return false;
+    }
+    return this.removeItem(position) !== null;
+  }
+  
+  public syncUI(player: Player): void {
+    for (const [ position, item ] of this._positionItems) {
+      this.syncUIUpdate(player, position, item);
+    }
+  }
+
+  public syncUIUpdate(player: Player, position: number, item: BaseItem | null): void {
+    const type = `${this._tag}Update`;
+
+    if (item) {
+      player.ui.sendData(ItemUIDataHelper.getUIData(item, {
+        position,
+        sellPrice: item.sellPrice,
+        quantity: item.quantity,
+        type,
+      }));
+    } else {
+      player.ui.sendData({
+        position,
+        type,
+        removed: true,
+      });
+    }
+  }
+
+
+  protected onSlotChanged(position: number, item: BaseItem | null): void {
+    // Default implementation does nothing - subclasses can override
+  }
+
+  public serialize(): SerializedItemInventoryData {
+    const items: SerializedItem[] = [];
+    
+    for (const [position, item] of this._positionItems) {
+      const serializedItem: SerializedItem = {
+        position,
+        itemId: item.id,
+      };
+      
+      // Only include quantity if it's not the default
+      if (item.stackable && item.quantity !== 1) {
+        serializedItem.quantity = item.quantity;
+      }
+      
+      items.push(serializedItem);
+    }
+    
+    return { items };
+  }
+
+  public loadFromSerializedData(serializedItemInventoryData: SerializedItemInventoryData): boolean {
+    try {
+      const { items } = serializedItemInventoryData;
+      
+      // Clear existing inventory
+      this._itemPositions.clear();
+      this._positionItems.clear();
+      
+      // Load items
+      for (const itemData of items) {
+        const ItemClass = ItemRegistry.getItemClass(itemData.itemId);
+        if (!ItemClass) continue; // Skip unknown items silently
+        
+        if (itemData.position < 0 || itemData.position >= this._size) continue;
+        if (this._positionItems.has(itemData.position)) continue;
+        
+        const item = ItemClass.create({ quantity: itemData.quantity });
+        this._itemPositions.set(item, itemData.position);
+        this._positionItems.set(itemData.position, item);
+      }
+      
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private _findEmptyPosition(): number {
+    for (let i = 0; i < this._size; i++) {
+      if (!this._positionItems.has(i)) {
+        return i;
+      }
+    }
+    return -1;
+  }
+}

package/frontiers-rpg-game/src/systems/Levels.ts

@@ -0,0 +1,29 @@
+/**
+ * Experience and Level System
+ * Handles all level calculations and experience requirements
+ */
+export default class Levels {
+  private static readonly MAX_LEVEL = 100;
+  private static readonly EXPERIENCE_TABLE: number[] = [0]; // Level 1 = 0 XP
+  
+  public static getLevelFromExperience(experience: number): number {
+    if (experience <= 0) return 1;
+    
+    return Math.max(1, Math.floor(Math.pow(experience / 35, 1 / 2.2)));
+  }
+  
+  public static getLevelRequiredExperience(level: number): number {
+    if (level <= 1) return 0;
+
+    if (level >= this.EXPERIENCE_TABLE.length) {
+      return this.EXPERIENCE_TABLE[this.EXPERIENCE_TABLE.length - 1];
+    }
+    
+    return this.EXPERIENCE_TABLE[level];
+  }
+}
+
+// Initialize experience table on module load using formula: 35 * level^2.2
+for (let level = 2; level <= Levels['MAX_LEVEL']; level++) {
+  Levels['EXPERIENCE_TABLE'][level] = Math.floor(35 * Math.pow(level, 2.2));
+}

package/frontiers-rpg-game/src/systems/QuestLog.ts

@@ -0,0 +1,224 @@
+import QuestRegistry from '../quests/QuestRegistry';
+import type BaseQuest from '../quests/BaseQuest';
+import type GamePlayer from '../GamePlayer';
+import type BaseEntity from '../entities/BaseEntity';
+import type { PlayerQuestState } from '../quests/BaseQuest';
+
+export type SerializedQuestLogData = {
+  quests: PlayerQuestState[];
+};
+
+export default class QuestLog {
+  private _entityAlertClasses = new Set<typeof BaseEntity>();
+  private _owner: GamePlayer;
+  private _questStates = new Map<string, PlayerQuestState>();
+
+  public constructor(owner: GamePlayer) {
+    this._owner = owner;
+  }
+
+  public get owner(): GamePlayer { return this._owner; }
+  
+  public get activeQuests(): PlayerQuestState[] { 
+    return Array.from(this._questStates.values()).filter(quest => quest.state === 'active');
+  }
+
+  public adjustObjectiveProgress(questId: string, objectiveId: string, adjustAmount: number): boolean {
+    const questState = this._questStates.get(questId);
+    if (!questState || questState.state !== 'active') return false;
+
+    const questClass = QuestRegistry.getQuestClass(questId);
+    if (!questClass) return false;
+
+    const objective = questClass.objectives.find(o => o.id === objectiveId);
+    if (!objective) return false;
+
+    if (questState.objectiveProgress[objectiveId] >= objective.target) return false; // Already completed
+
+    questState.objectiveProgress[objectiveId] += adjustAmount;
+
+    if (questState.objectiveProgress[objectiveId] >= objective.target) {
+      this._owner.showNotification(`Completed objective: ${objective.name}.`, 'complete');
+    }
+
+    this.syncUIUpdate(questId);
+    this.updateEntityAlerts();
+
+    this._owner.save();
+
+    return true;
+  }
+
+  public startQuest(questClass: typeof BaseQuest): boolean {
+    if (!questClass.id || this._questStates.has(questClass.id)) {
+      return false;
+    }
+
+    const questState: PlayerQuestState = {
+      questId: questClass.id,
+      state: 'active',
+      objectiveProgress: Object.fromEntries(questClass.objectives.map(obj => [obj.id, 0])),
+      completionCleanup: questClass.setupForPlayer(this._owner),
+    };
+
+    this._questStates.set(questClass.id, questState);
+
+
+    this.syncUIUpdate(questClass.id);
+    this._owner.showNotification(`Started quest: ${questClass.name}. See quests for more details.`, 'new');
+
+    this._owner.save();
+
+    this.updateEntityAlerts();
+
+    return true;
+  }
+
+  public updateEntityAlerts(): void {
+    if (!this._owner.currentEntity) return;
+
+    const shouldShowEntityClasses = new Set<typeof BaseEntity>();
+
+    // Iterate all known quests and determine which entity classes should show alerts
+    for (const questClass of QuestRegistry.getQuests().values()) {
+      for (const dialogueInteraction of questClass.dialogueInteractions) {
+        if (dialogueInteraction.enabledForInteractor(this._owner.currentEntity)) {
+          shouldShowEntityClasses.add(dialogueInteraction.npcClass);
+        }
+      }
+    }
+
+    // Add new alerts
+    for (const entityClass of shouldShowEntityClasses) {
+      if (!this._entityAlertClasses.has(entityClass)) {
+        this._owner.addEntityAlert(entityClass);
+        this._entityAlertClasses.add(entityClass);
+      }
+    }
+
+    // Remove alerts that are no longer needed
+    for (const entityClass of this._entityAlertClasses) {
+      if (!shouldShowEntityClasses.has(entityClass)) {
+        this._owner.removeEntityAlert(entityClass);
+        this._entityAlertClasses.delete(entityClass);
+      }
+    }
+  }
+
+  public completeQuest(questId: string): boolean {
+    const questClass = QuestRegistry.getQuestClass(questId);
+    const questState = this._questStates.get(questId);
+
+    if (!questClass || !questState || questState.state !== 'active' || !questClass.rewardCompletionForPlayer(this._owner)) {
+      return false;
+    }
+
+    questState.state = 'completed';
+    questState.completionCleanup?.();
+    
+    this.syncUIUpdate(questId);
+    this._owner.showNotification(`Completed quest: ${questClass.name}.`, 'success');
+
+    this.updateEntityAlerts();
+
+    return true;
+  }
+
+  public getQuestState(questId: string): PlayerQuestState | undefined {
+    return this._questStates.get(questId);
+  }
+
+  public hasQuest(questId: string): boolean {
+    return this._questStates.has(questId);
+  }
+
+  public isQuestActive(questId: string): boolean {
+    return this._questStates.get(questId)?.state === 'active';
+  }
+
+  public isQuestCompleted(questId: string): boolean {
+    return this._questStates.get(questId)?.state === 'completed';
+  }
+
+  public isQuestObjectiveCompleted(questId: string, objectiveId: string): boolean {
+    const questState = this._questStates.get(questId);
+    if (!questState || questState.state !== 'active') return false;
+
+    const questClass = QuestRegistry.getQuestClass(questId);
+    if (!questClass) return false;
+
+    const objective = questClass.objectives.find(o => o.id === objectiveId);
+    if (!objective) return false;
+
+    if (questState.objectiveProgress[objectiveId] >= objective.target) {
+      return true;
+    }
+
+    return false;
+  }
+
+  public serialize(): SerializedQuestLogData {
+    const quests = Array.from(this._questStates.values());
+    return { quests };
+  }
+
+  public syncUI(): void {
+    for (const [ questId ] of this._questStates) {
+      this.syncUIUpdate(questId);
+    }
+  }
+
+  public syncUIUpdate(questId: string): void {
+    const questClass = QuestRegistry.getQuestClass(questId);
+    const questState = this._questStates.get(questId);
+
+    if (!questClass || !questState) return;
+
+    this._owner.player.ui.sendData({
+      type: 'questUpdate',
+      id: questId,
+      name: questClass.name,
+      description: questClass.description,
+      objectives: questClass.objectives,
+      reward: {
+        items: questClass.reward.items?.map(item => ({
+          name: item.itemClass.name,
+          iconImageUri: item.itemClass.iconImageUri,
+          quantity: item.quantity,
+        })),
+        skillExperience: questClass.reward.skillExperience,
+      },
+      state: questState
+    });
+  }
+
+  public loadFromSerializedData(serializedQuestLogData: SerializedQuestLogData): boolean {
+    try {
+      const { quests } = serializedQuestLogData;
+      
+      // Clear existing quest states and alert classes
+      this._entityAlertClasses.clear();
+      this._questStates.clear();
+      
+      // Load quests
+      for (const questState of quests) {
+        const questClass = QuestRegistry.getQuestClass(questState.questId);
+        
+        if (!questState.questId || !questState.state || !questClass) continue;
+        if (questState.state !== 'active' && questState.state !== 'completed') continue;
+        
+        // Load quest state
+        this._questStates.set(questState.questId, {
+          questId: questState.questId,
+          state: questState.state,
+          objectiveProgress: questState.objectiveProgress || {},
+          completionCleanup: questClass.setupForPlayer(this._owner),
+        });
+      }
+
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}