@hytopia.com/examples 1.0.27 → 1.0.28

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

@@ -46,19 +46,16 @@ export default class GameManager {
     const chitterForestRegion = new ChitterForestRegion();
     this._regions.set(chitterForestRegion.id, chitterForestRegion);
     GameClock.instance.addRegionClockCycle(chitterForestRegion);
-    // this._startRegion = chitterForestRegion;
 
     // Hearthwilds
     const hearthwildsRegion = new HearthwildsRegion();
     this._regions.set(hearthwildsRegion.id, hearthwildsRegion);
     GameClock.instance.addRegionClockCycle(hearthwildsRegion);
-    this._startRegion = hearthwildsRegion;
 
     // Ratkin Nest
     const ratkinNestRegion = new RatkinNestRegion();
     this._regions.set(ratkinNestRegion.id, ratkinNestRegion);
     GameClock.instance.addRegionClockCycle(ratkinNestRegion);
-    // this._startRegion = ratkinNestRegion;
     
     // Stalkhaven
     const stalkhavenRegion = new StalkhavenRegion();
@@ -69,7 +66,7 @@ export default class GameManager {
     const stalkhavenPortRegion = new StalkhavenPortRegion();
     this._regions.set(stalkhavenPortRegion.id, stalkhavenPortRegion);
     GameClock.instance.addRegionClockCycle(stalkhavenPortRegion);
-    // this._startRegion = stalkhavenPortRegion;
+    this._startRegion = stalkhavenPortRegion;
 
     // Weaver's Hollow
     const weaversHollowRegion = new WeaversHollowRegion();

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

@@ -12,6 +12,7 @@ import {
   WorldOptions,
   Vector3Like,
   Quaternion,
+  RgbColor,
 } from 'hytopia';
 
 import GamePlayer from './GamePlayer';
@@ -52,6 +53,7 @@ export type GameRegionOptions = {
 export default class GameRegion {
   private _id: string;
   private _ambientAudio: Audio | undefined;
+  private _baseFogColor: RgbColor | undefined;
   private _isSetup: boolean = false;
   private _maxAmbientLightIntensity: number;
   private _maxDirectionalLightIntensity: number;
@@ -74,6 +76,7 @@ export default class GameRegion {
       loop: true,
     }) : undefined;
 
+    this._baseFogColor = regionOptions.fogColor;
     this._maxAmbientLightIntensity = regionOptions.maxAmbientLightIntensity ?? DEFAULT_MAX_AMBIENT_LIGHT_INTENSITY;
     this._maxDirectionalLightIntensity = regionOptions.maxDirectionalLightIntensity ?? DEFAULT_MAX_DIRECTIONAL_LIGHT_INTENSITY;
     this._minAmbientLightIntensity = regionOptions.minAmbientLightIntensity ?? DEFAULT_MIN_AMBIENT_LIGHT_INTENSITY;
@@ -81,13 +84,13 @@ export default class GameRegion {
     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));
     this._world.on(PlayerEvent.RECONNECTED_WORLD, ({ player }) => this.onPlayerReconnected(player));
-
+    
     // temp
     // this._world.simulation.enableDebugRendering(true);
     // this._world.simulation.enableDebugRaycasting(true);
@@ -96,6 +99,7 @@ export default class GameRegion {
   }
 
   public get id(): string { return this._id; }
+  public get baseFogColor(): RgbColor | undefined { return this._baseFogColor; }
   public get maxAmbientLightIntensity(): number { return this._maxAmbientLightIntensity; }
   public get maxDirectionalLightIntensity(): number { return this._maxDirectionalLightIntensity; }
   public get minAmbientLightIntensity(): number { return this._minAmbientLightIntensity; }

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

@@ -37,6 +37,8 @@ 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
+  stopAllAnimationForMs?: number;
+  stopMovingForDurationMs?: number;
   stopMovingDuringDelay?: boolean;
   weight: number;
   onHit?: (target: BaseEntity | GamePlayerEntity, attacker: BaseCombatEntity) => void;
@@ -49,6 +51,7 @@ export type BaseCombatEntityOptions = {
   aggroSensorForwardOffset?: number;
   aggroTargetTypes?: (typeof BaseEntity | typeof GamePlayerEntity)[];
   attacks?: BaseCombatEntityAttack[];
+  diameterOverride?: number;
   health: number;
   outOfCombatRegenDelayMs?: number;
   outOfCombatRegenPerSecondRate?: number; // rate per second as a percent, ie 0.03 is 3% per second
@@ -97,7 +100,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._diameterSquared = options.diameterOverride ? options.diameterOverride ** 2 : (this.width > this.depth ? this.width ** 2 : this.depth ** 2);
     this._nextAttack = this._pickRandomAttack();
     this._outOfCombatRegenDelayMs = options.outOfCombatRegenDelayMs ?? COMBAT_REGEN_DEFAULT_DELAY_MS;
     this._outOfCombatRegenPerSecondRate = options.outOfCombatRegenPerSecondRate ?? COMBAT_REGEN_DEFAULT_RATE;
@@ -121,6 +124,7 @@ export default class BaseCombatEntity extends BaseEntity {
     this.on(EntityEvent.TICK, this._onTick);
   }
 
+  public get attacks(): BaseCombatEntityAttack[] { return this._attacks; }
   public get diameterSquared(): number { return this._diameterSquared; }
 
   public attack() {
@@ -128,38 +132,38 @@ export default class BaseCombatEntity extends BaseEntity {
     
     const attack = this._nextAttack;
     const target = this._aggroActiveTarget;
-    
+
+    if (attack.stopAllAnimationForMs && !this.isDead) {
+      const idleAnimations = this.pathfindingController.idleLoopedAnimations;
+      const moveAnimations = this.pathfindingController.moveLoopedAnimations;
+
+      this.pathfindingController.idleLoopedAnimations = [];
+      this.pathfindingController.moveLoopedAnimations = [];
+      this.stopAllModelAnimations();
+
+      setTimeout(() => {
+        if (this.isDead) return;
+        this.pathfindingController.idleLoopedAnimations = idleAnimations;
+        this.pathfindingController.moveLoopedAnimations = moveAnimations;
+        this.startModelLoopedAnimations(idleAnimations);
+      }, attack.stopAllAnimationForMs);
+    }
+
     this.startModelOneshotAnimations(attack.animations);
 
     if (attack.stopMovingDuringDelay) {
       this.stopMoving();
       this._stopMoving = true;
     }
+
+    if (attack.stopMovingForDurationMs) {
+      this.stopMoving();
+      this._stopMoving = true;
+      setTimeout(() => this._stopMoving = false, attack.stopMovingForDurationMs);
+    }
     
     if (!attack.complexAttack) { // Simple attack, animation + damage
-      setTimeout(() => {
-        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.calculateDistanceSquaredToTarget(target);
-        const reachSquared = attack.simpleAttackReach ? attack.simpleAttackReach ** 2 : attack.range ** 2;
-        
-        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);
-          }
-          
-          if (attack.onHit) {
-            attack.onHit(target, this);
-          }
-        }
-        
-        this._stopMoving = false;
-      }, attack.simpleAttackDamageDelayMs ?? 0);
+      setTimeout(() => this.processSimpleAttack(target, attack), attack.simpleAttackDamageDelayMs ?? 0);
     } else { // Complex attack, such as projectile, spell, AoE, etc
       setTimeout(() => {
         if (this.isDead || !attack.complexAttack || !this.world) return;
@@ -169,7 +173,9 @@ export default class BaseCombatEntity extends BaseEntity {
           target: target,
         });
 
-        this._stopMoving = false;
+        if (attack.stopMovingDuringDelay) {
+          this._stopMoving = false;
+        }
       }, attack.complexAttackDelayMs ?? 0);
     }
 
@@ -248,6 +254,32 @@ export default class BaseCombatEntity extends BaseEntity {
     return Math.floor(min + Math.random() * (max - min));
   }
 
+  protected processSimpleAttack(target: BaseEntity | GamePlayerEntity, attack: BaseCombatEntityAttack) {
+    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.calculateDistanceSquaredToTarget(target);
+    const reachSquared = attack.simpleAttackReach ? attack.simpleAttackReach ** 2 : attack.range ** 2;
+    
+    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);
+      }
+      
+      if (attack.onHit) {
+        attack.onHit(target, this);
+      }
+    }
+    
+    if (attack.stopMovingDuringDelay) {
+      this._stopMoving = false;
+    }
+  }
+
   protected override shouldDeferWander(): boolean {
     return !!this._aggroActiveTarget;
   }

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

@@ -1,6 +1,6 @@
 import {
   Entity,
-  EntityOptions,
+  ModelEntityOptions,
   MoveOptions,
   PathfindingEntityController,
   PathfindingOptions,
@@ -80,8 +80,9 @@ export type BaseEntityOptions = {
   nameplateType?: BaseEntityNameplateType;
   nameplateViewDistnace?: number;
   pathfindingOptions?: PathfindingOptions;
+  rotatesOnInteract?: boolean;
   pushable?: boolean;
-} & EntityOptions;
+} & ModelEntityOptions;
 
 export type WanderOptions = {
   idleMinMs: number;
@@ -111,6 +112,7 @@ export default class BaseEntity extends Entity implements IInteractable, IDamage
   private _optionMap: Map<number, BaseEntityDialogueOption> = new Map();
   private _pathfindingOptions: PathfindingOptions | undefined;
   private _pushable: boolean;
+  private _rotatesOnInteract: boolean;
   private _wanderTimeout: NodeJS.Timeout | undefined;
   
   public constructor(options: BaseEntityOptions = {}) {
@@ -143,6 +145,8 @@ export default class BaseEntity extends Entity implements IInteractable, IDamage
     this._nameplateViewDistance = options.nameplateViewDistnace;
     this._pathfindingOptions = options.pathfindingOptions;
     this._pushable = options.pushable ?? false;
+    this._rotatesOnInteract = options.rotatesOnInteract ?? true;
+
     if (this._dialogueRoot) {
       this._buildDialogueOptionMap();
     }
@@ -234,7 +238,10 @@ export default class BaseEntity extends Entity implements IInteractable, IDamage
     if (this._dialogueRoot) {
       interactor.setCurrentDialogueEntity(this);
       this.showDialogue(interactor, this._dialogueRoot.dialogue);
-      this.faceTowards(interactor.position, 8);
+
+      if (this._rotatesOnInteract) {
+        this.faceTowards(interactor.position, 8);
+      }
     }
   }
 

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

@@ -0,0 +1,190 @@
+import { Collider, ColliderShape, ParticleEmitter, RigidBodyType } from "hytopia";
+import BaseCombatEntity, { BaseCombatEntityOptions } from "../BaseCombatEntity";
+import GamePlayerEntity from "../../GamePlayerEntity";
+import { isDamageable } from '../../interfaces/IDamageable';
+import type { Vector3Like, QuaternionLike, World } from 'hytopia';
+import type BaseEntity from "../BaseEntity"; 
+
+// Aggro Target Types
+import ReclusiveWeaverEntity from "./ReclusiveWeaverEntity";
+
+// Drops
+import GoldItem from "../../items/general/GoldItem";
+import ChieftanBladeItem from "../../items/weapons/ChieftanBladeItem";
+import GoldIngotItem from "../../items/materials/GoldIngotItem";
+import GorkinEarItem from "../../items/materials/GorkinEarItem";
+import GorkinEyeItem from "../../items/materials/GorkinEyeItem";
+import GorkinFootItem from "../../items/materials/GorkinFootItem";
+import GorkinHandItem from "../../items/materials/GorkinHandItem";
+import GorkinSkullItem from "../../items/materials/GorkinSkullItem";
+import IronIngotItem from "../../items/materials/IronIngotItem";
+import ShatteredSwordItem from "../../items/materials/ShatteredSwordItem";
+import ShackleItem from "../../items/materials/ShackleItem";
+import SilverSlabItem from "../../items/materials/SilverSlabItem";
+import ToughMonsterHide from "../../items/materials/ToughMonsterHide";
+
+export type GorkinChieftanEntityOptions = {
+
+} & Partial<BaseCombatEntityOptions>;
+
+export default class GorkinChieftanEntity extends BaseCombatEntity {
+  private _stompParticleEmitter: ParticleEmitter;
+
+  constructor(options?: GorkinChieftanEntityOptions) {
+    super({
+      aggroRadius: 9,
+      aggroSensorForwardOffset: 3,
+      aggroTargetTypes: [
+        GamePlayerEntity,
+        ReclusiveWeaverEntity,
+      ],
+      attacks: [
+        { // Slash, stab attack
+          animations: [ 'atk1' ],
+          complexAttack: (params) => this._slashStabAttack(params.target),
+          complexAttackDelayMs: 700,
+          cooldownMs: 3500,
+          simpleAttackDamage: 70, // complex attack triggers simple attack processing
+          simpleAttackDamageVariance: 0.3,
+          stopAllAnimationForMs: 2500,
+          stopMovingForDurationMs: 2500,
+          range: 3,
+          weight: 2,
+        },
+        { // Stomp
+          animations: [ 'atk2' ],
+          complexAttack: () => this._stompAttack(),
+          complexAttackDelayMs: 550,
+          cooldownMs: 1800,
+          range: 4,
+          stopAllAnimationForMs: 1400,
+          stopMovingForDurationMs: 1400,
+          weight: 1,
+        },
+        { // Double slash attack
+          animations: [ 'atk3' ],
+          complexAttack: (params) => this._doubleSlashAttack(params.target),
+          complexAttackDelayMs: 850,
+          cooldownMs: 3500,
+          simpleAttackDamage: 55, // complex attack triggers simple attack processing
+          simpleAttackDamageVariance: 0.2,
+          stopAllAnimationForMs: 2500,
+          stopMovingForDurationMs: 2500,
+          range: 4,
+          weight: 1,
+        },
+      ],
+      combatExperienceReward: 850,
+      deathAnimations: [ 'death' ],
+      deathDespawnDelayMs: 2400,
+      deathItemDrops: [
+        { itemClass: GoldItem, minQuantity: 30, maxQuantity: 45, weight: 20 },
+        { itemClass: GorkinEyeItem, minQuantity: 1, maxQuantity: 2, weight: 15 },
+        { itemClass: GorkinFootItem, minQuantity: 1, maxQuantity: 2, weight: 15 },
+        { itemClass: GorkinHandItem, minQuantity: 1, maxQuantity: 2, weight: 15 },
+        { itemClass: ShatteredSwordItem, weight: 10 },
+        { itemClass: ToughMonsterHide, weight: 10 },
+        { itemClass: GorkinSkullItem, weight: 10 },
+        { itemClass: ShackleItem, weight: 10 },
+        { itemClass: GoldIngotItem, minQuantity: 1, maxQuantity: 2, weight: 5 },
+        { itemClass: IronIngotItem, minQuantity: 1, maxQuantity: 2, weight: 5 },
+        { itemClass: SilverSlabItem, minQuantity: 1, maxQuantity: 2, weight: 5 },
+        { itemClass: GorkinEarItem, minQuantity: 1, maxQuantity: 2, weight: 5 },
+        { itemClass: ChieftanBladeItem, weight: 1 },
+      ],
+      deathItemMaxDrops: 3,
+      diameterOverride: 0.75,
+      health: 1550,
+      idleAnimations: [ 'idle' ],
+      modelUri: 'models/enemies/gorkin-chieftan.gltf',
+      modelPreferredShape: ColliderShape.CAPSULE,
+      modelScale: 1.1,
+      moveAnimations: [ 'fastwalk' ],
+      moveSpeed: 5,
+      moveAnimationSpeed: 1.25,
+      name: 'Gorkin Chieftan',
+      nameplateType: 'boss',
+      rigidBodyOptions: {
+        type: RigidBodyType.DYNAMIC,
+        colliders: [ // manually sized collider since the chain whip breaks auto calculations
+          {
+            shape: ColliderShape.CAPSULE,
+            halfHeight: 0.8,
+            radius: 0.75,
+          },
+        ],
+      },
+      pathfindingOptions: {
+        maxJump: 3,
+        maxFall: 3,
+      },
+      ...options,
+    });
+
+    this._stompParticleEmitter = new ParticleEmitter({
+      textureUri: 'particles/dirt.png',
+      attachedToEntity: this,
+      colorStart: { r: 194, g: 164, b: 132 },
+      offset: { x: 0, y: -1, z: 0 },
+      size: 1,
+      sizeVariance: 1,
+      lifetime: 5,
+      lifetimeVariance: 3,
+      rate: 125,
+      maxParticles: 250,
+      velocity: { x: 0, y: 6, z: 0 },
+      velocityVariance: { x: 6, y: 2, z: 6 },
+    });
+  }
+
+  public override spawn(world: World, position: Vector3Like, rotation: QuaternionLike) {
+    super.spawn(world, position, rotation);
+    this._stompParticleEmitter.spawn(world);
+    this._stompParticleEmitter.stop();
+  }
+
+  private _doubleSlashAttack(target: BaseEntity | GamePlayerEntity) {
+    this.processSimpleAttack(target, this.attacks[2]);
+    setTimeout(() => this.processSimpleAttack(target, this.attacks[2]), 650);
+  }
+
+  private _slashStabAttack(target: BaseEntity | GamePlayerEntity) {
+    this.processSimpleAttack(target, this.attacks[0]);
+    setTimeout(() => this.processSimpleAttack(target, this.attacks[0]), 1000);
+  }
+
+  private _stompAttack() {
+    if (!this.world) return;
+
+    this._stompParticleEmitter.restart();
+    setTimeout(() => this._stompParticleEmitter.stop(), 500);
+
+    const aoeCollider = new Collider({
+      shape: ColliderShape.CYLINDER,
+      halfHeight: this.height / 2,
+      radius: Math.sqrt(this.diameterSquared) / 2 + 3,
+    })
+
+    const targets = this.getTargetsByRawShapeIntersection(
+      aoeCollider.rawShape,
+      this.position,
+      this.rotation,
+    );
+
+    for (const target of targets) {
+      if (!target.isSpawned || !isDamageable(target)) continue;
+
+      target.takeDamage(this.calculateDamageWithVariance(80, 0.2));
+
+      // Ignore impulse if dodging.
+      if (target instanceof GamePlayerEntity && target.isDodging) continue;
+
+      const direction = this.calculateDirectionToTargetPosition(target.position);
+      target.applyImpulse({
+        x: direction.x * 13 * target.mass,
+        y: 5 * target.mass,
+        z: direction.z * 13 * target.mass,
+      });
+    }
+  }
+}

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

@@ -0,0 +1,87 @@
+import { ColliderShape, RigidBodyType } from "hytopia";
+import BaseCombatEntity, { BaseCombatEntityOptions } from "../BaseCombatEntity";
+import GamePlayerEntity from "../../GamePlayerEntity";
+
+// Aggro Target Types
+import ReclusiveWeaverEntity from "./ReclusiveWeaverEntity";
+
+// Drops
+import GoldItem from "../../items/general/GoldItem";
+import GorkinEarItem from "../../items/materials/GorkinEarItem";
+import GorkinEyeItem from "../../items/materials/GorkinEyeItem";
+import GorkinFootItem from "../../items/materials/GorkinFootItem";
+import GorkinHandItem from "../../items/materials/GorkinHandItem";
+import GorkinSkullItem from "../../items/materials/GorkinSkullItem";
+import IronIngotItem from "../../items/materials/IronIngotItem";
+import ShatteredSwordItem from "../../items/materials/ShatteredSwordItem";
+import ShackleItem from "../../items/materials/ShackleItem";
+import ToughMonsterHide from "../../items/materials/ToughMonsterHide";
+
+export type GorkinEnforcerEntityOptions = {
+
+} & Partial<BaseCombatEntityOptions>;
+
+export default class GorkinEnforcerEntity extends BaseCombatEntity {
+  constructor(options?: GorkinEnforcerEntityOptions) {
+    super({
+      aggroRadius: 9,
+      aggroSensorForwardOffset: 3,
+      aggroTargetTypes: [
+        GamePlayerEntity,
+        ReclusiveWeaverEntity,
+      ],
+      attacks: [
+        {
+          animations: [ 'atk1' ],
+          cooldownMs: 3000,
+          range: 5, // width/depth calculation is messed up and too large because of the model idle shape, so we use 0
+          simpleAttackDamage: 38,
+          simpleAttackDamageVariance: 0.2,
+          simpleAttackDamageDelayMs: 800,
+          stopAllAnimationForMs: 1900,
+          stopMovingForDurationMs: 1900,
+          weight: 1,
+        },
+      ],
+      combatExperienceReward: 65,
+      deathAnimations: [ 'death' ],
+      deathDespawnDelayMs: 2400,
+      deathItemDrops: [
+        { itemClass: GoldItem, minQuantity: 18, maxQuantity: 27, weight: 5 },
+        { itemClass: GorkinSkullItem, weight: 4 },
+        { itemClass: GorkinEarItem, minQuantity: 1, maxQuantity: 2, weight: 4 },
+        { itemClass: GorkinEyeItem, minQuantity: 1, maxQuantity: 2, weight: 3 },
+        { itemClass: GorkinFootItem, minQuantity: 1, maxQuantity: 2, weight: 3 },
+        { itemClass: GorkinHandItem, minQuantity: 1, maxQuantity: 2, weight: 3 },
+        { itemClass: ShatteredSwordItem, weight: 3 },
+        { itemClass: ToughMonsterHide, weight: 3 },
+        { itemClass: IronIngotItem, minQuantity: 1, maxQuantity: 2, weight: 2 },
+        { itemClass: ShackleItem, weight: 2 },
+      ],
+      diameterOverride: 0.75,
+      health: 230,
+      idleAnimations: [ 'idle' ],
+      modelUri: 'models/enemies/gorkin-enforcer.gltf',
+      modelPreferredShape: ColliderShape.CAPSULE,
+      modelScale: 0.9,
+      moveAnimations: [ 'walk' ],
+      moveSpeed: 3,
+      name: 'Gorkin Enforcer',
+      rigidBodyOptions: {
+        type: RigidBodyType.DYNAMIC,
+        colliders: [ // manually sized collider since the chain whip breaks auto calculations
+          {
+            shape: ColliderShape.CAPSULE,
+            halfHeight: 0.35,
+            radius: 0.65,
+          },
+        ],
+      },
+      pathfindingOptions: {
+        maxJump: 2,
+        maxFall: 2,
+      },
+      ...options,
+    });
+  }
+}

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

@@ -0,0 +1,113 @@
+import BaseCombatEntity, { BaseCombatEntityOptions } from "../BaseCombatEntity";
+import GamePlayerEntity from "../../GamePlayerEntity";
+import type BaseEntity from "../BaseEntity";
+
+// Aggro Target Types
+import RatkinBruteEntity from "./RatkinBruteEntity";
+import RatkinRangerEntity from "./RatkinRangerEntity";
+import RatkinSpellcasterEntity from "./RatkinSpellcasterEntity";
+import RatkinWarriorEntity from "./RatkinWarriorEntity";
+import ReclusiveWeaverEntity from "./ReclusiveWeaverEntity";
+
+// Drops
+import GoldItem from "../../items/general/GoldItem";
+import GorkinEarItem from "../../items/materials/GorkinEarItem";
+import GorkinEyeItem from "../../items/materials/GorkinEyeItem";
+import GorkinFootItem from "../../items/materials/GorkinFootItem";
+import GorkinHandItem from "../../items/materials/GorkinHandItem";
+import GorkinSkullItem from "../../items/materials/GorkinSkullItem";
+import IronIngotItem from "../../items/materials/IronIngotItem";
+import ShatteredSwordItem from "../../items/materials/ShatteredSwordItem";
+import ShackleItem from "../../items/materials/ShackleItem";
+import ToughMonsterHide from "../../items/materials/ToughMonsterHide";
+
+export type GorkinGruntEntityOptions = {
+
+} & Partial<BaseCombatEntityOptions>;
+
+export default class GorkinGruntEntity extends BaseCombatEntity {
+  constructor(options?: GorkinGruntEntityOptions) {
+    super({
+      aggroRadius: 9,
+      aggroSensorForwardOffset: 3,
+      aggroTargetTypes: [
+        GamePlayerEntity,
+        RatkinBruteEntity,
+        RatkinRangerEntity,
+        RatkinSpellcasterEntity,
+        RatkinWarriorEntity,
+        ReclusiveWeaverEntity,
+      ],
+      attacks: [
+        { // Light attack
+          animations: [ 'atk1' ],
+          cooldownMs: 2000,
+          range: 1.5,
+          simpleAttackDamage: 27,
+          simpleAttackDamageVariance: 0.2,
+          simpleAttackDamageDelayMs: 800,
+          simpleAttackReach: 2,
+          stopAllAnimationForMs: 1400,
+          stopMovingForDurationMs: 1400,
+          weight: 1,
+        },
+        { // Double swing attack
+          animations: [ 'atk2' ],
+          complexAttack: (params) => this._doubleSwingAttack(params.target),
+          complexAttackDelayMs: 700,
+          cooldownMs: 2000,
+          simpleAttackDamage: 30, // complex attack triggers simple attack processing
+          simpleAttackDamageVariance: 0.3,
+          stopAllAnimationForMs: 1800,
+          stopMovingForDurationMs: 2200,
+          range: 1.5,
+          weight: 1,
+        },
+        { // Heavy attack
+          animations: [ 'atk3' ],
+          cooldownMs: 2000,
+          stopAllAnimationForMs: 1450,
+          stopMovingForDurationMs: 1450,
+          range: 1.5,
+          simpleAttackDamage: 36,
+          simpleAttackDamageVariance: 0.2,
+          simpleAttackDamageDelayMs: 500,
+          simpleAttackReach: 2,
+          weight: 1,
+        },
+      ],
+      combatExperienceReward: 50,
+      deathAnimations: [ 'death' ],
+      deathDespawnDelayMs: 2400,
+      deathItemDrops: [
+        { itemClass: GoldItem, minQuantity: 14, maxQuantity: 24, weight: 5 },
+        { itemClass: GorkinSkullItem, weight: 4 },
+        { itemClass: GorkinEarItem, minQuantity: 1, maxQuantity: 2, weight: 4 },
+        { itemClass: GorkinEyeItem, minQuantity: 1, maxQuantity: 2, weight: 3 },
+        { itemClass: GorkinFootItem, minQuantity: 1, maxQuantity: 2, weight: 3 },
+        { itemClass: GorkinHandItem, minQuantity: 1, maxQuantity: 2, weight: 3 },
+        { itemClass: ToughMonsterHide, weight: 3 },
+        { itemClass: ShatteredSwordItem, weight: 1 },
+        { itemClass: IronIngotItem, minQuantity: 1, maxQuantity: 2, weight: 1 },
+        { itemClass: ShackleItem, weight: 1 },
+      ],
+      health: 170,
+      idleAnimations: [ 'idle' ],
+      modelUri: 'models/enemies/gorkin-grunt.gltf',
+      modelScale: 0.9,
+      moveAnimations: [ 'walk' ],
+      moveSpeed: 3,
+      name: 'Gorkin Grunt',
+      pathfindingOptions: {
+        maxJump: 2,
+        maxFall: 2,
+      },
+      ...options,
+    });
+  }
+
+  private _doubleSwingAttack(target: BaseEntity | GamePlayerEntity) {
+    this.processSimpleAttack(target, this.attacks[1]);
+    setTimeout(() => this.processSimpleAttack(target, this.attacks[1]), 700);
+  }
+}