class="kw">package com.hypixel.hytale.server.npc.commands;

class="kw">import com.hypixel.hytale.builtin.tagset.config.NPCGroup;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.component.query.AndQuery;
class="kw">import com.hypixel.hytale.component.query.Query;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.server.core.Message;
class="kw">import com.hypixel.hytale.server.core.asset.type.blockset.config.BlockSet;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.command.system.CommandContext;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.system.RequiredArg;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.types.ArgTypes;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.types.EntityWrappedArg;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.types.RelativeChunkPosition;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.types.RelativeIntPosition;
class="kw">import com.hypixel.hytale.server.core.command.system.basecommands.AbstractCommandCollection;
class="kw">import com.hypixel.hytale.server.core.command.system.basecommands.AbstractPlayerCommand;
class="kw">import com.hypixel.hytale.server.core.command.system.basecommands.AbstractWorldCommand;
class="kw">import com.hypixel.hytale.server.core.entity.UUIDComponent;
class="kw">import com.hypixel.hytale.server.core.entity.entities.Player;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.ChunkSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.blockpositions.BlockPositionProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.npc.NPCPlugin;
class="kw">import com.hypixel.hytale.server.npc.blackboard.Blackboard;
class="kw">import com.hypixel.hytale.server.npc.blackboard.BlackboardSubscription;
class="kw">import com.hypixel.hytale.server.npc.blackboard.view.BlockRegionView;
class="kw">import com.hypixel.hytale.server.npc.blackboard.view.blocktype.BlockTypeView;
class="kw">import com.hypixel.hytale.server.npc.blackboard.view.event.block.BlockEventView;
class="kw">import com.hypixel.hytale.server.npc.blackboard.view.event.entity.EntityEventView;
class="kw">import com.hypixel.hytale.server.npc.blackboard.view.interaction.InteractionView;
class="kw">import com.hypixel.hytale.server.npc.blackboard.view.interaction.ReservationStatus;
class="kw">import com.hypixel.hytale.server.npc.blackboard.view.resource.ResourceView;
class="kw">import com.hypixel.hytale.server.npc.entities.NPCEntity;
class="kw">import it.unimi.dsi.fastutil.Pair;
class="kw">import it.unimi.dsi.fastutil.ints.Int2IntMap;
class="kw">import it.unimi.dsi.fastutil.ints.IntList;
class="kw">import java.util.BitSet;
class="kw">import java.util.Set;
class="kw">import java.util.UUID;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import org.joml.Vector2i;
class="kw">import org.joml.Vector3i;

class="kw">public class NPCBlackboardCommand class="kw">extends AbstractCommandCollection {
   class="kw">public NPCBlackboardCommand() {
      super("blackboard", "server.commands.npc.blackboard.desc");
      this.addSubCommand(new NPCBlackboardCommand.ChunksCommand());
      this.addSubCommand(new NPCBlackboardCommand.ChunkCommand());
      this.addSubCommand(new NPCBlackboardCommand.DropCommand());
      this.addSubCommand(new NPCBlackboardCommand.ViewsCommand());
      this.addSubCommand(new NPCBlackboardCommand.ViewCommand());
      this.addSubCommand(new NPCBlackboardCommand.BlockEventsCommand());
      this.addSubCommand(new NPCBlackboardCommand.EntityEventsCommand());
      this.addSubCommand(new NPCBlackboardCommand.ResourceViewsCommand());
      this.addSubCommand(new NPCBlackboardCommand.ResourceViewCommand());
      this.addSubCommand(new NPCBlackboardCommand.ReserveCommand());
      this.addSubCommand(new NPCBlackboardCommand.ReservationCommand());
   }

   class="kw">public class="kw">static class BlockEventsCommand class="kw">extends AbstractWorldCommand {
      class="kw">public BlockEventsCommand() {
         super("blockevents", "server.commands.npc.blackboard.blockevents.desc");
      }

      @Override
      class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
         BlockEventView var4 = var3.getResource(Blackboard.getResourceType()).getView(BlockEventView.class, 0L);
         StringBuilder var5 = new StringBuilder("Block Event View:\n");
         var5.append(" Total BlockSets: ").append(var4.getSetCount());
         var5.append("\n BlockSets:\n");
         Message var6 = Message.translation("server.commands.npc.blackboard.blockevents.title").param("count", var4.getSetCount());
         var4.forEach((var2x, var3x) -> {
            var5.append("  ").append(BlockSet.getAssetMap().getAsset(var2x).getId()).append(" (").append(var3x.get()).append("):\n");
            var6.insert("  " + BlockSet.getAssetMap().getAsset(var2x).getId() + " (" + var3x.get() + "):\n");
         }, var3x -> {
            UUIDComponent var4 = var3.getComponent(var3x, UUIDComponent.getComponentType());
            assert var4 != null;
            UUID var5 = var4.getUuid();
            NPCEntity var6 = var3.getComponent(var3x, NPCEntity.getComponentType());
            assert var6 != null;
            String var7 = var6.getRoleName();
            var5.append("   ").append(var5).append(": ").append(var7).append("\n");
            var6.insert("   " + var5 + ": " + var7 + "\n");
         });
         var1.sendMessage(var6);
         NPCPlugin.get().getLogger().at(Level.INFO).log("%s", var5.toString());
      }
   }

   class="kw">public class="kw">static class ChunkCommand class="kw">extends AbstractWorldCommand {
      @Nonnull
      class="kw">private class="kw">final RequiredArg<RelativeIntPosition> positionArg = this.withRequiredArg(
         "position", "server.commands.npc.blackboard.chunk.position.desc", ArgTypes.RELATIVE_BLOCK_POSITION
      );

      class="kw">public ChunkCommand() {
         super("chunk", "server.commands.npc.blackboard.chunk.desc");
      }

      @Override
      class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
         Vector3i var4 = this.positionArg.get(var1).getBlockPosition(var1, var3);
         Vector3i var5 = new Vector3i(ChunkUtil.chunkCoordinate(var4.x), ChunkUtil.chunkCoordinate(var4.y), ChunkUtil.chunkCoordinate(var4.z));
         long var6 = ChunkUtil.indexChunk(var5.x, var5.z);
         StringBuilder var8 = new StringBuilder("Blackboard chunk entry " + var6);
         var8.append(" (").append(var5.x).append(", ").append(var5.y).append(", ").append(var5.z).append("):\n");
         var8.append(" Partial blackboard grid coordinates: ");
         var8.append(BlockRegionView.chunkToRegionalBlackboardCoordinate(var5.x)).append(", ");
         var8.append(BlockRegionView.chunkToRegionalBlackboardCoordinate(var5.z)).append('\n');
         Message var9 = Message.translation("server.commands.npc.blackboard.chunk.entry")
            .param("index", var6)
            .param("chunkX", var5.x)
            .param("chunkY", var5.y)
            .param("chunkZ", var5.z)
            .param("regionChunkX", BlockRegionView.chunkToRegionalBlackboardCoordinate(var5.x))
            .param("regionChunkZ", BlockRegionView.chunkToRegionalBlackboardCoordinate(var5.z))
            .insert("\n");
         ChunkStore var10 = var2.getChunkStore();
         Store var11 = var10.getStore();
         Ref var12 = var10.getChunkSectionReference(var5.x, var5.y, var5.z);
         if (var12 == null) {
            var8.append(" Chunk not loaded");
            var9.insert(Message.translation("server.commands.npc.blackboard.chunk.notLoaded"));
         } else {
            BlockPositionProvider var13 = var11.getComponent(var12, BlockPositionProvider.getComponentType());
            if (var13 == null) {
               var8.append(" No entry exists");
               var9.insert(Message.translation("server.commands.npc.blackboard.chunk.noEntry"));
            } else {
               var8.append(" Searched BlockSets: [ ");
               var9.insert(Message.translation("server.commands.npc.blockSetsSearched"));
               BitSet var14 = var13.getSearchedBlockSets();
               boolean var15 = false;

               for (int var16 = var14.nextSetBit(0); var16 >= 0; var16 = var14.nextSetBit(var16 + 1)) {
                  if (var15) {
                     var8.append(", ");
                     var9.insert(", ");
                  }

                  var8.append(BlockSet.getAssetMap().getAsset(var16).getId());
                  var9.insert(BlockSet.getAssetMap().getAsset(var16).getId());
                  var15 = true;
                  if (var16 == Integer.MAX_VALUE) {
                     break;
                  }
               }

               var8.append(" ]\n Entries:\n");
               var9.insert(Message.translation("server.commands.npc.blackboard.chunk.entries"));
               var13.forEachBlockSet(
                  (var2x, var3x) -> {
                     var8.append("  BlockSet: ").append(BlockSet.getAssetMap().getAsset(var2x).getId()).append("\n   Blocks:\n");
                     var9.insert(
                        Message.translation("server.commands.npc.blackboard.chunk.blockSet").param("id", BlockSet.getAssetMap().getAsset(var2x).getId())
                     );
                     var9.insert("\n");
                     var3x.forEach(
                        var2xx -> {
                           var8.append("    [ ").append(BlockType.getAssetMap().getAsset(var2xx.getBlockType()).getId());
                           var8.append(" (").append(var2xx.getX()).append(", ").append(var2xx.getY()).append(", ").append(var2xx.getZ()).append(") ]\n");
                           var9.insert(
                              "    [ "
                                 + BlockType.getAssetMap().getAsset(var2xx.getBlockType()).getId()
                                 + " ("
                                 + var2xx.getX()
                                 + ", "
                                 + var2xx.getY()
                                 + ", "
                                 + var2xx.getZ()
                                 + ") ]"
                           );
                        }
                     );
                  }
               );
            }
         }

         var1.sendMessage(var9);
         NPCPlugin.get().getLogger().at(Level.INFO).log("%s", var8.toString());
      }
   }

   class="kw">public class="kw">static class ChunksCommand class="kw">extends AbstractWorldCommand {
      class="kw">public ChunksCommand() {
         super("chunks", "server.commands.npc.blackboard.chunks.desc");
      }

      @Override
      class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
         Store var4 = var2.getChunkStore().getStore();
         StringBuilder var5 = new StringBuilder("Blackboard chunk info:\n");
         int[] var6 = new int[]{0};
         var4.forEachChunk(BlockPositionProvider.getComponentType(), (var1x, var2x) -> var6[0] += var1x.size());
         var5.append(" Total sections: ").append(var6[0]).append('\n');
         var5.append(" Chunk sections:\n");
         Message var7 = Message.translation("server.commands.npc.blackboard.chunks.chunkInfo").param("nb", var6[0]);
         AndQuery var8 = Query.and(ChunkSection.getComponentType(), BlockPositionProvider.getComponentType());
         var4.forEachChunk(
            var8,
            (var2x, var3x) -> {
               for (int var4 = 0; var4 < var2x.size(); var4++) {
                  BlockPositionProvider var5 = var2x.getComponent(var4, BlockPositionProvider.getComponentType());
                  assert var5 != null;
                  ChunkSection var6 = var2x.getComponent(var4, ChunkSection.getComponentType());
                  assert var6 != null;
                  int var7 = var6.getX();
                  int var8 = var6.getZ();
                  var5.append(' ').append(var7).append(", ").append(var6.getY()).append(", ").append(var8);
                  int[] var9 = new int[]{0};
                  var5.forEachBlockSet((var1x, var2xx) -> var9[0] += var2xx.size());
                  var5.append(" (").append(var9[0]).append(" entries, ").append(var5.getSearchedBlockSets().cardinality()).append(" BlockSets)\n");
                  var7.insert(
                     Message.translation("server.commands.npc.blackboard.chunks.detailed_entry")
                        .param("x", var7)
                        .param("y", var6.getY())
                        .param("z", var8)
                        .param("count", var9[0])
                        .param("blockSets", var5.getSearchedBlockSets().cardinality())
                  );
               }
            }
         );
         var1.sendMessage(var7);
         NPCPlugin.get().getLogger().at(Level.INFO).log("%s", var5.toString());
      }
   }

   class="kw">public class="kw">static class DropCommand class="kw">extends AbstractWorldCommand {
      class="kw">public DropCommand() {
         super("drop", "server.commands.npc.blackboard.drop.desc");
      }

      @Override
      class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
         var3.getResource(Blackboard.getResourceType()).clear();
         var1.sendMessage(Message.translation("server.commands.npc.blackboard.cleared"));
      }
   }

   class="kw">public class="kw">static class EntityEventsCommand class="kw">extends AbstractWorldCommand {
      class="kw">public EntityEventsCommand() {
         super("entityevents", "server.commands.npc.blackboard.entityevents.desc");
      }

      @Override
      class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
         EntityEventView var4 = var3.getResource(Blackboard.getResourceType()).getView(EntityEventView.class, 0L);
         StringBuilder var5 = new StringBuilder("Entity Event View:\n");
         var5.append(" Total NPCGroups: ").append(var4.getSetCount());
         var5.append("\n NPCGroups:\n");
         Message var6 = Message.translation("server.commands.npc.blackboard.entityevents.title").param("count", var4.getSetCount());
         var4.forEach((var2x, var3x) -> {
            var5.append("  ").append(NPCGroup.getAssetMap().getAsset(var2x).getId()).append(" (").append(var3x.get()).append("):\n");
            var6.insert("  " + NPCGroup.getAssetMap().getAsset(var2x).getId() + " (" + var3x.get() + "):\n");
         }, var3x -> {
            UUIDComponent var4 = var3.getComponent(var3x, UUIDComponent.getComponentType());
            assert var4 != null;
            UUID var5 = var4.getUuid();
            NPCEntity var6 = var3.getComponent(var3x, NPCEntity.getComponentType());
            assert var6 != null;
            String var7 = var6.getRoleName();
            var5.append("   ").append(var5).append(": ").append(var7).append("\n");
            var6.insert("   " + var5 + ": " + var7 + "\n");
         });
         var1.sendMessage(var6);
         NPCPlugin.get().getLogger().at(Level.INFO).log("%s", var5.toString());
      }
   }

   class="kw">public class="kw">static class ReservationCommand class="kw">extends AbstractPlayerCommand {
      @Nonnull
      class="kw">private class="kw">final EntityWrappedArg entityArg = this.withOptionalArg("entity", "server.commands.entity.entity.desc", ArgTypes.ENTITY_ID);

      class="kw">public ReservationCommand() {
         super("reservation", "server.commands.npc.blackboard.reservation.desc");
      }

      @Override
      class="kw">protected void execute(
         @Nonnull CommandContext var1, @Nonnull Store<EntityStore> var2, @Nonnull Ref<EntityStore> var3, @Nonnull PlayerRef var4, @Nonnull World var5
      ) {
         Pair var6 = NPCCommandUtils.getTargetNpc(var1, this.entityArg, var2);
         if (var6 != null) {
            Blackboard var7 = var2.getResource(Blackboard.getResourceType());
            InteractionView var8 = var7.getView(InteractionView.class, 0L);
            ReservationStatus var9 = var8.getReservationStatus((Ref<EntityStore>)var6.first(), var3, var2);
            var1.sendMessage(Message.translation("server.commands.npc.blackboard.reservationStatus").param("status", var9.toString()));
         }
      }
   }

   class="kw">public class="kw">static class ReserveCommand class="kw">extends AbstractPlayerCommand {
      @Nonnull
      class="kw">private class="kw">final RequiredArg<Boolean> reserveArg = this.withRequiredArg("reserve", "server.commands.npc.blackboard.reserve.reserve.desc", ArgTypes.BOOLEAN);
      @Nonnull
      class="kw">private class="kw">final EntityWrappedArg entityArg = this.withOptionalArg("entity", "server.commands.entity.entity.desc", ArgTypes.ENTITY_ID);

      class="kw">public ReserveCommand() {
         super("reserve", "server.commands.npc.blackboard.reserve.desc");
      }

      @Override
      class="kw">protected void execute(
         @Nonnull CommandContext var1, @Nonnull Store<EntityStore> var2, @Nonnull Ref<EntityStore> var3, @Nonnull PlayerRef var4, @Nonnull World var5
      ) {
         Player var6 = var2.getComponent(var3, Player.getComponentType());
         assert var6 != null;
         UUIDComponent var7 = var2.getComponent(var3, UUIDComponent.getComponentType());
         assert var7 != null;
         UUID var8 = var7.getUuid();
         Pair var9 = NPCCommandUtils.getTargetNpc(var1, this.entityArg, var2);
         if (var9 != null) {
            NPCEntity var10 = (NPCEntity)var9.second();
            if (this.reserveArg.get(var1)) {
               var10.addReservation(var8);
               var1.sendMessage(Message.translation("server.commands.npc.blackboard.roleReserved").param("role", var10.getRoleName()));
            } else {
               var10.removeReservation(var8);
               var1.sendMessage(Message.translation("server.commands.npc.blackboard.roleReleased").param("role", var10.getRoleName()));
            }
         }
      }
   }

   class="kw">public class="kw">static class ResourceViewCommand class="kw">extends AbstractWorldCommand {
      @Nonnull
      class="kw">private class="kw">final RequiredArg<RelativeChunkPosition> chunkArg = this.withRequiredArg(
         "chunk", "server.commands.npc.blackboard.resourceview.chunk.desc", ArgTypes.RELATIVE_CHUNK_POSITION
      );

      class="kw">public ResourceViewCommand() {
         super("resourceview", "server.commands.npc.blackboard.resourceview.desc");
      }

      @Override
      class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
         Vector2i var4 = this.chunkArg.get(var1).getChunkPosition(var1, var3);
         long var5 = ResourceView.indexView(var4.x, var4.y);
         Blackboard var7 = var3.getResource(Blackboard.getResourceType());
         ResourceView var8 = var7.getView(ResourceView.class, var5);
         int var9 = ResourceView.xOfViewIndex(var5);
         int var10 = ResourceView.zOfViewIndex(var5);
         StringBuilder var11 = new StringBuilder("View (");
         var11.append(var9).append(", ").append(var10).append(")\n");
         var11.append(" Spans world coordinates: (").append(ResourceView.toWorldCoordinate(var9)).append(", ").append(ResourceView.toWorldCoordinate(var10));
         var11.append(") to (").append(ResourceView.toWorldCoordinate(var9 + 1)).append(", ").append(ResourceView.toWorldCoordinate(var10 + 1)).append(")\n");
         Message var12 = Message.translation("server.commands.npc.blackboard.view.title").param("x", var9).param("z", var10);
         var12.insert(
            Message.translation("server.commands.npc.blackboard.view.coordinates")
               .param("x1", ResourceView.toWorldCoordinate(var9))
               .param("z1", ResourceView.toWorldCoordinate(var10))
               .param("x2", ResourceView.toWorldCoordinate(var9 + 1))
               .param("z2", ResourceView.toWorldCoordinate(var10 + 1))
         );
         var12.insert("\n");
         if (var8 == null) {
            var11.append(" No resource view exists");
            var12.insert(Message.translation("server.commands.npc.blackboard.resourceview.noResourceView"));
         } else {
            var11.append(" Reservations: [ ").append('\n');
            var12.insert(Message.translation("server.commands.npc.blackboard.resourceview.reservations"));
            var8.getReservationsByEntity()
               .forEach(
                  (var6, var7x) -> {
                     if (!var6.isValid()) {
                        var11.append("!!!INVALID ENTITY!!!");
                        var12.insert(Message.translation("server.commands.npc.blackboard.view.invalidEntity"));
                     } else {
                        UUIDComponent var8 = var3.getComponent((Ref<EntityStore>)var6, UUIDComponent.getComponentType());
                        assert var8 != null;
                        UUID var9 = var8.getUuid();
                        var11.append("  ").append(var9).append(": ");
                        var12.insert("  " + var9 + ": ");
                        NPCEntity var10 = var3.getComponent((Ref<EntityStore>)var6, NPCEntity.getComponentType());
                        if (var10 == null) {
                           var11.append("!!!NON-NPC ENTITY!!!");
                           var12.insert(Message.translation("server.commands.npc.blackboard.view.nonNpcEntity"));
                        } else {
                           var11.append(var10.getRoleName());
                           var12.insert(var10.getRoleName());
                        }

                        int var11 = var7x.getBlockIndex();
                        int var12 = ResourceView.xFromIndex(var11) + (var9 << 7);
                        int var13 = ResourceView.yFromIndex(var11) + (var7x.getSectionIndex() << 5);
                        int var14 = ResourceView.zFromIndex(var11) + (var10 << 7);
                        BlockType var15 = BlockType.getAssetMap().getAsset(var2.getBlock(var12, var13, var14));
                        var11.append(" reserved block ")
                           .append(var15.getId())
                           .append(" at ")
                           .append(var12)
                           .append(", ")
                           .append(var13)
                           .append(", ")
                           .append(var14)
                           .append('\n');
                        var12.insert(
                           Message.translation("server.commands.npc.blackboard.resourceview.reservedBlock")
                              .param("name", var15.getId())
                              .param("x", var12)
                              .param("y", var13)
                              .param("z", var14)
                        );
                     }
                  }
               );
            var11.append(" ]");
            var12.insert(" ]");
         }

         var1.sendMessage(var12);
         NPCPlugin.get().getLogger().at(Level.INFO).log("%s", var11.toString());
      }
   }

   class="kw">public class="kw">static class ResourceViewsCommand class="kw">extends AbstractWorldCommand {
      class="kw">public ResourceViewsCommand() {
         super("resourceviews", "server.commands.npc.blackboard.resourceviews.desc");
      }

      @Override
      class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
         StringBuilder var4 = new StringBuilder("Resource views:\n");
         Message var5 = Message.translation("server.commands.npc.blackboard.resourceviews.title");
         Blackboard var6 = var3.getResource(Blackboard.getResourceType());
         int[] var7 = new int[]{0};
         var6.forEachView(ResourceView.class, var1x -> var7[0]++);
         var4.append(" Total resource views: ").append(var7[0]).append('\n').append(" Views:\n");
         var5.insert(Message.translation("server.commands.npc.blackboard.resourceviews.totalViews").param("count", var7[0]));
         var6.forEachView(
            ResourceView.class,
            var2x -> {
               var4.append("  View (").append(ResourceView.xOfViewIndex(var2x.getIndex())).append(", ").append(ResourceView.zOfViewIndex(var2x.getIndex()));
               var4.append(") Reservations: ").append(var2x.getReservationsByEntity().size()).append('\n');
               var5.insert(
                  Message.translation("server.commands.npc.blackboard.resourceviews.view")
                     .param("x", ResourceView.xOfViewIndex(var2x.getIndex()))
                     .param("z", ResourceView.zOfViewIndex(var2x.getIndex()))
                     .param("count", var2x.getReservationsByEntity().size())
               );
            }
         );
         var1.sendMessage(var5);
         NPCPlugin.get().getLogger().at(Level.INFO).log("%s", var4.toString());
      }
   }

   class="kw">public class="kw">static class ViewCommand class="kw">extends AbstractWorldCommand {
      @Nonnull
      class="kw">private class="kw">final RequiredArg<RelativeChunkPosition> chunkArg = this.withRequiredArg(
         "chunk", "server.commands.npc.blackboard.view.chunk.desc", ArgTypes.RELATIVE_CHUNK_POSITION
      );

      class="kw">public ViewCommand() {
         super("view", "server.commands.npc.blackboard.view.desc");
      }

      @Override
      class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
         Vector2i var4 = this.chunkArg.get(var1).getChunkPosition(var1, var3);
         long var5 = BlockTypeView.indexView(var4.x, var4.y);
         Blackboard var7 = var3.getResource(Blackboard.getResourceType());
         BlockTypeView var8 = var7.getView(BlockTypeView.class, var5);
         int var9 = BlockTypeView.xOfViewIndex(var5);
         int var10 = BlockTypeView.zOfViewIndex(var5);
         StringBuilder var11 = new StringBuilder("View (");
         var11.append(var9).append(", ").append(var10).append(")\n");
         var11.append(" Spans world coordinates: (").append(BlockTypeView.toWorldCoordinate(var9)).append(", ").append(BlockTypeView.toWorldCoordinate(var10));
         var11.append(") to (").append(BlockTypeView.toWorldCoordinate(var9 + 1)).append(", ").append(BlockTypeView.toWorldCoordinate(var10 + 1)).append(")\n");
         Message var12 = Message.translation("server.commands.npc.blackboard.view.title").param("x", var9).param("z", var10);
         var12.insert(
            Message.translation("server.commands.npc.blackboard.view.coordinates")
               .param("x1", BlockTypeView.toWorldCoordinate(var9))
               .param("z1", BlockTypeView.toWorldCoordinate(var10))
               .param("x2", BlockTypeView.toWorldCoordinate(var9 + 1))
               .param("z2", BlockTypeView.toWorldCoordinate(var10 + 1))
         );
         var12.insert("\n");
         if (var8 == null) {
            var11.append(" No partial view exists");
            var12.insert(Message.translation("server.commands.npc.blackboard.view.noPartialViews"));
         } else {
            var11.append(" Searched BlockSets: [ ");
            var12.insert(Message.translation("server.commands.npc.blockSetsSearched"));
            BitSet var13 = var8.getAllBlockSets();
            Int2IntMap var14 = var8.getBlockSetCounts();
            boolean var15 = false;

            for (int var16 = var13.nextSetBit(0); var16 >= 0; var16 = var13.nextSetBit(var16 + 1)) {
               if (var15) {
                  var11.append(", ");
                  var12.insert(", ");
               }

               var11.append(BlockSet.getAssetMap().getAsset(var16).getId()).append(" (").append(var14.getOrDefault(var16, 0)).append(')');
               var12.insert(BlockSet.getAssetMap().getAsset(var16).getId() + " (" + var14.getOrDefault(var16, 0) + ")");
               var15 = true;
               if (var16 == Integer.MAX_VALUE) {
                  break;
               }
            }

            Set var17 = var8.getEntities();
            var11.append(" ]\n Entities (").append(var17.size()).append("):\n");
            var12.insert(Message.translation("server.commands.npc.blackboard.view.entities").param("count", var17.size()));
            var17.forEach(var3x -> {
               var11.append("  [").append(var3x.getIndex()).append("] ");
               var12.insert("  [" + var3x.getIndex() + "] ");
               if (!var3x.isValid()) {
                  var11.append("!!!INVALID ENTITY!!!");
                  var12.insert(Message.translation("server.commands.npc.blackboard.view.invalidEntity"));
               } else {
                  NPCEntity var4 = var3.getComponent((Ref<EntityStore>)var3x, NPCEntity.getComponentType());
                  if (var4 == null) {
                     var11.append("!!!NON-NPC ENTITY!!!\n");
                     var12.insert(Message.translation("server.commands.npc.blackboard.view.nonNpcEntity"));
                  } else {
                     var11.append(var4.getRoleName()).append("\n    BlockSets: [ ");
                     var12.insert(Message.translation("server.commands.npc.blackboard.view.blockSets"));
                     BlackboardSubscription var5 = var3.getComponent((Ref<EntityStore>)var3x, BlackboardSubscription.getComponentType());
                     IntList var6 = var5 != null ? var5.getBlockTypeSets() : null;
                     if (var6 != null) {
                        for (int var7 = 0; var7 < var6.size(); var7++) {
                           if (var7 > 0) {
                              var11.append(", ");
                              var12.insert(", ");
                           }

                           String var8 = BlockSet.getAssetMap().getAsset(var6.getInt(var7)).getId();
                           var11.append(var8);
                           var12.insert(var8);
                        }
                     }

                     var11.append(" ]\n");
                     var12.insert(" ]\n");
                  }
               }
            });
         }

         var1.sendMessage(var12);
         NPCPlugin.get().getLogger().at(Level.INFO).log("%s", var11.toString());
      }
   }

   class="kw">public class="kw">static class ViewsCommand class="kw">extends AbstractWorldCommand {
      class="kw">public ViewsCommand() {
         super("views", "server.commands.npc.blackboard.views.desc");
      }

      @Override
      class="kw">protected void execute(@Nonnull CommandContext var1, @Nonnull World var2, @Nonnull Store<EntityStore> var3) {
         StringBuilder var4 = new StringBuilder("Blackboard views:\n");
         Message var5 = Message.translation("server.commands.npc.blackboard.views.title");
         Blackboard var6 = var3.getResource(Blackboard.getResourceType());
         int[] var7 = new int[]{0};
         var6.forEachView(BlockTypeView.class, var1x -> var7[0]++);
         var4.append(" Total partial views: ").append(var7[0]).append('\n').append(" Views:\n");
         var5.insert(Message.translation("server.commands.npc.blackboard.views.partialViews").param("count", var7[0]));
         var5.insert("\n");
         var6.forEachView(
            BlockTypeView.class,
            var2x -> {
               var4.append("  View (").append(BlockTypeView.xOfViewIndex(var2x.getIndex())).append(", ").append(BlockTypeView.zOfViewIndex(var2x.getIndex()));
               var4.append(") Entities: ")
                  .append(var2x.getEntities().size())
                  .append(", BlockSets: ")
                  .append(var2x.getAllBlockSets().cardinality())
                  .append('\n');
               var5.insert(
                  Message.translation("server.commands.npc.blackboard.views.view")
                     .param("x", BlockTypeView.xOfViewIndex(var2x.getIndex()))
                     .param("z", BlockTypeView.zOfViewIndex(var2x.getIndex()))
                     .param("size", var2x.getEntities().size())
                     .param("cardinal", var2x.getAllBlockSets().cardinality())
               );
               var5.insert("\n");
            }
         );
         var1.sendMessage(var5);
         NPCPlugin.get().getLogger().at(Level.INFO).log("%s", var4.toString());
      }
   }
}