hytopia 0.1.98 → 0.2.0

package/examples/zombies-fps/classes/EnemyEntity.ts

@@ -1,20 +1,199 @@
 import {
+  Audio,
   Entity,
   EntityOptions,
+  PathfindingEntityController,
 } from 'hytopia';
 
+import type { QuaternionLike, Vector3Like, World } from 'hytopia';
+
+import GamePlayerEntity from './GamePlayerEntity';
+
+const RETARGET_ACCUMULATOR_THRESHOLD_MS = 5000;
+const PATHFIND_ACCUMULATOR_THRESHOLD_MS = 3000;
+
 export interface EnemyEntityOptions extends EntityOptions {
-  health: number;
   damage: number;
+  damageAudioUri?: string;
+  health: number;
+  idleAudioUri?: string;
+  idleAudioReferenceDistance?: number;
+  idleAudioVolume?: number;
+  jumpHeight?: number
+  preferJumping?: boolean;
+  reward: number;
+  speed: number;
 }
 
-export class EnemyEntity extends Entity {
-  public health: number;
+export default class EnemyEntity extends Entity {
   public damage: number;
+  public health: number;
+  public jumpHeight: number;
+  public maxHealth: number;
+  public preferJumping: boolean;
+  public reward: number;
+  public speed: number;
+
+  private _damageAudio: Audio | undefined;
+  private _idleAudio: Audio | undefined;
+  private _isPathfinding = false;
+  private _pathfindAccumulatorMs = 0;
+  private _retargetAccumulatorMs = 0;
+  private _targetEntity: Entity | undefined;
 
   public constructor(options: EnemyEntityOptions) {
     super(options);
-    this.health = options.health;
     this.damage = options.damage;
+    this.health = options.health;
+    this.jumpHeight = options.jumpHeight ?? 1;
+    this.maxHealth = options.health;
+    this.preferJumping = options.preferJumping ?? false;
+    this.reward = options.reward;
+    this.speed = options.speed;
+
+    if (options.damageAudioUri) {
+      this._damageAudio = new Audio({
+        attachedToEntity: this,
+        uri: options.damageAudioUri,
+        volume: 1,
+        loop: false,
+      });
+    }
+
+    if (options.idleAudioUri) {
+      this._idleAudio = new Audio({
+        attachedToEntity: this,
+        uri: options.idleAudioUri,
+        volume: options.idleAudioVolume ?? 0.5,
+        loop: true,
+        referenceDistance: options.idleAudioReferenceDistance ?? 1, // low reference distance so its only heard when the enemy is very near
+      });
+    }
+
+    this.onEntityCollision = this._onEntityCollision;
+    this.onTick = this._onTick;
+
+    this.setCcdEnabled(true);
+  }
+
+  public override spawn(world: World, position: Vector3Like, rotation?: QuaternionLike) {
+    super.spawn(world, position, rotation);
+
+    if (this._idleAudio) {
+      this._idleAudio.play(world, true);
+    }
+  }
+
+  public takeDamage(damage: number, fromPlayer: GamePlayerEntity) {
+    if (!this.world) {
+      return;
+    }
+
+    this.health -= damage;
+
+    if (this._damageAudio) {
+      this._damageAudio.play(this.world, true);
+    }
+
+    // Give reward based on damage as % of health
+    fromPlayer.addMoney((this.damage / this.maxHealth) * this.reward);
+
+    if (this.health <= 0 && this.isSpawned) {
+      // Enemy is dead, give half reward & despawn
+      this.despawn();
+    } else {
+      // Apply red tint for 75ms to indicate damage
+      this.setTintColor({ r: 255, g: 0, b: 0 });
+      // Reset tint after 75ms, make sure to check if the entity is still
+      // spawned to prevent setting tint on a despawned entity
+      setTimeout(() => this.isSpawned ? this.setTintColor({ r: 255, g: 255, b: 255 }) : undefined, 75);
+    }
+  }
+
+  private _onEntityCollision = (entity: Entity, otherEntity: Entity, started: boolean) => {
+    if (!started || !(otherEntity instanceof GamePlayerEntity)) {
+      return;
+    }
+
+    otherEntity.takeDamage(this.damage);
+  }
+
+  /*
+   * Pathfinding is handled on an accumulator basis to prevent excessive pathfinding
+   * or movement calculations. It defers to dumb movements 
+   */
+  private _onTick = (entity: Entity, tickDeltaMs: number) => {
+    if (!this.isSpawned) {
+      return;
+    }
+
+    this._pathfindAccumulatorMs += tickDeltaMs;
+    this._retargetAccumulatorMs += tickDeltaMs;
+
+    // Acquire a target to hunt
+    if (!this._targetEntity || !this._targetEntity.isSpawned || this._retargetAccumulatorMs > RETARGET_ACCUMULATOR_THRESHOLD_MS) {
+      this._targetEntity = this._getNearestTarget();
+      this._retargetAccumulatorMs = 0;
+    }
+
+    // No target, do nothing
+    if (!this._targetEntity) {
+      return;
+    }
+
+    const targetDistance = this._getTargetDistance(this._targetEntity);
+    const pathfindingController = this.controller as PathfindingEntityController;
+
+    if (targetDistance < 8 || (!this._isPathfinding && this._pathfindAccumulatorMs < PATHFIND_ACCUMULATOR_THRESHOLD_MS)) {
+      pathfindingController.move(this._targetEntity.position, this.speed);
+      pathfindingController.face(this._targetEntity.position, this.speed * 2);
+    } else if (this._pathfindAccumulatorMs > PATHFIND_ACCUMULATOR_THRESHOLD_MS) {
+      this._isPathfinding = pathfindingController.pathfind(this._targetEntity.position, this.speed, {
+        maxFall: this.jumpHeight,
+        maxJump: this.jumpHeight,
+        maxOpenSetIterations: 200,
+        verticalPenalty: this.preferJumping ? -1 : 1,
+        pathfindAbortCallback: () => this._isPathfinding = false,
+        pathfindCompleteCallback: () => this._isPathfinding = false,
+        waypointMoveSkippedCallback: () => this._isPathfinding = false,
+      });
+
+      this._pathfindAccumulatorMs = 0;
+    }
+  }
+
+  private _getNearestTarget(): Entity | undefined {
+    if (!this.world) {
+      return undefined;
+    }
+
+    let nearestTarget: Entity | undefined;
+    let nearestDistance = Infinity;
+
+    const targetableEntities = this.world.entityManager.getAllPlayerEntities();
+
+    targetableEntities.forEach(target => {
+      if (target instanceof GamePlayerEntity && target.downed) { // skip downed players
+        return;
+      }
+      
+      const distance = this._getTargetDistance(target);
+      if (distance < nearestDistance) {
+        nearestTarget = target;
+        nearestDistance = distance;
+      }
+    });
+
+    return nearestTarget;
+  }
+
+  private _getTargetDistance(target: Entity) {
+    const targetDistance = {
+      x: target.position.x - this.position.x,
+      y: target.position.y - this.position.y,
+      z: target.position.z - this.position.z,
+    };
+
+    return Math.sqrt(targetDistance.x * targetDistance.x + targetDistance.y * targetDistance.y + targetDistance.z * targetDistance.z);
   }
 }

package/examples/zombies-fps/classes/GameManager.ts

@@ -0,0 +1,165 @@
+import { Audio, Collider, ColliderShape, CollisionGroup, GameServer } from 'hytopia';
+import PurchaseBarrierEntity from './PurchaseBarrierEntity';
+import { INVISIBLE_WALLS, INVISIBLE_WALL_COLLISION_GROUP, PURCHASE_BARRIERS, ENEMY_SPAWN_POINTS, WEAPON_CRATES } from '../gameConfig';
+import type { World, Vector3Like } from 'hytopia';
+
+// temp
+import ZombieEntity from './enemies/ZombieEntity';
+import RipperEntity from './enemies/RipperEntity';
+import WeaponCrateEntity from './WeaponCrateEntity';
+
+const GAME_WAVE_INTERVAL_MS = 30 * 1000; // 30 seconds between waves
+const SLOWEST_SPAWN_INTERVAL_MS = 4000; // Starting spawn rate
+const FASTEST_SPAWN_INTERVAL_MS = 750; // Fastest spawn rate
+const WAVE_SPAWN_INTERVAL_REDUCTION_MS = 300; // Spawn rate reduction per wave
+const WAVE_DELAY_MS = 10000; // 10s between waves
+
+export default class GameManager {
+  public static readonly instance = new GameManager();
+
+  public isStarted = false;
+  public unlockedIds: Set<string> = new Set([ 'start' ]);
+  public waveNumber = 0;
+  public waveDelay = 0;
+  public world: World | undefined;
+
+  private _enemySpawnTimeout: NodeJS.Timeout | undefined;
+  private _startTime: number | undefined;
+  private _waveTimeout: NodeJS.Timeout | undefined;
+  private _waveStartAudio: Audio;
+
+  public constructor() {
+    this._waveStartAudio = new Audio({
+      uri: 'audio/sfx/wave-start.mp3',
+      loop: false,
+      volume: 1,
+    });
+  }
+
+  public addUnlockedId(id: string) {
+    this.unlockedIds.add(id);
+  }
+
+  public setupGame(world: World) {
+    this.world = world;
+
+    // Setup invisible walls that only enemies can pass through
+    INVISIBLE_WALLS.forEach(wall => {
+      const wallCollider = new Collider({
+        shape: ColliderShape.BLOCK,
+        halfExtents: wall.halfExtents,
+        relativePosition: wall.position, // since this is not attached to a rigid body, relative position is relative to the world global coordinate space.
+        collisionGroups: {
+          belongsTo: [ INVISIBLE_WALL_COLLISION_GROUP ],
+          collidesWith: [ CollisionGroup.PLAYER ],
+        },
+      });
+
+      wallCollider.addToSimulation(world.simulation);
+    });
+
+    // Setup purchase barriers
+    PURCHASE_BARRIERS.forEach(barrier => {
+      const purchaseBarrier = new PurchaseBarrierEntity({
+        name: barrier.name,
+        removalPrice: barrier.removalPrice,
+        unlockIds: barrier.unlockIds,
+        width: barrier.width,
+      });
+
+      purchaseBarrier.spawn(world, barrier.position, barrier.rotation);
+    });
+
+    // Setup weapon crates
+    WEAPON_CRATES.forEach(crate => {
+      const weaponCrate = new WeaponCrateEntity({
+        name: crate.name,
+        price: crate.price,
+        rollableWeaponIds: crate.rollableWeaponIds,
+      });
+
+      weaponCrate.spawn(world, crate.position, crate.rotation);
+    });
+
+    // Start ambient music
+    (new Audio({
+      uri: 'audio/music/bg.mp3',
+      loop: true,
+      volume: 0.4,
+    })).play(world);
+
+    world.chatManager.registerCommand('/start', () => this.startGame());
+  }
+
+  public startGame() {
+    if (!this.world || this.isStarted) return; // type guard
+
+    this.isStarted = true;
+    this._startTime = Date.now();
+
+    GameServer.instance.playerManager.getConnectedPlayersByWorld(this.world).forEach(player => {
+      player.ui.sendData({ type: 'start' });
+    });
+
+    this._spawnLoop();
+    this._waveLoop();
+  }
+
+  private _spawnLoop() {
+    if (!this.world) return; // type guard
+
+    clearTimeout(this._enemySpawnTimeout);
+
+    const zombie = new ZombieEntity({
+      health: 7 + (this.waveNumber * 0.25),
+      speed: Math.min(6, 2 + this.waveNumber * 0.25), // max speed of 6
+    });
+
+    zombie.spawn(this.world, this._getSpawnPoint());
+
+    const nextSpawn = Math.max(FASTEST_SPAWN_INTERVAL_MS, SLOWEST_SPAWN_INTERVAL_MS - (this.waveNumber * WAVE_SPAWN_INTERVAL_REDUCTION_MS)) + this.waveDelay;
+
+    this._enemySpawnTimeout = setTimeout(() => this._spawnLoop(), nextSpawn);
+    this.waveDelay = 0;
+  }
+
+  private _waveLoop() {
+    if (!this.world) return; // type guard
+
+    clearTimeout(this._waveTimeout);
+
+    this.waveNumber++;
+    this.waveDelay = WAVE_DELAY_MS;
+
+    this._waveStartAudio.play(this.world, true);
+
+    GameServer.instance.playerManager.getConnectedPlayersByWorld(this.world).forEach(player => {
+      player.ui.sendData({
+        type: 'wave',
+        wave: this.waveNumber,
+      });
+    });
+    
+    if (this.waveNumber % 5 === 0) { // Spawn a ripper every 5 waves
+      const ripper = new RipperEntity({
+        health: 50 * this.waveNumber,
+        speed: 2 + this.waveNumber * 0.25,
+        reward: 50 * this.waveNumber,
+      });
+      ripper.spawn(this.world, this._getSpawnPoint());
+    }
+    
+    this._waveTimeout = setTimeout(() => this._waveLoop(), GAME_WAVE_INTERVAL_MS);
+  }
+
+  private _getSpawnPoint(): Vector3Like {
+    const spawnPoints: Vector3Like[] = [];
+
+    this.unlockedIds.forEach(id => {
+      const spawnPoint = ENEMY_SPAWN_POINTS[id];
+      if (spawnPoint) spawnPoints.push(...spawnPoint);
+    });
+
+    return spawnPoints[Math.floor(Math.random() * spawnPoints.length)];
+  }
+}

package/examples/zombies-fps/classes/GamePlayerEntity.ts

@@ -1,28 +1,47 @@
 import { 
+  Audio,
   CollisionGroup,
+  Light,
+  LightType,
   Player,
   PlayerCameraOrientation,
   PlayerEntity,
   PlayerCameraMode,
   PlayerInput,
+  SceneUI,
   Vector3Like,
   QuaternionLike,
   World,
   Quaternion,
   PlayerEntityController,
+  Vector3,
 } from 'hytopia';
 
 import PistolEntity from './guns/PistolEntity';
-import type GunEntity from './guns/GunEntity';
+
+import InteractableEntity from './InteractableEntity';
+import type GunEntity from './GunEntity';
+import type { GunEntityOptions } from './GunEntity';
+import { INVISIBLE_WALL_COLLISION_GROUP } from '../gameConfig';
 
 const BASE_HEALTH = 100;
-const BASE_MONEY = 10;
+const REVIVE_REQUIRED_HEALTH = 50;
+const REVIVE_PROGRESS_INTERVAL_MS = 1000;
+const REVIVE_DISTANCE_THRESHOLD = 3;
 
 export default class GamePlayerEntity extends PlayerEntity {
   public health: number;
   public maxHealth: number;
   public money: number;
-  private _gun: GunEntity | null = null;
+  public downed = false;
+  private _damageAudio: Audio;
+  private _downedSceneUI: SceneUI;
+  private _purchaseAudio: Audio;
+  private _gun: GunEntity | undefined;
+  private _light: Light;
+  private _reviveInterval: NodeJS.Timeout | undefined;
+  private _reviveDistanceVectorA: Vector3;
+  private _reviveDistanceVectorB: Vector3;
 
   // Player entities always assign a PlayerController to the entity, so we can safely create a convenience getter
   public get playerController(): PlayerEntityController {
@@ -37,16 +56,15 @@ export default class GamePlayerEntity extends PlayerEntity {
       modelScale: 0.5,
     });
     
-
     // Prevent mouse left click from being cancelled, required
     // for auto-fire and semi-auto fire mechanics, etc.
     this.playerController.autoCancelMouseLeftClick = false;
     
     // Setup player animations
-    this.playerController.idleLoopedAnimations = [ 'idle_gun_right', 'idle_lower' ];
+    this.playerController.idleLoopedAnimations = [ 'idle_lower' ];
     this.playerController.interactOneshotAnimations = [];
-    this.playerController.walkLoopedAnimations = [ 'idle_gun_right', 'walk_lower' ];
-    this.playerController.runLoopedAnimations = [ 'idle_gun_right', 'run_lower' ];
+    this.playerController.walkLoopedAnimations = ['walk_lower' ];
+    this.playerController.runLoopedAnimations = [ 'run_lower' ];
     this.playerController.onTickWithPlayerInput = this._onTickWithPlayerInput;
     
     // Setup UI
@@ -54,14 +72,52 @@ export default class GamePlayerEntity extends PlayerEntity {
 
     // Setup first person camera
     this.player.camera.setMode(PlayerCameraMode.FIRST_PERSON);
-    this.player.camera.setModelHiddenNodes([ 'head', 'neck' ]);
+    this.player.camera.setModelHiddenNodes([ 'head', 'neck', 'torso', 'leg_right', 'leg_left' ]);
     this.player.camera.setOffset({ x: 0, y: 0.5, z: 0 });
-    this.player.camera.setForwardOffset(0.2);
   
     // Set base stats
     this.health = BASE_HEALTH;
     this.maxHealth = BASE_HEALTH;
-    this.money = BASE_MONEY;
+    this.money = 0;
+
+    // Setup damage audio
+    this._damageAudio = new Audio({
+      attachedToEntity: this,
+      uri: 'audio/sfx/player-hurt.mp3',
+      loop: false,
+      volume: 0.7,
+    });
+
+    // Setup purchase audio
+    this._purchaseAudio = new Audio({
+      attachedToEntity: this,
+      uri: 'audio/sfx/purchase.mp3',
+      loop: false,
+      volume: 1,
+    });
+
+    // Setup downed scene UI
+    this._downedSceneUI = new SceneUI({
+      attachedToEntity: this,
+      templateId: 'downed-player',
+      offset: { x: 0, y: 0.5, z: 0 },
+    });
+
+    // Setup light
+    this._light = new Light({
+      angle: Math.PI / 4 + 0.1,
+      penumbra: 0.03,
+      attachedToEntity: this,
+      trackedEntity: this,
+      type: LightType.SPOTLIGHT,
+      intensity: 5,
+      offset: { x: 0, y: 0, z: 0.1 }, 
+      color: { r: 255, g: 255, b: 255 },
+    });
+
+    // Create reusable vector3 for revive distance calculations
+    this._reviveDistanceVectorA = new Vector3(0, 0, 0);
+    this._reviveDistanceVectorB = new Vector3(0, 0, 0);
   }
 
   public override spawn(world: World, position: Vector3Like, rotation?: QuaternionLike): void {
@@ -70,18 +126,211 @@ export default class GamePlayerEntity extends PlayerEntity {
     // Prevent players from colliding, setup appropriate collision groups for invisible walls, etc.
     this.setCollisionGroupsForSolidColliders({
       belongsTo: [ CollisionGroup.PLAYER ],
-      collidesWith: [ CollisionGroup.BLOCK, CollisionGroup.ENTITY, CollisionGroup.ENTITY_SENSOR ],
+      collidesWith: [ CollisionGroup.BLOCK, CollisionGroup.ENTITY, CollisionGroup.ENTITY_SENSOR, INVISIBLE_WALL_COLLISION_GROUP ],
     });
 
     // Give player a pistol.
-    this._gun = new PistolEntity({ parent: this });
-    this._gun.spawn(world, { x: 0, y: 0, z: -0.2 }, Quaternion.fromEuler(-90, 0, 0));
+    this.equipGun(new PistolEntity({ parent: this }));
+
+    // Spawn light
+    this._light.spawn(world);
+
+    // Start auto heal ticker
+    this._autoHealTicker();
+  }
+
+  public addMoney(amount: number) {
+    this.money += amount;
+    this._updatePlayerUIMoney();
+  }
+
+  public equipGun(gun: GunEntity) {
+    if (!this.world) {
+      return;
+    }
+
+    if (gun.isSpawned) {
+      // no support for equipping already spawned guns atm, like pickup up guns etc, 
+      // but would be easy to add. Not needed for this game though.
+      return console.warn('Cannot equip already spawned gun!');
+    }
+
+    if (this._gun) { // despawn old gun
+      this._gun.despawn();
+    }
+
+    this._gun = gun;
+    this._gun.spawn(this.world, { x: 0, y: 0, z: -0.2 }, Quaternion.fromEuler(-90, 0, 0));
+  }
+
+  public spendMoney(amount: number): boolean {
+    if (!this.world || this.money < amount) {
+      return false;
+    }
+
+    this.money -= amount;
+    this._updatePlayerUIMoney();
+    this._purchaseAudio.play(this.world, true);
+    return true;
+  }
+
+  public takeDamage(damage: number) {
+    if (!this.isSpawned || !this.world || this.downed) {
+      return;
+    }
+
+    const healthAfterDamage = this.health - damage;
+    if (this.health > 0 && healthAfterDamage <= 0) {
+      this._setDowned(true);
+    }
+
+    this.health = Math.max(healthAfterDamage, 0);
+    
+    this._updatePlayerUIHealth();
+
+    // randomize the detune for variation each hit
+    this._damageAudio.setDetune(-200 + Math.random() * 800);
+    this._damageAudio.play(this.world, true);
+  }
+
+  public progressRevive(byPlayer: GamePlayerEntity) {
+    if (!this.world) {
+      return;
+    }
+
+    clearTimeout(this._reviveInterval);
+
+    this._reviveInterval = setTimeout(() => {
+      this._reviveDistanceVectorA.set([ this.position.x, this.position.y, this.position.z ]);
+      this._reviveDistanceVectorB.set([ byPlayer.position.x, byPlayer.position.y, byPlayer.position.z ]);
+      const distance = this._reviveDistanceVectorA.distance(this._reviveDistanceVectorB);
+
+      if (distance > REVIVE_DISTANCE_THRESHOLD) {
+        return;
+      }
+
+      this.health += 10;
+      this._updatePlayerUIHealth();
+
+      this._downedSceneUI.setState({
+        progress: (this.health / REVIVE_REQUIRED_HEALTH) * 100,
+      });
+
+      if (this.health >= REVIVE_REQUIRED_HEALTH) {
+        this._setDowned(false);
+      } else {
+        this.progressRevive(byPlayer);
+      }
+    }, REVIVE_PROGRESS_INTERVAL_MS);
   }
 
   private _onTickWithPlayerInput = (entity: PlayerEntity, input: PlayerInput, cameraOrientation: PlayerCameraOrientation, deltaTimeMs: number) => {
-    if (input.ml && this._gun) {
+    if (!this._gun) {
+      return;
+    }
+    
+    if (input.ml && !this.downed) {
       this._gun.shoot();
     }
+
+    if (input.r && !this.downed) {
+      this._gun.reload();
+      input.r = false;
+    }
+
+    if (input.e) {
+      this._interactRaycast();
+      input.e = false;
+    }
+  }
+
+  private _setDowned(downed: boolean) {
+    if (!this.world) {
+      return;
+    }
+
+    this.downed = downed;
+
+    if (downed) {
+      this.health = 0;
+      this._updatePlayerUIHealth();
+    }
+
+    this.playerController.idleLoopedAnimations = downed ? [ 'sleep' ] : [ 'idle_lower' ];
+    this.playerController.walkLoopedAnimations = downed ? [ 'crawling' ] : [ 'walk_lower' ];
+    this.playerController.runLoopedAnimations = downed ? [ 'crawling' ] : [ 'run_lower' ];
+    this.playerController.runVelocity = downed ? 1 : 8;
+    this.playerController.walkVelocity = downed ? 1 : 4;
+    this.playerController.jumpVelocity = downed ? 0 : 10;
+
+    if (downed) {
+      this._downedSceneUI.setState({ progress: 0 })
+      this._downedSceneUI.load(this.world);
+      this.world.chatManager.sendPlayerMessage(this.player, 'You are downed! A teammate can still revive you!', 'FF0000');
+    } else {
+      this._downedSceneUI.unload();
+      this.world.chatManager.sendPlayerMessage(this.player, 'You are back up! Thank your team & fight the horde!', '00FF00');
+    }
+  }
+
+  private _interactRaycast() {
+    if (!this.world) {
+      return;
+    }
+
+    if (this.downed) {
+      return this.world.chatManager.sendPlayerMessage(this.player, 'You are downed! You cannot revive others or make purchases!', 'FF0000');
+    }
+
+    // Get raycast direction from player camera
+    const origin = {
+      x: this.position.x,
+      y: this.position.y + this.player.camera.offset.y,
+      z: this.position.z,
+    };
+    const direction = this.player.camera.facingDirection;
+    const length = 4;
+
+    const raycastHit = this.world.simulation.raycast(origin, direction, length, {
+      filterExcludeRigidBody: this.rawRigidBody, // prevent raycast from hitting the player
+    });
+
+    const hitEntity = raycastHit?.hitEntity;
+
+    if (!hitEntity) {
+      return;
+    }
+
+    if (hitEntity instanceof InteractableEntity) {
+      hitEntity.interact(this);
+    }
+
+    if (hitEntity instanceof GamePlayerEntity && hitEntity.downed) {
+      hitEntity.progressRevive(this);
+    }
+  }
+
+  private _updatePlayerUIMoney() {
+    this.player.ui.sendData({ type: 'money', money: this.money });
+  }
+
+  private _updatePlayerUIHealth() {
+    this.player.ui.sendData({ type: 'health', health: this.health, maxHealth: this.maxHealth });
+  }
+
+  private _autoHealTicker() {
+    setTimeout(() => {
+      if (!this.isSpawned) {
+        return;
+      }
+
+      if (!this.downed && this.health < this.maxHealth) {
+        this.health += 1;
+        this._updatePlayerUIHealth();
+      }
+
+      this._autoHealTicker();
+    }, 1000);
   }
 }