hytopia 0.1.77 → 0.1.78

package/examples/ai-agents/src/behaviors/TradeBehavior.ts

@@ -0,0 +1,254 @@
+import { World } from "hytopia";
+import { BaseAgent, type AgentBehavior } from "../BaseAgent";
+
+interface TradeRequest {
+	from: BaseAgent;
+	to: BaseAgent;
+	offerItems: { name: string; quantity: number }[];
+	requestItems: { name: string; quantity: number }[];
+	timestamp: number;
+}
+/**
+ * Simple implementation of trade behavior for Agents.
+ * This is a simple example of how behaviours can have state, in this case, a map of active trade requests.
+ * It also demonstrates how Behaviors can manage agent state like the inventory.
+ */
+export class TradeBehavior implements AgentBehavior {
+	private activeRequests: Map<string, TradeRequest> = new Map();
+
+	onUpdate(agent: BaseAgent, world: World): void {}
+
+	private generateTradeId(from: BaseAgent, to: BaseAgent): string {
+		return `${from.name}_${to.name}_${Date.now()}`;
+	}
+
+	onToolCall(
+		agent: BaseAgent,
+		world: World,
+		toolName: string,
+		args: any
+	): string | void {
+		if (toolName === "request_trade") {
+			const { target, offer, request } = args;
+
+			// Find target agent
+			const nearbyEntities = agent.getNearbyEntities(5);
+			const targetEntity = nearbyEntities.find((e) => e.name === target);
+
+			if (!targetEntity || targetEntity.type !== "Agent") {
+				return `Cannot find ${target} nearby to trade with.`;
+			}
+
+			const targetAgent = world.entityManager
+				.getAllEntities()
+				.find(
+					(e) => e instanceof BaseAgent && e.name === target
+				) as BaseAgent;
+
+			if (!targetAgent) return "Target agent not found";
+
+			// Verify agent has the items they're offering
+			for (const item of offer) {
+				if (!agent.removeFromInventory(item.name, item.quantity)) {
+					return `You don't have enough ${item.name} to offer.`;
+				}
+				// Return items since this is just a check
+				agent.addToInventory({
+					name: item.name,
+					quantity: item.quantity,
+				});
+			}
+
+			const tradeId = this.generateTradeId(agent, targetAgent);
+			const tradeRequest = {
+				from: agent,
+				to: targetAgent,
+				offerItems: offer,
+				requestItems: request,
+				timestamp: Date.now(),
+			};
+
+			// Set trade request in both agents' trade behaviors
+			this.activeRequests.set(tradeId, tradeRequest);
+			const targetTradeBehavior = targetAgent
+				.getBehaviors()
+				.find((b) => b instanceof TradeBehavior) as TradeBehavior;
+			if (targetTradeBehavior) {
+				targetTradeBehavior.activeRequests.set(tradeId, tradeRequest);
+			}
+
+			targetAgent.handleEnvironmentTrigger(
+				`${agent.name} wants to trade!\n` +
+					`Offering: ${offer
+						.map(
+							(i: { quantity: number; name: string }) =>
+								`${i.quantity}x ${i.name}`
+						)
+						.join(", ")}\n` +
+					`Requesting: ${request
+						.map(
+							(i: { quantity: number; name: string }) =>
+								`${i.quantity}x ${i.name}`
+						)
+						.join(", ")}\n` +
+					`Use accept_trade or decline_trade with tradeId: ${tradeId}`
+			);
+
+			return "Trade request sent!";
+		} else if (toolName === "accept_trade") {
+			const { tradeId } = args;
+			const request = this.activeRequests.get(tradeId);
+			console.log(`${agent.name} attempting to accept trade ${tradeId}`);
+
+			if (!request) {
+				console.log(`Trade ${tradeId} not found or expired`);
+				return "Trade request not found or expired.";
+			}
+
+			if (request.to !== agent) {
+				console.log(
+					`${agent.name} tried to accept trade meant for ${request.to.name}`
+				);
+				return "This trade request was not sent to you.";
+			}
+
+			// Verify receiving agent has requested items
+			for (const item of request.requestItems) {
+				if (!agent.removeFromInventory(item.name, item.quantity)) {
+					console.log(
+						`${agent.name} lacks required item: ${item.quantity}x ${item.name}`
+					);
+					return `You don't have enough ${item.name} to complete the trade.`;
+				}
+
+				// Return items since this is just a check
+				agent.addToInventory({
+					name: item.name,
+					quantity: item.quantity,
+				});
+			}
+
+			console.log(
+				`Executing trade between ${request.from.name} and ${request.to.name}`
+			);
+			console.log(
+				`${request.from.name} offers: ${JSON.stringify(
+					request.offerItems
+				)}`
+			);
+			console.log(
+				`${request.to.name} offers: ${JSON.stringify(
+					request.requestItems
+				)}`
+			);
+
+			// Execute the trade
+			// Remove items from both agents
+			for (const item of request.offerItems) {
+				request.from.removeFromInventory(item.name, item.quantity);
+			}
+			for (const item of request.requestItems) {
+				request.to.removeFromInventory(item.name, item.quantity);
+			}
+
+			// Add items to both agents
+			for (const item of request.offerItems) {
+				request.to.addToInventory({
+					name: item.name,
+					quantity: item.quantity,
+				});
+			}
+			for (const item of request.requestItems) {
+				request.from.addToInventory({
+					name: item.name,
+					quantity: item.quantity,
+				});
+			}
+
+			// Clear trade request from both agents' trade behaviors
+			this.activeRequests.delete(tradeId);
+			const fromTradeBehavior = request.from
+				.getBehaviors()
+				.find((b) => b instanceof TradeBehavior) as TradeBehavior;
+			if (fromTradeBehavior) {
+				fromTradeBehavior.activeRequests.delete(tradeId);
+			}
+
+			console.log(`Trade ${tradeId} completed successfully`);
+
+			// Notify both agents
+			request.from.handleEnvironmentTrigger(
+				`${agent.name} accepted your trade!`
+			);
+			request.to.handleEnvironmentTrigger(
+				`You accepted the trade with ${agent.name}!`
+			);
+			return "Trade completed successfully!";
+		} else if (toolName === "decline_trade") {
+			const { tradeId } = args;
+			const request = this.activeRequests.get(tradeId);
+
+			if (!request) {
+				console.log("Trade request not found or expired.");
+				return "Trade request not found or expired.";
+			}
+
+			if (request.to !== agent) {
+				console.log("This trade request was not sent to you.");
+				return "This trade request was not sent to you.";
+			}
+
+			// Clear trade request from both agents' trade behaviors
+			this.activeRequests.delete(tradeId);
+			const fromTradeBehavior = request.from
+				.getBehaviors()
+				.find((b) => b instanceof TradeBehavior) as TradeBehavior;
+			if (fromTradeBehavior) {
+				fromTradeBehavior.activeRequests.delete(tradeId);
+			}
+
+			request.from.handleEnvironmentTrigger(
+				`${agent.name} declined your trade.`
+			);
+			console.log("Trade declined.");
+			return "Trade declined.";
+		}
+	}
+
+	getPromptInstructions(): string {
+		return `
+To request a trade with another agent:
+<action type="request_trade">
+{
+	"target": "name of agent to trade with",
+	"offer": [{ "name": "item name", "quantity": number }],
+	"request": [{ "name": "item name", "quantity": number }]
+}
+</action>
+
+To accept a trade request:
+<action type="accept_trade">
+{
+	"tradeId": "trade_id_from_request"
+}
+</action>
+
+To decline a trade request:
+<action type="decline_trade">
+{
+	"tradeId": "trade_id_from_request"
+}
+</action>
+
+Trading requires both agents to be within 5 meters of each other.
+Both agents must have the required items in their inventory.
+
+If someone verbally offers a trade, but you don't get the official request from the Environment, you should ask them to request the trade so you can accept it.
+
+If you request to trade with an agent, they will need to accept the trade request.`;
+	}
+
+	getState(): string {
+		return `Active trade requests: ${JSON.stringify(this.activeRequests)}`;
+	}
+}

package/examples/entity-controller/MyEntityController.ts

@@ -144,7 +144,7 @@ export default class MyEntityController extends BaseEntityController {
         collidesWith: [ CollisionGroup.BLOCK, CollisionGroup.ENTITY ],
       },
       isSensor: true,
-      relativePosition: { x: 0, y: -0.75, z: 0 },
+      position: { x: 0, y: -0.75, z: 0 },
       tag: 'groundSensor',
       onCollision: (_other: BlockType | Entity, started: boolean) => {
         // Ground contact

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hytopia",
-  "version": "0.1.77",
+  "version": "0.1.78",
   "description": "The HYTOPIA SDK makes it easy for developers to create massively multiplayer games using JavaScript or TypeScript.",
   "main": "server.js",
   "bin": {

package/server.api.json

@@ -13664,17 +13664,17 @@
             },
             {
               "kind": "Property",
-              "canonicalReference": "server!GameServer#modelManager:member",
+              "canonicalReference": "server!GameServer#modelRegistry:member",
               "docComment": "/**\n * The model manager for the game server.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
-                  "text": "get modelManager(): "
+                  "text": "get modelRegistry(): "
                 },
                 {
                   "kind": "Reference",
-                  "text": "ModelManager",
-                  "canonicalReference": "server!ModelManager:class"
+                  "text": "ModelRegistry",
+                  "canonicalReference": "server!ModelRegistry:class"
                 },
                 {
                   "kind": "Content",
@@ -13684,7 +13684,7 @@
               "isReadonly": true,
               "isOptional": false,
               "releaseTag": "Public",
-              "name": "modelManager",
+              "name": "modelRegistry",
               "propertyTypeTokenRange": {
                 "startIndex": 1,
                 "endIndex": 2
@@ -16691,23 +16691,23 @@
         },
         {
           "kind": "Class",
-          "canonicalReference": "server!ModelManager:class",
-          "docComment": "/**\n * Manages model data for all known models of the game.\n *\n * @remarks\n *\n * The ModelManager is created internally as a global singletone accessible with the static property `ModelManager.instance`.\n *\n * The constructor for this class is marked as internal. Third-party code should not call the constructor directly or create subclasses that extend the `ModelManager` class.\n *\n * @example\n * ```typescript\n * import { ModelManager } from 'hytopia';\n *\n * const modelManager = ModelManager.instance;\n * const boundingBox = modelManager.getBoundingBox('models/player.gltf');\n * ```\n *\n * @public\n */\n",
+          "canonicalReference": "server!ModelRegistry:class",
+          "docComment": "/**\n * Manages model data for all known models of the game.\n *\n * @remarks\n *\n * The ModelRegistry is created internally as a global singletone accessible with the static property `ModelRegistry.instance`.\n *\n * The constructor for this class is marked as internal. Third-party code should not call the constructor directly or create subclasses that extend the `ModelRegistry` class.\n *\n * @example\n * ```typescript\n * import { ModelRegistry } from 'hytopia';\n *\n * const modelRegistry = ModelRegistry.instance;\n * const boundingBox = modelRegistry.getBoundingBox('models/player.gltf');\n * ```\n *\n * @public\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
-              "text": "export default class ModelManager "
+              "text": "export default class ModelRegistry "
             }
           ],
-          "fileUrlPath": "src/models/ModelManager.ts",
+          "fileUrlPath": "src/models/ModelRegistry.ts",
           "releaseTag": "Public",
           "isAbstract": false,
-          "name": "ModelManager",
+          "name": "ModelRegistry",
           "preserveMemberOrder": false,
           "members": [
             {
               "kind": "Method",
-              "canonicalReference": "server!ModelManager#getBoundingBox:member(1)",
+              "canonicalReference": "server!ModelRegistry#getBoundingBox:member(1)",
               "docComment": "/**\n * Retrieves the bounding box of a model.\n *\n * @param modelUri - The URI of the model to retrieve the bounding box for.\n *\n * @returns The bounding box of the model.\n */\n",
               "excerptTokens": [
                 {
@@ -16756,8 +16756,8 @@
             },
             {
               "kind": "Property",
-              "canonicalReference": "server!ModelManager.instance:member",
-              "docComment": "/**\n * The global PlayerManager instance as a singleton.\n */\n",
+              "canonicalReference": "server!ModelRegistry.instance:member",
+              "docComment": "/**\n * The global ModelRegistry instance as a singleton.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",
@@ -16765,8 +16765,8 @@
                 },
                 {
                   "kind": "Reference",
-                  "text": "ModelManager",
-                  "canonicalReference": "server!ModelManager:class"
+                  "text": "ModelRegistry",
+                  "canonicalReference": "server!ModelRegistry:class"
                 },
                 {
                   "kind": "Content",

package/server.d.ts

@@ -1768,7 +1768,7 @@ export declare class GameServer {
     /** The singleton instance of the game server. */
     static get instance(): GameServer;
     /** The model manager for the game server. */
-    get modelManager(): ModelManager;
+    get modelRegistry(): ModelRegistry;
     /** The player manager for the game server. */
     get playerManager(): PlayerManager;
 
@@ -2077,39 +2077,31 @@ export declare enum LightType {
 
 /** A bounding box for a model. @public */
 declare type ModelBoundingBox = {
-    min: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    max: {
-        x: number;
-        y: number;
-        z: number;
-    };
+    min: Vector3Like;
+    max: Vector3Like;
 };
 
 /**
  * Manages model data for all known models of the game.
  *
  * @remarks
- * The ModelManager is created internally as a global
+ * The ModelRegistry is created internally as a global
  * singletone accessible with the static property
- * `ModelManager.instance`.
+ * `ModelRegistry.instance`.
  *
  * @example
  * ```typescript
- * import { ModelManager } from 'hytopia';
+ * import { ModelRegistry } from 'hytopia';
  *
- * const modelManager = ModelManager.instance;
- * const boundingBox = modelManager.getBoundingBox('models/player.gltf');
+ * const modelRegistry = ModelRegistry.instance;
+ * const boundingBox = modelRegistry.getBoundingBox('models/player.gltf');
  * ```
  *
  * @public
  */
-export declare class ModelManager {
-    /** The global PlayerManager instance as a singleton. */
-    static readonly instance: ModelManager;
+export declare class ModelRegistry {
+    /** The global ModelRegistry instance as a singleton. */
+    static readonly instance: ModelRegistry;