hytopia 0.1.29 → 0.1.30

package/examples/payload-game/index.ts

@@ -23,9 +23,9 @@ import {
   CollisionGroup,
   DefaultCharacterController,
   Entity,
-  GameServer,
   PlayerEntity,
   RigidBodyType,
+  SimpleCharacterController,
   World,
   startServer,
 } from 'hytopia';
@@ -47,9 +47,9 @@ const PAYLOAD_SPAWN_COORDINATE = { x: 1.5, y: 2.6, z: 69.5 };
 const PAYLOAD_PER_PLAYER_SPEED = 1;
 const PAYLOAD_MAX_SPEED = 5;
 const PAYLOAD_WAYPOINT_COORDINATES = [
-  { x: 1.5, z: 1.5 },
-  { x: 60.5, z: 1.5 },
-  { x: 60.5, z: -62.5 },
+  { x: 1.5, y: 0, z: 1.5 },
+  { x: 60.5, y: 0, z: 1.5 },
+  { x: 60.5, y: 0, z: -62.5 },
 ];
 const PLAYER_SPAWN_COORDINATES = [
   { x: 4, y: 3, z: 71 },
@@ -89,6 +89,9 @@ let targetWaypointCoordinateIndex = 0; // Current waypoint coordinate index for
 startServer(world => { // Perform our game setup logic in the startServer init callback here.
   const chatManager = world.chatManager;
 
+  // Enable debug rendering
+  world.simulation.enableDebugRendering(true);
+
   // Load Map
   world.loadMap(map);
 
@@ -225,36 +228,36 @@ function spawnBullet(world: World, coordinate: Vector3, direction: Vector3) {
     },
   });
 
-  bullet.onBlockCollision = (block: BlockType, started: boolean) => { // If the bullet hits a block, despawn it
+  bullet.onBlockCollision = (bullet: Entity, block: BlockType, started: boolean) => { // If the bullet hits a block, despawn it
     if (started) {
       bullet.despawn();
     }
   };
 
-  bullet.onEntityCollision = (entity: Entity, started: boolean) => { // If the bullet hits an enemy, deal damage if it is a Spider
-    if (!started || entity.name !== 'Spider') {
+  bullet.onEntityCollision = (bullet: Entity, otherEntity: Entity, started: boolean) => { // If the bullet hits an enemy, deal damage if it is a Spider
+    if (!started || otherEntity.name !== 'Spider') {
       return;
     }
     
-    enemyHealth[entity.id!]--;
+    enemyHealth[otherEntity.id!]--;
 
     // Apply knockback, the knockback effect is less if the spider is larger, and more if it is smaller
     // because of how the physics simulation applies forces relative to automatically calculated mass from the spider's
     // size
     const bulletDirection = bullet.getDirectionFromRotation();
-    const mass = entity.getMass();
+    const mass = otherEntity.getMass();
     const knockback = 14 * mass;
 
-    entity.applyImpulse({
+    otherEntity.applyImpulse({
       x: -bulletDirection.x * knockback,
       y: 0,
       z: -bulletDirection.z * knockback,
     });
 
-    if (enemyHealth[entity.id!] <= 0) {
+    if (enemyHealth[otherEntity.id!] <= 0) {
       // YEET the spider before despawning it so it registers leaving the sensor
-      entity.setTranslation({ 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.
+      otherEntity.setTranslation({ x: 0, y: 100, z: 0 });
+      setTimeout(() => { otherEntity.despawn(); }, 50); // Despawn after a short delay so we step the physics after translating it so leaving the sensor registers.
     }
 
     bullet.despawn();
@@ -280,12 +283,13 @@ function spawnPayloadEntity(world: World) {
   }
 
   payloadEntity = new Entity({
+    createCustomCharacterController: (entity: Entity) => new SimpleCharacterController(entity),
     name: 'Payload',
     modelUri: 'models/payload.gltf',
     modelScale: 0.7,
     modelLoopedAnimations: [ 'idle' ],
     rigidBodyOptions: {
-      type: RigidBodyType.KINEMATIC_VELOCITY,
+      type: RigidBodyType.KINEMATIC_POSITION,
       colliders: [
         {
           shape: ColliderShape.BLOCK,
@@ -336,6 +340,7 @@ function spawnSpider(world: World, coordinate: Vector3) {
   const targetPlayers = new Set<PlayerEntity>();
 
   const spider = new Entity({
+    createCustomCharacterController: (entity: Entity) => new SimpleCharacterController(entity),
     name: 'Spider',
     modelUri: 'models/spider.gltf',
     modelLoopedAnimations: [ 'walk' ],
@@ -375,14 +380,14 @@ function spawnSpider(world: World, coordinate: Vector3) {
     },
   });
 
-  spider.onTick = (tickDeltaMs: number) => onTickPathfindEnemy( // Use our own basic pathfinding function each tick of the game for the enemy
-    spider,
+  spider.onTick = (entity: Entity, tickDeltaMs: number) => onTickPathfindEnemy( // Use our own basic pathfinding function each tick of the game for the enemy
+    entity,
     targetPlayers,
     baseSpeed * randomScaleMultiplier,
     tickDeltaMs,
   );
 
-  spider.onEntityCollision = (entity: Entity, started: boolean) => { // If the spider hits a player, deal damage and apply knockback
+  spider.onEntityCollision = (spider: Entity, entity: Entity, started: boolean) => { // If the spider hits a player, deal damage and apply knockback
     if (started && entity instanceof PlayerEntity && entity.isSpawned) {
       const spiderDirection = spider.getDirectionFromRotation();
       const knockback = 4 * randomScaleMultiplier;
@@ -410,70 +415,35 @@ function spawnSpider(world: World, coordinate: Vector3) {
   enemyHealth[spider.id!] = 2 * Math.round(randomScaleMultiplier);
 }
 
-function onTickPathfindPayload(this: Entity, tickDeltaMs: number) { // Movement logic for the payload
+function onTickPathfindPayload(entity: Entity) { // Movement logic for the payload
   const speed = started // Set the payload speed relative to the number of players in the payload sensor
     ? Math.max(Math.min(PAYLOAD_PER_PLAYER_SPEED * payloadPlayerEntityCount, PAYLOAD_MAX_SPEED), 0)
     : 0;
 
   if (!speed) { // Play animations based on if its moving or not
-    this.stopModelAnimations(Array.from(this.modelLoopedAnimations).filter(v => v !== 'idle'));
-    this.startModelLoopedAnimations([ 'idle' ]);
+    entity.stopModelAnimations(Array.from(entity.modelLoopedAnimations).filter(v => v !== 'idle'));
+    entity.startModelLoopedAnimations([ 'idle' ]);
   } else {
-    this.stopModelAnimations(Array.from(this.modelLoopedAnimations).filter(v => v !== 'walk'));
-    this.startModelLoopedAnimations([ 'walk' ]);
+    entity.stopModelAnimations(Array.from(entity.modelLoopedAnimations).filter(v => v !== 'walk'));
+    entity.startModelLoopedAnimations([ 'walk' ]);
   }
 
-  // Calculate direction to target waypoint
   const targetWaypointCoordinate = PAYLOAD_WAYPOINT_COORDINATES[targetWaypointCoordinateIndex];
-  const currentPosition = this.getTranslation();
-  const deltaX = targetWaypointCoordinate.x - currentPosition.x;
-  const deltaZ = targetWaypointCoordinate.z - currentPosition.z;
 
-  const direction = {
-    x: Math.abs(deltaX) > 0.1 ? Math.sign(deltaX) : 0,
-    z: Math.abs(deltaZ) > 0.1 ? Math.sign(deltaZ) : 0,
-  };
+  if (!targetWaypointCoordinate) {
+    return console.warn('Payload destination reached!! Game won!!');
+  }
 
-  // Apply rotation to face direction if necessary based on the current target waypoint
-  const rotation = this.getRotation();
-  const currentAngle = 2 * Math.atan2(rotation.y, rotation.w);
-  const targetAngle = Math.atan2(direction.x, direction.z) + Math.PI; // Add PI to face forward
-
-  let angleDiff = targetAngle - currentAngle;
-  while (angleDiff > Math.PI) angleDiff -= 2 * Math.PI;
-  while (angleDiff < -Math.PI) angleDiff += 2 * Math.PI;
-
-  if (Math.abs(angleDiff) > 0.01) {
-    const rotationStep = (Math.PI / 2) * (tickDeltaMs / 1000) * Math.sign(angleDiff);
-    const actualRotation = Math.abs(rotationStep) > Math.abs(angleDiff) ? angleDiff : rotationStep;
-    const newAngle = currentAngle + actualRotation;
-
-    this.setRotation({
-      x: 0,
-      y: Math.sin(newAngle / 2),
-      z: 0,
-      w: Math.cos(newAngle / 2),
-    });
+  if (!(entity.characterController instanceof SimpleCharacterController)) { // type guard
+    return console.warn('Payload entity does not have a SimpleCharacterController!');
   }
 
-  // Apply velocity to move towards target
-  this.setLinearVelocity({
-    x: direction.x * speed,
-    y: 0,
-    z: direction.z * speed,
+  entity.characterController.move(targetWaypointCoordinate, speed, {
+    moveCompleteCallback: () => targetWaypointCoordinateIndex++,
+    moveIgnoreAxes: { y: true },
   });
 
-  // Check if we're within 3 blocks of the target waypoint, if so move to next waypoint
-  const distanceX = Math.abs(currentPosition.x - targetWaypointCoordinate.x);
-  const distanceZ = Math.abs(currentPosition.z - targetWaypointCoordinate.z);
-  
-  if (distanceX <= 2 && distanceZ <= 2) {
-    if (targetWaypointCoordinateIndex + 1 < PAYLOAD_WAYPOINT_COORDINATES.length) {
-      targetWaypointCoordinateIndex++;
-    } else {
-      console.log('GAME WON!');
-    }
-  }
+  entity.characterController.face(targetWaypointCoordinate, speed / 2);
 }
 
 function onTickPathfindEnemy(entity: Entity, targetPlayers: Set<PlayerEntity>, speed: number, _tickDeltaMs: number) {
@@ -482,7 +452,6 @@ function onTickPathfindEnemy(entity: Entity, targetPlayers: Set<PlayerEntity>, s
   const entityId = entity.id!;
   enemyPathfindAccumulators[entityId] ??= 0; // Initialize the accumulator for this enemy if it isn't initialized yet
 
-  // Handle pathfinding
   if (!enemyPathfindingTargets[entityId] || enemyPathfindAccumulators[entityId] >= PATHFIND_ACCUMULATOR_THRESHOLD) {
     const targetPlayer = targetPlayers.values().next().value as PlayerEntity | undefined;
 
@@ -492,6 +461,7 @@ function onTickPathfindEnemy(entity: Entity, targetPlayers: Set<PlayerEntity>, s
 
     enemyPathfindAccumulators[entityId] -= PATHFIND_ACCUMULATOR_THRESHOLD;
 
+    // Make the spider jump if its close to the target player
     const currentPosition = entity.getTranslation();
     const dx = enemyPathfindingTargets[entityId].x - currentPosition.x;
     const dz = enemyPathfindingTargets[entityId].z - currentPosition.z;
@@ -501,46 +471,18 @@ function onTickPathfindEnemy(entity: Entity, targetPlayers: Set<PlayerEntity>, s
       const mass = entity.getMass();
       entity.applyImpulse({ x: 0, y: (10 * Math.random() + 5) * mass, z: 0 });
     }
-  }
-
-  enemyPathfindAccumulators[entityId]++;
 
-  // Handle movement to target
-  const currentPosition = entity.getTranslation();
-  const targetPosition = enemyPathfindingTargets[entityId];
-  const direction = {
-    x: targetPosition.x - currentPosition.x,
-    y: 0, // We only want rotation around Y axis, so ignore vertical difference
-    z: targetPosition.z - currentPosition.z,
-  };
-
-  // Normalize the direction vector
-  const length = Math.sqrt(direction.x * direction.x + direction.z * direction.z);
-  if (length > 0) {
-    direction.x /= length;
-    direction.z /= length;
+    // Handle Movement
+    if (!(entity.characterController instanceof SimpleCharacterController)) {
+      return console.warn('Enemy entity does not have a SimpleCharacterController!');
+    }
+  
+    const targetPosition = enemyPathfindingTargets[entityId];
+    entity.characterController.move(targetPosition, speed, { moveIgnoreAxes: { y: true } });
+    entity.characterController.face(targetPosition, speed / 2);
   }
 
-  // Calculate facing rotation
-  const angle = Math.atan2(direction.x, direction.z);
-  const adjustedAngle = angle + Math.PI;
-  const sinHalfAngle = Math.sin(adjustedAngle * 0.5);
-  const cosHalfAngle = Math.cos(adjustedAngle * 0.5);
-
-  entity.setRotation({ x: 0, y: sinHalfAngle, z: 0, w: cosHalfAngle });
-
-  // Calculate movement
-  const currentVelocity = entity.getLinearVelocity();
-
-  if (Math.abs(currentVelocity.x) < speed && Math.abs(currentVelocity.z) < speed) {
-    const movement = {
-      x: direction.x * speed,
-      y: currentVelocity.y,
-      z: direction.z * speed,
-    };
-
-    entity.setLinearVelocity(movement);
-  }
+  enemyPathfindAccumulators[entityId]++;
 }
 
 function onTickPlayerMovement(this: DefaultCharacterController, inputState: PlayerInputState, orientationState: PlayerOrientationState, _deltaTimeMs: number) {

package/package.json

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