@hytopia.com/examples 1.0.8 → 1.0.9

package/frontiers-rpg-game/src/GameClock.ts

@@ -29,6 +29,7 @@ export default class GameClock {
 
   public addRegionClockCycle(region: GameRegion): void {
     this._regions.add(region);
+    this._updateRegionClockCycle(region);
   }
 
   public removeRegionClockCycle(region: GameRegion): void {

package/frontiers-rpg-game/src/GameManager.ts

@@ -10,7 +10,7 @@ import ChitterForestRegion from './regions/chitter-forest/ChitterForestRegion';
 import RatkinNestRegion from './regions/ratkin-nest/RatkinNestRegion';
 import StalkhavenRegion from './regions/stalkhaven/StalkhavenRegion';
 import StalkhavenPortRegion from './regions/stalkhaven-port/StalkhavenPortRegion';
-// import WeaversHollowRegion from './regions/weavers-hollow/WeaversHollowRegion';
+import WeaversHollowRegion from './regions/weavers-hollow/WeaversHollowRegion';
 
 // Since globalEventRouter isn't exported in the main index, we'll handle cleanup differently
 // We can rely on the GamePlayer.remove() method being called manually when needed
@@ -63,10 +63,9 @@ export default class GameManager {
     this._startRegion = stalkhavenPortRegion;
 
     // Weaver's Hollow
-    // const weaversHollowRegion = new WeaversHollowRegion();
-    // this._regions.set(weaversHollowRegion.id, weaversHollowRegion);
-    // // GameClock.instance.addRegionClockCycle(weaversHollowRegion);
-    // this._startRegion = weaversHollowRegion;
+    const weaversHollowRegion = new WeaversHollowRegion();
+    this._regions.set(weaversHollowRegion.id, weaversHollowRegion);
+    GameClock.instance.addRegionClockCycle(weaversHollowRegion);
   }
 
   private _selectWorldForPlayer = async (player: Player): Promise<World | undefined> => {

package/frontiers-rpg-game/src/GamePlayer.ts

@@ -28,12 +28,10 @@ import TrainingSwordItem from './items/weapons/TrainingSwordItem';
 
 export enum GamePlayerPlayerEvent {
   DIED = 'GamePlayer.DIED',
-  RESPAWNED = 'GamePlayer.RESPAWNED',
 }
 
 export type GamePlayerPlayerEventPayloads = {
   [GamePlayerPlayerEvent.DIED]: null;
-  [GamePlayerPlayerEvent.RESPAWNED]: null;
 }
 
 export type NotificationType = 'success' | 'error' | 'warning' | 'complete' | 'new';
@@ -317,6 +315,13 @@ export default class GamePlayer {
     return this._skillExperience.get(skillId) ?? 0;
   }
 
+  public joinRegion(region: GameRegion, facingAngle: number, spawnPoint: Vector3Like): void {
+    this.setCurrentRegion(region);
+    this.setCurrentRegionSpawnFacingAngle(facingAngle);
+    this.setCurrentRegionSpawnPoint(spawnPoint);              
+    this.player.joinWorld(region.world);
+  }
+
   public async load(): Promise<void> {
     const serializedGamePlayerData = await this.player.getPersistedData();
 
@@ -351,17 +356,17 @@ export default class GamePlayer {
     // Restore health
     this.adjustHealth(this.maxHealth);
 
-    // Teleport to spawn point if available
-    this._currentEntity.setPosition(this.respawnPoint);
-
-    // Re enable movement if it was disabled
-    this._currentEntity.setIsMovementDisabled(false);
-
-    // Show respawn notification
-    this.showNotification('You have respawned!', 'success');
+    if (this._currentRegion?.respawnOverride) {
+      const region = GameManager.instance.getRegion(this._currentRegion.respawnOverride.regionId);
 
-    // Emit event to GamePlayer to handle respawn
-    this.eventRouter.emit(GamePlayerPlayerEvent.RESPAWNED, null);
+      if (region) {
+        this.joinRegion(region, this._currentRegion.respawnOverride.facingAngle, this._currentRegion.respawnOverride.spawnPoint);
+      }
+    } else { // Same region respawn, 
+      this._currentEntity.setPosition(this.respawnPoint);
+      this._currentEntity.setIsMovementDisabled(false);
+      this.showNotification('You have respawned!', 'success');
+    }
   }
 
   public setCurrentDialogueEntity(entity: BaseEntity): void {
@@ -436,8 +441,8 @@ export default class GamePlayer {
       
       // Restore current region if available
       if (playerData.currentRegionId) {
-        
         const region = GameManager.instance.getRegion(playerData.currentRegionId);
+        
         if (region) {
           this._currentRegion = region;
         }

package/frontiers-rpg-game/src/GamePlayerEntity.ts

@@ -99,6 +99,10 @@ export default class GamePlayerEntity extends DefaultPlayerEntity implements IDa
   public get isDamaged(): boolean {
     return this._gamePlayer.health < this._gamePlayer.maxHealth;
   }
+
+  public get isDead(): boolean {
+    return this._gamePlayer.isDead;
+  }
   
   public get isDodging(): boolean {
     const timeSinceDodge = performance.now() - this._lastDodgeTimeMs;
@@ -142,6 +146,10 @@ export default class GamePlayerEntity extends DefaultPlayerEntity implements IDa
     return this._gamePlayer.getSkillExperience(skillId);
   }
 
+  public joinRegion(region: GameRegion, facingAngle: number, spawnPoint: Vector3Like): void {
+    this._gamePlayer.joinRegion(region, facingAngle, spawnPoint);
+  }
+
   public setCurrentDialogueEntity(entity: any): void {
     this._gamePlayer.setCurrentDialogueEntity(entity);
   }

package/frontiers-rpg-game/src/GameRegion.ts

@@ -30,6 +30,12 @@ export type GameRegionPlayerEventPayloads = {
   [GameRegionPlayerEvent.REACHED]: { regionId: string };
 }
 
+export type GameRegionRespawnOverride = {
+  regionId: string,
+  facingAngle: number,
+  spawnPoint: Vector3Like,
+}
+
 export type GameRegionOptions = {
   id: string,
   ambientAudioUri?: string,
@@ -38,6 +44,7 @@ export type GameRegionOptions = {
   maxDirectionalLightIntensity?: number,
   minAmbientLightIntensity?: number,
   minDirectionalLightIntensity?: number,
+  respawnOverride?: GameRegionRespawnOverride,
   spawnFacingAngle?: number,
   spawnPoint?: Vector3Like,
 } & Omit<WorldOptions, 'id'>;
@@ -50,7 +57,8 @@ export default class GameRegion {
   private _maxDirectionalLightIntensity: number;
   private _minAmbientLightIntensity: number;
   private _minDirectionalLightIntensity: number;
-  private _outOfWorldCollider: Collider | undefined;
+  private _playerCount: number = 0;
+  private _respawnOverride: GameRegionRespawnOverride | undefined;
   private _spawnFacingAngle: number;
   private _spawnPoint: Vector3Like;
 
@@ -70,10 +78,12 @@ export default class GameRegion {
     this._maxDirectionalLightIntensity = regionOptions.maxDirectionalLightIntensity ?? DEFAULT_MAX_DIRECTIONAL_LIGHT_INTENSITY;
     this._minAmbientLightIntensity = regionOptions.minAmbientLightIntensity ?? DEFAULT_MIN_AMBIENT_LIGHT_INTENSITY;
     this._minDirectionalLightIntensity = regionOptions.minDirectionalLightIntensity ?? DEFAULT_MIN_DIRECTIONAL_LIGHT_INTENSITY;
+    this._respawnOverride = regionOptions.respawnOverride;
     this._spawnFacingAngle = regionOptions.spawnFacingAngle ?? 0;
     this._spawnPoint = regionOptions.spawnPoint ?? { x: 0, y: 10, z: 0 };
 
     this._world = WorldManager.instance.createWorld(regionOptions);
+    this._world.stop(); // Keep it in stopped state, when a player joins the world, we'll start it.
     this._world.on(PlayerEvent.JOINED_WORLD, ({ player }) => this.onPlayerJoin(player));
     this._world.on(PlayerEvent.LEFT_WORLD, ({ player }) => this.onPlayerLeave(player));
 
@@ -90,6 +100,7 @@ export default class GameRegion {
   public get minAmbientLightIntensity(): number { return this._minAmbientLightIntensity; }
   public get minDirectionalLightIntensity(): number { return this._minDirectionalLightIntensity; }
   public get name(): string { return this._world.name; }
+  public get respawnOverride(): GameRegionRespawnOverride | undefined { return this._respawnOverride; }
   public get spawnFacingAngle(): number { return this._spawnFacingAngle; }
   public get spawnPoint(): Vector3Like { return this._spawnPoint; }
   public get world(): World { return this._world; }
@@ -103,13 +114,13 @@ export default class GameRegion {
       this._ambientAudio.play(this._world);
     }
 
-    this._outOfWorldCollider = new Collider({
+    new Collider({ // Out of world collider
       shape: ColliderShape.BLOCK,
       halfExtents: { x: 500, y : 32, z: 500 },
       isSensor: true,
       relativePosition: { x: 0, y: -64, z: 0 },
       onCollision: this.onEntityOutOfWorld,
-      simulation: this._world.simulation, // setting this auto adds collider to simulation upon creation.
+      simulation: this._world.simulation, // setting this auto adds collider to simulation upon instantiation.
     });
 
     this._isSetup = true;
@@ -157,14 +168,25 @@ export default class GameRegion {
 
     // Emit the reached event to the player's event router.
     gamePlayer.eventRouter.emit(GameRegionPlayerEvent.REACHED, { regionId: this._id });
+
+    this._playerCount++;
+
+    // Only run the region physics & ticking if a player is in the region.
+    if (this._playerCount === 1) {
+      this._world.start();
+    }
   }
 
   protected onPlayerLeave(player: Player) {
     this._world.entityManager.getPlayerEntitiesByPlayer(player).forEach(entity => {
       entity.despawn();
     });
-    
-    // Note: We don't remove the GamePlayer instance here since the player
-    // might move to another region and we want to preserve their state
+
+    this._playerCount--;
+
+    // Stop the region physics & ticking if no players are in the region.
+    if (this._playerCount <= 0) {
+      this._world.stop();
+    }
   }
 }

package/frontiers-rpg-game/src/entities/BaseCombatEntity.ts

@@ -7,6 +7,7 @@ import {
   ErrorHandler,
   EventPayloads,
   QuaternionLike,
+  RawShape,
   Vector3,
   Vector3Like,
   World,
@@ -33,6 +34,7 @@ export type BaseCombatEntityAttack = {
   simpleAttackDamageVariance?: number; // Percentage variance (0-1), e.g., 0.2 = ±20% damage
   simpleAttackDamageDelayMs?: number; // When during animation to deal damage (if projectile, delay after hit)
   simpleAttackReach?: number; // Applies damage if target is < reach after delay
+  stopMovingDuringDelay?: boolean;
   weight: number;
   onHit?: (target: BaseEntity | GamePlayerEntity, attacker: BaseCombatEntity) => void;
 }
@@ -69,7 +71,9 @@ export default class BaseCombatEntity extends BaseEntity {
   private _attackAccumulatorMs: number = 0;
   private _attackCooldownMs: number = 0;
   private _attackTotalWeight: number = 0;
+  private _diameterSquared: number = 0;
   private _nextAttack: BaseCombatEntityAttack | null = null;
+  private _stopMoving: boolean = false;
 
   constructor(options: BaseCombatEntityOptions) {
     super({
@@ -84,7 +88,7 @@ export default class BaseCombatEntity extends BaseEntity {
     this._aggroSensorForwardOffset = options.aggroSensorForwardOffset ?? 0;
     this._attacks = options.attacks ?? [];
     this._attackTotalWeight = this._attacks.reduce((sum, attack) => sum + attack.weight, 0);
-    
+    this._diameterSquared = this.width > this.depth ? this.width ** 2 : this.depth ** 2;
     this._nextAttack = this._pickRandomAttack();
     
     // Set accumulator to interval to trigger immediate target check on first tick
@@ -106,6 +110,8 @@ export default class BaseCombatEntity extends BaseEntity {
     this.on(EntityEvent.TICK, this._onTick);
   }
 
+  public get diameterSquared(): number { return this._diameterSquared; }
+
   public attack() {
     if (!this._nextAttack || !this._aggroActiveTarget) return;
     
@@ -113,19 +119,24 @@ export default class BaseCombatEntity extends BaseEntity {
     const target = this._aggroActiveTarget;
     
     this.startModelOneshotAnimations(attack.animations);
+
+    if (attack.stopMovingDuringDelay) {
+      this.stopMoving();
+      this._stopMoving = true;
+    }
     
     if (!attack.complexAttack) { // Simple attack, animation + damage
       setTimeout(() => {
-        if (!target || !this._aggroPotentialTargets.has(target) || this.isDying) return;
+        if (!target || !this._aggroPotentialTargets.has(target) || this.isDead) return;
         
         if (!attack.simpleAttackDamage) {
           return ErrorHandler.warning(`BaseCombatEntity.attack(): Simple attack has no simple attack damage!`);
         };
         
-        const distanceSquared = this._distanceSquaredToTarget(target);
+        const distanceSquared = this.calculateDistanceSquaredToTarget(target);
         const reachSquared = attack.simpleAttackReach ? attack.simpleAttackReach ** 2 : attack.range ** 2;
         
-        if (distanceSquared <= reachSquared) { // make sure target is in reach still
+        if (distanceSquared <= reachSquared + this._diameterSquared) { // make sure target is in reach still
           if (isDamageable(target)) {
             const damage = this.calculateDamageWithVariance(attack.simpleAttackDamage, attack.simpleAttackDamageVariance);
             target.takeDamage(damage, this);
@@ -135,15 +146,19 @@ export default class BaseCombatEntity extends BaseEntity {
             attack.onHit(target, this);
           }
         }
+        
+        this._stopMoving = false;
       }, attack.simpleAttackDamageDelayMs ?? 0);
     } else { // Complex attack, such as projectile, spell, AoE, etc
       setTimeout(() => {
-        if (this.isDying || !attack.complexAttack || !this.world) return;
+        if (this.isDead || !attack.complexAttack || !this.world) return;
 
         attack.complexAttack({
           attacker: this,
           target: target,
         });
+
+        this._stopMoving = false;
       }, attack.complexAttackDelayMs ?? 0);
     }
 
@@ -168,6 +183,26 @@ export default class BaseCombatEntity extends BaseEntity {
     return { x: target.x, y: target.y, z: target.z };
   }
 
+  public calculateDistanceSquaredToTarget(target: BaseEntity | GamePlayerEntity): number {
+    return this._distanceSquaredBetweenPositions(this.position, target.position);
+  }
+
+  public getTargetsByRawShapeIntersection(rawShape: RawShape, position: Vector3Like, rotation: QuaternionLike): Entity[] {
+    if (!this.world) return [];
+
+    const intersectionsResults = this.world.simulation.intersectionsWithRawShape(
+      rawShape,
+      position,
+      rotation,
+      {
+        filterExcludeRigidBody: this.rawRigidBody, // ignore self (parent/player)
+        filterFlags: 8, // Rapier flag to exclude sensor colliders
+      },
+    );
+
+    return intersectionsResults.map(result => result.intersectedEntity).filter(Boolean) as Entity[];
+  }
+
   public override spawn(world: World, position: Vector3Like, rotation?: QuaternionLike): void {
     super.spawn(world, position, rotation);
 
@@ -214,16 +249,14 @@ export default class BaseCombatEntity extends BaseEntity {
     return dx * dx + dy * dy + dz * dz;
   }
 
-  private _distanceSquaredToTarget(target: BaseEntity | GamePlayerEntity): number {
-    return this._distanceSquaredBetweenPositions(this.position, target.position);
-  }
-
   private _findClosestAggroTarget(): BaseEntity | GamePlayerEntity | null {
     let closestTarget: BaseEntity | GamePlayerEntity | null = null;
     let closestDistanceSquared = Infinity;
 
     for (const target of this._aggroPotentialTargets) {
-      const distanceSquared = this._distanceSquaredToTarget(target);
+      if (target.isDead) continue;
+
+      const distanceSquared = this.calculateDistanceSquaredToTarget(target);
 
       if (distanceSquared < closestDistanceSquared) {
         closestDistanceSquared = distanceSquared;
@@ -248,7 +281,7 @@ export default class BaseCombatEntity extends BaseEntity {
 
   private _hasAttackInRange(targetDistanceSquared: number): boolean {
     for (const attack of this._attacks) {
-      if (targetDistanceSquared <= attack.range ** 2) {
+      if (targetDistanceSquared <= attack.range ** 2 + this._diameterSquared) {
         return true;
       }
     }
@@ -269,16 +302,20 @@ export default class BaseCombatEntity extends BaseEntity {
 
     if (!this._aggroActiveTarget) return;
 
-    const targetDistanceSquared = this._distanceSquaredToTarget(this._aggroActiveTarget);
+    const targetDistanceSquared = this.calculateDistanceSquaredToTarget(this._aggroActiveTarget);
+
+    if (targetDistanceSquared < this._diameterSquared) {
+      this.stopMoving(); // Don't push into target when in contact range.
+    }
 
     // Handle attacks if available
     if (this._nextAttack) {
       const attackRangeSquared = this._nextAttack.range ** 2;
 
-      if (targetDistanceSquared <= attackRangeSquared && this._attackAccumulatorMs >= this._attackCooldownMs) {
+      if (targetDistanceSquared <= attackRangeSquared + this._diameterSquared && this._attackAccumulatorMs >= this._attackCooldownMs) {
         this._attackAccumulatorMs = 0;
         this.attack();
-      } else if (targetDistanceSquared > attackRangeSquared) {
+      } else if (targetDistanceSquared > attackRangeSquared + this._diameterSquared) {
         // Target is out of current attack range, only repick if there's an attack that can reach the target
         if (this._hasAttackInRange(targetDistanceSquared)) {
           this._attackAccumulatorMs = Math.max(0, this._attackAccumulatorMs - 500); // Prevent too-frequent repicking every tick
@@ -286,20 +323,24 @@ export default class BaseCombatEntity extends BaseEntity {
         }
       }
 
+      if (this._stopMoving) {
+        return;
+      }
+
       // Update movement strategy
       if (this.moveSpeed > 0 && this._aggroPathfindAccumulatorMs >= this._aggroPathfindIntervalMs) {
         this._updateMovementStrategy(targetDistanceSquared);
       }
 
       if (!this._aggroPathfinding) {
-        // Only move if not within attack range and can move, but always face the target
-        if (this.moveSpeed > 0 && targetDistanceSquared > attackRangeSquared) {
+        // Only move if not within contact range and can move, but always face the target
+        if (this.moveSpeed > 0 && targetDistanceSquared > this._diameterSquared + 2) {
           this.moveTo(this._aggroActiveTarget.position);
         }
         
         this.faceTowards(this._aggroActiveTarget.position, this.faceSpeed);
       }
-    } else {
+    } else if (!this._stopMoving) {
       // No attacks - just follow the target
       if (this.moveSpeed > 0 && this._aggroPathfindAccumulatorMs >= this._aggroPathfindIntervalMs) {
         this._updateMovementStrategy(targetDistanceSquared);
@@ -340,7 +381,7 @@ export default class BaseCombatEntity extends BaseEntity {
     if (!this._aggroActiveTarget) return true;
     if (!this._aggroPathfinding) return true; // Always switch when using simple movement
     
-    return this._distanceSquaredToTarget(newTarget) * 2 < this._distanceSquaredToTarget(this._aggroActiveTarget);
+    return this.calculateDistanceSquaredToTarget(newTarget) * 2 < this.calculateDistanceSquaredToTarget(this._aggroActiveTarget);
   }
 
   private _updateMovementStrategy(targetDistanceSquared: number): void {
@@ -354,13 +395,17 @@ export default class BaseCombatEntity extends BaseEntity {
     
     const distanceMovedSquared = this._distanceSquaredBetweenPositions(this._aggroPathfindLastPosition, this.position);
     const isStuck = distanceMovedSquared < MOVEMENT_NOT_STUCK_DISTANCE_SQUARED;
-    const notAtDestination = this._nextAttack ? targetDistanceSquared > this._nextAttack.range ** 2 : false;
+    const notAtDestination = this._nextAttack ? targetDistanceSquared > this._nextAttack.range ** 2 + this._diameterSquared : false;
     const shouldPathfind = isStuck && notAtDestination;
 
     if (shouldPathfind !== this._aggroPathfinding) {
       this._aggroPathfinding = shouldPathfind;
       if (shouldPathfind && this._aggroActiveTarget) {
-        this.pathfindTo(this._aggroActiveTarget.position, this.moveSpeed);
+        this.pathfindTo(this._aggroActiveTarget.position, this.moveSpeed, {
+          ...this.pathfindingOptions,
+          pathfindAbortCallback: () => this._aggroPathfinding = false,
+          pathfindCompleteCallback: () => this._aggroPathfinding = false,
+        });
       }
     }
     
@@ -372,9 +417,9 @@ export default class BaseCombatEntity extends BaseEntity {
     if (this._aggroPotentialTargets.size > 0) {
       this._aggroRetargetAccumulatorMs = 0;
     }
-    
+
     // Handle lost target
-    if (this._aggroActiveTarget && !this._aggroPotentialTargets.has(this._aggroActiveTarget)) {
+    if (this._aggroActiveTarget && (!this._aggroPotentialTargets.has(this._aggroActiveTarget) || this._aggroActiveTarget.isDead)) {
       this._handleLostTarget();
     }
     

package/frontiers-rpg-game/src/entities/BaseEntity.ts

@@ -159,13 +159,14 @@ export default class BaseEntity extends Entity implements IInteractable, IDamage
   public get idleAnimations(): string[] { return this.pathfindingController.idleLoopedAnimations; }
   public get idleAnimationsSpeed(): number | undefined { return this.pathfindingController.idleLoopedAnimationsSpeed; }
   public get interactActionText(): string | undefined { return this._interactActionText; }
-  public get isDying(): boolean { return this._dying; }
+  public get isDead(): boolean { return this._dying; }
   public get isInteractable(): boolean { return !!this._dialogueRoot || !!this._interactActionText; }
   public get health(): number { return this._health; }
   public get maxHealth(): number { return this._maxHealth; }
   public get moveAnimations(): string[] { return this.pathfindingController.moveLoopedAnimations; }
   public get moveAnimationsSpeed(): number | undefined { return this.pathfindingController.moveLoopedAnimationsSpeed; }
   public get moveSpeed(): number { return this._moveSpeed; }
+  public get pathfindingOptions(): PathfindingOptions | undefined { return this._pathfindingOptions; }
   public get pathfindingController(): PathfindingEntityController { return this.controller as PathfindingEntityController; }
   public get pushable(): boolean { return this._pushable; }
 
@@ -175,6 +176,7 @@ export default class BaseEntity extends Entity implements IInteractable, IDamage
     this._dying = true;
 
     this.startModelOneshotAnimations(this._deathAnimations);
+    this.stopFacing();
     this.stopMoving();
     this.dropItems();
 
@@ -285,8 +287,11 @@ export default class BaseEntity extends Entity implements IInteractable, IDamage
     });
   }
 
-  public stopMoving() {
+  public stopFacing() {
     this.pathfindingController.stopFace();
+  }
+
+  public stopMoving() {
     this.pathfindingController.stopMove();
   }
 

package/frontiers-rpg-game/src/entities/PortalEntity.ts

@@ -5,7 +5,6 @@ import {
   Entity,
   ErrorHandler,
   ModelEntityOptions,
-  QuaternionLike,
   RigidBodyType,
   Vector3Like
 } from 'hytopia';
@@ -14,15 +13,19 @@ import GameManager from '../GameManager';
 import GamePlayerEntity from '../GamePlayerEntity';
 
 export type PortalEntityOptions = {
+  delayS?: number;
   destinationRegionId: string;
   destinationRegionFacingAngle?: number;
   destinationRegionPosition: Vector3Like;
+  type?: 'normal' | 'boss';
 } & ModelEntityOptions;
 
 export default class PortalEntity extends Entity {
+  public readonly delayS: number;
   public readonly destinationRegionId: string;
   public readonly destinationRegionFacingAngle: number;
   public readonly destinationRegionPosition: Vector3Like;
+  private readonly _playerTimeouts = new Map<GamePlayerEntity, NodeJS.Timeout>();
 
   public constructor(options: PortalEntityOptions) {
     const colliderOptions = Collider.optionsFromModelUri('models/environment/portal.gltf', options.modelScale ?? 1, ColliderShape.BLOCK) as BlockColliderOptions;
@@ -37,30 +40,55 @@ export default class PortalEntity extends Entity {
         colliders: [
           {
             ...colliderOptions,
-            relativePosition: { x: 0, y: 0, z: 0.5 }, // inset the sensor a bit
             isSensor: true,
             onCollision: (other, started) => {
-              if (!started || !(other instanceof GamePlayerEntity)) return;
-              
-              const destinationRegion = GameManager.instance.getRegion(this.destinationRegionId);
-              
-              if (!destinationRegion) {
-                ErrorHandler.warning(`PortalEntity: Destination region ${this.destinationRegionId} not found`);
-                return;
+              if (!(other instanceof GamePlayerEntity)) return;
+
+              if (started) {
+                if (this.delayS > 0) {
+                  other.showNotification(`This is a delayed portal! You'll be teleported in ${this.delayS} seconds. You must stay in the portal area.`, 'warning');
+                  const timeout = setTimeout(() => this._teleportPlayer(other), this.delayS * 1000);
+                  this._playerTimeouts.set(other, timeout);
+                } else {
+                  this._teleportPlayer(other);
+                }
+              } else {
+                const timeout = this._playerTimeouts.get(other);
+
+                if (timeout) {
+                  clearTimeout(timeout);
+                  this._playerTimeouts.delete(other);
+                  other.showNotification('You exited the delayed portal. Please re-enter the portal again to be teleported.', 'warning');
+                }
               }
-              other.gamePlayer.setCurrentRegion(destinationRegion);
-              other.gamePlayer.setCurrentRegionSpawnFacingAngle(this.destinationRegionFacingAngle);
-              other.gamePlayer.setCurrentRegionSpawnPoint(this.destinationRegionPosition);              
-              other.player.joinWorld(destinationRegion.world);
             },
           },
         ],
       },
+      tintColor: options.type === 'boss' ? { r: 255, g: 255, b: 0 } : undefined,
       ...options,
     });
 
+    this.delayS = options.delayS ?? 0;
     this.destinationRegionId = options.destinationRegionId;
     this.destinationRegionFacingAngle = options.destinationRegionFacingAngle ?? 0;
     this.destinationRegionPosition = options.destinationRegionPosition;
   }
+
+  private _teleportPlayer(player: GamePlayerEntity): void {
+    const destinationRegion = GameManager.instance.getRegion(this.destinationRegionId);
+
+    if (!destinationRegion) {
+      ErrorHandler.warning(`PortalEntity: Destination region ${this.destinationRegionId} not found`);
+      return;
+    }
+
+    if (player.isDead) {
+      return;
+    }
+
+    player.joinRegion(destinationRegion, this.destinationRegionFacingAngle, this.destinationRegionPosition);
+
+    this._playerTimeouts.delete(player);
+  }
 }

package/frontiers-rpg-game/src/entities/enemies/LesserBlightBloomEntity.ts

@@ -12,13 +12,12 @@ import GoldItem from '../../items/general/GoldItem';
 
 export type LesserBlightBloomEntityOptions = {
 
-} & BaseCombatEntityOptions;
+} & Partial<BaseCombatEntityOptions>;
 
 export default class LesserBlightBloomEntity extends BaseCombatEntity {
   constructor(options?: LesserBlightBloomEntityOptions) {
     super({
       aggroRadius: 8,
-      aggroSensorForwardOffset: 0,
       attacks: [
         { // Eat
           animations: [ 'eat' ],