add spawners to custom dungeons

Author: leaftail1880

src/modules/places/dungeons/custom-dungeon.ts

@@ -29,6 +29,7 @@ export class CustomDungeonRegion extends DungeonRegion {
   override ldb: CustomDungeonRegionDatabase = {
     chestLoot: [],
     chests: {},
+    spawnerCooldowns: {},
     structureId: '',
     name: '',
     rotation: StructureRotation.None,
@@ -46,6 +47,8 @@ export class CustomDungeonRegion extends DungeonRegion {
   protected override structureFile: StructureFile = {
     chestPositions: [],
     enderChestPositions: [],
+    structureVoidPoisitions: [],
+    shulkers: [],
     size: { x: 10, y: 10, z: 10 },
   }
 
@@ -72,60 +75,61 @@ export class CustomDungeonRegion extends DungeonRegion {
     this.createChest(location, lootTable, restoreTime)
     this.save()
   }
-}
-registerSaveableRegion('customDungeon', CustomDungeonRegion)
-registerRegionType(noI18n`Кастомный данж`, CustomDungeonRegion, false, true)
 
-function eventHelper(player: Player, block: Block) {
-  if (!is(player.id, 'techAdmin')) return false
+  static {
+    world.afterEvents.playerPlaceBlock.subscribe(({ player, block }) => {
+      if (block.typeId !== MinecraftBlockTypes.Chest) return false
 
-  const region = CustomDungeonRegion.getAt(block)
-  if (!region) return false
+      const region = getDungeonRegionForTechAdmin(player, block)
+      if (!region) return
 
-  return region
-}
-
-world.afterEvents.playerPlaceBlock.subscribe(({ player, block }) => {
-  if (block.typeId !== MinecraftBlockTypes.Chest) return false
+      editChest(player, block, region)
+    })
 
-  const region = eventHelper(player, block)
-  if (!region) return
+    world.afterEvents.playerBreakBlock.subscribe(({ player, block, brokenBlockPermutation }) => {
+      if (brokenBlockPermutation.type.id !== MinecraftBlockTypes.Chest) return false
 
-  editChest(player, block, region)
-})
+      const region = getDungeonRegionForTechAdmin(player, block)
+      if (!region) return
 
-world.afterEvents.playerBreakBlock.subscribe(({ player, block, brokenBlockPermutation }) => {
-  if (brokenBlockPermutation.type.id !== MinecraftBlockTypes.Chest) return false
+      const location = block.location
+      const chest = getChest(region, location)
+      if (chest) {
+        region.ldb.chestLoot = region.ldb.chestLoot.filter(e => e !== chest)
+        region.removeChest(location)
+        player.success(i18n`Removed chest with loot ${chest.loot} and restore time ${chest.restoreTime / 60_000}min`)
+      }
+    })
 
-  const region = eventHelper(player, block)
-  if (!region) return
+    world.beforeEvents.playerInteractWithBlock.subscribe(event => {
+      const { player, block } = event
+      if (player.getGameMode() !== GameMode.Creative) return
+      if (!player.isSneaking) return
 
-  const location = block.location
-  const chest = getChest(region, location)
-  if (chest) {
-    region.ldb.chestLoot = region.ldb.chestLoot.filter(e => e !== chest)
-    region.chests = region.chests.filter(e => !Vec.equals(e.location, location))
+      const region = CustomDungeonRegion.getAt(block)
+      if (!region) return
 
-    player.success(i18n`Removed chest with loot ${chest.loot} and restore time ${chest.restoreTime / 60_000}min`)
+      const chest = getChest(region, block.location)
+      if (chest) {
+        event.cancel
+        system.delay(() => {
+          editChest(player, block.location, region, chest)
+        })
+      }
+    })
   }
-})
+}
+registerSaveableRegion('customDungeon', CustomDungeonRegion)
+registerRegionType(noI18n`Кастомный данж`, CustomDungeonRegion, false, true)
 
-world.beforeEvents.playerInteractWithBlock.subscribe(event => {
-  const { player, block } = event
-  if (player.getGameMode() !== GameMode.Creative) return
-  if (!player.isSneaking) return
+function getDungeonRegionForTechAdmin(player: Player, block: Block) {
+  if (!is(player.id, 'techAdmin')) return false
 
   const region = CustomDungeonRegion.getAt(block)
-  if (!region) return
+  if (!region) return false
 
-  const chest = getChest(region, block.location)
-  if (chest) {
-    event.cancel
-    system.delay(() => {
-      editChest(player, block.location, region, chest)
-    })
-  }
-})
+  return region
+}
 
 function editChest(
   player: Player,

src/modules/places/dungeons/dungeon.ts

@@ -1,4 +1,4 @@
-import { Player, StructureRotation, StructureSaveMode, system, world } from '@minecraft/server'
+import { EntityTypes, Player, StructureRotation, StructureSaveMode, system, world } from '@minecraft/server'
 import { MinecraftBlockTypes } from '@minecraft/vanilla-data'
 import {
   ActionForm,
@@ -13,14 +13,17 @@ import {
 } from 'lib'
 import { StructureDungeonsId, StructureFile, structureFiles } from 'lib/assets/structures'
 import { i18n, noI18n } from 'lib/i18n/text'
+import { anyPlayerNear } from 'lib/player-move'
 import { Area } from 'lib/region/areas/area'
 import { SphereArea } from 'lib/region/areas/sphere'
 import { Region, RegionCreationOptions, RegionPermissions } from 'lib/region/kinds/region'
+import { createLogger } from 'lib/utils/logger'
 import { structureLikeRotate, structureLikeRotateRelative, toAbsolute, toRelative } from 'lib/utils/structure'
 import { Dungeon } from './loot'
 
 export interface DungeonRegionDatabase extends JsonObject {
   chests: Record<string, number | null>
+  spawnerCooldowns: Record<string, number>
   structureId: string
   rotation: StructureRotation
   terrainStructureId: string
@@ -39,9 +42,20 @@ export interface DungeonChest {
   location: Vector3
 }
 
+export interface DungeonSpawner {
+  id: string
+  restoreTime: number
+  location: Vector3
+  entities: { typeId: string; amount: number }[]
+}
+
 export class DungeonRegion extends Region {
+  static logger = createLogger('DungeonRegion')
+
   static dungeons: DungeonRegion[] = []
 
+  static oldChestLogPositions = new Set<string>()
+
   static {
     system.runInterval(
       () => {
@@ -53,19 +67,34 @@ export class DungeonRegion extends Region {
             }
           }
 
+          for (const spawner of dungeon.spawners) {
+            const cooldown = dungeon.ldb.spawnerCooldowns[spawner.id]
+            if (!cooldown || Cooldown.isExpired(cooldown, spawner.restoreTime)) {
+              dungeon.spawn(spawner)
+            }
+          }
+
+          // Old chest
           for (const chest of Object.keys(dungeon.ldb.chests)) {
             const vector = Vec.parse(chest)
             if (!vector) continue
 
             if (dungeon.chests.find(e => Vec.equals(e.location, vector))) continue
 
-            // Old chest
-            console.log('Found old chest', Vec.string(vector, true))
-            try {
-              dungeon.dimension.setBlockType(vector, MinecraftBlockTypes.Air)
-              Reflect.deleteProperty(dungeon.ldb.chests, chest)
-              dungeon.save()
-            } catch (e) {}
+            const oldChestPosition = Vec.string(vector, true)
+            if (!this.oldChestLogPositions.has(oldChestPosition)) {
+              this.logger.info('Found old chest', oldChestPosition, 'removing once there is any player nearby...')
+              this.oldChestLogPositions.add(oldChestPosition)
+            }
+
+            if (anyPlayerNear(vector, dungeon.dimensionType, 20)) {
+              try {
+                this.logger.info('Trying to remove old chest', oldChestPosition)
+                dungeon.dimension.setBlockType(vector, MinecraftBlockTypes.Air)
+                Reflect.deleteProperty(dungeon.ldb.chests, chest)
+                dungeon.save()
+              } catch (e) {}
+            }
           }
         }
       },
@@ -82,6 +111,7 @@ export class DungeonRegion extends Region {
 
   ldb: DungeonRegionDatabase = {
     chests: {},
+    spawnerCooldowns: {},
     structureId: '',
     terrainStructureId: '',
     terrainStructurePosition: { x: 0, z: 0, y: 0 },
@@ -96,14 +126,24 @@ export class DungeonRegion extends Region {
 
   protected configureDungeon(): void {
     if (!this.structureFile) return
-    const { chestPositions, enderChestPositions } = this.structureFile
+    const { chestPositions, enderChestPositions, shulkers } = this.structureFile
     const toRotated = (f: Vector3[]) => this.rotate(f.map(e => this.fromRelativeToAbsolute(e)))
 
     const loot = Dungeon.loot[this.structureId] ?? Dungeon.defaultLoot
     for (const f of toRotated(chestPositions)) this.createChest(f, loot)
 
     const powerfullLoot = Dungeon.powerfullLoot[this.structureId] ?? Dungeon.defaultLoot
     for (const f of toRotated(enderChestPositions)) this.createChest(f, powerfullLoot)
+
+    for (const { loc, inv } of shulkers) {
+      const [rotated] = this.rotate([this.fromRelativeToAbsolute(loc)])
+      if (!rotated) {
+        console.warn('Not rotated')
+        continue
+      }
+
+      this.createSpawnerFromShulkerInventory(inv, rotated)
+    }
   }
 
   private rotate(vectors: Vector3[]) {
@@ -144,7 +184,7 @@ export class DungeonRegion extends Region {
   }
 
   customFormButtons(form: ActionForm, player: Player): void {
-    form.button(noI18n`Установить структуру`, () => {
+    form.button(noI18n`Снова установить структуру`, () => {
       this.placeStructure()
     })
   }
@@ -223,7 +263,65 @@ export class DungeonRegion extends Region {
     allowedAllItem: true,
   }
 
-  chests: DungeonChest[] = []
+  private spawners: DungeonSpawner[] = []
+
+  protected createSpawnerFromShulkerInventory(
+    inv: { amount: number; typeId: string }[],
+    rotated: Vector3,
+    restoreTime?: number,
+  ) {
+    const entities: DungeonSpawner['entities'] = []
+    for (const value of inv) {
+      const entityTypeId = /^(?:minecraft:)(.+)_spawn_egg$/.exec(value.typeId)?.[1]
+      if (!entityTypeId) {
+        console.warn('No entity type id for', value.typeId)
+        continue
+      }
+
+      entities.push({ typeId: entityTypeId, amount: value.amount })
+    }
+    this.createSpawner(rotated, entities, restoreTime)
+  }
+
+  protected createSpawner(location: Vector3, entities: DungeonSpawner['entities'], restoreTime = ms.from('min', 20)) {
+    this.spawners.push({
+      id: Vec.string(location),
+      location,
+      entities,
+      restoreTime,
+    })
+  }
+
+  private static invalidSpawnerTypeIds = new Set<string>()
+
+  private spawn(spawner: DungeonSpawner) {
+    if (!anyPlayerNear(spawner.location, this.dimensionType, 20)) return
+
+    for (const { typeId, amount } of spawner.entities) {
+      const type = EntityTypes.get<string>(typeId)
+      if (!type) {
+        if (!DungeonRegion.invalidSpawnerTypeIds.has(typeId)) {
+          console.warn('Dungeon spawner invalid typeId', typeId, spawner)
+          DungeonRegion.invalidSpawnerTypeIds.add(typeId)
+        }
+        continue
+      }
+
+      const entities = this.dimension.getEntities({ location: spawner.location, maxDistance: 20 })
+      if (entities.length < amount) {
+        const toSpawn = amount - entities.length
+        for (let i = 0; i < toSpawn; i++) {
+          this.dimension.spawnEntity(type, spawner.location)
+        }
+      }
+    }
+  }
+
+  private chests: DungeonChest[] = []
+
+  protected removeChest(location: Vector3) {
+    this.chests = this.chests.filter(e => !Vec.equals(e.location, location))
+  }
 
   protected createChest(location: Vector3, loot: LootTable, restoreTime = ms.from('min', 20)) {
     // console.log(