hytopia 0.1.76 → 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/big-world/index.ts

@@ -36,6 +36,6 @@ startServer(world => {
 
   // Despawn all player entities when a player leaves the game.
   world.onPlayerLeave = player => {
-    world.entityManager.getAllPlayerEntities(player).forEach(entity => entity.despawn());
+    world.entityManager.getPlayerEntitiesByPlayer(player).forEach(entity => entity.despawn());
   };
 });

package/examples/block-entity/index.ts

@@ -30,7 +30,7 @@ startServer(world => {
   };
 
   world.onPlayerLeave = player => {
-    world.entityManager.getAllPlayerEntities(player).forEach(entity => entity.despawn());
+    world.entityManager.getPlayerEntitiesByPlayer(player).forEach(entity => entity.despawn());
   };
 
   /**
@@ -41,7 +41,7 @@ startServer(world => {
     blockHalfExtents: { x: 1, y: 0.5, z: 1 },
     rigidBodyOptions: {
       type: RigidBodyType.KINEMATIC_VELOCITY, // Kinematic means platform won't be effected by external physics, including gravity
-      linearVelocity: { x: 0, y: 0, z: 3 }, // A starting velocity that won't change because it's kinematic
+      linearVelocity: { x: 0, y: 0, z: 3 }, // A starting velocity that won't change until we change it, because it's kinematic
     },
   });
 
@@ -162,7 +162,7 @@ startServer(world => {
       const targetPlayer = connectedPlayers[Math.floor(Math.random() * connectedPlayers.length)];
 
       // get the player's entity
-      const targetPlayerEntity = world.entityManager.getAllPlayerEntities(targetPlayer)[0];
+      const targetPlayerEntity = world.entityManager.getPlayerEntitiesByPlayer(targetPlayer)[0];
 
       if (!targetPlayerEntity) { return; } // if the player doesn't have an entity, don't pathfind.
 

package/examples/custom-ui/index.ts

@@ -51,7 +51,7 @@ startServer(world => {
   };
 
   world.onPlayerLeave = player => {
-    world.entityManager.getAllPlayerEntities(player).forEach(entity => entity.despawn());
+    world.entityManager.getPlayerEntitiesByPlayer(player).forEach(entity => entity.despawn());
     // Remove the player entity from our map for our list.
     playerEntityMap.delete(player);
   };

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/examples/entity-controller/index.ts

@@ -33,6 +33,6 @@ startServer(world => {
   };
   
   world.onPlayerLeave = player => {
-    world.entityManager.getAllPlayerEntities(player).forEach(entity => entity.despawn());
+    world.entityManager.getPlayerEntitiesByPlayer(player).forEach(entity => entity.despawn());
   };
 });

package/examples/entity-spawn/index.ts

@@ -80,6 +80,6 @@ function setup(world: World) {
 
   // Despawn all player entities when a player leaves the game.
   world.onPlayerLeave = player => {
-    world.entityManager.getAllPlayerEntities(player).forEach(entity => entity.despawn());
+    world.entityManager.getPlayerEntitiesByPlayer(player).forEach(entity => entity.despawn());
   };
 }

package/examples/hole-in-wall-game/index.ts

@@ -115,7 +115,7 @@ function onPlayerJoin(world: World, player: Player) {
 }
 
 function onPlayerLeave(world: World, player: Player) {
-  world.entityManager.getAllPlayerEntities(player).forEach(entity => {
+  world.entityManager.getPlayerEntitiesByPlayer(player).forEach(entity => {
     removePlayerFromQueue(entity);
     killPlayer(entity);
     entity.despawn();

package/examples/lighting/index.ts

@@ -109,7 +109,7 @@ startServer(world => {
 
   // Despawn all player entities when a player leaves the game.
   world.onPlayerLeave = player => {
-    world.entityManager.getAllPlayerEntities(player).forEach(entity => entity.despawn());
+    world.entityManager.getPlayerEntitiesByPlayer(player).forEach(entity => entity.despawn());
   };
 
   // Play some music on game start

package/examples/payload-game/index.ts

@@ -151,7 +151,7 @@ startServer(world => { // Perform our game setup logic in the startServer init c
     // We apply a translation prior to despawn because of a bug in the RAPIER
     // physics engine we use where entities despawned to not trigger a collision
     // event for leaving a sensor. This is a workaround till a better solution is found.
-    world.entityManager.getAllPlayerEntities(player).forEach(entity => {
+    world.entityManager.getPlayerEntitiesByPlayer(player).forEach(entity => {
       entity.setPosition({ x: 0, y: 100, z: 0 });
       setTimeout(() => entity.despawn(), 50); // Despawn after a short delay so we step the physics after translating it so leaving the sensor registers.
     });

package/examples/wall-dodge-game/index.ts

@@ -277,7 +277,7 @@ function onPlayerJoin(world: World, player: Player) {
  * cleanup when they leave the game. 
  */
 function onPlayerLeave(world: World, player: Player) {
-  world.entityManager.getAllPlayerEntities(player).forEach(entity => {
+  world.entityManager.getPlayerEntitiesByPlayer(player).forEach(entity => {
     endGame(entity); // explicitly end their game if they leave
     entity.despawn(); // despawn their entity
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hytopia",
-  "version": "0.1.76",
+  "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": {