hytopia 0.1.77 → 0.1.78

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

@@ -0,0 +1,171 @@
+import {
+	Player,
+	PlayerEntity,
+	SimpleEntityController,
+	Vector3,
+	World,
+} from "hytopia";
+import type { AgentBehavior, BaseAgent } from "../BaseAgent";
+import { PlayerManager } from "hytopia";
+
+/**
+ * This is a simple implementation of a follow behavior for Agents. It includes basic animation handling, jump detection, and running vs walking.
+ * Agents can call actions like `follow` to start following a player.
+ *
+ * This provides a simple example of how behaviours have State, which get passed to the LLM.
+ */
+export class FollowBehavior implements AgentBehavior {
+	private playerToFollow: Player | null = null;
+	private followDistance = 2;
+	private speed = 3;
+	private runSpeed = 6;
+	private runThreshold = 5;
+	private isJumping = false;
+	private jumpCooldown = 0;
+
+	private needsToJump(
+		world: World,
+		currentPos: Vector3,
+		targetPos: Vector3
+	): boolean {
+		// Check block directly in front of us
+		const direction = new Vector3(
+			targetPos.x - currentPos.x,
+			0,
+			targetPos.z - currentPos.z
+		).normalize();
+
+		// Check one block ahead
+		const checkPos = {
+			x: Math.floor(currentPos.x + direction.x),
+			y: Math.floor(currentPos.y),
+			z: Math.floor(currentPos.z + direction.z),
+		};
+
+		// Check if there's a block at head or leg level
+		const blockAtLegs = world.chunkLattice.hasBlock(checkPos);
+		const blockAtHead = world.chunkLattice.hasBlock({
+			...checkPos,
+			y: checkPos.y + 1,
+		});
+
+		// Check if there's space to jump into
+		const blockAboveHead = world.chunkLattice.hasBlock({
+			...checkPos,
+			y: checkPos.y + 2,
+		});
+
+		return (blockAtLegs || blockAtHead) && !blockAboveHead;
+	}
+
+	onUpdate(agent: BaseAgent, world: World): void {
+		if (!this.playerToFollow) return;
+		if (!(agent.controller instanceof SimpleEntityController)) return;
+
+		// Decrease jump cooldown
+		if (this.jumpCooldown > 0) {
+			this.jumpCooldown--;
+		}
+
+		const targetEntity = world.entityManager
+			.getPlayerEntitiesByPlayer(this.playerToFollow)
+			.at(0);
+
+		if (!targetEntity) return;
+
+		const dx = targetEntity.position.x - agent.position.x;
+		const dz = targetEntity.position.z - agent.position.z;
+		const distance = Math.sqrt(dx * dx + dz * dz);
+		const yDiff = targetEntity.position.y - agent.position.y;
+
+		if (Math.abs(distance - this.followDistance) > 0.5) {
+			const isRunning = distance > this.runThreshold;
+			agent.startModelLoopedAnimations([isRunning ? "run" : "walk"]);
+
+			const angle = Math.atan2(dz, dx);
+			const targetPos = new Vector3(
+				targetEntity.position.x - Math.cos(angle) * this.followDistance,
+				targetEntity.position.y,
+				targetEntity.position.z - Math.sin(angle) * this.followDistance
+			);
+
+			// Check if we need to jump
+			if (
+				!this.isJumping &&
+				this.jumpCooldown === 0 &&
+				this.needsToJump(
+					world,
+					Vector3.fromVector3Like(agent.position),
+					targetPos
+				)
+			) {
+				const direction = Vector3.fromVector3Like(targetPos)
+					.subtract(Vector3.fromVector3Like(agent.position))
+					.normalize();
+				direction.y = 10 * agent.mass;
+				agent.applyImpulse(direction);
+				this.isJumping = true;
+				this.jumpCooldown = 30;
+			}
+
+			(agent.controller as SimpleEntityController).move(
+				targetPos,
+				isRunning ? this.runSpeed : this.speed,
+				{ moveIgnoreAxes: yDiff >= 0 ? { y: true } : undefined }
+			);
+			agent.controller.face(targetEntity.position, this.speed * 2);
+		} else {
+			agent.stopModelAnimations(["walk", "run"]);
+			agent.startModelLoopedAnimations(["idle"]);
+			this.isJumping = false; // Reset jump state when we're close enough
+		}
+	}
+
+	getState(): string {
+		if (this.playerToFollow) {
+			return "You are following " + this.playerToFollow.username;
+		}
+		return "You are not following anyone";
+	}
+
+	onToolCall(
+		agent: BaseAgent,
+		world: World,
+		toolName: string,
+		args: any
+	): void {
+		if (toolName === "follow") {
+			if (args.following) {
+				const allPlayers = PlayerManager.instance.getConnectedPlayers();
+
+				console.log(
+					"All player usernames:",
+					allPlayers.map((p) => p.username)
+				);
+				const player = allPlayers.find(
+					(p) => p.username === args.targetPlayer
+				);
+				if (player) {
+					this.playerToFollow = player;
+					console.log("Following player:", player.username);
+				} else {
+					console.log("Could not find player:", args.targetPlayer);
+				}
+			} else {
+				this.playerToFollow = null;
+				console.log("Stopped following all players");
+			}
+		}
+	}
+
+	getPromptInstructions(): string {
+		return `
+To follow a player, use:
+<action type="follow">
+{
+	"targetPlayer": "Username of player to follow",
+	"following": true  // true to start following, false to stop
+}
+</action>`;
+	}
+}

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

@@ -0,0 +1,226 @@
+import { Vector3, World } from "hytopia";
+import { BaseAgent, type AgentBehavior } from "../BaseAgent";
+
+interface MiningResult {
+	success: boolean;
+	type?:
+		| "coal"
+		| "iron"
+		| "silver"
+		| "gold"
+		| "diamond"
+		| "mysterious_crystal";
+	quantity?: number;
+}
+
+interface MineralInfo {
+	chance: number;
+	quantity: [number, number]; // [min, max]
+	value: number; // For trading purposes
+}
+
+/**
+ * This is a simple implementation of a mining behavior for Agents.
+ * It does not include animations or any other fancy features.
+ * Agents can call actions like `mine` to start mining, and the environment will trigger a callback when the mining is complete.
+ * This is a simple example of ENVIRONMENT type messages for Agents.
+ */
+export class MiningBehavior implements AgentBehavior {
+	private isMining: boolean = false;
+	private readonly CAVE_LOCATION = new Vector3(-30, 1, 15);
+	private readonly MINING_RANGE = 15; // meters from cave entrance
+	private inventory: Record<string, number> = {
+		coal: 0,
+		iron: 0,
+		silver: 0,
+		gold: 0,
+		diamond: 0,
+		mysterious_crystal: 0,
+	};
+
+	private readonly MINERALS: Record<string, MineralInfo> = {
+		coal: { chance: 0.4, quantity: [1, 5], value: 1 },
+		iron: { chance: 0.3, quantity: [1, 3], value: 2 },
+		silver: { chance: 0.15, quantity: [1, 2], value: 5 },
+		gold: { chance: 0.1, quantity: [1, 1], value: 10 },
+		diamond: { chance: 0.04, quantity: [1, 1], value: 25 },
+		mysterious_crystal: { chance: 0.01, quantity: [1, 1], value: 50 },
+	};
+
+	onUpdate(agent: BaseAgent, world: World): void {
+		// Could add ambient mining animations here
+	}
+
+	private isNearCave(agent: BaseAgent): boolean {
+		const distance = Vector3.fromVector3Like(agent.position).distance(
+			this.CAVE_LOCATION
+		);
+		return distance <= this.MINING_RANGE;
+	}
+
+	private rollForMinerals(): MiningResult {
+		const roll = Math.random();
+		let cumulative = 0;
+
+		// First check for no find
+		const noFindChance = 0.3; // 30% chance of finding nothing
+		if (roll < noFindChance) {
+			return { success: false };
+		}
+
+		// Roll for each mineral type
+		for (const [type, info] of Object.entries(this.MINERALS)) {
+			cumulative += info.chance;
+			if (roll < cumulative) {
+				const quantity = Math.floor(
+					Math.random() * (info.quantity[1] - info.quantity[0] + 1) +
+						info.quantity[0]
+				);
+				return {
+					success: true,
+					type: type as MiningResult["type"],
+					quantity,
+				};
+			}
+		}
+
+		return { success: false };
+	}
+
+	onToolCall(
+		agent: BaseAgent,
+		world: World,
+		toolName: string,
+		args: any
+	): string | void {
+		if (toolName === "mine") {
+			console.log("Mining tool called");
+
+			if (!this.isNearCave(agent)) {
+				return "You need to be closer to the cave to mine!";
+			}
+
+			if (this.isMining) {
+				return "You're already mining!";
+			}
+
+			this.isMining = true;
+
+			// Start mining animation if available
+			agent.stopModelAnimations(["walk", "run"]);
+			agent.startModelLoopedAnimations(["idle"]); // Could be replaced with mining animation
+
+			// Simulate mining time
+			setTimeout(() => {
+				this.isMining = false;
+				const result = this.rollForMinerals();
+
+				if (!result.success) {
+					agent.handleEnvironmentTrigger(
+						"Just found some worthless rocks..."
+					);
+					return;
+				}
+
+				if (result.type && result.quantity) {
+					const mineralName = result.type.replace("_", " ");
+					agent.addToInventory({
+						name: mineralName,
+						quantity: result.quantity,
+						metadata: {
+							value: this.MINERALS[result.type].value,
+						},
+					});
+
+					let message = `Found ${result.quantity} ${mineralName}!`;
+					if (result.type === "mysterious_crystal") {
+						message +=
+							" *mutters* These crystals... there's something strange about them...";
+					}
+
+					agent.handleEnvironmentTrigger(message);
+				}
+			}, 30000); // 30 second mining time
+
+			return "Mining away...";
+		} else if (toolName === "check_minerals") {
+			const inventory = Object.entries(this.inventory)
+				.filter(([_, amount]) => amount > 0)
+				.map(
+					([mineral, amount]) =>
+						`${mineral.replace("_", " ")}: ${amount}`
+				)
+				.join(", ");
+
+			return inventory || "No minerals in inventory";
+		} else if (toolName === "give_minerals") {
+			const { mineral, quantity, target } = args;
+			const mineralName = mineral.replace("_", " ");
+
+			if (!agent.removeFromInventory(mineralName, quantity)) {
+				return `Not enough ${mineralName} in inventory`;
+			}
+
+			const nearbyEntities = agent.getNearbyEntities(5);
+			const targetEntity = nearbyEntities.find((e) => e.name === target);
+
+			if (!targetEntity) {
+				return `Cannot find ${target} nearby. Try getting closer to them.`;
+			}
+
+			// Add to target's inventory if it's an agent
+			if (targetEntity.type === "Agent") {
+				const targetAgent = world.entityManager
+					.getAllEntities()
+					.find(
+						(e) => e instanceof BaseAgent && e.name === target
+					) as BaseAgent;
+
+				if (targetAgent) {
+					targetAgent.addToInventory({
+						name: mineralName,
+						quantity,
+						metadata: {
+							value: this.MINERALS[mineral].value,
+						},
+					});
+				}
+			}
+
+			return `Successfully gave ${quantity} ${mineralName} to ${target}`;
+		}
+	}
+
+	getPromptInstructions(): string {
+		return `
+To mine in the cave, use:
+<action type="mine"></action>
+
+To check your mineral inventory, use:
+<action type="check_minerals"></action>
+
+To give minerals to another agent, use:
+<action type="give_minerals">
+{
+    mineral: "coal" | "iron" | "silver" | "gold" | "diamond" | "mysterious_crystal",
+    quantity: number
+    target: "name of the player or agent to give the minerals to"
+}
+</action>
+
+You must be within 15 meters of the cave to mine.
+Each mining attempt takes 30 seconds and has a chance to find various minerals.
+You can only mine one spot at a time.`;
+	}
+
+	getState(): string {
+		const minerals = Object.entries(this.inventory)
+			.filter(([_, amount]) => amount > 0)
+			.map(([mineral, amount]) => `${mineral}: ${amount}`)
+			.join(", ");
+
+		return this.isMining
+			? "Currently mining"
+			: `Not mining. Inventory: ${minerals || "empty"}`;
+	}
+}