com/hypixel/hytale/server/core/asset

com/hypixel/hytale/server/core/asset/AssetModule.java

package com.hypixel.hytale.server.core.asset;

import com.hypixel.hytale.assetstore.AssetLoadResult;
import com.hypixel.hytale.assetstore.AssetMap;
import com.hypixel.hytale.assetstore.AssetPack;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.event.RegisterAssetStoreEvent;
import com.hypixel.hytale.assetstore.event.RemoveAssetStoreEvent;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.util.RawJsonReader;
import com.hypixel.hytale.common.plugin.PluginIdentifier;
import com.hypixel.hytale.common.plugin.PluginManifest;
import com.hypixel.hytale.common.util.FormatUtil;
import com.hypixel.hytale.event.EventPriority;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.server.core.HytaleServer;
import com.hypixel.hytale.server.core.HytaleServerConfig;
import com.hypixel.hytale.server.core.Options;
import com.hypixel.hytale.server.core.ShutdownReason;
import com.hypixel.hytale.server.core.asset.monitor.AssetMonitor;
import com.hypixel.hytale.server.core.asset.type.gameplay.respawn.HomeOrSpawnPoint;
import com.hypixel.hytale.server.core.asset.type.gameplay.respawn.RespawnController;
import com.hypixel.hytale.server.core.asset.type.gameplay.respawn.WorldSpawnPoint;
import com.hypixel.hytale.server.core.asset.type.item.DroplistCommand;
import com.hypixel.hytale.server.core.event.events.BootEvent;
import com.hypixel.hytale.server.core.plugin.JavaPlugin;
import com.hypixel.hytale.server.core.plugin.JavaPluginInit;
import com.hypixel.hytale.server.core.plugin.PluginManager;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.universe.world.worldgen.IWorldGen;
import com.hypixel.hytale.server.core.universe.world.worldgen.ValidatableWorldGen;
import com.hypixel.hytale.server.core.universe.world.worldgen.WorldGenLoadException;
import com.hypixel.hytale.server.core.universe.world.worldgen.provider.IWorldGenProvider;
import com.hypixel.hytale.server.core.universe.world.worldmap.IWorldMap;
import com.hypixel.hytale.server.core.universe.world.worldmap.provider.IWorldMapProvider;
import com.hypixel.hytale.sneakythrow.SneakyThrow;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.DirectoryStream;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.logging.Level;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class AssetModule extends JavaPlugin {
   public static final PluginManifest MANIFEST = PluginManifest.corePlugin(AssetModule.class).build();
   private static AssetModule instance;
   @Nullable
   private AssetMonitor assetMonitor;
   @Nonnull
   private final List<AssetPack> assetPacks = new CopyOnWriteArrayList();
   private boolean hasLoaded = false;
   private final List<AssetStore<?, ?, ?>> pendingAssetStores = new CopyOnWriteArrayList();

   public static AssetModule get() {
      return instance;
   }

   public AssetModule(@Nonnull JavaPluginInit init) {
      super(init);
      instance = this;
   }

   protected void setup() {
      if (Options.getOptionSet().has(Options.DISABLE_FILE_WATCHER)) {
         this.getLogger().at(Level.WARNING).log("Not running asset watcher because --disable-file-watcher was set");
      } else {
         try {
            this.assetMonitor = new AssetMonitor();
            this.getLogger().at(Level.INFO).log("Asset monitor enabled!");
         } catch (IOException e) {
            ((HytaleLogger.Api)this.getLogger().at(Level.SEVERE).withCause(e)).log("Failed to create asset monitor!");
         }
      }

      for(Path path : Options.getOptionSet().valuesOf(Options.ASSET_DIRECTORY)) {
         this.loadAndRegisterPack(path);
      }

      this.loadPacksFromDirectory(PluginManager.MODS_PATH);

      for(Path modsPath : Options.getOptionSet().valuesOf(Options.MODS_DIRECTORIES)) {
         this.loadPacksFromDirectory(modsPath);
      }

      if (this.assetPacks.isEmpty()) {
         HytaleServer.get().shutdownServer(ShutdownReason.MISSING_ASSETS.withMessage("Failed to load any asset packs"));
      } else {
         this.getEventRegistry().register((short)-16, LoadAssetEvent.class, (event) -> {
            if (this.hasLoaded) {
               throw new IllegalStateException("LoadAssetEvent has already been dispatched");
            } else {
               AssetRegistry.ASSET_LOCK.writeLock().lock();

               try {
                  this.hasLoaded = true;
                  AssetRegistryLoader.preLoadAssets(event);

                  for(AssetPack pack : this.assetPacks) {
                     AssetRegistryLoader.loadAssets(event, pack);
                  }
               } finally {
                  AssetRegistry.ASSET_LOCK.writeLock().unlock();
               }

            }
         });
         this.getEventRegistry().register((short)-16, AssetPackRegisterEvent.class, (event) -> AssetRegistryLoader.loadAssets((LoadAssetEvent)null, event.getAssetPack()));
         this.getEventRegistry().register(AssetPackUnregisterEvent.class, (event) -> {
            for(AssetStore<?, ?, ?> assetStore : AssetRegistry.getStoreMap().values()) {
               assetStore.removeAssetPack(event.getAssetPack().getName());
            }

         });
         this.getEventRegistry().register(LoadAssetEvent.class, AssetModule::validateWorldGen);
         this.getEventRegistry().register(EventPriority.FIRST, LoadAssetEvent.class, SneakyThrow.sneakyConsumer(AssetRegistryLoader::writeSchemas));
         this.getEventRegistry().register(RegisterAssetStoreEvent.class, this::onNewStore);
         this.getEventRegistry().register(RemoveAssetStoreEvent.class, this::onRemoveStore);
         this.getEventRegistry().registerGlobal(BootEvent.class, (event) -> {
            StringBuilder sb = new StringBuilder("Total Loaded Assets: ");
            AssetStore[] assetStores = (AssetStore[])AssetRegistry.getStoreMap().values().toArray((x$0) -> new AssetStore[x$0]);
            Arrays.sort(assetStores, Comparator.comparingInt((o) -> o.getAssetMap().getAssetCount()));

            for(int i = assetStores.length - 1; i >= 0; --i) {
               AssetStore assetStore = assetStores[i];
               String simpleName = assetStore.getAssetClass().getSimpleName();
               int assetCount = assetStore.getAssetMap().getAssetCount();
               sb.append(simpleName).append(": ").append(assetCount).append(", ");
            }

            sb.setLength(sb.length() - 2);
            this.getLogger().at(Level.INFO).log(sb.toString());
         });
         RespawnController.CODEC.register((String)"HomeOrSpawnPoint", HomeOrSpawnPoint.class, HomeOrSpawnPoint.CODEC);
         RespawnController.CODEC.register((String)"WorldSpawnPoint", WorldSpawnPoint.class, WorldSpawnPoint.CODEC);
         this.getCommandRegistry().registerCommand(new DroplistCommand());
      }
   }

   protected void shutdown() {
      if (this.assetMonitor != null) {
         this.assetMonitor.shutdown();
         this.assetMonitor = null;
      }

      for(AssetPack pack : this.assetPacks) {
         if (pack.getFileSystem() != null) {
            try {
               pack.getFileSystem().close();
            } catch (IOException e) {
               ((HytaleLogger.Api)this.getLogger().at(Level.WARNING).withCause(e)).log("Failed to close asset pack filesystem: %s", pack.getName());
            }
         }
      }

      this.assetPacks.clear();
   }

   @Nonnull
   public AssetPack getBaseAssetPack() {
      return (AssetPack)this.assetPacks.getFirst();
   }

   @Nonnull
   public List<AssetPack> getAssetPacks() {
      return this.assetPacks;
   }

   @Nullable
   public AssetMonitor getAssetMonitor() {
      return this.assetMonitor;
   }

   @Nullable
   public AssetPack findAssetPackForPath(Path path) {
      path = path.toAbsolutePath().normalize();

      for(AssetPack pack : this.assetPacks) {
         if (path.startsWith(pack.getRoot())) {
            return pack;
         }
      }

      return null;
   }

   public boolean isAssetPathImmutable(@Nonnull Path path) {
      AssetPack pack = this.findAssetPackForPath(path);
      return pack != null && pack.isImmutable();
   }

   @Nullable
   private PluginManifest loadPackManifest(Path packPath) throws IOException {
      if (packPath.getFileName().toString().toLowerCase().endsWith(".zip")) {
         FileSystem fs = FileSystems.newFileSystem(packPath, (ClassLoader)null);

         PluginManifest var9;
         label96: {
            try {
               Path manifestPath = fs.getPath("manifest.json");
               if (Files.exists(manifestPath, new LinkOption[0])) {
                  BufferedReader reader = Files.newBufferedReader(manifestPath, StandardCharsets.UTF_8);

                  try {
                     char[] buffer = (char[])RawJsonReader.READ_BUFFER.get();
                     RawJsonReader rawJsonReader = new RawJsonReader(reader, buffer);
                     ExtraInfo extraInfo = (ExtraInfo)ExtraInfo.THREAD_LOCAL.get();
                     PluginManifest manifest = PluginManifest.CODEC.decodeJson(rawJsonReader, extraInfo);
                     extraInfo.getValidationResults().logOrThrowValidatorExceptions(this.getLogger());
                     var9 = manifest;
                  } catch (Throwable var14) {
                     if (reader != null) {
                        try {
                           reader.close();
                        } catch (Throwable var12) {
                           var14.addSuppressed(var12);
                        }
                     }

                     throw var14;
                  }

                  if (reader != null) {
                     reader.close();
                  }
                  break label96;
               }
            } catch (Throwable var15) {
               if (fs != null) {
                  try {
                     fs.close();
                  } catch (Throwable var11) {
                     var15.addSuppressed(var11);
                  }
               }

               throw var15;
            }

            if (fs != null) {
               fs.close();
            }

            return null;
         }

         if (fs != null) {
            fs.close();
         }

         return var9;
      } else if (Files.isDirectory(packPath, new LinkOption[0])) {
         Path manifestPath = packPath.resolve("manifest.json");
         if (Files.exists(manifestPath, new LinkOption[0])) {
            FileReader reader = new FileReader(manifestPath.toFile(), StandardCharsets.UTF_8);

            PluginManifest manifest;
            try {
               char[] buffer = (char[])RawJsonReader.READ_BUFFER.get();
               RawJsonReader rawJsonReader = new RawJsonReader(reader, buffer);
               ExtraInfo extraInfo = (ExtraInfo)ExtraInfo.THREAD_LOCAL.get();
               PluginManifest manifest = PluginManifest.CODEC.decodeJson(rawJsonReader, extraInfo);
               extraInfo.getValidationResults().logOrThrowValidatorExceptions(this.getLogger());
               manifest = manifest;
            } catch (Throwable var13) {
               try {
                  reader.close();
               } catch (Throwable var10) {
                  var13.addSuppressed(var10);
               }

               throw var13;
            }

            reader.close();
            return manifest;
         }
      }

      return null;
   }

   private void loadPacksFromDirectory(Path modsPath) {
      if (Files.isDirectory(modsPath, new LinkOption[0])) {
         this.getLogger().at(Level.INFO).log("Loading packs from directory: %s", modsPath);

         try {
            DirectoryStream<Path> stream = Files.newDirectoryStream(modsPath);

            try {
               for(Path packPath : stream) {
                  if (packPath.getFileName() != null && !packPath.getFileName().toString().toLowerCase().endsWith(".jar")) {
                     this.loadAndRegisterPack(packPath);
                  }
               }
            } catch (Throwable var6) {
               if (stream != null) {
                  try {
                     stream.close();
                  } catch (Throwable var5) {
                     var6.addSuppressed(var5);
                  }
               }

               throw var6;
            }

            if (stream != null) {
               stream.close();
            }
         } catch (IOException e) {
            ((HytaleLogger.Api)this.getLogger().at(Level.SEVERE).withCause(e)).log("Failed to load mods from: %s", modsPath);
         }

      }
   }

   private void loadAndRegisterPack(Path packPath) {
      PluginManifest manifest;
      try {
         manifest = this.loadPackManifest(packPath);
         if (manifest == null) {
            this.getLogger().at(Level.WARNING).log("Skipping pack at %s: missing or invalid manifest.json", packPath.getFileName());
            return;
         }
      } catch (Exception e) {
         ((HytaleLogger.Api)this.getLogger().at(Level.WARNING).withCause(e)).log("Failed to load manifest for pack at %s", packPath);
         return;
      }

      PluginIdentifier packIdentifier = new PluginIdentifier(manifest);
      HytaleServerConfig.ModConfig modConfig = (HytaleServerConfig.ModConfig)HytaleServer.get().getConfig().getModConfig().get(packIdentifier);
      boolean enabled = modConfig == null || modConfig.getEnabled() == null || modConfig.getEnabled();
      String packId = packIdentifier.toString();
      if (enabled) {
         this.registerPack(packId, packPath, manifest);
         this.getLogger().at(Level.INFO).log("Loaded pack: %s from %s", packId, packPath.getFileName());
      } else {
         this.getLogger().at(Level.INFO).log("Skipped disabled pack: %s", packId);
      }

   }

   public void registerPack(@Nonnull String name, @Nonnull Path path, @Nonnull PluginManifest manifest) {
      Path absolutePath = path.toAbsolutePath().normalize();
      Path packLocation = absolutePath;
      FileSystem fileSystem = null;
      boolean isImmutable = false;
      String lowerFileName = absolutePath.getFileName().toString().toLowerCase();
      if (!lowerFileName.endsWith(".zip") && !lowerFileName.endsWith(".jar")) {
         isImmutable = Files.isRegularFile(absolutePath.resolve("CommonAssetsIndex.hashes"), new LinkOption[0]);
      } else {
         try {
            fileSystem = FileSystems.newFileSystem(absolutePath, (ClassLoader)null);
            absolutePath = fileSystem.getPath("").toAbsolutePath().normalize();
            isImmutable = true;
         } catch (IOException e) {
            throw SneakyThrow.sneakyThrow(e);
         }
      }

      AssetPack pack = new AssetPack(packLocation, name, absolutePath, fileSystem, isImmutable, manifest);
      this.assetPacks.add(pack);
      AssetRegistry.ASSET_LOCK.writeLock().lock();

      try {
         if (this.hasLoaded) {
            HytaleServer.get().getEventBus().dispatchFor(AssetPackRegisterEvent.class).dispatch(new AssetPackRegisterEvent(pack));
            return;
         }
      } finally {
         AssetRegistry.ASSET_LOCK.writeLock().unlock();
      }

   }

   public void unregisterPack(@Nonnull String name) {
      AssetPack pack = this.getAssetPack(name);
      if (pack == null) {
         this.getLogger().at(Level.WARNING).log("Tried to unregister non-existent asset pack: %s", name);
      } else {
         this.assetPacks.remove(pack);
         if (pack.getFileSystem() != null) {
            try {
               pack.getFileSystem().close();
            } catch (IOException e) {
               throw SneakyThrow.sneakyThrow(e);
            }
         }

         AssetRegistry.ASSET_LOCK.writeLock().lock();

         try {
            HytaleServer.get().getEventBus().dispatchFor(AssetPackUnregisterEvent.class).dispatch(new AssetPackUnregisterEvent(pack));
         } finally {
            AssetRegistry.ASSET_LOCK.writeLock().unlock();
         }

      }
   }

   public AssetPack getAssetPack(@Nonnull String name) {
      for(AssetPack pack : this.assetPacks) {
         if (name.equals(pack.getName())) {
            return pack;
         }
      }

      return null;
   }

   private void onRemoveStore(@Nonnull RemoveAssetStoreEvent event) {
      AssetStore<?, ? extends JsonAssetWithMap<?, ? extends AssetMap<?, ?>>, ? extends AssetMap<?, ? extends JsonAssetWithMap<?, ?>>> assetStore = event.getAssetStore();
      String path = assetStore.getPath();
      if (path != null) {
         for(AssetPack pack : this.assetPacks) {
            if (!pack.isImmutable()) {
               Path assetsPath = pack.getRoot().resolve("Server").resolve(path);
               if (Files.isDirectory(assetsPath, new LinkOption[0])) {
                  assetStore.removeFileMonitor(assetsPath);
               }
            }
         }

      }
   }

   private void onNewStore(@Nonnull RegisterAssetStoreEvent event) {
      if (AssetRegistry.HAS_INIT) {
         this.pendingAssetStores.add(event.getAssetStore());
      }
   }

   public void initPendingStores() {
      for(int i = 0; i < this.pendingAssetStores.size(); ++i) {
         this.initStore((AssetStore)this.pendingAssetStores.get(i));
      }

      this.pendingAssetStores.clear();
   }

   private void initStore(@Nonnull AssetStore<?, ?, ?> assetStore) {
      AssetRegistry.ASSET_LOCK.writeLock().lock();

      try {
         List<?> preAddedAssets = assetStore.getPreAddedAssets();
         if (preAddedAssets != null && !preAddedAssets.isEmpty()) {
            AssetLoadResult loadResult = assetStore.loadAssets("Hytale:Hytale", preAddedAssets);
            if (loadResult.hasFailed()) {
               throw new RuntimeException("Failed to load asset store: " + String.valueOf(assetStore.getAssetClass()));
            }
         }

         for(AssetPack pack : this.assetPacks) {
            Path serverAssetDirectory = pack.getRoot().resolve("Server");
            String path = assetStore.getPath();
            if (path != null) {
               Path assetsPath = serverAssetDirectory.resolve(path);
               if (Files.isDirectory(assetsPath, new LinkOption[0])) {
                  AssetLoadResult<?, ? extends JsonAssetWithMap<?, ? extends AssetMap<?, ?>>> loadResult = assetStore.loadAssetsFromDirectory(pack.getName(), assetsPath);
                  if (loadResult.hasFailed()) {
                     throw new RuntimeException("Failed to load asset store: " + String.valueOf(assetStore.getAssetClass()));
                  }
               } else {
                  this.getLogger().at(Level.SEVERE).log("Path for %s isn't a directory or doesn't exist: %s", assetStore.getAssetClass().getSimpleName(), assetsPath);
               }
            }

            assetStore.validateCodecDefaults();
            if (path != null) {
               Path assetsPath = serverAssetDirectory.resolve(path);
               if (Files.isDirectory(assetsPath, new LinkOption[0])) {
                  assetStore.addFileMonitor(pack.getName(), assetsPath);
               }
            }
         }
      } catch (IOException e) {
         throw SneakyThrow.sneakyThrow(e);
      } finally {
         AssetRegistry.ASSET_LOCK.writeLock().unlock();
      }

   }

   private static void validateWorldGen(@Nonnull LoadAssetEvent event) {
      if (Options.getOptionSet().has(Options.VALIDATE_WORLD_GEN)) {
         long start = System.nanoTime();

         try {
            IWorldGenProvider provider = IWorldGenProvider.CODEC.getDefault();
            IWorldGen generator = provider.getGenerator();
            generator.getDefaultSpawnProvider(0);
            if (generator instanceof ValidatableWorldGen) {
               boolean valid = ((ValidatableWorldGen)generator).validate();
               if (!valid) {
                  event.failed(true, "failed to validate world gen");
               }
            }

            if (generator instanceof IWorldMapProvider) {
               IWorldMapProvider worldMapProvider = (IWorldMapProvider)generator;
               IWorldMap worldMap = worldMapProvider.getGenerator((World)null);
               worldMap.getWorldMapSettings();
            }
         } catch (WorldGenLoadException e) {
            ((HytaleLogger.Api)HytaleLogger.getLogger().at(Level.SEVERE).withCause(e)).log("Failed to load default world gen!");
            HytaleLogger.getLogger().at(Level.SEVERE).log("\n" + e.getTraceMessage("\n"));
            event.failed(true, "failed to validate world gen: " + e.getTraceMessage(" -> "));
         } catch (Throwable e) {
            ((HytaleLogger.Api)HytaleLogger.getLogger().at(Level.SEVERE).withCause(e)).log("Failed to load default world gen!");
            event.failed(true, "failed to validate world gen");
         }

         HytaleLogger.getLogger().at(Level.INFO).log("Validate world gen phase completed! Boot time %s, Took %s", FormatUtil.nanosToString(System.nanoTime() - event.getBootStart()), FormatUtil.nanosToString(System.nanoTime() - start));
      }
   }
}

com/hypixel/hytale/server/core/asset/AssetNotifications.java

package com.hypixel.hytale.server.core.asset;

public class AssetNotifications {
   public static final String ASSET_ADDED_MESSAGE_KEY = "server.general.assetstore.reloadAssets";
   public static final String ASSET_DELETED_MESSAGE_KEY = "server.general.assetstore.removedAssets";
   public static final String ASSET_RELOADED_MESSAGE_KEY = "server.general.assetstore.reloadAssets";
   public static final String ASSET_SECONDARY_GENERIC_MESSAGE_KEY = "server.general.assetstore.removedAssetsSecondaryGeneric";
   public static final String ASSET_ADDED_ICON = "Icons/AssetNotifications/IconCheckmark.png";
   public static final String ASSET_DELETED_ICON = "Icons/AssetNotifications/Trash.png";
   public static     ;
         ;
         ;
         ;

     {
   }
}

com/hypixel/hytale/server/core/asset/AssetPackRegisterEvent.java

package com.hypixel.hytale.server.core.asset;

import com.hypixel.hytale.assetstore.AssetPack;
import com.hypixel.hytale.event.IEvent;

public class AssetPackRegisterEvent implements IEvent<Void> {
   private final AssetPack assetPack;

   public AssetPackRegisterEvent(AssetPack assetPack) {
      this.assetPack = assetPack;
   }

   public AssetPack getAssetPack() {
      return this.assetPack;
   }
}

com/hypixel/hytale/server/core/asset/AssetPackUnregisterEvent.java

package com.hypixel.hytale.server.core.asset;

import com.hypixel.hytale.assetstore.AssetPack;
import com.hypixel.hytale.event.IEvent;

public class AssetPackUnregisterEvent implements IEvent<Void> {
   private final AssetPack assetPack;

   public AssetPackUnregisterEvent(AssetPack assetPack) {
      this.assetPack = assetPack;
   }

   public AssetPack getAssetPack() {
      return this.assetPack;
   }
}

com/hypixel/hytale/server/core/asset/AssetRegistryLoader.java

package com.hypixel.hytale.server.core.asset;

import com.hypixel.hytale.assetstore.AssetLoadResult;
import com.hypixel.hytale.assetstore.AssetMap;
import com.hypixel.hytale.assetstore.AssetPack;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetCodec;
import com.hypixel.hytale.assetstore.codec.AssetCodecMapCodec;
import com.hypixel.hytale.assetstore.iterator.AssetStoreIterator;
import com.hypixel.hytale.assetstore.iterator.CircularDependencyException;
import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.IndexedAssetMap;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.EmptyExtraInfo;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.common.util.FormatUtil;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.server.core.HytaleServer;
import com.hypixel.hytale.server.core.Options;
import com.hypixel.hytale.server.core.ShutdownReason;
import com.hypixel.hytale.server.core.asset.type.ambiencefx.AmbienceFXPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.ambiencefx.config.AmbienceFX;
import com.hypixel.hytale.server.core.asset.type.audiocategory.AudioCategoryPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.audiocategory.config.AudioCategory;
 com.hypixel.hytale.server.core.asset.type.blockbreakingdecal.BlockBreakingDecalPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.blockbreakingdecal.config.BlockBreakingDecal;
 com.hypixel.hytale.server.core.asset.type.blockhitbox.BlockBoundingBoxes;
 com.hypixel.hytale.server.core.asset.type.blockhitbox.BlockBoundingBoxesPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.blockparticle.BlockParticleSetPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.blockparticle.config.BlockParticleSet;
 com.hypixel.hytale.server.core.asset.type.blockset.BlockSetPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.blockset.config.BlockSet;
 com.hypixel.hytale.server.core.asset.type.blocksound.BlockSoundSetPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.blocksound.config.BlockSoundSet;
 com.hypixel.hytale.server.core.asset.type.blocktype.BlockGroupPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.blocktype.BlockTypePacketGenerator;
 com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockMigration;
 com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
 com.hypixel.hytale.server.core.asset.type.buildertool.config.BlockTypeListAsset;
 com.hypixel.hytale.server.core.asset.type.buildertool.config.PrefabListAsset;
 com.hypixel.hytale.server.core.asset.type.camera.CameraEffect;
 com.hypixel.hytale.server.core.asset.type.entityeffect.EntityEffectPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.entityeffect.config.EntityEffect;
 com.hypixel.hytale.server.core.asset.type.environment.EnvironmentPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.environment.config.Environment;
 com.hypixel.hytale.server.core.asset.type.equalizereffect.EqualizerEffectPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.equalizereffect.config.EqualizerEffect;
 com.hypixel.hytale.server.core.asset.type.fluid.Fluid;
 com.hypixel.hytale.server.core.asset.type.fluid.FluidTypePacketGenerator;
 com.hypixel.hytale.server.core.asset.type.fluidfx.FluidFXPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.fluidfx.config.FluidFX;
 com.hypixel.hytale.server.core.asset.type.gamemode.GameModeType;
 com.hypixel.hytale.server.core.asset.type.gameplay.GameplayConfig;
 com.hypixel.hytale.server.core.asset.type.item.FieldcraftCategoryPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.item.ItemCategoryPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.item.ResourceTypePacketGenerator;
 com.hypixel.hytale.server.core.asset.type.item.config.BlockGroup;
 com.hypixel.hytale.server.core.asset.type.item.config.BuilderToolItemReferenceAsset;
 com.hypixel.hytale.server.core.asset.type.item.config.CraftingRecipe;
 com.hypixel.hytale.server.core.asset.type.item.config.FieldcraftCategory;
 com.hypixel.hytale.server.core.asset.type.item.config.Item;
 com.hypixel.hytale.server.core.asset.type.item.config.ItemCategory;
 com.hypixel.hytale.server.core.asset.type.item.config.ItemDropList;
 com.hypixel.hytale.server.core.asset.type.item.config.ItemQuality;
 com.hypixel.hytale.server.core.asset.type.item.config.ItemReticleConfig;
 com.hypixel.hytale.server.core.asset.type.item.config.ItemToolSpec;
 com.hypixel.hytale.server.core.asset.type.item.config.ResourceType;
 com.hypixel.hytale.server.core.asset.type.itemanimation.ItemPlayerAnimationsPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.itemanimation.config.ItemPlayerAnimations;
 com.hypixel.hytale.server.core.asset.type.itemsound.ItemSoundSetPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.itemsound.config.ItemSoundSet;
 com.hypixel.hytale.server.core.asset.type.model.config.ModelAsset;
 com.hypixel.hytale.server.core.asset.type.modelvfx.ModelVFXPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.modelvfx.config.ModelVFX;
 com.hypixel.hytale.server.core.asset.type.particle.ParticleSpawnerPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.particle.ParticleSystemPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.particle.config.ParticleSpawner;
 com.hypixel.hytale.server.core.asset.type.particle.config.ParticleSystem;
 com.hypixel.hytale.server.core.asset.type.portalworld.PortalType;
 com.hypixel.hytale.server.core.asset.type.projectile.config.Projectile;
 com.hypixel.hytale.server.core.asset.type.responsecurve.config.ExponentialResponseCurve;
 com.hypixel.hytale.server.core.asset.type.responsecurve.config.ResponseCurve;
 com.hypixel.hytale.server.core.asset.type.reverbeffect.ReverbEffectPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.reverbeffect.config.ReverbEffect;
 com.hypixel.hytale.server.core.asset.type.soundevent.SoundEventPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
 com.hypixel.hytale.server.core.asset.type.soundset.SoundSetPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.soundset.config.SoundSet;
 com.hypixel.hytale.server.core.asset.type.tagpattern.TagPatternPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.tagpattern.config.AndPatternOp;
 com.hypixel.hytale.server.core.asset.type.tagpattern.config.EqualsTagOp;
 com.hypixel.hytale.server.core.asset.type.tagpattern.config.NotPatternOp;
 com.hypixel.hytale.server.core.asset.type.tagpattern.config.OrPatternOp;
 com.hypixel.hytale.server.core.asset.type.tagpattern.config.TagPattern;
 com.hypixel.hytale.server.core.asset.type.trail.TrailPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.trail.config.Trail;
 com.hypixel.hytale.server.core.asset.type.weather.WeatherPacketGenerator;
 com.hypixel.hytale.server.core.asset.type.weather.config.Weather;
 com.hypixel.hytale.server.core.asset.type.wordlist.WordList;
 com.hypixel.hytale.server.core.inventory.ItemStack;
 com.hypixel.hytale.server.core.io.PacketHandler;
 com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
 com.hypixel.hytale.server.core.modules.entity.hitboxcollision.HitboxCollisionConfig;
 com.hypixel.hytale.server.core.modules.entity.repulsion.RepulsionConfig;
 com.hypixel.hytale.server.core.modules.entitystats.asset.EntityStatType;
 com.hypixel.hytale.server.core.modules.interaction.interaction.UnarmedInteractions;
 com.hypixel.hytale.server.core.modules.interaction.interaction.config.Interaction;
 com.hypixel.hytale.server.core.modules.item.CraftingRecipePacketGenerator;
 com.hypixel.hytale.server.core.modules.item.ItemPacketGenerator;
 com.hypixel.hytale.server.core.modules.item.ItemQualityPacketGenerator;
 com.hypixel.hytale.server.core.modules.item.ItemReticleConfigPacketGenerator;
 com.hypixel.hytale.server.core.modules.projectile.config.ProjectileConfig;
 com.hypixel.hytale.server.core.modules.projectile.config.ProjectileConfigPacketGenerator;
 com.hypixel.hytale.server.core.universe.world.connectedblocks.CustomConnectedBlockTemplateAsset;
 com.hypixel.hytale.server.core.util.BsonUtil;
 com.hypixel.hytale.sneakythrow.SneakyThrow;
 it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap;
 java.nio.file.FileVisitOption;
 java.nio.file.Files;
 java.nio.file.LinkOption;
 java.nio.file.Path;
 java.util.Arrays;
 java.util.Collection;
 java.util.Collections;
 java.util.Comparator;
 java.util.HashMap;
 java.util.List;
 java.util.Map;
 java.util.Objects;
 java.util.function.Consumer;
 java.util.logging.Level;
 java.util.stream.Stream;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;
 org.bson.BsonArray;
 org.bson.BsonDocument;
 org.bson.BsonInt32;
 org.bson.BsonString;
 org.bson.BsonValue;

   {
         HytaleLogger.forEnclosingClass();

     {
   }

       {
   }

       {
       {
         preLoadAssets0(event);
      }  (Throwable t) {
         event.failed(, );
          SneakyThrow.sneakyThrow(t);
      }
   }

       {
      AssetRegistry.ASSET_LOCK.writeLock().lock();

       {
         loadAssets0(event, assetPack);
         AssetRegistry.HAS_INIT = ;
      }  (Throwable t) {
          (event != ) {
            event.failed(, );
         }

          SneakyThrow.sneakyThrow(t);
      }  {
         AssetRegistry.ASSET_LOCK.writeLock().unlock();
      }

   }

       {
      AssetStore.DISABLE_DYNAMIC_DEPENDENCIES = ;
      Collection<AssetStore<?, ?, ?>> values = AssetRegistry.getStoreMap().values();
      LOGGER.at(Level.INFO).log(, values.size());

      (AssetStore<?, ?, ?> assetStore : values) {
         assetStore.simplifyLoadBeforeDependencies();
      }

         ;
      LOGGER.at(Level.INFO).log();
          (values);

      label71: {
          {
            (iterator.hasNext()) {
                (HytaleServer.get().isShuttingDown()) {
                  LOGGER.at(Level.INFO).log();
                   label71;
               }

               AssetStore<?, ?  <?, ?  <?, ?>>, ?  <?, ?  <?, ?>>> assetStore = iterator.next();
                (assetStore == ) {
                    (values, iterator);
               }

                  System.nanoTime();
               Class<?  <?, ?  <?, ?>>> assetClass = assetStore.getAssetClass();

                {
                  List<?> preAddedAssets = assetStore.getPreAddedAssets();
                   (preAddedAssets !=  && !preAddedAssets.isEmpty()) {
                        assetStore.loadAssets(, preAddedAssets);
                     failedToLoadAsset |= loadResult.hasFailed();
                  }
               }  (Exception e) {
                  failedToLoadAsset = ;
                     System.nanoTime();
                     end - start;
                   (iterator.isBeingWaitedFor(assetStore)) {
                       (String.format(, assetClass.getSimpleName(), FormatUtil.nanosToString(diff)), e);
                  }

                  ((HytaleLogger.Api)LOGGER.at(Level.SEVERE).withCause(e)).log(, assetClass.getSimpleName(), FormatUtil.nanosToString(diff));
               }
            }
         }  (Throwable var15) {
             {
               iterator.close();
            }  (Throwable var13) {
               var15.addSuppressed(var13);
            }

             var15;
         }

         iterator.close();
          (failedToLoadAsset) {
            event.failed(Options.getOptionSet().has(Options.VALIDATE_ASSETS), );
         }

         ;
      }

      iterator.close();
   }

       {
      AssetStore.DISABLE_DYNAMIC_DEPENDENCIES = ;
         assetPack.getRoot().resolve();
      HytaleLogger.getLogger().at(Level.INFO).log(, serverAssetDirectory);
         System.nanoTime();
         ;
      LOGGER.at(Level.INFO).log(, serverAssetDirectory);
      Collection<AssetStore<?, ?, ?>> values = AssetRegistry.getStoreMap().values();
          (values);

      label87: {
          {
            (iterator.hasNext()) {
                (HytaleServer.get().isShuttingDown()) {
                  LOGGER.at(Level.INFO).log();
                   label87;
               }

               AssetStore<?, ?  <?, ?  <?, ?>>, ?  <?, ?  <?, ?>>> assetStore = iterator.next();
                (assetStore == ) {
                    (values, iterator);
               }

                  System.nanoTime();
               Class<?  <?, ?  <?, ?>>> assetClass = assetStore.getAssetClass();

                {
                     assetStore.getPath();
                   (path != ) {
                        serverAssetDirectory.resolve(path);
                      (Files.isDirectory(assetsPath,  [])) {
                        AssetLoadResult<?, ?  <?, ?  <?, ?>>> loadResult = assetStore.loadAssetsFromDirectory(assetPack.getName(), assetsPath);
                        failedToLoadAsset |= loadResult.hasFailed();
                     }
                  }
               }  (Exception e) {
                  failedToLoadAsset = ;
                     System.nanoTime();
                     end - start;
                   (iterator.isBeingWaitedFor(assetStore)) {
                       (String.format(, assetClass.getSimpleName(), assetStore.getPath(), FormatUtil.nanosToString(diff)), e);
                  }

                  ((HytaleLogger.Api)LOGGER.at(Level.SEVERE).withCause(e)).log(, assetClass.getSimpleName(), assetStore.getPath(), FormatUtil.nanosToString(diff));
               }
            }
         }  (Throwable var19) {
             {
               iterator.close();
            }  (Throwable var17) {
               var19.addSuppressed(var17);
            }

             var19;
         }

         iterator.close();

         (AssetStore<?, ?, ?> assetStore : values) {
             (assetPack.getName().equals()) {
               assetStore.validateCodecDefaults();
            }

               assetStore.getPath();
             (path != ) {
                  serverAssetDirectory.resolve(path);
                (Files.isDirectory(assetsPath,  []) && !assetPack.isImmutable()) {
                  assetStore.addFileMonitor(assetPack.getName(), assetsPath);
               }
            }
         }

            System.nanoTime();
            endAll - startAll;
         LOGGER.at(Level.INFO).log(, FormatUtil.nanosToString(diffAll));
          (failedToLoadAsset && event != ) {
            event.failed(Options.getOptionSet().has(Options.VALIDATE_ASSETS), );
         }

         ;
      }

      iterator.close();
   }

       {
      Objects.requireNonNull(packetHandler);
      Consumer<Packet[]> packetConsumer = packetHandler::write;
      Objects.requireNonNull(packetHandler);
      Consumer<Packet> singlePacketConsumer = packetHandler::write;
      AssetRegistry.ASSET_LOCK.writeLock().lock();

       {
         HytaleAssetStore.SETUP_PACKET_CONSUMERS.add(singlePacketConsumer);
      }  {
         AssetRegistry.ASSET_LOCK.writeLock().unlock();
      }

       {
         (AssetStore<?, ?, ?> assetStore : AssetRegistry.getStoreMap().values()) {
            ((HytaleAssetStore)assetStore).sendAssets(packetConsumer);
         }
      }  {
         AssetRegistry.ASSET_LOCK.writeLock().lock();

          {
            HytaleAssetStore.SETUP_PACKET_CONSUMERS.remove(singlePacketConsumer);
         }  {
            AssetRegistry.ASSET_LOCK.writeLock().unlock();
         }
      }

   }

   
     Map<String, Schema>  {
      AssetStore[] values = (AssetStore[])AssetRegistry.getStoreMap().values().toArray((x$) ->  [x$]);
      Arrays.sort(values, Comparator.comparing((storex) -> storex.getAssetClass().getSimpleName()));
          ();
          ();
      vsCodeConfig.put((String), (BsonValue)vsCodeSchemas);
      vsCodeConfig.put((String), (BsonValue)vsCodeFiles);
      vsCodeConfig.put((String), (BsonValue)( ()));

      (AssetStore store : values) {
            store.getAssetClass();
            assetClass.getSimpleName();
            store.getCodec();
         context.addFileReference(name + , codec);
      }

      HashMap<String, Schema> schemas =  ();

      (AssetStore store : values) {
            store.getAssetClass();
            store.getPath();
            assetClass.getSimpleName();
            store.getCodec();
            codec.toSchema(context);
          (codec  AssetCodecMapCodec) {
            schema.setTitle(name);
         }

         schema.setId(name + );
         Schema.   schema.getHytale();
         hytale.setPath(path);
         hytale.setExtension(store.getExtension());
            store.getIdProvider();
          (idProvider != ) {
            hytale.setIdProvider(idProvider.getSimpleName());
         }

            store.getPreAddedAssets();
          (preload !=  && !preload.isEmpty()) {
            String[] internal =  [preload.size()];

            (   ; i < preload.size(); ++i) {
                  preload.get(i);
                  store.getKeyFunction().apply(p);
               internal[i] = k.toString();
            }

            hytale.setInternalKeys(internal);
         }

             ();
         config.put((String), (BsonValue)( (List.of( ( + path +  + store.getExtension()),  ( + path +  + store.getExtension())))));
         config.put((String), (BsonValue)( ( + name + )));
         vsCodeSchemas.add((BsonValue)config);
          (!store.getExtension().equals()) {
            vsCodeFiles.put((String)( + store.getExtension()), (BsonValue)( ()));
         }

         schemas.put(name + , schema);
      }

      HytaleServer.get().getEventBus().dispatchFor(GenerateSchemaEvent.class).dispatch( (schemas, context, vsCodeConfig));
          ();
      definitions.setDefinitions(context.getDefinitions());
      definitions.setId();
      schemas.put(, definitions);
          ();
      otherDefinitions.setDefinitions(context.getOtherDefinitions());
      otherDefinitions.setId();
      schemas.put(, otherDefinitions);
       schemas;
   }

       {
       (Options.getOptionSet().has(Options.GENERATE_SCHEMA)) {
          {
               AssetModule.get().getBaseAssetPack();
             (pack.isImmutable()) {
               LOGGER.at(Level.SEVERE).log();
               HytaleServer.get().shutdownServer(ShutdownReason.VALIDATE_ERROR.withMessage());
               ;
            }

                ();
               pack.getRoot();
               assetDirectory.resolve();
            Files.createDirectories(schemaDir);
            Stream<Path> stream = Files.walk(schemaDir, ,  []);

             {
               stream.filter((v) -> v.toString().endsWith()).forEach(SneakyThrow.sneakyConsumer(Files::delete));
            }  (Throwable var10) {
                (stream != ) {
                   {
                     stream.close();
                  }  (Throwable var9) {
                     var10.addSuppressed(var9);
                  }
               }

                var10;
            }

             (stream != ) {
               stream.close();
            }

                ();
            Map<String, Schema> schemas = generateSchemas(context, vsCodeConfig);

            (Map.Entry<String, Schema> schema : schemas.entrySet()) {
               BsonUtil.writeDocument(schemaDir.resolve((String)schema.getKey()), Schema.CODEC.encode((Schema)schema.getValue(), EmptyExtraInfo.EMPTY).asDocument(), ).join();
            }

            Files.createDirectories(assetDirectory.resolve());
            BsonUtil.writeDocument(assetDirectory.resolve(), vsCodeConfig, ).join();
         }  (Throwable t) {
            ((HytaleLogger.Api)LOGGER.at(Level.SEVERE).withCause(t)).log();
            HytaleServer.get().shutdownServer(ShutdownReason.CRASH.withMessage());
            ;
         }

         HytaleServer.get().shutdownServer(ShutdownReason.SHUTDOWN.withMessage());
      }
   }

    {
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(AmbienceFX.class,  ()).setPath()).setCodec(AmbienceFX.CODEC)).setKeyFunction(AmbienceFX::getId)).setReplaceOnRemove(AmbienceFX::)).setPacketGenerator( ()).loadsAfter( []{Weather.class, Environment.class, FluidFX.class, SoundEvent.class, BlockSoundSet.class, TagPattern.class, AudioCategory.class, ReverbEffect.class, EqualizerEffect.class})).preLoadAssets(Collections.singletonList(AmbienceFX.EMPTY))).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(BlockBoundingBoxes.class,  ((x$) ->  [x$])).setPath()).setCodec(BlockBoundingBoxes.CODEC)).setKeyFunction(BlockBoundingBoxes::getId)).setReplaceOnRemove(BlockBoundingBoxes::getUnitBoxFor)).setPacketGenerator( ()).preLoadAssets(Collections.singletonList(BlockBoundingBoxes.UNIT_BOX))).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(BlockSet.class,  ((x$) ->  [x$])).setPath()).setCodec(BlockSet.CODEC)).setKeyFunction(BlockSet::getId)).setReplaceOnRemove(BlockSet::)).setPacketGenerator( ()).loadsBefore( []{Item.class})).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(BlockSoundSet.class,  ((x$) ->  [x$])).setPath()).setCodec(BlockSoundSet.CODEC)).setKeyFunction(BlockSoundSet::getId)).setReplaceOnRemove(BlockSoundSet::)).setPacketGenerator( ()).loadsAfter( []{SoundEvent.class})).preLoadAssets(Collections.singletonList(BlockSoundSet.EMPTY_BLOCK_SOUND_SET))).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(ItemSoundSet.class,  ((x$) ->  [x$])).setPath()).setCodec(ItemSoundSet.CODEC)).setKeyFunction(ItemSoundSet::getId)).setReplaceOnRemove(ItemSoundSet::)).setPacketGenerator( ()).loadsAfter( []{SoundEvent.class})).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(BlockParticleSet.class,  ()).setPath()).setCodec(BlockParticleSet.CODEC)).setKeyFunction(BlockParticleSet::getId)).setPacketGenerator( ()).loadsAfter( []{ParticleSystem.class})).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(BlockBreakingDecal.class,  ()).setPath()).setCodec(BlockBreakingDecal.CODEC)).setKeyFunction(BlockBreakingDecal::getId)).setPacketGenerator( ()).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(Integer.class, BlockMigration.class,  ()).setPath()).setCodec(BlockMigration.CODEC)).setKeyFunction(BlockMigration::getId)).build());
      BlockTypeAssetMap<String, BlockType> blockTypeAssetMap =  <String, BlockType>((x$) ->  [x$], BlockType::getGroup);
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(BlockType.class, blockTypeAssetMap).setPath()).setCodec(BlockType.CODEC)).setKeyFunction(BlockType::getId)).setPacketGenerator( ()).loadsAfter( []{BlockBoundingBoxes.class, BlockSoundSet.class, SoundEvent.class, BlockParticleSet.class, BlockBreakingDecal.class, CustomConnectedBlockTemplateAsset.class, PrefabListAsset.class, BlockTypeListAsset.class})).setNotificationItemFunction((item) -> ( (item, )).toPacket()).setReplaceOnRemove(BlockType::getUnknownFor)).preLoadAssets(Arrays.asList(BlockType.EMPTY, BlockType.UNKNOWN, BlockType.DEBUG_CUBE, BlockType.DEBUG_MODEL))).setIdProvider(Item.class)).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(Fluid.class,  ((x$) ->  [x$])).setPath()).setCodec(Fluid.CODEC)).setKeyFunction(Fluid::getId)).setReplaceOnRemove(Fluid::getUnknownFor)).setPacketGenerator( ()).loadsAfter( []{FluidFX.class, BlockSoundSet.class, BlockParticleSet.class, SoundEvent.class})).preLoadAssets(List.of(Fluid.EMPTY, Fluid.UNKNOWN))).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(ItemPlayerAnimations.class,  ()).setPath()).setCodec(ItemPlayerAnimations.CODEC)).setKeyFunction(ItemPlayerAnimations::getId)).setPacketGenerator( ()).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(Environment.class,  ((x$) ->  [x$])).setPath()).setCodec(Environment.CODEC)).setKeyFunction(Environment::getId)).setReplaceOnRemove(Environment::getUnknownFor)).setPacketGenerator( ()).loadsAfter( []{Weather.class, FluidFX.class, ParticleSystem.class})).preLoadAssets(Collections.singletonList(Environment.UNKNOWN))).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(FluidFX.class,  ((x$) ->  [x$])).setPath()).setCodec(FluidFX.CODEC)).setKeyFunction(FluidFX::getId)).setReplaceOnRemove(FluidFX::getUnknownFor)).setPacketGenerator( ()).loadsAfter( []{ParticleSystem.class})).preLoadAssets(Collections.singletonList(FluidFX.EMPTY_FLUID_FX))).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(ItemCategory.class,  (Collections.synchronizedMap( ()))).setPath()).setCodec(ItemCategory.CODEC)).setKeyFunction(ItemCategory::getId)).setPacketGenerator( ()).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(FieldcraftCategory.class,  (Collections.synchronizedMap( ()))).setPath()).setCodec(FieldcraftCategory.CODEC)).setKeyFunction(FieldcraftCategory::getId)).setPacketGenerator( ()).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(ItemDropList.class,  ()).setPath()).setCodec(ItemDropList.CODEC)).setKeyFunction(ItemDropList::getId)).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(WordList.class,  ()).setPath()).setCodec(WordList.CODEC)).setKeyFunction(WordList::getId)).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(ItemReticleConfig.class,  ((x$) ->  [x$])).setPath()).setCodec(ItemReticleConfig.CODEC)).setKeyFunction(ItemReticleConfig::getId)).setReplaceOnRemove(ItemReticleConfig::)).setPacketGenerator( ()).preLoadAssets(Collections.singletonList(ItemReticleConfig.DEFAULT))).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(ItemToolSpec.class,  ()).setPath()).setCodec(ItemToolSpec.CODEC)).setKeyFunction(ItemToolSpec::getGatherType)).loadsAfter( []{SoundEvent.class})).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(PortalType.class,  ()).setPath()).setCodec(PortalType.CODEC)).setKeyFunction(PortalType::getId)).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(Item.class,  ()).setPath()).setCodec(Item.CODEC)).setKeyFunction(Item::getId)).setPacketGenerator( ()).loadsAfter( []{ItemCategory.class, ItemPlayerAnimations.class, UnarmedInteractions.class, ResourceType.class, BlockType.class, EntityEffect.class, ItemQuality.class, ItemReticleConfig.class, SoundEvent.class, PortalType.class, ItemSoundSet.class})).setNotificationItemFunction((item) -> ( (item, )).toPacket()).preLoadAssets(Collections.singletonList(Item.UNKNOWN))).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(CraftingRecipe.class,  ()).setPath()).setCodec(CraftingRecipe.CODEC)).setKeyFunction(CraftingRecipe::getId)).setPacketGenerator( ()).loadsAfter( []{Item.class, BlockType.class})).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(ModelAsset.class,  ()).setPath()).setCodec(ModelAsset.CODEC)).setKeyFunction(ModelAsset::getId)).loadsAfter( []{ParticleSystem.class, SoundEvent.class, Trail.class})).preLoadAssets(List.of(ModelAsset.DEBUG))).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(ParticleSpawner.class,  ()).setPath()).setExtension()).setCodec(ParticleSpawner.CODEC)).setKeyFunction(ParticleSpawner::getId)).setPacketGenerator( ()).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(ParticleSystem.class,  ()).setPath()).setExtension()).setCodec(ParticleSystem.CODEC)).setKeyFunction(ParticleSystem::getId)).setPacketGenerator( ()).loadsAfter( []{ParticleSpawner.class})).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(Trail.class,  ()).setPath()).setCodec(Trail.CODEC)).setKeyFunction(Trail::getId)).setPacketGenerator( ()).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(Projectile.class,  ()).setPath()).setCodec(Projectile.CODEC)).setKeyFunction(Projectile::getId)).loadsAfter( []{SoundEvent.class, ModelAsset.class, ParticleSystem.class})).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(EntityEffect.class,  ((x$) ->  [x$])).setPath()).setCodec(EntityEffect.CODEC)).setKeyFunction(EntityEffect::getId)).setReplaceOnRemove(EntityEffect::)).setPacketGenerator( ()).loadsAfter( []{ModelAsset.class, ParticleSystem.class, EntityStatType.class, ModelVFX.class, DamageCause.class, CameraEffect.class, SoundEvent.class})).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(ModelVFX.class,  ((x$) ->  [x$])).setPath()).setCodec(ModelVFX.CODEC)).setKeyFunction(ModelVFX::getId)).setReplaceOnRemove(ModelVFX::)).setPacketGenerator( ()).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(GameModeType.class,  ()).setPath()).setCodec(GameModeType.CODEC)).setKeyFunction(GameModeType::getId)).loadsAfter( []{Interaction.class})).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(ResourceType.class,  ()).setPath()).setCodec(ResourceType.CODEC)).setKeyFunction(ResourceType::getId)).setPacketGenerator( ()).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(Weather.class,  ((x$) ->  [x$])).setPath()).setCodec(Weather.CODEC)).setKeyFunction(Weather::getId)).setReplaceOnRemove(Weather::)).setPacketGenerator( ()).loadsAfter( []{ParticleSystem.class})).preLoadAssets(Collections.singletonList(Weather.UNKNOWN))).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(GameplayConfig.class,  ()).setPath()).setCodec(GameplayConfig.CODEC)).setKeyFunction(GameplayConfig::getId)).loadsAfter( []{Item.class, SoundEvent.class, SoundSet.class, BlockType.class, EntityEffect.class, HitboxCollisionConfig.class, DamageCause.class, RepulsionConfig.class, ParticleSystem.class, AmbienceFX.class})).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(SoundEvent.class,  ((x$) ->  [x$])).setPath()).setCodec(SoundEvent.CODEC)).setKeyFunction(SoundEvent::getId)).setReplaceOnRemove(SoundEvent::)).setPacketGenerator( ()).preLoadAssets(Collections.singletonList(SoundEvent.EMPTY_SOUND_EVENT))).loadsAfter( []{AudioCategory.class})).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(SoundSet.class,  ((x$) ->  [x$])).setPath()).setCodec(SoundSet.CODEC)).setKeyFunction(SoundSet::getId)).setReplaceOnRemove(SoundSet::)).setPacketGenerator( ()).loadsAfter( []{SoundEvent.class})).preLoadAssets(Collections.singletonList(SoundSet.EMPTY_SOUND_SET))).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(AudioCategory.class,  ((x$) ->  [x$])).setPath()).setCodec(AudioCategory.CODEC)).setKeyFunction(AudioCategory::getId)).setReplaceOnRemove(AudioCategory::)).setPacketGenerator( ()).preLoadAssets(Collections.singletonList(AudioCategory.EMPTY_AUDIO_CATEGORY))).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(ReverbEffect.class,  ((x$) ->  [x$])).setPath()).setCodec(ReverbEffect.CODEC)).setKeyFunction(ReverbEffect::getId)).setReplaceOnRemove(ReverbEffect::)).setPacketGenerator( ()).preLoadAssets(Collections.singletonList(ReverbEffect.EMPTY_REVERB_EFFECT))).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(EqualizerEffect.class,  ((x$) ->  [x$])).setPath()).setCodec(EqualizerEffect.CODEC)).setKeyFunction(EqualizerEffect::getId)).setReplaceOnRemove(EqualizerEffect::)).setPacketGenerator( ()).preLoadAssets(Collections.singletonList(EqualizerEffect.EMPTY_EQUALIZER_EFFECT))).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(ResponseCurve.class,  ((x$) ->  [x$])).setPath()).setCodec(ResponseCurve.CODEC)).setKeyFunction(ResponseCurve::getId)).setReplaceOnRemove(ExponentialResponseCurve::)).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(ItemQuality.class,  ((x$) ->  [x$])).setPath()).setCodec(ItemQuality.CODEC)).setKeyFunction(ItemQuality::getId)).setPacketGenerator( ()).setReplaceOnRemove(ItemQuality::)).loadsAfter( []{ParticleSystem.class})).preLoadAssets(Collections.singletonList(ItemQuality.DEFAULT_ITEM_QUALITY))).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(DamageCause.class,  ((x$) ->  [x$])).setPath()).setCodec(DamageCause.CODEC)).setKeyFunction(DamageCause::getId)).setReplaceOnRemove(DamageCause::)).loadsBefore( []{Item.class, Interaction.class})).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(ProjectileConfig.class,  ()).setPath()).setCodec(ProjectileConfig.CODEC)).setKeyFunction(ProjectileConfig::getId)).loadsAfter( []{Interaction.class, SoundEvent.class, ModelAsset.class, ParticleSystem.class})).setPacketGenerator( ()).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(BlockGroup.class,  ()).setPath()).setCodec(BlockGroup.CODEC)).setKeyFunction(BlockGroup::getId)).loadsAfter( []{BlockType.class, Item.class})).setPacketGenerator( ()).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(BuilderToolItemReferenceAsset.class,  ()).setPath()).setCodec(BuilderToolItemReferenceAsset.CODEC)).setKeyFunction(BuilderToolItemReferenceAsset::getId)).loadsAfter( []{BlockType.class, Item.class})).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(BlockTypeListAsset.class,  ()).setPath()).setKeyFunction(BlockTypeListAsset::getId)).setCodec(BlockTypeListAsset.CODEC)).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(PrefabListAsset.class,  ()).setPath()).setKeyFunction(PrefabListAsset::getId)).setCodec(PrefabListAsset.CODEC)).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(CameraEffect.class,  ((x$) ->  [x$])).loadsBefore( []{GameplayConfig.class, Interaction.class})).setPath()).setCodec(CameraEffect.CODEC)).setKeyFunction(CameraEffect::getId)).setReplaceOnRemove(CameraEffect.MissingCameraEffect::)).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(TagPattern.class,  ((x$) ->  [x$])).setPath()).setCodec(TagPattern.CODEC)).setKeyFunction(TagPattern::getId)).setReplaceOnRemove(EqualsTagOp::)).setPacketGenerator( ()).build());
      TagPattern.CODEC.register(, EqualsTagOp.class, EqualsTagOp.CODEC);
      TagPattern.CODEC.register(, AndPatternOp.class, AndPatternOp.CODEC);
      TagPattern.CODEC.register(, OrPatternOp.class, OrPatternOp.CODEC);
      TagPattern.CODEC.register(, NotPatternOp.class, NotPatternOp.CODEC);
   }
}

com/hypixel/hytale/server/core/asset/GenerateSchemaEvent.java

package com.hypixel.hytale.server.core.asset;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.event.IEvent;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonArray;
import org.bson.BsonDocument;
import org.bson.BsonString;
import org.bson.BsonValue;

public class GenerateSchemaEvent implements IEvent<Void> {
   protected final Map<String, Schema> schemas;
   protected final SchemaContext context;
   protected final BsonDocument vsCodeConfig;

   public GenerateSchemaEvent(Map<String, Schema> schemas, SchemaContext context, BsonDocument vsCodeConfig) {
      this.schemas = schemas;
      this.context = context;
      this.vsCodeConfig = vsCodeConfig;
   }

   public SchemaContext getContext() {
      return this.context;
   }

   public BsonDocument getVsCodeConfig() {
      return this.vsCodeConfig;
   }

      {
          ();
      config.put((String), (BsonValue)( ((List)paths.stream().map((v) ->  ( + v)).collect(Collectors.toList()))));
      config.put((String), (BsonValue)( ( + name + )));
      .vsCodeConfig.getArray().add((BsonValue)config);
       (extension !=  && !extension.equals()) {
         .vsCodeConfig.getDocument().put((String)( + extension), (BsonValue)( ()));
      }

   }

      {
      .schemas.put(fileName, schema);
   }
}

com/hypixel/hytale/server/core/asset/HytaleAssetStore.java

package com.hypixel.hytale.server.core.asset;

import com.hypixel.hytale.assetstore.AssetLoadResult;
import com.hypixel.hytale.assetstore.AssetMap;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.AssetUpdateQuery;
import com.hypixel.hytale.assetstore.event.AssetStoreMonitorEvent;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.common.util.FormatUtil;
import com.hypixel.hytale.common.util.PathUtil;
import com.hypixel.hytale.event.EventBus;
import com.hypixel.hytale.event.IEventDispatcher;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.protocol.ItemWithAllMetadata;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.packets.interface_.NotificationStyle;
import com.hypixel.hytale.server.core.HytaleServer;
import com.hypixel.hytale.server.core.Message;
import com.hypixel.hytale.server.core.Options;
import com.hypixel.hytale.server.core.asset.monitor.AssetMonitor;
import com.hypixel.hytale.server.core.asset.monitor.AssetMonitorHandler;
import com.hypixel.hytale.server.core.asset.monitor.EventKind;
import com.hypixel.hytale.server.core.asset.packet.AssetPacketGenerator;
import com.hypixel.hytale.server.core.universe.Universe;
import com.hypixel.hytale.server.core.util.NotificationUtil;
import com.hypixel.hytale.server.core.util.io.FileUtil;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import it.unimi.dsi.fastutil.objects.ObjectList;
import java.io.IOException;
import java.lang.ref.SoftReference;
import java.nio.file.Files;
 java.nio.file.LinkOption;
 java.nio.file.Path;
 java.util.Map;
 java.util.Objects;
 java.util.Set;
 java.util.function.Consumer;
 java.util.function.Function;
 java.util.logging.Level;
 java.util.stream.Stream;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;

  <K, T  <K, M>, M  <K, T>>  <K, T, M> {
      ObjectList<Consumer<Packet>> SETUP_PACKET_CONSUMERS;
     AssetPacketGenerator<K, T, M> packetGenerator;
     Function<K, ItemWithAllMetadata> notificationItemFunction;
   
    SoftReference<Packet[]> cachedInitPackets;

     {
      (builder);
      .packetGenerator = builder.packetGenerator;
      .notificationItemFunction = builder.notificationItemFunction;
   }

    AssetPacketGenerator<K, T, M>  {
       .packetGenerator;
   }

    Function<K, ItemWithAllMetadata>  {
       .notificationItemFunction;
   }

   
    EventBus  {
       HytaleServer.get().getEventBus();
   }

      {
         AssetModule.get().getAssetMonitor();
       (assetMonitor != ) {
         assetMonitor.monitorDirectoryFiles(assetsPath,  (packKey));
      }
   }

      {
         AssetModule.get().getAssetMonitor();
       (assetMonitor != ) {
         assetMonitor.removeMonitorDirectoryFiles(path, );
      }

   }

      {
       (.packetGenerator != ) {
         .cachedInitPackets = ;
            Universe.get();
          (universe.getPlayerCount() !=  || !SETUP_PACKET_CONSUMERS.isEmpty()) {
             (toBeRemoved !=  && !toBeRemoved.isEmpty()) {
                  .packetGenerator.generateRemovePacket(.assetMap, toBeRemoved, query);
               universe.broadcastPacketNoCache(packet);

               (   ; i < SETUP_PACKET_CONSUMERS.size(); ++i) {
                  Consumer<Packet> c = (Consumer)SETUP_PACKET_CONSUMERS.get(i);
                  c.accept(packet);
               }
            }

             (toBeUpdated !=  && !toBeUpdated.isEmpty()) {
                  .packetGenerator.generateUpdatePacket(.assetMap, toBeUpdated, query);
               universe.broadcastPacketNoCache(packet);

               (   ; i < SETUP_PACKET_CONSUMERS.size(); ++i) {
                  Consumer<Packet> c = (Consumer)SETUP_PACKET_CONSUMERS.get(i);
                  c.accept(packet);
               }
            }

         }
      }
   }

      {
       (.packetGenerator != ) {
         Packet[] packets = .cachedInitPackets ==  ?  : (Packet[]).cachedInitPackets.get();
          (packets != ) {
            packetConsumer.accept(packets);
         }  {
            Map<K, T> map = .assetMap.getAssetMap();
               .packetGenerator.generateInitPacket(.assetMap, map);
            .cachedInitPackets =  (packets =  []{packet});
            packetConsumer.accept(packets);
         }
      }
   }

      {
      .sendNotificationKeys(Message.translation().param(, .tClass.getSimpleName()).color(), , result.getLoadedAssets().keySet());
      .sendNotificationKeys(Message.translation().param(, .tClass.getSimpleName()), (String), result.getFailedToLoadKeys());
      .sendNotificationPaths(Message.translation().param(, .tClass.getSimpleName()), result.getFailedToLoadPaths());
   }

      {
      .sendNotificationKeys(Message.translation().param(, .tClass.getSimpleName()).color(), , removedKeys);
   }

      {
       (!keys.isEmpty()) {
          (.notificationItemFunction !=  && keys.size() < ) {
            (K key : keys) {
                  (ItemWithAllMetadata).notificationItemFunction.apply(key);
                (item != ) {
                  NotificationUtil.sendNotificationToUniverse(primaryMessage, Message.raw(key.toString()), item, NotificationStyle.Default);
               }  {
                  NotificationUtil.sendNotificationToUniverse(primaryMessage, Message.raw(key.toString()), icon, (ItemWithAllMetadata), NotificationStyle.Default);
               }
            }

         }  {
               Message.translation().param(, keys.size());
            NotificationUtil.sendNotificationToUniverse(primaryMessage, secondaryMessage, icon, NotificationStyle.Default);
         }
      }
   }

      {
       (!paths.isEmpty()) {
         NotificationUtil.sendNotificationToUniverse(primaryMessage, Message.raw(paths.toString()), NotificationStyle.Warning);
      }
   }

   
     <T  <String, M>, M  <String, T>> Builder<String, T, M>  {
        <String, T, M>(String.class, tClass, assetMap);
   }

   
     <K, T  <K, M>, M  <K, T>> Builder<K, T, M>  {
        <K, T, M>(kClass, tClass, assetMap);
   }

    {
      AssetStore.DISABLE_ASSET_COMPARE = Options.getOptionSet().has(Options.DISABLE_ASSET_COMPARE);
      SETUP_PACKET_CONSUMERS =  <Consumer<Packet>>();
   }

      <K, T  <K, M>, M  <K, T>>  .Builder<K, T, M, Builder<K, T, M>> {
       AssetPacketGenerator<K, T, M> packetGenerator;
       Function<K, ItemWithAllMetadata> notificationItemFunction;

        {
         (kClass, tClass, assetMap);
      }

      
       Builder<K, T, M>  {
         .packetGenerator = (AssetPacketGenerator)Objects.requireNonNull(packetGenerator, );
          ;
      }

      
       Builder<K, T, M>  {
         .notificationItemFunction = (Function)Objects.requireNonNull(notificationItemFunction, );
          ;
      }

      
       HytaleAssetStore<K, T, M>  {
           <K, T, M>();
      }
   }

        {
        String packKey;

        {
         .packKey = packKey;
      }

       Object  {
          HytaleAssetStore.;
      }

         {
          !Files.isRegularFile(path,  []) || path.getFileName().toString().endsWith(HytaleAssetStore..extension);
      }

         {
         ObjectArrayList<Path> createdOrModifiedFilesToLoad =  <Path>();
         ObjectArrayList<Path> removedFilesToUnload =  <Path>();
         ObjectArrayList<Path> createdOrModifiedDirectories =  <Path>();
         ObjectArrayList<Path> removedFilesAndDirectories =  <Path>();

         (Map.Entry<Path, EventKind> entry : map.entrySet()) {
               (Path)entry.getKey();
             ((EventKind)entry.getValue()) {
                ENTRY_CREATE:
                   (Files.isDirectory(path,  [])) {
                     HytaleAssetStore..logger.at(Level.FINEST).log(, path);

                      {
                        Stream<Path> stream = Files.walk(path, FileUtil.DEFAULT_WALK_TREE_OPTIONS_ARRAY);

                         {
                           stream.forEach((child) -> {
                               (Files.isDirectory(child,  [])) {
                                 createdOrModifiedDirectories.add(path);
                              }

                               (Files.isRegularFile(child,  []) && child.getFileName().toString().endsWith(HytaleAssetStore..extension)) {
                                 createdOrModifiedFilesToLoad.add(child);
                              }

                           });
                        }  (Throwable var13) {
                            (stream != ) {
                               {
                                 stream.close();
                              }  (Throwable var12) {
                                 var13.addSuppressed(var12);
                              }
                           }

                            var13;
                        }

                         (stream != ) {
                           stream.close();
                        }
                     }  (IOException e) {
                        ((HytaleLogger.Api)HytaleAssetStore..logger.at(Level.SEVERE).withCause(e)).log(, path);
                     }
                  }  {
                     HytaleAssetStore..logger.at(Level.FINEST).log(, path);
                     createdOrModifiedFilesToLoad.add(path);
                     createdOrModifiedFilesToLoad.add(path);
                  }
                  ;
                ENTRY_DELETE:
                  removedFilesAndDirectories.add(path);

                  (Path value : HytaleAssetStore..getAssetMap().getPathMap(.packKey).values()) {
                      (PathUtil.isChildOf(path, value)) {
                        HytaleAssetStore..logger.at(Level.FINEST).log(, value);
                        removedFilesToUnload.add(value);
                     }
                  }
                  ;
                ENTRY_MODIFY:
                   (Files.isDirectory(path,  [])) {
                     HytaleAssetStore..logger.at(Level.FINEST).log(, path);
                     createdOrModifiedDirectories.add(path);
                  }  {
                     HytaleAssetStore..logger.at(Level.FINEST).log(, path);
                     createdOrModifiedFilesToLoad.add(path);
                  }
                  ;
               :
                    ( + String.valueOf(entry.getValue()));
            }
         }

          (!removedFilesAndDirectories.isEmpty() || !createdOrModifiedFilesToLoad.isEmpty() || !createdOrModifiedDirectories.isEmpty()) {
            IEventDispatcher<AssetStoreMonitorEvent, AssetStoreMonitorEvent> dispatchFor = HytaleAssetStore..getEventBus().dispatchFor(AssetStoreMonitorEvent.class);
             (dispatchFor.hasListener()) {
               dispatchFor.dispatch( (.packKey, HytaleAssetStore., createdOrModifiedFilesToLoad, removedFilesToUnload, createdOrModifiedDirectories, removedFilesAndDirectories));
            }
         }

          (!createdOrModifiedFilesToLoad.isEmpty()) {
            HytaleAssetStore..logger.at(Level.INFO).log(, createdOrModifiedFilesToLoad);
               System.nanoTime();
            AssetLoadResult<K, T> result = HytaleAssetStore..loadAssetsFromPaths(.packKey, createdOrModifiedFilesToLoad, AssetUpdateQuery.DEFAULT, );
            HytaleAssetStore..logger.at(Level.INFO).log(, FormatUtil.nanosToString(System.nanoTime() - start), createdOrModifiedFilesToLoad);
            HytaleAssetStore..sendReloadedNotification(result);
         }

          (!removedFilesToUnload.isEmpty()) {
            HytaleAssetStore..logger.at(Level.INFO).log(, removedFilesToUnload);
            Set<K> removedKeys = HytaleAssetStore..removeAssetWithPaths(.packKey, removedFilesToUnload);
            HytaleAssetStore..sendRemovedNotification(removedKeys);
         }

      }
   }
}

com/hypixel/hytale/server/core/asset/LoadAssetEvent.java

package com.hypixel.hytale.server.core.asset;

import com.hypixel.hytale.event.IEvent;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.util.List;
import javax.annotation.Nonnull;

public class LoadAssetEvent implements IEvent<Void> {
   public static final short PRIORITY_LOAD_COMMON = -32;
   public static final short PRIORITY_LOAD_REGISTRY = -16;
   public static final short PRIORITY_LOAD_LATE = 64;
   private final long bootStart;
   @Nonnull
   private final List<String> reasons = new ObjectArrayList<String>();
   private boolean shouldShutdown = false;

   public LoadAssetEvent(long bootStart) {
      this.bootStart = bootStart;
   }

      {
       .bootStart;
   }

      {
       .shouldShutdown;
   }

   
    List<String>  {
       .reasons;
   }

      {
      .shouldShutdown |= shouldShutdown;
      .reasons.add(reason);
   }

   
    String  {
         .bootStart;
        + var10000 +  + .shouldShutdown +  + String.valueOf(.reasons) + ;
   }
}

com/hypixel/hytale/server/core/asset/common/BlockyAnimationCache.java

package com.hypixel.hytale.server.core.asset.common;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.util.RawJsonReader;
import com.hypixel.hytale.common.util.CompletableFutureUtil;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.sneakythrow.SneakyThrow;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class BlockyAnimationCache {
   public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   private static final Map<String, BlockyAnimation> animations = new ConcurrentHashMap();

   public BlockyAnimationCache() {
   }

   @Nonnull
   public static CompletableFuture<BlockyAnimation> get(String name) {
      BlockyAnimation animationData  (BlockyAnimation)animations.get(name);
       (animationData != ) {
          CompletableFuture.completedFuture(animationData);
      }  {
            CommonAssetRegistry.getByName(name);
          asset ==  ? CompletableFuture.completedFuture((Object)) : get0(asset);
      }
   }

   
     CompletableFuture<BlockyAnimation>  {
         (BlockyAnimation)animations.get(asset.getName());
       animationData !=  ? CompletableFuture.completedFuture(animationData) : get0(asset);
   }

   
     BlockyAnimation  {
         (BlockyAnimation)animations.get(name);
       (animationData != ) {
          animationData;
      }  {
            CommonAssetRegistry.getByName(name);
          asset ==  ?  : (BlockyAnimation)get0(asset).join();
      }
   }

     BlockyAnimation  {
         (BlockyAnimation)animations.get(asset.getName());
       animationData !=  ? animationData : (BlockyAnimation)get0(asset).join();
   }

   
     CompletableFuture<BlockyAnimation>  {
         asset.getName();
       CompletableFutureUtil.<BlockyAnimation>_catch(asset.getBlob().thenApply((bytes) -> {
             (bytes, StandardCharsets.UTF_8);
            RawJsonReader.fromJsonString(str);

          {
               (ExtraInfo)ExtraInfo.THREAD_LOCAL.get();
               BlockyAnimationCache.BlockyAnimation.CODEC.decodeJson(reader, extraInfo);
            extraInfo.getValidationResults().logOrThrowValidatorExceptions(LOGGER);
            animations.put(name, newAnimationData);
             newAnimationData;
         }  (IOException e) {
             SneakyThrow.sneakyThrow(e);
         }
      }));
   }

       {
      animations.remove(name);
   }

       {
         BuilderCodec<BlockyAnimation> CODEC;
            ;
        duration;

        {
      }

         {
          .duration;
      }

         {
          ().duration *  / ;
      }

         {
          ().duration / ;
      }

      
       String  {
           + .duration + ;
      }

       {
         CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(BlockyAnimation.class, BlockyAnimation::).addField( (, Codec.INTEGER, , ), (blockyAnimation, i) -> blockyAnimation.duration = i, (blockyAnimation) -> blockyAnimation.duration)).build();
      }
   }
}

com/hypixel/hytale/server/core/asset/common/CommonAsset.java

package com.hypixel.hytale.server.core.asset.common;

import com.hypixel.hytale.common.util.PatternUtil;
import com.hypixel.hytale.protocol.Asset;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import com.hypixel.hytale.server.core.util.HashUtil;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.util.concurrent.CompletableFuture;
import java.util.regex.Pattern;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public abstract class CommonAsset implements NetworkSerializable<Asset> {
   public static final int HASH_LENGTH = 64;
   public static final Pattern HASH_PATTERN = Pattern.compile("^[A-Fa-f0-9]{64}$");
   @Nonnull
   private final String name;
   @Nonnull
   private final String hash;
   protected transient WeakReference<CompletableFuture<byte[]>> blob;
   protected transient SoftReference<Asset> cachedPacket;

   public CommonAsset {
      .name = PatternUtil.replaceBackslashWithForwardSlash(name);
      .hash = hash(bytes);
      .blob =  (bytes !=  ? CompletableFuture.completedFuture(bytes) : );
   }

     {
      .name = PatternUtil.replaceBackslashWithForwardSlash(name);
      .hash = hash.toLowerCase();
      .blob =  (bytes !=  ? CompletableFuture.completedFuture(bytes) : );
   }

   
    String  {
       .name;
   }

   
    String  {
       .hash;
   }

    CompletableFuture<[]> getBlob() {
      CompletableFuture<[]> future = (CompletableFuture).blob.get();
       (future == ) {
         future = .getBlob0();
         .blob =  (future);
      }

       future;
   }

     CompletableFuture<[]> getBlob0();

   
    Asset  {
         .cachedPacket ==  ?  : (Asset).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
             (.hash, .name);
         .cachedPacket =  (packet);
          packet;
      }
   }

      {
       ( == o) {
          ;
      }   (o !=  && .getClass() == o.getClass()) {
            (CommonAsset)o;
          !.name.equals(asset.name) ?  : .hash.equals(asset.hash);
      }  {
          ;
      }
   }

      {
         .name.hashCode();
      result =  * result + .hash.hashCode();
       result;
   }

   
    String  {
        + .name +  + .hash + ;
   }

   
     String  {
       HashUtil.sha256(bytes);
   }
}

com/hypixel/hytale/server/core/asset/common/CommonAssetModule.java

package com.hypixel.hytale.server.core.asset.common;

import com.hypixel.hytale.assetstore.AssetPack;
import com.hypixel.hytale.common.plugin.PluginManifest;
import com.hypixel.hytale.common.util.ArrayUtil;
import com.hypixel.hytale.common.util.FormatUtil;
import com.hypixel.hytale.common.util.PathUtil;
import com.hypixel.hytale.common.util.PatternUtil;
import com.hypixel.hytale.event.IEventDispatcher;
import com.hypixel.hytale.function.supplier.CachedSupplier;
import com.hypixel.hytale.function.supplier.SupplierUtil;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.logger.sentry.SkipSentryException;
import com.hypixel.hytale.math.util.MathUtil;
import com.hypixel.hytale.protocol.Asset;
import com.hypixel.hytale.protocol.ItemWithAllMetadata;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.packets.interface_.Notification;
import com.hypixel.hytale.protocol.packets.interface_.NotificationStyle;
import com.hypixel.hytale.protocol.packets.setup.AssetFinalize;
import com.hypixel.hytale.protocol.packets.setup.AssetInitialize;
import com.hypixel.hytale.protocol.packets.setup.AssetPart;
import com.hypixel.hytale.protocol.packets.setup.RemoveAssets;
import com.hypixel.hytale.protocol.packets.setup.RequestCommonAssetsRebuild;
import com.hypixel.hytale.protocol.packets.setup.WorldLoadProgress;
import com.hypixel.hytale.server.core.HytaleServer;
import com.hypixel.hytale.server.core.Message;
import com.hypixel.hytale.server.core.asset.AssetModule;
import com.hypixel.hytale.server.core.asset.AssetPackRegisterEvent;
import com.hypixel.hytale.server.core.asset.AssetPackUnregisterEvent;
 com.hypixel.hytale.server.core.asset.LoadAssetEvent;
 com.hypixel.hytale.server.core.asset.common.asset.FileCommonAsset;
 com.hypixel.hytale.server.core.asset.common.events.CommonAssetMonitorEvent;
 com.hypixel.hytale.server.core.asset.common.events.SendCommonAssetsEvent;
 com.hypixel.hytale.server.core.asset.monitor.AssetMonitor;
 com.hypixel.hytale.server.core.asset.monitor.AssetMonitorHandler;
 com.hypixel.hytale.server.core.asset.monitor.EventKind;
 com.hypixel.hytale.server.core.io.PacketHandler;
 com.hypixel.hytale.server.core.plugin.JavaPlugin;
 com.hypixel.hytale.server.core.plugin.JavaPluginInit;
 com.hypixel.hytale.server.core.universe.Universe;
 com.hypixel.hytale.server.core.util.NotificationUtil;
 com.hypixel.hytale.server.core.util.io.FileUtil;
 com.hypixel.hytale.sneakythrow.SneakyThrow;
 com.hypixel.hytale.sneakythrow.supplier.ThrowableSupplier;
 it.unimi.dsi.fastutil.booleans.BooleanObjectPair;
 it.unimi.dsi.fastutil.objects.ObjectArrayList;
 java.io.BufferedReader;
 java.io.IOException;
 java.nio.file.FileVisitResult;
 java.nio.file.Files;
 java.nio.file.LinkOption;
 java.nio.file.NoSuchFileException;
 java.nio.file.Path;
 java.nio.file.SimpleFileVisitor;
 java.nio.file.attribute.BasicFileAttributes;
 java.time.Instant;
 java.time.temporal.ChronoUnit;
 java.util.List;
 java.util.Map;
 java.util.Objects;
 java.util.Set;
 java.util.concurrent.CompletableFuture;
 java.util.concurrent.atomic.AtomicInteger;
 java.util.logging.Level;
 java.util.stream.Stream;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;

     {
         PluginManifest.corePlugin(CommonAssetModule.class).depends(AssetModule.class).build();
     CommonAssetModule instance;
      Set<Path> IGNORED_FILES = Set.of(Path.of(), Path.of());
         Instant.parse();
         ;
         ;
         ;
         ;
     CachedSupplier<Asset[]> assets = SupplierUtil.<Asset[]>cache(() -> (Asset[])CommonAssetRegistry.getAllAssets().stream().map(List::getLast).map(CommonAssetRegistry.PackAsset::asset).map(CommonAsset::toPacket).toArray((x$) ->  [x$]));

     CommonAssetModule  {
       instance;
   }

     {
      (init);
      instance = ;
   }

      {
      .getEventRegistry().register(SendCommonAssetsEvent.class, ::onSendCommonAssets);
      .getEventRegistry().register(()-, LoadAssetEvent.class, (event) -> {
         (AssetPack pack : AssetModule.get().getAssetPacks()) {
            .loadCommonAssets(pack, event.getBootStart());
         }

      });
      .getEventRegistry().register(()-, AssetPackRegisterEvent.class, (event) -> .loadCommonAssets(event.getAssetPack(), System.nanoTime()));
      .getEventRegistry().register(AssetPackUnregisterEvent.class, (event) -> .removeCommonAssets(event.getAssetPack()));
   }

      {
      .unregisterAssetMonitor(assetPack);
      List<CommonAssetRegistry.PackAsset> removedAssets =  <CommonAssetRegistry.PackAsset>();
      List<CommonAsset> updatedAssets =  <CommonAsset>();

      (List<CommonAssetRegistry.PackAsset> assets : CommonAssetRegistry.getAllAssets()) {
         (CommonAssetRegistry.PackAsset asset : assets) {
             (asset.pack().equals(assetPack.getName())) {
               BooleanObjectPair<CommonAssetRegistry.PackAsset> removed = CommonAssetRegistry.removeCommonAssetByName(asset.pack(), asset.asset().getName());
                (removed != ) {
                   (removed.firstBoolean()) {
                     updatedAssets.add(((CommonAssetRegistry.PackAsset)removed.second()).asset());
                  }  {
                     removedAssets.add((CommonAssetRegistry.PackAsset)removed.second());
                  }
               }

               .assets.invalidate();
            }
         }
      }

      .sendRemoveAssets(removedAssets, );
      .sendAssets(updatedAssets, );
      Universe.get().broadcastPacketNoCache( ());
   }

      {
         pack.getRoot();
      HytaleLogger.getLogger().at(Level.INFO).log(, assetPath);
         System.nanoTime();
       (.readCommonAssetsIndexHashes(pack)) {
            CommonAssetRegistry.getDuplicateAssetCount();
          (duplicateAssetCount > ) {
            .getLogger().at(Level.WARNING).log(, duplicateAssetCount);
         }

         HytaleLogger.getLogger().at(Level.INFO).log(, FormatUtil.nanosToString(System.nanoTime() - bootTime), FormatUtil.nanosToString(System.nanoTime() - start));
      }  {
            pack.getRoot().resolve();
            AssetModule.get().getAssetMonitor();
          (assetMonitor !=  && !pack.isImmutable() && Files.isDirectory(commonPath,  [])) {
            assetMonitor.monitorDirectoryFiles(commonPath,  (pack, commonPath));
         }

         .readCommonAssetsIndexCache(pack);

          {
            .walkFileTree(pack);
         }  (IOException e) {
             SneakyThrow.sneakyThrow(e);
         }

            CommonAssetRegistry.getDuplicateAssetCount();
          (duplicateAssetCount > ) {
            .getLogger().at(Level.WARNING).log(, duplicateAssetCount);
         }

         HytaleLogger.getLogger().at(Level.INFO).log(, FormatUtil.nanosToString(System.nanoTime() - bootTime), FormatUtil.nanosToString(System.nanoTime() - start));
         Universe.get().broadcastPacketNoCache( ());
      }
   }

    <T  >   {
      .addCommonAsset(pack, asset, );
   }

    <T  >   {
      CommonAssetRegistry.   CommonAssetRegistry.addCommonAsset(pack, asset);
      CommonAssetRegistry.   result.getNewPackAsset();
      CommonAssetRegistry.   result.getPreviousNameAsset();
       (oldAsset !=  && oldAsset.asset().getHash().equals(newAsset.asset().getHash())) {
          (log) {
            .getLogger().at(Level.INFO).log(, asset.getName());
         }

      }  {
          (oldAsset == ) {
             (log) {
               .getLogger().at(Level.INFO).log(, newAsset);
            }
         }   (log) {
            .getLogger().at(Level.INFO).log(, newAsset, oldAsset.asset().getHash());
         }

            oldAsset ==  ?  : ;
            oldAsset ==  ?  : ;
            oldAsset ==  ?  : ;
            Message.translation(messageId).color(messageColor).param(, );
            newAsset.pack();
         NotificationUtil.sendNotificationToUniverse(var10000, Message.raw(var10001 +  + newAsset.asset().getName()), iconPath, NotificationStyle.Success);
          (result.getActiveAsset().equals(newAsset)) {
            .assets.invalidate();
            BlockyAnimationCache.invalidate(newAsset.asset().getName());
             (Universe.get().getPlayerCount() > ) {
               .sendAsset(newAsset.asset(), );
            }

         }
      }
   }

   
    Asset[] getRequiredAssets() {
       .assets.get();
   }

      {
         pack.getRoot();
         assetPath.resolve();
         assetPath.resolve();
       (Files.isRegularFile(assetHashFile,  [])) {
            System.nanoTime();
            ;

          {
               Files.newBufferedReader(assetHashFile);

             {
                  ;
                  ;

               () {
                     reader.readLine();
                   (line == ) {
                     ;
                  }

                   (line.startsWith()) {
                     version = Integer.parseInt(line.substring(.length()));
                     .getLogger().at(Level.FINEST).log(, version, i, line);
                      (version > ) {
                          (String.format(, version, version, ));
                     }
                  }  {
                     String[] split = line.split(, );
                      (split.length != ) {
                        .getLogger().at(Level.WARNING).log(, i, line);
                     }  {
                           split[];
                         (hash.length() !=  && !CommonAsset.HASH_PATTERN.matcher(hash).matches()) {
                           .getLogger().at(Level.WARNING).log(, i, line);
                        }  {
                              split[];
                           .addCommonAsset(pack.getName(),  (commonPath.resolve(name), name, hash, ([])), );
                           .getLogger().at(Level.FINEST).log(, i, name);
                           ++loadedAssetCount;
                        }
                     }
                  }

                  ++i;
               }
            }  (Throwable var16) {
                (reader != ) {
                   {
                     reader.close();
                  }  (Throwable var15) {
                     var16.addSuppressed(var15);
                  }
               }

                var16;
            }

             (reader != ) {
               reader.close();
            }
         }  (IOException e) {
            ((HytaleLogger.Api).getLogger().at(Level.WARNING).withCause(e)).log();
             ;
         }

            System.nanoTime();
            loadHashesEnd - loadHashesStart;
         .getLogger().at(Level.INFO).log(, FormatUtil.nanosToString(loadHashesDiff), loadedAssetCount);
          ;
      }  {
          ;
      }
   }

      {
         pack.getRoot();
         assetPath.resolve();
         assetPath.resolve();
       (Files.isRegularFile(assetCacheFile,  [])) {
            System.nanoTime();
             ();
         List<CompletableFuture<Void>> futures =  <CompletableFuture<Void>>();

          {
               Files.newBufferedReader(assetCacheFile);

             {
                  ;
                  ;

               () {
                     reader.readLine();
                   (line == ) {
                     ;
                  }

                   (line.startsWith()) {
                     version = Integer.parseInt(line.substring(.length()));
                     .getLogger().at(Level.FINEST).log(, version, i, line);
                      (version > ) {
                          (String.format(, version, version, ));
                     }
                  }  {
                        line.indexOf();
                        line.indexOf(, indexOne + );
                      (indexTwo < ) {
                        .getLogger().at(Level.WARNING).log(, i, line);
                     }  {
                           line.substring(, indexOne);
                         (hash.length() !=  && !CommonAsset.HASH_PATTERN.matcher(hash).matches()) {
                           .getLogger().at(Level.WARNING).log(, i, line);
                        }  {
                              Long.parseLong(line, indexOne + , indexTwo, );
                           Instant timestamp;
                            (version > ) {
                              timestamp = Instant.ofEpochSecond(timestampLong);
                           }  {
                                 timestampLong / ;
                              timestamp = TICK_TIMESTAMP_ORIGIN.plusMillis(timestampMillis);
                           }

                              line.substring(indexTwo + );
                              commonPath.resolve(name);
                           futures.add(CompletableFuture.supplyAsync(() -> {
                              BasicFileAttributes attributes;
                               {
                                 attributes = Files.readAttributes(file, BasicFileAttributes.class);
                              }  (IOException var10) {
                                  ;
                              }

                               (!attributes.isRegularFile()) {
                                  ;
                              }  {
                                    attributes.lastModifiedTime().toInstant().truncatedTo(ChronoUnit.SECONDS);
                                  (timestamp.equals(lastModified)) {
                                    .addCommonAsset(pack.getName(),  (file, name, hash, ([])), );
                                    .getLogger().at(Level.FINEST).log(, i, name);
                                    loadedAssetCount.getAndIncrement();
                                 }  {
                                    .getLogger().at(Level.FINEST).log(, i, name, timestamp, lastModified);
                                 }

                                  ;
                              }
                           }));
                        }
                     }
                  }

                  ++i;
               }
            }  (Throwable var23) {
                (reader != ) {
                   {
                     reader.close();
                  }  (Throwable var22) {
                     var23.addSuppressed(var22);
                  }
               }

                var23;
            }

             (reader != ) {
               reader.close();
            }
         }  (IOException e) {
            ((HytaleLogger.Api).getLogger().at(Level.WARNING).withCause(e)).log();
         }

         CompletableFuture.allOf((CompletableFuture[])futures.toArray((x$) ->  [x$])).join();
            System.nanoTime();
            loadCacheEnd - loadCacheStart;
         .getLogger().at(Level.INFO).log(, FormatUtil.nanosToString(loadCacheDiff), loadedAssetCount.get());
      }
   }

       IOException {
         pack.getRoot();
         assetPath.resolve().toAbsolutePath();
       (Files.exists(commonPath,  [])) {
             commonPath.toString().length() + ;
            System.nanoTime();
          ObjectArrayList<CompletableFuture<Void>> futures =  <CompletableFuture<Void>>();
         Files.walkFileTree(commonPath, FileUtil.DEFAULT_WALK_TREE_OPTIONS_SET, ,  <Path>() {
            
             FileVisitResult   IOException {
                (!attrs.isRegularFile()) {
                   FileVisitResult.CONTINUE;
               }  {
                     path.getFileName();
                   (CommonAssetModule.IGNORED_FILES.contains(fileName)) {
                        PatternUtil.replaceBackslashWithForwardSlash(path.toString().substring(commonPathSubStringIndex));
                     CommonAssetModule..getLogger().at(Level.FINEST).log(, name);
                      FileVisitResult.CONTINUE;
                  }   (fileName.toString().endsWith()) {
                     Files.deleteIfExists(path);
                      FileVisitResult.CONTINUE;
                  }  {
                        PatternUtil.replaceBackslashWithForwardSlash(path.toString().substring(commonPathSubStringIndex));
                      (CommonAssetRegistry.hasCommonAsset(pack, name)) {
                         FileVisitResult.CONTINUE;
                     }  {
                        CommonAssetModule..getLogger().at(Level.FINER).log(, name);
                        futures.add(CompletableFuture.supplyAsync(SneakyThrow.sneakySupplier((ThrowableSupplier)(() -> Files.readAllBytes(path)))).thenAcceptAsync((bytes) -> {
                               (path, name, bytes);
                           CommonAssetModule..addCommonAsset(pack.getName(), asset, );
                           CommonAssetModule..getLogger().at(Level.FINER).log(, asset);
                        }).exceptionally((throwable) -> {
                           ((HytaleLogger.Api)CommonAssetModule..getLogger().at(Level.FINE).withCause(throwable)).log(, name);
                            SneakyThrow.sneakyThrow(throwable);
                        }));
                         FileVisitResult.CONTINUE;
                     }
                  }
               }
            }
         });
         CompletableFuture.allOf((CompletableFuture[])futures.toArray((x$) ->  [x$])).join();
         .assets.invalidate();
            System.nanoTime();
            walkFileTreeEnd - walkFileTreeStart;
         .getLogger().at(Level.INFO).log(, FormatUtil.nanosToString(walkFileTreeDiff), futures.size());
      }
   }

      {
         AssetModule.get().getAssetMonitor();
       (assetMonitor != ) {
         assetMonitor.removeMonitorDirectoryFiles(pack.getRoot().resolve(), pack);
      }

   }

      {
      .getLogger().at(Level.FINEST).log(, file);
      addedOrUpdatedAssets.add(CompletableFuture.supplyAsync(SneakyThrow.sneakySupplier((ThrowableSupplier)(() -> Files.readAllBytes(file)))).thenAcceptAsync((bytes) -> .addCommonAsset(pack,  (file, name, bytes))).exceptionally((throwable) -> {
          (throwable  NoSuchFileException) {
            throwable =  (throwable);
         }

         ((HytaleLogger.Api).getLogger().at(Level.SEVERE).withCause(throwable)).log(, file);
          ;
      }));
   }

      {
      .sendAssetsToPlayer(event.getPacketHandler(), event.getRequestedAssets(), );
   }

      {
      List<CommonAsset> toSend =  <CommonAsset>();
       (requested != ) {
         (Asset toSendAsset : requested) {
               CommonAssetRegistry.getByHash(toSendAsset.hash);
            Objects.requireNonNull(asset, toSendAsset.hash);
            toSend.add(asset);
         }
      }  {
         (List<CommonAssetRegistry.PackAsset> asset : CommonAssetRegistry.getAllAssets()) {
            toSend.add(((CommonAssetRegistry.PackAsset)asset.getLast()).asset());
         }
      }

      .getLogger().at(Level.FINE).log(, packetHandler.getIdentifier(), toSend.size());
      .sendAssetsToPlayer(packetHandler, toSend, forceRebuild);
   }

      {
      (   ; i < toSend.size(); ++i) {
            (CommonAsset)toSend.get(i);
         [] allBytes = ([])thisAsset.getBlob().join();
         [][] parts = ArrayUtil.split(allBytes, );
         Packet[] packets =  [ + parts.length];
         packets[] =  (thisAsset.toPacket(), allBytes.length);

         (   ; partIndex < parts.length; ++partIndex) {
            packets[ + partIndex] =  (parts[partIndex]);
         }

         packets[packets.length - ] =  ();
         Universe.get().broadcastPacket(packets);
      }

       (!toSend.isEmpty() && forceRebuild) {
         Universe.get().broadcastPacketNoCache( ());
      }

   }

      {
      (   ; i < toSend.size(); ++i) {
            MathUtil.getPercentageOf(i, toSend.size());
            (CommonAsset)toSend.get(i);
         [] allBytes = ([])thisAsset.getBlob().join();
         [][] parts = ArrayUtil.split(allBytes, );
         Packet[] packets =  [ + parts.length * ];
         packets[] =  (thisAsset.toPacket(), allBytes.length);

         (   ; partIndex < parts.length; ++partIndex) {
            packets[ + partIndex * ] =  ( + thisAsset.getName(), thisPercent,  * partIndex / parts.length);
            packets[ + partIndex *  + ] =  (parts[partIndex]);
         }

         packets[packets.length - ] =  ();
         packetHandler.write(packets);
      }

       (!toSend.isEmpty() && forceRebuild) {
         packetHandler.writeNoCache( ());
      }

   }

      {
      asset.getBlob().whenComplete((allBytes, throwable) -> {
          (throwable != ) {
            .getLogger().at(Level.WARNING).log(, asset.getName(), asset.getHash());
         }  {
            [][] parts = ArrayUtil.split(allBytes, );
            Packet[] packets =  [ + (forceRebuild ?  : ) + parts.length];
            packets[] =  (asset.toPacket(), allBytes.length);

            (   ; i < parts.length; ++i) {
               packets[ + i] =  (parts[i]);
            }

            packets[ + parts.length] =  ();
             (forceRebuild) {
               packets[ + parts.length] =  ();
            }

            Universe.get().broadcastPacket(packets);
         }

      });
   }

      {
         assets.size();
      Asset[] asset_ =  [size];
         ;
         ;
         ;
         Message.translation().param(, ).color();
         ;
          + (forceRebuild ?  : ) + (assets.size() <  ? assets.size() : );
      Packet[] packets =  [packetsCount];
         ;

      (CommonAssetRegistry.PackAsset asset : assets) {
         asset_[i++] = asset.asset().toPacket();
      }

       (assets.size() < ) {
         i = ;

         (CommonAssetRegistry.PackAsset asset : assets) {
               asset.pack();
               Message.raw(var10000 +  + asset.asset().getName()).color();
            packets[i++] =  (message.getFormattedMessage(), assetName.getFormattedMessage(), , (ItemWithAllMetadata), NotificationStyle.Default);
         }

         packets[i++] =  (asset_);
          (forceRebuild) {
            packets[i++] =  ();
         }
      }  {
            Message.translation().param(, assets.size());
         packets[] =  (message.getFormattedMessage(), secondaryMessage.getFormattedMessage(), , (ItemWithAllMetadata), NotificationStyle.Default);
         packets[] =  (asset_);
          (forceRebuild) {
            packets[] =  ();
         }
      }

      Universe.get().broadcastPacket(packets);
   }

        {
        AssetPack pack;
        Path commonPath;

        {
         .pack = pack;
         .commonPath = commonPath;
      }

       Object  {
          .pack;
      }

         {
          !CommonAssetModule.IGNORED_FILES.contains(path.getFileName());
      }

         {
         List<Path> createdOrModifiedFilesToLoad =  <Path>();
         List<Path> removedFilesToUnload =  <Path>();
         List<Path> createdOrModifiedDirectories =  <Path>();
         List<Path> removedFilesAndDirectories =  <Path>();

         (Map.Entry<Path, EventKind> entry : map.entrySet()) {
               (Path)entry.getKey();
               (EventKind)entry.getValue();
             (eventKind) {
                ENTRY_CREATE:
                   (Files.isDirectory(path,  [])) {
                     CommonAssetModule..getLogger().at(Level.INFO).log(, path);

                      {
                        Stream<Path> stream = Files.walk(path, FileUtil.DEFAULT_WALK_TREE_OPTIONS_ARRAY);

                         {
                           stream.forEach((child) -> {
                              BasicFileAttributes attributes;
                               {
                                 attributes = Files.readAttributes(child, BasicFileAttributes.class);
                              }  (IOException var6) {
                                 ;
                              }

                               (attributes.isDirectory()) {
                                 createdOrModifiedDirectories.add(path);
                              }   (attributes.isRegularFile()) {
                                 createdOrModifiedFilesToLoad.add(child);
                              }

                           });
                        }  (Throwable var16) {
                            (stream != ) {
                               {
                                 stream.close();
                              }  (Throwable var15) {
                                 var16.addSuppressed(var15);
                              }
                           }

                            var16;
                        }

                         (stream != ) {
                           stream.close();
                        }
                     }  (IOException e) {
                        ((HytaleLogger.Api)CommonAssetModule..getLogger().at(Level.SEVERE).withCause(e)).log(, path);
                     }
                  }  {
                     CommonAssetModule..getLogger().at(Level.INFO).log(, path);
                     createdOrModifiedFilesToLoad.add(path);
                  }
                  ;
                ENTRY_DELETE:
                  CommonAssetModule..getLogger().at(Level.INFO).log(, path);
                  removedFilesAndDirectories.add(path);
                     PathUtil.relativize(.commonPath, path);
                     PatternUtil.replaceBackslashWithForwardSlash(relative.toString());

                  (CommonAsset asset : CommonAssetRegistry.getCommonAssetsStartingWith(.pack.getName(), name)) {
                     removedFilesToUnload.add(.commonPath.resolve(asset.getName()));
                  }
                  ;
                ENTRY_MODIFY:
                   (Files.isDirectory(path,  [])) {
                     CommonAssetModule..getLogger().at(Level.INFO).log(, path);
                     createdOrModifiedDirectories.add(path);
                  }  {
                     CommonAssetModule..getLogger().at(Level.INFO).log(, path);
                     createdOrModifiedFilesToLoad.add(path);
                  }
                  ;
               :
                    ( + String.valueOf(eventKind));
            }
         }

          (!removedFilesAndDirectories.isEmpty() || !createdOrModifiedFilesToLoad.isEmpty() || !createdOrModifiedDirectories.isEmpty()) {
            IEventDispatcher<CommonAssetMonitorEvent, CommonAssetMonitorEvent> dispatchFor = HytaleServer.get().getEventBus().dispatchFor(CommonAssetMonitorEvent.class);
             (dispatchFor.hasListener()) {
               dispatchFor.dispatch( (.pack.getName(), createdOrModifiedFilesToLoad, removedFilesToUnload, createdOrModifiedDirectories, removedFilesAndDirectories));
            }
         }

         List<CompletableFuture<Void>> addedOrUpdatedAssets =  <CompletableFuture<Void>>();
         List<CommonAssetRegistry.PackAsset> removedAssets =  <CommonAssetRegistry.PackAsset>();
         List<CommonAsset> updatedAssets =  <CommonAsset>();
          (!removedFilesToUnload.isEmpty()) {
            CommonAssetModule..getLogger().at(Level.INFO).log(, removedFilesToUnload);

            (Path path : removedFilesToUnload) {
                  PathUtil.relativize(.commonPath, path);
                  PatternUtil.replaceBackslashWithForwardSlash(relativePath.toString());
               BooleanObjectPair<CommonAssetRegistry.PackAsset> removed = CommonAssetRegistry.removeCommonAssetByName(.pack.getName(), name);
                (removed != ) {
                   (removed.firstBoolean()) {
                     updatedAssets.add(((CommonAssetRegistry.PackAsset)removed.second()).asset());
                  }  {
                     removedAssets.add((CommonAssetRegistry.PackAsset)removed.second());
                  }
               }

               CommonAssetModule..assets.invalidate();
            }

            CommonAssetModule..sendRemoveAssets(removedAssets, );
            CommonAssetModule..sendAssets(updatedAssets, );
         }

          (!createdOrModifiedFilesToLoad.isEmpty()) {
            CommonAssetModule..getLogger().at(Level.INFO).log(, createdOrModifiedFilesToLoad);

            (Path path : createdOrModifiedFilesToLoad) {
                  PathUtil.relativize(.commonPath, path);
                  PatternUtil.replaceBackslashWithForwardSlash(relative.toString());
               CommonAssetModule..reloadAsset(addedOrUpdatedAssets, .pack.getName(), path, name);
            }

            CompletableFuture.allOf((CompletableFuture[])addedOrUpdatedAssets.toArray((x$) ->  [x$])).thenAccept((v) -> Universe.get().broadcastPacketNoCache( ()));
         }  {
            Universe.get().broadcastPacketNoCache( ());
         }

      }
   }
}

com/hypixel/hytale/server/core/asset/common/CommonAssetRegistry.java

package com.hypixel.hytale.server.core.asset.common;

import com.hypixel.hytale.assetstore.AssetPack;
import com.hypixel.hytale.common.util.PatternUtil;
import it.unimi.dsi.fastutil.booleans.BooleanObjectPair;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicInteger;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class CommonAssetRegistry {
   private static final Map<String, List<PackAsset>> assetByNameMap = new ConcurrentHashMap();
   private static final Map<String, List<PackAsset>> assetByHashMap = new ConcurrentHashMap();
   private static final AtomicInteger duplicateAssetCount = new AtomicInteger();
   private static final Collection<List<PackAsset>> unmodifiableAssetByNameMapValues;

     {
   }

       {
       duplicateAssetCount.get();
   }

   
     Map<String, List<PackAsset>>  {
      Map<String, List<PackAsset>> duplicates =  <String, List<PackAsset>>();

      (Map.Entry<String, List<PackAsset>> entry : assetByHashMap.entrySet()) {
          (((List)entry.getValue()).size() > ) {
            duplicates.put((String)entry.getKey(),  ((Collection)entry.getValue()));
         }
      }

       duplicates;
   }

   
     Collection<List<PackAsset>>  {
       unmodifiableAssetByNameMapValues;
   }

       {
      assetByNameMap.clear();
      assetByHashMap.clear();
   }

   
     AddCommonAssetResult  {
          ();
      result.newPackAsset =  (pack, asset);
      List<PackAsset> list = (List)assetByNameMap.computeIfAbsent(asset.getName(), (v) ->  ());
         ;
         ;

      (   ; i < list.size(); ++i) {
            (PackAsset)list.get(i);
          (e.pack().equals(pack)) {
            result.previousNameAsset = e;
             (i == list.size() - ) {
               ((List)assetByHashMap.get(e.asset.getHash())).remove(e);
               assetByHashMap.compute(e.asset.getHash(), (k, v) -> v !=  && !v.isEmpty() ? v : );
            }  {
               addHash = ;
            }

            list.set(i, result.newPackAsset);
            added = ;
            ;
         }
      }

       (!added) {
          (!list.isEmpty()) {
               (PackAsset)list.getLast();
            ((List)assetByHashMap.get(e.asset.getHash())).remove(e);
            assetByHashMap.compute(e.asset.getHash(), (k, v) -> v !=  && !v.isEmpty() ? v : );
            result.previousNameAsset = e;
         }

         list.add(result.newPackAsset);
      }

       (addHash) {
         List<PackAsset> commonAssets = (List)assetByHashMap.computeIfAbsent(asset.getHash(), (k) ->  ());
          (!commonAssets.isEmpty()) {
            result.previousHashAssets = (PackAsset[])commonAssets.toArray((x$) ->  [x$]);
         }

         commonAssets.add(result.newPackAsset);
      }

       (result.previousHashAssets !=  || result.previousNameAsset != ) {
         result.duplicateAssetId = duplicateAssetCount.getAndIncrement();
      }

      result.activeAsset = (PackAsset)list.getLast();
       result;
   }

   
     BooleanObjectPair<PackAsset>  {
      name = PatternUtil.replaceBackslashWithForwardSlash(name);
      List<PackAsset> oldAssets = (List)assetByNameMap.get(name);
       (oldAssets == ) {
          ;
      }  {
            (PackAsset)oldAssets.getLast();
         oldAssets.removeIf((v) -> v.pack().equals(pack));
         assetByNameMap.compute(name, (k, v) -> v !=  && !v.isEmpty() ? v : );
          (oldAssets.isEmpty()) {
            removeCommonAssetByHash0(previousCurrent);
             BooleanObjectPair.<PackAsset>of(, previousCurrent);
         }  {
               (PackAsset)oldAssets.getLast();
             (newCurrent.equals(previousCurrent)) {
                ;
            }  {
               removeCommonAssetByHash0(previousCurrent);
               ((List)assetByHashMap.computeIfAbsent(newCurrent.asset.getHash(), (v) ->  ())).add(newCurrent);
                BooleanObjectPair.<PackAsset>of(, newCurrent);
            }
         }
      }
   }

   
     List<CommonAsset>  {
      List<CommonAsset> oldAssets =  <CommonAsset>();

      (List<PackAsset> assets : assetByNameMap.values()) {
         (PackAsset asset : assets) {
             (asset.asset().getName().startsWith(name) && asset.pack().equals(pack)) {
               oldAssets.add(asset.asset());
            }
         }
      }

       oldAssets;
   }

       {
       assetByNameMap.containsKey(name);
   }

       {
      List<PackAsset> packAssets = (List)assetByNameMap.get(name);
       (packAssets != ) {
         (PackAsset packAsset : packAssets) {
             (packAsset.pack.equals(pack.getName())) {
                ;
            }
         }
      }

       ;
   }

   
     CommonAsset  {
      name = PatternUtil.replaceBackslashWithForwardSlash(name);
      List<PackAsset> asset = (List)assetByNameMap.get(name);
       asset ==  ?  : ((PackAsset)asset.getLast()).asset();
   }

   
     CommonAsset  {
      List<PackAsset> assets = (List)assetByHashMap.get(hash.toLowerCase());
       assets !=  && !assets.isEmpty() ? ((PackAsset)assets.getFirst()).asset() : ;
   }

       {
      List<PackAsset> commonAssets = (List)assetByHashMap.get(oldAsset.asset().getHash());
       (commonAssets !=  && commonAssets.remove(oldAsset) && commonAssets.isEmpty()) {
         assetByHashMap.compute(oldAsset.asset().getHash(), (key, assets) -> assets !=  && !assets.isEmpty() ? assets : );
      }

   }

    {
      unmodifiableAssetByNameMapValues = Collections.unmodifiableCollection(assetByNameMap.values());
   }

       {
       PackAsset newPackAsset;
       PackAsset previousNameAsset;
       PackAsset activeAsset;
       PackAsset[] previousHashAssets;
        duplicateAssetId;

        {
      }

       PackAsset  {
          .newPackAsset;
      }

       PackAsset  {
          .previousNameAsset;
      }

       PackAsset  {
          .activeAsset;
      }

       PackAsset[] getPreviousHashAssets() {
          .previousHashAssets;
      }

         {
          .duplicateAssetId;
      }

      
       String  {
            String.valueOf(.previousNameAsset);
           + var10000 +  + Arrays.toString(.previousHashAssets) +  + .duplicateAssetId + ;
      }
   }

       {
         {
          ( == o) {
             ;
         }   (o !=  && .getClass() == o.getClass()) {
               (PackAsset)o;
             !.pack.equals(packAsset.pack) ?  : .asset.equals(packAsset.asset);
         }  {
             ;
         }
      }

      
       String  {
            .pack;
           + var10000 +  + String.valueOf(.asset) + ;
      }
   }
}

com/hypixel/hytale/server/core/asset/common/CommonAssetValidator.java

package com.hypixel.hytale.server.core.asset.common;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import com.hypixel.hytale.codec.validation.validator.ArrayValidator;
import com.hypixel.hytale.common.util.PatternUtil;
import java.util.Arrays;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class CommonAssetValidator implements Validator<String> {
   public static final CommonAssetValidator TEXTURE_ITEM = new CommonAssetValidator("png", new String[]{"Blocks", "BlockTextures", "Items", "NPC", "Resources", "VFX"});
   public static final CommonAssetValidator TEXTURE_CHARACTER = new CommonAssetValidator("png", new String[]{, , , });
          (,  []{, , , , , , });
          (,  []{});
          (,  []{});
          (,  []{});
          (, ,  []{});
          (,  []{});
          (,  []{, });
          (,  []{});
          (,  []{});
          (,  []{});
          (,  []{, });
          (,  []{});
      ArrayValidator<String> UI_RETICLE_PARTS_ARRAY;
      CommonAssetValidator UI_SCREEN_EFFECT;
      CommonAssetValidator UI_CRAFTING_DIAGRAM;
      CommonAssetValidator MODEL_ITEM;
      CommonAssetValidator MODEL_CHARACTER;
      CommonAssetValidator MODEL_CHARACTER_ATTACHMENT;
      CommonAssetValidator PREFAB_LIST;
      CommonAssetValidator BLOCK_LIST;
      CommonAssetValidator ANIMATION_ITEM_CHARACTER;
      CommonAssetValidator ANIMATION_ITEM_BLOCK;
      CommonAssetValidator ANIMATION_CHARACTER;
      CommonAssetValidator MUSIC;
      CommonAssetValidator SOUNDS;
   
     String[] requiredRoots;
   
     String requiredExtension;
      isUIAsset;

     {
       (requiredRoots != ) {
         (   ; i < requiredRoots.length; ++i) {
               requiredRoots[i];
             (!req.endsWith()) {
               requiredRoots[i] = req + ;
            }
         }
      }

      .requiredRoots = requiredRoots;
      .requiredExtension = requiredExtension;
      .isUIAsset = isUIAsset;
   }

     {
      (requiredExtension, , requiredRoots);
   }

     {
      .requiredRoots = ;
      .requiredExtension = ;
      .isUIAsset = ;
   }

      {
       (asset != ) {
          (.requiredRoots != ) {
               ;

            (String root : .requiredRoots) {
                (asset.startsWith(root)) {
                  valid = ;
                  ;
               }
            }

             (!valid) {
               results.fail( + asset +  + Arrays.toString(.requiredRoots));
            }
         }

          (.requiredExtension !=  && !asset.endsWith(.requiredExtension)) {
            results.fail( + asset +  + .requiredExtension);
         }

         asset = PatternUtil.replaceBackslashWithForwardSlash(asset);
          (!CommonAssetRegistry.hasCommonAsset(asset)) {
             (.isUIAsset && asset.endsWith()) {
                  asset.substring(, asset.lastIndexOf()) + ;
                (!CommonAssetRegistry.hasCommonAsset(scaled2XVersionFilename)) {
                  results.fail( + asset + );
               }
            }  {
               results.fail( + asset + );
            }
         }

      }
   }

      {
      ((StringSchema)target).setHytaleCommonAsset( .CommonAsset(.requiredExtension, .isUIAsset, .requiredRoots));
   }

    {
      UI_RETICLE_PARTS_ARRAY =  <String>(UI_RETICLE_PART);
      UI_SCREEN_EFFECT =  (,  []{});
      UI_CRAFTING_DIAGRAM =  (,  []{});
      MODEL_ITEM =  (,  []{, , , , , });
      MODEL_CHARACTER =  (,  []{, , , });
      MODEL_CHARACTER_ATTACHMENT =  (,  []{, , , , , , });
      PREFAB_LIST =  (,  []{});
      BLOCK_LIST =  (,  []{});
      ANIMATION_ITEM_CHARACTER =  (,  []{, });
      ANIMATION_ITEM_BLOCK =  (,  []{, , , , , });
      ANIMATION_CHARACTER =  (,  []{, , , , });
      MUSIC =  (,  []{});
      SOUNDS =  (,  []{});
   }
}

com/hypixel/hytale/server/core/asset/common/HytaleFileTypes.java

package com.hypixel.hytale.server.core.asset.common;

public class HytaleFileTypes {
   static final String ANIMATION_FILE_TYPE = "blockyanim";
   static final String PNG_FILE_TYPE = "png";
   static final String SVG_FILE_TYPE = "svg";
   static final String MODEL_FILE_TYPE = "blockymodel";
   static final String OGG_FILE_TYPE = "ogg";
   static final String JSON_FILE_TYPE = "json";

   public HytaleFileTypes() {
   }
}

com/hypixel/hytale/server/core/asset/common/OggVorbisInfoCache.java

package com.hypixel.hytale.server.core.asset.common;

import com.hypixel.hytale.common.util.CompletableFutureUtil;
import com.hypixel.hytale.logger.HytaleLogger;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class OggVorbisInfoCache {
   public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   private static final Map<String, OggVorbisInfo> vorbisFiles = new ConcurrentHashMap();

   public OggVorbisInfoCache() {
   }

   @Nonnull
   public static CompletableFuture<OggVorbisInfo> get(String name) {
      OggVorbisInfo info = (OggVorbisInfo)vorbisFiles.get(name);
      if (info != null) {
         return CompletableFuture.completedFuture(info);
      } else {
         CommonAsset asset = CommonAssetRegistry.getByName(name);
          asset ==  ? CompletableFuture.completedFuture((Object)) : get0(asset);
      }
   }

   
     CompletableFuture<OggVorbisInfo>  {
         (OggVorbisInfo)vorbisFiles.get(asset.getName());
       info !=  ? CompletableFuture.completedFuture(info) : get0(asset);
   }

   
     OggVorbisInfo  {
         (OggVorbisInfo)vorbisFiles.get(name);
       (info != ) {
          info;
      }  {
            CommonAssetRegistry.getByName(name);
          asset ==  ?  : (OggVorbisInfo)get0(asset).join();
      }
   }

     OggVorbisInfo  {
         (OggVorbisInfo)vorbisFiles.get(asset.getName());
       info !=  ? info : (OggVorbisInfo)get0(asset).join();
   }

   
     CompletableFuture<OggVorbisInfo>  {
         asset.getName();
       CompletableFutureUtil.<OggVorbisInfo>_catch(asset.getBlob().thenApply((bytes) -> {
            Unpooled.wrappedBuffer(bytes);

         OggVorbisInfo var21;
          {
               b.readableBytes();
               -;
               ;

            (   len - ; i <= end; ++i) {
               i = b.indexOf(i, len - , ());
                (i == -) {
                  ;
               }

                (b.getByte(i + ) ==  && b.getByte(i + ) ==  && b.getByte(i + ) ==  && b.getByte(i + ) ==  && b.getByte(i + ) ==  && b.getByte(i + ) == ) {
                  id = i;
                  ;
               }
            }

             (id <  || id +  > len) {
                 ();
            }

            i = b.getUnsignedByte(id + );
               b.getIntLE(id + );
               -;
             (sampleRate > ) {
               (   Math.max(, len - ); i >= ; --i) {
                  i = b.indexOf(i, , ());
                   (i == -) {
                     ;
                  }

                   (b.getByte(i + ) ==  && b.getByte(i + ) ==  && b.getByte(i + ) == ) {
                        b.getUnsignedByte(i + );
                      ((headerType & ) != ) {
                           b.getLongLE(i + );
                         (granule >= ) {
                           duration = ()granule / ()sampleRate;
                        }
                        ;
                     }
                  }
               }
            }

                (i, sampleRate, duration);
            vorbisFiles.put(name, info);
            var21 = info;
         }  {
            b.release();
         }

          var21;
      }));
   }

       {
      vorbisFiles.remove(name);
   }

       {
         channels;
         sampleRate;
         duration;

      OggVorbisInfo( channels,  sampleRate,  duration) {
         .channels = channels;
         .sampleRate = sampleRate;
         .duration = duration;
      }

      
       String  {
           + .channels +  + .sampleRate +  + .duration + ;
      }
   }
}

com/hypixel/hytale/server/core/asset/common/PlayerCommonAssets.java

package com.hypixel.hytale.server.core.asset.common;

import com.hypixel.hytale.protocol.Asset;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class PlayerCommonAssets {
   @Nonnull
   private final Map<String, String> assetMissing = new Object2ObjectOpenHashMap<String, String>();
   @Nonnull
   private final Map<String, String> assetSent;

   public PlayerCommonAssets(@Nonnull Asset[] requiredAssets) {
      for(Asset requiredAsset : requiredAssets) {
         this.assetMissing.put(requiredAsset.hash, requiredAsset.name);
      }

      this.assetSent = new Object2ObjectOpenHashMap<String, String>();
   }

   public void sent(@Nullable Asset[] hashes) {
      Set<String> set = new HashSet();
      if (hashes != null) {
         for(Asset hash : hashes) {
            set.add(hash.hash);
         }
      }

      Iterator<String> iterator = this.assetMissing.keySet().iterator();

      (iterator.hasNext()) {
            (String)iterator.next();
          (set.contains(hash)) {
            iterator.remove();
            set.remove(hash);
         }
      }

       (!set.isEmpty()) {
           ( + String.valueOf(set));
      }  {
         .assetSent.putAll(.assetMissing);
         .assetMissing.clear();
      }
   }
}

com/hypixel/hytale/server/core/asset/common/ResourceCommonAsset.java

package com.hypixel.hytale.server.core.asset.common;

import com.hypixel.hytale.sneakythrow.SneakyThrow;
import java.io.IOException;
import java.io.InputStream;
import java.util.concurrent.CompletableFuture;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ResourceCommonAsset extends CommonAsset {
   private final Class<?> clazz;
   private final String path;

   public ResourceCommonAsset(Class<?> clazz, String path, @Nonnull String name, byte[] bytes) {
      super(name, bytes);
      this.clazz = clazz;
      this.path = path;
   }

   public ResourceCommonAsset(Class<?> clazz, String path, @Nonnull String name, @Nonnull String hash, byte[] bytes) {
      super(name, hash, bytes);
      this.clazz = clazz;
      this.path = path;
   }

   public String getPath() {
      return this.path;
   }

   @Nonnull
   public CompletableFuture<byte[]> getBlob0() {
      try {
         InputStream   .clazz.getResourceAsStream(.path);

         CompletableFuture var2;
          {
            var2 = CompletableFuture.completedFuture(stream.readAllBytes());
         }  (Throwable var5) {
             (stream != ) {
                {
                  stream.close();
               }  (Throwable var4) {
                  var5.addSuppressed(var4);
               }
            }

             var5;
         }

          (stream != ) {
            stream.close();
         }

          var2;
      }  (IOException e) {
          CompletableFuture.failedFuture(e);
      }
   }

   
    String  {
        + .toString() + ;
   }

   
     ResourceCommonAsset  {
       {
            clazz.getResourceAsStream(path);

         Object var9;
         label48: {
            ResourceCommonAsset var5;
             {
                (stream == ) {
                  var9 = ;
                   label48;
               }

               [] bytes = stream.readAllBytes();
               var5 =  (clazz, path, name, bytes);
            }  (Throwable var7) {
                (stream != ) {
                   {
                     stream.close();
                  }  (Throwable var6) {
                     var7.addSuppressed(var6);
                  }
               }

                var7;
            }

             (stream != ) {
               stream.close();
            }

             var5;
         }

          (stream != ) {
            stream.close();
         }

          (ResourceCommonAsset)var9;
      }  (IOException e) {
          SneakyThrow.sneakyThrow(e);
      }
   }
}

com/hypixel/hytale/server/core/asset/common/SoundFileValidators.java

package com.hypixel.hytale.server.core.asset.common;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class SoundFileValidators {
   public static final ChannelValidator MONO = new ChannelValidator(1);
   public static final ChannelValidator STEREO = new ChannelValidator(2);
   private static final String MONO_STRING = "Mono";
   private static final String STEREO_STRING = "Stereo";

   public SoundFileValidators() {
   }

   @Nonnull
   public static String  {
      String var10000;
       (channelCount) {
           -> var10000 = ;
           -> var10000 = ;
          ->   ( + channelCount);
      }

       var10000;
   }

        <String> {
         channelCount;

        {
          channelCount ==  || channelCount == ;

         .channelCount = channelCount;
      }

         {
          (s != ) {
            OggVorbisInfoCache.   OggVorbisInfoCache.getNow(s);
             (info == ) {
               results.fail( + s);
            }  {
                (info.channels != .channelCount) {
                  results.fail( + s +  + SoundFileValidators.getEncoding(info.channels) +  + SoundFileValidators.getEncoding(.channelCount));
               }

            }
         }
      }

         {
      }
   }
}

com/hypixel/hytale/server/core/asset/common/asset/FileCommonAsset.java

package com.hypixel.hytale.server.core.asset.common.asset;

import com.hypixel.hytale.server.core.asset.common.CommonAsset;
import com.hypixel.hytale.sneakythrow.SneakyThrow;
import com.hypixel.hytale.sneakythrow.supplier.ThrowableSupplier;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.concurrent.CompletableFuture;
import javax.annotation.Nonnull;

public class FileCommonAsset extends CommonAsset {
   private final Path file;

   public FileCommonAsset(Path file, @Nonnull String name, byte[] bytes) {
      super(name, bytes);
      this.file = file;
   }

   public FileCommonAsset(Path file, @Nonnull String name, @Nonnull String hash, byte[] bytes) {
      super(name, hash, bytes);
      this.file = file;
   }

   public Path getFile() {
      return this.file;
   }

   @Nonnull
   public CompletableFuture<byte[]> getBlob0() {
      return CompletableFuture.supplyAsync(SneakyThrow.sneakySupplier((ThrowableSupplier)(() -> Files.readAllBytes(this.file))));
   }

   @Nonnull
    String  {
         String.valueOf(.file);
        + var10000 +  + .toString() + ;
   }
}

com/hypixel/hytale/server/core/asset/common/events/CommonAssetMonitorEvent.java

package com.hypixel.hytale.server.core.asset.common.events;

import com.hypixel.hytale.assetstore.event.AssetMonitorEvent;
import java.nio.file.Path;
import java.util.List;

public class CommonAssetMonitorEvent extends AssetMonitorEvent<Void> {
   public CommonAssetMonitorEvent(String assetPack, List<Path> createdOrModified, List<Path> removed, List<Path> createdOrModifiedDirectories, List<Path> removedDirectories) {
      super(assetPack, createdOrModified, removed, createdOrModifiedDirectories, removedDirectories);
   }
}

com/hypixel/hytale/server/core/asset/common/events/SendCommonAssetsEvent.java

package com.hypixel.hytale.server.core.asset.common.events;

import com.hypixel.hytale.event.IAsyncEvent;
import com.hypixel.hytale.protocol.Asset;
import com.hypixel.hytale.server.core.io.PacketHandler;
import java.util.Arrays;
import javax.annotation.Nonnull;

public class SendCommonAssetsEvent implements IAsyncEvent<Void> {
   private final PacketHandler packetHandler;
   private final Asset[] assets;

   public SendCommonAssetsEvent(PacketHandler packetHandler, Asset[] assets) {
      this.packetHandler = packetHandler;
      this.assets = assets;
   }

   public PacketHandler getPacketHandler() {
      return this.packetHandler;
   }

   public Asset[] getRequestedAssets() {
      return this.assets;
   }

   @Nonnull
   public String toString() {
      String var10000 = String.valueOf(this.packetHandler);
      return "SendCommonAssetsEvent{packetHandler=" + var10000 + ", assets=" + Arrays.toString(this.assets) + "}";
   }
}

com/hypixel/hytale/server/core/asset/modifiers/MovementEffects.java

package com.hypixel.hytale.server.core.asset.modifiers;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;

public class MovementEffects implements NetworkSerializable<com.hypixel.hytale.protocol.MovementEffects> {
   @Nonnull
   public static final BuilderCodec<MovementEffects> CODEC;
   protected boolean disableAll = false;
   protected boolean disableForward = false;
   protected boolean disableBackward = false;
   protected boolean disableLeft = false;
   protected boolean disableRight = false;
   protected boolean disableSprint = false;
   protected boolean   ;
       ;

     {
   }

      {
       .disableAll;
   }

   
    com.hypixel.hytale.protocol.MovementEffects  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.MovementEffects();
      packet.disableForward = .disableForward;
      packet.disableBackward = .disableBackward;
      packet.disableLeft = .disableLeft;
      packet.disableRight = .disableRight;
      packet.disableSprint = .disableSprint;
      packet.disableJump = .disableJump;
      packet.disableCrouch = .disableCrouch;
       packet;
   }

   
    String  {
        + .disableAll +  + .disableForward +  + .disableBackward +  + .disableLeft +  + .disableRight +  + .disableSprint +  + .disableJump +  + .disableCrouch + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(MovementEffects.class, MovementEffects::).appendInherited( (, Codec.BOOLEAN), (entityEffect, s) -> entityEffect.disableAll = s, (entityEffect) -> entityEffect.disableAll, (entityEffect, parent) -> entityEffect.disableAll = parent.disableAll).documentation().add()).appendInherited( (, Codec.BOOLEAN), (entityEffect, s) -> entityEffect.disableForward = s, (entityEffect) -> entityEffect.disableForward, (entityEffect, parent) -> entityEffect.disableForward = parent.disableForward).documentation().add()).appendInherited( (, Codec.BOOLEAN), (entityEffect, s) -> entityEffect.disableBackward = s, (entityEffect) -> entityEffect.disableBackward, (entityEffect, parent) -> entityEffect.disableBackward = parent.disableBackward).documentation().add()).appendInherited( (, Codec.BOOLEAN), (entityEffect, s) -> entityEffect.disableLeft = s, (entityEffect) -> entityEffect.disableLeft, (entityEffect, parent) -> entityEffect.disableLeft = parent.disableLeft).documentation().add()).appendInherited( (, Codec.BOOLEAN), (entityEffect, s) -> entityEffect.disableRight = s, (entityEffect) -> entityEffect.disableRight, (entityEffect, parent) -> entityEffect.disableRight = parent.disableRight).documentation().add()).appendInherited( (, Codec.BOOLEAN), (entityEffect, s) -> entityEffect.disableSprint = s, (entityEffect) -> entityEffect.disableSprint, (entityEffect, parent) -> entityEffect.disableSprint = parent.disableSprint).documentation().add()).appendInherited( (, Codec.BOOLEAN), (entityEffect, s) -> entityEffect.disableJump = s, (entityEffect) -> entityEffect.disableJump, (entityEffect, parent) -> entityEffect.disableJump = parent.disableJump).documentation().add()).appendInherited( (, Codec.BOOLEAN), (entityEffect, s) -> entityEffect.disableCrouch = s, (entityEffect) -> entityEffect.disableCrouch, (entityEffect, parent) -> entityEffect.disableCrouch = parent.disableCrouch).documentation().add()).afterDecode((movementEffects, extraInfo) -> {
          (movementEffects.disableAll) {
            movementEffects.disableForward = ;
            movementEffects.disableBackward = ;
            movementEffects.disableLeft = ;
            movementEffects.disableRight = ;
            movementEffects.disableSprint = ;
            movementEffects.disableJump = ;
            movementEffects.disableCrouch = ;
         }

      })).build();
   }
}

com/hypixel/hytale/server/core/asset/monitor/AssetMonitor.java

package com.hypixel.hytale.server.core.asset.monitor;

import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.logger.sentry.SkipSentryException;
import com.hypixel.hytale.server.core.util.concurrent.ThreadUtil;
import com.hypixel.hytale.sneakythrow.SneakyThrow;
import com.hypixel.hytale.sneakythrow.function.ThrowableFunction;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.file.AccessDeniedException;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import javax.annotation.Nonnull;

public class AssetMonitor {
   public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   private static final ScheduledExecutorService EXECUTOR = Executors.newSingleThreadScheduledExecutor(ThreadUtil.daemon());
     Map<Path, List<AssetMonitorHandler>> directoryMonitors =  ();
     Map<Path, FileChangeTask> fileChangeTasks =  ();
     Map<Path, Map<AssetMonitorHandler, DirectoryHandlerChangeTask>> directoryHandlerChangeTasks =  ();
   
         (::onChange);

      IOException {
      .pathWatcherThread.start();
   }

      {
      .pathWatcherThread.shutdown();
   }

      {
       (!Files.isDirectory(path,  [])) {
           (String.valueOf(path));
      }  {
          {
               path.toAbsolutePath().normalize();
            LOGGER.at(Level.FINE).log(, normalize);
            ((List).directoryMonitors.computeIfAbsent(normalize, SneakyThrow.sneakyFunction((ThrowableFunction)((k) -> {
               .pathWatcherThread.addPath(k);
                 ();
            })))).add(handler);
         }  (Exception e) {
            ((HytaleLogger.Api)LOGGER.at(Level.SEVERE).withCause( (e))).log(, path);
         }

      }
   }

      {
       (!Files.isDirectory(path,  [])) {
           (String.valueOf(path));
      }  {
          {
               path.toAbsolutePath().normalize();
            LOGGER.at(Level.FINE).log(, normalize);
            ((List).directoryMonitors.computeIfAbsent(normalize, SneakyThrow.sneakyFunction((ThrowableFunction)((k) -> {
               .pathWatcherThread.addPath(k);
                 ();
            })))).removeIf((v) -> v.getKey().equals(key));
         }  (Exception e) {
            ((HytaleLogger.Api)LOGGER.at(Level.SEVERE).withCause( (e))).log(, path);
         }

      }
   }

      {
      LOGGER.at(Level.FINER).log(, file, eventKind);
         file.toAbsolutePath().normalize();
         (FileChangeTask).fileChangeTasks.remove(path);
       (oldTask != ) {
         oldTask.cancelSchedule();
      }

      (Map<AssetMonitorHandler, DirectoryHandlerChangeTask> tasks : .directoryHandlerChangeTasks.values()) {
         (DirectoryHandlerChangeTask task : tasks.values()) {
            task.removePath(path);
         }
      }

         eventKind == EventKind.ENTRY_CREATE || eventKind == EventKind.ENTRY_MODIFY;
       (createdOrModified && !Files.exists(path,  [])) {
         LOGGER.at(Level.WARNING).log(, path);
      }  {
          {
            .fileChangeTasks.put(path,  (, path,  (eventKind, System.nanoTime())));
         }  (FileNotFoundException | AccessDeniedException | NoSuchFileException var9) {
            LOGGER.at(Level.WARNING).log(, path);
         }  (IOException e) {
            ((HytaleLogger.Api)LOGGER.at(Level.SEVERE).withCause(e)).log(, path);
         }

      }
   }

      {
      LOGGER.at(Level.FINER).log(, path, pathEvent);

      (Map.Entry<Path, List<AssetMonitorHandler>> entry : .directoryMonitors.entrySet()) {
            (Path)entry.getKey();
          (path.startsWith(parent)) {
            Map<AssetMonitorHandler, DirectoryHandlerChangeTask> tasks = (Map).directoryHandlerChangeTasks.computeIfAbsent(parent, (k) ->  ());

            (AssetMonitorHandler directoryHandler : (List)entry.getValue()) {
                {
                   (directoryHandler.test(path, pathEvent.getEventKind())) {
                     ((DirectoryHandlerChangeTask)tasks.computeIfAbsent(directoryHandler, (handler) ->  (, parent, handler))).addPath(path, pathEvent);
                  }
               }  (Exception e) {
                  ((HytaleLogger.Api)LOGGER.at(Level.SEVERE).withCause(e)).log(, parent, path, pathEvent);
               }
            }
         }
      }

   }

      {
      .fileChangeTasks.remove(fileChangeTask.getPath());
   }

      {
      (Map.Entry<Path, Map<AssetMonitorHandler, DirectoryHandlerChangeTask>> entry : .directoryHandlerChangeTasks.entrySet()) {
            (Path)entry.getKey();
          (path.startsWith(parent)) {
            (DirectoryHandlerChangeTask hookChangeTask : ((Map)entry.getValue()).values()) {
               hookChangeTask.markChanged();
            }
         }
      }

   }

      {
         directoryHandlerChangeTask.getHandler();
      .directoryHandlerChangeTasks.compute(directoryHandlerChangeTask.getParent(), (k, map) -> {
          (map == ) {
             ;
         }  {
            map.remove(hook);
             map.isEmpty() ?  : map;
         }
      });
   }

   
     ScheduledFuture<?> runTask( Runnable task,  millisDelay) {
       EXECUTOR.scheduleWithFixedDelay(task, millisDelay, millisDelay, TimeUnit.MILLISECONDS);
   }
}

com/hypixel/hytale/server/core/asset/monitor/AssetMonitorHandler.java

package com.hypixel.hytale.server.core.asset.monitor;

import java.nio.file.Path;
import java.util.Map;
import java.util.function.BiPredicate;
import java.util.function.Consumer;

public interface AssetMonitorHandler extends BiPredicate<Path, EventKind>, Consumer<Map<Path, EventKind>> {
   Object getKey();
}

com/hypixel/hytale/server/core/asset/monitor/DirectoryHandlerChangeTask.java

package com.hypixel.hytale.server.core.asset.monitor;

import com.hypixel.hytale.logger.HytaleLogger;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.nio.file.Path;
import java.util.AbstractMap;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.logging.Level;
import javax.annotation.Nonnull;

public class DirectoryHandlerChangeTask implements Runnable {
   public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   private static final long ACCUMULATION_DELAY_MILLIS = 1000L;
   private final AssetMonitor assetMonitor;
   private final Path parent;
   private final AssetMonitorHandler handler;
   @Nonnull
   private final ScheduledFuture<?> task;
   private final     ();
     Map<Path, PathEvent> paths =  <Path, PathEvent>();

     {
      .assetMonitor = assetMonitor;
      .parent = parent;
      .handler = handler;
      .task = AssetMonitor.runTask(, );
   }

      {
       (!.changed.getAndSet()) {
         .cancelSchedule();

          {
            LOGGER.at(Level.FINER).log(, .paths);
            ObjectArrayList<Map.Entry<Path, PathEvent>> entries =  <Map.Entry<Path, PathEvent>>(.paths.size());

            (Map.Entry<Path, PathEvent> entry : .paths.entrySet()) {
               entries.add( .SimpleEntry((Path)entry.getKey(), (PathEvent)entry.getValue()));
            }

            .paths.clear();
            entries.sort(Comparator.comparingLong((value) -> ((PathEvent)value.getValue()).getTimestamp()));
            Set<String> fileNames =  ();
            Map<Path, EventKind> eventPaths =  <Path, EventKind>();

            (Map.Entry<Path, PathEvent> entry : entries) {
                (!fileNames.add(((Path)entry.getKey()).getFileName().toString())) {
                  LOGGER.at(Level.FINER).log(, eventPaths);
                  .handler.accept(eventPaths);
                  eventPaths =  <Path, EventKind>();
                  fileNames.clear();
               }

               eventPaths.put((Path)entry.getKey(), ((PathEvent)entry.getValue()).getEventKind());
            }

             (!eventPaths.isEmpty()) {
               LOGGER.at(Level.FINER).log(, eventPaths);
               .handler.accept(eventPaths);
            }
         }  (Exception e) {
            ((HytaleLogger.Api)LOGGER.at(Level.SEVERE).withCause(e)).log(, );
         }
      }

   }

    AssetMonitor  {
       .assetMonitor;
   }

    Path  {
       .parent;
   }

    AssetMonitorHandler  {
       .handler;
   }

      {
      LOGGER.at(Level.FINEST).log(, path, pathEvent, );
      .paths.put(path, pathEvent);
      .changed.set();
   }

      {
      LOGGER.at(Level.FINEST).log(, path, );
      .paths.remove(path);
       (.paths.isEmpty()) {
         .cancelSchedule();
      }  {
         .changed.set();
      }

   }

      {
      AssetMonitor.LOGGER.at(Level.FINEST).log(, );
      .changed.set();
   }

      {
      LOGGER.at(Level.FINEST).log(, );
      .assetMonitor.removeHookChangeTask();
       (.task !=  && !.task.isDone()) {
         .task.cancel();
      }

   }

   
    String  {
         String.valueOf(.parent);
        + var10000 +  + String.valueOf(.handler) +  + String.valueOf(.changed) +  + String.valueOf(.paths) + ;
   }
}

com/hypixel/hytale/server/core/asset/monitor/EventKind.java

package com.hypixel.hytale.server.core.asset.monitor;

import java.nio.file.Path;
import java.nio.file.StandardWatchEventKinds;
import java.nio.file.WatchEvent;
import javax.annotation.Nonnull;

public enum EventKind {
   ENTRY_CREATE,
   ENTRY_DELETE,
   ENTRY_MODIFY;

   private EventKind() {
   }

   @Nonnull
   public static EventKind parse(WatchEvent.Kind<Path> kind) {
      if (kind == StandardWatchEventKinds.ENTRY_CREATE) {
         return ENTRY_CREATE;
      } else if (kind == StandardWatchEventKinds.ENTRY_DELETE) {
         return ENTRY_DELETE;
      } else if (kind == StandardWatchEventKinds.ENTRY_MODIFY) {
         return ENTRY_MODIFY;
      } else {
         throw new IllegalStateException("Unknown type: " + String.valueOf(kind));
      }
   }
}

com/hypixel/hytale/server/core/asset/monitor/FileChangeTask.java

package com.hypixel.hytale.server.core.asset.monitor;

import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.logger.sentry.SkipSentryException;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.concurrent.ScheduledFuture;
import java.util.logging.Level;
import javax.annotation.Nonnull;

public class FileChangeTask implements Runnable {
   public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   private static final long FILE_SIZE_CHECK_DELAY_MILLIS = 200L;
   private final AssetMonitor assetMonitor;
   @Nonnull
   private final Path path;
   @Nonnull
   private final PathEvent pathEvent;
   private final boolean createdOrModified;
   @Nonnull
   private  ScheduledFuture<?> task;
     lastSize;

      IOException {
      .assetMonitor = assetMonitor;
      .path = path;
      .pathEvent = pathEvent;
      .createdOrModified = pathEvent.getEventKind() == EventKind.ENTRY_CREATE || pathEvent.getEventKind() == EventKind.ENTRY_MODIFY;
         ;
       (.createdOrModified) {
            Files.readAttributes(path, BasicFileAttributes.class);
          (!fileAttributes.isDirectory()) {
            size = fileAttributes.size();
         }
      }

      .lastSize = size;
      .task = AssetMonitor.runTask(, );
   }

    AssetMonitor  {
       .assetMonitor;
   }

   
    Path  {
       .path;
   }

   
    PathEvent  {
       .pathEvent;
   }

      {
       {
          (.createdOrModified) {
             (!Files.exists(.path,  [])) {
               LOGGER.at(Level.WARNING).log(, .path);
               .cancelSchedule();
               ;
            }

               Files.readAttributes(.path, BasicFileAttributes.class);
             (!fileAttributes.isDirectory()) {
                  fileAttributes.size();
                (size > .lastSize) {
                  LOGGER.at(Level.FINEST).log(, .path, .pathEvent, size, .lastSize);
                  .lastSize = size;
                  .assetMonitor.markChanged(.path);
                  ;
               }
            }
         }

         .cancelSchedule();
         .assetMonitor.onDelayedChange(.path, .pathEvent);
      }  (FileNotFoundException | NoSuchFileException e) {
         ((HytaleLogger.Api)LOGGER.at(Level.SEVERE).withCause( (e))).log(, .path);
      }  (Throwable e) {
         ((HytaleLogger.Api)LOGGER.at(Level.SEVERE).withCause(e)).log(, .path);
      }

   }

      {
      LOGGER.at(Level.FINEST).log(, );
      .assetMonitor.removeFileChangeTask();
       (.task !=  && !.task.isDone()) {
         .task.cancel();
      }

   }

   
    String  {
         String.valueOf(.path);
        + var10000 +  + String.valueOf(.pathEvent) +  + .lastSize + ;
   }
}

com/hypixel/hytale/server/core/asset/monitor/PathEvent.java

package com.hypixel.hytale.server.core.asset.monitor;

import javax.annotation.Nonnull;

public class PathEvent {
   private final EventKind eventKind;
   private final long timestamp;

   public PathEvent(EventKind eventKind, long timestamp) {
      this.eventKind = eventKind;
      this.timestamp = timestamp;
   }

   public EventKind getEventKind() {
      return this.eventKind;
   }

   public long getTimestamp() {
      return this.timestamp;
   }

   @Nonnull
   public String toString() {
      String var10000 = String.valueOf(this.eventKind);
      return "PathEvent{eventKind=" + var10000 + ", timestamp=" + this.timestamp + "}";
   }
}

com/hypixel/hytale/server/core/asset/monitor/PathWatcherThread.java

package com.hypixel.hytale.server.core.asset.monitor;

import com.hypixel.hytale.common.util.SystemUtil;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.server.core.util.io.FileUtil;
import com.hypixel.hytale.sneakythrow.SneakyThrow;
import com.hypixel.hytale.sneakythrow.consumer.ThrowableConsumer;
import com.sun.nio.file.ExtendedWatchEventModifier;
import com.sun.nio.file.SensitivityWatchEventModifier;
import java.io.IOException;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.StandardWatchEventKinds;
import java.nio.file.WatchEvent;
import java.nio.file.WatchKey;
import java.nio.file.WatchService;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.BiConsumer;
import java.util.logging.Level;
import java.util.stream.Stream;
import javax.annotation.Nonnull;

public class PathWatcherThread implements Runnable {
   public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   public static final boolean HAS_FILE_TREE_SUPPORT;
   public   WatchEvent.Kind<?>[] WATCH_EVENT_KINDS;
     BiConsumer<Path, EventKind> consumer;
   
     Thread thread;
     WatchService service;
     Map<Path, WatchKey> registered =  ();

      IOException {
      .consumer = consumer;
      .thread =  (, );
      .thread.setDaemon();
      .service = FileSystems.getDefault().newWatchService();
   }

       {
       {
         (!Thread.interrupted()) {
               .service.take();
               (Path)key.watchable();

            (WatchEvent<?> event : key.pollEvents()) {
               WatchEvent.Kind<?> kind = event.kind();
                (kind == StandardWatchEventKinds.OVERFLOW) {
                  LOGGER.at(Level.WARNING).log();
               }  {
                     directory.resolve((Path)event.context());
                   (!HAS_FILE_TREE_SUPPORT && event.kind() == StandardWatchEventKinds.ENTRY_CREATE && Files.isDirectory(path,  [])) {
                     .addPath(path);
                  }

                  .consumer.accept(path, EventKind.parse(event.kind()));
               }
            }

             (!key.reset()) {
               ;
            }
         }
      }  (InterruptedException var9) {
         Thread.currentThread().interrupt();
      }  (Throwable t) {
         ((HytaleLogger.Api)LOGGER.at(Level.SEVERE).withCause(t)).log();
      }

      LOGGER.at(Level.INFO).log();

       {
         .service.close();
      }  (IOException var8) {
      }

      .registered.clear();
   }

      {
      .thread.start();
   }

      {
      .thread.interrupt();

       {
         .thread.join();

          {
            .service.close();
         }  (IOException var2) {
         }

         .registered.clear();
      }  (InterruptedException var3) {
         Thread.currentThread().interrupt();
      }

   }

       IOException {
      path = path.toAbsolutePath();
       (Files.isRegularFile(path,  [])) {
         path = path.getParent();
      }

         path;

       {
            (WatchKey).registered.get(parent);
          (keys != ) {
             (!HAS_FILE_TREE_SUPPORT) {
               .watchPath(path);
            }

            ;
         }
      } ((parent = parent.getParent()) != );

      .watchPath(path);
   }

       IOException {
       (HAS_FILE_TREE_SUPPORT) {
         .registered.put(path, path.register(.service, WATCH_EVENT_KINDS, SensitivityWatchEventModifier.HIGH, ExtendedWatchEventModifier.FILE_TREE));
         LOGGER.at(Level.FINEST).log(, path);
      }  {
         WatchEvent.Modifier[] modifiers =  .Modifier[]{SensitivityWatchEventModifier.HIGH};
         Stream<Path> stream = Files.walk(path, FileUtil.DEFAULT_WALK_TREE_OPTIONS_ARRAY);

          {
            stream.forEach(SneakyThrow.sneakyConsumer((ThrowableConsumer)((childPath) -> {
                (Files.isDirectory(childPath,  [])) {
                  .registered.put(childPath, childPath.register(.service, WATCH_EVENT_KINDS, modifiers));
                  LOGGER.at(Level.FINEST).log(, childPath);
               }

            })));
         }  (Throwable var7) {
             (stream != ) {
                {
                  stream.close();
               }  (Throwable var6) {
                  var7.addSuppressed(var6);
               }
            }

             var7;
         }

          (stream != ) {
            stream.close();
         }
      }

      LOGGER.at(Level.FINER).log(, path);
   }

    {
      HAS_FILE_TREE_SUPPORT = SystemUtil.TYPE == SystemUtil.SystemType.WINDOWS;
      WATCH_EVENT_KINDS =  .Kind[]{StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY};
   }
}

com/hypixel/hytale/server/core/asset/packet/AssetPacketGenerator.java

package com.hypixel.hytale.server.core.asset.packet;

import com.hypixel.hytale.assetstore.AssetMap;
import com.hypixel.hytale.assetstore.AssetUpdateQuery;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.protocol.Packet;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public abstract class AssetPacketGenerator<K, T extends JsonAssetWithMap<K, M>, M extends AssetMap<K, T>> {
   public AssetPacketGenerator() {
   }

   public abstract Packet generateInitPacket(M var1, Map<K, T> var2);

   public abstract Packet generateUpdatePacket(M var1, Map<K, T> var2, @Nonnull AssetUpdateQuery var3);

   @Nullable
   public abstract Packet generateRemovePacket(M var1, Set<K> var2, @Nonnull AssetUpdateQuery var3);
}

com/hypixel/hytale/server/core/asset/packet/DefaultAssetPacketGenerator.java

package com.hypixel.hytale.server.core.asset.packet;

import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.protocol.Packet;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nullable;

public abstract class DefaultAssetPacketGenerator<K, T extends JsonAssetWithMap<K, DefaultAssetMap<K, T>>> extends SimpleAssetPacketGenerator<K, T, DefaultAssetMap<K, T>> {
   public DefaultAssetPacketGenerator() {
   }

   public abstract Packet generateInitPacket(DefaultAssetMap<K, T> var1, Map<K, T> var2);

   public abstract Packet generateUpdatePacket(Map<K, T> var1);

   @Nullable
   public abstract Packet generateRemovePacket(Set<K> var1);

   public final Packet generateUpdatePacket(DefaultAssetMap<K, T> assetMap, Map<K, T> loadedAssets) {
      return this.generateUpdatePacket(loadedAssets);
   }

   @Nullable
   public final Packet generateRemovePacket(DefaultAssetMap<K, T> assetMap, Set<K> removed) {
       .generateRemovePacket(removed);
   }
}

com/hypixel/hytale/server/core/asset/packet/SimpleAssetPacketGenerator.java

package com.hypixel.hytale.server.core.asset.packet;

import com.hypixel.hytale.assetstore.AssetMap;
import com.hypixel.hytale.assetstore.AssetUpdateQuery;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.protocol.Packet;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public abstract class SimpleAssetPacketGenerator<K, T extends JsonAssetWithMap<K, M>, M extends AssetMap<K, T>> extends AssetPacketGenerator<K, T, M> {
   public SimpleAssetPacketGenerator() {
   }

   public abstract Packet generateInitPacket(M var1, Map<K, T> var2);

   public Packet generateUpdatePacket(M assetMap, Map<K, T> loadedAssets, @Nonnull AssetUpdateQuery query) {
      return this.generateUpdatePacket(assetMap, loadedAssets);
   }

   public Packet generateRemovePacket(M assetMap, Set<K> removed, @Nonnull AssetUpdateQuery query) {
      return this.generateRemovePacket(assetMap, removed);
   }

   protected abstract Packet generateUpdatePacket;

   
     Packet ;
}

com/hypixel/hytale/server/core/asset/type/ambiencefx/AmbienceFXPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.ambiencefx;

import com.hypixel.hytale.assetstore.map.IndexedAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateAmbienceFX;
import com.hypixel.hytale.server.core.asset.packet.SimpleAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.ambiencefx.config.AmbienceFX;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class AmbienceFXPacketGenerator extends SimpleAssetPacketGenerator<String, AmbienceFX, IndexedAssetMap<String, AmbienceFX>> {
   public AmbienceFXPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull IndexedAssetMap<String, AmbienceFX> assetMap, @Nonnull Map<String, AmbienceFX> assets) {
      UpdateAmbienceFX packet = new UpdateAmbienceFX();
      packet.type = UpdateType.Init;
      packet.ambienceFX = new Object2ObjectOpenHashMap<Integer, com.hypixel.hytale.protocol.AmbienceFX>();

      for(Map.Entry<String, AmbienceFX> entry : assets.entrySet()) {
         String key = (String)entry.getKey();
         int   assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.ambienceFX.put(index, ((AmbienceFX)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.ambienceFX =  <Integer, com.hypixel.hytale.protocol.AmbienceFX>();

      (Map.Entry<String, AmbienceFX> entry : loadedAssets.entrySet()) {
            (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.ambienceFX.put(index, ((AmbienceFX)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.ambienceFX =  <Integer, com.hypixel.hytale.protocol.AmbienceFX>();

      (String key : removed) {
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.ambienceFX.put(index, (Object));
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/ambiencefx/config/AmbienceFX.java

package com.hypixel.hytale.server.core.asset.type.ambiencefx.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.IndexedAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIDefaultCollapsedState;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditorSectionStart;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.common.util.ArrayUtil;
import com.hypixel.hytale.server.core.asset.type.audiocategory.config.AudioCategory;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.lang.ref.SoftReference;
import java.util.Arrays;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class AmbienceFX implements JsonAssetWithMap<String, IndexedAssetMap<String, AmbienceFX>>, NetworkSerializable<com.hypixel.hytale.protocol.AmbienceFX> {
   public static final ValidatorCache<String> VALIDATOR_CACHE = new ValidatorCache<String>( (AmbienceFX::getAssetStore));
      AssetBuilderCodec<String, AmbienceFX> CODEC;
         ;
      AmbienceFX EMPTY;
     AssetStore<String, AmbienceFX, IndexedAssetMap<String, AmbienceFX>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
    AmbienceFXConditions conditions;
    AmbienceFXSound[] sounds;
    AmbienceFXMusic music;
    AmbienceFXAmbientBed ambientBed;
    AmbienceFXSoundEffect soundEffect;
       ;
    String[] blockedAmbienceFxIds;
   
       ;
        ;
    SoftReference<com.hypixel.hytale.protocol.AmbienceFX> cachedPacket;

     AssetStore<String, AmbienceFX, IndexedAssetMap<String, AmbienceFX>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, AmbienceFX, IndexedAssetMap<String, AmbienceFX>>getAssetStore(AmbienceFX.class);
      }

       ASSET_STORE;
   }

     IndexedAssetMap<String, AmbienceFX>  {
       (IndexedAssetMap)getAssetStore().getAssetMap();
   }

     {
      .id = id;
   }

     {
   }

   
    com.hypixel.hytale.protocol.AmbienceFX  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.AmbienceFX).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.AmbienceFX();
         packet.id = .id;
          (.conditions != ) {
            packet.conditions = .conditions.toPacket();
         }

          (.sounds !=  && .sounds.length > ) {
            packet.sounds = (com.hypixel.hytale.protocol.AmbienceFXSound[])ArrayUtil.copyAndMutate(.sounds, AmbienceFXSound::toPacket, (x$) ->  .hypixel.hytale.protocol.AmbienceFXSound[x$]);
         }

          (.music != ) {
            packet.music = .music.toPacket();
         }

          (.ambientBed != ) {
            packet.ambientBed = .ambientBed.toPacket();
         }

          (.soundEffect != ) {
            packet.soundEffect = .soundEffect.toPacket();
         }

         packet.priority = .priority;
          (.blockedAmbienceFxIds != ) {
            packet.blockedAmbienceFxIndices =  [.blockedAmbienceFxIds.length];

            (   ; i < .blockedAmbienceFxIds.length; ++i) {
               packet.blockedAmbienceFxIndices[i] = getAssetMap().getIndex(.blockedAmbienceFxIds[i]);
            }
         }

         packet.audioCategoryIndex = .audioCategoryIndex;
         .cachedPacket =  (packet);
          packet;
      }
   }

    String  {
       .id;
   }

    AmbienceFXConditions  {
       .conditions;
   }

    AmbienceFXSound[] getSounds() {
       .sounds;
   }

    AmbienceFXMusic  {
       .music;
   }

    AmbienceFXAmbientBed  {
       .ambientBed;
   }

    AmbienceFXSoundEffect  {
       .soundEffect;
   }

      {
       .priority;
   }

    String[] getBlockedAmbienceFxIds() {
       .blockedAmbienceFxIds;
   }

   
    String  {
         .id;
        + var10000 +  + String.valueOf(.conditions) +  + Arrays.toString(.sounds) +  + String.valueOf(.music) +  + String.valueOf(.ambientBed) +  + String.valueOf(.soundEffect) +  + .priority +  + Arrays.toString(.blockedAmbienceFxIds) +  + .audioCategoryId + ;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(AmbienceFX.class, AmbienceFX::, Codec.STRING, (ambienceFX, k) -> ambienceFX.id = k, (ambienceFX) -> ambienceFX.id, (asset, data) -> asset.data = data, (asset) -> asset.data).appendInherited( (, AmbienceFXConditions.CODEC), (ambienceFX, l) -> ambienceFX.conditions = l, (ambienceFX) -> ambienceFX.conditions, (ambienceFX, parent) -> ambienceFX.conditions = parent.conditions).metadata( ()).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (,  (AmbienceFXSound.CODEC, (x$) ->  [x$])), (ambienceFX, l) -> ambienceFX.sounds = l, (ambienceFX) -> ambienceFX.sounds, (ambienceFX, parent) -> ambienceFX.sounds = parent.sounds).metadata( ()).add()).appendInherited( (, AmbienceFXMusic.CODEC), (ambienceFX, l) -> ambienceFX.music = l, (ambienceFX) -> ambienceFX.music, (ambienceFX, parent) -> ambienceFX.music = parent.music).add()).appendInherited( (, AmbienceFXAmbientBed.CODEC), (ambienceFX, l) -> ambienceFX.ambientBed = l, (ambienceFX) -> ambienceFX.ambientBed, (ambienceFX, parent) -> ambienceFX.ambientBed = parent.ambientBed).add()).appendInherited( (, AmbienceFXSoundEffect.CODEC), (ambienceFX, l) -> ambienceFX.soundEffect = l, (ambienceFX) -> ambienceFX.soundEffect, (ambienceFX, parent) -> ambienceFX.soundEffect = parent.soundEffect).add()).appendInherited( (, Codec.INTEGER), (ambienceFX, i) -> ambienceFX.priority = i, (ambienceFX) -> ambienceFX.priority, (ambienceFX, parent) -> ambienceFX.priority = parent.priority).addValidator(Validators.greaterThanOrEqual()).documentation().add()).appendInherited( (, Codec.STRING_ARRAY), (ambienceFX, s) -> ambienceFX.blockedAmbienceFxIds = s, (ambienceFX) -> ambienceFX.blockedAmbienceFxIds, (ambienceFX, parent) -> ambienceFX.blockedAmbienceFxIds = parent.blockedAmbienceFxIds).addValidatorLate(() -> VALIDATOR_CACHE.getArrayValidator().late()).add()).appendInherited( (, Codec.STRING), (ambienceFX, s) -> ambienceFX.audioCategoryId = s, (ambienceFX) -> ambienceFX.audioCategoryId, (ambienceFX, parent) -> ambienceFX.audioCategoryId = parent.audioCategoryId).addValidator(AudioCategory.VALIDATOR_CACHE.getValidator()).documentation().add()).afterDecode((ambienceFX) -> {
          (ambienceFX.audioCategoryId != ) {
            ambienceFX.audioCategoryIndex = AudioCategory.getAssetMap().getIndex(ambienceFX.audioCategoryId);
         }

      })).build();
      EMPTY =  () {
         {
            .id = ;
         }
      };
   }
}

com/hypixel/hytale/server/core/asset/type/ambiencefx/config/AmbienceFXAmbientBed.java

package com.hypixel.hytale.server.core.asset.type.ambiencefx.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditor;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.common.util.AudioUtil;
import com.hypixel.hytale.protocol.AmbienceTransitionSpeed;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import com.hypixel.hytale.server.core.asset.common.SoundFileValidators;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;

public class AmbienceFXAmbientBed implements NetworkSerializable<com.hypixel.hytale.protocol.AmbienceFXAmbientBed> {
   public static final BuilderCodec<AmbienceFXAmbientBed> CODEC;
   protected String track;
   protected float decibels = 0.0F;
   protected transient float volume = 1.0F;
   protected AmbienceTransitionSpeed transitionSpeed;

   public AmbienceFXAmbientBed(String track, float decibels, AmbienceTransitionSpeed transitionSpeed) {
      .transitionSpeed = AmbienceTransitionSpeed.Default;
      .track = track;
      .decibels = decibels;
      .transitionSpeed = transitionSpeed;
   }

     {
      .transitionSpeed = AmbienceTransitionSpeed.Default;
   }

   
    com.hypixel.hytale.protocol.AmbienceFXAmbientBed  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.AmbienceFXAmbientBed();
      packet.track = .track;
      packet.volume = .volume;
      packet.transitionSpeed = .transitionSpeed;
       packet;
   }

    String  {
       .track;
   }

      {
       .decibels;
   }

      {
       .volume;
   }

    AmbienceTransitionSpeed  {
       .transitionSpeed;
   }

      {
      .volume = AudioUtil.decibelsToLinearGain(.decibels);
   }

   
    String  {
         .track;
        + var10000 +  + .decibels +  + .volume +  + String.valueOf(.transitionSpeed) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(AmbienceFXAmbientBed.class, AmbienceFXAmbientBed::).appendInherited( (, Codec.STRING), (ambienceFXAmbientBed, s) -> ambienceFXAmbientBed.track = s, (ambienceFXAmbientBed) -> ambienceFXAmbientBed.track, (ambienceFXAmbientBed, parent) -> ambienceFXAmbientBed.track = parent.track).addValidator(Validators.nonNull()).addValidator(CommonAssetValidator.SOUNDS).addValidator(SoundFileValidators.STEREO).add()).appendInherited( (, Codec.FLOAT), (ambienceFXAmbientBed, f) -> ambienceFXAmbientBed.decibels = f, (ambienceFXAmbientBed) -> ambienceFXAmbientBed.decibels, (ambienceFXAmbientBed, parent) -> ambienceFXAmbientBed.decibels = parent.decibels).metadata( ( .FormattedNumber((Double), , (Integer)))).addValidator(Validators.range(-, )).add()).appendInherited( (,  (AmbienceTransitionSpeed.class)), (ambienceFXAmbientBed, e) -> ambienceFXAmbientBed.transitionSpeed = e, (ambienceFXAmbientBed) -> ambienceFXAmbientBed.transitionSpeed, (ambienceFXAmbientBed, parent) -> ambienceFXAmbientBed.transitionSpeed = parent.transitionSpeed).documentation().add()).afterDecode(AmbienceFXAmbientBed::processConfig)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/ambiencefx/config/AmbienceFXBlockSoundSet.java

package com.hypixel.hytale.server.core.asset.type.ambiencefx.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.Rangef;
import com.hypixel.hytale.server.core.asset.type.blocksound.config.BlockSoundSet;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;

public class AmbienceFXBlockSoundSet implements NetworkSerializable<com.hypixel.hytale.protocol.AmbienceFXBlockSoundSet> {
   public static final BuilderCodec<AmbienceFXBlockSoundSet> CODEC;
   public static final Rangef DEFAULT_PERCENT;
   protected String blockSoundSetId;
   protected transient int blockSoundSetIndex;
   protected Rangef percent;

   public AmbienceFXBlockSoundSet(String blockSoundSetId, Rangef percent) {
      this.percent = DEFAULT_PERCENT;
      this.blockSoundSetId = blockSoundSetId;
      this.percent = percent;
   }

   protected AmbienceFXBlockSoundSet() {
      this.percent = DEFAULT_PERCENT;
   }

   @Nonnull
    com.hypixel.hytale.protocol.AmbienceFXBlockSoundSet  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.AmbienceFXBlockSoundSet();
      packet.blockSoundSetIndex = .blockSoundSetIndex;
      packet.percent = .percent;
       packet;
   }

    String  {
       .blockSoundSetId;
   }

    Rangef  {
       .percent;
   }

      {
      .blockSoundSetIndex = BlockSoundSet.getAssetMap().getIndex(.blockSoundSetId);
   }

   
    String  {
         .blockSoundSetId;
        + var10000 +  + .blockSoundSetIndex +  + String.valueOf(.percent) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(AmbienceFXBlockSoundSet.class, AmbienceFXBlockSoundSet::).append( (, Codec.STRING), (ambienceFXBlockSoundSet, s) -> ambienceFXBlockSoundSet.blockSoundSetId = s, (ambienceFXBlockSoundSet) -> ambienceFXBlockSoundSet.blockSoundSetId).addValidator(Validators.nonNull()).addValidator(BlockSoundSet.VALIDATOR_CACHE.getValidator()).add()).addField( (, ProtocolCodecs.RANGEF), (ambienceFXBlockSoundSet, o) -> ambienceFXBlockSoundSet.percent = o, (ambienceFXBlockSoundSet) -> ambienceFXBlockSoundSet.percent)).afterDecode(AmbienceFXBlockSoundSet::processConfig)).build();
      DEFAULT_PERCENT =  (, );
   }
}

com/hypixel/hytale/server/core/asset/type/ambiencefx/config/AmbienceFXConditions.java

package com.hypixel.hytale.server.core.asset.type.ambiencefx.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.common.util.ArrayUtil;
import com.hypixel.hytale.protocol.Range;
import com.hypixel.hytale.protocol.Rangeb;
import com.hypixel.hytale.protocol.Rangef;
import com.hypixel.hytale.server.core.asset.type.environment.config.Environment;
import com.hypixel.hytale.server.core.asset.type.fluidfx.config.FluidFX;
import com.hypixel.hytale.server.core.asset.type.tagpattern.config.TagPattern;
import com.hypixel.hytale.server.core.asset.type.weather.config.Weather;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.util.Arrays;
import javax.annotation.Nonnull;

public class AmbienceFXConditions implements NetworkSerializable<com.hypixel.hytale.protocol.AmbienceFXConditions> {
   public static final BuilderCodec<AmbienceFXConditions> CODEC;
   public static final Range DEFAULT_ALTITUDE;
   public static final Rangeb DEFAULT_WALLS;
   public static final Rangeb DEFAULT_LIGHT_LEVEL;
   public static  Rangef DEFAULT_DAY_TIME;
     never;
    String[] environmentIds;
     [] environmentIndices;
    String[] weatherIds;
     [] weatherIndices;
    String environmentTagPattern;
    String weatherTagPattern;
    String[] fluidFXIds;
     [] fluidFXIndices;
    AmbienceFXBlockSoundSet[] surroundingBlockSoundSets;
    Range altitude;
    Rangeb walls;
     roof;
    String roofMaterialTagPattern;
     floor;
    Rangeb sunLightLevel;
    Rangeb torchLightLevel;
    Rangeb globalLightLevel;
    Rangef dayTime;

     {
      .altitude = DEFAULT_ALTITUDE;
      .walls = DEFAULT_WALLS;
      .sunLightLevel = DEFAULT_LIGHT_LEVEL;
      .torchLightLevel = DEFAULT_LIGHT_LEVEL;
      .globalLightLevel = DEFAULT_LIGHT_LEVEL;
      .dayTime = DEFAULT_DAY_TIME;
   }

   
    com.hypixel.hytale.protocol.AmbienceFXConditions  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.AmbienceFXConditions();
      packet.never = .never;
       (.environmentIndices !=  && .environmentIndices.length > ) {
         packet.environmentIndices = .environmentIndices;
      }

       (.environmentTagPattern != ) {
         packet.environmentTagPatternIndex = TagPattern.getAssetMap().getIndex(.environmentTagPattern);
      }  {
         packet.environmentTagPatternIndex = -;
      }

       (.weatherIndices !=  && .weatherIndices.length > ) {
         packet.weatherIndices = .weatherIndices;
      }

       (.weatherTagPattern != ) {
         packet.weatherTagPatternIndex = TagPattern.getAssetMap().getIndex(.weatherTagPattern);
      }  {
         packet.weatherTagPatternIndex = -;
      }

       (.fluidFXIndices != ) {
         packet.fluidFXIndices = .fluidFXIndices;
      }

       (.surroundingBlockSoundSets !=  && .surroundingBlockSoundSets.length > ) {
         packet.surroundingBlockSoundSets = (com.hypixel.hytale.protocol.AmbienceFXBlockSoundSet[])ArrayUtil.copyAndMutate(.surroundingBlockSoundSets, AmbienceFXBlockSoundSet::toPacket, (x$) ->  .hypixel.hytale.protocol.AmbienceFXBlockSoundSet[x$]);
      }

      packet.altitude = .altitude;
      packet.walls = .walls;
      packet.roof = .roof;
       (.roofMaterialTagPattern != ) {
         packet.roofMaterialTagPatternIndex = TagPattern.getAssetMap().getIndex(.roofMaterialTagPattern);
      }  {
         packet.roofMaterialTagPatternIndex = -;
      }

      packet.floor = .floor;
      packet.sunLightLevel = .sunLightLevel;
      packet.torchLightLevel = .torchLightLevel;
      packet.globalLightLevel = .globalLightLevel;
      packet.dayTime = .dayTime;
       packet;
   }

      {
       .never;
   }

    String[] getEnvironmentIds() {
       .environmentIds;
   }

    [] getEnvironmentIndices() {
       .environmentIndices;
   }

    String[] getWeatherIds() {
       .weatherIds;
   }

    [] getWeatherIndices() {
       .weatherIndices;
   }

    String[] getFluidFXIds() {
       .fluidFXIds;
   }

    [] getFluidFXIndices() {
       .fluidFXIndices;
   }

    AmbienceFXBlockSoundSet[] getSurroundingBlockSoundSets() {
       .surroundingBlockSoundSets;
   }

    Range  {
       .altitude;
   }

    Rangeb  {
       .walls;
   }

      {
       .roof;
   }

      {
       .floor;
   }

    Rangeb  {
       .sunLightLevel;
   }

    Rangeb  {
       .torchLightLevel;
   }

    Rangeb  {
       .globalLightLevel;
   }

    Rangef  {
       .dayTime;
   }

      {
       .roof;
   }

      {
       .floor;
   }

      {
       (.environmentIds != ) {
         .environmentIndices =  [.environmentIds.length];

         (   ; i < .environmentIds.length; ++i) {
            .environmentIndices[i] = Environment.getAssetMap().getIndex(.environmentIds[i]);
         }
      }

       (.weatherIds != ) {
         .weatherIndices =  [.weatherIds.length];

         (   ; i < .weatherIds.length; ++i) {
            .weatherIndices[i] = Weather.getAssetMap().getIndex(.weatherIds[i]);
         }
      }

       (.fluidFXIds != ) {
         .fluidFXIndices =  [.fluidFXIds.length];

         (   ; i < .fluidFXIds.length; ++i) {
            .fluidFXIndices[i] = FluidFX.getAssetMap().getIndex(.fluidFXIds[i]);
         }
      }

   }

   
    String  {
         .never;
        + var10000 +  + Arrays.toString(.environmentIds) +  + Arrays.toString(.environmentIndices) +  + .environmentTagPattern +  + Arrays.toString(.weatherIds) +  + Arrays.toString(.weatherIndices) +  + Arrays.toString(.fluidFXIds) +  + Arrays.toString(.fluidFXIndices) +  + Arrays.toString(.surroundingBlockSoundSets) +  + String.valueOf(.altitude) +  + String.valueOf(.walls) +  + .roof +  + .roofMaterialTagPattern +  + .floor +  + String.valueOf(.sunLightLevel) +  + String.valueOf(.torchLightLevel) +  + String.valueOf(.globalLightLevel) +  + String.valueOf(.dayTime) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(AmbienceFXConditions.class, AmbienceFXConditions::).appendInherited( (, Codec.BOOLEAN), (ambienceFXConditions, l) -> ambienceFXConditions.never = l, (ambienceFXConditions) -> ambienceFXConditions.never, (ambienceFXConditions, parent) -> ambienceFXConditions.never = parent.never).documentation().add()).appendInherited( (, Codec.STRING_ARRAY), (ambienceFXConditions, l) -> ambienceFXConditions.environmentIds = l, (ambienceFXConditions) -> ambienceFXConditions.environmentIds, (ambienceFXConditions, parent) -> ambienceFXConditions.environmentIds = parent.environmentIds).addValidator(Environment.VALIDATOR_CACHE.getArrayValidator()).add()).appendInherited( (, TagPattern.CHILD_ASSET_CODEC), (ambienceFxConditions, t) -> ambienceFxConditions.environmentTagPattern = t, (ambienceFXConditions) -> ambienceFXConditions.environmentTagPattern, (ambienceFXConditions, parent) -> ambienceFXConditions.environmentTagPattern = parent.environmentTagPattern).addValidator(TagPattern.VALIDATOR_CACHE.getValidator()).documentation().add()).appendInherited( (, TagPattern.CHILD_ASSET_CODEC), (ambienceFxConditions, t) -> ambienceFxConditions.weatherTagPattern = t, (ambienceFXConditions) -> ambienceFXConditions.weatherTagPattern, (ambienceFXConditions, parent) -> ambienceFXConditions.weatherTagPattern = parent.weatherTagPattern).addValidator(TagPattern.VALIDATOR_CACHE.getValidator()).documentation().add()).appendInherited( (, Codec.STRING_ARRAY), (ambienceFXConditions, l) -> ambienceFXConditions.weatherIds = l, (ambienceFXConditions) -> ambienceFXConditions.weatherIds, (ambienceFXConditions, parent) -> ambienceFXConditions.weatherIds = parent.weatherIds).addValidator(Weather.VALIDATOR_CACHE.getArrayValidator()).add()).appendInherited( (, Codec.STRING_ARRAY), (ambienceFXConditions, l) -> ambienceFXConditions.fluidFXIds = l, (ambienceFXConditions) -> ambienceFXConditions.fluidFXIds, (ambienceFXConditions, parent) -> ambienceFXConditions.fluidFXIds = parent.fluidFXIds).addValidator(FluidFX.VALIDATOR_CACHE.getArrayValidator()).add()).appendInherited( (,  (AmbienceFXBlockSoundSet.CODEC, (x$) ->  [x$])), (ambienceFXConditions, l) -> ambienceFXConditions.surroundingBlockSoundSets = l, (ambienceFXConditions) -> ambienceFXConditions.surroundingBlockSoundSets, (ambienceFXConditions, parent) -> ambienceFXConditions.surroundingBlockSoundSets = parent.surroundingBlockSoundSets).add()).appendInherited( (, ProtocolCodecs.RANGE), (ambienceFXBlockEnvironment, o) -> ambienceFXBlockEnvironment.altitude = o, (ambienceFXBlockEnvironment) -> ambienceFXBlockEnvironment.altitude, (ambienceFXConditions, parent) -> ambienceFXConditions.altitude = parent.altitude).add()).appendInherited( (, ProtocolCodecs.RANGEB), (ambienceFXBlockEnvironment, o) -> ambienceFXBlockEnvironment.walls = o, (ambienceFXBlockEnvironment) -> ambienceFXBlockEnvironment.walls, (ambienceFXConditions, parent) -> ambienceFXConditions.walls = parent.walls).add()).appendInherited( (, Codec.BOOLEAN), (ambienceFXConditions, aBoolean) -> ambienceFXConditions.roof = aBoolean, (ambienceFXConditions) -> ambienceFXConditions.roof, (ambienceFXConditions, parent) -> ambienceFXConditions.roof = parent.roof).add()).appendInherited( (, TagPattern.CHILD_ASSET_CODEC), (ambienceFxConditions, t) -> ambienceFxConditions.roofMaterialTagPattern = t, (ambienceFXConditions) -> ambienceFXConditions.roofMaterialTagPattern, (ambienceFXConditions, parent) -> ambienceFXConditions.roofMaterialTagPattern = parent.roofMaterialTagPattern).addValidator(TagPattern.VALIDATOR_CACHE.getValidator()).documentation().add()).appendInherited( (, Codec.BOOLEAN), (ambienceFXConditions, aBoolean) -> ambienceFXConditions.floor = aBoolean, (ambienceFXConditions) -> ambienceFXConditions.floor, (ambienceFXConditions, parent) -> ambienceFXConditions.floor = parent.floor).add()).appendInherited( (, ProtocolCodecs.RANGEB), (ambienceFXBlockEnvironment, o) -> ambienceFXBlockEnvironment.sunLightLevel = o, (ambienceFXBlockEnvironment) -> ambienceFXBlockEnvironment.sunLightLevel, (ambienceFXConditions, parent) -> ambienceFXConditions.sunLightLevel = parent.sunLightLevel).add()).appendInherited( (, ProtocolCodecs.RANGEB), (ambienceFXBlockEnvironment, o) -> ambienceFXBlockEnvironment.torchLightLevel = o, (ambienceFXBlockEnvironment) -> ambienceFXBlockEnvironment.torchLightLevel, (ambienceFXConditions, parent) -> ambienceFXConditions.torchLightLevel = parent.torchLightLevel).add()).appendInherited( (, ProtocolCodecs.RANGEB), (ambienceFXBlockEnvironment, o) -> ambienceFXBlockEnvironment.globalLightLevel = o, (ambienceFXBlockEnvironment) -> ambienceFXBlockEnvironment.globalLightLevel, (ambienceFXConditions, parent) -> ambienceFXConditions.globalLightLevel = parent.globalLightLevel).add()).appendInherited( (, ProtocolCodecs.RANGEF), (ambienceFXBlockEnvironment, o) -> ambienceFXBlockEnvironment.dayTime = o, (ambienceFXBlockEnvironment) -> ambienceFXBlockEnvironment.dayTime, (ambienceFXConditions, parent) -> ambienceFXConditions.dayTime = parent.dayTime).add()).afterDecode(AmbienceFXConditions::processConfig)).build();
      DEFAULT_ALTITUDE =  (, );
      DEFAULT_WALLS =  ((), ());
      DEFAULT_LIGHT_LEVEL =  ((), ());
      DEFAULT_DAY_TIME =  (, );
   }
}

com/hypixel/hytale/server/core/asset/type/ambiencefx/config/AmbienceFXMusic.java

package com.hypixel.hytale.server.core.asset.type.ambiencefx.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditor;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.codec.validation.validator.ArrayValidator;
import com.hypixel.hytale.common.util.AudioUtil;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.util.Arrays;
import javax.annotation.Nonnull;

public class AmbienceFXMusic implements NetworkSerializable<com.hypixel.hytale.protocol.AmbienceFXMusic> {
   public static final BuilderCodec<AmbienceFXMusic> CODEC;
   protected String[] tracks;
   protected float decibels = 0.0F;
   protected transient float volume = 1.0F;

   public AmbienceFXMusic(String[] tracks, float decibels) {
      this.tracks = tracks;
      this.decibels = decibels;
   }

   protected AmbienceFXMusic {
   }

   
    com.hypixel.hytale.protocol.AmbienceFXMusic  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.AmbienceFXMusic();
       (.tracks !=  && .tracks.length > ) {
         packet.tracks = .tracks;
      }

      packet.volume = .volume;
       packet;
   }

    String[] getTracks() {
       .tracks;
   }

      {
       .decibels;
   }

      {
       .volume;
   }

      {
      .volume = AudioUtil.decibelsToLinearGain(.decibels);
   }

   
    String  {
         Arrays.toString(.tracks);
        + var10000 +  + .decibels +  + .volume + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(AmbienceFXMusic.class, AmbienceFXMusic::).appendInherited( (, Codec.STRING_ARRAY), (ambienceFXMusic, strings) -> ambienceFXMusic.tracks = strings, (ambienceFXMusic) -> ambienceFXMusic.tracks, (ambienceFXMusic, parent) -> ambienceFXMusic.tracks = parent.tracks).addValidator(Validators.nonEmptyArray()).addValidator( (CommonAssetValidator.MUSIC)).add()).appendInherited( (, Codec.FLOAT), (ambienceFXMusic, f) -> ambienceFXMusic.decibels = f, (ambienceFXMusic) -> ambienceFXMusic.decibels, (ambienceFXMusic, parent) -> ambienceFXMusic.decibels = parent.decibels).metadata( ( .FormattedNumber((Double), , (Integer)))).addValidator(Validators.range(-, )).add()).afterDecode(AmbienceFXMusic::processConfig)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/ambiencefx/config/AmbienceFXSound.java

package com.hypixel.hytale.server.core.asset.type.ambiencefx.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.AmbienceFXAltitude;
import com.hypixel.hytale.protocol.AmbienceFXSoundPlay3D;
import com.hypixel.hytale.protocol.Range;
import com.hypixel.hytale.protocol.Rangef;
import com.hypixel.hytale.server.core.asset.type.blocksound.config.BlockSoundSet;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;

public class AmbienceFXSound implements NetworkSerializable<com.hypixel.hytale.protocol.AmbienceFXSound> {
   public static final BuilderCodec<AmbienceFXSound> CODEC;
   public static final Rangef DEFAULT_FREQUENCY;
   public static final Range DEFAULT_RADIUS;
   protected String soundEventId;
   protected transient int soundEventIndex;
   protected AmbienceFXSoundPlay3D play3D;
   protected String blockSoundSetId;
   protected   blockSoundSetIndex;
    AmbienceFXAltitude altitude;
    Rangef frequency;
    Range radius;

     {
      .play3D = AmbienceFXSoundPlay3D.Random;
      .altitude = AmbienceFXAltitude.Normal;
      .frequency = DEFAULT_FREQUENCY;
      .radius = DEFAULT_RADIUS;
      .soundEventId = soundEventId;
      .play3D = play3D;
      .blockSoundSetId = blockSoundSetId;
      .altitude = altitude;
      .frequency = frequency;
      .radius = radius;
   }

     {
      .play3D = AmbienceFXSoundPlay3D.Random;
      .altitude = AmbienceFXAltitude.Normal;
      .frequency = DEFAULT_FREQUENCY;
      .radius = DEFAULT_RADIUS;
   }

   
    com.hypixel.hytale.protocol.AmbienceFXSound  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.AmbienceFXSound();
      packet.soundEventIndex = .soundEventIndex;
      packet.play3D = .play3D;
      packet.blockSoundSetIndex = .blockSoundSetIndex;
      packet.altitude = .altitude;
      packet.frequency = .frequency;
      packet.radius = .radius;
       packet;
   }

    String  {
       .soundEventId;
   }

      {
       .soundEventIndex;
   }

    AmbienceFXSoundPlay3D  {
       .play3D;
   }

    String  {
       .blockSoundSetId;
   }

    AmbienceFXAltitude  {
       .altitude;
   }

    Rangef  {
       .frequency;
   }

    Range  {
       .radius;
   }

      {
       (.soundEventId != ) {
         .soundEventIndex = SoundEvent.getAssetMap().getIndex(.soundEventId);
      }

       (.blockSoundSetId != ) {
         .blockSoundSetIndex = BlockSoundSet.getAssetMap().getIndex(.blockSoundSetId);
      }

   }

   
    String  {
         .soundEventId;
        + var10000 +  + .soundEventIndex +  + String.valueOf(.play3D) +  + .blockSoundSetId +  + .blockSoundSetIndex +  + String.valueOf(.altitude) +  + String.valueOf(.frequency) +  + String.valueOf(.radius) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(AmbienceFXSound.class, AmbienceFXSound::).append( (, Codec.STRING), (ambienceFXSound, o) -> ambienceFXSound.soundEventId = o, (ambienceFXSound) -> ambienceFXSound.soundEventId).addValidator(Validators.nonNull()).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).add()).addField( (,  (AmbienceFXSoundPlay3D.class)), (ambienceFXSound, o) -> ambienceFXSound.play3D = o, (ambienceFXSound) -> ambienceFXSound.play3D)).append( (, Codec.STRING), (ambienceFXSound, o) -> ambienceFXSound.blockSoundSetId = o, (ambienceFXSound) -> ambienceFXSound.blockSoundSetId).addValidator(BlockSoundSet.VALIDATOR_CACHE.getValidator()).add()).addField( (,  (AmbienceFXAltitude.class)), (ambienceFXSound, o) -> ambienceFXSound.altitude = o, (ambienceFXSound) -> ambienceFXSound.altitude)).addField( (, ProtocolCodecs.RANGEF), (ambienceFXSound, o) -> ambienceFXSound.frequency = o, (ambienceFXSound) -> ambienceFXSound.frequency)).addField( (, ProtocolCodecs.RANGE), (ambienceFXSound, o) -> ambienceFXSound.radius = o, (ambienceFXSound) -> ambienceFXSound.radius)).afterDecode(AmbienceFXSound::processConfig)).build();
      DEFAULT_FREQUENCY =  (, );
      DEFAULT_RADIUS =  (, );
   }
}

com/hypixel/hytale/server/core/asset/type/ambiencefx/config/AmbienceFXSoundEffect.java

package com.hypixel.hytale.server.core.asset.type.ambiencefx.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.server.core.asset.type.equalizereffect.config.EqualizerEffect;
import com.hypixel.hytale.server.core.asset.type.reverbeffect.config.ReverbEffect;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class AmbienceFXSoundEffect implements NetworkSerializable<com.hypixel.hytale.protocol.AmbienceFXSoundEffect> {
   public static final BuilderCodec<AmbienceFXSoundEffect> CODEC;
   @Nullable
   protected String reverbEffectId;
   protected transient int reverbEffectIndex = 0;
   @Nullable
   protected String equalizerEffectId;
   protected transient int equalizerEffectIndex = 0;
   protected boolean isInstant = false;

   public AmbienceFXSoundEffect(@Nullable String reverbEffectId,  String equalizerEffectId,  isInstant) {
      .reverbEffectId = reverbEffectId;
      .equalizerEffectId = equalizerEffectId;
      .isInstant = isInstant;
   }

     {
   }

      {
       (.reverbEffectId != ) {
         .reverbEffectIndex = ReverbEffect.getAssetMap().getIndex(.reverbEffectId);
      }

       (.equalizerEffectId != ) {
         .equalizerEffectIndex = EqualizerEffect.getAssetMap().getIndex(.equalizerEffectId);
      }

   }

   
    com.hypixel.hytale.protocol.AmbienceFXSoundEffect  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.AmbienceFXSoundEffect();
      packet.reverbEffectIndex = .reverbEffectIndex;
      packet.equalizerEffectIndex = .equalizerEffectIndex;
      packet.isInstant = .isInstant;
       packet;
   }

   
    String  {
       .reverbEffectId;
   }

      {
       .reverbEffectIndex;
   }

   
    String  {
       .equalizerEffectId;
   }

      {
       .equalizerEffectIndex;
   }

      {
       .isInstant;
   }

   
    String  {
        + .reverbEffectId +  + .equalizerEffectId +  + .isInstant + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(AmbienceFXSoundEffect.class, AmbienceFXSoundEffect::).appendInherited( (, Codec.STRING), (ambienceFXSoundEffect, s) -> ambienceFXSoundEffect.reverbEffectId = s, (ambienceFXSoundEffect) -> ambienceFXSoundEffect.reverbEffectId, (ambienceFXSoundEffect, parent) -> ambienceFXSoundEffect.reverbEffectId = parent.reverbEffectId).addValidator(ReverbEffect.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, Codec.STRING), (ambienceFXSoundEffect, s) -> ambienceFXSoundEffect.equalizerEffectId = s, (ambienceFXSoundEffect) -> ambienceFXSoundEffect.equalizerEffectId, (ambienceFXSoundEffect, parent) -> ambienceFXSoundEffect.equalizerEffectId = parent.equalizerEffectId).addValidator(EqualizerEffect.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, Codec.BOOLEAN), (ambienceFXSoundEffect, b) -> ambienceFXSoundEffect.isInstant = b, (ambienceFXSoundEffect) -> ambienceFXSoundEffect.isInstant, (ambienceFXSoundEffect, parent) -> ambienceFXSoundEffect.isInstant = parent.isInstant).add()).afterDecode(AmbienceFXSoundEffect::processConfig)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/attitude/Attitude.java

package com.hypixel.hytale.server.core.asset.type.attitude;

import com.hypixel.hytale.codec.codecs.EnumCodec;
import java.util.function.Supplier;

public enum Attitude implements Supplier<String> {
   IGNORE("is ignoring the target"),
   HOSTILE("is hostile towards the target"),
   NEUTRAL("is neutral towards the target"),
   FRIENDLY("is friendly towards the target"),
   REVERED("reveres the target");

   public static final EnumCodec<Attitude> CODEC = new EnumCodec<Attitude>(Attitude.class);
   public static final Attitude[] VALUES = values();
   private final String description;

   private Attitude(String description) {
      this.description = description;
   }

   public String get() {
      return this.description;
   }
}

com/hypixel/hytale/server/core/asset/type/audiocategory/AudioCategoryPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.audiocategory;

import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateAudioCategories;
import com.hypixel.hytale.server.core.asset.packet.SimpleAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.audiocategory.config.AudioCategory;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class AudioCategoryPacketGenerator extends SimpleAssetPacketGenerator<String, AudioCategory, IndexedLookupTableAssetMap<String, AudioCategory>> {
   public AudioCategoryPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull IndexedLookupTableAssetMap<String, AudioCategory> assetMap, @Nonnull Map<String, AudioCategory> assets) {
      UpdateAudioCategories packet = new UpdateAudioCategories();
      packet.type = UpdateType.Init;
      packet.categories = new Int2ObjectOpenHashMap(assets.size());

      for(Map.Entry<String, AudioCategory> entry : assets.entrySet()) {
         String key = (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.categories.put(index, ((AudioCategory)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.categories =  (loadedAssets.size());

      (Map.Entry<String, AudioCategory> entry : loadedAssets.entrySet()) {
            (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.categories.put(index, ((AudioCategory)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.categories =  (removed.size());

      (String key : removed) {
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.categories.put(index, (Object));
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/audiocategory/config/AudioCategory.java

package com.hypixel.hytale.server.core.asset.type.audiocategory.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditor;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.common.util.AudioUtil;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.lang.ref.SoftReference;
import javax.annotation.Nonnull;

public class AudioCategory implements JsonAssetWithMap<String, IndexedLookupTableAssetMap<String, AudioCategory>>, NetworkSerializable<com.hypixel.hytale.protocol.AudioCategory> {
   public static final int EMPTY_ID = 0;
   public static final String EMPTY = "EMPTY";
   public static      ();
      AssetBuilderCodec<String, AudioCategory> CODEC;
      ValidatorCache<String> VALIDATOR_CACHE;
     AssetStore<String, AudioCategory, IndexedLookupTableAssetMap<String, AudioCategory>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
       AudioUtil.decibelsToLinearGain();
    SoftReference<com.hypixel.hytale.protocol.AudioCategory> cachedPacket;

     AssetStore<String, AudioCategory, IndexedLookupTableAssetMap<String, AudioCategory>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, AudioCategory, IndexedLookupTableAssetMap<String, AudioCategory>>getAssetStore(AudioCategory.class);
      }

       ASSET_STORE;
   }

     IndexedLookupTableAssetMap<String, AudioCategory>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

     {
      .id = id;
   }

     {
   }

    String  {
       .id;
   }

      {
       .volume;
   }

   
    String  {
        + .id +  + .volume + ;
   }

   
    com.hypixel.hytale.protocol.AudioCategory  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.AudioCategory).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.AudioCategory();
         packet.id = .id;
         packet.volume = .volume;

         AudioCategory parent;
         (AssetExtraInfo.   .data; parentData != ; parentData = parent.data) {
               ASSET_STORE.transformKey(parentData.getParentKey());
             (parentKey == ) {
               ;
            }

            parent = (AudioCategory)((IndexedLookupTableAssetMap)ASSET_STORE.getAssetMap()).getAsset(parentKey);
             (parent == ) {
               ;
            }

            packet.volume *= parent.volume;
         }

         .cachedPacket =  (packet);
          packet;
      }
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(AudioCategory.class, AudioCategory::, Codec.STRING, (t, k) -> t.id = k, (t) -> t.id, (asset, data) -> asset.data = data, (asset) -> asset.data).documentation()).appendInherited( (, Codec.FLOAT), (category, f) -> category.volume = AudioUtil.decibelsToLinearGain(f), (category) -> AudioUtil.linearGainToDecibels(category.volume), (category, parent) -> category.volume = parent.volume).metadata( ( .FormattedNumber((Double), , (Integer)))).addValidator(Validators.range(-, )).documentation().add()).build();
      VALIDATOR_CACHE =  <String>( (AudioCategory::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/blockbreakingdecal/BlockBreakingDecalPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.blockbreakingdecal;

import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateBlockBreakingDecals;
import com.hypixel.hytale.server.core.asset.packet.DefaultAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.blockbreakingdecal.config.BlockBreakingDecal;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class BlockBreakingDecalPacketGenerator extends DefaultAssetPacketGenerator<String, BlockBreakingDecal> {
   public BlockBreakingDecalPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull DefaultAssetMap<String, BlockBreakingDecal> assetMap, Map<String, BlockBreakingDecal> assets) {
      UpdateBlockBreakingDecals packet = new UpdateBlockBreakingDecals();
      packet.type = UpdateType.Init;
      packet.blockBreakingDecals = (Map)assetMap.getAssetMap().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, (entry) -> ((BlockBreakingDecal)entry.getValue()).toPacket()));
      return packet;
   }

   @Nonnull
   public Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.blockBreakingDecals = (Map)loadedAssets.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, (entry) -> ((BlockBreakingDecal)entry.getValue()).toPacket()));
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.blockBreakingDecals =  <String, com.hypixel.hytale.protocol.BlockBreakingDecal>();

      (String string : removed) {
         packet.blockBreakingDecals.put(string, (Object));
      }

       ;
   }
}

com/hypixel/hytale/server/core/asset/type/blockbreakingdecal/config/BlockBreakingDecal.java

package com.hypixel.hytale.server.core.asset.type.blockbreakingdecal.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.codec.AssetCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.validator.ArrayValidator;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.util.Arrays;
import javax.annotation.Nonnull;

public class BlockBreakingDecal implements JsonAssetWithMap<String, DefaultAssetMap<String, BlockBreakingDecal>>, NetworkSerializable<com.hypixel.hytale.protocol.BlockBreakingDecal> {
   private static final String[] DEFAULT_STAGE_TEXTURE_LIST = new String[0];
   public static final AssetCodec<String, BlockBreakingDecal> CODEC;
   private static AssetStore<String, BlockBreakingDecal, DefaultAssetMap<String, BlockBreakingDecal>> ASSET_STORE;
   public   ValidatorCache<String> VALIDATOR_CACHE;
    String id;
    AssetExtraInfo.Data data;
    String[] stageTextures;

     AssetStore<String, BlockBreakingDecal, DefaultAssetMap<String, BlockBreakingDecal>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, BlockBreakingDecal, DefaultAssetMap<String, BlockBreakingDecal>>getAssetStore(BlockBreakingDecal.class);
      }

       ASSET_STORE;
   }

     {
      .stageTextures = DEFAULT_STAGE_TEXTURE_LIST;
   }

   
    com.hypixel.hytale.protocol.BlockBreakingDecal  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.BlockBreakingDecal();
      packet.stageTextures = .stageTextures;
       packet;
   }

    String  {
       .id;
   }

   
    String  {
         .id;
        + var10000 +  + String.valueOf(.data) +  + Arrays.toString(.stageTextures) + ;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(BlockBreakingDecal.class, BlockBreakingDecal::, Codec.STRING, (t, k) -> t.id = k, (t) -> t.id, (asset, data) -> asset.data = data, (asset) -> asset.data).append( (, Codec.STRING_ARRAY), (blockSet, strings) -> blockSet.stageTextures = strings, (blockSet) -> blockSet.stageTextures).addValidator( (CommonAssetValidator.TEXTURE_ITEM)).add()).build();
      VALIDATOR_CACHE =  <String>( (BlockBreakingDecal::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/blockhitbox/BlockBoundingBoxes.java

package com.hypixel.hytale.server.core.asset.type.blockhitbox;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.math.shape.Box;
import com.hypixel.hytale.protocol.Hitbox;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.Rotation;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.RotationTuple;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import com.hypixel.hytale.server.core.io.NetworkSerializers;
import java.util.Arrays;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class BlockBoundingBoxes implements JsonAssetWithMap<String, IndexedLookupTableAssetMap<String, BlockBoundingBoxes>>, NetworkSerializable<Hitbox[]> {
   private static final int ROTATIONS;
   public static     ;
         ;
      BlockBoundingBoxes UNIT_BOX;
       UNIT_BOX_MAXIMUM_EXTENT;
      AssetBuilderCodec<String, BlockBoundingBoxes> CODEC;
      ValidatorCache<String> VALIDATOR_CACHE;
      Hitbox[] EMPTY_HITBOXES;
     AssetStore<String, BlockBoundingBoxes, IndexedLookupTableAssetMap<String, BlockBoundingBoxes>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
    Box[] baseDetailBoxes;
   
      RotatedVariantBoxes[] variants;
      protrudesUnitBox;

     AssetStore<String, BlockBoundingBoxes, IndexedLookupTableAssetMap<String, BlockBoundingBoxes>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, BlockBoundingBoxes, IndexedLookupTableAssetMap<String, BlockBoundingBoxes>>getAssetStore(BlockBoundingBoxes.class);
      }

       ASSET_STORE;
   }

     IndexedLookupTableAssetMap<String, BlockBoundingBoxes>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

     {
      .variants =  [ROTATIONS];
   }

     {
      .variants =  [ROTATIONS];
      .id = id;
      .baseDetailBoxes =  []{( ()).setMinMax(min, max)};
      .processConfig();
   }

    String  {
       .id;
   }

      {
       .protrudesUnitBox;
   }

      {
       (.baseDetailBoxes != ) {
         .protrudesUnitBox = ;

         (RotationTuple tuple : RotationTuple.VALUES) {
               tuple.yaw();
               tuple.pitch();
               tuple.roll();
               getRotated(, yaw, pitch, roll);
            .variants[RotationTuple.index(yaw, pitch, roll)] = variant;
            .protrudesUnitBox |= variant.boundingBox.min.x <  || variant.boundingBox.max.x >  || variant.boundingBox.min.y <  || variant.boundingBox.max.y >  || variant.boundingBox.min.z <  || variant.boundingBox.max.z > ;
         }

      }
   }

    RotatedVariantBoxes  {
       .variants[RotationTuple.index(yaw, pitch, roll)];
   }

    RotatedVariantBoxes  {
       .variants[index];
   }

    Hitbox[] toPacket() {
       (.baseDetailBoxes == ) {
          EMPTY_HITBOXES;
      }  {
         Hitbox[] arr =  [.baseDetailBoxes.length];

         (   ; i < .baseDetailBoxes.length; ++i) {
            arr[i] = NetworkSerializers.BOX.toPacket(.baseDetailBoxes[i]);
         }

          arr;
      }
   }

   
    String  {
         String.valueOf(.data);
        + var10000 +  + .id +  + Arrays.toString(.baseDetailBoxes) +  + Arrays.toString(.variants) +  + .protrudesUnitBox + ;
   }

   
     BlockBoundingBoxes  {
        (id, , );
   }

   
     RotatedVariantBoxes  {
      Box[] detailBoxes = boxes.baseDetailBoxes;
      Box[] newDetailBoxes =  [detailBoxes.length];

      (   ; i < detailBoxes.length; ++i) {
         newDetailBoxes[i] = rotate( (detailBoxes[i]), rotationYaw, rotationPitch, rotationRoll);
      }

        (newDetailBoxes);
   }

   
     Box  {
       (rotationRoll) {
          None:
         :
            ;
          Ninety:
            rotate90Z(box);
            ;
          OneEighty:
            rotate180Z(box);
            ;
          TwoSeventy:
            rotate270Z(box);
      }

       (rotationPitch) {
          None:
         :
            ;
          Ninety:
            rotate90X(box);
            ;
          OneEighty:
            rotate180X(box);
            ;
          TwoSeventy:
            rotate270X(box);
      }

       (rotationYaw) {
          None:
         :
            ;
          Ninety:
            rotate90Y(box);
            ;
          OneEighty:
            rotate180Y(box);
            ;
          TwoSeventy:
            rotate270Y(box);
      }

      box.normalize();
       box;
   }

       {
         box.min.z;
      box.min.z = box.min.y;
      box.min.y =  - t;
      t = box.max.z;
      box.max.z = box.max.y;
      box.max.y =  - t;
   }

       {
      box.min.z =  - box.min.z;
      box.min.y =  - box.min.y;
      box.max.z =  - box.max.z;
      box.max.y =  - box.max.y;
   }

       {
         box.min.z;
      box.min.z =  - box.min.y;
      box.min.y = t;
      t = box.max.z;
      box.max.z =  - box.max.y;
      box.max.y = t;
   }

       {
         box.min.x;
      box.min.x = box.min.z;
      box.min.z =  - t;
      t = box.max.x;
      box.max.x = box.max.z;
      box.max.z =  - t;
   }

       {
      box.min.x =  - box.min.x;
      box.min.z =  - box.min.z;
      box.max.x =  - box.max.x;
      box.max.z =  - box.max.z;
   }

       {
         box.min.x;
      box.min.x =  - box.min.z;
      box.min.z = t;
      t = box.max.x;
      box.max.x =  - box.max.z;
      box.max.z = t;
   }

       {
         box.min.x;
      box.min.x = box.min.y;
      box.min.y =  - t;
      t = box.max.x;
      box.max.x = box.max.y;
      box.max.y =  - t;
   }

       {
      box.min.x =  - box.min.x;
      box.min.y =  - box.min.y;
      box.max.x =  - box.max.x;
      box.max.y =  - box.max.y;
   }

       {
         box.min.x;
      box.min.x =  - box.min.y;
      box.min.y = t;
      t = box.max.x;
      box.max.x =  - box.max.y;
      box.max.y = t;
   }

    {
      ROTATIONS = Rotation.VALUES.length * Rotation.VALUES.length * Rotation.VALUES.length;
      UNIT_BOX =  (, , );
      UNIT_BOX_MAXIMUM_EXTENT = UNIT_BOX.variants[].getBoundingBox().getMaximumExtent();
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(BlockBoundingBoxes.class, BlockBoundingBoxes::, Codec.STRING, (blockBoundingBoxes, s) -> blockBoundingBoxes.id = s, (blockBoundingBoxes) -> blockBoundingBoxes.id, (asset, data) -> asset.data = data, (asset) -> asset.data).appendInherited( (,  (Box.CODEC, (x$) ->  [x$]), ), (blockBoundingBoxes, boxes) -> blockBoundingBoxes.baseDetailBoxes = boxes, (blockBoundingBoxes) -> blockBoundingBoxes.baseDetailBoxes, (blockBoundingBoxes, parent) -> blockBoundingBoxes.baseDetailBoxes = parent.baseDetailBoxes).addValidator(Validators.nonEmptyArray()).add()).afterDecode(BlockBoundingBoxes::processConfig)).build();
      VALIDATOR_CACHE =  <String>( (BlockBoundingBoxes::getAssetStore));
      EMPTY_HITBOXES =  [];
   }

       {
       Box boundingBox;
       Box[] detailBoxes;

        {
          (boxes ==  || boxes.length == ) {
            boxes =  []{( ()).setMinMax(, )};
         }

          (boxes.length == ) {
            .boundingBox = boxes[];
         }  {
               .boundingBox =  ();

            (   ; i < boxes.length; ++i) {
               box.union(boxes[i]);
            }
         }

         .detailBoxes = boxes;
      }

      
       Box  {
          .boundingBox;
      }

      
       Box[] getDetailBoxes() {
          .detailBoxes;
      }

         {
          .detailBoxes.length > ;
      }

         {
          (.hasDetailBoxes()) {
            (Box detailBox : .detailBoxes) {
                (detailBox.containsPosition(x, y, z)) {
                   ;
               }
            }

             ;
         }  {
             .boundingBox.containsPosition(x, y, z);
         }
      }
   }
}

com/hypixel/hytale/server/core/asset/type/blockhitbox/BlockBoundingBoxesPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.blockhitbox;

import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.protocol.Hitbox;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateBlockHitboxes;
import com.hypixel.hytale.server.core.asset.packet.SimpleAssetPacketGenerator;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class BlockBoundingBoxesPacketGenerator extends SimpleAssetPacketGenerator<String, BlockBoundingBoxes, IndexedLookupTableAssetMap<String, BlockBoundingBoxes>> {
   public BlockBoundingBoxesPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull IndexedLookupTableAssetMap<String, BlockBoundingBoxes> assetMap, @Nonnull Map<String, BlockBoundingBoxes> assets) {
      UpdateBlockHitboxes packet = new UpdateBlockHitboxes();
      packet.type = UpdateType.Init;
      Map<Integer, Hitbox[]> hitboxes = new Int2ObjectOpenHashMap();

      for(Map.Entry<String, BlockBoundingBoxes> entry : assets.entrySet()) {
         String key = (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         hitboxes.put(index, ((BlockBoundingBoxes)entry.getValue()).toPacket());
      }

      packet.blockBaseHitboxes = hitboxes;
      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      Map<Integer, Hitbox[]> hitboxes =  ();

      (Map.Entry<String, BlockBoundingBoxes> entry : loadedAssets.entrySet()) {
            (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         hitboxes.put(index, ((BlockBoundingBoxes)entry.getValue()).toPacket());
      }

      packet.blockBaseHitboxes = hitboxes;
      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      Map<Integer, Hitbox[]> hitboxes =  ();

      (String key : removed) {
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         hitboxes.put(index, (Object));
      }

      packet.blockBaseHitboxes = hitboxes;
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/blockparticle/BlockParticleSetPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.blockparticle;

import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateBlockParticleSets;
import com.hypixel.hytale.server.core.asset.packet.DefaultAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.blockparticle.config.BlockParticleSet;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class BlockParticleSetPacketGenerator extends DefaultAssetPacketGenerator<String, BlockParticleSet> {
   public BlockParticleSetPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(DefaultAssetMap<String, BlockParticleSet> assetMap, @Nonnull Map<String, BlockParticleSet> assets) {
      UpdateBlockParticleSets packet = new UpdateBlockParticleSets();
      packet.type = UpdateType.Init;
      packet.blockParticleSets = new Object2ObjectOpenHashMap<String, com.hypixel.hytale.protocol.BlockParticleSet>();

      for(Map.Entry<String, BlockParticleSet> entry : assets.entrySet()) {
         packet.blockParticleSets.put((String)entry.getKey(), ((BlockParticleSet)entry.getValue()).toPacket());
      }

      return packet;
   }

   @Nonnull
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.blockParticleSets =  <String, com.hypixel.hytale.protocol.BlockParticleSet>();

      (Map.Entry<String, BlockParticleSet> entry : loadedAssets.entrySet()) {
         packet.blockParticleSets.put((String)entry.getKey(), ((BlockParticleSet)entry.getValue()).toPacket());
      }

       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.blockParticleSets =  <String, com.hypixel.hytale.protocol.BlockParticleSet>();

      (String key : removed) {
         packet.blockParticleSets.put(key, (Object));
      }

       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/blockparticle/config/BlockParticleSet.java

package com.hypixel.hytale.server.core.asset.type.blockparticle.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.map.EnumMapCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIDefaultCollapsedState;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.BlockParticleEvent;
import com.hypixel.hytale.protocol.Color;
import com.hypixel.hytale.protocol.Direction;
import com.hypixel.hytale.protocol.Vector3f;
import com.hypixel.hytale.server.core.asset.type.particle.config.ParticleSystem;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.lang.ref.SoftReference;
import java.util.Map;
import javax.annotation.Nonnull;

public class BlockParticleSet implements JsonAssetWithMap<String, DefaultAssetMap<String, BlockParticleSet>>, NetworkSerializable<com.hypixel.hytale.protocol.BlockParticleSet> {
   public static final AssetBuilderCodec<String, BlockParticleSet> CODEC;
     AssetStore<String, BlockParticleSet, DefaultAssetMap<String, BlockParticleSet>> ASSET_STORE;
      ValidatorCache<String> VALIDATOR_CACHE;
    AssetExtraInfo.Data data;
    String id;
    Color color;
       ;
    Vector3f positionOffset;
    Direction rotationOffset;
    Map<BlockParticleEvent, String> particleSystemIds;
    SoftReference<com.hypixel.hytale.protocol.BlockParticleSet> cachedPacket;

     AssetStore<String, BlockParticleSet, DefaultAssetMap<String, BlockParticleSet>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, BlockParticleSet, DefaultAssetMap<String, BlockParticleSet>>getAssetStore(BlockParticleSet.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, BlockParticleSet>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

     {
      .id = id;
      .color = color;
      .scale = scale;
      .positionOffset = positionOffset;
      .rotationOffset = rotationOffset;
      .particleSystemIds = particleSystemIds;
   }

     {
   }

   
    com.hypixel.hytale.protocol.BlockParticleSet  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.BlockParticleSet).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.BlockParticleSet();
         packet.id = .id;
         packet.color = .color;
         packet.scale = .scale;
         packet.positionOffset = .positionOffset;
         packet.rotationOffset = .rotationOffset;
         packet.particleSystemIds = .particleSystemIds;
         .cachedPacket =  (packet);
          packet;
      }
   }

    String  {
       .id;
   }

    Color  {
       .color;
   }

      {
       .scale;
   }

    Vector3f  {
       .positionOffset;
   }

    Direction  {
       .rotationOffset;
   }

    Map<BlockParticleEvent, String>  {
       .particleSystemIds;
   }

   
    String  {
         .id;
        + var10000 +  + String.valueOf(.color) +  + .scale +  + String.valueOf(.positionOffset) +  + String.valueOf(.rotationOffset) +  + String.valueOf(.particleSystemIds) + ;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(BlockParticleSet.class, BlockParticleSet::, Codec.STRING, (blockParticleSet, s) -> blockParticleSet.id = s, (blockParticleSet) -> blockParticleSet.id, (asset, data) -> asset.data = data, (asset) -> asset.data).documentation()).appendInherited( (, ProtocolCodecs.COLOR), (blockParticleSet, s) -> blockParticleSet.color = s, (blockParticleSet) -> blockParticleSet.color, (blockParticleSet, parent) -> blockParticleSet.color = parent.color).documentation().add()).appendInherited( (, Codec.FLOAT), (blockParticleSet, f) -> blockParticleSet.scale = f, (blockParticleSet) -> blockParticleSet.scale, (blockParticleSet, parent) -> blockParticleSet.scale = parent.scale).documentation().add()).appendInherited( (, ProtocolCodecs.VECTOR3F), (blockParticleSet, s) -> blockParticleSet.positionOffset = s, (blockParticleSet) -> blockParticleSet.positionOffset, (blockParticleSet, parent) -> blockParticleSet.positionOffset = parent.positionOffset).documentation().add()).appendInherited( (, ProtocolCodecs.DIRECTION), (blockParticleSet, s) -> blockParticleSet.rotationOffset = s, (blockParticleSet) -> blockParticleSet.rotationOffset, (blockParticleSet, parent) -> blockParticleSet.rotationOffset = parent.rotationOffset).documentation().add()).appendInherited( (,  (BlockParticleEvent.class, Codec.STRING)), (blockParticleSet, s) -> blockParticleSet.particleSystemIds = s, (blockParticleSet) -> blockParticleSet.particleSystemIds, (blockParticleSet, parent) -> blockParticleSet.particleSystemIds = parent.particleSystemIds).addValidator(Validators.nonNull()).addValidator(ParticleSystem.VALIDATOR_CACHE.getMapValueValidator()).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).build();
      VALIDATOR_CACHE =  <String>( (BlockParticleSet::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/blockset/BlockSetPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.blockset;

import com.hypixel.hytale.assetstore.AssetUpdateQuery;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateBlockSets;
import com.hypixel.hytale.server.core.asset.packet.AssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.blockset.config.BlockSet;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class BlockSetPacketGenerator extends AssetPacketGenerator<String, BlockSet, IndexedLookupTableAssetMap<String, BlockSet>> {
   public BlockSetPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull IndexedLookupTableAssetMap<String, BlockSet> assetMap, Map<String, BlockSet> assets) {
      UpdateBlockSets packet = new UpdateBlockSets();
      packet.type = UpdateType.Init;
      packet.blockSets = (Map)assetMap.getAssetMap().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, (entry) -> ((BlockSet)entry.getValue()).toPacket()));
      return packet;
   }

   @Nonnull
   public Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.blockSets = (Map)loadedAssets.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, (entry) -> ((BlockSet)entry.getValue()).toPacket()));
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.blockSets =  <String, com.hypixel.hytale.protocol.BlockSet>();

      (String string : removed) {
         packet.blockSets.put(string, (Object));
      }

       ;
   }
}

com/hypixel/hytale/server/core/asset/type/blockset/config/BlockSet.java

package com.hypixel.hytale.server.core.asset.type.blockset.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditorSectionStart;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import com.hypixel.hytale.server.core.modules.blockset.BlockSetModule;
import it.unimi.dsi.fastutil.ints.IntSet;
import java.util.Arrays;
import javax.annotation.Nonnull;

/** @deprecated */
@Deprecated(
   forRemoval = true
)
public class BlockSet implements JsonAssetWithMap<String, IndexedLookupTableAssetMap<String, BlockSet>>, NetworkSerializable<com.hypixel.hytale.protocol.BlockSet> {
   public static final AssetBuilderCodec<String, BlockSet> CODEC;
   public static final ValidatorCache<String> VALIDATOR_CACHE;
   private static AssetStore<String, BlockSet, IndexedLookupTableAssetMap<String, BlockSet>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
    String parent;
     includeAll;
    String[] includeBlockTypes;
    String[] excludeBlockTypes;
    String[] includeBlockGroups;
    String[] excludeBlockGroups;
    String[] includeHitboxTypes;
    String[] excludeHitboxTypes;
    String[][] includeCategories;
    String[][] excludeCategories;

     AssetStore<String, BlockSet, IndexedLookupTableAssetMap<String, BlockSet>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, BlockSet, IndexedLookupTableAssetMap<String, BlockSet>>getAssetStore(BlockSet.class);
      }

       ASSET_STORE;
   }

     IndexedLookupTableAssetMap<String, BlockSet>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

     {
      .id = id;
   }

     {
      .id = id;
      .parent = parent;
      .includeAll = includeAll;
      .includeBlockTypes = includeBlockTypes;
      .excludeBlockTypes = excludeBlockTypes;
      .includeBlockGroups = includeBlockGroups;
      .excludeBlockGroups = excludeBlockGroups;
      .includeHitboxTypes = includeHitboxTypes;
      .excludeHitboxTypes = excludeHitboxTypes;
      .includeCategories = includeCategories;
      .excludeCategories = excludeCategories;
   }

     {
   }

    String  {
       .id;
   }

    String  {
       .parent;
   }

      {
       .includeAll;
   }

    String[] getIncludeBlockTypes() {
       .includeBlockTypes;
   }

    String[] getExcludeBlockTypes() {
       .excludeBlockTypes;
   }

    String[] getIncludeBlockGroups() {
       .includeBlockGroups;
   }

    String[] getExcludeBlockGroups() {
       .excludeBlockGroups;
   }

    String[] getIncludeHitboxTypes() {
       .includeHitboxTypes;
   }

    String[] getExcludeHitboxTypes() {
       .excludeHitboxTypes;
   }

    String[][] getIncludeCategories() {
       .includeCategories;
   }

    String[][] getExcludeCategories() {
       .excludeCategories;
   }

   
    String  {
         .id;
        + var10000 +  + .parent +  + .includeAll +  + Arrays.toString(.includeBlockTypes) +  + Arrays.toString(.excludeBlockTypes) +  + Arrays.toString(.includeBlockGroups) +  + Arrays.toString(.excludeBlockGroups) +  + Arrays.toString(.includeHitboxTypes) +  + Arrays.toString(.excludeHitboxTypes) +  + Arrays.deepToString(.includeCategories) +  + Arrays.deepToString(.excludeCategories) + ;
   }

   
    com.hypixel.hytale.protocol.BlockSet  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.BlockSet();
         getAssetMap().getIndex(.id);
         (IntSet)BlockSetModule.getInstance().getBlockSets().get(index);
      packet.name = .id;
      packet.blocks = allBlocks.toIntArray();
       packet;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(BlockSet.class, BlockSet::, Codec.STRING, (t, k) -> t.id = k, (t) -> t.id, (asset, data) -> asset.data = data, (asset) -> asset.data).append( (, Codec.STRING), (blockSet, b) -> blockSet.parent = b, (blockSet) -> blockSet.parent).metadata( ()).add()).addField( (, Codec.BOOLEAN), (blockSet, b) -> blockSet.includeAll = b, (blockSet) -> blockSet.includeAll)).addField( (, Codec.STRING_ARRAY), (blockSet, strings) -> blockSet.includeBlockTypes = strings, (blockSet) -> blockSet.includeBlockTypes)).addField( (, Codec.STRING_ARRAY), (blockSet, strings) -> blockSet.excludeBlockTypes = strings, (blockSet) -> blockSet.excludeBlockTypes)).addField( (, Codec.STRING_ARRAY), (blockSet, strings) -> blockSet.includeBlockGroups = strings, (blockSet) -> blockSet.includeBlockGroups)).addField( (, Codec.STRING_ARRAY), (blockSet, strings) -> blockSet.excludeBlockGroups = strings, (blockSet) -> blockSet.excludeBlockGroups)).addField( (, Codec.STRING_ARRAY), (blockSet, strings) -> blockSet.includeHitboxTypes = strings, (blockSet) -> blockSet.includeHitboxTypes)).addField( (, Codec.STRING_ARRAY), (blockSet, strings) -> blockSet.excludeHitboxTypes = strings, (blockSet) -> blockSet.excludeHitboxTypes)).addField( (,  (Codec.STRING_ARRAY, (x$) ->  [x$][])), (blockSet, strings) -> blockSet.includeCategories = strings, (blockSet) -> blockSet.includeCategories)).addField( (,  (Codec.STRING_ARRAY, (x$) ->  [x$][])), (blockSet, strings) -> blockSet.excludeCategories = strings, (blockSet) -> blockSet.excludeCategories)).build();
      VALIDATOR_CACHE =  <String>( (BlockSet::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/blocksound/BlockSoundSetPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.blocksound;

import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateBlockSoundSets;
import com.hypixel.hytale.server.core.asset.packet.SimpleAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.blocksound.config.BlockSoundSet;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class BlockSoundSetPacketGenerator extends SimpleAssetPacketGenerator<String, BlockSoundSet, IndexedLookupTableAssetMap<String, BlockSoundSet>> {
   public BlockSoundSetPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull IndexedLookupTableAssetMap<String, BlockSoundSet> assetMap, @Nonnull Map<String, BlockSoundSet> assets) {
      UpdateBlockSoundSets packet = new UpdateBlockSoundSets();
      packet.type = UpdateType.Init;
      packet.blockSoundSets = new Int2ObjectOpenHashMap();

      for(Map.Entry<String, BlockSoundSet> entry : assets.entrySet()) {
         String key = (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.blockSoundSets.put(index, ((BlockSoundSet)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.blockSoundSets =  ();

      (Map.Entry<String, BlockSoundSet> entry : loadedAssets.entrySet()) {
            (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.blockSoundSets.put(index, ((BlockSoundSet)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.blockSoundSets =  ();

      (String key : removed) {
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.blockSoundSets.put(index, (Object));
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/blocksound/config/BlockSoundSet.java

package com.hypixel.hytale.server.core.asset.type.blocksound.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.map.EnumMapCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIDefaultCollapsedState;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.math.range.FloatRange;
import com.hypixel.hytale.protocol.BlockSoundEvent;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
import com.hypixel.hytale.server.core.asset.type.soundevent.validator.SoundEventValidators;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import it.unimi.dsi.fastutil.objects.Object2IntMap;
import it.unimi.dsi.fastutil.objects.Object2IntMaps;
import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
import java.lang.ref.SoftReference;
import java.util.Collections;
import java.util.Map;
import javax.annotation.Nonnull;

public class BlockSoundSet implements JsonAssetWithMap<String, IndexedLookupTableAssetMap<String, BlockSoundSet>>, NetworkSerializable<com.hypixel.hytale.protocol.BlockSoundSet> {
         ;
         ;
          (, );
          ();
      AssetBuilderCodec<String, BlockSoundSet> CODEC;
      ValidatorCache<String> VALIDATOR_CACHE;
     AssetStore<String, BlockSoundSet, IndexedLookupTableAssetMap<String, BlockSoundSet>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
    Map<BlockSoundEvent, String> soundEventIds = Collections.emptyMap();
     Object2IntMap<BlockSoundEvent> soundEventIndices = Object2IntMaps.<BlockSoundEvent>emptyMap();
    FloatRange moveInRepeatRange;
    SoftReference<com.hypixel.hytale.protocol.BlockSoundSet> cachedPacket;

     AssetStore<String, BlockSoundSet, IndexedLookupTableAssetMap<String, BlockSoundSet>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, BlockSoundSet, IndexedLookupTableAssetMap<String, BlockSoundSet>>getAssetStore(BlockSoundSet.class);
      }

       ASSET_STORE;
   }

     IndexedLookupTableAssetMap<String, BlockSoundSet>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

     {
      .moveInRepeatRange = DEFAULT_MOVE_IN_REPEAT_RANGE;
      .id = id;
      .soundEventIds = soundEventIds;
   }

     {
      .moveInRepeatRange = DEFAULT_MOVE_IN_REPEAT_RANGE;
      .id = id;
   }

     {
      .moveInRepeatRange = DEFAULT_MOVE_IN_REPEAT_RANGE;
   }

   
    com.hypixel.hytale.protocol.BlockSoundSet  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.BlockSoundSet).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.BlockSoundSet();
         packet.id = .id;
         packet.soundEventIndices = .soundEventIndices;
         packet.moveInRepeatRange =  .hypixel.hytale.protocol.FloatRange(.moveInRepeatRange.getInclusiveMin(), .moveInRepeatRange.getInclusiveMax());
         .cachedPacket =  (packet);
          packet;
      }
   }

    String  {
       .id;
   }

    Map<BlockSoundEvent, String>  {
       .soundEventIds;
   }

    Object2IntMap<BlockSoundEvent>  {
       .soundEventIndices;
   }

    FloatRange  {
       .moveInRepeatRange;
   }

      {
       (!.soundEventIds.isEmpty()) {
         .soundEventIndices =  <BlockSoundEvent>();

         (Map.Entry<BlockSoundEvent, String> entry : .soundEventIds.entrySet()) {
            .soundEventIndices.put((BlockSoundEvent)entry.getKey(), SoundEvent.getAssetMap().getIndex((String)entry.getValue()));
         }
      }

   }

   
    String  {
         .id;
        + var10000 +  + String.valueOf(.soundEventIds) +  + String.valueOf(.soundEventIndices) +  + String.valueOf(.moveInRepeatRange) + ;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(BlockSoundSet.class, BlockSoundSet::, Codec.STRING, (blockSounds, s) -> blockSounds.id = s, (blockSounds) -> blockSounds.id, (asset, data) -> asset.data = data, (asset) -> asset.data).appendInherited( (,  (BlockSoundEvent.class, Codec.STRING)), (blockParticleSet, s) -> blockParticleSet.soundEventIds = s, (blockParticleSet) -> blockParticleSet.soundEventIds, (blockParticleSet, parent) -> blockParticleSet.soundEventIds = parent.soundEventIds).addValidator(Validators.nonNull()).addValidator(SoundEvent.VALIDATOR_CACHE.getMapValueValidator()).addValidator(SoundEventValidators.MONO_VALIDATOR_CACHE.getMapValueValidator()).addValidator(SoundEventValidators.ONESHOT_VALIDATOR_CACHE.getMapValueValidator()).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, FloatRange.CODEC), (blockSounds, f) -> blockSounds.moveInRepeatRange = f, (blockSounds) -> blockSounds.moveInRepeatRange, (blockSounds, parent) -> blockSounds.moveInRepeatRange = parent.moveInRepeatRange).add()).afterDecode(BlockSoundSet::processConfig)).build();
      VALIDATOR_CACHE =  <String>( (BlockSoundSet::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/blocktick/BlockTickManager.java

package com.hypixel.hytale.server.core.asset.type.blocktick;

import java.util.concurrent.atomic.AtomicReference;
import javax.annotation.Nonnull;

/** @deprecated */
@Deprecated(
   forRemoval = true
)
public final class BlockTickManager {
   private static final AtomicReference<IBlockTickProvider> BLOCK_TICK_PROVIDER;

   private BlockTickManager() {
   }

   public static void setBlockTickProvider(@Nonnull IBlockTickProvider provider) {
      BLOCK_TICK_PROVIDER.set(provider);
   }

   @Nonnull
   public static IBlockTickProvider getBlockTickProvider() {
      return (IBlockTickProvider)BLOCK_TICK_PROVIDER.get();
   }

   public static boolean hasBlockTickProvider() {
      return getBlockTickProvider() != IBlockTickProvider.NONE;
   }

   static {
      BLOCK_TICK_PROVIDER = new AtomicReference(IBlockTickProvider.NONE);
   }
}

com/hypixel/hytale/server/core/asset/type/blocktick/BlockTickStrategy.java

package com.hypixel.hytale.server.core.asset.type.blocktick;

public enum BlockTickStrategy {
   CONTINUE,
   IGNORED,
   SLEEP,
   WAIT_FOR_ADJACENT_CHUNK_LOAD;

   private BlockTickStrategy() {
   }
}

com/hypixel/hytale/server/core/asset/type/blocktick/IBlockTickProvider.java

package com.hypixel.hytale.server.core.asset.type.blocktick;

import com.hypixel.hytale.server.core.asset.type.blocktick.config.TickProcedure;
import javax.annotation.Nullable;

@FunctionalInterface
public interface IBlockTickProvider {
   IBlockTickProvider NONE = (blockId) -> null;

   @Nullable
   TickProcedure getTickProcedure(int var1);
}

com/hypixel/hytale/server/core/asset/type/blocktick/config/TickProcedure.java

package com.hypixel.hytale.server.core.asset.type.blocktick.config;

import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.lookup.CodecMapCodec;
import com.hypixel.hytale.server.core.asset.type.blocktick.BlockTickStrategy;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
import java.util.Objects;
import java.util.SplittableRandom;

public abstract class TickProcedure {
   public static final CodecMapCodec<TickProcedure> CODEC = new CodecMapCodec<TickProcedure>("Type");
   public static final BuilderCodec<TickProcedure> BASE_CODEC = BuilderCodec.abstractBuilder(TickProcedure.class).build();
   protected static final SplittableRandom BASE_RANDOM = new SplittableRandom();
   protected static final ThreadLocal<SplittableRandom> RANDOM;

   public TickProcedure() {
   }

   protected SplittableRandom getRandom() {
      return (SplittableRandom)RANDOM.get();
   }

   public abstract BlockTickStrategy ;

    {
         BASE_RANDOM;
      Objects.requireNonNull(var10000);
      RANDOM = ThreadLocal.withInitial(var10000::split);
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/BlockGroupPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.blocktype;

import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateBlockGroups;
import com.hypixel.hytale.server.core.asset.packet.DefaultAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.item.config.BlockGroup;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class BlockGroupPacketGenerator extends DefaultAssetPacketGenerator<String, BlockGroup> {
   public BlockGroupPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull DefaultAssetMap<String, BlockGroup> assetMap, Map<String, BlockGroup> assets) {
      UpdateBlockGroups packet = new UpdateBlockGroups();
      packet.type = UpdateType.Init;
      packet.groups = (Map)assetMap.getAssetMap().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, (entry) -> ((BlockGroup)entry.getValue()).toPacket()));
      return packet;
   }

   @Nonnull
   public Packet generateUpdatePacket( Map<String, BlockGroup> loadedAssets) {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.groups = (Map)loadedAssets.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, (entry) -> ((BlockGroup)entry.getValue()).toPacket()));
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.groups =  <String, com.hypixel.hytale.protocol.BlockGroup>();

      (String string : removed) {
         packet.groups.put(string, (Object));
      }

       ;
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/BlockTypePacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.blocktype;

import com.hypixel.hytale.assetstore.AssetUpdateQuery;
import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
import com.hypixel.hytale.protocol.CachedPacket;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateBlockTypes;
import com.hypixel.hytale.server.core.asset.packet.AssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class BlockTypePacketGenerator extends AssetPacketGenerator<String, BlockType, BlockTypeAssetMap<String, BlockType>> {
   public BlockTypePacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull BlockTypeAssetMap<String, BlockType> assetMap, @Nonnull Map<String, BlockType> assets) {
      UpdateBlockTypes packet = new UpdateBlockTypes();
      packet.type = UpdateType.Init;
      Map<Integer, com.hypixel.hytale.protocol.BlockType> blockTypes = new Int2ObjectOpenHashMap();

      for(Map.Entry<String, BlockType> entry : assets.entrySet()) {
         String   (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         blockTypes.put(index, ((BlockType)entry.getValue()).toPacket());
      }

      packet.blockTypes = blockTypes;
      packet.maxId = assetMap.getNextIndex();
      packet.updateBlockTextures = ;
      packet.updateModels = ;
      packet.updateModelTextures = ;
      packet.updateMapGeometry = ;
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      Map<Integer, com.hypixel.hytale.protocol.BlockType> blockTypes =  ();

      (Map.Entry<String, BlockType> entry : loadedAssets.entrySet()) {
            (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         blockTypes.put(index, ((BlockType)entry.getValue()).toPacket());
      }

      packet.blockTypes = blockTypes;
      packet.maxId = assetMap.getNextIndex();
      AssetUpdateQuery.   query.getRebuildCache();
      packet.updateBlockTextures = rebuildCache.isBlockTextures();
      packet.updateModelTextures = rebuildCache.isModelTextures();
      packet.updateModels = rebuildCache.isModels();
      packet.updateMapGeometry = rebuildCache.isMapGeometry();
       CachedPacket.cache(packet);
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      Map<Integer, com.hypixel.hytale.protocol.BlockType> blockTypes =  ();

      (String key : removed) {
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.BlockType();
         blockType.name = key;
         blockTypes.put(index, blockType);
      }

      packet.blockTypes = blockTypes;
      AssetUpdateQuery.   query.getRebuildCache();
      packet.updateBlockTextures = rebuildCache.isBlockTextures();
      packet.updateModels = rebuildCache.isModels();
      packet.updateModelTextures = rebuildCache.isModelTextures();
      packet.updateMapGeometry = rebuildCache.isMapGeometry();
       CachedPacket.cache(packet);
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/BlockBreakingDropType.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.BlockBreaking;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemDropList;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;

public class BlockBreakingDropType implements NetworkSerializable<BlockBreaking> {
   public static final BuilderCodec<BlockBreakingDropType> CODEC;
   protected String gatherType;
   protected int quality;
   protected String itemId;
   protected String dropListId;
   protected int quantity = 1;

   public BlockBreakingDropType(String gatherType, int quality, int quantity, String itemId, String dropListId) {
      this.gatherType = gatherType;
      this.quality = quality;
      this.quantity = quantity;
      this.itemId = itemId;
      this.dropListId = dropListId;
   }

   protected  {
   }

   
    BlockBreaking  {
          ();
      packet.gatherType = .gatherType;
      packet.quality = .quality;
      packet.quantity = .quantity;
       (.itemId != ) {
         packet.itemId = .itemId.toString();
      }

      packet.dropListId = .dropListId;
       packet;
   }

    String  {
       .gatherType;
   }

      {
       .quality;
   }

      {
       .quantity;
   }

    String  {
       .itemId;
   }

    String  {
       .dropListId;
   }

   
    BlockBreakingDropType  {
        (.gatherType, , , (String), (String));
   }

   
    String  {
        + .gatherType +  + .quality +  + .quantity +  + .itemId +  + .dropListId + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(BlockBreakingDropType.class, BlockBreakingDropType::).append( (, Codec.STRING), (blockBreaking, s) -> blockBreaking.gatherType = s, (blockBreaking) -> blockBreaking.gatherType).add()).append( (, Codec.INTEGER), (blockBreaking, s) -> blockBreaking.quality = s, (blockBreaking) -> blockBreaking.quality).add()).append( (, Codec.STRING), (blockBreaking, s) -> blockBreaking.itemId = s, (blockBreaking) -> blockBreaking.itemId).addValidatorLate(() -> Item.VALIDATOR_CACHE.getValidator().late()).add()).append( (, Codec.INTEGER), (blockBreaking, s) -> blockBreaking.quantity = s, (blockBreaking) -> blockBreaking.quantity).add()).append( (,  (ItemDropList.class, ItemDropList.CODEC)), (blockBreaking, s) -> blockBreaking.dropListId = s, (blockBreaking) -> blockBreaking.dropListId).addValidatorLate(() -> ItemDropList.VALIDATOR_CACHE.getValidator().late()).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/BlockFace.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.math.vector.Vector3i;
import com.hypixel.hytale.protocol.BlockNeighbor;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.util.Map;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public enum BlockFace {
   UP(BlockFace.FaceConnectionType.FLIP, BlockNeighbor.Up, Vector3i.UP),
   DOWN(BlockFace.FaceConnectionType.FLIP, BlockNeighbor.Down, Vector3i.DOWN),
   NORTH(BlockFace.FaceConnectionType.FLIP, BlockNeighbor.North, Vector3i.NORTH),
   EAST(BlockFace.FaceConnectionType.FLIP, BlockNeighbor.East, Vector3i.EAST),
   SOUTH(BlockFace.FaceConnectionType.FLIP, BlockNeighbor.South, Vector3i.SOUTH),
   WEST(BlockFace.FaceConnectionType.FLIP, BlockNeighbor.West, Vector3i.WEST),
   UP_NORTH(BlockFace.FaceConnectionType.ROTATE_X, BlockNeighbor.UpNorth, new BlockFace[]{UP, NORTH}),
   UP_SOUTH(BlockFace.FaceConnectionType.ROTATE_X, BlockNeighbor.UpSouth, new BlockFace[]{UP, SOUTH}),
   UP_EAST(BlockFace.FaceConnectionType.ROTATE_Z, BlockNeighbor.UpEast, new BlockFace[]{UP, EAST}),
   UP_WEST(BlockFace.FaceConnectionType.ROTATE_Z, BlockNeighbor.UpWest, new BlockFace[]{UP, WEST}),
   DOWN_NORTH(BlockFace.FaceConnectionType.ROTATE_X, BlockNeighbor.DownNorth, new BlockFace[]{DOWN, NORTH}),
   DOWN_SOUTH(BlockFace.FaceConnectionType.ROTATE_X, BlockNeighbor.DownSouth, new BlockFace[]{DOWN, SOUTH}),
   DOWN_EAST(BlockFace.FaceConnectionType.ROTATE_Z, BlockNeighbor.DownEast, new BlockFace[]{DOWN, EAST}),
   DOWN_WEST(BlockFace.FaceConnectionType.ROTATE_Z, BlockNeighbor.DownWest, new BlockFace[]{DOWN, WEST}),
   NORTH_EAST(BlockFace.FaceConnectionType.ROTATE_Y, BlockNeighbor.NorthEast,  []{NORTH, EAST}),
   SOUTH_EAST(BlockFace.FaceConnectionType.ROTATE_Y, BlockNeighbor.SouthEast,  []{SOUTH, EAST}),
   SOUTH_WEST(BlockFace.FaceConnectionType.ROTATE_Y, BlockNeighbor.SouthWest,  []{SOUTH, WEST}),
   NORTH_WEST(BlockFace.FaceConnectionType.ROTATE_Y, BlockNeighbor.NorthWest,  []{NORTH, WEST}),
   UP_NORTH_EAST(BlockFace.FaceConnectionType.ROTATE_ALL, BlockNeighbor.UpNorthEast,  []{UP, NORTH, EAST}),
   UP_SOUTH_EAST(BlockFace.FaceConnectionType.ROTATE_ALL, BlockNeighbor.UpSouthEast,  []{UP, SOUTH, EAST}),
   UP_SOUTH_WEST(BlockFace.FaceConnectionType.ROTATE_ALL, BlockNeighbor.UpSouthWest,  []{UP, SOUTH, WEST}),
   UP_NORTH_WEST(BlockFace.FaceConnectionType.ROTATE_ALL, BlockNeighbor.UpNorthWest,  []{UP, NORTH, WEST}),
   DOWN_NORTH_EAST(BlockFace.FaceConnectionType.ROTATE_ALL, BlockNeighbor.DownNorthEast,  []{DOWN, NORTH, EAST}),
   DOWN_SOUTH_EAST(BlockFace.FaceConnectionType.ROTATE_ALL, BlockNeighbor.DownSouthEast,  []{DOWN, SOUTH, EAST}),
   DOWN_SOUTH_WEST(BlockFace.FaceConnectionType.ROTATE_ALL, BlockNeighbor.DownSouthWest,  []{DOWN, SOUTH, WEST}),
   DOWN_NORTH_WEST(BlockFace.FaceConnectionType.ROTATE_ALL, BlockNeighbor.DownNorthWest,  []{DOWN, NORTH, WEST});

      EnumCodec<BlockFace> CODEC =  <BlockFace>(BlockFace.class);
      BlockFace[] VALUES = values();
   
      Map<Vector3i, BlockFace> DIRECTION_MAP =  <Vector3i, BlockFace>();
     FaceConnectionType faceConnectionType;
   
     BlockFace[] components;
     Vector3i direction;
     BlockNeighbor blockNeighbor;
    BlockFace[] connectingFaces;
    Vector3i[] connectingFaceOffsets;

     {
      .faceConnectionType = faceConnectionType;
      .direction = direction;
      .blockNeighbor = blockNeighbor;
      .components =  [];
   }

     {
      .faceConnectionType = faceConnectionType;
      .components = components;

      (BlockFace component : components) {
          (component.components.length > ) {
              ();
         }
      }

      .direction =  ();

      (BlockFace component : components) {
         .direction.add(component.direction);
      }

      .blockNeighbor = blockNeighbor;
   }

    FaceConnectionType  {
       .faceConnectionType;
   }

   
    BlockFace[] getComponents() {
       .components;
   }

    Vector3i  {
       .direction;
   }

    BlockFace[] getConnectingFaces() {
       .connectingFaces;
   }

    Vector3i[] getConnectingFaceOffsets() {
       .connectingFaceOffsets;
   }

   
    BlockFace[] getConnectingFaces0() {
       (.faceConnectionType.ordinal()) {
          :
              []{flip()};
          :
            BlockFace[] blockFaces =  [];
            blockFaces[] = rotate(, Rotation.Ninety, Rotation.None, Rotation.None);
            blockFaces[] = rotate(, Rotation.OneEighty, Rotation.None, Rotation.None);
            blockFaces[] = rotate(, Rotation.TwoSeventy, Rotation.None, Rotation.None);
             blockFaces;
          :
            BlockFace[] blockFaces =  [];
            blockFaces[] = rotate(, Rotation.None, Rotation.Ninety, Rotation.None);
            blockFaces[] = rotate(, Rotation.None, Rotation.OneEighty, Rotation.None);
            blockFaces[] = rotate(, Rotation.None, Rotation.TwoSeventy, Rotation.None);
             blockFaces;
          :
            BlockFace[] blockFaces =  [];
            blockFaces[] = rotate(, Rotation.None, Rotation.None, Rotation.Ninety);
            blockFaces[] = rotate(, Rotation.None, Rotation.None, Rotation.OneEighty);
            blockFaces[] = rotate(, Rotation.None, Rotation.None, Rotation.TwoSeventy);
             blockFaces;
          :
            BlockFace[] blockFaces =  [];
            blockFaces[] = rotate(, Rotation.Ninety, Rotation.None, Rotation.None);
            blockFaces[] = rotate(, Rotation.OneEighty, Rotation.None, Rotation.None);
            blockFaces[] = rotate(, Rotation.None, Rotation.Ninety, Rotation.None);
            blockFaces[] = rotate(, Rotation.None, Rotation.OneEighty, Rotation.None);
            blockFaces[] = rotate(, Rotation.None, Rotation.TwoSeventy, Rotation.None);
            blockFaces[] = rotate(, Rotation.None, Rotation.None, Rotation.OneEighty);
            blockFaces[] = flip();
             blockFaces;
         :
              ( + String.valueOf(.faceConnectionType));
      }
   }

   
    Vector3i  {
          ();
       (.direction.getX() == -connectingFace.direction.getX()) {
         vector3i.setX(.direction.getX());
      }

       (.direction.getY() == -connectingFace.direction.getY()) {
         vector3i.setY(.direction.getY());
      }

       (.direction.getZ() == -connectingFace.direction.getZ()) {
         vector3i.setZ(.direction.getZ());
      }

       vector3i;
   }

     BlockFace  {
       (BlockFace)DIRECTION_MAP.get(direction);
   }

     BlockFace  {
         Rotation.rotate(blockFace.direction, rotationYaw, rotationPitch);
       lookup(rotate);
   }

     BlockFace  {
         Rotation.rotate(blockFace.direction, rotationX, rotationY, rotationZ);
       lookup(rotate);
   }

     BlockFace  {
         blockFace.direction.clone().scale(-);
       lookup(flipped);
   }

    BlockNeighbor  {
       .blockNeighbor;
   }

   
     BlockFace  {
      BlockFace var10000;
       (face) {
          Up -> var10000 = UP;
          Down -> var10000 = DOWN;
          North -> var10000 = NORTH;
          South -> var10000 = SOUTH;
          East -> var10000 = EAST;
          West -> var10000 = WEST;
          None -> var10000 = ;
          ->   ((String), (Throwable));
      }

       var10000;
   }

   
     com.hypixel.hytale.protocol.BlockFace  {
       (face == ) {
          com.hypixel.hytale.protocol.BlockFace.None;
      }  {
         com.hypixel.hytale.protocol.BlockFace var10000;
          (face.ordinal()) {
              -> var10000 = com.hypixel.hytale.protocol.BlockFace.Up;
              -> var10000 = com.hypixel.hytale.protocol.BlockFace.Down;
              -> var10000 = com.hypixel.hytale.protocol.BlockFace.North;
              -> var10000 = com.hypixel.hytale.protocol.BlockFace.East;
              -> var10000 = com.hypixel.hytale.protocol.BlockFace.South;
              -> var10000 = com.hypixel.hytale.protocol.BlockFace.West;
             ->   ();
         }

          var10000;
      }
   }

    {
      (BlockFace blockFace : VALUES) {
         DIRECTION_MAP.put(blockFace.direction, blockFace);
      }

      (BlockFace blockFace : VALUES) {
         blockFace.connectingFaces = blockFace.getConnectingFaces0();
         blockFace.connectingFaceOffsets =  [blockFace.connectingFaces.length];

         (   ; i < blockFace.connectingFaces.length; ++i) {
            blockFace.connectingFaceOffsets[i] = blockFace.directionTo(blockFace.connectingFaces[i]);
         }
      }

   }

      {
      FLIP,
      ROTATE_X,
      ROTATE_Y,
      ROTATE_Z,
      ROTATE_ALL;

        {
      }
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/BlockFaceSupport.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.common.util.ArrayUtil;
import com.hypixel.hytale.math.vector.Vector3i;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.util.Arrays;
import javax.annotation.Nonnull;

public class BlockFaceSupport implements NetworkSerializable<com.hypixel.hytale.protocol.BlockFaceSupport> {
   public static final BuilderCodec<BlockFaceSupport> CODEC;
   public static final BlockFaceSupport ALL;
   public static final String FULL_SUPPORTING_FACE = "Full";
   protected String faceType = "Full";
   protected Vector3i[] filler;

   public BlockFaceSupport() {
   }

   public BlockFaceSupport(String faceType, Vector3i[] filler) {
      this.faceType = faceType;
      this.filler = filler;
   }

    String  {
       .faceType;
   }

    Vector3i[] getFiller() {
       .filler;
   }

      {
       .filler ==  || ArrayUtil.contains(.filler, filler);
   }

   
    String  {
         .faceType;
        + var10000 +  + Arrays.toString(.filler) + ;
   }

   
     BlockFaceSupport  {
       (original == ALL) {
          ALL;
      }  {
         Vector3i[] rotatedFiller = (Vector3i[])ArrayUtil.copyAndMutate(original.filler, (vector) -> Rotation.rotate(vector, rotationYaw, rotationPitch, roll), (x$) ->  [x$]);
           (original.faceType, rotatedFiller);
      }
   }

   
    com.hypixel.hytale.protocol.BlockFaceSupport  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.BlockFaceSupport();
      protocolBlockFaceSupport.faceType = .faceType;
       (.filler != ) {
         com.hypixel.hytale.protocol.Vector3i[] filler =  .hypixel.hytale.protocol.Vector3i[.filler.length];

         (   ; j < .filler.length; ++j) {
               .filler[j];
            filler[j] =  .hypixel.hytale.protocol.Vector3i(fillerVector.x, fillerVector.y, fillerVector.z);
         }

         protocolBlockFaceSupport.filler = filler;
      }

       protocolBlockFaceSupport;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(BlockFaceSupport.class, BlockFaceSupport::).append( (, Codec.STRING), (blockFaceSupport, s) -> blockFaceSupport.faceType = s, (blockFaceSupport) -> blockFaceSupport.faceType).add()).documentation()).append( (,  (Vector3i.CODEC, (x$) ->  [x$])), (blockFaceSupport, o) -> blockFaceSupport.filler = o, (blockFaceSupport) -> blockFaceSupport.filler).add()).build();
      ALL =  ();
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/BlockFlipType.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.math.Axis;
import javax.annotation.Nonnull;

public enum BlockFlipType {
   ORTHOGONAL,
   SYMMETRIC;

   private BlockFlipType() {
   }

   public Rotation flipYaw(@Nonnull Rotation rotation, Axis axis) {
      if (axis == Axis.Y) {
         return rotation;
      } else {
         switch (this.ordinal()) {
            case 0:
               int multiplier = axis == rotation.getAxisOfAlignment() ? -1 : 1;
               int index = rotation.ordinal() + multiplier + Rotation.VALUES.length;
               index %= Rotation.VALUES.length;
               return Rotation.VALUES[index];
            case 1:
               if (rotation.getAxisOfAlignment() == axis) {
                  return rotation.add(Rotation.OneEighty);
               }

               return rotation;
            default:
               throw new UnsupportedOperationException();
         }
      }
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/BlockGathering.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.schema.metadata.AllowEmptyObject;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemDropList;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.util.Collections;
import java.util.Map;
import javax.annotation.Nonnull;

public class BlockGathering implements NetworkSerializable<com.hypixel.hytale.protocol.BlockGathering> {
   public static final BuilderCodec<BlockGathering> CODEC;
   protected BlockBreakingDropType breaking;
   protected HarvestingDropType harvest;
   protected SoftBlockDropType soft;
   protected PhysicsDropType physics;
   protected BlockToolData[] toolDataRaw;
   @Nonnull
   protected Map<String, BlockToolData> toolData = Collections.emptyMap();
   protected boolean useDefaultDropWhenPlaced = false;

   protected BlockGathering {
   }

   
    com.hypixel.hytale.protocol.BlockGathering  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.BlockGathering();
       (.breaking != ) {
         packet.breaking = .breaking.toPacket();
      }

       (.harvest != ) {
         packet.harvest = .harvest.toPacket();
      }

       (.soft != ) {
         packet.soft = .soft.toPacket();
      }

       packet;
   }

    BlockBreakingDropType  {
       .breaking;
   }

    HarvestingDropType  {
       .harvest;
   }

    SoftBlockDropType  {
       .soft;
   }

      {
       .harvest != ;
   }

      {
       .soft != ;
   }

    PhysicsDropType  {
       .physics;
   }

      {
       .useDefaultDropWhenPlaced;
   }

   
    String  {
         String.valueOf(.breaking);
        + var10000 +  + String.valueOf(.harvest) +  + String.valueOf(.soft) + ;
   }

   
    Map<String, BlockToolData>  {
       .toolData;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(BlockGathering.class, BlockGathering::).append( (, BlockBreakingDropType.CODEC), (blockGathering, o) -> blockGathering.breaking = o, (blockGathering) -> blockGathering.breaking).metadata(AllowEmptyObject.INSTANCE).add()).append( (, HarvestingDropType.CODEC), (blockGathering, o) -> blockGathering.harvest = o, (blockGathering) -> blockGathering.harvest).metadata(AllowEmptyObject.INSTANCE).add()).append( (, SoftBlockDropType.CODEC), (blockGathering, o) -> blockGathering.soft = o, (blockGathering) -> blockGathering.soft).metadata(AllowEmptyObject.INSTANCE).add()).append( (, PhysicsDropType.CODEC), (blockGathering, o) -> blockGathering.physics = o, (blockGathering) -> blockGathering.physics).metadata(AllowEmptyObject.INSTANCE).add()).append( (,  (BlockGathering.BlockToolData.CODEC, (x$) ->  [x$])), (blockGathering, o) -> blockGathering.toolDataRaw = o, (blockGathering) -> blockGathering.toolDataRaw).metadata(AllowEmptyObject.INSTANCE).add()).appendInherited( (, Codec.BOOLEAN), (o, v) -> o.useDefaultDropWhenPlaced = v, (o) -> o.useDefaultDropWhenPlaced, (o, p) -> o.useDefaultDropWhenPlaced = p.useDefaultDropWhenPlaced).documentation().add()).afterDecode((g) -> {
          (g.toolDataRaw != ) {
            g.toolData =  <String, BlockToolData>();

            (BlockToolData t : g.toolDataRaw) {
               g.toolData.put(t.getTypeId(), t);
            }
         }

      })).build();
   }

       {
         BuilderCodec<BlockToolData> CODEC;
       String typeId;
       String stateId;
       String itemId;
       String dropListId;

        {
      }

       String  {
          .typeId;
      }

       String  {
          .stateId;
      }

       String  {
          .itemId;
      }

       String  {
          .dropListId;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(BlockToolData.class, BlockToolData::).append( (, Codec.STRING), (toolData, o) -> toolData.typeId = o, (toolData) -> toolData.typeId).metadata(AllowEmptyObject.INSTANCE).add()).append( (, Codec.STRING), (toolData, o) -> toolData.stateId = o, (toolData) -> toolData.stateId).metadata(AllowEmptyObject.INSTANCE).add()).append( (, Codec.STRING), (toolData, s) -> toolData.itemId = s, (toolData) -> toolData.itemId).addValidatorLate(() -> Item.VALIDATOR_CACHE.getValidator().late()).add()).append( (,  (ItemDropList.class, ItemDropList.CODEC)), (toolData, s) -> toolData.dropListId = s, (toolData) -> toolData.dropListId).addValidatorLate(() -> ItemDropList.VALIDATOR_CACHE.getValidator().late()).add()).build();
      }
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/BlockMigration.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.StringIntegerCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.Nonnull;

public class BlockMigration implements JsonAssetWithMap<Integer, DefaultAssetMap<Integer, BlockMigration>> {
   public static final AssetBuilderCodec<Integer, BlockMigration> CODEC;
   private static DefaultAssetMap<Integer, BlockMigration> ASSET_MAP;
   protected AssetExtraInfo.Data data;
   protected int id;
   protected Map<String, String> directMigrations = Collections.emptyMap();
   protected Map<String, String> nameMigrations = Collections.emptyMap();

   public static DefaultAssetMap<Integer, BlockMigration> getAssetMap() {
      if (ASSET_MAP == null) {
         ASSET_MAP = (DefaultAssetMap)AssetRegistry.getAssetStore(BlockMigration.class).getAssetMap();
      }

       ASSET_MAP;
   }

     {
      .id = id;
      .directMigrations = directMigrations;
      .nameMigrations = nameMigrations;
   }

     {
   }

   
    Integer  {
       .id;
   }

   
    String  {
         (String).directMigrations.get(blockTypeKey);
       (direct != ) {
          direct;
      }  {
            (String).nameMigrations.get(blockTypeKey);
          name !=  ? name : blockTypeKey;
      }
   }

    String  {
       (String).directMigrations.getOrDefault(blockTypeKey, blockTypeKey);
   }

    String  {
       (String).nameMigrations.getOrDefault(blockTypeKey, blockTypeKey);
   }

    Map<String, String>  {
       .directMigrations;
   }

    Map<String, String>  {
       .nameMigrations;
   }

   
    String  {
         .id;
        + var10000 +  + String.valueOf(.directMigrations) +  + String.valueOf(.nameMigrations) + ;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(BlockMigration.class, BlockMigration::,  (), (blockMigration, i) -> blockMigration.id = i, (blockMigration) -> blockMigration.id, (asset, data) -> asset.data = data, (asset) -> asset.data).addField( (,  (Codec.STRING, HashMap::)), (blockMigration, document) -> blockMigration.directMigrations = document, (blockMigration) -> blockMigration.directMigrations)).addField( (,  (Codec.STRING, HashMap::)), (blockMigration, document) -> blockMigration.nameMigrations = document, (blockMigration) -> blockMigration.nameMigrations)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/BlockMovementSettings.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;

public class BlockMovementSettings implements NetworkSerializable<com.hypixel.hytale.protocol.BlockMovementSettings> {
   public static final BuilderCodec<BlockMovementSettings> CODEC;
   private boolean isClimbable;
   private boolean isBouncy;
   private float bounceVelocity;
   private float drag = 0.82F;
   private float friction = 0.18F;
   private float climbUpSpeedMultiplier = 1.0F;
   private float climbDownSpeedMultiplier = 1.0F;
   private float climbLateralSpeedMultiplier = 1.0F;
   private    ;
       ;
       ;

     {
      .isClimbable = isClimbable;
      .isBouncy = isBouncy;
      .bounceVelocity = bounceVelocity;
      .climbUpSpeedMultiplier = climbUpSpeed;
      .climbDownSpeedMultiplier = climbDownSpeed;
      .climbLateralSpeedMultiplier = climbLateralSpeedMultiplier;
      .drag = drag;
      .friction = friction;
      .terminalVelocityModifier = terminalVelocityModifier;
      .horizontalSpeedMultiplier = horizontalSpeedMultiplier;
      .jumpForceMultiplier = jumpForceMultiplier;
   }

     {
   }

   
    com.hypixel.hytale.protocol.BlockMovementSettings  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.BlockMovementSettings();
      packet.isClimbable = .isClimbable;
      packet.isBouncy = .isBouncy;
      packet.bounceVelocity = .bounceVelocity;
      packet.climbUpSpeedMultiplier = .climbUpSpeedMultiplier;
      packet.climbDownSpeedMultiplier = .climbDownSpeedMultiplier;
      packet.climbLateralSpeedMultiplier = .climbLateralSpeedMultiplier;
      packet.drag = .drag;
      packet.friction = .friction;
      packet.terminalVelocityModifier = .terminalVelocityModifier;
      packet.horizontalSpeedMultiplier = .horizontalSpeedMultiplier;
      packet.jumpForceMultiplier = .jumpForceMultiplier;
       packet;
   }

      {
       .isClimbable;
   }

      {
       .isBouncy;
   }

      {
       .bounceVelocity;
   }

      {
       .drag;
   }

      {
       .friction;
   }

      {
       .climbUpSpeedMultiplier;
   }

      {
       .climbDownSpeedMultiplier;
   }

      {
       .climbLateralSpeedMultiplier;
   }

      {
       .terminalVelocityModifier;
   }

      {
       .horizontalSpeedMultiplier;
   }

      {
       .jumpForceMultiplier;
   }

   
    String  {
        + .isClimbable +  + .isBouncy +  + .bounceVelocity +  + .climbUpSpeedMultiplier +  + .climbDownSpeedMultiplier +  + .climbLateralSpeedMultiplier +  + .drag +  + .friction +  + .terminalVelocityModifier +  + .horizontalSpeedMultiplier +  + .jumpForceMultiplier + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(BlockMovementSettings.class, BlockMovementSettings::).append( (, Codec.BOOLEAN), (blockMovementSettings, o) -> blockMovementSettings.isClimbable = o, (blockMovementSettings) -> blockMovementSettings.isClimbable).add()).append( (, Codec.BOOLEAN), (blockMovementSettings, o) -> blockMovementSettings.isBouncy = o, (blockMovementSettings) -> blockMovementSettings.isBouncy).add()).append( (, Codec.FLOAT), (blockMovementSettings, o) -> blockMovementSettings.bounceVelocity = o, (blockMovementSettings) -> blockMovementSettings.bounceVelocity).add()).append( (, Codec.FLOAT), (blockMovementSettings, o) -> blockMovementSettings.climbUpSpeedMultiplier = o, (blockMovementSettings) -> blockMovementSettings.climbUpSpeedMultiplier).add()).append( (, Codec.FLOAT), (blockMovementSettings, o) -> blockMovementSettings.climbDownSpeedMultiplier = o, (blockMovementSettings) -> blockMovementSettings.climbDownSpeedMultiplier).add()).append( (, Codec.FLOAT), (blockMovementSettings, o) -> blockMovementSettings.climbLateralSpeedMultiplier = o, (blockMovementSettings) -> blockMovementSettings.climbLateralSpeedMultiplier).add()).append( (, Codec.FLOAT), (blockMovementSettings, o) -> blockMovementSettings.drag = o, (blockMovementSettings) -> blockMovementSettings.drag).add()).append( (, Codec.FLOAT), (blockMovementSettings, o) -> blockMovementSettings.friction = o, (blockMovementSettings) -> blockMovementSettings.friction).add()).append( (, Codec.FLOAT), (blockMovementSettings, o) -> blockMovementSettings.terminalVelocityModifier = o, (blockMovementSettings) -> blockMovementSettings.terminalVelocityModifier).add()).append( (, Codec.FLOAT), (blockMovementSettings, o) -> blockMovementSettings.horizontalSpeedMultiplier = o, (blockMovementSettings) -> blockMovementSettings.horizontalSpeedMultiplier).add()).append( (, Codec.FLOAT), (blockMovementSettings, o) -> blockMovementSettings.jumpForceMultiplier = o, (blockMovementSettings) -> blockMovementSettings.jumpForceMultiplier).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/BlockPlacementSettings.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.protocol.BlockPlacementRotationMode;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;

public class BlockPlacementSettings implements NetworkSerializable<com.hypixel.hytale.protocol.BlockPlacementSettings> {
   public static final BuilderCodec<BlockPlacementSettings> CODEC;
   protected String wallPlacementOverrideBlockId;
   protected String floorPlacementOverrideBlockId;
   protected String ceilingPlacementOverrideBlockId;
   private boolean allowRotationKey = true;
   private boolean placeInEmptyBlocks;
   private BlockPreviewVisibility previewVisibility;
   private RotationMode rotationMode;

   protected BlockPlacementSettings() {
      this.previewVisibility = BlockPlacementSettings.BlockPreviewVisibility.DEFAULT;
      this.rotationMode = BlockPlacementSettings.RotationMode.DEFAULT;
   }

   @Nonnull
   public com.hypixel.hytale.protocol.BlockPlacementSettings toPacket() {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.BlockPlacementSettings();
      packet.allowRotationKey = .allowRotationKey;
      packet.placeInEmptyBlocks = .placeInEmptyBlocks;
         .previewVisibility;
         ;
      com.hypixel.hytale.protocol.BlockPreviewVisibility var10001;
      
       (var2.typeSwitch<invokedynamic>(var2, var3)) {
          - -> var10001 = com.hypixel.hytale.protocol.BlockPreviewVisibility.Default;
           -> var10001 = com.hypixel.hytale.protocol.BlockPreviewVisibility.Default;
           -> var10001 = com.hypixel.hytale.protocol.BlockPreviewVisibility.AlwaysHidden;
           -> var10001 = com.hypixel.hytale.protocol.BlockPreviewVisibility.AlwaysVisible;
          ->   ((String), (Throwable));
      }

      packet.previewVisibility = var10001;
         .rotationMode;
      var3 = ;
      BlockPlacementRotationMode var6;
      
       (var4.typeSwitch<invokedynamic>(var4, var3)) {
          - -> var6 = BlockPlacementRotationMode.Default;
           -> var6 = BlockPlacementRotationMode.Default;
           -> var6 = BlockPlacementRotationMode.FacingPlayer;
           -> var6 = BlockPlacementRotationMode.StairFacingPlayer;
           -> var6 = BlockPlacementRotationMode.BlockNormal;
          ->   ((String), (Throwable));
      }

      packet.rotationMode = var6;
      packet.wallPlacementOverrideBlockId = .wallPlacementOverrideBlockId ==  ? - : BlockType.getAssetMap().getIndex(.wallPlacementOverrideBlockId);
       (packet.wallPlacementOverrideBlockId == -) {
           ( + .wallPlacementOverrideBlockId);
      }  {
         packet.floorPlacementOverrideBlockId = .floorPlacementOverrideBlockId ==  ? - : BlockType.getAssetMap().getIndex(.floorPlacementOverrideBlockId);
          (packet.floorPlacementOverrideBlockId == -) {
              ( + .floorPlacementOverrideBlockId);
         }  {
            packet.ceilingPlacementOverrideBlockId = .ceilingPlacementOverrideBlockId ==  ? - : BlockType.getAssetMap().getIndex(.ceilingPlacementOverrideBlockId);
             (packet.ceilingPlacementOverrideBlockId == -) {
                 ( + .ceilingPlacementOverrideBlockId);
            }  {
                packet;
            }
         }
      }
   }

    String  {
       .wallPlacementOverrideBlockId;
   }

    String  {
       .floorPlacementOverrideBlockId;
   }

    String  {
       .ceilingPlacementOverrideBlockId;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(BlockPlacementSettings.class, BlockPlacementSettings::).append( (, Codec.BOOLEAN), (placementSettings, o) -> placementSettings.allowRotationKey = o, (placementSettings) -> placementSettings.allowRotationKey).add()).append( (, Codec.BOOLEAN), (placementSettings, o) -> placementSettings.placeInEmptyBlocks = o, (placementSettings) -> placementSettings.placeInEmptyBlocks).documentation().add()).append( (, BlockPlacementSettings.RotationMode.CODEC), (placementSettings, o) -> placementSettings.rotationMode = o, (placementSettings) -> placementSettings.rotationMode).documentation().add()).append( (, BlockPlacementSettings.BlockPreviewVisibility.CODEC), (placementSettings, o) -> placementSettings.previewVisibility = o, (placementSettings) -> placementSettings.previewVisibility).documentation().add()).append( (, Codec.STRING), (placementSettings, o) -> placementSettings.wallPlacementOverrideBlockId = o, (placementSettings) -> placementSettings.wallPlacementOverrideBlockId).add()).append( (, Codec.STRING), (placementSettings, o) -> placementSettings.floorPlacementOverrideBlockId = o, (placementSettings) -> placementSettings.floorPlacementOverrideBlockId).add()).append( (, Codec.STRING), (placementSettings, o) -> placementSettings.ceilingPlacementOverrideBlockId = o, (placementSettings) -> placementSettings.ceilingPlacementOverrideBlockId).add()).build();
   }

       {
      ALWAYS_VISIBLE,
      ALWAYS_HIDDEN,
      DEFAULT;

         EnumCodec<BlockPreviewVisibility> CODEC =  <BlockPreviewVisibility>(BlockPreviewVisibility.class);

        {
      }
   }

       {
      FACING_PLAYER,
      BLOCK_NORMAL,
      STAIR_FACING_PLAYER,
      DEFAULT;

         EnumCodec<RotationMode> CODEC =  <RotationMode>(RotationMode.class);

        {
      }
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/BlockSupportsRequiredForType.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

public enum BlockSupportsRequiredForType {
   Any,
   All;

   private BlockSupportsRequiredForType() {
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/BlockType.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.AssetUpdateQuery;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.codecs.map.EnumMapCodec;
import com.hypixel.hytale.codec.codecs.map.MergedEnumMapCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIDefaultCollapsedState;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditor;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditorSectionStart;
import com.hypixel.hytale.codec.schema.metadata.ui.UIPropertyTitle;
import com.hypixel.hytale.codec.schema.metadata.ui.UIRebuildCaches;
import com.hypixel.hytale.codec.store.StoredCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.common.util.ArrayUtil;
import com.hypixel.hytale.common.util.MapUtil;
import com.hypixel.hytale.component.Holder;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.math.shape.Box;
 com.hypixel.hytale.math.vector.Vector3d;
 com.hypixel.hytale.math.vector.Vector3f;
 com.hypixel.hytale.protocol.BenchType;
 com.hypixel.hytale.protocol.BlockFlags;
 com.hypixel.hytale.protocol.BlockMaterial;
 com.hypixel.hytale.protocol.BlockNeighbor;
 com.hypixel.hytale.protocol.BlockTextures;
 com.hypixel.hytale.protocol.Color;
 com.hypixel.hytale.protocol.ColorLight;
 com.hypixel.hytale.protocol.DrawType;
 com.hypixel.hytale.protocol.InteractionType;
 com.hypixel.hytale.protocol.ModelTexture;
 com.hypixel.hytale.protocol.Opacity;
 com.hypixel.hytale.protocol.RailConfig;
 com.hypixel.hytale.protocol.RailPoint;
 com.hypixel.hytale.protocol.RandomRotation;
 com.hypixel.hytale.protocol.ShaderType;
 com.hypixel.hytale.protocol.ShadingMode;
 com.hypixel.hytale.protocol.Tint;
 com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
 com.hypixel.hytale.server.core.asset.type.blockbreakingdecal.config.BlockBreakingDecal;
 com.hypixel.hytale.server.core.asset.type.blockhitbox.BlockBoundingBoxes;
 com.hypixel.hytale.server.core.asset.type.blockparticle.config.BlockParticleSet;
 com.hypixel.hytale.server.core.asset.type.blocksound.config.BlockSoundSet;
 com.hypixel.hytale.server.core.asset.type.blocktick.config.TickProcedure;
 com.hypixel.hytale.server.core.asset.type.blocktype.config.bench.Bench;
 com.hypixel.hytale.server.core.asset.type.blocktype.config.farming.FarmingData;
 com.hypixel.hytale.server.core.asset.type.blocktype.config.mountpoints.RotatedMountPointsArray;
 com.hypixel.hytale.server.core.asset.type.buildertool.config.BlockTypeListAsset;
 com.hypixel.hytale.server.core.asset.type.buildertool.config.PrefabListAsset;
 com.hypixel.hytale.server.core.asset.type.item.config.Item;
 com.hypixel.hytale.server.core.asset.type.model.config.ModelParticle;
 com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
 com.hypixel.hytale.server.core.asset.type.soundevent.validator.SoundEventValidators;
 com.hypixel.hytale.server.core.asset.util.ColorParseUtil;
 com.hypixel.hytale.server.core.codec.ProtocolCodecs;
 com.hypixel.hytale.server.core.io.NetworkSerializable;
 com.hypixel.hytale.server.core.modules.interaction.interaction.config.InteractionTypeUtils;
 com.hypixel.hytale.server.core.modules.interaction.interaction.config.RootInteraction;
 com.hypixel.hytale.server.core.universe.world.chunk.section.palette.ISectionPalette;
 com.hypixel.hytale.server.core.universe.world.connectedblocks.ConnectedBlockRuleSet;
 com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
 com.hypixel.hytale.server.core.util.io.ByteBufUtil;
 io.netty.buffer.ByteBuf;
 it.unimi.dsi.fastutil.ints.IntSet;
 it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
 it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
 it.unimi.dsi.fastutil.objects.ObjectArrayList;
 java.lang.ref.SoftReference;
 java.util.Arrays;
 java.util.Collections;
 java.util.EnumMap;
 java.util.List;
 java.util.Map;
 java.util.function.ToIntFunction;
 java.util.logging.Level;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;

    <String, BlockTypeAssetMap<String, BlockType>>, NetworkSerializable<com.hypixel.hytale.protocol.BlockType> {
      AssetBuilderCodec<String, BlockType> CODEC;
      String[] EMPTY_ALIAS_LIST;
      ValidatorCache<String> VALIDATOR_CACHE;
         ;
      ModelTexture[] UNKNOWN_CUSTOM_MODEL_TEXTURE;
      BlockTextures[] UNKNOWN_BLOCK_TEXTURES;
      Map<BlockFace, RequiredBlockFaceSupport[]> REQUIRED_BOTTOM_FACE_SUPPORT;
      BlockFaceSupport[] BLOCK_FACE_SUPPORT_ALL_ARRAY;
      Map<BlockFace, BlockFaceSupport[]> ALL_SUPPORTING_FACES;
      ShaderType[] DEFAULT_SHADER_EFFECTS;
      BlockType DEFAULT_BLOCK_TYPE;
      ISectionPalette.KeySerializer KEY_SERIALIZER;
      ToIntFunction<ByteBuf> KEY_DESERIALIZER;
         ;
         ;
         ;
         ;
         ;
      BlockType EMPTY;
         ;
      BlockType UNKNOWN;
         ;
      BlockType DEBUG_CUBE;
         ;
      BlockType DEBUG_MODEL;
         ;
     AssetStore<String, BlockType, BlockTypeAssetMap<String, BlockType>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
     unknown;
    String group;
    String blockListAssetId;
    String prefabListAssetId;
       ;
        ;
    ModelParticle[] particles;
    String blockParticleSetId;
    String blockBreakingDecalId;
    Color particleColor;
    TickProcedure tickProcedure;
    ShaderType[] effect;
    BlockTypeTextures[] textures;
    String textureSideMask;
   
    ShadingMode cubeShadingMode;
   
    String customModel;
   
    CustomModelTexture[] customModelTexture;
     customModelScale;
    String customModelAnimation;
   
    DrawType drawType;
   
    BlockMaterial material;
   
    Opacity opacity;
     requiresAlphaBlending;
    Color[] tintUp;
    Color[] tintDown;
    Color[] tintNorth;
    Color[] tintSouth;
    Color[] tintWest;
    Color[] tintEast;
     biomeTintUp;
     biomeTintDown;
     biomeTintNorth;
     biomeTintSouth;
     biomeTintWest;
     biomeTintEast;
   
    BlockSupportsRequiredForType blockSupportsRequiredFor;
   
    RandomRotation randomRotation;
   
    VariantRotation variantRotation;
    BlockFlipType flipType;
   
    Rotation rotationYawPlacementOffset;
   
    RotatedMountPointsArray seats;
   
    RotatedMountPointsArray beds;
    String transitionTexture;
    String[] transitionToGroups;
    String transitionToTag;
    String hitboxType;
      hitboxTypeIndex;
   
    String interactionHitboxType;
      interactionHitboxTypeIndex;
    ColorLight light;
    BlockMovementSettings movementSettings;
    BlockFlags flags;
    String interactionHint;
     isTrigger;
   
   
     isDoor;
     damageToEntities;
     allowsMultipleUsers;
   
    ConnectedBlockRuleSet connectedBlockRuleSet;
    Bench bench;
    BlockGathering gathering;
    BlockPlacementSettings placementSettings;
    StateData state;
    String ambientSoundEventId;
      ambientSoundEventIndex;
    String interactionSoundEventId;
      interactionSoundEventIndex;
     isLooping;
    Holder<ChunkStore> blockEntity;
    FarmingData farming;
    SupportDropType supportDropType;
     maxSupportDistance;
   
    Map<BlockFace, RequiredBlockFaceSupport[]> support;
   
     Map<BlockFace, RequiredBlockFaceSupport[]>[] rotatedSupport;
   
    Map<BlockFace, BlockFaceSupport[]> supporting;
   
     Map<BlockFace, BlockFaceSupport[]>[] rotatedSupporting;
     ignoreSupportWhenPlaced;
    Map<InteractionType, String> interactions;
   
    RailConfig railConfig;
   
    RailConfig[] rotatedRailConfig;
    String[] aliases;
   
     String defaultStateKey;
   
     SoftReference<com.hypixel.hytale.protocol.BlockType> cachedPacket;

   
     BlockType  {
       (BlockType)getAssetMap().getAsset(input);
   }

     AssetStore<String, BlockType, BlockTypeAssetMap<String, BlockType>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, BlockType, BlockTypeAssetMap<String, BlockType>>getAssetStore(BlockType.class);
      }

       ASSET_STORE;
   }

     BlockTypeAssetMap<String, BlockType>  {
       (BlockTypeAssetMap)getAssetStore().getAssetMap();
   }

     {
      .cubeShadingMode = ShadingMode.Standard;
      .customModelScale = ;
      .drawType = DrawType.Cube;
      .material = BlockMaterial.Empty;
      .opacity = Opacity.Solid;
      .blockSupportsRequiredFor = BlockSupportsRequiredForType.All;
      .randomRotation = RandomRotation.None;
      .variantRotation = VariantRotation.None;
      .flipType = BlockFlipType.SYMMETRIC;
      .rotationYawPlacementOffset = Rotation.None;
      .hitboxType = ;
      .hitboxTypeIndex = ;
      .interactionHitboxTypeIndex = -;
      .movementSettings =  ();
      .flags =  (, );
      .allowsMultipleUsers = ;
      .supportDropType = SupportDropType.BREAK;
      .interactions = Collections.emptyMap();
      .aliases = EMPTY_ALIAS_LIST;
   }

     {
      .cubeShadingMode = ShadingMode.Standard;
      .customModelScale = ;
      .drawType = DrawType.Cube;
      .material = BlockMaterial.Empty;
      .opacity = Opacity.Solid;
      .blockSupportsRequiredFor = BlockSupportsRequiredForType.All;
      .randomRotation = RandomRotation.None;
      .variantRotation = VariantRotation.None;
      .flipType = BlockFlipType.SYMMETRIC;
      .rotationYawPlacementOffset = Rotation.None;
      .hitboxType = ;
      .hitboxTypeIndex = ;
      .interactionHitboxTypeIndex = -;
      .movementSettings =  ();
      .flags =  (, );
      .allowsMultipleUsers = ;
      .supportDropType = SupportDropType.BREAK;
      .interactions = Collections.emptyMap();
      .aliases = EMPTY_ALIAS_LIST;
      .id = id;
   }

     {
      .cubeShadingMode = ShadingMode.Standard;
      .customModelScale = ;
      .drawType = DrawType.Cube;
      .material = BlockMaterial.Empty;
      .opacity = Opacity.Solid;
      .blockSupportsRequiredFor = BlockSupportsRequiredForType.All;
      .randomRotation = RandomRotation.None;
      .variantRotation = VariantRotation.None;
      .flipType = BlockFlipType.SYMMETRIC;
      .rotationYawPlacementOffset = Rotation.None;
      .hitboxType = ;
      .hitboxTypeIndex = ;
      .interactionHitboxTypeIndex = -;
      .movementSettings =  ();
      .flags =  (, );
      .allowsMultipleUsers = ;
      .supportDropType = SupportDropType.BREAK;
      .interactions = Collections.emptyMap();
      .aliases = EMPTY_ALIAS_LIST;
      .data = other.data;
      .id = other.id;
      .unknown = other.unknown;
      .group = other.group;
      .blockSoundSetId = other.blockSoundSetId;
      .blockSoundSetIndex = other.blockSoundSetIndex;
      .particles = other.particles;
      .blockParticleSetId = other.blockParticleSetId;
      .blockBreakingDecalId = other.blockBreakingDecalId;
      .particleColor = other.particleColor;
      .tickProcedure = other.tickProcedure;
      .effect = other.effect;
      .textures = other.textures;
      .textureSideMask = other.textureSideMask;
      .customModelTexture = other.customModelTexture;
      .drawType = other.drawType;
      .material = other.material;
      .opacity = other.opacity;
      .requiresAlphaBlending = other.requiresAlphaBlending;
      .customModel = other.customModel;
      .customModelScale = other.customModelScale;
      .customModelAnimation = other.customModelAnimation;
      .tintUp = other.tintUp;
      .tintDown = other.tintDown;
      .tintNorth = other.tintNorth;
      .tintSouth = other.tintSouth;
      .tintWest = other.tintWest;
      .tintEast = other.tintEast;
      .biomeTintUp = other.biomeTintUp;
      .biomeTintDown = other.biomeTintDown;
      .biomeTintNorth = other.biomeTintNorth;
      .biomeTintSouth = other.biomeTintSouth;
      .biomeTintWest = other.biomeTintWest;
      .biomeTintEast = other.biomeTintEast;
      .randomRotation = other.randomRotation;
      .variantRotation = other.variantRotation;
      .flipType = other.flipType;
      .rotationYawPlacementOffset = other.rotationYawPlacementOffset;
      .seats = other.seats;
      .transitionTexture = other.transitionTexture;
      .transitionToGroups = other.transitionToGroups;
      .transitionToTag = other.transitionToTag;
      .hitboxType = other.hitboxType;
      .hitboxTypeIndex = other.hitboxTypeIndex;
      .interactionHitboxType = other.interactionHitboxType;
      .interactionHitboxTypeIndex = other.interactionHitboxTypeIndex;
      .light = other.light;
      .movementSettings = other.movementSettings;
      .flags = other.flags;
      .interactionHint = other.interactionHint;
      .isTrigger = other.isTrigger;
      .damageToEntities = other.damageToEntities;
      .bench = other.bench;
      .gathering = other.gathering;
      .placementSettings = other.placementSettings;
      .state = other.state;
      .blockEntity = other.blockEntity;
      .farming = other.farming;
      .supportDropType = other.supportDropType;
      .maxSupportDistance = other.maxSupportDistance;
      .support = other.support;
      .supporting = other.supporting;
      .cubeShadingMode = other.cubeShadingMode;
      .allowsMultipleUsers = other.allowsMultipleUsers;
      .interactions = other.interactions;
      .ambientSoundEventId = other.ambientSoundEventId;
      .ambientSoundEventIndex = other.ambientSoundEventIndex;
      .interactionSoundEventId = other.interactionSoundEventId;
      .interactionSoundEventIndex = other.interactionSoundEventIndex;
      .isLooping = other.isLooping;
      .isDoor = other.isDoor;
      .blockSupportsRequiredFor = other.blockSupportsRequiredFor;
      .connectedBlockRuleSet = other.connectedBlockRuleSet;
      .railConfig = other.railConfig;
      .ignoreSupportWhenPlaced = other.ignoreSupportWhenPlaced;
   }

   
    com.hypixel.hytale.protocol.BlockType  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.BlockType).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         BlockTypeAssetMap<String, BlockType> blockTypeAssetMap = getAssetMap();
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.BlockType();
         packet.name = .id;
            .getItem();
          (item != ) {
            packet.item = item.getId();
         }

         packet.unknown = .unknown;
          (.group != ) {
            packet.group = getAssetMap().getGroupId(.group);
         }

         packet.blockSoundSetIndex = .blockSoundSetIndex;
         packet.blockParticleSetId = .blockParticleSetId;
         packet.blockBreakingDecalId = .blockBreakingDecalId;
         packet.particleColor = .particleColor;
          (.support != ) {
            Object2ObjectOpenHashMap<BlockNeighbor, com.hypixel.hytale.protocol.RequiredBlockFaceSupport[]> supportMap =  <BlockNeighbor, com.hypixel.hytale.protocol.RequiredBlockFaceSupport[]>();

            (Map.Entry<BlockFace, RequiredBlockFaceSupport[]> entry : .support.entrySet()) {
               RequiredBlockFaceSupport[] supports = (RequiredBlockFaceSupport[])entry.getValue();
               com.hypixel.hytale.protocol.RequiredBlockFaceSupport[] protocolSupports =  .hypixel.hytale.protocol.RequiredBlockFaceSupport[supports.length];

               (   ; i < supports.length; ++i) {
                  protocolSupports[i] = supports[i].toPacket();
               }

               supportMap.put(((BlockFace)entry.getKey()).toProtocolBlockNeighbor(), protocolSupports);
            }

            packet.support = supportMap;
         }

          (.supporting != ) {
            Object2ObjectOpenHashMap<BlockNeighbor, com.hypixel.hytale.protocol.BlockFaceSupport[]> supportingMap =  <BlockNeighbor, com.hypixel.hytale.protocol.BlockFaceSupport[]>();

            (Map.Entry<BlockFace, BlockFaceSupport[]> entry : .supporting.entrySet()) {
               BlockFaceSupport[] blockFaceSupports = (BlockFaceSupport[])entry.getValue();
               com.hypixel.hytale.protocol.BlockFaceSupport[] protocolBlockFaceSupports =  .hypixel.hytale.protocol.BlockFaceSupport[blockFaceSupports.length];

               (   ; i < blockFaceSupports.length; ++i) {
                  protocolBlockFaceSupports[i] = blockFaceSupports[i].toPacket();
               }

               supportingMap.put(((BlockFace)entry.getKey()).toProtocolBlockNeighbor(), protocolBlockFaceSupports);
            }

            packet.supporting = supportingMap;
         }

         com.hypixel.hytale.protocol.BlockSupportsRequiredForType var10001;
          (.blockSupportsRequiredFor) {
             Any -> var10001 = com.hypixel.hytale.protocol.BlockSupportsRequiredForType.Any;
             All -> var10001 = com.hypixel.hytale.protocol.BlockSupportsRequiredForType.All;
             ->   ((String), (Throwable));
         }

         packet.blockSupportsRequiredFor = var10001;
         packet.maxSupportDistance = .maxSupportDistance;
          (.effect !=  && .effect.length > ) {
            packet.shaderEffect = .effect;
         }  {
            packet.shaderEffect = DEFAULT_SHADER_EFFECTS;
         }

          (.textures !=  && .textures.length > ) {
               ;

            (BlockTypeTextures texture : .textures) {
               totalWeight = ()(()totalWeight + texture.getWeight());
            }

            BlockTextures[] texturePackets =  [.textures.length];

            (   ; i < .textures.length; ++i) {
               texturePackets[i] = .textures[i].toPacket(()totalWeight);
            }

            packet.cubeTextures = texturePackets;
         }  {
            packet.cubeTextures = UNKNOWN_BLOCK_TEXTURES;
         }

         packet.cubeSideMaskTexture = .textureSideMask;
         packet.cubeShadingMode = .cubeShadingMode;
          (.customModelTexture !=  && .customModelTexture.length > ) {
               ;

            (CustomModelTexture modelTexture : .customModelTexture) {
               totalWeight += modelTexture.getWeight();
            }

            ModelTexture[] texturePackets =  [.customModelTexture.length];

            (   ; i < .customModelTexture.length; ++i) {
               texturePackets[i] = .customModelTexture[i].toPacket(()totalWeight);
            }

            packet.modelTexture = texturePackets;
         }  {
            packet.modelTexture = UNKNOWN_CUSTOM_MODEL_TEXTURE;
         }

         packet.drawType = .drawType;
         packet.requiresAlphaBlending = .requiresAlphaBlending;
          (.customModel != ) {
            packet.model = .customModel;
         }

         packet.modelScale = .customModelScale;
          (.customModelAnimation != ) {
            packet.modelAnimation = .customModelAnimation;
         }

         packet.tint =  ();
          (.tintUp !=  && .tintUp.length > ) {
            packet.tint.top = ColorParseUtil.colorToARGBInt(.tintUp[]);
         }  {
            packet.tint.top = -;
         }

          (.tintDown !=  && .tintDown.length > ) {
            packet.tint.bottom = ColorParseUtil.colorToARGBInt(.tintDown[]);
         }  {
            packet.tint.bottom = -;
         }

          (.tintNorth !=  && .tintNorth.length > ) {
            packet.tint.back = ColorParseUtil.colorToARGBInt(.tintNorth[]);
         }  {
            packet.tint.back = -;
         }

          (.tintSouth !=  && .tintSouth.length > ) {
            packet.tint.front = ColorParseUtil.colorToARGBInt(.tintSouth[]);
         }  {
            packet.tint.front = -;
         }

          (.tintWest !=  && .tintWest.length > ) {
            packet.tint.left = ColorParseUtil.colorToARGBInt(.tintWest[]);
         }  {
            packet.tint.left = -;
         }

          (.tintEast !=  && .tintEast.length > ) {
            packet.tint.right = ColorParseUtil.colorToARGBInt(.tintEast[]);
         }  {
            packet.tint.right = -;
         }

         packet.biomeTint =  (.biomeTintUp, .biomeTintDown, .biomeTintSouth, .biomeTintNorth, .biomeTintWest, .biomeTintEast);
         packet.variantRotation = .variantRotation.toPacket();
         packet.randomRotation = .randomRotation;
         packet.rotationYawPlacementOffset = .rotationYawPlacementOffset.toPacket();
         packet.opacity = .opacity;
          (.transitionTexture != ) {
            packet.transitionTexture = .transitionTexture;
         }

          (.transitionToGroups !=  && .transitionToGroups.length > ) {
            [] arr =  [.transitionToGroups.length];

            (   ; i < .transitionToGroups.length; ++i) {
               arr[i] = blockTypeAssetMap.getGroupId(.transitionToGroups[i]);
            }

            packet.transitionToGroups = arr;
         }

          (.transitionToTag != ) {
            packet.transitionToTag = AssetRegistry.getOrCreateTagIndex(.transitionToTag);
         }  {
            packet.transitionToTag = -;
         }

         packet.material = .material;
         packet.hitbox = .hitboxTypeIndex;
         packet.interactionHitbox = .interactionHitboxTypeIndex;
         packet.light = .light;
         packet.movementSettings = .movementSettings.toPacket();
         packet.flags = .flags;
         packet.interactionHint = .interactionHint;
          (.gathering != ) {
            packet.gathering = .gathering.toPacket();
         }

          (.placementSettings != ) {
            packet.placementSettings = .placementSettings.toPacket();
         }

         packet.looping = .isLooping;
         packet.ambientSoundEventIndex = .ambientSoundEventIndex;
          (.particles !=  && .particles.length > ) {
            packet.particles =  .hypixel.hytale.protocol.ModelParticle[.particles.length];

            (   ; i < .particles.length; ++i) {
               packet.particles[i] = .particles[i].toPacket();
            }
         }

         Object2IntOpenHashMap<InteractionType> interactionMap =  <InteractionType>();

         (Map.Entry<InteractionType, String> e : .interactions.entrySet()) {
            interactionMap.put((InteractionType)e.getKey(), RootInteraction.getRootInteractionIdOrUnknown((String)e.getValue()));
         }

         packet.interactions = interactionMap;
          (.state != ) {
            packet.states = .state.toPacket();
               .getBlockKeyForState();
             (def != ) {
               packet.states.put(, getAssetMap().getIndex(def));
            }
         }

          (.data != ) {
               .data.getExpandedTagIndexes();
             (tags != ) {
               packet.tagIndexes = tags.toIntArray();
            }
         }

         packet.rail = .railConfig;
         packet.ignoreSupportWhenPlaced = .ignoreSupportWhenPlaced;
          (.bench != ) {
            packet.bench = .bench.toPacket();
         }

          (.connectedBlockRuleSet != ) {
            packet.connectedBlockRuleSet = .connectedBlockRuleSet.toPacket(blockTypeAssetMap);
         }

         .cachedPacket =  (packet);
          packet;
      }
   }

    String  {
       .id;
   }

    AssetExtraInfo.Data  {
       .data;
   }

   
    Item  {
       (.data == ) {
          ;
      }  {
            (String).data.getContainerKey(Item.class);
          itemKey ==  ?  : (Item)Item.getAssetMap().getAsset(itemKey);
      }
   }

      {
       .getStateForBlock(.id) != ;
   }

   
    BlockType  {
         .getBlockKeyForState(state);
       key ==  ?  : (BlockType)getAssetMap().getAsset(key);
   }

   
    String  {
      String key;
       (state.equals()) {
         key = .getDefaultStateKey();
      }  {
         key = .state !=  ? .state.getBlockForState(state) : ;
      }

       key;
   }

    String  {
       (.defaultStateKey == ) {
         .defaultStateKey = (String).data.getContainerKey(BlockType.class);
      }

       .defaultStateKey;
   }

   
    String  {
       .getStateForBlock(blockType.getId());
   }

   
    String  {
       .state !=  ? .state.getStateForBlock(blockTypeKey) : ;
   }

      {
       .unknown;
   }

    String  {
       .group;
   }

    String  {
       .blockSoundSetId;
   }

      {
       .blockSoundSetIndex;
   }

    ModelParticle[] getParticles() {
       .particles;
   }

    String  {
       .blockParticleSetId;
   }

    String  {
       .blockBreakingDecalId;
   }

    Color  {
       .particleColor;
   }

    TickProcedure  {
       .tickProcedure;
   }

    ShaderType[] getEffect() {
       .effect;
   }

    BlockTypeTextures[] getTextures() {
       .textures;
   }

    String  {
       .textureSideMask;
   }

   
    CustomModelTexture[] getCustomModelTexture() {
       .customModelTexture;
   }

    DrawType  {
       .drawType;
   }

    BlockMaterial  {
       .material;
   }

    Opacity  {
       .opacity;
   }

   
    String  {
       .customModel;
   }

      {
       .customModelScale;
   }

    String  {
       .customModelAnimation;
   }

    Color[] getTintUp() {
       .tintUp;
   }

    Color[] getTintDown() {
       .tintDown;
   }

    Color[] getTintNorth() {
       .tintNorth;
   }

    Color[] getTintSouth() {
       .tintSouth;
   }

    Color[] getTintWest() {
       .tintWest;
   }

    Color[] getTintEast() {
       .tintEast;
   }

      {
       .biomeTintUp;
   }

      {
       .biomeTintDown;
   }

      {
       .biomeTintNorth;
   }

      {
       .biomeTintSouth;
   }

      {
       .biomeTintWest;
   }

      {
       .biomeTintEast;
   }

   
    ConnectedBlockRuleSet  {
       .connectedBlockRuleSet;
   }

    BlockSupportsRequiredForType  {
       .blockSupportsRequiredFor;
   }

    RandomRotation  {
       .randomRotation;
   }

   
    VariantRotation  {
       .variantRotation;
   }

    BlockFlipType  {
       .flipType;
   }

    Rotation  {
       .rotationYawPlacementOffset;
   }

   
    RotatedMountPointsArray  {
       .seats;
   }

   
    RotatedMountPointsArray  {
       .beds;
   }

    String  {
       .transitionTexture;
   }

    String[] getTransitionToGroups() {
       .transitionToGroups;
   }

    String  {
       .blockListAssetId;
   }

    String  {
       .prefabListAssetId;
   }

    String  {
       .hitboxType;
   }

      {
       .hitboxTypeIndex;
   }

   
    String  {
       .interactionHitboxType;
   }

      {
       .interactionHitboxTypeIndex;
   }

    ColorLight  {
       .light;
   }

    BlockMovementSettings  {
       .movementSettings;
   }

    BlockFlags  {
       .flags;
   }

    String  {
       .interactionHint;
   }

      {
       .isTrigger;
   }

      {
       .damageToEntities;
   }

    Bench  {
       .bench;
   }

    BlockGathering  {
       .gathering;
   }

    BlockPlacementSettings  {
       .placementSettings;
   }

    StateData  {
       .state;
   }

    Holder<ChunkStore>  {
       .blockEntity;
   }

    String  {
       .ambientSoundEventId;
   }

      {
       .ambientSoundEventIndex;
   }

    String  {
       .interactionSoundEventId;
   }

      {
       .interactionSoundEventIndex;
   }

      {
       .isLooping;
   }

    FarmingData  {
       .farming;
   }

    SupportDropType  {
       .supportDropType;
   }

      {
       .maxSupportDistance;
   }

      {
       .supporting == ALL_SUPPORTING_FACES;
   }

   
    Map<BlockFace, RequiredBlockFaceSupport[]> getSupport( rotationIndex) {
       (.support !=  && rotationIndex != ) {
          (.rotatedSupport == ) {
            .rotatedSupport =  [RotationTuple.VALUES.length];
         }

         Map<BlockFace, RequiredBlockFaceSupport[]> rotatedSupportArray = .rotatedSupport[rotationIndex];
          (rotatedSupportArray == ) {
               RotationTuple.get(rotationIndex);
            Map<BlockFace, List<RequiredBlockFaceSupport>> rotatedSupport =  (BlockFace.class);

            (Map.Entry<BlockFace, RequiredBlockFaceSupport[]> entry : .support.entrySet()) {
                  (BlockFace)entry.getKey();
               RequiredBlockFaceSupport[] requiredBlockFaceSupports = (RequiredBlockFaceSupport[])entry.getValue();
                  BlockFace.rotate(blockFace, rotation.yaw(), rotation.pitch(), rotation.roll());

               (RequiredBlockFaceSupport requiredBlockFaceSupport : requiredBlockFaceSupports) {
                   (requiredBlockFaceSupport.isRotated()) {
                        RequiredBlockFaceSupport.rotate(requiredBlockFaceSupport, rotation.yaw(), rotation.pitch(), rotation.roll());
                     ((List)rotatedSupport.computeIfAbsent(rotatedBlockFace, (k) ->  ())).add(rotatedRequiredBlockFaceSupport);
                  }  {
                     ((List)rotatedSupport.computeIfAbsent(blockFace, (k) ->  ())).add(requiredBlockFaceSupport);
                  }
               }
            }

            rotatedSupportArray =  (BlockFace.class);

            (Map.Entry<BlockFace, List<RequiredBlockFaceSupport>> entry : rotatedSupport.entrySet()) {
               rotatedSupportArray.put((BlockFace)entry.getKey(), (RequiredBlockFaceSupport[])((List)entry.getValue()).toArray((x$) ->  [x$]));
            }

            .rotatedSupport[rotationIndex] = rotatedSupportArray;
         }

          rotatedSupportArray;
      }  {
          .support;
      }
   }

   
    Map<BlockFace, BlockFaceSupport[]> getSupporting( rotationIndex) {
       (.supporting !=  && rotationIndex != ) {
          (.rotatedSupporting == ) {
            .rotatedSupporting =  [RotationTuple.VALUES.length];
         }

         Map<BlockFace, BlockFaceSupport[]> rotatedSupportingArray = .rotatedSupporting[rotationIndex];
          (rotatedSupportingArray == ) {
               RotationTuple.get(rotationIndex);
             (.isFullySupportive()) {
               rotatedSupportingArray = ALL_SUPPORTING_FACES;
            }  {
               Map<BlockFace, List<BlockFaceSupport>> rotatedSupporting =  (BlockFace.class);

               (Map.Entry<BlockFace, BlockFaceSupport[]> entry : .supporting.entrySet()) {
                     (BlockFace)entry.getKey();
                  BlockFaceSupport[] blockFaceSupports = (BlockFaceSupport[])entry.getValue();
                     BlockFace.rotate(blockFace, rotation.yaw(), rotation.pitch(), rotation.roll());

                  (BlockFaceSupport blockFaceSupport : blockFaceSupports) {
                        BlockFaceSupport.rotate(blockFaceSupport, rotation.yaw(), rotation.pitch(), rotation.roll());
                     ((List)rotatedSupporting.computeIfAbsent(rotatedBlockFace, (k) ->  ())).add(rotatedBlockFaceSupport);
                  }
               }

               rotatedSupportingArray =  (BlockFace.class);

               (Map.Entry<BlockFace, List<BlockFaceSupport>> entry : rotatedSupporting.entrySet()) {
                  rotatedSupportingArray.put((BlockFace)entry.getKey(), (BlockFaceSupport[])((List)entry.getValue()).toArray((x$) ->  [x$]));
               }
            }

            .rotatedSupporting[rotationIndex] = rotatedSupportingArray;
         }

          rotatedSupportingArray;
      }  {
          .supporting;
      }
   }

      {
       .support !=  && !.support.isEmpty() || .maxSupportDistance > ;
   }

      {
       .allowsMultipleUsers;
   }

    Map<InteractionType, String>  {
       .interactions;
   }

   
    RailConfig  {
       (.railConfig !=  && rotationIndex != ) {
          (.rotatedRailConfig == ) {
            .rotatedRailConfig =  [RotationTuple.VALUES.length];
         }

            .rotatedRailConfig[rotationIndex];
          (rotatedRail == ) {
               RotationTuple.get(rotationIndex);
            rotatedRail =  (.railConfig);

            (RailPoint p : rotatedRail.points) {
                   (p.point.x - , p.point.y - , p.point.z - );
               hyPoint = Rotation.rotate(hyPoint, rotation.yaw(), rotation.pitch(), rotation.roll());
               p.point.x = hyPoint.x + ;
               p.point.y = hyPoint.y + ;
               p.point.z = hyPoint.z + ;
                   (p.normal.x, p.normal.y, p.normal.z);
               hyNormal = Rotation.rotate(hyNormal, rotation.yaw(), rotation.pitch(), rotation.roll());
               p.normal.x = hyNormal.x;
               p.normal.y = hyNormal.y;
               p.normal.z = hyNormal.z;
            }

            .rotatedRailConfig[rotationIndex] = rotatedRail;
         }

          rotatedRail;
      }  {
          .railConfig;
      }
   }

   
   
      {
       .isDoor;
   }

      {
       .ignoreSupportWhenPlaced;
   }

      {
       .ignoreSupportWhenPlaced || .gathering !=  && .gathering.shouldUseDefaultDropWhenPlaced();
   }

      {
       (.bench != ) {
          (.state ==  && .bench.getType() == BenchType.Processing) {
            .state =  ();
         }

         .flags.isUsable = ;
          (.interactionHint == ) {
            .interactionHint = ;
         }
      }   (.state ==  || !.equalsIgnoreCase(.state.getId()) && !.equalsIgnoreCase(.state.getId())) {
          (.gathering !=  && .gathering.isHarvestable()) {
            .flags.isUsable = ;
             (.interactionHint == ) {
               .interactionHint = ;
            }
         }   (.seats !=  && .seats.size() >  && .interactionHint == ) {
            .interactionHint = ;
         }
      }  {
         .flags.isUsable = ;
          (.interactionHint == ) {
            .interactionHint = ;
         }
      }

       (.interactions.containsKey(InteractionType.Use)) {
         .flags.isUsable = ;
          (.interactionHint == ) {
            .interactionHint = ;
         }
      }

       (.flags.isUsable && .interactionHint == ) {
         .interactionHint = ;
      }

       (.ambientSoundEventId != ) {
         .ambientSoundEventIndex = SoundEvent.getAssetMap().getIndex(.ambientSoundEventId);
      }

       (.interactionSoundEventId != ) {
         .interactionSoundEventIndex = SoundEvent.getAssetMap().getIndex(.interactionSoundEventId);
      }

       (.support ==  && .material == BlockMaterial.Empty && !.equals(.group)) {
         .support = REQUIRED_BOTTOM_FACE_SUPPORT;
      }

       (.supporting ==  && (.drawType == DrawType.Cube || .drawType == DrawType.CubeWithModel || .drawType == DrawType.GizmoCube) && .material == BlockMaterial.Solid) {
         .supporting = ALL_SUPPORTING_FACES;
      }   (.supporting == ) {
         .supporting = Collections.emptyMap();
      }

      .hitboxTypeIndex = .hitboxType.equals() ?  : BlockBoundingBoxes.getAssetMap().getIndex(.hitboxType);
       (.hitboxTypeIndex == -) {
         HytaleLogger.getLogger().at(Level.WARNING).log(, .hitboxType, .getId());
         .hitboxTypeIndex = ;
      }

       (.interactionHitboxType != ) {
         .interactionHitboxTypeIndex = .interactionHitboxType.equals() ?  : BlockBoundingBoxes.getAssetMap().getIndex(.interactionHitboxType);
          (.interactionHitboxTypeIndex == -) {
            HytaleLogger.getLogger().at(Level.WARNING).log(, .interactionHitboxType, .getId());
            .interactionHitboxTypeIndex = .hitboxTypeIndex;
         }
      }

      .blockSoundSetIndex = .blockSoundSetId.equals() ?  : BlockSoundSet.getAssetMap().getIndex(.blockSoundSetId);
       (.blockSoundSetIndex == -) {
         HytaleLogger.getLogger().at(Level.WARNING).log(, .blockSoundSetId, .getId());
         .blockSoundSetIndex = ;
      }

      (InteractionType type : .interactions.keySet()) {
          (InteractionTypeUtils.isCollisionType(type)) {
            .isTrigger = ;
            ;
         }
      }

       (.bench !=  && !.interactions.containsKey(InteractionType.Use)) {
         Map<InteractionType, String> interactions = .interactions.isEmpty() ?  (InteractionType.class) :  (.interactions);
            .bench.getRootInteraction();
          (rootInteraction != ) {
            interactions.put(InteractionType.Use, rootInteraction.getId());
         }

         .interactions = Collections.unmodifiableMap(interactions);
      }

   }

   
     BlockType  {
       UNKNOWN.clone(blockTypeKey);
   }

      {
         (BlockBoundingBoxes)BlockBoundingBoxes.getAssetMap().getAsset(.hitboxTypeIndex);
       (hitboxAsset == ) {
           ( + .hitboxType);
      }  {
         BlockBoundingBoxes.   hitboxAsset.get(rotationIndex);
            rotatedHitbox.getBoundingBox();
         outCenter.assign(boundingBox.middleX(), boundingBox.middleY(), boundingBox.middleZ());
      }
   }

   
    String  {
         .id;
        + var10000 +  + .unknown +  + .group +  + .blockSoundSetId +  + .blockSoundSetIndex +  + Arrays.toString(.particles) +  + .blockParticleSetId +  + .blockBreakingDecalId +  + String.valueOf(.particleColor) +  + Arrays.toString(.effect) +  + Arrays.toString(.textures) +  + .textureSideMask +  + String.valueOf(.cubeShadingMode) +  + .customModel +  + Arrays.toString(.customModelTexture) +  + .customModelScale +  + .customModelAnimation +  + String.valueOf(.drawType) +  + String.valueOf(.material) +  + String.valueOf(.opacity) +  + .requiresAlphaBlending +  + String.valueOf(.tickProcedure) +  + Arrays.toString(.tintUp) +  + Arrays.toString(.tintDown) +  + Arrays.toString(.tintNorth) +  + Arrays.toString(.tintSouth) +  + Arrays.toString(.tintWest) +  + Arrays.toString(.tintEast) +  + .biomeTintUp +  + .biomeTintDown +  + .biomeTintNorth +  + .biomeTintSouth +  + .biomeTintWest +  + .biomeTintEast +  + String.valueOf(.randomRotation) +  + String.valueOf(.variantRotation) +  + String.valueOf(.flipType) +  + String.valueOf(.rotationYawPlacementOffset) +  + .transitionTexture +  + Arrays.toString(.transitionToGroups) +  + .hitboxType +  + .hitboxTypeIndex +  + .interactionHitboxType +  + .interactionHitboxTypeIndex +  + String.valueOf(.light) +  + String.valueOf(.movementSettings) +  + String.valueOf(.flags) +  + .interactionHint +  + .isTrigger +  + .damageToEntities +  + .allowsMultipleUsers +  + String.valueOf(.bench) +  + String.valueOf(.gathering) +  + String.valueOf(.placementSettings) +  + String.valueOf(.state) +  + .ambientSoundEventId +  + .ambientSoundEventIndex +  + .interactionSoundEventId +  + .interactionSoundEventIndex +  + .isLooping +  + String.valueOf(.farming) +  + String.valueOf(.supportDropType) +  + .maxSupportDistance +  + String.valueOf(.support) +  + String.valueOf(.supporting) +  + String.valueOf(.interactions) +  + String.valueOf(.railConfig) + ;
   }

   
    BlockType  {
       (.id !=  && .id.equals(newKey)) {
          ;
      }  {
             ();
         blockType.id = newKey;
         blockType.cachedPacket = ;
          blockType;
      }
   }

       {
       getBlockIdOrUnknown(getAssetMap(), blockTypeKey, message, params);
   }

       {
         assetMap.getIndex(blockTypeKey);
       (blockId == -) {
         HytaleLogger.getLogger().at(Level.WARNING).logVarargs(message, params);
         AssetRegistry.getAssetStore(BlockType.class).loadAssets(, Collections.singletonList(getUnknownFor(blockTypeKey)), AssetUpdateQuery.DEFAULT_NO_REBUILD);
            assetMap.getIndex(blockTypeKey);
          (index == -) {
              ( + blockTypeKey);
         }

         blockId = index;
      }

       blockId;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(BlockType.class, BlockType::, Codec.STRING, (t, k) -> t.id = k, (t) -> t.id, (asset, data) -> asset.data = data, (asset) -> asset.data).documentation()).appendInherited( (, Codec.STRING), (blockType, o) -> blockType.group = o, (blockType) -> blockType.group, (blockType, parent) -> blockType.group = parent.group).documentation().metadata( ( .TextField())).add()).appendInherited( (, Codec.STRING), (blockType, blockListAssetId) -> blockType.blockListAssetId = blockListAssetId, (blockType) -> blockType.blockListAssetId, (blockType, parent) -> blockType.blockListAssetId = parent.blockListAssetId).addValidator(BlockTypeListAsset.VALIDATOR_CACHE.getValidator()).documentation().add()).appendInherited( (, Codec.STRING), (blockType, prefabListAssetId) -> blockType.prefabListAssetId = prefabListAssetId, (blockType) -> blockType.prefabListAssetId, (blockType, parent) -> blockType.prefabListAssetId = parent.prefabListAssetId).addValidator(PrefabListAsset.VALIDATOR_CACHE.getValidator()).documentation().add()).appendInherited( (,  (DrawType.class)), (blockType, o) -> blockType.drawType = o, (blockType) -> blockType.drawType, (blockType, parent) -> blockType.drawType = parent.drawType).addValidator(Validators.nonNull()).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS, UIRebuildCaches.ClientCache.BLOCK_TEXTURES, UIRebuildCaches.ClientCache.MODEL_TEXTURES})).metadata( ()).add()).appendInherited( (,  (BlockTypeTextures.CODEC, (x$) ->  [x$])), (blockType, o) -> blockType.textures = o, (blockType) -> blockType.textures, (blockType, parent) -> blockType.textures = parent.textures).metadata( ()).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS, UIRebuildCaches.ClientCache.BLOCK_TEXTURES})).add()).appendInherited( (, Codec.STRING), (blockType, o) -> blockType.textureSideMask = o, (blockType) -> blockType.textureSideMask, (blockType, parent) -> blockType.textureSideMask = parent.textureSideMask).addValidator(CommonAssetValidator.TEXTURE_ITEM).metadata( ()).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS, UIRebuildCaches.ClientCache.BLOCK_TEXTURES})).add()).appendInherited( (,  (ShadingMode.class)), (blockType, o) -> blockType.cubeShadingMode = o, (blockType) -> blockType.cubeShadingMode, (blockType, parent) -> blockType.cubeShadingMode = parent.cubeShadingMode).addValidator(Validators.nonNull()).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).add()).appendInherited( (,  (CustomModelTexture.CODEC, (x$) ->  [x$])), (blockType, o) -> blockType.customModelTexture = o, (blockType) -> blockType.customModelTexture, (blockType, parent) -> blockType.customModelTexture = parent.customModelTexture).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS, UIRebuildCaches.ClientCache.BLOCK_TEXTURES})).metadata( ()).add()).appendInherited( (, Codec.STRING), (blockType, o) -> blockType.customModel = o, (blockType) -> blockType.customModel, (blockType, parent) -> blockType.customModel = parent.customModel).addValidator(CommonAssetValidator.MODEL_ITEM).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).metadata( ()).add()).appendInherited( (, Codec.STRING), (blockType, s) -> blockType.blockBreakingDecalId = s, (blockType) -> blockType.blockBreakingDecalId, (blockType, parent) -> blockType.blockBreakingDecalId = parent.blockBreakingDecalId).documentation().addValidator(BlockBreakingDecal.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (,  (BlockMaterial.class)), (blockType, o) -> blockType.material = o, (blockType) -> blockType.material, (blockType, parent) -> blockType.material = parent.material).addValidator(Validators.nonNull()).add()).appendInherited( (,  (Opacity.class)), (blockType, o) -> blockType.opacity = o, (blockType) -> blockType.opacity, (blockType, parent) -> blockType.opacity = parent.opacity).addValidator(Validators.nonNull()).add()).appendInherited( (, Codec.BOOLEAN), (blockType, o) -> blockType.requiresAlphaBlending = o, (blockType) -> blockType.requiresAlphaBlending, (blockType, parent) -> blockType.requiresAlphaBlending = parent.requiresAlphaBlending).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).add()).appendInherited( (, Codec.FLOAT), (blockType, o) -> blockType.customModelScale = o, (blockType) -> blockType.customModelScale, (blockType, parent) -> blockType.customModelScale = parent.customModelScale).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).add()).appendInherited( (, Codec.STRING), (blockType, o) -> blockType.customModelAnimation = o, (blockType) -> blockType.customModelAnimation, (blockType, parent) -> blockType.customModelAnimation = parent.customModelAnimation).addValidator(CommonAssetValidator.ANIMATION_ITEM_BLOCK).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).metadata( ()).add()).appendInherited( (, ProtocolCodecs.COLOR_LIGHT), (blockType, o) -> blockType.light = o, (blockType) -> blockType.light, (blockType, parent) -> blockType.light = parent.light).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).metadata( ()).add()).appendInherited( (, TickProcedure.CODEC), (blockType, v) -> blockType.tickProcedure = v, (blockType) -> blockType.tickProcedure, (blockType, parent) -> blockType.tickProcedure = parent.tickProcedure).add()).appendInherited( (, ConnectedBlockRuleSet.CODEC), (blockType, connectedBlockRuleSet) -> blockType.connectedBlockRuleSet = connectedBlockRuleSet, (blockType) -> blockType.connectedBlockRuleSet, (blockType, parent) -> blockType.connectedBlockRuleSet = parent.connectedBlockRuleSet).add()).appendInherited( (,  ( (ShaderType.class), (x$) ->  [x$])), (blockType, o) -> blockType.effect = o, (blockType) -> blockType.effect, (blockType, parent) -> blockType.effect = parent.effect).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).add()).appendInherited( (, Codec.STRING), (blockType, o) -> blockType.transitionTexture = o, (blockType) -> blockType.transitionTexture, (blockType, parent) -> blockType.transitionTexture = parent.transitionTexture).addValidator(CommonAssetValidator.TEXTURE_ITEM).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS, UIRebuildCaches.ClientCache.BLOCK_TEXTURES})).add()).appendInherited( (, ( (Codec.STRING, (x$) ->  [x$])).metadata( ( .TextField()))), (blockType, o) -> blockType.transitionToGroups = o, (blockType) -> blockType.transitionToGroups, (blockType, parent) -> blockType.transitionToGroups = parent.transitionToGroups).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).add()).appendInherited( (, Codec.STRING), (blockType, o) -> blockType.transitionToTag = o, (blockType) -> blockType.transitionToTag, (blockType, parent) -> blockType.transitionToTag = parent.transitionToTag).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).add()).appendInherited( (, Codec.STRING), (blockType, s) -> blockType.blockParticleSetId = s, (blockType) -> blockType.blockParticleSetId, (blockType, parent) -> blockType.blockParticleSetId = parent.blockParticleSetId).documentation().addValidator(BlockParticleSet.VALIDATOR_CACHE.getValidator()).metadata( ()).add()).appendInherited( (, ProtocolCodecs.COLOR), (blockType, s) -> blockType.particleColor = s, (blockType) -> blockType.particleColor, (blockType, parent) -> blockType.particleColor = parent.particleColor).add()).appendInherited( (, ModelParticle.ARRAY_CODEC), (blockType, s) -> blockType.particles = s, (blockType) -> blockType.particles, (blockType, parent) -> blockType.particles = parent.particles).documentation().metadata( ()).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).metadata(UIDefaultCollapsedState.UNCOLLAPSED).addValidator(Validators.nonNullArrayElements()).add()).appendInherited( (,  (RandomRotation.class)), (blockType, o) -> blockType.randomRotation = o, (blockType) -> blockType.randomRotation, (blockType, parent) -> blockType.randomRotation = parent.randomRotation).metadata( ()).addValidator(Validators.nonNull()).add()).appendInherited( (,  (VariantRotation.class)), (blockType, o) -> blockType.variantRotation = o, (blockType) -> blockType.variantRotation, (blockType, parent) -> blockType.variantRotation = parent.variantRotation).addValidator(Validators.nonNull()).add()).appendInherited( (,  (BlockFlipType.class)), (blockType, o) -> blockType.flipType = o, (blockType) -> blockType.flipType, (blockType, parent) -> blockType.flipType = parent.flipType).add()).appendInherited( (,  (Rotation.class)), (blockType, o) -> blockType.rotationYawPlacementOffset = o, (blockType) -> blockType.rotationYawPlacementOffset, (blockType, parent) -> blockType.rotationYawPlacementOffset = parent.rotationYawPlacementOffset).addValidator(Validators.nonNull()).add()).appendInherited( (, RotatedMountPointsArray.CODEC), (blockType, o) -> blockType.seats = o, (blockType) -> blockType.seats, (blockType, parent) -> blockType.seats = parent.seats).metadata( ()).documentation().add()).appendInherited( (, RotatedMountPointsArray.CODEC), (blockType, o) -> blockType.beds = o, (blockType) -> blockType.beds, (blockType, parent) -> blockType.beds = parent.beds).documentation().add()).appendInherited( (, BlockMovementSettings.CODEC), (blockType, o) -> blockType.movementSettings = o, (blockType) -> blockType.movementSettings, (blockType, parent) -> blockType.movementSettings = parent.movementSettings).add()).appendInherited( (, ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(BlockFlags.class, BlockFlags::).appendInherited( (, Codec.BOOLEAN), (blockFlags, b) -> blockFlags.isUsable = b, (blockFlags) -> blockFlags.isUsable, (blockFlags, parent) -> blockFlags.isUsable = parent.isUsable).add()).appendInherited( (, Codec.BOOLEAN), (blockFlags, b) -> blockFlags.isStackable = b, (blockFlags) -> blockFlags.isStackable, (blockFlags, parent) -> blockFlags.isStackable = parent.isStackable).add()).build()), (blockType, o) -> blockType.flags = o, (blockType) -> blockType.flags, (blockType, parent) -> blockType.flags =  (parent.flags)).add()).appendInherited( (, Bench.CODEC), (blockType, s) -> blockType.bench = s, (blockType) -> blockType.bench, (blockType, parent) -> blockType.bench = parent.bench).add()).appendInherited( (, BlockGathering.CODEC), (blockType, s) -> blockType.gathering = s, (blockType) -> blockType.gathering, (blockType, parent) -> blockType.gathering = parent.gathering).add()).appendInherited( (, BlockPlacementSettings.CODEC), (blockType, s) -> blockType.placementSettings = s, (blockType) -> blockType.placementSettings, (blockType, parent) -> blockType.placementSettings = parent.placementSettings).add()).appendInherited( (, FarmingData.CODEC), (blockType, farming) -> blockType.farming = farming, (blockType) -> blockType.farming, (blockType, parent) -> blockType.farming = parent.farming).add()).appendInherited( (, Codec.BOOLEAN), (blockType, s) -> blockType.isDoor = s, (blockType) -> blockType.isDoor, (blockType, parent) -> blockType.isDoor = parent.isDoor).add()).appendInherited( (, Codec.BOOLEAN), (blockType, b) -> blockType.allowsMultipleUsers = b, (blockType) -> blockType.allowsMultipleUsers, (blockType, parent) -> blockType.allowsMultipleUsers = parent.allowsMultipleUsers).add()).appendInherited( (, Codec.STRING), (blockType, o) -> blockType.hitboxType = o, (blockType) -> blockType.hitboxType, (blockType, parent) -> blockType.hitboxType = parent.hitboxType).addValidator(BlockBoundingBoxes.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, Codec.STRING), (blockType, o) -> blockType.interactionHitboxType = o, (blockType) -> blockType.interactionHitboxType, (blockType, parent) -> blockType.interactionHitboxType = parent.interactionHitboxType).addValidator(BlockBoundingBoxes.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, Codec.STRING), (blockType, s) -> blockType.interactionHint = s, (blockType) -> blockType.interactionHint, (blockType, parent) -> blockType.interactionHint = parent.interactionHint).documentation().add()).appendInherited( (, Codec.INTEGER), (blockType, s) -> blockType.damageToEntities = s, (blockType) -> blockType.damageToEntities, (blockType, parent) -> blockType.damageToEntities = parent.damageToEntities).add()).appendInherited( (,  (InteractionType.class, RootInteraction.CHILD_ASSET_CODEC)), (item, v) -> item.interactions = MapUtil.combineUnmodifiable(item.interactions, v, () ->  (InteractionType.class)), (item) -> item.interactions, (item, parent) -> item.interactions = parent.interactions).addValidator(RootInteraction.VALIDATOR_CACHE.getMapValueValidator()).metadata( ()).add()).appendInherited( (, Codec.STRING), (blockType, o) -> blockType.blockSoundSetId = o, (blockType) -> blockType.blockSoundSetId, (blockType, parent) -> blockType.blockSoundSetId = parent.blockSoundSetId).documentation().addValidator(BlockSoundSet.VALIDATOR_CACHE.getValidator()).metadata( ()).add()).appendInherited( (, Codec.STRING), (blockType, s) -> blockType.ambientSoundEventId = s, (blockType) -> blockType.ambientSoundEventId, (blockType, parent) -> blockType.ambientSoundEventId = parent.ambientSoundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.MONO).addValidator(SoundEventValidators.LOOPING).documentation().add()).appendInherited( (, Codec.STRING), (blockType, s) -> blockType.interactionSoundEventId = s, (blockType) -> blockType.interactionSoundEventId, (blockType, parent) -> blockType.interactionSoundEventId = parent.interactionSoundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.MONO).addValidator(SoundEventValidators.ONESHOT).documentation().add()).appendInherited( (, Codec.BOOLEAN), (blockType, s) -> blockType.isLooping = s, (blockType) -> blockType.isLooping, (blockType, parent) -> blockType.isLooping = parent.isLooping).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).add()).appendInherited( (, SupportDropType.CODEC), (blockType, o) -> blockType.supportDropType = o, (blockType) -> blockType.supportDropType, (blockType, parent) -> blockType.supportDropType = parent.supportDropType).metadata( ()).add()).appendInherited( (, Codec.INTEGER), (blockType, i) -> blockType.maxSupportDistance = i, (blockType) -> blockType.maxSupportDistance, (blockType, parent) -> blockType.maxSupportDistance = parent.maxSupportDistance).addValidator(Validators.range(, )).add()).appendInherited( (,  (BlockSupportsRequiredForType.class)), (blockType, o) -> blockType.blockSupportsRequiredFor = o, (blockType) -> blockType.blockSupportsRequiredFor, (blockType, parent) -> blockType.blockSupportsRequiredFor = parent.blockSupportsRequiredFor).addValidator(Validators.nonNull()).add()).appendInherited( (,  (BlockFace.class, MergedBlockFaces.class, MergedBlockFaces::getComponents, ArrayUtil::combine,  (RequiredBlockFaceSupport.CODEC, (x$) ->  [x$]))), (blockType, o) -> blockType.support = o, (blockType) -> blockType.support, (blockType, parent) -> blockType.support = parent.support).addValidator(RequiredBlockFaceSupportValidator.INSTANCE).documentation().add()).appendInherited( (,  (BlockFace.class, MergedBlockFaces.class, MergedBlockFaces::getComponents, ArrayUtil::combine,  (BlockFaceSupport.CODEC, (x$) ->  [x$]))), (blockType, o) -> blockType.supporting = o, (blockType) -> blockType.supporting, (blockType, parent) -> blockType.supporting = parent.supporting).add()).documentation()).appendInherited( (, Codec.BOOLEAN), (o, i) -> o.ignoreSupportWhenPlaced = i, (o) -> o.ignoreSupportWhenPlaced, (o, p) -> o.ignoreSupportWhenPlaced = p.ignoreSupportWhenPlaced).documentation().add()).append( (,  (Codec.STRING, (x$) ->  [x$])), (blockType, o) -> blockType.aliases = o, (blockType) -> blockType.aliases).documentation().add()).append( (, ProtocolCodecs.COLOR_ARRAY), (blockType, o) -> {
         blockType.tintUp = o;
         blockType.tintDown = o;
         blockType.tintNorth = o;
         blockType.tintSouth = o;
         blockType.tintWest = o;
         blockType.tintEast = o;
      }, (blockType) -> ).metadata( ()).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MAP_GEOMETRY})).add()).appendInherited( (, ProtocolCodecs.COLOR_ARRAY), (blockType, o) -> blockType.tintUp = o, (blockType) -> blockType.tintUp, (blockType, parent) -> blockType.tintUp = parent.tintUp).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MAP_GEOMETRY})).add()).appendInherited( (, ProtocolCodecs.COLOR_ARRAY), (blockType, o) -> blockType.tintDown = o, (blockType) -> blockType.tintDown, (blockType, parent) -> blockType.tintDown = parent.tintDown).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MAP_GEOMETRY})).add()).appendInherited( (, ProtocolCodecs.COLOR_ARRAY), (blockType, o) -> blockType.tintNorth = o, (blockType) -> blockType.tintNorth, (blockType, parent) -> blockType.tintNorth = parent.tintNorth).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MAP_GEOMETRY})).add()).appendInherited( (, ProtocolCodecs.COLOR_ARRAY), (blockType, o) -> blockType.tintSouth = o, (blockType) -> blockType.tintSouth, (blockType, parent) -> blockType.tintSouth = parent.tintSouth).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MAP_GEOMETRY})).add()).appendInherited( (, ProtocolCodecs.COLOR_ARRAY), (blockType, o) -> blockType.tintWest = o, (blockType) -> blockType.tintWest, (blockType, parent) -> blockType.tintWest = parent.tintWest).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MAP_GEOMETRY})).add()).appendInherited( (, ProtocolCodecs.COLOR_ARRAY), (blockType, o) -> blockType.tintEast = o, (blockType) -> blockType.tintEast, (blockType, parent) -> blockType.tintEast = parent.tintEast).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MAP_GEOMETRY})).add()).append( (, Codec.INTEGER), (blockType, o) -> {
         blockType.biomeTintUp = o;
         blockType.biomeTintDown = o;
         blockType.biomeTintNorth = o;
         blockType.biomeTintSouth = o;
         blockType.biomeTintWest = o;
         blockType.biomeTintEast = o;
      }, (blockType) -> ).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MAP_GEOMETRY})).add()).appendInherited( (, Codec.INTEGER), (blockType, o) -> blockType.biomeTintUp = o, (blockType) -> blockType.biomeTintUp, (blockType, parent) -> blockType.biomeTintUp = parent.biomeTintUp).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MAP_GEOMETRY})).add()).appendInherited( (, Codec.INTEGER), (blockType, o) -> blockType.biomeTintDown = o, (blockType) -> blockType.biomeTintDown, (blockType, parent) -> blockType.biomeTintDown = parent.biomeTintDown).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MAP_GEOMETRY})).add()).appendInherited( (, Codec.INTEGER), (blockType, o) -> blockType.biomeTintNorth = o, (blockType) -> blockType.biomeTintNorth, (blockType, parent) -> blockType.biomeTintNorth = parent.biomeTintNorth).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MAP_GEOMETRY})).add()).appendInherited( (, Codec.INTEGER), (blockType, o) -> blockType.biomeTintSouth = o, (blockType) -> blockType.biomeTintSouth, (blockType, parent) -> blockType.biomeTintSouth = parent.biomeTintSouth).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MAP_GEOMETRY})).add()).appendInherited( (, Codec.INTEGER), (blockType, o) -> blockType.biomeTintWest = o, (blockType) -> blockType.biomeTintWest, (blockType, parent) -> blockType.biomeTintWest = parent.biomeTintWest).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MAP_GEOMETRY})).add()).appendInherited( (, Codec.INTEGER), (blockType, o) -> blockType.biomeTintEast = o, (blockType) -> blockType.biomeTintEast, (blockType, parent) -> blockType.biomeTintEast = parent.biomeTintEast).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MAP_GEOMETRY})).add()).appendInherited( (, StateData.CODEC), (blockType, s) -> {
         s.copyFrom(blockType.state);
         blockType.state = s;
      }, (blockType) -> blockType.state, (blockType, parent) -> blockType.state = parent.state).metadata( ()).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (,  (ChunkStore.HOLDER_CODEC_KEY)), (blockType, s) -> blockType.blockEntity = s, (blockType) -> blockType.blockEntity, (blockType, parent) -> blockType.blockEntity = parent.blockEntity).metadata( ()).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, ProtocolCodecs.RAIL_CONFIG_CODEC), (o, v) -> o.railConfig = v, (o) -> o.railConfig, (o, p) -> o.railConfig = p.railConfig).add()).afterDecode(BlockType::processConfig)).build();
      EMPTY_ALIAS_LIST =  [];
      StateData.addDefinitions();
      VALIDATOR_CACHE =  <String>( (BlockType::getAssetStore));
      UNKNOWN_CUSTOM_MODEL_TEXTURE =  []{ (, )};
      UNKNOWN_BLOCK_TEXTURES =  []{ (, , , , , , )};
      REQUIRED_BOTTOM_FACE_SUPPORT = Collections.unmodifiableMap( <BlockFace, RequiredBlockFaceSupport[]>(BlockFace.class) {
         {
            .put(BlockFace.DOWN,  []{ ()});
         }
      });
      BLOCK_FACE_SUPPORT_ALL_ARRAY =  []{BlockFaceSupport.ALL};
      ALL_SUPPORTING_FACES = Collections.unmodifiableMap( <BlockFace, BlockFaceSupport[]>(BlockFace.class) {
         {
            (BlockFace blockFace : BlockFace.VALUES) {
               .put(blockFace, BlockType.BLOCK_FACE_SUPPORT_ALL_ARRAY);
            }

         }
      });
      DEFAULT_SHADER_EFFECTS =  []{ShaderType.None};
      DEFAULT_BLOCK_TYPE =  ();
      KEY_SERIALIZER = (buf, id) -> {
            ((BlockType)getAssetMap().getAssetOrDefault(id, UNKNOWN)).getId();
         ByteBufUtil.writeUTF(buf, key);
      };
      KEY_DESERIALIZER = (byteBuf) -> {
            ByteBufUtil.readUTF(byteBuf);
          getBlockIdOrUnknown(blockType, , blockType);
      };
      EMPTY =  () {
         {
            .drawType = DrawType.Empty;
            .material = BlockMaterial.Empty;
            .opacity = Opacity.Transparent;
            .group = ;
            .support = Collections.emptyMap();
            .processConfig();
         }
      };
      UNKNOWN =  () {
         {
            .unknown = ;
            .drawType = DrawType.Cube;
            .material = BlockMaterial.Solid;
            .processConfig();
         }
      };
      DEBUG_CUBE =  () {
         {
            .drawType = DrawType.Cube;
            .material = BlockMaterial.Solid;
            .variantRotation = VariantRotation.Debug;
            .textures =  []{ (, , , , , , )};
            .processConfig();
         }
      };
      DEBUG_MODEL =  () {
         {
            .drawType = DrawType.Model;
            .material = BlockMaterial.Empty;
            .variantRotation = VariantRotation.Debug;
            .customModel = ;
            .customModelTexture =  []{ (, )};
            .processConfig();
         }
      };
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/BlockTypeTextures.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.BlockTextures;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import javax.annotation.Nonnull;

public class BlockTypeTextures {
   public static final BuilderCodec<BlockTypeTextures> CODEC;
   protected String up = "BlockTextures/Unknown.png";
   protected String down = "BlockTextures/Unknown.png";
   protected String north = "BlockTextures/Unknown.png";
   protected String south = "BlockTextures/Unknown.png";
   protected String east = "BlockTextures/Unknown.png";
   protected String west = "BlockTextures/Unknown.png";
   protected int weight  ;

     {
   }

     {
      .up = all;
      .down = all;
      .north = all;
      .south = all;
      .east = all;
      .west = all;
   }

     {
      .up = up;
      .down = down;
      .north = north;
      .south = south;
      .east = east;
      .west = west;
      .weight = weight;
   }

    String  {
       .up;
   }

    String  {
       .down;
   }

    String  {
       .north;
   }

    String  {
       .south;
   }

    String  {
       .east;
   }

    String  {
       .west;
   }

      {
       ().weight;
   }

   
    BlockTextures  {
          ();
      packet.top = .up;
      packet.bottom = .down;
      packet.front = .south;
      packet.back = .north;
      packet.left = .west;
      packet.right = .east;
      packet.weight = ().weight / totalWeight;
       packet;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(BlockTypeTextures.class, BlockTypeTextures::).append( (, Codec.STRING), (blockType, o) -> {
         blockType.up = o;
         blockType.down = o;
         blockType.north = o;
         blockType.south = o;
         blockType.west = o;
         blockType.east = o;
      }, (blockType) -> ).addValidator(CommonAssetValidator.TEXTURE_ITEM).add()).append( (, Codec.STRING), (blockType, o) -> {
         blockType.north = o;
         blockType.south = o;
         blockType.west = o;
         blockType.east = o;
      }, (blockType) -> ).addValidator(CommonAssetValidator.TEXTURE_ITEM).add()).append( (, Codec.STRING), (blockType, o) -> {
         blockType.up = o;
         blockType.down = o;
      }, (blockType) -> ).addValidator(CommonAssetValidator.TEXTURE_ITEM).add()).appendInherited( (, Codec.STRING), (blockType, o) -> blockType.up = o, (blockType) -> blockType.up, (blockType, parent) -> blockType.up = parent.up).addValidator(CommonAssetValidator.TEXTURE_ITEM).add()).appendInherited( (, Codec.STRING), (blockType, o) -> blockType.down = o, (blockType) -> blockType.down, (blockType, parent) -> blockType.down = parent.down).addValidator(CommonAssetValidator.TEXTURE_ITEM).add()).appendInherited( (, Codec.STRING), (blockType, o) -> blockType.north = o, (blockType) -> blockType.north, (blockType, parent) -> blockType.north = parent.north).addValidator(CommonAssetValidator.TEXTURE_ITEM).add()).appendInherited( (, Codec.STRING), (blockType, o) -> blockType.south = o, (blockType) -> blockType.south, (blockType, parent) -> blockType.south = parent.south).addValidator(CommonAssetValidator.TEXTURE_ITEM).add()).appendInherited( (, Codec.STRING), (blockType, o) -> blockType.west = o, (blockType) -> blockType.west, (blockType, parent) -> blockType.west = parent.west).addValidator(CommonAssetValidator.TEXTURE_ITEM).add()).appendInherited( (, Codec.STRING), (blockType, o) -> blockType.east = o, (blockType) -> blockType.east, (blockType, parent) -> blockType.east = parent.east).addValidator(CommonAssetValidator.TEXTURE_ITEM).add()).appendInherited( (, Codec.INTEGER), (blockType, o) -> blockType.weight = o, (blockType) -> blockType.weight, (blockType, parent) -> blockType.weight = parent.weight).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/CustomModelTexture.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.ModelTexture;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import javax.annotation.Nonnull;

public class CustomModelTexture {
   @Nonnull
   public static BuilderCodec<CustomModelTexture> CODEC;
   private String texture;
   private int weight;

   public CustomModelTexture() {
   }

   public CustomModelTexture(String texture, int weight) {
      this.texture = texture;
      this.weight = weight;
   }

   public String getTexture() {
      return this.texture;
   }

   public int getWeight() {
      return this.weight;
   }

   @Nonnull
   public ModelTexture toPacket(float totalWight) {
      return new ModelTexture(.texture, ().weight / totalWight);
   }

   
    String  {
        + .texture +  + .weight + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(CustomModelTexture.class, CustomModelTexture::).append( (, Codec.STRING), (customModelTexture, s) -> customModelTexture.texture = s, (customModelTexture) -> customModelTexture.texture).addValidator(CommonAssetValidator.TEXTURE_ITEM).add()).addField( (, Codec.INTEGER), (customModelTexture, i) -> customModelTexture.weight = i, (customModelTexture) -> customModelTexture.weight)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/HarvestingDropType.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.Harvesting;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemDropList;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class HarvestingDropType implements NetworkSerializable<Harvesting> {
   public static final BuilderCodec<HarvestingDropType> CODEC;
   protected String itemId;
   protected String dropListId;

   public HarvestingDropType(String itemId, String dropListId) {
      this.itemId = itemId;
      this.dropListId = dropListId;
   }

   protected HarvestingDropType() {
   }

   @Nonnull
   public Harvesting toPacket() {
      Harvesting packet = new Harvesting();
      if (this.itemId != ) {
         packet.itemId = .itemId.toString();
      }

      packet.dropListId = .dropListId;
       packet;
   }

    String  {
       .itemId;
   }

    String  {
       .dropListId;
   }

   
    HarvestingDropType  {
       ;
   }

   
    String  {
        + .itemId +  + .dropListId + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(HarvestingDropType.class, HarvestingDropType::).append( (, Codec.STRING), (harvesting, o) -> harvesting.itemId = o, (harvesting) -> harvesting.itemId).addValidatorLate(() -> Item.VALIDATOR_CACHE.getValidator().late()).add()).append( (,  (ItemDropList.class, ItemDropList.CODEC)), (harvesting, o) -> harvesting.dropListId = o, (harvesting) -> harvesting.dropListId).addValidatorLate(() -> ItemDropList.VALIDATOR_CACHE.getValidator().late()).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/MergedBlockFaces.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.codec.codecs.EnumCodec;
import java.util.Arrays;
import javax.annotation.Nonnull;

public enum MergedBlockFaces {
   ALL(BlockFace.VALUES),
   BLOCK_SIDES(new BlockFace[]{BlockFace.UP, BlockFace.DOWN, BlockFace.NORTH, BlockFace.EAST, BlockFace.SOUTH, BlockFace.WEST}),
   CARDINAL_DIRECTIONS(new BlockFace[]{BlockFace.NORTH, BlockFace.EAST, BlockFace.SOUTH, BlockFace.WEST}),
   HORIZONTAL(new BlockFace[]{BlockFace.NORTH, BlockFace.NORTH_EAST, BlockFace.EAST, BlockFace.SOUTH_EAST, BlockFace.SOUTH, BlockFace.SOUTH_WEST, BlockFace.WEST, BlockFace.NORTH_WEST}),
   UP_CARDINAL_DIRECTIONS(new BlockFace[]{BlockFace.UP_NORTH, BlockFace.UP_EAST, BlockFace.UP_SOUTH, BlockFace.UP_WEST}),
   DOWN_CARDINAL_DIRECTIONS(new BlockFace[]{BlockFace.DOWN_NORTH, BlockFace.DOWN_EAST, BlockFace.DOWN_SOUTH, BlockFace.DOWN_WEST});

   @Nonnull
   public static EnumCodec<MergedBlockFaces> CODEC = new EnumCodec<MergedBlockFaces>(MergedBlockFaces.class);
   private final BlockFace[] components;

   private MergedBlockFaces(BlockFace... components) {
      this.components = components;
   }

   public BlockFace[] getComponents() {
      return this.components;
   }

   @Nonnull
   public String toString() {
        + Arrays.toString(.components) + ;
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/PhysicsDropType.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemDropList;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class PhysicsDropType {
   public static final BuilderCodec<PhysicsDropType> CODEC;
   protected String itemId;
   protected String dropListId;

   public PhysicsDropType(String itemId, String dropListId) {
      this.itemId = itemId;
      this.dropListId = dropListId;
   }

   protected PhysicsDropType() {
   }

   public String getItemId() {
      return this.itemId;
   }

   public String getDropListId() {
      return this.dropListId;
   }

   @Nullable
   public PhysicsDropType withoutDrops() {
      return null;
   }

   
    String  {
        + .itemId +  + .dropListId + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(PhysicsDropType.class, PhysicsDropType::).append( (, Codec.STRING), (softBlock, o) -> softBlock.itemId = o, (softBlock) -> softBlock.itemId).addValidatorLate(() -> Item.VALIDATOR_CACHE.getValidator().late()).add()).append( (,  (ItemDropList.class, ItemDropList.CODEC)), (softBlock, o) -> softBlock.dropListId = o, (softBlock) -> softBlock.dropListId).addValidatorLate(() -> ItemDropList.VALIDATOR_CACHE.getValidator().late()).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/RequiredBlockFaceSupport.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.common.util.ArrayUtil;
import com.hypixel.hytale.math.vector.Vector3i;
import com.hypixel.hytale.protocol.SupportMatch;
import com.hypixel.hytale.server.core.asset.type.blockset.config.BlockSet;
import com.hypixel.hytale.server.core.asset.type.fluid.Fluid;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.util.Arrays;
import javax.annotation.Nonnull;

public class RequiredBlockFaceSupport implements NetworkSerializable<com.hypixel.hytale.protocol.RequiredBlockFaceSupport> {
   public static final BuilderCodec<RequiredBlockFaceSupport> CODEC;
   protected String faceType;
   protected String selfFaceType;
   protected String blockSetId;
   protected int blockSetIndex = -2147483648;
   protected String blockTypeId;
   protected String fluidId;
   protected Match matchSelf;
   protected String tagId;
   protected int tagIndex;
    Match support;
     allowSupportPropagation;
     rotate;
    Vector3i[] filler;

     {
      .matchSelf = RequiredBlockFaceSupport.Match.IGNORED;
      .tagIndex = -;
      .support = RequiredBlockFaceSupport.Match.REQUIRED;
      .allowSupportPropagation = ;
      .rotate = ;
   }

     {
      .matchSelf = RequiredBlockFaceSupport.Match.IGNORED;
      .tagIndex = -;
      .support = RequiredBlockFaceSupport.Match.REQUIRED;
      .allowSupportPropagation = ;
      .rotate = ;
      .faceType = faceType;
   }

     {
      .matchSelf = RequiredBlockFaceSupport.Match.IGNORED;
      .tagIndex = -;
      .support = RequiredBlockFaceSupport.Match.REQUIRED;
      .allowSupportPropagation = ;
      .rotate = ;
      .faceType = faceType;
      .selfFaceType = selfFaceType;
      .blockSetId = blockSetId;
      .blockTypeId = blockTypeId;
      .fluidId = fluidId;
      .matchSelf = matchSelf;
      .support = support;
      .allowSupportPropagation = allowSupportPropagation;
      .rotate = rotate;
      .filler = filler;
      .tagId = tagId;
      .tagIndex = tagIndex;
   }

    String  {
       .faceType;
   }

    String  {
       .selfFaceType;
   }

    String  {
       .blockSetId;
   }

      {
       .blockSetIndex;
   }

    String  {
       .blockTypeId;
   }

    String  {
       .fluidId;
   }

    Match  {
       .matchSelf;
   }

    Match  {
       .support;
   }

      {
       .allowSupportPropagation;
   }

      {
       .rotate;
   }

    Vector3i[] getFiller() {
       .filler;
   }

      {
       .filler ==  || ArrayUtil.contains(.filler, filler);
   }

    String  {
       .tagId;
   }

      {
       .tagIndex;
   }

   
    String  {
         .faceType;
        + var10000 +  + .selfFaceType +  + .blockSetId +  + .blockTypeId +  + .fluidId +  + String.valueOf(.matchSelf) +  + String.valueOf(.support) +  + .allowSupportPropagation +  + .rotate +  + Arrays.toString(.filler) +  + .tagId + ;
   }

   
     RequiredBlockFaceSupport  {
      Vector3i[] rotatedFiller = (Vector3i[])ArrayUtil.copyAndMutate(original.filler, (vector) -> Rotation.rotate(vector, rotationYaw, rotationPitch, roll), (x$) ->  [x$]);
        (original.faceType, original.selfFaceType, original.blockSetId, original.blockTypeId, original.fluidId, original.matchSelf, original.support, original.allowSupportPropagation, original.rotate, rotatedFiller, original.tagId, original.tagIndex);
   }

   
    com.hypixel.hytale.protocol.RequiredBlockFaceSupport  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.RequiredBlockFaceSupport();
      packet.faceType = .faceType;
      packet.selfFaceType = .selfFaceType;
      packet.tagIndex = .tagIndex;
      packet.blockTypeId = .blockTypeId ==  ? - : BlockType.getAssetMap().getIndex(.blockTypeId);
       (packet.blockTypeId == -) {
           ( + .blockTypeId);
      }  {
         packet.fluidId = .fluidId ==  ? - : Fluid.getAssetMap().getIndex(.fluidId);
          (packet.fluidId == -) {
              ( + .fluidId);
         }  {
            packet.allowSupportPropagation = .allowSupportPropagation;
            packet.rotate = .rotate;
            packet.blockSetId = .blockSetId;
            SupportMatch var10001;
             (.support.ordinal()) {
                 -> var10001 = SupportMatch.Ignored;
                 -> var10001 = SupportMatch.Required;
                 -> var10001 = SupportMatch.Disallowed;
                ->   ((String), (Throwable));
            }

            packet.support = var10001;
             (.matchSelf.ordinal()) {
                 -> var10001 = SupportMatch.Ignored;
                 -> var10001 = SupportMatch.Required;
                 -> var10001 = SupportMatch.Disallowed;
                ->   ((String), (Throwable));
            }

            packet.matchSelf = var10001;
             (.filler != ) {
               com.hypixel.hytale.protocol.Vector3i[] filler =  .hypixel.hytale.protocol.Vector3i[.filler.length];

               (   ; j < .filler.length; ++j) {
                     .filler[j];
                  filler[j] =  .hypixel.hytale.protocol.Vector3i(fillerVector.x, fillerVector.y, fillerVector.z);
               }

               packet.filler = filler;
            }

             packet;
         }
      }
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(RequiredBlockFaceSupport.class, RequiredBlockFaceSupport::).append( (, Codec.STRING), (blockFaceSupport, o) -> blockFaceSupport.faceType = o, (blockFaceSupport) -> blockFaceSupport.faceType).documentation().add()).addField( (, Codec.STRING), (blockFaceSupport, o) -> blockFaceSupport.selfFaceType = o, (blockFaceSupport) -> blockFaceSupport.selfFaceType)).addField( (, Codec.STRING), (blockFaceSupport, o) -> blockFaceSupport.blockSetId = o, (blockFaceSupport) -> blockFaceSupport.blockSetId)).addField( (, Codec.STRING), (blockFaceSupport, o) -> blockFaceSupport.blockTypeId = o, (blockFaceSupport) -> blockFaceSupport.blockTypeId)).addField( (, Codec.STRING), (blockFaceSupport, o) -> blockFaceSupport.fluidId = o, (blockFaceSupport) -> blockFaceSupport.fluidId)).addField( (, RequiredBlockFaceSupport.Match.CODEC), (requiredBlockFaceSupport, b) -> requiredBlockFaceSupport.matchSelf = b, (requiredBlockFaceSupport) -> requiredBlockFaceSupport.matchSelf)).addField( (, RequiredBlockFaceSupport.Match.CODEC), (requiredBlockFaceSupport, b) -> requiredBlockFaceSupport.support = b, (requiredBlockFaceSupport) -> requiredBlockFaceSupport.support)).addField( (, Codec.BOOLEAN), (requiredBlockFaceSupport, b) -> requiredBlockFaceSupport.allowSupportPropagation = b, (requiredBlockFaceSupport) -> requiredBlockFaceSupport.allowSupportPropagation)).addField( (, Codec.BOOLEAN), (requiredBlockFaceSupport, b) -> requiredBlockFaceSupport.rotate = b, (requiredBlockFaceSupport) -> requiredBlockFaceSupport.rotate)).addField( (,  (Vector3i.CODEC, (x$) ->  [x$])), (blockFaceSupport, o) -> blockFaceSupport.filler = o, (blockFaceSupport) -> blockFaceSupport.filler)).append( (, Codec.STRING), (requiredBlockFaceSupport, s) -> requiredBlockFaceSupport.tagId = s, (requiredBlockFaceSupport) -> requiredBlockFaceSupport.tagId).add()).afterDecode((blockFaceSupport) -> {
          (blockFaceSupport.blockSetId != ) {
               BlockSet.getAssetMap().getIndex(blockFaceSupport.blockSetId);
             (index == -) {
                 ( + blockFaceSupport.blockSetId);
            }

            blockFaceSupport.blockSetIndex = index;
         }

          (blockFaceSupport.tagId != ) {
            blockFaceSupport.tagIndex = AssetRegistry.getOrCreateTagIndex(blockFaceSupport.tagId);
         }

      })).build();
   }

       {
      IGNORED,
      REQUIRED,
      DISALLOWED;

         EnumCodec<Match> CODEC =  <Match>(Match.class);

        {
      }
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/RequiredBlockFaceSupportValidator.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.codec.validation.LegacyValidator;
import com.hypixel.hytale.codec.validation.ValidationResults;
import java.util.Map;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

class RequiredBlockFaceSupportValidator implements LegacyValidator<Map<BlockFace, RequiredBlockFaceSupport[]>> {
   static final RequiredBlockFaceSupportValidator INSTANCE = new RequiredBlockFaceSupportValidator();

   RequiredBlockFaceSupportValidator() {
   }

   public void accept(@Nullable Map<BlockFace, RequiredBlockFaceSupport[]> support, @Nonnull ValidationResults results) {
      if (support != null) {
         for(Map.Entry<BlockFace, RequiredBlockFaceSupport[]> entry : support.entrySet()) {
            BlockFace blockFace = (BlockFace)entry.getKey();
            RequiredBlockFaceSupport[] requiredBlockFaceSupports = (RequiredBlockFaceSupport[])entry.getValue();

            for(int i = 0; i < requiredBlockFaceSupports.length; ++i) {
               RequiredBlockFaceSupport blockFaceSupport = requiredBlockFaceSupports[i];
               if (blockFaceSupport == ) {
                     String.valueOf(blockFace);
                  results.fail( + var10001 +  + i + );
               }  {
                     blockFaceSupport.getFaceType() ==  && blockFaceSupport.getBlockSetId() ==  && blockFaceSupport.getBlockTypeId() ==  && blockFaceSupport.getFluidId() ==  && blockFaceSupport.getMatchSelf() == RequiredBlockFaceSupport.Match.IGNORED && blockFaceSupport.getTagId() == ;
                   (blockFaceSupport.getSupport() != RequiredBlockFaceSupport.Match.IGNORED && noRequirements) {
                        String.valueOf(blockFace);
                     results.warn( + var10 +  + i + );
                  }

                   (blockFaceSupport.getSupport() == RequiredBlockFaceSupport.Match.IGNORED && !blockFaceSupport.allowsSupportPropagation()) {
                        String.valueOf(blockFace);
                     results.warn( + var11 +  + i + );
                  }
               }
            }
         }

      }
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/Rotation.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.math.Axis;
import com.hypixel.hytale.math.util.MathUtil;
import com.hypixel.hytale.math.vector.Vector3d;
import com.hypixel.hytale.math.vector.Vector3f;
import com.hypixel.hytale.math.vector.Vector3i;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import com.hypixel.hytale.server.core.util.FillerBlockUtil;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public enum Rotation implements NetworkSerializable<com.hypixel.hytale.protocol.Rotation> {
   None(0, com.hypixel.hytale.protocol.Rotation.None, Axis.Z, Vector3i.NEG_Z),
   Ninety(90, com.hypixel.hytale.protocol.Rotation.Ninety, Axis.X, Vector3i.NEG_X),
   OneEighty(180, com.hypixel.hytale.protocol.Rotation.OneEighty, Axis.Z, Vector3i.POS_Z),
   TwoSeventy(270, com.hypixel.hytale.protocol.Rotation.TwoSeventy, Axis.X, Vector3i.POS_X);

   public static final Rotation[] VALUES = values();
   public static final Rotation[] NORMAL = new Rotation[]{None, Ninety, OneEighty, TwoSeventy};
   public static final Codec<Rotation> CODEC = new EnumCodec<Rotation>(Rotation.class);
   private final  degrees;
     com.hypixel.hytale.protocol.Rotation packet;
     Axis axisOfAlignment;
     Vector3i axisDirection;

     {
      .degrees = degrees;
      .packet = packet;
      .axisOfAlignment = axisOfAlignment;
      .axisDirection = axisDirection;
   }

    com.hypixel.hytale.protocol.Rotation  {
       .packet;
   }

      {
       .degrees;
   }

      {
       Math.toRadians(().degrees);
   }

    Axis  {
       .axisOfAlignment;
   }

    Vector3i  {
       .axisDirection;
   }

   
    Rotation  {
       .add(OneEighty);
   }

   
    Rotation  {
       .axisOfAlignment != axis ?  : .flip();
   }

   
    Rotation  {
       rotation ==  ?  : ofDegrees(.degrees - rotation.degrees);
   }

   
    Rotation  {
       rotation ==  ?  : ofDegrees(.degrees + rotation.degrees);
   }

     Rotation  {
       a ==  ? b : a.add(b);
   }

   
    Vector3i  {
       .rotateX(in, out);
   }

   
    Vector3f  {
       .rotateX(in, out);
   }

      {
       var10000;
       (.ordinal()) {
           -> var10000 = filler;
           -> var10000 = FillerBlockUtil.pack(FillerBlockUtil.unpackX(filler), -FillerBlockUtil.unpackZ(filler), FillerBlockUtil.unpackY(filler));
           -> var10000 = FillerBlockUtil.pack(FillerBlockUtil.unpackX(filler), -FillerBlockUtil.unpackY(filler), -FillerBlockUtil.unpackZ(filler));
           -> var10000 = FillerBlockUtil.pack(FillerBlockUtil.unpackX(filler), FillerBlockUtil.unpackZ(filler), -FillerBlockUtil.unpackY(filler));
          ->   ((String), (Throwable));
      }

       var10000;
   }

   
    Vector3i  {
      Vector3i var10000;
       (.ordinal()) {
           -> var10000 = out.assign(in);
           -> var10000 = out.assign(in.x, -in.z, in.y);
           -> var10000 = out.assign(in.x, -in.y, -in.z);
           -> var10000 = out.assign(in.x, in.z, -in.y);
          ->   ((String), (Throwable));
      }

       var10000;
   }

   
    Vector3f  {
      Vector3f var10000;
       (.ordinal()) {
           -> var10000 = out.assign(in);
           -> var10000 = out.assign(in.x, -in.z, in.y);
           -> var10000 = out.assign(in.x, -in.y, -in.z);
           -> var10000 = out.assign(in.x, in.z, -in.y);
          ->   ((String), (Throwable));
      }

       var10000;
   }

   
    Vector3d  {
      Vector3d var10000;
       (.ordinal()) {
           -> var10000 = out.assign(in);
           -> var10000 = out.assign(in.x, -in.z, in.y);
           -> var10000 = out.assign(in.x, -in.y, -in.z);
           -> var10000 = out.assign(in.x, in.z, -in.y);
          ->   ((String), (Throwable));
      }

       var10000;
   }

   
    Vector3i  {
       .rotateY(in, out);
   }

   
    Vector3f  {
       .rotateY(in, out);
   }

      {
       var10000;
       (.ordinal()) {
           -> var10000 = filler;
           -> var10000 = FillerBlockUtil.pack(FillerBlockUtil.unpackZ(filler), FillerBlockUtil.unpackY(filler), -FillerBlockUtil.unpackX(filler));
           -> var10000 = FillerBlockUtil.pack(-FillerBlockUtil.unpackX(filler), FillerBlockUtil.unpackY(filler), -FillerBlockUtil.unpackZ(filler));
           -> var10000 = FillerBlockUtil.pack(-FillerBlockUtil.unpackZ(filler), FillerBlockUtil.unpackY(filler), FillerBlockUtil.unpackX(filler));
          ->   ((String), (Throwable));
      }

       var10000;
   }

   
    Vector3i  {
      Vector3i var10000;
       (.ordinal()) {
           -> var10000 = out.assign(in);
           -> var10000 = out.assign(in.z, in.y, -in.x);
           -> var10000 = out.assign(-in.x, in.y, -in.z);
           -> var10000 = out.assign(-in.z, in.y, in.x);
          ->   ((String), (Throwable));
      }

       var10000;
   }

   
    Vector3f  {
      Vector3f var10000;
       (.ordinal()) {
           -> var10000 = out.assign(in);
           -> var10000 = out.assign(in.z, in.y, -in.x);
           -> var10000 = out.assign(-in.x, in.y, -in.z);
           -> var10000 = out.assign(-in.z, in.y, in.x);
          ->   ((String), (Throwable));
      }

       var10000;
   }

   
    Vector3d  {
      Vector3d var10000;
       (.ordinal()) {
           -> var10000 = out.assign(in);
           -> var10000 = out.assign(in.z, in.y, -in.x);
           -> var10000 = out.assign(-in.x, in.y, -in.z);
           -> var10000 = out.assign(-in.z, in.y, in.x);
          ->   ((String), (Throwable));
      }

       var10000;
   }

   
    Vector3i  {
       .rotateZ(in, out);
   }

   
    Vector3f  {
       .rotateZ(in, out);
   }

      {
       var10000;
       (.ordinal()) {
           -> var10000 = filler;
           -> var10000 = FillerBlockUtil.pack(-FillerBlockUtil.unpackY(filler), FillerBlockUtil.unpackX(filler), FillerBlockUtil.unpackZ(filler));
           -> var10000 = FillerBlockUtil.pack(-FillerBlockUtil.unpackX(filler), -FillerBlockUtil.unpackY(filler), FillerBlockUtil.unpackZ(filler));
           -> var10000 = FillerBlockUtil.pack(FillerBlockUtil.unpackY(filler), -FillerBlockUtil.unpackX(filler), FillerBlockUtil.unpackZ(filler));
          ->   ((String), (Throwable));
      }

       var10000;
   }

   
    Vector3i  {
      Vector3i var10000;
       (.ordinal()) {
           -> var10000 = out.assign(in);
           -> var10000 = out.assign(-in.y, in.x, in.z);
           -> var10000 = out.assign(-in.x, -in.y, in.z);
           -> var10000 = out.assign(in.y, -in.x, in.z);
          ->   ((String), (Throwable));
      }

       var10000;
   }

   
    Vector3f  {
      Vector3f var10000;
       (.ordinal()) {
           -> var10000 = out.assign(in);
           -> var10000 = out.assign(-in.y, in.x, in.z);
           -> var10000 = out.assign(-in.x, -in.y, in.z);
           -> var10000 = out.assign(in.y, -in.x, in.z);
          ->   ((String), (Throwable));
      }

       var10000;
   }

   
    Vector3d  {
      Vector3d var10000;
       (.ordinal()) {
           -> var10000 = out.assign(in);
           -> var10000 = out.assign(-in.y, in.x, in.z);
           -> var10000 = out.assign(-in.x, -in.y, in.z);
           -> var10000 = out.assign(in.y, -in.x, in.z);
          ->   ((String), (Throwable));
      }

       var10000;
   }

   
     Rotation  {
      degrees = Math.floorMod(degrees, );
      Rotation var10000;
       (degrees) {
           -> var10000 = None;
           -> var10000 = Ninety;
           -> var10000 = OneEighty;
           -> var10000 = TwoSeventy;
          ->   ( + degrees + );
      }

       var10000;
   }

     Rotation  {
       (degrees < ) {
         degrees = degrees %  + ;
      }

       VALUES[MathUtil.fastRound(degrees / ) % VALUES.length];
   }

   
     Rotation  {
      Rotation var10000;
       (packet) {
          None -> var10000 = None;
          Ninety -> var10000 = Ninety;
          OneEighty -> var10000 = OneEighty;
          TwoSeventy -> var10000 = TwoSeventy;
          ->   ((String), (Throwable));
      }

       var10000;
   }

   
     Vector3i  {
         vector3i.clone();
      rotationPitch.rotatePitch(rotated, rotated);
      rotationYaw.rotateYaw(rotated, rotated);
       rotated;
   }

   
     Vector3i  {
         rotate(vector3i, rotationYaw, rotationPitch);
      rotationRoll.rotateRoll(rotated, rotated);
       rotated;
   }

   
     Vector3f  {
         vector3f.clone();
      rotationPitch.rotatePitch(rotated, rotated);
      rotationYaw.rotateYaw(rotated, rotated);
      rotationRoll.rotateRoll(rotated, rotated);
       rotated;
   }

   
     Vector3d  {
         vector3d.clone();
      rotationPitch.rotateX(rotated, rotated);
      rotationYaw.rotateY(rotated, rotated);
      rotationRoll.rotateZ(rotated, rotated);
       rotated;
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/RotationTuple.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.math.vector.Vector3d;
import javax.annotation.Nonnull;

public record RotationTuple(int index, Rotation yaw, Rotation pitch, Rotation roll) {
   public static final RotationTuple[] EMPTY_ARRAY = new RotationTuple[0];
   public static final RotationTuple NONE;
   public static final int NONE_INDEX = 0;
   @Nonnull
   public static final RotationTuple[] VALUES;

   public static RotationTuple of(@Nonnull Rotation yaw, @Nonnull Rotation pitch, @Nonnull Rotation roll) {
      return VALUES[index(yaw, pitch, roll)];
   }

   public static RotationTuple of(@Nonnull Rotation yaw, @Nonnull Rotation pitch) {
      return VALUES[index(yaw, pitch, Rotation.None)];
   }

   public static int index {
       roll.ordinal() * Rotation.VALUES.length * Rotation.VALUES.length + pitch.ordinal() * Rotation.VALUES.length + yaw.ordinal();
   }

     RotationTuple  {
       VALUES[index];
   }

     RotationTuple  {
         ;

      (   ; i < rotations.length; ++i) {
            rotations[i];
          (pair.equals(rotationPair)) {
            index = i;
            ;
         }
      }

       rotations[(index + rotation.ordinal()) % Rotation.VALUES.length];
   }

   
    Vector3d  {
       Rotation.rotate(vector, .yaw, .pitch, .roll);
   }

    {
      NONE =  (, Rotation.None, Rotation.None, Rotation.None);
      RotationTuple[] arr =  [Rotation.VALUES.length * Rotation.VALUES.length * Rotation.VALUES.length];
      arr[] = NONE;

      (Rotation roll : Rotation.VALUES) {
         (Rotation pitch : Rotation.VALUES) {
            (Rotation yaw : Rotation.VALUES) {
                (yaw != Rotation.None || pitch != Rotation.None || roll != Rotation.None) {
                     index(yaw, pitch, roll);
                  arr[index] =  (index, yaw, pitch, roll);
               }
            }
         }
      }

      VALUES = arr;
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/SoftBlockDropType.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.SoftBlock;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemDropList;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;

public class SoftBlockDropType implements NetworkSerializable<SoftBlock> {
   public static final BuilderCodec<SoftBlockDropType> CODEC;
   protected String itemId;
   protected String dropListId;
   protected boolean isWeaponBreakable = true;

   public SoftBlockDropType(String itemId, String dropListId, boolean isWeaponBreakable) {
      this.itemId = itemId;
      this.dropListId = dropListId;
      this.isWeaponBreakable = isWeaponBreakable;
   }

   protected SoftBlockDropType() {
   }

   @Nonnull
   public SoftBlock toPacket() {
          ();
       (.itemId != ) {
         packet.itemId = .itemId.toString();
      }

      packet.dropListId = .dropListId;
      packet.isWeaponBreakable = .isWeaponBreakable;
       packet;
   }

    String  {
       .itemId;
   }

    String  {
       .dropListId;
   }

      {
       .isWeaponBreakable;
   }

   
    SoftBlockDropType  {
        ((String), (String), .isWeaponBreakable);
   }

   
    String  {
        + .itemId +  + .dropListId +  + .isWeaponBreakable + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(SoftBlockDropType.class, SoftBlockDropType::).append( (, Codec.STRING), (softBlock, o) -> softBlock.itemId = o, (softBlock) -> softBlock.itemId).addValidatorLate(() -> Item.VALIDATOR_CACHE.getValidator().late()).add()).append( (,  (ItemDropList.class, ItemDropList.CODEC)), (softBlock, o) -> softBlock.dropListId = o, (softBlock) -> softBlock.dropListId).addValidatorLate(() -> ItemDropList.VALIDATOR_CACHE.getValidator().late()).add()).addField( (, Codec.BOOLEAN), (blockGathering, o) -> blockGathering.isWeaponBreakable = o, (blockGathering) -> blockGathering.isWeaponBreakable)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/StateData.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.codec.lookup.CodecMapCodec;
import com.hypixel.hytale.codec.lookup.Priority;
import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class StateData {
   public static final String NULL_STATE_ID = "default";
   public static final BuilderCodec.Builder<StateData> DEFAULT_CODEC_BUILDER;
   public static final BuilderCodec<StateData> DEFAULT_CODEC;
   public static final CodecMapCodec<StateData> CODEC;
   private String id;
   private Map<String, String> stateToBlock;
   private Map<String, String> blockToState;

   protected  {
   }

     {
      .id = id;
   }

   
    String  {
       .id;
   }

   
    String  {
       .stateToBlock ==  ?  : (String).stateToBlock.get(state);
   }

   
    String  {
       .blockToState ==  ?  : (String).blockToState.get(blockTypeKey);
   }

   
    Map<String, Integer>  {
       (.stateToBlock == ) {
          ;
      }  {
         Map<String, Integer> data =  ();

         (String state : .stateToBlock.keySet()) {
               current.getBlockKeyForState(state);
               BlockType.getAssetMap().getIndex(key);
             (index != -) {
               data.put(state, index);
            }
         }

          data;
      }
   }

   
    String  {
         .id;
        + var10000 +  + String.valueOf(.stateToBlock) + ;
   }

      {
       (state !=  && .stateToBlock == ) {
         .stateToBlock = state.stateToBlock;
         .blockToState = state.blockToState;
      }
   }

      {
      DEFAULT_CODEC_BUILDER.addField( (,  ( (BlockType.class, BlockType.CODEC, ContainedAssetCodec.Mode.INJECT_PARENT, StateData::generateBlockKey), HashMap::)), (stateData, m) -> stateData.stateToBlock = m, (stateData) -> stateData.stateToBlock);
   }

   
     String  {
         extraInfo.getKey();
          + key +  + extraInfo.peekKey();
       newName;
   }

    {
      DEFAULT_CODEC_BUILDER = (BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(StateData.class, StateData::).appendInherited( (, Codec.STRING), (stateData, s) -> stateData.id = s, (stateData) -> stateData.id, (o, p) -> o.id = p.id).add()).afterDecode((stateData, extraInfo) -> {
          (stateData.stateToBlock != ) {
            Map<String, String> map =  <String, String>();

            (Map.Entry<String, String> entry : stateData.stateToBlock.entrySet()) {
               map.put((String)entry.getValue(), (String)entry.getKey());
            }

            stateData.blockToState = Collections.unmodifiableMap(map);
         }

      });
      DEFAULT_CODEC = DEFAULT_CODEC_BUILDER.build();
      CODEC = ( ()).register(Priority.DEFAULT, (String), StateData.class, DEFAULT_CODEC);
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/SupportDropType.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.codec.codecs.EnumCodec;

public enum SupportDropType {
   BREAK,
   DESTROY;

   public static final EnumCodec<SupportDropType> CODEC = new EnumCodec<SupportDropType>(SupportDropType.class);

   private SupportDropType() {
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/VariantRotation.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config;

import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.util.function.BiFunction;
import java.util.function.Function;
import javax.annotation.Nonnull;

public enum VariantRotation implements NetworkSerializable<com.hypixel.hytale.protocol.VariantRotation> {
   None(com.hypixel.hytale.protocol.VariantRotation.None, RotationTuple.EMPTY_ARRAY, (pair) -> RotationTuple.NONE, (pair, rotation) -> RotationTuple.NONE, (pair, rotation) -> RotationTuple.NONE),
   Wall(com.hypixel.hytale.protocol.VariantRotation.Wall, new RotationTuple[]{RotationTuple.of(Rotation.Ninety, Rotation.None)}, (pair) -> pair.yaw() != Rotation.Ninety && pair.yaw() != Rotation.TwoSeventy ? RotationTuple.of(Rotation.None, Rotation.None) : RotationTuple.of(Rotation.Ninety, Rotation.None), (pair, rotation) -> pair, (pair, rotation) -> pair),
   UpDown(com.hypixel.hytale.protocol.VariantRotation.UpDown, new RotationTuple[]{RotationTuple.of(Rotation.None, Rotation.OneEighty)}, (pair) -> pair.pitch() == Rotation.OneEighty ? RotationTuple.of(Rotation.None, Rotation.OneEighty) : RotationTuple.of(Rotation.None, Rotation.None), (pair, rotation) -> RotationTuple.of(pair.yaw(), pair.pitch().add(rotation)), (pair, rotation) -> pair.pitch().add(rotation) == Rotation.OneEighty ? RotationTuple.of(pair.yaw(), Rotation.OneEighty) : RotationTuple.of(pair.yaw(), Rotation.None)),
   Pipe(com.hypixel.hytale.protocol.VariantRotation.Pipe, new RotationTuple[]{RotationTuple.of(Rotation.None, Rotation.Ninety), RotationTuple.of(Rotation.Ninety, Rotation.Ninety)}, (pair) -> pair.pitch() != Rotation.Ninety && pair.pitch() != Rotation.TwoSeventy ? RotationTuple.of(Rotation.None, validatePipe(pair.pitch())) : RotationTuple.of(validatePipe(pair.yaw()), validatePipe(pair.pitch())), (pair, rotation) -> RotationTuple.of(pair.yaw(), pair.pitch().add(rotation)), (pair, rotation) -> {
      if (pair.yaw() == Rotation.None && pair.pitch() == Rotation.Ninety) {
         return pair;
      } else {
         RotationTuple var10000;
          (pair.yaw().add(rotation)) {
             None:
             OneEighty:
               var10000 = RotationTuple.of(Rotation.None, Rotation.None);
               ;
             Ninety:
             TwoSeventy:
               var10000 = RotationTuple.of(Rotation.Ninety, Rotation.Ninety);
               ;
            :
                 ((String), (Throwable));
         }

          var10000;
      }
   }),
   DoublePipe(com.hypixel.hytale.protocol.VariantRotation.DoublePipe,  []{RotationTuple.of(Rotation.None, Rotation.Ninety), RotationTuple.of(Rotation.Ninety, Rotation.Ninety), RotationTuple.of(Rotation.OneEighty, Rotation.Ninety), RotationTuple.of(Rotation.TwoSeventy, Rotation.Ninety), RotationTuple.of(Rotation.None, Rotation.OneEighty)}, (pair) -> {
      RotationTuple var10000;
       (pair.pitch()) {
          OneEighty -> var10000 = RotationTuple.of(Rotation.None, Rotation.OneEighty);
          Ninety -> var10000 = pair;
          TwoSeventy -> var10000 = RotationTuple.of(pair.yaw().flip(), Rotation.Ninety);
          -> var10000 = RotationTuple.NONE;
      }

       var10000;
   }, (pair, rotation) -> (pair.yaw() == Rotation.Ninety || pair.yaw() == Rotation.TwoSeventy) && pair.pitch() == Rotation.Ninety ? pair : RotationTuple.getRotation( []{RotationTuple.NONE, RotationTuple.of(Rotation.None, Rotation.Ninety), RotationTuple.of(Rotation.None, Rotation.OneEighty), RotationTuple.of(Rotation.OneEighty, Rotation.Ninety)}, pair, rotation), (pair, rotation) -> pair.yaw() != Rotation.None || pair.pitch() != Rotation.Ninety && pair.pitch() != Rotation.TwoSeventy ? RotationTuple.getRotation( []{RotationTuple.NONE, RotationTuple.of(Rotation.Ninety, Rotation.Ninety), RotationTuple.of(Rotation.None, Rotation.OneEighty), RotationTuple.of(Rotation.TwoSeventy, Rotation.Ninety)}, pair, rotation) : pair),
   NESW(com.hypixel.hytale.protocol.VariantRotation.NESW,  []{RotationTuple.of(Rotation.Ninety, Rotation.None), RotationTuple.of(Rotation.OneEighty, Rotation.None), RotationTuple.of(Rotation.TwoSeventy, Rotation.None)}, (pair) -> RotationTuple.of(pair.yaw(), Rotation.None), (pair, rotation) -> pair, (pair, rotation) -> pair),
   UpDownNESW(com.hypixel.hytale.protocol.VariantRotation.UpDownNESW,  []{RotationTuple.of(Rotation.Ninety, Rotation.None), RotationTuple.of(Rotation.OneEighty, Rotation.None), RotationTuple.of(Rotation.TwoSeventy, Rotation.None), RotationTuple.of(Rotation.None, Rotation.OneEighty), RotationTuple.of(Rotation.Ninety, Rotation.OneEighty), RotationTuple.of(Rotation.OneEighty, Rotation.OneEighty), RotationTuple.of(Rotation.TwoSeventy, Rotation.OneEighty)}, (pair) -> pair.pitch() == Rotation.OneEighty ? RotationTuple.of(pair.yaw(), Rotation.OneEighty) : RotationTuple.of(pair.yaw(), Rotation.None), (pair, rotation) -> RotationTuple.of(pair.yaw(), pair.pitch().add(rotation)), (pair, rotation) -> pair.pitch().add(rotation) == Rotation.OneEighty ? RotationTuple.of(pair.yaw(), Rotation.OneEighty) : pair),
   Debug(com.hypixel.hytale.protocol.VariantRotation.UpDownNESW,  []{RotationTuple.of(Rotation.Ninety, Rotation.None), RotationTuple.of(Rotation.OneEighty, Rotation.None), RotationTuple.of(Rotation.TwoSeventy, Rotation.None), RotationTuple.of(Rotation.None, Rotation.Ninety), RotationTuple.of(Rotation.Ninety, Rotation.Ninety), RotationTuple.of(Rotation.OneEighty, Rotation.Ninety), RotationTuple.of(Rotation.TwoSeventy, Rotation.Ninety), RotationTuple.of(Rotation.None, Rotation.OneEighty), RotationTuple.of(Rotation.Ninety, Rotation.OneEighty), RotationTuple.of(Rotation.OneEighty, Rotation.OneEighty), RotationTuple.of(Rotation.TwoSeventy, Rotation.OneEighty), RotationTuple.of(Rotation.None, Rotation.TwoSeventy), RotationTuple.of(Rotation.Ninety, Rotation.TwoSeventy), RotationTuple.of(Rotation.OneEighty, Rotation.TwoSeventy), RotationTuple.of(Rotation.TwoSeventy, Rotation.TwoSeventy)}, Function.identity(), (pair, rotation) -> RotationTuple.of(pair.yaw(), pair.pitch().add(rotation)), (pair, rotation) -> pair),
   All(com.hypixel.hytale.protocol.VariantRotation.All,  []{RotationTuple.of(Rotation.None, Rotation.None, Rotation.Ninety), RotationTuple.of(Rotation.None, Rotation.None, Rotation.OneEighty), RotationTuple.of(Rotation.None, Rotation.None, Rotation.TwoSeventy), RotationTuple.of(Rotation.None, Rotation.Ninety, Rotation.None), RotationTuple.of(Rotation.None, Rotation.Ninety, Rotation.Ninety), RotationTuple.of(Rotation.None, Rotation.Ninety, Rotation.OneEighty), RotationTuple.of(Rotation.None, Rotation.Ninety, Rotation.TwoSeventy), RotationTuple.of(Rotation.None, Rotation.OneEighty, Rotation.None), RotationTuple.of(Rotation.None, Rotation.OneEighty, Rotation.Ninety), RotationTuple.of(Rotation.None, Rotation.OneEighty, Rotation.OneEighty), RotationTuple.of(Rotation.None, Rotation.OneEighty, Rotation.TwoSeventy), RotationTuple.of(Rotation.None, Rotation.TwoSeventy, Rotation.None), RotationTuple.of(Rotation.None, Rotation.TwoSeventy, Rotation.Ninety), RotationTuple.of(Rotation.None, Rotation.TwoSeventy, Rotation.OneEighty), RotationTuple.of(Rotation.None, Rotation.TwoSeventy, Rotation.TwoSeventy), RotationTuple.of(Rotation.Ninety, Rotation.None, Rotation.None), RotationTuple.of(Rotation.Ninety, Rotation.None, Rotation.Ninety), RotationTuple.of(Rotation.Ninety, Rotation.None, Rotation.OneEighty), RotationTuple.of(Rotation.Ninety, Rotation.None, Rotation.TwoSeventy), RotationTuple.of(Rotation.Ninety, Rotation.Ninety, Rotation.None), RotationTuple.of(Rotation.Ninety, Rotation.Ninety, Rotation.Ninety), RotationTuple.of(Rotation.Ninety, Rotation.Ninety, Rotation.OneEighty), RotationTuple.of(Rotation.Ninety, Rotation.Ninety, Rotation.TwoSeventy), RotationTuple.of(Rotation.Ninety, Rotation.OneEighty, Rotation.None), RotationTuple.of(Rotation.Ninety, Rotation.OneEighty, Rotation.Ninety), RotationTuple.of(Rotation.Ninety, Rotation.OneEighty, Rotation.OneEighty), RotationTuple.of(Rotation.Ninety, Rotation.OneEighty, Rotation.TwoSeventy), RotationTuple.of(Rotation.Ninety, Rotation.TwoSeventy, Rotation.None), RotationTuple.of(Rotation.Ninety, Rotation.TwoSeventy, Rotation.Ninety), RotationTuple.of(Rotation.Ninety, Rotation.TwoSeventy, Rotation.OneEighty), RotationTuple.of(Rotation.Ninety, Rotation.TwoSeventy, Rotation.TwoSeventy), RotationTuple.of(Rotation.OneEighty, Rotation.None, Rotation.None), RotationTuple.of(Rotation.OneEighty, Rotation.None, Rotation.Ninety), RotationTuple.of(Rotation.OneEighty, Rotation.None, Rotation.OneEighty), RotationTuple.of(Rotation.OneEighty, Rotation.None, Rotation.TwoSeventy), RotationTuple.of(Rotation.OneEighty, Rotation.Ninety, Rotation.None), RotationTuple.of(Rotation.OneEighty, Rotation.Ninety, Rotation.Ninety), RotationTuple.of(Rotation.OneEighty, Rotation.Ninety, Rotation.OneEighty), RotationTuple.of(Rotation.OneEighty, Rotation.Ninety, Rotation.TwoSeventy), RotationTuple.of(Rotation.OneEighty, Rotation.OneEighty, Rotation.None), RotationTuple.of(Rotation.OneEighty, Rotation.OneEighty, Rotation.Ninety), RotationTuple.of(Rotation.OneEighty, Rotation.OneEighty, Rotation.OneEighty), RotationTuple.of(Rotation.OneEighty, Rotation.OneEighty, Rotation.TwoSeventy), RotationTuple.of(Rotation.OneEighty, Rotation.TwoSeventy, Rotation.None), RotationTuple.of(Rotation.OneEighty, Rotation.TwoSeventy, Rotation.Ninety), RotationTuple.of(Rotation.OneEighty, Rotation.TwoSeventy, Rotation.OneEighty), RotationTuple.of(Rotation.OneEighty, Rotation.TwoSeventy, Rotation.TwoSeventy), RotationTuple.of(Rotation.TwoSeventy, Rotation.None, Rotation.None), RotationTuple.of(Rotation.TwoSeventy, Rotation.None, Rotation.Ninety), RotationTuple.of(Rotation.TwoSeventy, Rotation.None, Rotation.OneEighty), RotationTuple.of(Rotation.TwoSeventy, Rotation.None, Rotation.TwoSeventy), RotationTuple.of(Rotation.TwoSeventy, Rotation.Ninety, Rotation.None), RotationTuple.of(Rotation.TwoSeventy, Rotation.Ninety, Rotation.Ninety), RotationTuple.of(Rotation.TwoSeventy, Rotation.Ninety, Rotation.OneEighty), RotationTuple.of(Rotation.TwoSeventy, Rotation.Ninety, Rotation.TwoSeventy), RotationTuple.of(Rotation.TwoSeventy, Rotation.OneEighty, Rotation.None), RotationTuple.of(Rotation.TwoSeventy, Rotation.OneEighty, Rotation.Ninety), RotationTuple.of(Rotation.TwoSeventy, Rotation.OneEighty, Rotation.OneEighty), RotationTuple.of(Rotation.TwoSeventy, Rotation.OneEighty, Rotation.TwoSeventy), RotationTuple.of(Rotation.TwoSeventy, Rotation.TwoSeventy, Rotation.None), RotationTuple.of(Rotation.TwoSeventy, Rotation.TwoSeventy, Rotation.Ninety), RotationTuple.of(Rotation.TwoSeventy, Rotation.TwoSeventy, Rotation.OneEighty), RotationTuple.of(Rotation.TwoSeventy, Rotation.TwoSeventy, Rotation.TwoSeventy)}, Function.identity(), (pair, rotation) -> RotationTuple.of(pair.yaw(), pair.pitch().add(rotation)), (pair, rotation) -> pair);

      VariantRotation[] EMPTY_ARRAY =  [];
     com.hypixel.hytale.protocol.VariantRotation protocolType;
     RotationTuple[] rotations;
     Function<RotationTuple, RotationTuple> verify;
     BiFunction<RotationTuple, Rotation, RotationTuple> rotateX;
     BiFunction<RotationTuple, Rotation, RotationTuple> rotateZ;

   
     Rotation  {
      Rotation var10000;
       (yaw) {
          None:
          Ninety:
            var10000 = yaw;
            ;
          OneEighty:
            var10000 = Rotation.None;
            ;
          TwoSeventy:
            var10000 = Rotation.Ninety;
            ;
         :
              ((String), (Throwable));
      }

       var10000;
   }

     {
      .protocolType = protocolType;
      .rotations = rotations;
      .verify = verify;
      .rotateX = rotateX;
      .rotateZ = rotateZ;
   }

    RotationTuple[] getRotations() {
       .rotations;
   }

    RotationTuple  {
       (RotationTuple).rotateX.apply(pair, rotation);
   }

    RotationTuple  {
       (RotationTuple).rotateZ.apply(pair, rotation);
   }

    RotationTuple  {
       (RotationTuple).verify.apply(pair);
   }

    com.hypixel.hytale.protocol.VariantRotation  {
       .protocolType;
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/bench/Bench.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config.bench;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.lookup.ObjectCodecMapCodec;
import com.hypixel.hytale.protocol.BenchType;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
import com.hypixel.hytale.server.core.asset.type.soundevent.validator.SoundEventValidators;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import com.hypixel.hytale.server.core.modules.interaction.interaction.config.RootInteraction;
import java.util.Arrays;
import java.util.EnumMap;
import java.util.Map;
import java.util.Objects;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public abstract class Bench implements NetworkSerializable<com.hypixel.hytale.protocol.Bench> {
   public static final ObjectCodecMapCodec<BenchType, Bench> CODEC = new ObjectCodecMapCodec<BenchType, Bench>("Type", new EnumCodec(BenchType.class));
   public static final BuilderCodec<Bench> BASE_CODEC;
   /** @deprecated */
   
      Map<BenchType, RootInteraction> BENCH_INTERACTIONS;
   
    BenchType type;
    String id;
    String descriptiveLabel;
    BenchTierLevel[] tierLevels;
   
    String localOpenSoundEventId;
      localOpenSoundEventIndex;
   
    String localCloseSoundEventId;
      localCloseSoundEventIndex;
   
    String completedSoundEventId;
      completedSoundEventIndex;
   
    String failedSoundEventId;
      failedSoundEventIndex;
   
    String benchUpgradeSoundEventId;
      benchUpgradeSoundEventIndex;
   
    String benchUpgradeCompletedSoundEventId;
      benchUpgradeCompletedSoundEventIndex;

     {
      .type = BenchType.Crafting;
      .localOpenSoundEventId = ;
      .localOpenSoundEventIndex = ;
      .localCloseSoundEventId = ;
      .localCloseSoundEventIndex = ;
      .completedSoundEventId = ;
      .completedSoundEventIndex = ;
      .failedSoundEventId = ;
      .failedSoundEventIndex = ;
      .benchUpgradeSoundEventId = ;
      .benchUpgradeSoundEventIndex = ;
      .benchUpgradeCompletedSoundEventId = ;
      .benchUpgradeCompletedSoundEventIndex = ;
   }

    BenchType  {
       .type;
   }

    String  {
       .id;
   }

    String  {
       .descriptiveLabel;
   }

    BenchTierLevel  {
       .tierLevels !=  && tierLevel >=  && tierLevel <= .tierLevels.length ? .tierLevels[tierLevel - ] : ;
   }

    BenchUpgradeRequirement  {
         .getTierLevel(tierLevel);
       currentTierLevel ==  ?  : currentTierLevel.upgradeRequirement;
   }

   
    String  {
       .localOpenSoundEventId;
   }

      {
       .localOpenSoundEventIndex;
   }

   
    String  {
       .localCloseSoundEventId;
   }

      {
       .localCloseSoundEventIndex;
   }

   
    String  {
       .completedSoundEventId;
   }

      {
       .completedSoundEventIndex;
   }

   
    String  {
       .failedSoundEventId;
   }

      {
       .failedSoundEventIndex;
   }

   
    String  {
       .benchUpgradeSoundEventId;
   }

      {
       .benchUpgradeSoundEventIndex;
   }

   
    String  {
       .benchUpgradeCompletedSoundEventId;
   }

      {
       .benchUpgradeCompletedSoundEventIndex;
   }

   
    RootInteraction  {
       (RootInteraction)BENCH_INTERACTIONS.get(.type);
   }

    com.hypixel.hytale.protocol.Bench  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.Bench();
       (.tierLevels !=  && .tierLevels.length > ) {
         packet.benchTierLevels =  .hypixel.hytale.protocol.BenchTierLevel[.tierLevels.length];

         (   ; i < .tierLevels.length; ++i) {
            packet.benchTierLevels[i] = .tierLevels[i].toPacket();
         }
      }

       packet;
   }

      {
       (o !=  && .getClass() == o.getClass()) {
            (Bench)o;
          .localOpenSoundEventIndex == bench.localOpenSoundEventIndex && .localCloseSoundEventIndex == bench.localCloseSoundEventIndex && .completedSoundEventIndex == bench.completedSoundEventIndex && .benchUpgradeSoundEventIndex == bench.benchUpgradeSoundEventIndex && .benchUpgradeCompletedSoundEventIndex == bench.benchUpgradeCompletedSoundEventIndex && .type == bench.type && Objects.equals(.id, bench.id) && Objects.equals(.descriptiveLabel, bench.descriptiveLabel) && Objects.deepEquals(.tierLevels, bench.tierLevels) && Objects.equals(.localOpenSoundEventId, bench.localOpenSoundEventId) && Objects.equals(.localCloseSoundEventId, bench.localCloseSoundEventId) && Objects.equals(.completedSoundEventId, bench.completedSoundEventId) && Objects.equals(.failedSoundEventId, bench.failedSoundEventId) && Objects.equals(.benchUpgradeSoundEventId, bench.benchUpgradeSoundEventId) && Objects.equals(.benchUpgradeCompletedSoundEventId, bench.benchUpgradeCompletedSoundEventId);
      }  {
          ;
      }
   }

      {
       Objects.hash( []{.type, .id, .descriptiveLabel, Arrays.hashCode(.tierLevels), .localOpenSoundEventId, .localOpenSoundEventIndex, .localCloseSoundEventId, .localCloseSoundEventIndex, .completedSoundEventId, .completedSoundEventIndex, .failedSoundEventId, .failedSoundEventIndex, .benchUpgradeSoundEventId, .benchUpgradeSoundEventIndex, .benchUpgradeCompletedSoundEventId, .benchUpgradeCompletedSoundEventIndex});
   }

    String  {
         String.valueOf(.type);
        + var10000 +  + .id +  + .descriptiveLabel +  + Arrays.toString(.tierLevels) +  + .localOpenSoundEventId +  + .localOpenSoundEventIndex +  + .localCloseSoundEventId +  + .localCloseSoundEventIndex +  + .completedSoundEventId +  + .completedSoundEventIndex +  + .failedSoundEventId +  + .failedSoundEventIndex +  + .benchUpgradeSoundEventId +  + .benchUpgradeSoundEventIndex +  + .benchUpgradeCompletedSoundEventId +  + .benchUpgradeCompletedSoundEventIndex + ;
   }

   
   
       {
      BENCH_INTERACTIONS.put(benchType, interaction);
   }

    {
      BASE_CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.abstractBuilder(Bench.class).addField( (, Codec.STRING), (bench, s) -> bench.id = s, (bench) -> bench.id)).addField( (, Codec.STRING), (bench, s) -> bench.descriptiveLabel = s, (bench) -> bench.descriptiveLabel)).appendInherited( (,  (BenchTierLevel.CODEC, (x$) ->  [x$])), (bench, u) -> bench.tierLevels = u, (bench) -> bench.tierLevels, (bench, parent) -> bench.tierLevels = parent.tierLevels).add()).append( (, Codec.STRING), (bench, s) -> bench.localOpenSoundEventId = s, (bench) -> bench.localOpenSoundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.ONESHOT).add()).append( (, Codec.STRING), (bench, s) -> bench.localCloseSoundEventId = s, (bench) -> bench.localCloseSoundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.ONESHOT).add()).append( (, Codec.STRING), (bench, s) -> bench.completedSoundEventId = s, (bench) -> bench.completedSoundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.MONO).addValidator(SoundEventValidators.ONESHOT).add()).append( (, Codec.STRING), (bench, s) -> bench.failedSoundEventId = s, (bench) -> bench.failedSoundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.MONO).addValidator(SoundEventValidators.ONESHOT).add()).append( (, Codec.STRING), (bench, s) -> bench.benchUpgradeSoundEventId = s, (bench) -> bench.benchUpgradeSoundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.MONO).addValidator(SoundEventValidators.ONESHOT).add()).append( (, Codec.STRING), (bench, s) -> bench.benchUpgradeCompletedSoundEventId = s, (bench) -> bench.benchUpgradeCompletedSoundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.MONO).addValidator(SoundEventValidators.ONESHOT).add()).afterDecode((bench) -> {
         bench.type = (BenchType)CODEC.getIdFor(bench.getClass());
          (bench.localOpenSoundEventId != ) {
            bench.localOpenSoundEventIndex = SoundEvent.getAssetMap().getIndex(bench.localOpenSoundEventId);
         }

          (bench.localCloseSoundEventId != ) {
            bench.localCloseSoundEventIndex = SoundEvent.getAssetMap().getIndex(bench.localCloseSoundEventId);
         }

          (bench.completedSoundEventId != ) {
            bench.completedSoundEventIndex = SoundEvent.getAssetMap().getIndex(bench.completedSoundEventId);
         }

          (bench.benchUpgradeSoundEventId != ) {
            bench.benchUpgradeSoundEventIndex = SoundEvent.getAssetMap().getIndex(bench.benchUpgradeSoundEventId);
         }

          (bench.benchUpgradeCompletedSoundEventId != ) {
            bench.benchUpgradeCompletedSoundEventIndex = SoundEvent.getAssetMap().getIndex(bench.benchUpgradeCompletedSoundEventId);
         }

          (bench.failedSoundEventId != ) {
            bench.failedSoundEventIndex = SoundEvent.getAssetMap().getIndex(bench.failedSoundEventId);
         }

      })).build();
      BENCH_INTERACTIONS =  (BenchType.class);
   }

       {
         BuilderCodec<BenchSlot> CODEC;
       String icon;

        {
      }

       String  {
          .icon;
      }

         {
          ( == o) {
             ;
         }   (o !=  && .getClass() == o.getClass()) {
               (BenchSlot)o;
             .icon !=  ? .icon.equals(benchSlot.icon) : benchSlot.icon == ;
         }  {
             ;
         }
      }

         {
          .icon !=  ? .icon.hashCode() : ;
      }

      
       String  {
           + .icon + ;
      }

       {
         CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(BenchSlot.class, BenchSlot::).addField( (, Codec.STRING), (benchSlot, s) -> benchSlot.icon = s, (benchSlot) -> benchSlot.icon)).build();
      }
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/bench/BenchTierLevel.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config.bench;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.server.core.io.NetworkSerializable;

public class BenchTierLevel implements NetworkSerializable<com.hypixel.hytale.protocol.BenchTierLevel> {
   public static final BuilderCodec<BenchTierLevel> CODEC;
   protected BenchUpgradeRequirement upgradeRequirement;
   protected float craftingTimeReductionModifier;
   protected int extraInputSlot;
   protected int extraOutputSlot;

   public BenchTierLevel(BenchUpgradeRequirement upgradeRequirement, float craftingTimeReductionModifier, int extraInputSlot, int extraOutputSlot) {
      this.upgradeRequirement = upgradeRequirement;
      this.craftingTimeReductionModifier = craftingTimeReductionModifier;
      this.extraInputSlot = extraInputSlot;
      this.extraOutputSlot = extraOutputSlot;
   }

   protected BenchTierLevel() {
   }

   public float getCraftingTimeReductionModifier() {
      return .craftingTimeReductionModifier;
   }

    BenchUpgradeRequirement  {
       .upgradeRequirement;
   }

      {
       .extraInputSlot;
   }

      {
       .extraOutputSlot;
   }

    com.hypixel.hytale.protocol.BenchTierLevel  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.BenchTierLevel();
       (.upgradeRequirement != ) {
         packet.benchUpgradeRequirement = .upgradeRequirement.toPacket();
      }

      packet.craftingTimeReductionModifier = ().craftingTimeReductionModifier;
      packet.extraInputSlot = .extraInputSlot;
      packet.extraOutputSlot = .extraOutputSlot;
       packet;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(BenchTierLevel.class, BenchTierLevel::).append( (, BenchUpgradeRequirement.CODEC), (tier, d) -> tier.upgradeRequirement = d, (tier) -> tier.upgradeRequirement).add()).append( (, Codec.DOUBLE), (tier, d) -> tier.craftingTimeReductionModifier = d.floatValue(), (tier) -> ()tier.craftingTimeReductionModifier).addValidator(Validators.range(, )).add()).append( (, Codec.INTEGER), (tier, d) -> tier.extraInputSlot = d, (tier) -> tier.extraInputSlot).addValidator(Validators.min()).add()).append( (, Codec.INTEGER), (tier, d) -> tier.extraOutputSlot = d, (tier) -> tier.extraOutputSlot).addValidator(Validators.min()).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/bench/BenchUpgradeRequirement.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config.bench;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.server.core.inventory.MaterialQuantity;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.util.Arrays;

public class BenchUpgradeRequirement implements NetworkSerializable<com.hypixel.hytale.protocol.BenchUpgradeRequirement> {
   public static final BuilderCodec<BenchUpgradeRequirement> CODEC;
   protected MaterialQuantity[] input;
   protected float timeSeconds;

   public BenchUpgradeRequirement(MaterialQuantity[] input, float timeSeconds) {
      this.input = input;
      this.timeSeconds = timeSeconds;
   }

   protected BenchUpgradeRequirement() {
   }

   public MaterialQuantity[] getInput() {
      return this.input;
   }

   public float getTimeSeconds() {
      return this.timeSeconds;
   }

   public String  {
         Arrays.toString(.input);
        + var10000 +  + .timeSeconds + ;
   }

    com.hypixel.hytale.protocol.BenchUpgradeRequirement  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.BenchUpgradeRequirement();
       (.input !=  && .input.length > ) {
         packet.material =  .hypixel.hytale.protocol.MaterialQuantity[.input.length];

         (   ; i < .input.length; ++i) {
            packet.material[i] = .input[i].toPacket();
         }

         packet.timeSeconds = ().timeSeconds;
      }

       packet;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(BenchUpgradeRequirement.class, BenchUpgradeRequirement::).append( (,  (MaterialQuantity.CODEC, (x$) ->  [x$])), (benchUpgradeRequirement, objects) -> benchUpgradeRequirement.input = objects, (benchUpgradeRequirement) -> benchUpgradeRequirement.input).addValidator(Validators.nonNull()).add()).append( (, Codec.DOUBLE), (benchUpgradeRequirement, d) -> benchUpgradeRequirement.timeSeconds = d.floatValue(), (benchUpgradeRequirement) -> ()benchUpgradeRequirement.timeSeconds).addValidator(Validators.min()).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/bench/CraftingBench.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config.bench;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditor;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import java.util.Arrays;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class CraftingBench extends Bench {
   public static final BuilderCodec<CraftingBench> CODEC;
   protected BenchCategory[] categories;

   public CraftingBench() {
   }

   public BenchCategory[] getCategories() {
      return this.categories;
   }

   public boolean equals(@Nullable Object o) {
      if (this == o) {
         return true;
      } else if (o != null && this.getClass() == o.getClass()) {
         if (!super.equals(o)) {
             ;
         }  {
               (CraftingBench)o;
             Arrays.equals(.categories, that.categories);
         }
      }  {
          ;
      }
   }

      {
         .hashCode();
      result =  * result + Arrays.hashCode(.categories);
       result;
   }

    {
      CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(CraftingBench.class, CraftingBench::, Bench.BASE_CODEC).append( (,  (CraftingBench.BenchCategory.CODEC, (x$) ->  [x$])), (bench, s) -> bench.categories = s, (bench) -> bench.categories).addValidator(Validators.nonNull()).add()).build();
   }

       {
         BuilderCodec<BenchCategory> CODEC;
       String id;
       String name;
       String icon;
       BenchItemCategory[] itemCategories;

        {
         .id = id;
         .name = name;
         .icon = icon;
         .itemCategories = itemCategories;
      }

        {
      }

       String  {
          .id;
      }

       String  {
          .name;
      }

       String  {
          .icon;
      }

       BenchItemCategory[] getItemCategories() {
          .itemCategories;
      }

      
       String  {
            .id;
           + var10000 +  + .name +  + .icon +  + Arrays.toString(.itemCategories) + ;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(BenchCategory.class, BenchCategory::).addField( (, Codec.STRING), (benchCategory, s) -> benchCategory.id = s, (benchCategory) -> benchCategory.id)).append( (, Codec.STRING), (benchCategory, s) -> benchCategory.name = s, (benchCategory) -> benchCategory.name).metadata( ( .LocalizationKeyField())).add()).append( (, Codec.STRING), (benchCategory, s) -> benchCategory.icon = s, (benchCategory) -> benchCategory.icon).addValidator(CommonAssetValidator.ICON_CRAFTING).add()).addField( (,  (CraftingBench.BenchItemCategory.CODEC, (x$) ->  [x$])), (benchCategory, s) -> benchCategory.itemCategories = s, (benchCategory) -> benchCategory.itemCategories)).build();
      }
   }

       {
         BuilderCodec<BenchItemCategory> CODEC;
       String id;
       String name;
       String icon;
       String diagram;
          ;
          ;

        {
         .id = id;
         .name = name;
         .icon = icon;
         .diagram = diagram;
         .slots = slots;
         .specialSlot = specialSlot;
      }

        {
      }

       String  {
          .id;
      }

       String  {
          .name;
      }

       String  {
          .icon;
      }

       String  {
          .diagram;
      }

         {
          .slots;
      }

         {
          .specialSlot;
      }

      
       String  {
           + .id +  + .name +  + .icon +  + .diagram +  + .slots +  + .specialSlot + ;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(BenchItemCategory.class, BenchItemCategory::).addField( (, Codec.STRING), (benchItemCategory, s) -> benchItemCategory.id = s, (benchItemCategory) -> benchItemCategory.id)).addField( (, Codec.STRING), (benchItemCategory, s) -> benchItemCategory.name = s, (benchItemCategory) -> benchItemCategory.name)).append( (, Codec.STRING), (benchItemCategory, s) -> benchItemCategory.icon = s, (benchItemCategory) -> benchItemCategory.icon).addValidator(CommonAssetValidator.ICON_CRAFTING).add()).append( (, Codec.STRING), (benchItemCategory, s) -> benchItemCategory.diagram = s, (benchItemCategory) -> benchItemCategory.diagram).addValidator(CommonAssetValidator.UI_CRAFTING_DIAGRAM).add()).addField( (, Codec.INTEGER), (benchItemCategory, s) -> benchItemCategory.slots = s, (benchItemCategory) -> benchItemCategory.slots)).addField( (, Codec.BOOLEAN), (benchItemCategory, s) -> benchItemCategory.specialSlot = s, (benchItemCategory) -> benchItemCategory.specialSlot)).build();
      }
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/bench/DiagramCraftingBench.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config.bench;

import com.hypixel.hytale.codec.builder.BuilderCodec;

public class DiagramCraftingBench extends CraftingBench {
   public static final BuilderCodec<DiagramCraftingBench> CODEC;

   public DiagramCraftingBench() {
   }

   static {
      CODEC = BuilderCodec.builder(DiagramCraftingBench.class, DiagramCraftingBench::new, CraftingBench.CODEC).build();
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/bench/ProcessingBench.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config.bench;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
import com.hypixel.hytale.server.core.asset.type.soundevent.validator.SoundEventValidators;
import com.hypixel.hytale.server.core.inventory.MaterialQuantity;
import java.util.Arrays;
import java.util.Locale;
import java.util.Objects;
import javax.annotation.Nullable;

public class ProcessingBench extends Bench {
   public static final BuilderCodec<ProcessingBench> CODEC;
   protected ProcessingSlot[] input;
   protected ProcessingSlot[] fuel;
   protected boolean allowNoInputProcessing;
   protected ExtraOutput extraOutput;
   protected int maxFuel = -1;
   protected String fuelDropItemId;
   protected int outputSlotsCount = 1;
   protected String iconItem;
    String icon;
    String iconName;
    String iconId;
   
       ;
        ;

     {
   }

    String  {
       .iconItem;
   }

    String  {
       .icon;
   }

    String  {
       .iconName;
   }

    String  {
       .iconId;
   }

    ProcessingSlot[] getInput( tierLevel) {
       (.tierLevels == ) {
          .input;
      }   (tierLevel > .tierLevels.length) {
          .input;
      }  {
         ProcessingSlot[] result =  [.input.length + .tierLevels[tierLevel - ].extraInputSlot];
         Arrays.fill(result, .input[]);
          result;
      }
   }

    ProcessingSlot[] getFuel() {
       .fuel;
   }

      {
       .maxFuel;
   }

    String  {
       .fuelDropItemId;
   }

      {
       (.tierLevels == ) {
          .outputSlotsCount;
      }  {
          tierLevel > .tierLevels.length ? .outputSlotsCount : .outputSlotsCount + .tierLevels[tierLevel - ].extraOutputSlot;
      }
   }

    ExtraOutput  {
       .extraOutput;
   }

   
    String  {
       .endSoundEventId;
   }

      {
       .endSoundEventIndex;
   }

      {
       .allowNoInputProcessing;
   }

      {
       (o !=  && .getClass() == o.getClass()) {
          (!.equals(o)) {
             ;
         }  {
               (ProcessingBench)o;
             .allowNoInputProcessing == that.allowNoInputProcessing && .maxFuel == that.maxFuel && .outputSlotsCount == that.outputSlotsCount && .endSoundEventIndex == that.endSoundEventIndex && Arrays.equals(.input, that.input) && Arrays.equals(.fuel, that.fuel) && Objects.equals(.extraOutput, that.extraOutput) && Objects.equals(.fuelDropItemId, that.fuelDropItemId) && Objects.equals(.iconItem, that.iconItem) && Objects.equals(.icon, that.icon) && Objects.equals(.iconName, that.iconName) && Objects.equals(.iconId, that.iconId) && Objects.equals(.endSoundEventId, that.endSoundEventId);
         }
      }  {
          ;
      }
   }

      {
         .hashCode();
      result =  * result + Arrays.hashCode(.input);
      result =  * result + Arrays.hashCode(.fuel);
      result =  * result + Boolean.hashCode(.allowNoInputProcessing);
      result =  * result + Objects.hashCode(.extraOutput);
      result =  * result + .maxFuel;
      result =  * result + Objects.hashCode(.fuelDropItemId);
      result =  * result + .outputSlotsCount;
      result =  * result + Objects.hashCode(.iconItem);
      result =  * result + Objects.hashCode(.icon);
      result =  * result + Objects.hashCode(.iconName);
      result =  * result + Objects.hashCode(.iconId);
      result =  * result + Objects.hashCode(.endSoundEventId);
      result =  * result + .endSoundEventIndex;
       result;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ProcessingBench.class, ProcessingBench::, Bench.BASE_CODEC).append( (,  (ProcessingBench.ProcessingSlot.CODEC, (x$) ->  [x$])), (bench, s) -> bench.input = s, (bench) -> bench.input).addValidator(Validators.nonNull()).add()).append( (,  (ProcessingBench.ProcessingSlot.CODEC, (x$) ->  [x$])), (bench, s) -> bench.fuel = s, (bench) -> bench.fuel).add()).append( (, Codec.INTEGER), (bench, s) -> bench.maxFuel = s, (bench) -> bench.maxFuel).add()).append( (, Codec.STRING), (bench, s) -> bench.fuelDropItemId = s, (bench) -> bench.fuelDropItemId).add()).append( (, Codec.INTEGER), (bench, s) -> bench.outputSlotsCount = s, (bench) -> bench.outputSlotsCount).addValidator(Validators.greaterThanOrEqual()).add()).append( (, ProcessingBench.ExtraOutput.CODEC), (bench, s) -> bench.extraOutput = s, (bench) -> bench.extraOutput).add()).append( (, Codec.BOOLEAN), (bench, s) -> bench.allowNoInputProcessing = s, (bench) -> bench.allowNoInputProcessing).add()).append( (, Codec.STRING), (bench, s) -> bench.iconItem = s, (bench) -> bench.iconItem).add()).append( (, Codec.STRING), (bench, s) -> bench.icon = s, (bench) -> bench.icon).add()).append( (, Codec.STRING), (bench, s) -> bench.iconName = s, (bench) -> bench.iconName).add()).append( (, Codec.STRING), (bench, s) -> bench.iconId = s, (bench) -> bench.iconId).add()).append( (, Codec.STRING), (bench, s) -> bench.endSoundEventId = s, (bench) -> bench.endSoundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.MONO).addValidator(SoundEventValidators.ONESHOT).add()).afterDecode((p) -> {
          (p.icon != ) {
             (p.iconId == ) {
                  p.icon.substring(, p.icon.indexOf());
               p.iconId = name.toLowerCase(Locale.ROOT);
            }

             (p.iconName == ) {
                  p.icon.substring(, p.icon.indexOf());
               p.iconName = name.toLowerCase(Locale.ROOT);
            }
         }

          (p.endSoundEventId != ) {
            p.endSoundEventIndex = SoundEvent.getAssetMap().getIndex(p.endSoundEventId);
         }

      })).build();
   }

        .BenchSlot {
         BuilderCodec<ProcessingSlot> CODEC;
        filterValidIngredients;
       String resourceTypeId;

        {
      }

       String  {
          .resourceTypeId;
      }

         {
          .filterValidIngredients;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ProcessingSlot.class, ProcessingSlot::, Bench.BenchSlot.CODEC).append( (, Codec.STRING), (benchSlot, s) -> benchSlot.resourceTypeId = s, (benchSlot) -> benchSlot.resourceTypeId).add()).append( (, Codec.BOOLEAN), (benchSlot, b) -> benchSlot.filterValidIngredients = b, (benchSlot) -> benchSlot.filterValidIngredients).add()).build();
      }
   }

       {
         BuilderCodec<ExtraOutput> CODEC;
       MaterialQuantity[] outputs;
          ;
       MaterialQuantity[] ignoredFuelSources;

        {
      }

       MaterialQuantity[] getOutputs() {
          .outputs;
      }

         {
          .perFuelItemsConsumed;
      }

         {
          (.ignoredFuelSources == ) {
             ;
         }  {
            (MaterialQuantity mat : .ignoredFuelSources) {
                (mat.getItemId() !=  && mat.getItemId().equals(id.getBlockId())) {
                   ;
               }
            }

             ;
         }
      }

         {
          ( == o) {
             ;
         }   (o !=  && .getClass() == o.getClass()) {
               (ExtraOutput)o;
             .perFuelItemsConsumed != that.perFuelItemsConsumed ?  : Arrays.equals(.outputs, that.outputs);
         }  {
             ;
         }
      }

         {
            Arrays.hashCode(.outputs);
         result =  * result + .perFuelItemsConsumed;
          result;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ExtraOutput.class, ExtraOutput::).append( (,  (MaterialQuantity.CODEC, (x$) ->  [x$])), (o, i) -> o.outputs = i, (o) -> o.outputs).addValidator(Validators.nonNull()).add()).append( (, Codec.INTEGER), (o, i) -> o.perFuelItemsConsumed = i, (o) -> o.perFuelItemsConsumed).addValidator(Validators.greaterThanOrEqual()).add()).append( (,  (MaterialQuantity.CODEC, (x$) ->  [x$])), (o, i) -> o.ignoredFuelSources = i, (o) -> o.ignoredFuelSources).add()).build();
      }
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/bench/StructuralCraftingBench.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config.bench;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import it.unimi.dsi.fastutil.objects.Object2IntMap;
import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
import java.util.Collections;
import javax.annotation.Nonnull;

public class StructuralCraftingBench extends Bench {
   public static final BuilderCodec<StructuralCraftingBench> CODEC;
   private String[] headerCategories;
   private ObjectOpenHashSet<String> headerCategoryMap;
   private String[] sortedCategories;
   private Object2IntMap<String> categoryToIndexMap;
   private boolean allowBlockGroupCycling;
   private boolean alwaysShowInventoryHints;

   public StructuralCraftingBench() {
   }

   private void processConfig() {
      if (this.headerCategories != null) {
         this.headerCategoryMap = new ObjectOpenHashSet<String>();
         Collections.addAll(.headerCategoryMap, .headerCategories);
      }

       (.sortedCategories != ) {
         .categoryToIndexMap =  <String>();

         (   ; i < .sortedCategories.length; ++i) {
            .categoryToIndexMap.put(.sortedCategories[i], i);
         }

      }
   }

      {
       .headerCategoryMap !=  && .headerCategoryMap.contains(category);
   }

      {
       .categoryToIndexMap.getOrDefault(category, );
   }

      {
       .allowBlockGroupCycling;
   }

      {
       .alwaysShowInventoryHints;
   }

    String  {
       ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(StructuralCraftingBench.class, StructuralCraftingBench::, Bench.BASE_CODEC).append( (,  (Codec.STRING, (x$) ->  [x$])), (bench, categories) -> bench.sortedCategories = categories, (bench) -> bench.sortedCategories).add()).append( (,  (Codec.STRING, (x$) ->  [x$])), (bench, headerCategories) -> bench.headerCategories = headerCategories, (bench) -> bench.headerCategories).add()).append( (, Codec.BOOLEAN), (bench, alwaysShowInventoryHints) -> bench.alwaysShowInventoryHints = alwaysShowInventoryHints, (bench) -> bench.alwaysShowInventoryHints).add()).append( (, Codec.BOOLEAN), (bench, allowBlockGroupCycling) -> bench.allowBlockGroupCycling = allowBlockGroupCycling, (bench) -> bench.allowBlockGroupCycling).add()).afterDecode(StructuralCraftingBench::processConfig)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/farming/FarmingData.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config.farming;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.Rangef;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class FarmingData {
   @Nonnull
   public static Codec<FarmingData> CODEC;
   protected Map<String, FarmingStageData[]> stages;
   protected String startingStageSet = "Default";
   protected String stageSetAfterHarvest;
   protected String[] growthModifiers;
   @Nullable
   protected SoilConfig soilConfig;

   public FarmingData() {
   }

   @Nullable
   public Map<String, FarmingStageData[]> getStages() {
      return this.stages;
   }

   
    String  {
       .startingStageSet;
   }

    String  {
       .stageSetAfterHarvest;
   }

    String[] getGrowthModifiers() {
       .growthModifiers;
   }

   
    SoilConfig  {
       .soilConfig;
   }

   
    String  {
         String.valueOf(.stages);
        + var10000 +  + .startingStageSet +  + .stageSetAfterHarvest +  + Arrays.toString(.growthModifiers) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(FarmingData.class, FarmingData::).append( (,  ( (FarmingStageData.CODEC, (x$) ->  [x$]), HashMap::)), (farming, stages) -> farming.stages = stages, (farming) -> farming.stages).add()).append( (, Codec.STRING), (farming, starting) -> farming.startingStageSet = starting, (farming) -> farming.startingStageSet).add()).append( (, Codec.STRING), (farming, set) -> farming.stageSetAfterHarvest = set, (farming) -> farming.stageSetAfterHarvest).add()).append( (, GrowthModifierAsset.CHILD_ASSET_CODEC_ARRAY), (farming, modifiers) -> farming.growthModifiers = modifiers, (farming) -> farming.growthModifiers).add()).appendInherited( (, FarmingData.SoilConfig.CODEC), (o, v) -> o.soilConfig = v, (o) -> o.soilConfig, (o, p) -> o.soilConfig = p.soilConfig).add()).afterDecode((farmingData) -> {
          (farmingData !=  && farmingData.getStages() != ) {
             (!farmingData.getStages().containsKey(farmingData.startingStageSet)) {
                 ( + farmingData.startingStageSet);
            }

             (farmingData.stageSetAfterHarvest !=  && !farmingData.getStages().containsKey(farmingData.stageSetAfterHarvest)) {
                 ( + farmingData.startingStageSet);
            }
         }

      })).build();
   }

       {
         BuilderCodec<SoilConfig> CODEC;
       String targetBlock;
       Rangef lifetime;

        {
      }

       String  {
          .targetBlock;
      }

       Rangef  {
          .lifetime;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(SoilConfig.class, SoilConfig::).appendInherited( (, Codec.STRING), (o, v) -> o.targetBlock = v, (o) -> o.targetBlock, (o, p) -> o.targetBlock = p.targetBlock).addValidatorLate(() -> BlockType.VALIDATOR_CACHE.getValidator().late()).addValidator(Validators.nonNull()).add()).appendInherited( (, ProtocolCodecs.RANGEF), (o, v) -> o.lifetime = v, (o) -> o.lifetime, (o, p) -> o.lifetime = p.lifetime).addValidator(Validators.nonNull()).add()).build();
      }
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/farming/FarmingStageData.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config.farming;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.lookup.CodecMapCodec;
import com.hypixel.hytale.component.ComponentAccessor;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.math.util.ChunkUtil;
import com.hypixel.hytale.protocol.Rangef;
import com.hypixel.hytale.protocol.SoundCategory;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
import com.hypixel.hytale.server.core.asset.type.soundevent.validator.SoundEventValidators;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.universe.world.SoundUtil;
import com.hypixel.hytale.server.core.universe.world.chunk.section.ChunkSection;
import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public abstract class FarmingStageData {
   @Nonnull
   public static CodecMapCodec<FarmingStageData> CODEC = new CodecMapCodec<FarmingStageData>("Type");
   @Nonnull
   public static BuilderCodec<FarmingStageData> BASE_CODEC;
   protected Rangef duration;
   @Nullable
   protected String   ;
        ;

     {
   }

   
    Rangef  {
       .duration;
   }

   
    String  {
       .soundEventId;
   }

      {
       .soundEventIndex;
   }

      {
       ;
   }

      {
       ;
   }

      {
         (ChunkSection)commandBuffer.getComponent(sectionRef, ChunkSection.getComponentType());
         ChunkUtil.worldCoordFromLocalCoord(section.getX(), x);
         ChunkUtil.worldCoordFromLocalCoord(section.getY(), y);
         ChunkUtil.worldCoordFromLocalCoord(section.getZ(), z);
      SoundUtil.playSoundEvent3d(.soundEventIndex, SoundCategory.SFX, ()worldX, ()worldY, ()worldZ, ((ChunkStore)commandBuffer.getExternalData()).getWorld().getEntityStore().getStore());
       (previousStage != ) {
         previousStage.remove(commandBuffer, sectionRef, blockRef, x, y, z);
      }

   }

      {
   }

   
    String  {
         String.valueOf(.duration);
        + var10000 +  + .soundEventId + ;
   }

    {
      BASE_CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.abstractBuilder(FarmingStageData.class).append( (, ProtocolCodecs.RANGEF), (farmingStage, duration) -> farmingStage.duration = duration, (farmingStage) -> farmingStage.duration).add()).append( (, Codec.STRING), (farmingStage, sound) -> farmingStage.soundEventId = sound, (farmingStage) -> farmingStage.soundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.MONO).addValidator(SoundEventValidators.ONESHOT).add()).afterDecode((farmingStage) -> {
          (farmingStage.soundEventId != ) {
            farmingStage.soundEventIndex = SoundEvent.getAssetMap().getIndex(farmingStage.soundEventId);
         }

      })).build();
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/farming/GrowthModifierAsset.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config.farming;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetCodecMapCodec;
import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.component.CommandBuffer;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
import javax.annotation.Nonnull;

public abstract class GrowthModifierAsset implements JsonAssetWithMap<String, DefaultAssetMap<String, GrowthModifierAsset>> {
   public static final AssetCodecMapCodec<String, GrowthModifierAsset> CODEC;
   public static final Codec<String> CHILD_ASSET_CODEC;
   public static final Codec<String[]> CHILD_ASSET_CODEC_ARRAY;
   public static final BuilderCodec<GrowthModifierAsset> ABSTRACT_CODEC;
   private static AssetStore<String, GrowthModifierAsset, DefaultAssetMap<String, GrowthModifierAsset>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
     modifier;

     AssetStore<String, GrowthModifierAsset, DefaultAssetMap<String, GrowthModifierAsset>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, GrowthModifierAsset, DefaultAssetMap<String, GrowthModifierAsset>>getAssetStore(GrowthModifierAsset.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, GrowthModifierAsset>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

     {
   }

     {
      .id = id;
   }

    String  {
       .id;
   }

      {
       .modifier;
   }

      {
       .modifier;
   }

   
    String  {
        + .id +  + .modifier + ;
   }

    {
      CODEC =  <String, GrowthModifierAsset>(Codec.STRING, (t, k) -> t.id = k, (t) -> t.id, (t, data) -> t.data = data, (t) -> t.data);
      CHILD_ASSET_CODEC =  (GrowthModifierAsset.class, CODEC);
      CHILD_ASSET_CODEC_ARRAY =  <String[]>(CHILD_ASSET_CODEC, (x$) ->  [x$]);
      ABSTRACT_CODEC = ((BuilderCodec.Builder)BuilderCodec.abstractBuilder(GrowthModifierAsset.class).appendInherited( (, Codec.DOUBLE), (asset, modifier) -> asset.modifier = modifier, (asset) -> asset.modifier, (asset, parent) -> asset.modifier = parent.modifier).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/mountpoints/BlockMountPoint.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config.mountpoints;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.math.vector.Vector3f;
import com.hypixel.hytale.math.vector.Vector3i;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.Rotation;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.RotationTuple;
import javax.annotation.Nonnull;

public class BlockMountPoint {
   public static final BuilderCodec<BlockMountPoint> CODEC;
   public static final BlockMountPoint[] EMPTY_ARRAY;
   private Vector3f offset;
   private float yawOffSetDegrees;

   public BlockMountPoint() {
      this(new Vector3f(), 0.0F);
   }

   public BlockMountPoint(Vector3f offset, float yawOffSetDegrees) {
      this.offset = offset;
      this.yawOffSetDegrees = yawOffSetDegrees;
   }

   public Vector3f getOffset() {
      return this.offset;
   }

   public float  {
       .yawOffSetDegrees;
   }

   
    BlockMountPoint  {
         Rotation.rotate(.offset, yaw, pitch, roll);
        (rotatedOffset, .yawOffSetDegrees);
   }

   
    Vector3f  {
       blockLoc.toVector3f().add(, , ).add(.offset.x, .offset.y, .offset.z);
   }

   
    Vector3f  {
         RotationTuple.get(rotationIndex);
          (()rotationTuple.pitch().getRadians(), ()rotationTuple.yaw().getRadians(), ()rotationTuple.roll().getRadians());
      rotation.addYaw();
      rotation.addYaw(()Math.toRadians(().yawOffSetDegrees));
       rotation;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(BlockMountPoint.class, BlockMountPoint::).appendInherited( (, Vector3f.CODEC), (seat, i) -> seat.offset = i, (seat) -> seat.offset, (seat, p) -> seat.offset = p.offset).documentation().add()).appendInherited( (, Codec.DOUBLE), (seat, o) -> seat.yawOffSetDegrees = o.floatValue(), (seat) -> ()seat.yawOffSetDegrees, (seat, p) -> seat.yawOffSetDegrees = p.yawOffSetDegrees).documentation().add()).build();
      EMPTY_ARRAY =  [];
   }
}

com/hypixel/hytale/server/core/asset/type/blocktype/config/mountpoints/RotatedMountPointsArray.java

package com.hypixel.hytale.server.core.asset.type.blocktype.config.mountpoints;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.function.FunctionCodec;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.RotationTuple;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.util.List;
import javax.annotation.Nullable;

public class RotatedMountPointsArray {
   private static final ArrayCodec<BlockMountPoint> CHILD;
   public static final Codec<RotatedMountPointsArray> CODEC;
   private BlockMountPoint[] raw;
   private transient BlockMountPoint[][] rotated;

   public RotatedMountPointsArray() {
   }

   public RotatedMountPointsArray(BlockMountPoint[] raw) {
      this.raw = raw;
   }

   public int size() {
      return this.raw == null ? 0 : this.raw.length;
   }

   public BlockMountPoint[] getRaw() {
      return this.raw;
   }

   @Nullable
   public BlockMountPoint[] getRotated( rotationIndex) {
       (.raw !=  && rotationIndex != ) {
          (.rotated == ) {
            .rotated =  [RotationTuple.VALUES.length][];
         }

         BlockMountPoint[] value = .rotated[rotationIndex];
          (value == ) {
               RotationTuple.get(rotationIndex);
            List<BlockMountPoint> list =  <BlockMountPoint>();

            (BlockMountPoint mountPoint : .raw) {
                  mountPoint.rotate(rotation.yaw(), rotation.pitch(), rotation.roll());
               list.add(rotated);
            }

            value = (BlockMountPoint[])list.toArray((x$) ->  [x$]);
            .rotated[rotationIndex] = value;
         }

          value;
      }  {
          .raw;
      }
   }

    {
      CHILD =  <BlockMountPoint>(BlockMountPoint.CODEC, (x$) ->  [x$]);
      CODEC =  (CHILD, RotatedMountPointsArray::, RotatedMountPointsArray::getRaw);
   }
}

com/hypixel/hytale/server/core/asset/type/buildertool/config/BlockTypeListAsset.java

package com.hypixel.hytale.server.core.asset.type.buildertool.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.common.map.WeightedMap;
import com.hypixel.hytale.common.util.ArrayUtil;
import com.hypixel.hytale.server.core.prefab.selection.mask.BlockPattern;
import java.util.Collections;
import java.util.HashSet;
import javax.annotation.Nonnull;

public class BlockTypeListAsset implements JsonAssetWithMap<String, DefaultAssetMap<String, BlockTypeListAsset>> {
   public static final AssetBuilderCodec<String, BlockTypeListAsset> CODEC;
   private static AssetStore<String, BlockTypeListAsset, DefaultAssetMap<String, BlockTypeListAsset>> ASSET_STORE;
   public static final ValidatorCache<String> VALIDATOR_CACHE;
   private String id;
   private final HashSet<String> blockTypeKeys =  ();
    BlockPattern blockPattern;
    AssetExtraInfo.Data data;

     {
   }

     AssetStore<String, BlockTypeListAsset, DefaultAssetMap<String, BlockTypeListAsset>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, BlockTypeListAsset, DefaultAssetMap<String, BlockTypeListAsset>>getAssetStore(BlockTypeListAsset.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, BlockTypeListAsset>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

    BlockPattern  {
       .blockPattern;
   }

   
    HashSet<String>  {
       .blockTypeKeys;
   }

    String  {
       .id;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(BlockTypeListAsset.class, BlockTypeListAsset::, Codec.STRING, (builder, id) -> builder.id = id, (builder) -> builder.id, (builder, data) -> builder.data = data, (builder) -> builder.data).append( (,  (Codec.STRING, (x$) ->  [x$]), ), (builder, blockTypeKeys) -> {
          (blockTypeKeys != ) {
            Collections.addAll(builder.blockTypeKeys, blockTypeKeys);
         }
      }, (builder) -> (String[])builder.blockTypeKeys.toArray((x$) ->  [x$])).add()).afterDecode((blockTypeListAsset) -> {
          (blockTypeListAsset.blockTypeKeys != ) {
            WeightedMap.Builder<String> weightedMapBuilder = WeightedMap.<String>builder(ArrayUtil.EMPTY_STRING_ARRAY);

            (String blockTypeKey : blockTypeListAsset.blockTypeKeys) {
               weightedMapBuilder.put(blockTypeKey, );
            }

            blockTypeListAsset.blockPattern =  (weightedMapBuilder.build());
         }
      })).build();
      VALIDATOR_CACHE =  <String>( (BlockTypeListAsset::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/buildertool/config/BrushData.java

package com.hypixel.hytale.server.core.asset.type.buildertool.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.common.util.ArrayUtil;
import com.hypixel.hytale.protocol.Rotation;
import com.hypixel.hytale.protocol.packets.buildertools.BrushAxis;
import com.hypixel.hytale.protocol.packets.buildertools.BrushOrigin;
import com.hypixel.hytale.protocol.packets.buildertools.BrushShape;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolBlockArg;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolBrushData;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolStringArg;
import com.hypixel.hytale.server.core.Message;
import com.hypixel.hytale.server.core.asset.type.buildertool.config.args.BlockArg;
import com.hypixel.hytale.server.core.asset.type.buildertool.config.args.BoolArg;
import com.hypixel.hytale.server.core.asset.type.buildertool.config.args.BrushAxisArg;
import com.hypixel.hytale.server.core.asset.type.buildertool.config.args.BrushOriginArg;
import com.hypixel.hytale.server.core.asset.type.buildertool.config.args.BrushRotationArg;
import com.hypixel.hytale.server.core.asset.type.buildertool.config.args.BrushShapeArg;
import com.hypixel.hytale.server.core.asset.type.buildertool.config.args.IntArg;
import com.hypixel.hytale.server.core.asset.type.buildertool.config.args.MaskArg;
import com.hypixel.hytale.server.core.asset.type.buildertool.config.args.StringArg;
import com.hypixel.hytale.server.core.asset.type.buildertool.config.args.ToolArg;
import com.hypixel.hytale.server.core.asset.type.buildertool.config.args.ToolArgException;
 com.hypixel.hytale.server.core.io.NetworkSerializable;
 com.hypixel.hytale.server.core.prefab.selection.mask.BlockMask;
 com.hypixel.hytale.server.core.prefab.selection.mask.BlockPattern;
 java.util.Arrays;
 java.util.Objects;
 java.util.regex.Pattern;
 javax.annotation.Nonnull;

    <BuilderToolBrushData> {
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
          ();
         ;
         Pattern.compile();
      BuilderCodec<BrushData> CODEC;
        (, , );
        (, , );
        (, , );
        ();
    BrushShapeArg shape;
    BrushOriginArg origin;
    BoolArg originRotation;
    BrushAxisArg rotationAxis;
    BrushRotationArg rotationAngle;
    BrushAxisArg mirrorAxis;
    BlockArg material;
    BlockArg[] favoriteMaterials;
    MaskArg mask;
    MaskArg maskAbove;
    MaskArg maskNot;
    MaskArg maskBelow;
    MaskArg maskAdjacent;
    MaskArg maskNeighbor;
    StringArg[] maskCommands;
    BoolArg useMaskCommands;
    BoolArg invertMask;

     {
      .shape =  (BrushShape.Cube);
      .origin =  (BrushOrigin.Center);
      .originRotation =  ();
      .rotationAxis =  (BrushAxis.None);
      .rotationAngle =  (Rotation.None);
      .mirrorAxis =  (BrushAxis.None);
      .material =  (BlockPattern.EMPTY, );
      .favoriteMaterials = BlockArg.EMPTY_ARRAY;
      .mask = MaskArg.EMPTY;
      .maskAbove = MaskArg.EMPTY;
      .maskNot = MaskArg.EMPTY;
      .maskBelow = MaskArg.EMPTY;
      .maskAdjacent = MaskArg.EMPTY;
      .maskNeighbor = MaskArg.EMPTY;
      .maskCommands = StringArg.EMPTY_ARRAY;
      .useMaskCommands =  ();
      .invertMask =  ();
   }

     {
      .shape =  (BrushShape.Cube);
      .origin =  (BrushOrigin.Center);
      .originRotation =  ();
      .rotationAxis =  (BrushAxis.None);
      .rotationAngle =  (Rotation.None);
      .mirrorAxis =  (BrushAxis.None);
      .material =  (BlockPattern.EMPTY, );
      .favoriteMaterials = BlockArg.EMPTY_ARRAY;
      .mask = MaskArg.EMPTY;
      .maskAbove = MaskArg.EMPTY;
      .maskNot = MaskArg.EMPTY;
      .maskBelow = MaskArg.EMPTY;
      .maskAdjacent = MaskArg.EMPTY;
      .maskNeighbor = MaskArg.EMPTY;
      .maskCommands = StringArg.EMPTY_ARRAY;
      .useMaskCommands =  ();
      .invertMask =  ();
      .width = width;
      .height = height;
      .thickness = thickness;
      .capped = capped;
      .shape = shape;
      .origin = origin;
      .originRotation = originRotation;
      .rotationAxis = rotationAxis;
      .rotationAngle = rotationAngle;
      .mirrorAxis = mirrorAxis;
      .material = material;
      .favoriteMaterials = favoriteMaterials;
      .mask = mask;
      .maskAbove = maskAbove;
      .maskNot = maskNot;
      .maskBelow = maskBelow;
      .maskAdjacent = maskAdjacent;
      .maskNeighbor = maskNeighbor;
      .maskCommands = maskCommands;
      .useMaskCommands = useMaskCommands;
   }

    IntArg  {
       .width;
   }

    IntArg  {
       .height;
   }

    IntArg  {
       .thickness;
   }

    BoolArg  {
       .capped;
   }

    BrushShapeArg  {
       .shape;
   }

    BrushOriginArg  {
       .origin;
   }

    BoolArg  {
       .originRotation;
   }

    BrushAxisArg  {
       .rotationAxis;
   }

    BrushRotationArg  {
       .rotationAngle;
   }

    BrushAxisArg  {
       .mirrorAxis;
   }

    BlockArg  {
       .material;
   }

    BlockArg[] getFavoriteMaterials() {
       .favoriteMaterials;
   }

    MaskArg  {
       .mask;
   }

    MaskArg  {
       .maskAbove;
   }

    MaskArg  {
       .maskNot;
   }

    MaskArg  {
       .maskBelow;
   }

    MaskArg  {
       .maskAdjacent;
   }

    MaskArg  {
       .maskNeighbor;
   }

    StringArg[] getMaskCommands() {
       .maskCommands;
   }

    BoolArg  {
       .useMaskCommands;
   }

    BoolArg  {
       .invertMask;
   }

       ToolArgException {
       (id) {
           -> brush.height = .height.fromString(value);
           -> brush.width = .width.fromString(value);
           -> brush.thickness = .thickness.fromString(value);
           -> brush.capped = .capped.fromString(value);
           -> brush.shape = .shape.fromString(value);
           -> brush.origin = .origin.fromString(value);
           -> brush.originRotation = .originRotation.fromString(value);
           -> brush.rotationAxis = .rotationAxis.fromString(value);
           -> brush.rotationAngle = .rotationAngle.fromString(value);
           -> brush.mirrorAxis = .mirrorAxis.fromString(value);
           -> brush.material = .material.fromString(value);
           -> brush.favoriteMaterials = value.isEmpty() ? BlockPattern.EMPTY_ARRAY : (BlockPattern[])Arrays.stream(value.split()).limit().map(BlockPattern::parse).toArray((x$) ->  [x$]);
           -> brush.mask = .mask.fromString(value);
           -> brush.maskAbove = .maskAbove.fromString(value);
           -> brush.maskNot = .maskNot.fromString(value);
           -> brush.maskBelow = .maskBelow.fromString(value);
           -> brush.maskAdjacent = .maskAdjacent.fromString(value);
           -> brush.maskNeighbor = .maskNeighbor.fromString(value);
           -> brush.maskCommands = value.isEmpty() ? ArrayUtil.EMPTY_STRING_ARRAY : NEWLINES_PATTERN.split(value);
           -> brush.useMaskCommands = .useMaskCommands.fromString(value);
           -> brush.invertMask = .invertMask.fromString(value);
          ->   (Message.translation().param(, id));
      }

   }

   
    BuilderToolBrushData  {
          ();
      packet.width = .width.toIntArgPacket();
      packet.height = .height.toIntArgPacket();
      packet.thickness = .thickness.toIntArgPacket();
      packet.capped = .capped.toBoolArgPacket();
      packet.shape = .shape.toBrushShapeArgPacket();
      packet.origin = .origin.toBrushOriginArgPacket();
      packet.originRotation = .originRotation.toBoolArgPacket();
      packet.rotationAxis = .rotationAxis.toBrushAxisArgPacket();
      packet.rotationAngle = .rotationAngle.toRotationArgPacket();
      packet.mirrorAxis = .mirrorAxis.toBrushAxisArgPacket();
      packet.material = .material.toBlockArgPacket();
      packet.favoriteMaterials = (BuilderToolBlockArg[])Arrays.stream(.favoriteMaterials).filter(Objects::nonNull).map(BlockArg::toBlockArgPacket).toArray((x$) ->  [x$]);
      packet.mask = .mask.toMaskArgPacket();
      packet.maskAbove = .maskAbove.toMaskArgPacket();
      packet.maskNot = .maskNot.toMaskArgPacket();
      packet.maskBelow = .maskBelow.toMaskArgPacket();
      packet.maskAdjacent = .maskAdjacent.toMaskArgPacket();
      packet.maskNeighbor = .maskNeighbor.toMaskArgPacket();
      packet.maskCommands = (BuilderToolStringArg[])Arrays.stream(.maskCommands).filter(Objects::nonNull).map(StringArg::toStringArgPacket).toArray((x$) ->  [x$]);
      packet.useMaskCommands = .useMaskCommands.toBoolArgPacket();
      packet.invertMask = .invertMask.toBoolArgPacket();
       packet;
   }

   
    String  {
         String.valueOf(.width);
        + var10000 +  + String.valueOf(.height) +  + String.valueOf(.thickness) +  + String.valueOf(.capped) +  + String.valueOf(.shape) +  + String.valueOf(.origin) +  + String.valueOf(.originRotation) +  + String.valueOf(.rotationAxis) +  + String.valueOf(.rotationAngle) +  + String.valueOf(.mirrorAxis) +  + String.valueOf(.material) +  + Arrays.toString(.favoriteMaterials) +  + String.valueOf(.mask) +  + String.valueOf(.maskAbove) +  + String.valueOf(.maskNot) +  + String.valueOf(.maskBelow) +  + String.valueOf(.maskAdjacent) +  + String.valueOf(.maskNeighbor) +  + Arrays.toString(.maskCommands) +  + String.valueOf(.useMaskCommands) +  + String.valueOf(.invertMask) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(BrushData.class, BrushData::).append( (, IntArg.CODEC), (brushData, o) -> brushData.width = o, (brushData) -> brushData.width).addValidator(Validators.nonNull()).documentation().add()).append( (, IntArg.CODEC), (brushData, o) -> brushData.height = o, (brushData) -> brushData.height).addValidator(Validators.nonNull()).documentation().add()).append( (, IntArg.CODEC), (data, o) -> data.thickness = o, (data) -> data.thickness).addValidator(Validators.nonNull()).documentation().add()).append( (, BoolArg.CODEC), (data, o) -> data.capped = o, (data) -> data.capped).addValidator(Validators.nonNull()).documentation().add()).append( (, BrushShapeArg.CODEC), (brushData, o) -> brushData.shape = o, (brushData) -> brushData.shape).addValidator(Validators.nonNull()).documentation().add()).append( (, BrushOriginArg.CODEC), (brushData, o) -> brushData.origin = o, (brushData) -> brushData.origin).addValidator(Validators.nonNull()).documentation().add()).append( (, BoolArg.CODEC), (data, o) -> data.originRotation = o, (data) -> data.originRotation).addValidator(Validators.nonNull()).documentation().add()).append( (, BrushAxisArg.CODEC), (data, o) -> data.rotationAxis = o, (data) -> data.rotationAxis).addValidator(Validators.nonNull()).documentation().add()).append( (, BrushRotationArg.CODEC), (data, o) -> data.rotationAngle = o, (data) -> data.rotationAngle).addValidator(Validators.nonNull()).documentation().add()).append( (, BrushAxisArg.CODEC), (data, o) -> data.mirrorAxis = o, (data) -> data.mirrorAxis).addValidator(Validators.nonNull()).documentation().add()).append( (, BlockArg.CODEC), (brushData, o) -> brushData.material = o, (brushData) -> brushData.material).addValidator(Validators.nonNull()).documentation().add()).append( (,  (BlockArg.CODEC, (x$) ->  [x$])), (brushData, o) -> brushData.favoriteMaterials = o, (brushData) -> brushData.favoriteMaterials).documentation().add()).append( (, MaskArg.CODEC), (brushData, o) -> brushData.mask = o, (brushData) -> brushData.mask).documentation().add()).append( (, MaskArg.CODEC), (brushData, o) -> brushData.maskAbove = o, (brushData) -> brushData.maskAbove).documentation().add()).append( (, MaskArg.CODEC), (brushData, o) -> brushData.maskNot = o, (brushData) -> brushData.maskNot).documentation().add()).append( (, MaskArg.CODEC), (brushData, o) -> brushData.maskBelow = o, (brushData) -> brushData.maskBelow).documentation().add()).append( (, MaskArg.CODEC), (brushData, o) -> brushData.maskAdjacent = o, (brushData) -> brushData.maskAdjacent).documentation().add()).append( (, MaskArg.CODEC), (brushData, o) -> brushData.maskNeighbor = o, (brushData) -> brushData.maskNeighbor).documentation().add()).append( (,  (StringArg.CODEC, (x$) ->  [x$])), (brushData, o) -> brushData.maskCommands = o, (brushData) -> brushData.maskCommands).documentation().add()).append( (, BoolArg.CODEC), (brushData, o) -> brushData.useMaskCommands = o, (brushData) -> brushData.useMaskCommands).documentation().add()).append( (, BoolArg.CODEC), (brushData, o) -> brushData.invertMask = o, (brushData) -> brushData.invertMask).documentation().add()).build();
   }

       {
         Codec<Values> CODEC;
        width;
        height;
        thickness;
        capped;
       BrushShape shape;
       BrushOrigin origin;
        originRotation;
       BrushAxis rotationAxis;
       Rotation rotationAngle;
       BrushAxis mirrorAxis;
       BlockPattern material;
       BlockPattern[] favoriteMaterials;
       BlockMask mask;
       BlockMask maskAbove;
       BlockMask maskNot;
       BlockMask maskBelow;
       BlockMask maskAdjacent;
       BlockMask maskNeighbor;
       String[] maskCommands;
        useMaskCommands;
        invertMask;

        {
         (BrushData.DEFAULT);
      }

        {
         .width = (Integer)brushData.width.getValue();
         .height = (Integer)brushData.height.getValue();
         .thickness = (Integer)brushData.thickness.getValue();
         .capped = (Boolean)brushData.capped.getValue();
         .shape = (BrushShape)brushData.shape.getValue();
         .origin = (BrushOrigin)brushData.origin.getValue();
         .originRotation = (Boolean)brushData.originRotation.getValue();
         .rotationAxis = (BrushAxis)brushData.rotationAxis.getValue();
         .rotationAngle = (Rotation)brushData.rotationAngle.getValue();
         .mirrorAxis = (BrushAxis)brushData.mirrorAxis.getValue();
         .material = (BlockPattern)brushData.material.getValue();
         .favoriteMaterials = brushData.favoriteMaterials.length ==  ? BlockPattern.EMPTY_ARRAY : (BlockPattern[])Arrays.stream(brushData.favoriteMaterials).limit().map(ToolArg::getValue).toArray((x$) ->  [x$]);
         .mask = (BlockMask)brushData.mask.getValue();
         .maskAbove = (BlockMask)brushData.maskAbove.getValue();
         .maskNot = (BlockMask)brushData.maskNot.getValue();
         .maskBelow = (BlockMask)brushData.maskBelow.getValue();
         .maskAdjacent = (BlockMask)brushData.maskAdjacent.getValue();
         .maskNeighbor = (BlockMask)brushData.maskNeighbor.getValue();
         .maskCommands = brushData.maskCommands.length ==  ? ArrayUtil.EMPTY_STRING_ARRAY : (String[])Arrays.stream(brushData.maskCommands).map(ToolArg::getValue).toArray((x$) ->  [x$]);
         .useMaskCommands = (Boolean)brushData.useMaskCommands.getValue();
         .invertMask = (Boolean)brushData.invertMask.getValue();
      }

        {
         .width = width;
         .height = height;
         .thickness = thickness;
         .capped = capped;
         .shape = shape;
         .origin = origin;
         .originRotation = originRotation;
         .rotationAxis = rotationAxis;
         .rotationAngle = rotationAngle;
         .mirrorAxis = mirrorAxis;
         .material = material;
         .favoriteMaterials = favoriteMaterials;
         .mask = mask;
         .maskAbove = maskAbove;
         .maskNot = maskNot;
         .maskBelow = maskBelow;
         .maskAdjacent = maskAdjacent;
         .maskNeighbor = maskNeighbor;
         .maskCommands = maskCommands;
         .useMaskCommands = useMaskCommands;
      }

         {
          .width;
      }

         {
          .height;
      }

         {
          .thickness;
      }

         {
          .capped;
      }

       BrushShape  {
          .shape;
      }

       BrushOrigin  {
          .origin;
      }

         {
          .originRotation;
      }

       BrushAxis  {
          .rotationAxis;
      }

       Rotation  {
          .rotationAngle;
      }

       BrushAxis  {
          .mirrorAxis;
      }

       BlockPattern  {
          .material;
      }

       BlockPattern[] getFavoriteMaterials() {
          .favoriteMaterials;
      }

       BlockMask  {
          .mask;
      }

       BlockMask  {
          .maskAbove;
      }

       BlockMask  {
          .maskNot;
      }

       BlockMask  {
          .maskBelow;
      }

       BlockMask  {
          .maskAdjacent;
      }

       BlockMask  {
          .maskNeighbor;
      }

       String[] getMaskCommands() {
          .maskCommands;
      }

      
       BlockMask[] getParsedMaskCommands() {
          (BlockMask[])Arrays.stream(.getMaskCommands()).map((m) -> m.split()).map(BlockMask::parse).toArray((x$) ->  [x$]);
      }

         {
          .useMaskCommands;
      }

         {
          .invertMask;
      }

      
       String  {
            .width;
           + var10000 +  + .height +  + .thickness +  + .capped +  + String.valueOf(.shape) +  + String.valueOf(.origin) +  + .originRotation +  + String.valueOf(.rotationAxis) +  + String.valueOf(.rotationAngle) +  + String.valueOf(.mirrorAxis) +  + String.valueOf(.material) +  + Arrays.toString(.favoriteMaterials) +  + String.valueOf(.mask) +  + String.valueOf(.maskAbove) +  + String.valueOf(.maskNot) +  + String.valueOf(.maskBelow) +  + String.valueOf(.maskAdjacent) +  + String.valueOf(.maskNeighbor) +  + Arrays.toString(.maskCommands) +  + .useMaskCommands +  + .invertMask + ;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(Values.class, Values::).append( (, Codec.INTEGER), (brushData, o) -> brushData.width = o, (brushData) -> brushData.width).addValidator(Validators.greaterThan()).documentation().add()).append( (, Codec.INTEGER), (brushData, o) -> brushData.height = o, (brushData) -> brushData.height).addValidator(Validators.greaterThan()).documentation().add()).append( (, Codec.INTEGER), (data, o) -> data.thickness = o, (data) -> data.thickness).addValidator(Validators.range(, )).documentation().add()).append( (, Codec.BOOLEAN), (data, o) -> data.capped = o, (data) -> data.capped).addValidator(Validators.nonNull()).documentation().add()).append( (, BrushShapeArg.BRUSH_SHAPE_CODEC), (brushData, o) -> brushData.shape = o, (brushData) -> brushData.shape).addValidator(Validators.nonNull()).documentation().add()).append( (, BrushOriginArg.BRUSH_ORIGIN_CODEC), (brushData, o) -> brushData.origin = o, (brushData) -> brushData.origin).addValidator(Validators.nonNull()).documentation().add()).append( (, Codec.BOOLEAN), (data, o) -> data.originRotation = o, (data) -> data.originRotation).addValidator(Validators.nonNull()).documentation().add()).append( (, BrushAxisArg.BRUSH_AXIS_CODEC), (data, o) -> data.rotationAxis = o, (data) -> data.rotationAxis).addValidator(Validators.nonNull()).documentation().add()).append( (, BrushRotationArg.ROTATION_CODEC), (data, o) -> data.rotationAngle = o, (data) -> data.rotationAngle).addValidator(Validators.nonNull()).documentation().add()).append( (, BrushAxisArg.BRUSH_AXIS_CODEC), (data, o) -> data.mirrorAxis = o, (data) -> data.mirrorAxis).addValidator(Validators.nonNull()).documentation().add()).append( (, BlockPattern.CODEC), (brushData, o) -> brushData.material = o, (brushData) -> brushData.material).addValidator(Validators.nonNull()).documentation().add()).append( (,  (BlockPattern.CODEC, (x$) ->  [x$])), (brushData, o) -> brushData.favoriteMaterials = o, (brushData) -> brushData.favoriteMaterials).addValidator(Validators.arraySizeRange(, )).documentation().add()).append( (, BlockMask.CODEC), (brushData, o) -> brushData.mask = o, (brushData) -> brushData.mask).documentation().add()).append( (, BlockMask.CODEC), (brushData, o) -> brushData.maskAbove = o, (brushData) -> brushData.maskAbove).documentation().add()).append( (, BlockMask.CODEC), (brushData, o) -> brushData.maskNot = o, (brushData) -> brushData.maskNot).documentation().add()).append( (, BlockMask.CODEC), (brushData, o) -> brushData.maskBelow = o, (brushData) -> brushData.maskBelow).documentation().add()).append( (, BlockMask.CODEC), (brushData, o) -> brushData.maskAdjacent = o, (brushData) -> brushData.maskAdjacent).documentation().add()).append( (, BlockMask.CODEC), (brushData, o) -> brushData.maskNeighbor = o, (brushData) -> brushData.maskNeighbor).documentation().add()).append( (, Codec.STRING_ARRAY), (brushData, o) -> brushData.maskCommands = o, (brushData) -> brushData.maskCommands).documentation().add()).append( (, Codec.BOOLEAN), (brushData, o) -> brushData.useMaskCommands = o, (brushData) -> brushData.useMaskCommands).documentation().add()).append( (, Codec.BOOLEAN), (brushData, o) -> brushData.invertMask = o, (brushData) -> brushData.invertMask).documentation().add()).build();
      }
   }
}

com/hypixel/hytale/server/core/asset/type/buildertool/config/BuilderTool.java

package com.hypixel.hytale.server.core.asset.type.buildertool.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.codec.lookup.MapProvidedMapCodec;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArg;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArgGroup;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolState;
import com.hypixel.hytale.server.core.Message;
import com.hypixel.hytale.server.core.asset.type.buildertool.config.args.ToolArg;
import com.hypixel.hytale.server.core.asset.type.buildertool.config.args.ToolArgException;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.entity.entities.Player;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.lang.ref.SoftReference;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDocument;

public class BuilderTool  <String, DefaultAssetMap<String, BuilderTool>>, NetworkSerializable<BuilderToolState> {
         ;
      KeyedCodec<BrushData.Values> BRUSH_DATA_KEY_CODEC;
      BuilderTool DEFAULT;
      AssetBuilderCodec<String, BuilderTool> CODEC;
     DefaultAssetMap<String, BuilderTool> ASSET_MAP;
    AssetExtraInfo.Data data;
    String id;
     isBrush;
    String brushConfigurationCommand;
    BrushData brushData;
    Map<String, ToolArg> args;
    Map<String, Object> defaultToolArgs;
    MapProvidedMapCodec<Object, ToolArg> argsCodec;
    SoftReference<BuilderToolState> cachedPacket;

     {
      .brushData = BrushData.DEFAULT;
      .args = Collections.emptyMap();
   }

     DefaultAssetMap<String, BuilderTool>  {
       (ASSET_MAP == ) {
         ASSET_MAP = (DefaultAssetMap)AssetRegistry.getAssetStore(BuilderTool.class).getAssetMap();
      }

       ASSET_MAP;
   }

   
     BuilderTool  {
         player.getInventory().getItemInHand();
       (activeItemStack == ) {
          ;
      }  {
            activeItemStack.getItem();
            item.getBuilderToolData();
          builderToolData ==  ?  : builderToolData.getTools()[];
      }
   }

    String  {
       .id;
   }

    String  {
       .brushConfigurationCommand;
   }

      {
       .isBrush;
   }

    BrushData  {
       .brushData;
   }

    Map<String, ToolArg>  {
       .args;
   }

    MapProvidedMapCodec<Object, ToolArg>  {
       .argsCodec;
   }

   
    Map<String, Object>  {
         itemStack.getItem().getBuilderToolData().getTools()[];
      Map<String, Object> map =  <String, Object>(builderToolAsset.args.size());

      (Map.Entry<String, ToolArg> entry : builderToolAsset.args.entrySet()) {
         map.put((String)entry.getKey(), ((ToolArg)entry.getValue()).getValue());
      }

       map;
   }

   
    BrushData.Values  {
         itemStack.getItem().getBuilderToolData().getTools()[];
        .Values(builderToolAsset.brushData);
   }

   
    ArgData  {
      Map<String, Object> toolArgs = ;
       (!.args.isEmpty()) {
         Map<String, Object> toolData = (Map)itemStack.getFromMetadataOrNull(, .argsCodec);
         toolArgs = toolData ==  ? .getDefaultToolArgs(itemStack) : toolData;
      }

      BrushData.   ;
       (.isBrush) {
         BrushData.   (BrushData.Values)itemStack.getFromMetadataOrNull(BRUSH_DATA_KEY_CODEC);
         brushArgs = brushData ==  ? .getDefaultBrushArgs(itemStack) : brushData;
      }

        (toolArgs, brushArgs);
   }

   
    ItemStack  {
          ();
       (argData.tool() != ) {
         meta.put(, .argsCodec.encode(argData.tool()));
      }

       (.isBrush) {
         BRUSH_DATA_KEY_CODEC.put(meta, argData.brush);
      }

        (itemId, quantity, meta);
   }

   
    ItemStack   ToolArgException {
         .getItemArgData(itemStack);
       (group == BuilderToolArgGroup.Brush) {
         .brushData.updateArgValue(argData.brush, id, value);
      }  {
            (ToolArg).args.get(id);
          (arg == ) {
              (Message.translation().param(, id));
         }

          (value == ) {
             (arg.isRequired()) {
                 (Message.translation().param(, id));
            }

            argData = BuilderTool.ArgData.removeToolArg(argData, id);
         }  {
               arg.fromString(value);
            argData = BuilderTool.ArgData.setToolArg(argData, id, newValue);
         }
      }

       .createItemStack(itemStack.getItemId(), itemStack.getQuantity(), argData);
   }

   
    BuilderToolState  {
         .cachedPacket ==  ?  : (BuilderToolState).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
             ();
         packet.id = .id;
         packet.isBrush = .isBrush;
          (.brushData != ) {
            packet.brushData = .brushData.toPacket();
         }

         Map<String, BuilderToolArg> map =  <String, BuilderToolArg>(.args.size());

         (Map.Entry<String, ToolArg> entry : .args.entrySet()) {
            map.put((String)entry.getKey(), ((ToolArg)entry.getValue()).toPacket());
         }

         packet.args = map;
         .cachedPacket =  (packet);
          packet;
      }
   }

   
    String  {
         .id;
        + var10000 +  + .isBrush +  + String.valueOf(.brushData) +  + String.valueOf(.args) + ;
   }

    {
      BRUSH_DATA_KEY_CODEC =  <BrushData.Values>(, BrushData.Values.CODEC);
      DEFAULT =  ();
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(BuilderTool.class, BuilderTool::, Codec.STRING, (t, k) -> t.id = k, (t) -> t.id, (asset, data) -> asset.data = data, (asset) -> asset.data).addField( (, Codec.STRING), (builderTool, o) -> builderTool.id = o, (builderTool) -> builderTool.id)).addField( (, Codec.BOOLEAN), (builderTool, o) -> builderTool.isBrush = o, (builderTool) -> builderTool.isBrush)).addField( (, Codec.STRING), (builderTool, o) -> builderTool.brushConfigurationCommand = o, (builderTool) -> builderTool.brushConfigurationCommand)).addField( (,  (ToolArg.CODEC, HashMap::)), (builderTool, s) -> builderTool.args = s, (builderTool) -> builderTool.args)).addField( (, BrushData.CODEC), (builderTool, o) -> builderTool.brushData = o, (builderTool) -> builderTool.brushData)).afterDecode((builderTool) -> {
          (!builderTool.args.isEmpty()) {
            builderTool.argsCodec =  <Object, ToolArg>(builderTool.args, ToolArg::getCodec, HashMap::);
         }

      })).build();
   }

       {
      
       Map<String, Object>  {
          .tool;
      }

      
        ArgData  {
         Map<String, Object> tool = argData.tool();
          (tool == ) {
             argData;
         }  {
            Object2ObjectOpenHashMap<String, Object> newToolArgs =  <String, Object>(tool);
            newToolArgs.put(argId, value);
              (newToolArgs, argData.brush());
         }
      }

      
        ArgData  {
         Map<String, Object> tool = argData.tool();
          (tool == ) {
             argData;
         }  {
            Object2ObjectOpenHashMap<String, Object> newToolArgs =  <String, Object>(tool);
            newToolArgs.remove(argId);
              (newToolArgs, argData.brush());
         }
      }

      
       BrushData.Values  {
          .brush;
      }

      
       String  {
            String.valueOf(.tool);
           + var10000 +  + String.valueOf(.brush) + ;
      }
   }
}

com/hypixel/hytale/server/core/asset/type/buildertool/config/BuilderToolData.java

package com.hypixel.hytale.server.core.asset.type.buildertool.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.ItemBuilderToolData;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolState;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.util.Arrays;
import javax.annotation.Nonnull;

public class BuilderToolData implements NetworkSerializable<ItemBuilderToolData> {
   public static final BuilderToolData DEFAULT = new BuilderToolData();
   public static final BuilderCodec<BuilderToolData> CODEC;
   protected String[] ui;
   protected BuilderTool[] tools;

   public BuilderToolData() {
   }

   public BuilderToolData(String[] ui, BuilderTool[] tools) {
      this.ui = ui;
      this.tools = tools;
   }

   public String[] getUi() {
      return this.ui;
   }

    BuilderTool[] getTools() {
       .tools;
   }

   
    ItemBuilderToolData  {
          ();
      packet.ui = .ui;
      packet.tools =  [.tools.length];

      (   ; i < .tools.length; ++i) {
         packet.tools[i] = .tools[i].toPacket();
      }

       packet;
   }

   
    String  {
         Arrays.toString(.ui);
        + var10000 +  + Arrays.toString(.tools) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(BuilderToolData.class, BuilderToolData::).addField( (,  (Codec.STRING, (x$) ->  [x$])), (builderToolData, o) -> builderToolData.ui = o, (builderToolData) -> builderToolData.ui)).append( (,  (BuilderTool.CODEC, (x$) ->  [x$])), (builderToolData, o) -> builderToolData.tools = o, (builderToolData) -> builderToolData.tools).addValidator(Validators.nonEmptyArray()).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/buildertool/config/PrefabListAsset.java

package com.hypixel.hytale.server.core.asset.type.buildertool.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.server.core.prefab.PrefabStore;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.io.IOException;
import java.nio.file.FileVisitOption;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.Supplier;
import java.util.logging.Level;
import java.util.stream.Stream;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class PrefabListAsset implements <String, DefaultAssetMap<String, PrefabListAsset>> {
      AssetBuilderCodec<String, PrefabListAsset> CODEC;
     AssetStore<String, PrefabListAsset, DefaultAssetMap<String, PrefabListAsset>> ASSET_STORE;
      ValidatorCache<String> VALIDATOR_CACHE;
    String id;
    Path[] prefabPaths;
    PrefabReference[] prefabReferences;
    AssetExtraInfo.Data data;

     {
   }

     AssetStore<String, PrefabListAsset, DefaultAssetMap<String, PrefabListAsset>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, PrefabListAsset, DefaultAssetMap<String, PrefabListAsset>>getAssetStore(PrefabListAsset.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, PrefabListAsset>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

      {
       (.prefabReferences != ) {
         ObjectArrayList<Path> paths =  <Path>();

         (PrefabReference prefabReference : .prefabReferences) {
            paths.addAll(prefabReference.prefabPaths);
         }

         .prefabPaths = (Path[])paths.toArray((x$) ->  [x$]);
      }
   }

    Path[] getPrefabPaths() {
       .prefabPaths;
   }

   
    PrefabReference[] getPrefabReferences() {
       .prefabReferences !=  ? .prefabReferences :  [];
   }

   
    Path  {
       .prefabPaths.length ==  ?  : .prefabPaths[ThreadLocalRandom.current().nextInt(.prefabPaths.length)];
   }

    String  {
       .id;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(PrefabListAsset.class, PrefabListAsset::, Codec.STRING, (builder, id) -> builder.id = id, (builder) -> builder.id, (builder, data) -> builder.data = data, (builder) -> builder.data).append( (,  (PrefabListAsset.PrefabReference.CODEC, (x$) ->  [x$]), ), (builder, prefabPaths) -> builder.prefabReferences = prefabPaths, (builder) -> builder.prefabReferences).add()).afterDecode(PrefabListAsset::convertPrefabReferencesToPrefabPaths)).build();
      VALIDATOR_CACHE =  <String>( (PrefabListAsset::getAssetStore));
   }

       {
      Server(() -> PrefabStore.get().getServerPrefabsPath(), ),
      Asset(() -> PrefabStore.get().getAssetPrefabsPath(), ),
      Worldgen(() -> PrefabStore.get().getWorldGenPrefabsPath(), );

        Supplier<Path> prefabPath;
        String localizationString;

        {
         .prefabPath = prefabPath;
         .localizationString = localizationString;
      }

       Path  {
          (Path).prefabPath.get();
      }

       String  {
          .localizationString;
      }
   }

       {
         BuilderCodec<PrefabReference> CODEC;
       PrefabRootDirectory rootDirectory;
       String unprocessedPrefabPath;
          ;
      
       List<Path> prefabPaths =  <Path>();

        {
      }

         {
          (.unprocessedPrefabPath != ) {
            .unprocessedPrefabPath = .unprocessedPrefabPath.replace(, );
             (.unprocessedPrefabPath.endsWith()) {
                {
                  Stream<Path> walk = Files.walk(.rootDirectory.getPrefabPath().resolve(.unprocessedPrefabPath), .recursive ?  : ,  []);

                   {
                        walk.filter((x$) -> Files.isRegularFile(x$,  [])).filter((path) -> path.toString().endsWith());
                        .prefabPaths;
                     Objects.requireNonNull(var10001);
                     var10000.forEach(var10001::add);
                  }  (Throwable var5) {
                      (walk != ) {
                         {
                           walk.close();
                        }  (Throwable var4) {
                           var5.addSuppressed(var4);
                        }
                     }

                      var5;
                  }

                   (walk != ) {
                     walk.close();
                  }
               }  (IOException e) {
                  ((HytaleLogger.Api)PrefabListAsset.getAssetStore().getLogger().at(Level.SEVERE).withCause(e)).log(, .unprocessedPrefabPath);
               }

            }  {
                (!.unprocessedPrefabPath.endsWith()) {
                  .unprocessedPrefabPath = .unprocessedPrefabPath + ;
               }

               .prefabPaths.add(.rootDirectory.getPrefabPath().resolve(.unprocessedPrefabPath));
            }
         }
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(PrefabReference.class, PrefabReference::).append( (,  (PrefabRootDirectory.class), ), (prefabReference, rootDirectory) -> prefabReference.rootDirectory = rootDirectory, (prefabReference) -> prefabReference.rootDirectory).add()).append( (, Codec.STRING, ), (prefabReference, unprocessedPrefabPath) -> prefabReference.unprocessedPrefabPath = unprocessedPrefabPath, (prefabReference) -> prefabReference.unprocessedPrefabPath).add()).append( (, Codec.BOOLEAN, ), (prefabReference, recursive) -> prefabReference.recursive = recursive, (prefabReference) -> prefabReference.recursive).add()).afterDecode(PrefabReference::processPrefabPath)).build();
      }
   }
}

com/hypixel/hytale/server/core/asset/type/buildertool/config/args/BlockArg.java

package com.hypixel.hytale.server.core.asset.type.buildertool.config.args;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArg;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArgType;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolBlockArg;
import com.hypixel.hytale.server.core.prefab.selection.mask.BlockPattern;
import javax.annotation.Nonnull;

public class BlockArg extends ToolArg<BlockPattern> {
   public static final BlockArg[] EMPTY_ARRAY = new BlockArg[0];
   public static final BuilderCodec<BlockArg> CODEC;
   protected boolean allowPattern;

   public BlockArg() {
   }

   public BlockArg(BlockPattern value, boolean allowPattern) {
      this.value = value;
      this.allowPattern = allowPattern;
   }

   @Nonnull
   public Codec<BlockPattern> getCodec() {
      return BlockPattern.CODEC;
   }

   @Nonnull
   public BlockPattern  {
       BlockPattern.parse(str);
   }

   
    BuilderToolBlockArg  {
        (((BlockPattern).value).toString(), .allowPattern);
   }

      {
      packet.argType = BuilderToolArgType.Block;
      packet.blockArg = .toBlockArgPacket();
   }

   
    String  {
         .allowPattern;
        + var10000 +  + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(BlockArg.class, BlockArg::, ToolArg.DEFAULT_CODEC).addField( (, BlockPattern.CODEC), (blockArg, d) -> blockArg.value = d, (blockArg) -> blockArg.value)).addField( (, Codec.BOOLEAN), (blockArg, d) -> blockArg.allowPattern = d, (blockArg) -> blockArg.allowPattern)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/buildertool/config/args/BoolArg.java

package com.hypixel.hytale.server.core.asset.type.buildertool.config.args;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArg;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArgType;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolBoolArg;
import javax.annotation.Nonnull;

public class BoolArg extends ToolArg<Boolean> {
   public static final BuilderCodec<BoolArg> CODEC;

   public BoolArg() {
   }

   public BoolArg(boolean value) {
      this.value = value;
   }

   @Nonnull
   public Codec<Boolean> getCodec() {
      return Codec.BOOLEAN;
   }

   @Nonnull
   public Boolean fromString(@Nonnull String str) {
      return Boolean.valueOf(str);
   }

   @Nonnull
   public BuilderToolBoolArg toBoolArgPacket() {
      return new BuilderToolBoolArg((Boolean).value);
   }

      {
      packet.argType = BuilderToolArgType.Bool;
      packet.boolArg = .toBoolArgPacket();
   }

   
    String  {
        + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(BoolArg.class, BoolArg::, ToolArg.DEFAULT_CODEC).addField( (, Codec.BOOLEAN), (boolArg, d) -> boolArg.value = d, (boolArg) -> boolArg.value)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/buildertool/config/args/BrushAxisArg.java

package com.hypixel.hytale.server.core.asset.type.buildertool.config.args;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.packets.buildertools.BrushAxis;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArg;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArgType;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolBrushAxisArg;
import javax.annotation.Nonnull;

public class BrushAxisArg extends ToolArg<BrushAxis> {
   public static final Codec<BrushAxis> BRUSH_AXIS_CODEC = new EnumCodec<BrushAxis>(BrushAxis.class);
   public static final BuilderCodec<BrushAxisArg> CODEC;

   public BrushAxisArg() {
   }

   public BrushAxisArg(BrushAxis value) {
      this.value = value;
   }

   @Nonnull
   public Codec<BrushAxis> getCodec() {
      return BRUSH_AXIS_CODEC;
   }

   @Nonnull
   public BrushAxis fromString  ToolArgException {
       BrushAxis.valueOf(str);
   }

   
    BuilderToolBrushAxisArg  {
        (.value);
   }

      {
      packet.argType = BuilderToolArgType.BrushAxis;
      packet.brushAxisArg = .toBrushAxisArgPacket();
   }

   
    String  {
        + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(BrushAxisArg.class, BrushAxisArg::, ToolArg.DEFAULT_CODEC).append( (, BRUSH_AXIS_CODEC), (arg, o) -> arg.value = o, (arg) -> arg.value).documentation().addValidator(Validators.nonNull()).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/buildertool/config/args/BrushOriginArg.java

package com.hypixel.hytale.server.core.asset.type.buildertool.config.args;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.protocol.packets.buildertools.BrushOrigin;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArg;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArgType;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolBrushOriginArg;
import javax.annotation.Nonnull;

public class BrushOriginArg extends ToolArg<BrushOrigin> {
   public static final EnumCodec<BrushOrigin> BRUSH_ORIGIN_CODEC = new EnumCodec<BrushOrigin>(BrushOrigin.class);
   public static final BuilderCodec<BrushOriginArg> CODEC;

   public BrushOriginArg() {
   }

   public BrushOriginArg(BrushOrigin value) {
      this.value = value;
   }

   @Nonnull
   public Codec<BrushOrigin> getCodec() {
      return BRUSH_ORIGIN_CODEC;
   }

   @Nonnull
   public BrushOrigin fromString( String str) {
       BrushOrigin.valueOf(str);
   }

   
    BuilderToolBrushOriginArg  {
        (.value);
   }

      {
      packet.argType = BuilderToolArgType.BrushOrigin;
      packet.brushOriginArg = .toBrushOriginArgPacket();
   }

   
    String  {
        + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(BrushOriginArg.class, BrushOriginArg::, ToolArg.DEFAULT_CODEC).addField( (, BRUSH_ORIGIN_CODEC), (originArg, o) -> originArg.value = o, (originArg) -> originArg.value)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/buildertool/config/args/BrushRotationArg.java

package com.hypixel.hytale.server.core.asset.type.buildertool.config.args;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.Rotation;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArg;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArgType;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolRotationArg;
import javax.annotation.Nonnull;

public class BrushRotationArg extends ToolArg<Rotation> {
   public static final Codec<Rotation> ROTATION_CODEC = new EnumCodec<Rotation>(Rotation.class);
   public static final BuilderCodec<BrushRotationArg> CODEC;

   public BrushRotationArg() {
   }

   public BrushRotationArg(Rotation value) {
      this.value = value;
   }

   @Nonnull
   public Codec<Rotation> getCodec() {
      return ROTATION_CODEC;
   }

   @Nonnull
   public Rotation fromString  ToolArgException {
       Rotation.valueOf(str);
   }

   
    BuilderToolRotationArg  {
        (.value);
   }

      {
      packet.argType = BuilderToolArgType.Rotation;
      packet.rotationArg = .toRotationArgPacket();
   }

   
    String  {
        + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(BrushRotationArg.class, BrushRotationArg::, ToolArg.DEFAULT_CODEC).append( (, ROTATION_CODEC), (arg, o) -> arg.value = o, (arg) -> arg.value).documentation().addValidator(Validators.nonNull()).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/buildertool/config/args/BrushShapeArg.java

package com.hypixel.hytale.server.core.asset.type.buildertool.config.args;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.protocol.packets.buildertools.BrushShape;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArg;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArgType;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolBrushShapeArg;
import javax.annotation.Nonnull;

public class BrushShapeArg extends ToolArg<BrushShape> {
   public static final EnumCodec<BrushShape> BRUSH_SHAPE_CODEC = new EnumCodec<BrushShape>(BrushShape.class);
   public static final BuilderCodec<BrushShapeArg> CODEC;

   public BrushShapeArg() {
   }

   public BrushShapeArg(BrushShape value) {
      this.value = value;
   }

   @Nonnull
   public Codec<BrushShape> getCodec() {
      return BRUSH_SHAPE_CODEC;
   }

   @Nonnull
   public BrushShape fromString(@Nonnull String str) {
       BrushShape.valueOf(str);
   }

   
    BuilderToolBrushShapeArg  {
        (.value);
   }

      {
      packet.argType = BuilderToolArgType.BrushShape;
      packet.brushShapeArg = .toBrushShapeArgPacket();
   }

   
    String  {
        + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(BrushShapeArg.class, BrushShapeArg::, ToolArg.DEFAULT_CODEC).addField( (, BRUSH_SHAPE_CODEC), (shapeArg, o) -> shapeArg.value = o, (shapeArg) -> shapeArg.value)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/buildertool/config/args/FloatArg.java

package com.hypixel.hytale.server.core.asset.type.buildertool.config.args;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArg;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArgType;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolFloatArg;
import com.hypixel.hytale.server.core.Message;
import javax.annotation.Nonnull;

public class FloatArg extends ToolArg<Float> {
   public static final BuilderCodec<FloatArg> CODEC;
   protected float min;
   protected float max;

   public FloatArg() {
      this.value = 0.0F;
   }

   public FloatArg(float value, float min, float max) {
      this.value = value;
      this.min = min;
      this.max = max;
   }

   public float getMin() {
      return this.min;
   }

   public float  {
       .max;
   }

   
    Codec<Float>  {
       Codec.FLOAT;
   }

   
    Float   ToolArgException {
         Float.parseFloat(str);
       (!(value < .min) && !(value > .max)) {
          value;
      }  {
           (Message.translation().param(, value).param(, .min).param(, .max));
      }
   }

   
    BuilderToolFloatArg  {
        ((Float).value, .min, .max);
   }

      {
      packet.argType = BuilderToolArgType.Float;
      packet.floatArg = .toFloatArgPacket();
   }

   
    String  {
         .min;
        + var10000 +  + .max +  + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(FloatArg.class, FloatArg::, ToolArg.DEFAULT_CODEC).addField( (, Codec.DOUBLE), (floatArg, o) -> floatArg.value = o.floatValue(), (floatArg) -> ()(Float)floatArg.value)).addField( (, Codec.DOUBLE), (floatArg, o) -> floatArg.min = o.floatValue(), (floatArg) -> ()floatArg.min)).addField( (, Codec.DOUBLE), (floatArg, o) -> floatArg.max = o.floatValue(), (floatArg) -> ()floatArg.max)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/buildertool/config/args/IntArg.java

package com.hypixel.hytale.server.core.asset.type.buildertool.config.args;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArg;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArgType;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolIntArg;
import com.hypixel.hytale.server.core.Message;
import javax.annotation.Nonnull;

public class IntArg extends ToolArg<Integer> {
   public static final BuilderCodec<IntArg> CODEC;
   protected int min;
   protected int max;

   public IntArg() {
   }

   public IntArg(int value, int min, int max) {
      this.value = value;
      this.min = min;
      this.max = max;
   }

   @Nonnull
   public Codec<Integer> getCodec() {
      return Codec.INTEGER;
   }

   public int getMin() {
      return .min;
   }

      {
       .max;
   }

   
    Integer   ToolArgException {
         Integer.parseInt(str);
       (value >= .min && value <= .max) {
          value;
      }  {
           (Message.translation().param(, value).param(, .min).param(, .max));
      }
   }

   
    BuilderToolIntArg  {
        ((Integer).value, .min, .max);
   }

      {
      packet.argType = BuilderToolArgType.Int;
      packet.intArg = .toIntArgPacket();
   }

   
    String  {
         .min;
        + var10000 +  + .max +  + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(IntArg.class, IntArg::, ToolArg.DEFAULT_CODEC).addField( (, Codec.INTEGER), (intArg, d) -> intArg.value = d, (intArg) -> intArg.value)).addField( (, Codec.INTEGER), (intArg, d) -> intArg.min = d, (intArg) -> intArg.min)).addField( (, Codec.INTEGER), (intArg, d) -> intArg.max = d, (intArg) -> intArg.max)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/buildertool/config/args/MaskArg.java

package com.hypixel.hytale.server.core.asset.type.buildertool.config.args;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArg;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArgType;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolMaskArg;
import com.hypixel.hytale.server.core.prefab.selection.mask.BlockMask;
import javax.annotation.Nonnull;

public class MaskArg extends ToolArg<BlockMask> {
   public static final MaskArg EMPTY;
   public static final BuilderCodec<MaskArg> CODEC;

   public MaskArg() {
   }

   public MaskArg(BlockMask value) {
      this.value = value;
   }

   public MaskArg(BlockMask value, boolean required) {
      this.value = value;
      this.required = required;
   }

   @Nonnull
   public Codec<BlockMask> getCodec() {
      return BlockMask.CODEC;
   }

   @Nonnull
   public BlockMask fromString {
       BlockMask.parse(str);
   }

   
    BuilderToolMaskArg  {
        (((BlockMask).value).toString());
   }

      {
      packet.argType = BuilderToolArgType.Mask;
      packet.maskArg = .toMaskArgPacket();
   }

   
    String  {
        + .toString();
   }

    {
      EMPTY =  (BlockMask.EMPTY, );
      CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(MaskArg.class, MaskArg::, ToolArg.DEFAULT_CODEC).addField( (, BlockMask.CODEC), (maskArg, d) -> maskArg.value = d, (maskArg) -> maskArg.value)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/buildertool/config/args/OptionArg.java

package com.hypixel.hytale.server.core.asset.type.buildertool.config.args;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArg;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArgType;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolOptionArg;
import java.util.Arrays;
import javax.annotation.Nonnull;

public class OptionArg extends ToolArg<String> {
   public static final BuilderCodec<OptionArg> CODEC;
   protected String[] options;

   public OptionArg() {
   }

   public OptionArg(String value, String[] options) {
      this.value = value;
      this.options = options;
   }

   @Nonnull
   public Codec<String> getCodec() {
      return Codec.STRING;
   }

   @Nonnull
   public String fromString(@Nonnull String str) {
      for(String option : this.options) {
         if (str.equalsIgnoreCase(option)) {
            return option;
         }
      }

       {
            Integer.parseInt(str);
          (index >=  && index < .options.length) {
             .options[index];
         }
      }  (NumberFormatException var6) {
      }

        ();
   }

   
    BuilderToolOptionArg  {
        (.value, .options);
   }

      {
      packet.argType = BuilderToolArgType.Option;
      packet.optionArg = .toOptionArgPacket();
   }

   
    String  {
         Arrays.toString(.options);
        + var10000 +  + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(OptionArg.class, OptionArg::, ToolArg.DEFAULT_CODEC).addField( (, Codec.STRING), (optionArg, o) -> optionArg.value = o, (optionArg) -> optionArg.value)).addField( (, Codec.STRING_ARRAY), (optionArg, o) -> optionArg.options = o, (optionArg) -> optionArg.options)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/buildertool/config/args/StringArg.java

package com.hypixel.hytale.server.core.asset.type.buildertool.config.args;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArg;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArgType;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolStringArg;
import javax.annotation.Nonnull;

public class StringArg extends ToolArg<String> {
   public static final StringArg[] EMPTY_ARRAY = new StringArg[0];
   public static final BuilderCodec<StringArg> CODEC;

   public StringArg() {
   }

   public StringArg(String value) {
      this.value = value;
   }

   @Nonnull
   public Codec<String> getCodec() {
      return Codec.STRING;
   }

   @Nonnull
   public String fromString(@Nonnull String str) {
      return str;
   }

   @Nonnull
   public BuilderToolStringArg  {
        (.value);
   }

      {
      packet.argType = BuilderToolArgType.String;
      packet.stringArg = .toStringArgPacket();
   }

   
    String  {
        + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(StringArg.class, StringArg::, ToolArg.DEFAULT_CODEC).addField( (, Codec.STRING), (stringArg, d) -> stringArg.value = d, (stringArg) -> stringArg.value)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/buildertool/config/args/ToolArg.java

package com.hypixel.hytale.server.core.asset.type.buildertool.config.args;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.lookup.CodecMapCodec;
import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolArg;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;

public abstract class ToolArg<T> implements NetworkSerializable<BuilderToolArg> {
   public static final CodecMapCodec<ToolArg> CODEC = new CodecMapCodec<ToolArg>("Type");
   public static final BuilderCodec<ToolArg> DEFAULT_CODEC;
   protected boolean required = true;
   protected T value;

   public ToolArg() {
   }

   public T getValue() {
      return this.value;
   }

   public boolean isRequired() {
      return this.required;
   }

   public  Codec<T> ;

   
     T   ToolArgException;

      ;

   
    BuilderToolArg  {
          ();
      packet.required = .required;
      .setupPacket(packet);
       packet;
   }

   
    String  {
         .required;
        + var10000 +  + String.valueOf(.value) + ;
   }

    {
      DEFAULT_CODEC = ((BuilderCodec.Builder)BuilderCodec.abstractBuilder(ToolArg.class).addField( (, Codec.BOOLEAN), (shapeArg, o) -> shapeArg.required = o, (shapeArg) -> shapeArg.required)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/buildertool/config/args/ToolArgException.java

package com.hypixel.hytale.server.core.asset.type.buildertool.config.args;

import com.hypixel.hytale.server.core.Message;
import javax.annotation.Nonnull;

public class ToolArgException extends Exception {
   @Nonnull
   private final Message translationMessage;

   public ToolArgException(@Nonnull Message translationMessage) {
      super(translationMessage.toString());
      this.translationMessage = translationMessage;
   }

   public ToolArgException(@Nonnull Message translationMessage, Throwable cause) {
      super(translationMessage.toString(), cause);
      this.translationMessage = translationMessage;
   }

   @Nonnull
   public Message getTranslationMessage() {
      return this.translationMessage;
   }
}

com/hypixel/hytale/server/core/asset/type/camera/CameraEffect.java

package com.hypixel.hytale.server.core.asset.type.camera;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetCodecMapCodec;
import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.protocol.packets.camera.CameraShakeEffect;
import javax.annotation.Nonnull;

public abstract class CameraEffect implements JsonAssetWithMap<String, IndexedLookupTableAssetMap<String, CameraEffect>> {
   @Nonnull
   public static final AssetCodecMapCodec<String, CameraEffect> CODEC;
   @Nonnull
   public static final Codec<String> CHILD_ASSET_CODEC;
   @Nonnull
   public static final ValidatorCache<String> VALIDATOR_CACHE;
   private static AssetStore<String, CameraEffect, IndexedLookupTableAssetMap<String, CameraEffect>> ASSET_STORE;
   protected String id;
   protected AssetExtraInfo.Data data;

   public  {
   }

   
     AssetStore<String, CameraEffect, IndexedLookupTableAssetMap<String, CameraEffect>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, CameraEffect, IndexedLookupTableAssetMap<String, CameraEffect>>getAssetStore(CameraEffect.class);
      }

       ASSET_STORE;
   }

   
     IndexedLookupTableAssetMap<String, CameraEffect>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

    String  {
       .id;
   }

     CameraShakeEffect ;

     CameraShakeEffect ;

    {
      CODEC =  <String, CameraEffect>(Codec.STRING, (t, k) -> t.id = k, (t) -> t.id, (t, data) -> t.data = data, (t) -> t.data);
      CHILD_ASSET_CODEC =  (CameraEffect.class, CODEC);
      VALIDATOR_CACHE =  <String>( (CameraEffect::getAssetStore));
   }

         {
        {
      }

      
       CameraShakeEffect  {
           ();
      }

      
       CameraShakeEffect  {
           ();
      }

      
       String  {
          ;
      }
   }
}

com/hypixel/hytale/server/core/asset/type/entityeffect/EntityEffectPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.entityeffect;

import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateEntityEffects;
import com.hypixel.hytale.server.core.asset.packet.SimpleAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.entityeffect.config.EntityEffect;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class EntityEffectPacketGenerator extends SimpleAssetPacketGenerator<String, EntityEffect, IndexedLookupTableAssetMap<String, EntityEffect>> {
   public EntityEffectPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull IndexedLookupTableAssetMap<String, EntityEffect> assetMap, @Nonnull Map<String, EntityEffect> assets) {
      UpdateEntityEffects packet = new UpdateEntityEffects();
      packet.type = UpdateType.Init;
      packet.entityEffects = new Int2ObjectOpenHashMap(assets.size());

      for(Map.Entry<String, EntityEffect> entry : assets.entrySet()) {
         String key = (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.entityEffects.put(index, ((EntityEffect)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.entityEffects =  (loadedAssets.size());

      (Map.Entry<String, EntityEffect> entry : loadedAssets.entrySet()) {
            (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.entityEffects.put(index, ((EntityEffect)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.entityEffects =  (removed.size());

      (String key : removed) {
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.entityEffects.put(index, (Object));
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/entityeffect/config/AbilityEffects.java

package com.hypixel.hytale.server.core.asset.type.entityeffect.config;

import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.InteractionType;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import com.hypixel.hytale.server.core.modules.interaction.InteractionModule;
import java.util.EnumSet;
import java.util.Set;
import javax.annotation.Nonnull;

public class AbilityEffects implements NetworkSerializable<com.hypixel.hytale.protocol.AbilityEffects> {
   @Nonnull
   public static final BuilderCodec<AbilityEffects> CODEC;
   protected Set<InteractionType> disabled;

   public AbilityEffects(@Nonnull Set<InteractionType> disabled) {
      this.disabled = EnumSet.copyOf(disabled);
   }

   protected AbilityEffects() {
   }

   @Nonnull
   public com.hypixel.hytale.protocol.AbilityEffects toPacket() {
      com.hypixel.hytale.protocol.AbilityEffects packet = new com.hypixel.hytale.protocol.AbilityEffects();
      packet.disabled = this.disabled == null ? null : (InteractionType[])this.disabled.toArray((x$) ->  [x$]);
       packet;
   }

   
    String  {
        + String.valueOf(.disabled) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(AbilityEffects.class, AbilityEffects::).appendInherited( (, InteractionModule.INTERACTION_TYPE_SET_CODEC), (entityEffect, s) -> entityEffect.disabled = s, (entityEffect) -> entityEffect.disabled, (entityEffect, parent) -> entityEffect.disabled = parent.disabled).documentation().add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/entityeffect/config/ApplicationEffects.java

package com.hypixel.hytale.server.core.asset.type.entityeffect.config;

import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.Color;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import com.hypixel.hytale.server.core.asset.modifiers.MovementEffects;
import com.hypixel.hytale.server.core.asset.type.model.config.ModelParticle;
import com.hypixel.hytale.server.core.asset.type.modelvfx.config.ModelVFX;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
import com.hypixel.hytale.server.core.asset.type.soundevent.validator.SoundEventValidators;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.util.Arrays;
import javax.annotation.Nonnull;

public class ApplicationEffects implements NetworkSerializable<com.hypixel.hytale.protocol.ApplicationEffects> {
   @Nonnull
   public static final BuilderCodec<ApplicationEffects> CODEC;
   protected Color entityBottomTint;
   protected Color entityTopTint;
   protected String entityAnimationId;
   protected ModelParticle[] particles;
   protected ModelParticle[] firstPersonParticles;
   protected String screenEffect;
       ;
       ;
    String soundEventIdLocal;
        ;
    String soundEventIdWorld;
        ;
    String modelVFXId;
    MovementEffects movementEffects;
    AbilityEffects abilityEffects;
     mouseSensitivityAdjustmentTarget;
     mouseSensitivityAdjustmentDuration;

     {
   }

   
    com.hypixel.hytale.protocol.ApplicationEffects  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ApplicationEffects();
      packet.entityBottomTint = .entityBottomTint;
      packet.entityTopTint = .entityTopTint;
      packet.entityAnimationId = .entityAnimationId;
       (.particles !=  && .particles.length > ) {
         packet.particles =  .hypixel.hytale.protocol.ModelParticle[.particles.length];

         (   ; i < .particles.length; ++i) {
            packet.particles[i] = .particles[i].toPacket();
         }
      }

       (.firstPersonParticles !=  && .firstPersonParticles.length > ) {
         packet.firstPersonParticles =  .hypixel.hytale.protocol.ModelParticle[.firstPersonParticles.length];

         (   ; i < .firstPersonParticles.length; ++i) {
            packet.firstPersonParticles[i] = .firstPersonParticles[i].toPacket();
         }
      }

      packet.screenEffect = .screenEffect;
      packet.horizontalSpeedMultiplier = .horizontalSpeedMultiplier;
      packet.soundEventIndexLocal = .soundEventIndexLocal !=  ? .soundEventIndexLocal : .soundEventIndexWorld;
      packet.soundEventIndexWorld = .soundEventIndexWorld;
      packet.modelVFXId = .modelVFXId;
       (.movementEffects != ) {
         packet.movementEffects = .movementEffects.toPacket();
      }

       (.abilityEffects != ) {
         packet.abilityEffects = .abilityEffects.toPacket();
      }

      packet.mouseSensitivityAdjustmentDuration = .mouseSensitivityAdjustmentDuration;
      packet.mouseSensitivityAdjustmentTarget = .mouseSensitivityAdjustmentTarget;
       packet;
   }

      {
       .horizontalSpeedMultiplier;
   }

      {
       .knockbackMultiplier;
   }

      {
      IndexedLookupTableAssetMap<String, SoundEvent> soundEventAssetMap = SoundEvent.getAssetMap();
       (.soundEventIdLocal != ) {
         .soundEventIndexLocal = soundEventAssetMap.getIndex(.soundEventIdLocal);
      }

       (.soundEventIdWorld != ) {
         .soundEventIndexWorld = soundEventAssetMap.getIndex(.soundEventIdWorld);
      }

   }

   
    String  {
         String.valueOf(.entityBottomTint);
        + var10000 +  + String.valueOf(.entityTopTint) +  + .entityAnimationId +  + Arrays.toString(.particles) +  + Arrays.toString(.firstPersonParticles) +  + .screenEffect +  + .horizontalSpeedMultiplier +  + .soundEventIndexLocal +  + .soundEventIndexWorld +  + String.valueOf(.movementEffects) +  + String.valueOf(.abilityEffects) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ApplicationEffects.class, ApplicationEffects::).appendInherited( (, ProtocolCodecs.COLOR), (entityEffect, s) -> entityEffect.entityBottomTint = s, (entityEffect) -> entityEffect.entityBottomTint, (entityEffect, parent) -> entityEffect.entityBottomTint = parent.entityBottomTint).add()).appendInherited( (, ProtocolCodecs.COLOR), (entityEffect, s) -> entityEffect.entityTopTint = s, (entityEffect) -> entityEffect.entityTopTint, (entityEffect, parent) -> entityEffect.entityTopTint = parent.entityTopTint).add()).appendInherited( (, Codec.STRING), (entityEffect, s) -> entityEffect.entityAnimationId = s, (entityEffect) -> entityEffect.entityAnimationId, (entityEffect, parent) -> entityEffect.entityAnimationId = parent.entityAnimationId).add()).appendInherited( (, ModelParticle.ARRAY_CODEC), (entityEffect, s) -> entityEffect.particles = s, (entityEffect) -> entityEffect.particles, (entityEffect, parent) -> entityEffect.particles = parent.particles).add()).appendInherited( (, ModelParticle.ARRAY_CODEC), (entityEffect, s) -> entityEffect.firstPersonParticles = s, (entityEffect) -> entityEffect.firstPersonParticles, (entityEffect, parent) -> entityEffect.firstPersonParticles = parent.firstPersonParticles).add()).appendInherited( (, Codec.STRING), (entityEffect, s) -> entityEffect.screenEffect = s, (entityEffect) -> entityEffect.screenEffect, (entityEffect, parent) -> entityEffect.screenEffect = parent.screenEffect).addValidator(CommonAssetValidator.UI_SCREEN_EFFECT).add()).appendInherited( (, Codec.DOUBLE), (entityEffect, s) -> entityEffect.horizontalSpeedMultiplier = s.floatValue(), (entityEffect) -> ()entityEffect.horizontalSpeedMultiplier, (entityEffect, parent) -> entityEffect.horizontalSpeedMultiplier = parent.horizontalSpeedMultiplier).addValidator(Validators.greaterThanOrEqual()).add()).appendInherited( (, Codec.DOUBLE), (entityEffect, s) -> entityEffect.knockbackMultiplier = s.floatValue(), (entityEffect) -> ()entityEffect.knockbackMultiplier, (entityEffect, parent) -> entityEffect.knockbackMultiplier = parent.knockbackMultiplier).addValidator(Validators.greaterThanOrEqual()).add()).appendInherited( (, Codec.STRING), (entityEffect, s) -> entityEffect.soundEventIdLocal = s, (entityEffect) -> entityEffect.soundEventIdLocal, (entityEffect, parent) -> entityEffect.soundEventIdLocal = parent.soundEventIdLocal).documentation().addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, Codec.STRING), (entityEffect, s) -> entityEffect.soundEventIdWorld = s, (entityEffect) -> entityEffect.soundEventIdWorld, (entityEffect, parent) -> entityEffect.soundEventIdWorld = parent.soundEventIdWorld).documentation().addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.MONO).add()).afterDecode(ApplicationEffects::processConfig)).appendInherited( (, Codec.STRING), (entityEffect, s) -> entityEffect.modelVFXId = s, (entityEffect) -> entityEffect.modelVFXId, (entityEffect, parent) -> entityEffect.modelVFXId = parent.modelVFXId).addValidator(ModelVFX.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, MovementEffects.CODEC), (entityEffect, s) -> entityEffect.movementEffects = s, (entityEffect) -> entityEffect.movementEffects, (entityEffect, parent) -> entityEffect.movementEffects = parent.movementEffects).add()).appendInherited( (, AbilityEffects.CODEC), (entityEffect, s) -> entityEffect.abilityEffects = s, (entityEffect) -> entityEffect.abilityEffects, (entityEffect, parent) -> entityEffect.abilityEffects = parent.abilityEffects).documentation().add()).appendInherited( (, Codec.FLOAT), (interaction, doubles) -> interaction.mouseSensitivityAdjustmentTarget = doubles, (interaction) -> interaction.mouseSensitivityAdjustmentTarget, (interaction, parent) -> interaction.mouseSensitivityAdjustmentTarget = parent.mouseSensitivityAdjustmentTarget).documentation().addValidator(Validators.range(, )).add()).appendInherited( (, Codec.FLOAT), (interaction, doubles) -> interaction.mouseSensitivityAdjustmentDuration = doubles, (interaction) -> interaction.mouseSensitivityAdjustmentDuration, (interaction, parent) -> interaction.mouseSensitivityAdjustmentDuration = parent.mouseSensitivityAdjustmentDuration).documentation().add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/entityeffect/config/EntityEffect.java

package com.hypixel.hytale.server.core.asset.type.entityeffect.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.codec.codecs.map.Object2FloatMapCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.ValueType;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemArmor;
import com.hypixel.hytale.server.core.asset.type.model.config.ModelAsset;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
import com.hypixel.hytale.server.core.modules.entitystats.EntityStatsModule;
import com.hypixel.hytale.server.core.modules.entitystats.asset.EntityStatType;
import com.hypixel.hytale.server.core.modules.entitystats.modifier.StaticModifier;
import com.hypixel.hytale.server.core.modules.interaction.interaction.config.server.combat.DamageCalculator;
 com.hypixel.hytale.server.core.modules.interaction.interaction.config.server.combat.DamageEffects;
 it.unimi.dsi.fastutil.ints.Int2FloatMap;
 it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 it.unimi.dsi.fastutil.objects.Object2FloatMap;
 it.unimi.dsi.fastutil.objects.Object2FloatOpenHashMap;
 java.lang.ref.SoftReference;
 java.util.HashMap;
 java.util.Map;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;

    <String, IndexedLookupTableAssetMap<String, EntityEffect>>, NetworkSerializable<com.hypixel.hytale.protocol.EntityEffect> {
   
      AssetBuilderCodec<String, EntityEffect> CODEC;
      Codec<String> CHILD_ASSET_CODEC;
   
     AssetStore<String, EntityEffect, IndexedLookupTableAssetMap<String, EntityEffect>> STORE;
      ValidatorCache<String> VALIDATOR_CACHE;
    AssetExtraInfo.Data data;
    String id;
   
    String name;
   
    ApplicationEffects applicationEffects;
   
    String worldRemovalSoundEventId;
        ;
   
    String localRemovalSoundEventId;
        ;
   
    DamageCalculator damageCalculator;
     damageCalculatorCooldown;
   
    DamageEffects damageEffects;
   
    DamageEffects statModifierEffects;
   
    ModelOverride modelOverride;
   
    String modelChange;
   
    Object2FloatMap<String> unknownEntityStats;
   
    Int2FloatMap entityStats;
   
    ValueType valueType;
     duration;
   
    OverlapBehavior overlapBehavior;
   
    RemovalBehavior removalBehavior;
     infinite;
     debuff;
   
    String statusEffectIcon;
   
    String locale;
     invulnerable;
   
    Map<String, StaticModifier[]> rawStatModifiers;
   
    Int2ObjectMap<StaticModifier[]> statModifiers;
   
    Map<String, StaticModifier[]> damageResistanceValuesRaw;
   
    Map<DamageCause, StaticModifier[]> damageResistanceValues;
   
    SoftReference<com.hypixel.hytale.protocol.EntityEffect> cachedPacket;

   
     AssetStore<String, EntityEffect, IndexedLookupTableAssetMap<String, EntityEffect>>  {
       (STORE == ) {
         STORE = AssetRegistry.<String, EntityEffect, IndexedLookupTableAssetMap<String, EntityEffect>>getAssetStore(EntityEffect.class);
      }

       STORE;
   }

   
     IndexedLookupTableAssetMap<String, EntityEffect>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

     {
      .valueType = ValueType.Absolute;
      .duration = ;
      .overlapBehavior = OverlapBehavior.IGNORE;
      .removalBehavior = RemovalBehavior.COMPLETE;
      .invulnerable = ;
      .id = id;
   }

     {
      .valueType = ValueType.Absolute;
      .duration = ;
      .overlapBehavior = OverlapBehavior.IGNORE;
      .removalBehavior = RemovalBehavior.COMPLETE;
      .invulnerable = ;
   }

   
    String  {
       .name;
   }

   
    Int2ObjectMap<StaticModifier[]> getStatModifiers() {
       .statModifiers;
   }

    String  {
       .id;
   }

   
    ApplicationEffects  {
       .applicationEffects;
   }

   
    DamageCalculator  {
       .damageCalculator;
   }

      {
       .damageCalculatorCooldown;
   }

   
    DamageEffects  {
       .damageEffects;
   }

   
    DamageEffects  {
       .statModifierEffects;
   }

   
    ModelOverride  {
       .modelOverride;
   }

   
    String  {
       .modelChange;
   }

   
    Int2FloatMap  {
       .entityStats;
   }

      {
       .duration;
   }

   
    OverlapBehavior  {
       .overlapBehavior;
   }

      {
       .infinite;
   }

      {
       .debuff;
   }

   
    String  {
       .statusEffectIcon;
   }

   
    String  {
       .locale;
   }

   
    RemovalBehavior  {
       .removalBehavior;
   }

   
    ValueType  {
       .valueType;
   }

      {
       .invulnerable;
   }

   
    Map<DamageCause, StaticModifier[]> getDamageResistanceValues() {
       .damageResistanceValues;
   }

   
    com.hypixel.hytale.protocol.EntityEffect  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.EntityEffect).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.EntityEffect();
         packet.id = .id;
         packet.name = .name;
          (.applicationEffects != ) {
            packet.applicationEffects = .applicationEffects.toPacket();
         }

         packet.worldRemovalSoundEventIndex = .worldRemovalSoundEventIndex;
         packet.localRemovalSoundEventIndex = .localRemovalSoundEventIndex !=  ? .localRemovalSoundEventIndex : .worldRemovalSoundEventIndex;
          (.modelOverride != ) {
            packet.modelOverride = .modelOverride.toPacket();
         }

         packet.duration = .duration;
         packet.infinite = .infinite;
         packet.debuff = .debuff;
         packet.statusEffectIcon = .statusEffectIcon;
         com.hypixel.hytale.protocol.OverlapBehavior var10001;
          (.overlapBehavior) {
             EXTEND -> var10001 = com.hypixel.hytale.protocol.OverlapBehavior.Extend;
             OVERWRITE -> var10001 = com.hypixel.hytale.protocol.OverlapBehavior.Overwrite;
             IGNORE -> var10001 = com.hypixel.hytale.protocol.OverlapBehavior.Ignore;
             ->   ((String), (Throwable));
         }

         packet.overlapBehavior = var10001;
         packet.damageCalculatorCooldown = ().damageCalculatorCooldown;
         packet.statModifiers = .entityStats;
         packet.valueType = .valueType;
         .cachedPacket =  (packet);
          packet;
      }
   }

   
    String  {
         .id;
        + var10000 +  + .name +  + String.valueOf(.applicationEffects) +  + String.valueOf(.damageCalculator) +  + .damageCalculatorCooldown +  + String.valueOf(.damageEffects) +  + String.valueOf(.modelOverride) +  + .modelChange +  + String.valueOf(.unknownEntityStats) +  + String.valueOf(.entityStats) +  + String.valueOf(.valueType) +  + .duration +  + String.valueOf(.overlapBehavior) +  + .infinite +  + .debuff +  + .statusEffectIcon +  + .locale +  + String.valueOf(.removalBehavior) +  + .invulnerable +  + String.valueOf(.damageResistanceValues) + ;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(EntityEffect.class, EntityEffect::, Codec.STRING, (entityEffect, s) -> entityEffect.id = s, (entityEffect) -> entityEffect.id, (asset, data) -> asset.data = data, (asset) -> asset.data).appendInherited( (, Codec.STRING), (entityEffect, s) -> entityEffect.name = s, (entityEffect) -> entityEffect.name, (entityEffect, parent) -> entityEffect.name = parent.name).documentation().add()).appendInherited( (, ApplicationEffects.CODEC), (entityEffect, s) -> entityEffect.applicationEffects = s, (entityEffect) -> entityEffect.applicationEffects, (entityEffect, parent) -> entityEffect.applicationEffects = parent.applicationEffects).add()).appendInherited( (, Codec.STRING), (entityEffect, s) -> entityEffect.worldRemovalSoundEventId = s, (entityEffect) -> entityEffect.worldRemovalSoundEventId, (entityEffect, parent) -> entityEffect.worldRemovalSoundEventId = parent.worldRemovalSoundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, Codec.STRING), (entityEffect, s) -> entityEffect.localRemovalSoundEventId = s, (entityEffect) -> entityEffect.localRemovalSoundEventId, (entityEffect, parent) -> entityEffect.localRemovalSoundEventId = parent.localRemovalSoundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, DamageCalculator.CODEC), (entityEffect, s) -> entityEffect.damageCalculator = s, (entityEffect) -> entityEffect.damageCalculator, (entityEffect, parent) -> entityEffect.damageCalculator = parent.damageCalculator).add()).appendInherited( (, Codec.FLOAT), (entityEffect, s) -> entityEffect.damageCalculatorCooldown = s, (entityEffect) -> entityEffect.damageCalculatorCooldown, (entityEffect, parent) -> entityEffect.damageCalculatorCooldown = parent.damageCalculatorCooldown).addValidator(Validators.greaterThanOrEqual()).add()).appendInherited( (, DamageEffects.CODEC), (entityEffect, s) -> entityEffect.damageEffects = s, (entityEffect) -> entityEffect.damageEffects, (entityEffect, parent) -> entityEffect.damageEffects = parent.damageEffects).add()).appendInherited( (, DamageEffects.CODEC), (entityEffect, s) -> entityEffect.statModifierEffects = s, (entityEffect) -> entityEffect.statModifierEffects, (entityEffect, parent) -> entityEffect.statModifierEffects = parent.statModifierEffects).documentation().add()).appendInherited( (, ModelOverride.CODEC), (entityEffect, o) -> entityEffect.modelOverride = o, (entityEffect) -> entityEffect.modelOverride, (entityEffect, parent) -> entityEffect.modelOverride = parent.modelOverride).add()).appendInherited( (, Codec.STRING), (entityEffect, s) -> entityEffect.modelChange = s, (entityEffect) -> entityEffect.modelChange, (entityEffect, parent) -> entityEffect.modelChange = parent.modelChange).addValidator(ModelAsset.VALIDATOR_CACHE.getValidator()).documentation().add()).append( (,  ( (StaticModifier.CODEC, (x$) ->  [x$]), HashMap::)), (entityEffect, map) -> entityEffect.rawStatModifiers = map, (entityEffect) -> entityEffect.rawStatModifiers).addValidator(EntityStatType.VALIDATOR_CACHE.getMapKeyValidator().late()).add()).appendInherited( (,  (Codec.STRING, Object2FloatOpenHashMap::)), (entityEffect, o) -> entityEffect.unknownEntityStats = o, (entityEffect) -> entityEffect.unknownEntityStats, (entityEffect, parent) -> entityEffect.entityStats = parent.entityStats).addValidator(EntityStatType.VALIDATOR_CACHE.getMapKeyValidator()).documentation().add()).appendInherited( (,  (ValueType.class)), (entityEffect, valueType) -> entityEffect.valueType = valueType, (entityEffect) -> entityEffect.valueType, (entityEffect, parent) -> entityEffect.valueType = parent.valueType).documentation().addValidator(Validators.nonNull()).add()).appendInherited( (, Codec.FLOAT), (entityEffect, o) -> entityEffect.duration = o, (entityEffect) -> entityEffect.duration, (entityEffect, parent) -> entityEffect.duration = parent.duration).documentation().add()).appendInherited( (, OverlapBehavior.CODEC), (entityEffect, s) -> entityEffect.overlapBehavior = s, (entityEffect) -> entityEffect.overlapBehavior, (entityEffect, parent) -> entityEffect.overlapBehavior = parent.overlapBehavior).documentation().add()).appendInherited( (, Codec.BOOLEAN), (entityEffect, aBoolean) -> entityEffect.infinite = aBoolean, (entityEffect) -> entityEffect.infinite, (entityEffect, parent) -> entityEffect.infinite = parent.infinite).documentation().add()).appendInherited( (, Codec.BOOLEAN), (entityEffect, aBoolean) -> entityEffect.debuff = aBoolean, (entityEffect) -> entityEffect.debuff, (entityEffect, parent) -> entityEffect.debuff = parent.debuff).documentation().add()).appendInherited( (, Codec.STRING), (entityEffect, aString) -> entityEffect.locale = aString, (entityEffect) -> entityEffect.locale, (entityEffect, parent) -> entityEffect.locale = parent.locale).documentation().add()).appendInherited( (, Codec.STRING), (entityEffect, aString) -> entityEffect.statusEffectIcon = aString, (entityEffect) -> entityEffect.statusEffectIcon, (entityEffect, parent) -> entityEffect.statusEffectIcon = parent.statusEffectIcon).documentation().add()).appendInherited( (, RemovalBehavior.CODEC), (entityEffect, removalBehavior) -> entityEffect.removalBehavior = removalBehavior, (entityEffect) -> entityEffect.removalBehavior, (entityEffect, parent) -> entityEffect.removalBehavior = parent.removalBehavior).documentation().add()).appendInherited( (, Codec.BOOLEAN), (entityEffect, aBoolean) -> entityEffect.invulnerable = aBoolean, (entityEffect) -> entityEffect.invulnerable, (entityEffect, parent) -> entityEffect.invulnerable = parent.invulnerable).documentation().add()).appendInherited( (,  ( (StaticModifier.CODEC, (x$) ->  [x$]), HashMap::)), (entityEffect, map) -> entityEffect.damageResistanceValuesRaw = map, (entityEffect) -> entityEffect.damageResistanceValuesRaw, (entityEffect, parent) -> entityEffect.damageResistanceValuesRaw = parent.damageResistanceValuesRaw).addValidator(DamageCause.VALIDATOR_CACHE.getMapKeyValidator()).add()).afterDecode((entityEffect) -> {
         entityEffect.entityStats = EntityStatsModule.resolveEntityStats(entityEffect.unknownEntityStats);
         entityEffect.statModifiers = EntityStatsModule.resolveEntityStats(entityEffect.rawStatModifiers);
          (entityEffect.damageResistanceValuesRaw !=  && !entityEffect.damageResistanceValuesRaw.isEmpty()) {
            entityEffect.damageResistanceValues = ItemArmor.convertStringKeyToDamageCause(entityEffect.damageResistanceValuesRaw);
         }

          (entityEffect.worldRemovalSoundEventId != ) {
            entityEffect.worldRemovalSoundEventIndex = SoundEvent.getAssetMap().getIndex(entityEffect.worldRemovalSoundEventId);
         }

          (entityEffect.localRemovalSoundEventId != ) {
            entityEffect.localRemovalSoundEventIndex = SoundEvent.getAssetMap().getIndex(entityEffect.localRemovalSoundEventId);
         }

      })).build();
      CHILD_ASSET_CODEC =  (EntityEffect.class, CODEC);
      VALIDATOR_CACHE =  <String>( (EntityEffect::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/entityeffect/config/ModelOverride.java

package com.hypixel.hytale.server.core.asset.type.entityeffect.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.protocol.AnimationSet;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import com.hypixel.hytale.server.core.asset.type.model.config.ModelAsset;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ModelOverride implements NetworkSerializable<com.hypixel.hytale.protocol.ModelOverride> {
   @Nonnull
   public static final BuilderCodec<ModelOverride> CODEC;
   @Nullable
   protected String model;
   @Nullable
   protected String texture;
   @Nonnull
   protected Map<String, ModelAsset.AnimationSet> animationSetMap = Collections.emptyMap();

   protected ModelOverride() {
   }

   @Nonnull
   public com.hypixel.hytale.protocol.ModelOverride toPacket() {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ModelOverride();
      packet.model = .model;
      packet.texture = .texture;
       (!.animationSetMap.isEmpty()) {
         Map<String, AnimationSet> map =  <String, AnimationSet>(.animationSetMap.size());

         (Map.Entry<String, ModelAsset.AnimationSet> entry : .animationSetMap.entrySet()) {
            map.put((String)entry.getKey(), ((ModelAsset.AnimationSet)entry.getValue()).toPacket((String)entry.getKey()));
         }

         packet.animationSets = map;
      }

       packet;
   }

   
    String  {
         .model;
        + var10000 +  + .texture +  + String.valueOf(.animationSetMap) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ModelOverride.class, ModelOverride::).appendInherited( (, Codec.STRING, ), (modelOverride, s) -> modelOverride.model = s, (modelOverride) -> modelOverride.model, (modelOverride, parent) -> modelOverride.model = parent.model).addValidator(CommonAssetValidator.MODEL_CHARACTER).add()).appendInherited( (, Codec.STRING, ), (modelOverride, s) -> modelOverride.texture = s, (modelOverride) -> modelOverride.texture, (modelOverride, parent) -> modelOverride.texture = parent.texture).addValidator(CommonAssetValidator.TEXTURE_CHARACTER).add()).appendInherited( (,  (ModelAsset.AnimationSet.CODEC, HashMap::)), (modelOverride, m) -> modelOverride.animationSetMap = m, (modelOverride) -> modelOverride.animationSetMap, (modelOverride, parent) -> modelOverride.animationSetMap = parent.animationSetMap).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/entityeffect/config/OverlapBehavior.java

package com.hypixel.hytale.server.core.asset.type.entityeffect.config;

import com.hypixel.hytale.codec.codecs.EnumCodec;
import javax.annotation.Nonnull;

public enum OverlapBehavior {
   EXTEND,
   OVERWRITE,
   IGNORE;

   @Nonnull
   public static final EnumCodec<OverlapBehavior> CODEC = new EnumCodec<OverlapBehavior>(OverlapBehavior.class);

   private OverlapBehavior() {
   }
}

com/hypixel/hytale/server/core/asset/type/entityeffect/config/RemovalBehavior.java

package com.hypixel.hytale.server.core.asset.type.entityeffect.config;

import com.hypixel.hytale.codec.codecs.EnumCodec;
import javax.annotation.Nonnull;

public enum RemovalBehavior {
   COMPLETE,
   INFINITE,
   DURATION;

   @Nonnull
   public static final EnumCodec<RemovalBehavior> CODEC = new EnumCodec<RemovalBehavior>(RemovalBehavior.class);

   private RemovalBehavior() {
   }
}

com/hypixel/hytale/server/core/asset/type/environment/EnvironmentPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.environment;

import com.hypixel.hytale.assetstore.AssetUpdateQuery;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateEnvironments;
import com.hypixel.hytale.server.core.asset.packet.AssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.environment.config.Environment;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class EnvironmentPacketGenerator extends AssetPacketGenerator<String, Environment, IndexedLookupTableAssetMap<String, Environment>> {
   public EnvironmentPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull IndexedLookupTableAssetMap<String, Environment> assetMap, @Nonnull Map<String, Environment> assets) {
      Map<String, Environment> assetsFromMap = assetMap.getAssetMap();
      if (assets.size() != assetsFromMap.size()) {
         throw new UnsupportedOperationException("Environments can not handle partial init packets!!!");
      } else {
         UpdateEnvironments packet = new ();
         packet.type = UpdateType.Init;
         packet.environments =  ();

         (Map.Entry<String, Environment> entry : assets.entrySet()) {
               (String)entry.getKey();
               assetMap.getIndex(key);
             (index == -) {
                 ( + key);
            }

            packet.environments.put(index, ((Environment)entry.getValue()).toPacket());
         }

         packet.maxId = assetMap.getNextIndex();
         packet.rebuildMapGeometry = ;
          packet;
      }
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.environments =  ();

      (Map.Entry<String, Environment> entry : loadedAssets.entrySet()) {
            (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.environments.put(index, ((Environment)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
      packet.rebuildMapGeometry = query.getRebuildCache().isMapGeometry();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.environments =  ();

      (String key : removed) {
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.environments.put(index, (Object));
      }

      packet.rebuildMapGeometry = query.getRebuildCache().isMapGeometry();
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/environment/config/Environment.java

package com.hypixel.hytale.server.core.asset.type.environment.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.map.Int2ObjectMapCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIDefaultCollapsedState;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditor;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditorFeatures;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditorSectionStart;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.codec.validation.validator.MapKeyValidator;
import com.hypixel.hytale.common.map.IWeightedMap;
import com.hypixel.hytale.common.map.WeightedMap;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.protocol.Color;
import com.hypixel.hytale.protocol.WorldEnvironment;
import com.hypixel.hytale.server.core.asset.type.fluidfx.config.FluidFX;
import com.hypixel.hytale.server.core.asset.type.fluidfx.config.FluidParticle;
import com.hypixel.hytale.server.core.asset.type.weather.config.Weather;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
 com.hypixel.hytale.server.core.codec.WeightedMapCodec;
 com.hypixel.hytale.server.core.io.NetworkSerializable;
 it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 it.unimi.dsi.fastutil.ints.IntSet;
 java.lang.ref.SoftReference;
 java.time.temporal.ChronoUnit;
 java.util.Collections;
 java.util.HashMap;
 java.util.Map;
 java.util.logging.Level;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;

    <String, IndexedLookupTableAssetMap<String, Environment>>, NetworkSerializable<WorldEnvironment> {
       HOURS_PER_DAY;
       MAX_KEY_HOUR;
      Integer[] HOURS;
   
      IWeightedMap<WeatherForecast> DEFAULT_WEATHER_FORECAST;
      AssetBuilderCodec<String, Environment> CODEC;
      ValidatorCache<String> VALIDATOR_CACHE;
     AssetStore<String, Environment, IndexedLookupTableAssetMap<String, Environment>> ASSET_STORE;
         ;
      Environment UNKNOWN;
    AssetExtraInfo.Data data;
    String id;
    Color waterTint;
    Map<String, FluidParticle> fluidParticles = Collections.emptyMap();
    Int2ObjectMap<IWeightedMap<WeatherForecast>> weatherForecasts;
     spawnDensity;
       ;
    SoftReference<WorldEnvironment> cachedPacket;

     AssetStore<String, Environment, IndexedLookupTableAssetMap<String, Environment>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, Environment, IndexedLookupTableAssetMap<String, Environment>>getAssetStore(Environment.class);
      }

       ASSET_STORE;
   }

     IndexedLookupTableAssetMap<String, Environment>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

     {
      .id = id;
      .waterTint = waterTint;
      .fluidParticles = fluidParticles;
      .weatherForecasts = weatherForecasts;
      .spawnDensity = spawnDensity;
   }

     {
   }

    String  {
       .id;
   }

    Color  {
       .waterTint;
   }

    Map<String, FluidParticle>  {
       .fluidParticles;
   }

    Int2ObjectMap<IWeightedMap<WeatherForecast>>  {
       .weatherForecasts;
   }

    IWeightedMap<WeatherForecast>  {
       (hour >=  && hour <= MAX_KEY_HOUR) {
          .weatherForecasts ==  ? DEFAULT_WEATHER_FORECAST : (IWeightedMap).weatherForecasts.getOrDefault(hour, DEFAULT_WEATHER_FORECAST);
      }  {
           ( + MAX_KEY_HOUR);
      }
   }

      {
       .spawnDensity;
   }

      {
       .blockModificationAllowed;
   }

   
    WorldEnvironment  {
         .cachedPacket ==  ?  : (WorldEnvironment).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
             ();
         packet.id = .id;
          (.waterTint != ) {
            packet.waterTint = .waterTint;
         }

          (!.fluidParticles.isEmpty()) {
            Map<Integer, com.hypixel.hytale.protocol.FluidParticle> map =  (.fluidParticles.size());

            (Map.Entry<String, FluidParticle> entry : .fluidParticles.entrySet()) {
                  FluidFX.getAssetMap().getIndex((String)entry.getKey());
                (index != -) {
                  map.put(index, ((FluidParticle)entry.getValue()).toPacket());
               }
            }

            packet.fluidParticles = map;
         }

          (.data != ) {
               .data.getExpandedTagIndexes();
            packet.tagIndexes = tags.toIntArray();
         }

         .cachedPacket =  (packet);
          packet;
      }
   }

      {
       ( == o) {
          ;
      }   (o !=  && .getClass() == o.getClass()) {
            (Environment)o;
          .id.equals(that.id);
      }  {
          ;
      }
   }

      {
       .id.hashCode();
   }

   
    String  {
         .id;
        + var10000 +  + String.valueOf(.waterTint) +  + String.valueOf(.fluidParticles) +  + String.valueOf(.weatherForecasts) +  + .spawnDensity +  + String.valueOf(.cachedPacket) + ;
   }

   
     Environment  {
        () {
         {
            .id = unknownId;
            .waterTint =  ((), (), ());
            .spawnDensity = ;
         }
      };
   }

       {
         getAssetMap().getIndex(id);
       (environmentIndex == -) {
         HytaleLogger.getLogger().at(Level.WARNING).logVarargs(message, params);
         getAssetStore().loadAssets(, Collections.singletonList(getUnknownFor(id)));
            getAssetMap().getIndex(id);
          (index == -) {
              ( + id);
         }

         environmentIndex = index;
      }

       environmentIndex;
   }

    {
      HOURS_PER_DAY = ()ChronoUnit.DAYS.getDuration().toHours();
      MAX_KEY_HOUR = HOURS_PER_DAY - ;
      HOURS =  [HOURS_PER_DAY];
      WeightedMap.Builder<WeatherForecast> mapBuilder = WeightedMap.<WeatherForecast>builder(WeatherForecast.EMPTY_ARRAY);
      mapBuilder.put( (Weather.UNKNOWN.getId(), ), );
      DEFAULT_WEATHER_FORECAST = mapBuilder.build();

      (   ; i < HOURS_PER_DAY; ++i) {
         HOURS[i] = i;
      }

      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(Environment.class, Environment::, Codec.STRING, (environment, s) -> environment.id = s, (environment) -> environment.id, (asset, data) -> asset.data = data, (asset) -> asset.data).metadata( ( .EditorFeature[]{UIEditorFeatures.EditorFeature.WEATHER_DAYTIME_BAR}))).appendInherited( (, ProtocolCodecs.COLOR), (environment, s) -> environment.waterTint = s, (environment) -> environment.waterTint, (environment, parent) -> environment.waterTint = parent.waterTint).add()).appendInherited( (,  (FluidParticle.CODEC, HashMap::)), (environment, s) -> environment.fluidParticles = s, (environment) -> environment.fluidParticles, (environment, parent) -> environment.fluidParticles = parent.fluidParticles).addValidator(FluidFX.VALIDATOR_CACHE.getMapKeyValidator()).add()).appendInherited( (, Codec.DOUBLE), (environment, d) -> environment.spawnDensity = d, (environment) -> environment.spawnDensity, (environment, parent) -> environment.spawnDensity = parent.spawnDensity).add()).appendInherited( (, Codec.BOOLEAN), (environment, b) -> environment.blockModificationAllowed = b, (environment) -> environment.blockModificationAllowed, (environment, parent) -> environment.blockModificationAllowed = parent.blockModificationAllowed).add()).appendInherited( (,  ( (WeatherForecast.CODEC, WeatherForecast.EMPTY_ARRAY), Int2ObjectOpenHashMap::), ), (environment, l) -> environment.weatherForecasts = l, (environment) -> environment.weatherForecasts, (environment, parent) -> environment.weatherForecasts = parent.weatherForecasts).addValidator(Validators.nonNull()).addValidator( (Validators.range(, MAX_KEY_HOUR))).addValidator(Validators.requiredMapKeysValidator(HOURS)).metadata( (UIEditor.WEIGHTED_TIMELINE)).metadata( ()).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).build();
      VALIDATOR_CACHE =  <String>( (Environment::getAssetStore));
      UNKNOWN = getUnknownFor();
   }
}

com/hypixel/hytale/server/core/asset/type/environment/config/WeatherForecast.java

package com.hypixel.hytale.server.core.asset.type.environment.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.common.map.IWeightedElement;
import com.hypixel.hytale.server.core.asset.type.weather.config.Weather;
import javax.annotation.Nonnull;

public class WeatherForecast implements IWeightedElement {
   public static final BuilderCodec<WeatherForecast> CODEC;
   public static final WeatherForecast[] EMPTY_ARRAY;
   protected String weatherId;
   protected transient int weatherIndex;
   protected double weight;

   public WeatherForecast(String weatherId, double weight) {
      this.weatherId = weatherId;
      this.weight = weight;
   }

   protected WeatherForecast() {
   }

   public String getWeatherId() {
      return this.weatherId;
   }

   public int getWeatherIndex {
       .weatherIndex;
   }

      {
      .weatherIndex = Weather.getAssetMap().getIndex(.weatherId);
   }

   
    String  {
        + .weatherId +  + .weatherIndex +  + .weight + ;
   }

      {
       .weight;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(WeatherForecast.class, WeatherForecast::).append( (, Codec.STRING), (weatherForecast, s) -> weatherForecast.weatherId = s, (weatherForecast) -> weatherForecast.weatherId).addValidator(Validators.nonNull()).addValidator(Weather.VALIDATOR_CACHE.getValidator()).add()).addField( (, Codec.DOUBLE, ), (spawn, s) -> spawn.weight = s, (spawn) -> spawn.weight)).afterDecode(WeatherForecast::processConfig)).build();
      EMPTY_ARRAY =  [];
   }
}

com/hypixel/hytale/server/core/asset/type/equalizereffect/EqualizerEffectPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.equalizereffect;

import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateEqualizerEffects;
import com.hypixel.hytale.server.core.asset.packet.SimpleAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.equalizereffect.config.EqualizerEffect;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class EqualizerEffectPacketGenerator extends SimpleAssetPacketGenerator<String, EqualizerEffect, IndexedLookupTableAssetMap<String, EqualizerEffect>> {
   public EqualizerEffectPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull IndexedLookupTableAssetMap<String, EqualizerEffect> assetMap, @Nonnull Map<String, EqualizerEffect> assets) {
      UpdateEqualizerEffects packet = new UpdateEqualizerEffects();
      packet.type = UpdateType.Init;
      packet.effects = new Int2ObjectOpenHashMap(assets.size());

      for(Map.Entry<String, EqualizerEffect> entry : assets.entrySet()) {
         String key = (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.effects.put(index, ((EqualizerEffect)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.effects =  (loadedAssets.size());

      (Map.Entry<String, EqualizerEffect> entry : loadedAssets.entrySet()) {
            (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.effects.put(index, ((EqualizerEffect)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.effects =  (removed.size());

      (String key : removed) {
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.effects.put(index, (Object));
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/equalizereffect/config/EqualizerEffect.java

package com.hypixel.hytale.server.core.asset.type.equalizereffect.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditor;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditorPreview;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.common.util.AudioUtil;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.lang.ref.SoftReference;
import javax.annotation.Nonnull;

public class EqualizerEffect implements JsonAssetWithMap<String, IndexedLookupTableAssetMap<String, EqualizerEffect>>, NetworkSerializable<com.hypixel.hytale.protocol.EqualizerEffect> {
   public static final int EMPTY_ID = 0;
   public static final String EMPTY = "EMPTY";
          ();
         -;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
      AssetBuilderCodec<String, EqualizerEffect> CODEC;
      ValidatorCache<String> VALIDATOR_CACHE;
     AssetStore<String, EqualizerEffect, IndexedLookupTableAssetMap<String, EqualizerEffect>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
       ;
       ;
       ;
       ;
       ;
       ;
       ;
       ;
       ;
       ;
    SoftReference<com.hypixel.hytale.protocol.EqualizerEffect> cachedPacket;

     AssetStore<String, EqualizerEffect, IndexedLookupTableAssetMap<String, EqualizerEffect>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, EqualizerEffect, IndexedLookupTableAssetMap<String, EqualizerEffect>>getAssetStore(EqualizerEffect.class);
      }

       ASSET_STORE;
   }

     IndexedLookupTableAssetMap<String, EqualizerEffect>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

     {
      .id = id;
   }

     {
   }

    String  {
       .id;
   }

      {
       .lowGain;
   }

      {
       .lowCutOff;
   }

      {
       .lowMidGain;
   }

      {
       .lowMidCenter;
   }

      {
       .lowMidWidth;
   }

      {
       .highMidGain;
   }

      {
       .highMidCenter;
   }

      {
       .highMidWidth;
   }

      {
       .highGain;
   }

      {
       .highCutOff;
   }

   
    String  {
        + .id +  + .lowGain +  + .lowCutOff +  + .lowMidGain +  + .lowMidCenter +  + .lowMidWidth +  + .highMidGain +  + .highMidCenter +  + .highMidWidth +  + .highGain +  + .highCutOff + ;
   }

   
    com.hypixel.hytale.protocol.EqualizerEffect  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.EqualizerEffect).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.EqualizerEffect();
         packet.id = .id;
         packet.lowGain = .lowGain;
         packet.lowCutOff = .lowCutOff;
         packet.lowMidGain = .lowMidGain;
         packet.lowMidCenter = .lowMidCenter;
         packet.lowMidWidth = .lowMidWidth;
         packet.highMidGain = .highMidGain;
         packet.highMidCenter = .highMidCenter;
         packet.highMidWidth = .highMidWidth;
         packet.highGain = .highGain;
         packet.highCutOff = .highCutOff;
         .cachedPacket =  (packet);
          packet;
      }
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(EqualizerEffect.class, EqualizerEffect::, Codec.STRING, (t, k) -> t.id = k, (t) -> t.id, (asset, data) -> asset.data = data, (asset) -> asset.data).documentation()).metadata( (UIEditorPreview.PreviewType.EQUALIZER_EFFECT))).appendInherited( (, Codec.FLOAT), (eq, f) -> eq.lowGain = AudioUtil.decibelsToLinearGain(f), (eq) -> AudioUtil.linearGainToDecibels(eq.lowGain), (eq, parent) -> eq.lowGain = parent.lowGain).metadata( ( .FormattedNumber((Double), , (Integer)))).addValidator(Validators.range(-, )).documentation().add()).appendInherited( (, Codec.FLOAT), (eq, f) -> eq.lowCutOff = f, (eq) -> eq.lowCutOff, (eq, parent) -> eq.lowCutOff = parent.lowCutOff).addValidator(Validators.range(, )).documentation().add()).appendInherited( (, Codec.FLOAT), (eq, f) -> eq.lowMidGain = AudioUtil.decibelsToLinearGain(f), (eq) -> AudioUtil.linearGainToDecibels(eq.lowMidGain), (eq, parent) -> eq.lowMidGain = parent.lowMidGain).metadata( ( .FormattedNumber((Double), , (Integer)))).addValidator(Validators.range(-, )).documentation().add()).appendInherited( (, Codec.FLOAT), (eq, f) -> eq.lowMidCenter = f, (eq) -> eq.lowMidCenter, (eq, parent) -> eq.lowMidCenter = parent.lowMidCenter).addValidator(Validators.range(, )).documentation().add()).appendInherited( (, Codec.FLOAT), (eq, f) -> eq.lowMidWidth = f, (eq) -> eq.lowMidWidth, (eq, parent) -> eq.lowMidWidth = parent.lowMidWidth).addValidator(Validators.range(, )).documentation().add()).appendInherited( (, Codec.FLOAT), (eq, f) -> eq.highMidGain = AudioUtil.decibelsToLinearGain(f), (eq) -> AudioUtil.linearGainToDecibels(eq.highMidGain), (eq, parent) -> eq.highMidGain = parent.highMidGain).metadata( ( .FormattedNumber((Double), , (Integer)))).addValidator(Validators.range(-, )).documentation().add()).appendInherited( (, Codec.FLOAT), (eq, f) -> eq.highMidCenter = f, (eq) -> eq.highMidCenter, (eq, parent) -> eq.highMidCenter = parent.highMidCenter).addValidator(Validators.range(, )).documentation().add()).appendInherited( (, Codec.FLOAT), (eq, f) -> eq.highMidWidth = f, (eq) -> eq.highMidWidth, (eq, parent) -> eq.highMidWidth = parent.highMidWidth).addValidator(Validators.range(, )).documentation().add()).appendInherited( (, Codec.FLOAT), (eq, f) -> eq.highGain = AudioUtil.decibelsToLinearGain(f), (eq) -> AudioUtil.linearGainToDecibels(eq.highGain), (eq, parent) -> eq.highGain = parent.highGain).metadata( ( .FormattedNumber((Double), , (Integer)))).addValidator(Validators.range(-, )).documentation().add()).appendInherited( (, Codec.FLOAT), (eq, f) -> eq.highCutOff = f, (eq) -> eq.highCutOff, (eq, parent) -> eq.highCutOff = parent.highCutOff).addValidator(Validators.range(, )).documentation().add()).build();
      VALIDATOR_CACHE =  <String>( (EqualizerEffect::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/fluid/DefaultFluidTicker.java

package com.hypixel.hytale.server.core.asset.type.fluid;

import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.common.util.MapUtil;
import com.hypixel.hytale.math.util.ChunkUtil;
import com.hypixel.hytale.math.vector.Vector2i;
import com.hypixel.hytale.protocol.SoundCategory;
import com.hypixel.hytale.server.core.asset.type.blocktick.BlockTickStrategy;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
import com.hypixel.hytale.server.core.universe.world.SoundUtil;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
import com.hypixel.hytale.server.core.universe.world.chunk.section.FluidSection;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class DefaultFluidTicker extends FluidTicker {
   public static final BuilderCodec<DefaultFluidTicker> CODEC;
         ;
      DefaultFluidTicker INSTANCE;
    String spreadFluid;
     spreadFluidId;
    Map<String, FluidCollisionConfig> rawCollisionMap = Collections.emptyMap();
   
     Int2ObjectMap<FluidCollisionConfig> collisionMap = ;

     {
   }

   
    BlockTickStrategy  {
       (worldY == ) {
          BlockTickStrategy.SLEEP;
      }  {
         BlockTypeAssetMap<String, BlockType> blockMap = BlockType.getAssetMap();
         IndexedLookupTableAssetMap<String, Fluid> fluidMap = Fluid.getAssetMap();
            fluidSection.getY() != ChunkUtil.chunkCoordinate(worldY - );
            isDifferentSectionBelow ? accessor.getFluidSectionByBlock(worldX, worldY - , worldZ) : fluidSection;
            isDifferentSectionBelow ? accessor.getBlockSectionByBlock(worldX, worldY - , worldZ) : blockSection;
          (fluidSectionBelow !=  && blockSectionBelow != ) {
               fluidSectionBelow.getFluidId(worldX, worldY - , worldZ);
               fluidMap.getAsset(fluidBelowId);
               fluidSectionBelow.getFluidLevel(worldX, worldY - , worldZ);
               .getSpreadFluidId(fluidId);
               blockSectionBelow.get(worldX, worldY - , worldZ);
               blockMap.getAsset(blockIdBelow);
             (isSolid(blockBelow) || fluidBelowId !=  && fluidBelowId != spreadFluidId && fluidBelowId == fluidId) {
                (fluidBelowId ==  || fluidBelowId != spreadFluidId) {
                   (fluidLevel ==  && fluid.getMaxFluidLevel() != ) {
                      BlockTickStrategy.SLEEP;
                  }

                     .getSpreadOffsets(blockMap, accessor, fluidSection, blockSection, worldX, worldY, worldZ, ORTO_OFFSETS, fluidId, );
                   (offsets == ) {
                      BlockTickStrategy.WAIT_FOR_ADJACENT_CHUNK_LOAD;
                  }

                     fluidLevel - ;
                   (spreadFluidId != fluidId) {
                     childFillLevel = ((Fluid)Fluid.getAssetMap().getAsset(spreadFluidId)).getMaxFluidLevel() - ;
                  }

                     blockMap.getAsset(blockSection.get(worldX, worldY, worldZ));
                     blockSection.getRotationIndex(worldX, worldY, worldZ);
                     blockSection.getFiller(worldX, worldY, worldZ);

                  (   ; i < ORTO_OFFSETS.length; ++i) {
                      (offsets ==  || (offsets &  << i) != ) {
                           ORTO_OFFSETS[i];
                           offset.x;
                           offset.y;
                           worldX + x;
                           worldZ + z;
                         (!blocksFluidFrom(sourceBlock, sourceRotationIndex, -x, -z, sourceFiller)) {
                              !ChunkUtil.isSameChunkSection(worldX, worldY, worldZ, blockX, worldY, blockZ);
                              isDifferentSection ? accessor.getFluidSectionByBlock(blockX, worldY, blockZ) : fluidSection;
                              isDifferentSection ? accessor.getBlockSectionByBlock(blockX, worldY, blockZ) : blockSection;
                            (otherFluidSection ==  || otherBlockSection == ) {
                               BlockTickStrategy.WAIT_FOR_ADJACENT_CHUNK_LOAD;
                           }

                              blockMap.getAsset(otherBlockSection.get(blockX, worldY, blockZ));
                              otherBlockSection.getRotationIndex(blockX, worldY, blockZ);
                              otherBlockSection.getFiller(blockX, worldY, blockZ);
                            (!blocksFluidFrom(block, rotationIndex, x, z, destFiller)) {
                                 otherFluidSection.getFluidId(blockX, worldY, blockZ);
                               (otherFluidId !=  && otherFluidId != spreadFluidId) {
                                    (FluidCollisionConfig).getCollisionMap().get(otherFluidId);
                                  (config ==  || executeCollision(world, accessor, otherFluidSection, otherBlockSection, config, blockX, worldY, blockZ)) {
                                    ;
                                 }
                              }

                                 otherFluidSection.getFluidLevel(blockX, worldY, blockZ);
                               (otherFluidId != spreadFluidId || fillLevel < childFillLevel) {
                                  (childFillLevel == ) {
                                    otherFluidSection.setFluid(blockX, worldY, blockZ, , ());
                                 }  {
                                    otherFluidSection.setFluid(blockX, worldY, blockZ, spreadFluidId, ()childFillLevel);
                                    otherBlockSection.setTicking(blockX, worldY, blockZ, );
                                 }
                              }
                           }
                        }
                     }
                  }
               }

                BlockTickStrategy.SLEEP;
            }  {
                  (FluidCollisionConfig).getCollisionMap().get(fluidBelowId);
                (config !=  && !executeCollision(world, accessor, fluidSectionBelow, blockSectionBelow, config, worldX, worldY - , worldZ)) {
                   BlockTickStrategy.CONTINUE;
               }  {
                   (fluidBelowId ==  && !isSolid(blockBelow) || fluidBelowId == spreadFluidId && fluidLevelBelow < fluidBelow.getMaxFluidLevel()) {
                        .getSpreadFluidId(fluidId);
                        fluidMap.getAsset(spreadId);
                        fluidSectionBelow.setFluid(worldX, worldY - , worldZ, spreadId, ()spreadFluid.getMaxFluidLevel());
                      (changed) {
                        blockSectionBelow.setTicking(worldX, worldY - , worldZ, );
                     }
                  }

                   BlockTickStrategy.SLEEP;
               }
            }
         }  {
             BlockTickStrategy.SLEEP;
         }
      }
   }

       {
         config.getBlockToPlaceIndex();
       (blockToPlace != -) {
         accessor.setBlock(blockX, blockY, blockZ, blockToPlace);
         setTickingSurrounding(accessor, blockSection, blockX, blockY, blockZ);
         fluidSection.setFluid(blockX, blockY, blockZ, , ());
      }

         config.getSoundEventIndex();
       (soundEvent != -) {
         world.execute(() -> SoundUtil.playSoundEvent3d(soundEvent, SoundCategory.SFX, ()blockX, ()blockY, ()blockZ, world.getEntityStore().getStore()));
      }

       !config.placeFluid;
   }

      {
       .isSelfFluid(selfFluidId, otherFluidId) || otherFluidId == .getSpreadFluidId(selfFluidId);
   }

      {
       (.spreadFluidId == ) {
          (.spreadFluid != ) {
            .spreadFluidId = Fluid.getAssetMap().getIndex(.spreadFluid);
         }  {
            .spreadFluidId = -;
         }
      }

       .spreadFluidId == - ? fluidId : .spreadFluidId;
   }

   
    Int2ObjectMap<FluidCollisionConfig>  {
       (.collisionMap == ) {
         Int2ObjectOpenHashMap<FluidCollisionConfig> collisionMap =  <FluidCollisionConfig>(.rawCollisionMap.size());

         (Map.Entry<String, FluidCollisionConfig> entry : .rawCollisionMap.entrySet()) {
               Fluid.getAssetMap().getIndex((String)entry.getKey());
             (index != -) {
               collisionMap.put(index, (FluidCollisionConfig)entry.getValue());
            }
         }

         .collisionMap = collisionMap;
      }

       .collisionMap;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(DefaultFluidTicker.class, DefaultFluidTicker::, BASE_CODEC).appendInherited( (, Codec.STRING), (ticker, o) -> ticker.spreadFluid = o, (ticker) -> ticker.spreadFluid, (ticker, parent) -> ticker.spreadFluid = parent.spreadFluid).addValidator(Fluid.VALIDATOR_CACHE.getValidator().late()).add()).appendInherited( (,  (DefaultFluidTicker.FluidCollisionConfig.CODEC, HashMap::)), (ticker, o) -> ticker.rawCollisionMap = MapUtil.<String, FluidCollisionConfig>combineUnmodifiable(ticker.rawCollisionMap, o), (ticker) -> ticker.rawCollisionMap, (ticker, parent) -> ticker.rawCollisionMap = parent.rawCollisionMap).documentation().add()).build();
      INSTANCE =  ();
   }

       {
         BuilderCodec<FluidCollisionConfig> CODEC;
       String blockToPlace;
          -;
          ;
       String soundEvent;
          -;

        {
      }

         {
          (.blockToPlaceIndex == - && .blockToPlace != ) {
            .blockToPlaceIndex = BlockType.getBlockIdOrUnknown(.blockToPlace, , .blockToPlace);
         }

          .blockToPlaceIndex;
      }

         {
          (.soundEventIndex == - && .soundEvent != ) {
            .soundEventIndex = SoundEvent.getAssetMap().getIndex(.soundEvent);
         }

          .soundEventIndex;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(FluidCollisionConfig.class, FluidCollisionConfig::).appendInherited( (, Codec.STRING), (o, v) -> o.blockToPlace = v, (o) -> o.blockToPlace, (o, p) -> o.blockToPlace = p.blockToPlace).documentation().add()).appendInherited( (, Codec.STRING), (o, v) -> o.soundEvent = v, (o) -> o.soundEvent, (o, p) -> o.soundEvent = p.soundEvent).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, Codec.BOOLEAN), (o, v) -> o.placeFluid = v, (o) -> o.placeFluid, (o, p) -> o.placeFluid = p.placeFluid).documentation().add()).build();
      }
   }
}

com/hypixel/hytale/server/core/asset/type/fluid/FiniteFluidTicker.java

package com.hypixel.hytale.server.core.asset.type.fluid;

import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.math.util.ChunkUtil;
import com.hypixel.hytale.math.util.HashUtil;
import com.hypixel.hytale.math.vector.Vector2i;
import com.hypixel.hytale.server.core.asset.type.blocktick.BlockTickStrategy;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
import com.hypixel.hytale.server.core.universe.world.chunk.section.FluidSection;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class FiniteFluidTicker extends FluidTicker {
   @Nonnull
   public static BuilderCodec<FiniteFluidTicker> CODEC;
   @Nonnull
   private static final Vector2i[] DIAG_OFFSETS;
   private static final int MAX_DROP_DISTANCE = 2;
   @Nonnull
      List<List<Vector2i[]>> OFFSETS_LISTS;
         ;

     {
   }

   
    FluidTicker.AliveStatus  {
       FluidTicker.AliveStatus.ALIVE;
   }

   
    BlockTickStrategy  {
       (worldY == ) {
          BlockTickStrategy.SLEEP;
      }  {
            fluidSection.getY() != ChunkUtil.chunkCoordinate(worldY - );
            isDifferentSectionBelow ? accessor.getFluidSectionByBlock(worldX, worldY - , worldZ) : fluidSection;
            isDifferentSectionBelow ? accessor.getBlockSectionByBlock(worldX, worldY - , worldZ) : blockSection;
          (belowFluidSection !=  && belowBlockSection != ) {
               belowFluidSection.getFluidId(worldX, worldY - , worldZ);
               belowFluidSection.getFluidLevel(worldX, worldY - , worldZ);
             .spreadDownwards(accessor, fluidSection, blockSection, belowFluidSection, belowBlockSection, worldX, worldY, worldZ, fluid, fluidId, fluidLevel, bottomFluidId, bottomFluidLevel) ? BlockTickStrategy.CONTINUE : .spreadSideways(tick, accessor, fluidSection, blockSection, worldX, worldY, worldZ, fluid, fluidId, fluidLevel);
         }  {
             BlockTickStrategy.SLEEP;
         }
      }
   }

      {
       (fluidId != bottomFluidId && bottomFluidId != ) {
          ;
      }   (isSolid((BlockType)BlockType.getAssetMap().getAsset(belowBlockSection.get(worldX, worldY - , worldZ)))) {
          ;
      }  {
            .getTopY(accessor, fluidSection, worldX, worldY, worldZ, fluid, fluidId);
            ChunkUtil.chunkCoordinate(topY) != fluidSection.getY();
            isTopDifferent ? accessor.getFluidSectionByBlock(worldX, topY, worldZ) : fluidSection;
            isTopDifferent ? accessor.getBlockSectionByBlock(worldX, topY, worldZ) : blockSection;
            topFluidSection.getFluidLevel(worldX, topY, worldZ);
            Math.min(topBlockLevel, fluid.getMaxFluidLevel() - bottomFluidLevel);
          (transferLevel == ) {
             ;
         }  {
               bottomFluidId ==  ? transferLevel : bottomFluidLevel + transferLevel;
            belowFluidSection.setFluid(worldX, worldY - , worldZ, fluidId, ()newBottomLevel);
            setTickingSurrounding(accessor, belowBlockSection, worldX, worldY - , worldZ);
             updated;
             (transferLevel == topBlockLevel) {
               updated = topFluidSection.setFluid(worldX, topY, worldZ, , ());
            }  {
               updated = topFluidSection.setFluid(worldX, topY, worldZ, fluidId, ()(topBlockLevel - transferLevel));
            }

            setTickingSurrounding(accessor, topBlockSection, worldX, topY, worldZ);
             updated;
         }
      }
   }

   
    BlockTickStrategy  {
       (fluidLevel == ) {
          BlockTickStrategy.SLEEP;
      }  {
            fluidLevel;
         BlockTypeAssetMap<String, BlockType> blockTypeMap = BlockType.getAssetMap();
            HashUtil.rehash(()worldX, ()worldY, ()worldZ, );
            OFFSETS_LISTS.size() + ()((hash + tick) % ()OFFSETS_LISTS.size());
         List<Vector2i[]> offsetsList = (List)OFFSETS_LISTS.get(index % OFFSETS_LISTS.size());

         (   ; idx < offsetsList.size(); ++idx) {
            Vector2i[] offsetArray = (Vector2i[])offsetsList.get(idx);
               .getSpreadOffsets(blockTypeMap, accessor, fluidSection, blockSection, worldX, worldY, worldZ, offsetArray, fluidId, );
               offsets != ;

            (   ; i < offsetArray.length && newLevel != ; ++i) {
                (!spreadDownhill || (offsets &  << i) != ) {
                     offsetArray[i];
                     .spreadToOffset(accessor, fluidSection, blockSection, offset, worldX, worldY, worldZ, fluid, fluidId, fluidLevel);
                   (spreadOutcome != ) {
                      (spreadOutcome.ordinal()) {
                          -> --newLevel;
                          -> {
                            BlockTickStrategy.WAIT_FOR_ADJACENT_CHUNK_LOAD;
                        }
                     }
                  }
               }
            }

             (spreadDownhill) {
               ;
            }
         }

          (newLevel == fluidLevel) {
             BlockTickStrategy.SLEEP;
         }  {
             !.drainFromTopBlock(accessor, fluidSection, blockSection, worldX, worldY, worldZ, fluid, fluidId, ()(fluidLevel - newLevel)) ? BlockTickStrategy.WAIT_FOR_ADJACENT_CHUNK_LOAD : BlockTickStrategy.CONTINUE;
         }
      }
   }

   
    SpreadOutcome  {
       (!isOffsetConnected(accessor, blockSection, offset, worldX, worldY, worldZ)) {
          ;
      }  {
            offset.getX();
            offset.getY();
            worldX + x;
            worldZ + z;
            !ChunkUtil.isSameChunkSection(worldX, worldY, worldZ, blockX, worldY, blockZ);
            isDifferentSection ? accessor.getFluidSectionByBlock(blockX, worldY, blockZ) : fluidSection;
            isDifferentSection ? accessor.getBlockSectionByBlock(blockX, worldY, blockZ) : blockSection;
          (otherFluidSection !=  && otherBlockSection != ) {
               otherBlockSection.get(blockX, worldY, blockZ);
               (BlockType)BlockType.getAssetMap().getAsset(blockId);
             (isSolid(blockType)) {
                ;
            }  {
                  otherFluidSection.getFluidId(blockX, worldY, blockZ);
                  otherFluidSection.getFluidLevel(blockX, worldY, blockZ);
                  ;
                (adjacentFluidId ==  || adjacentFluidId == fluidId && adjacentFluidLevel < fluidLevel - ) {
                   (adjacentFluidId == fluidId) {
                     newAdjacentFillLevel = adjacentFluidLevel + ;
                  }

                   (otherFluidSection.setFluid(blockX, worldY, blockZ, fluidId, ()newAdjacentFillLevel)) {
                     setTickingSurrounding(accessor, otherBlockSection, blockX, worldY, blockZ);
                      FiniteFluidTicker.SpreadOutcome.SUCCESS;
                  }
               }

                ;
            }
         }  {
             FiniteFluidTicker.SpreadOutcome.UNLOADED_CHUNK;
         }
      }
   }

      {
         .getTopY(accessor, fluidSection, worldX, worldY, worldZ, fluid, fluidId);
         fluidSection.getY() != ChunkUtil.chunkCoordinate(topY);
         isDifferentSection ? accessor.getFluidSectionByBlock(worldX, topY, worldZ) : fluidSection;
         isDifferentSection ? accessor.getBlockSectionByBlock(worldX, topY, worldZ) : blockSection;
       (topFluidSection !=  && topBlockSection != ) {
            topFluidSection.getFluidLevel(worldX, topY, worldZ);
          (topBlockFillLevels > drainLevels) {
            setTickingSurrounding(accessor, topBlockSection, worldX, topY, worldZ);
             topFluidSection.setFluid(worldX, topY, worldZ, fluidId, ()(topBlockFillLevels - drainLevels));
         }   (topBlockFillLevels == drainLevels) {
            setTickingSurrounding(accessor, topBlockSection, worldX, topY, worldZ);
             topFluidSection.setFluid(worldX, topY, worldZ, , ());
         }  {
               topY;
               ;
               topFluidSection;

            (   topBlockSection; drainLevels > ; --nextY) {
                  ChunkUtil.chunkCoordinate(nextY) != nextFluidSection.getY();
                (isDifferent) {
                  nextFluidSection = accessor.getFluidSectionByBlock(worldX, nextY, worldZ);
                  nextBlockSection = accessor.getBlockSectionByBlock(worldX, nextY, worldZ);
                   (nextFluidSection ==  || nextBlockSection == ) {
                      ;
                  }
               }

                  nextFluidSection.getFluidLevel(worldX, nextY, worldZ);
                  Math.min(nextFluidLevel, drainLevels);
                (transferLevels == nextFluidLevel) {
                  updated &= nextFluidSection.setFluid(worldX, nextY, worldZ, , ());
               }  {
                  updated &= nextFluidSection.setFluid(worldX, nextY, worldZ, fluidId, ()nextFluidLevel);
                  setTickingSurrounding(accessor, nextBlockSection, worldX, nextY, worldZ);
               }

               drainLevels -= ()transferLevels;
            }

             updated;
         }
      }  {
          ;
      }
   }

      {
         worldY;
         fluidSection.getY() != ChunkUtil.chunkCoordinate(worldY + ) ? accessor.getFluidSectionByBlock(worldX, worldY + , worldZ) : fluidSection;

      () {
          (fluidSection.getY() != ChunkUtil.chunkCoordinate(topY)) {
            fluidSection = accessor.getFluidSectionByBlock(worldX, topY, worldZ);
         }

          (aboveFluidSection.getY() != ChunkUtil.chunkCoordinate(topY + )) {
            aboveFluidSection = accessor.getFluidSectionByBlock(worldX, topY + , worldZ);
         }

          (fluidSection.getFluidLevel(worldX, topY, worldZ) != fluid.getMaxFluidLevel() || aboveFluidSection.getFluidId(worldX, topY + , worldZ) != fluidId) {
             topY;
         }

         ++topY;
      }
   }

       {
         offset.getX();
         offset.getY();
       (x !=  && z != ) {
            ChunkUtil.isSameChunkSection(worldX, worldY, worldZ, worldX + x, worldY, worldZ) ? blockSection : accessor.getBlockSection(worldX + x, worldY, worldZ);
            ChunkUtil.isSameChunkSection(worldX, worldY, worldZ, worldX, worldY, worldZ + z) ? blockSection : accessor.getBlockSection(worldX, worldY, worldZ + z);
          (section1 !=  && section2 != ) {
               section1.get(worldX + x, worldY, worldZ);
               section2.get(worldX, worldY, worldZ + z);
             block1 ==  || block2 ==  || !isSolid((BlockType)BlockType.getAssetMap().getAsset(block1)) || !isSolid((BlockType)BlockType.getAssetMap().getAsset(block2));
         }  {
             ;
         }
      }  {
          ;
      }
   }

    {
      CODEC = BuilderCodec.builder(FiniteFluidTicker.class, FiniteFluidTicker::, FluidTicker.BASE_CODEC).build();
      DIAG_OFFSETS =  []{ (-, -),  (, ),  (, -),  (-, )};
      OFFSETS_LISTS =  <List<Vector2i[]>>();
      List<Vector2i[]> offsets = List.of(ORTO_OFFSETS, DIAG_OFFSETS);
          ();

      (   ; i < ; ++i) {
         ObjectArrayList<Vector2i[]> offsetLists =  <Vector2i[]>();

         (Vector2i[] offset : offsets) {
            List<Vector2i> offsetArray = Arrays.asList(offset);
            Collections.shuffle(offsetArray, random);
            offsetLists.add((Vector2i[])offsetArray.toArray((x$) ->  [x$]));
         }

         OFFSETS_LISTS.add(offsetLists);
      }

   }

       {
      SUCCESS,
      UNLOADED_CHUNK;

        {
      }
   }
}

com/hypixel/hytale/server/core/asset/type/fluid/Fluid.java

package com.hypixel.hytale.server.core.asset.type.fluid;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.codecs.map.EnumMapCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditorSectionStart;
import com.hypixel.hytale.codec.schema.metadata.ui.UIPropertyTitle;
import com.hypixel.hytale.codec.schema.metadata.ui.UIRebuildCaches;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.protocol.BlockTextures;
import com.hypixel.hytale.protocol.Color;
import com.hypixel.hytale.protocol.ColorLight;
import com.hypixel.hytale.protocol.InteractionType;
import com.hypixel.hytale.protocol.Opacity;
import com.hypixel.hytale.protocol.ShaderType;
import com.hypixel.hytale.server.core.asset.type.blockparticle.config.BlockParticleSet;
import com.hypixel.hytale.server.core.asset.type.blocksound.config.BlockSoundSet;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockTypeTextures;
import com.hypixel.hytale.server.core.asset.type.fluidfx.config.FluidFX;
 com.hypixel.hytale.server.core.codec.ProtocolCodecs;
 com.hypixel.hytale.server.core.io.NetworkSerializable;
 com.hypixel.hytale.server.core.modules.interaction.interaction.config.InteractionTypeUtils;
 com.hypixel.hytale.server.core.modules.interaction.interaction.config.RootInteraction;
 com.hypixel.hytale.server.core.universe.world.chunk.section.palette.ISectionPalette;
 com.hypixel.hytale.server.core.util.io.ByteBufUtil;
 io.netty.buffer.ByteBuf;
 it.unimi.dsi.fastutil.ints.IntSet;
 java.util.Collections;
 java.util.Map;
 java.util.function.ToIntFunction;
 java.util.logging.Level;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;

    <String, IndexedLookupTableAssetMap<String, Fluid>>, NetworkSerializable<com.hypixel.hytale.protocol.Fluid> {
      AssetBuilderCodec<String, Fluid> CODEC;
      ValidatorCache<String> VALIDATOR_CACHE;
         ;
      BlockTextures[] UNKNOWN_BLOCK_TEXTURES;
      ShaderType[] DEFAULT_SHADER_EFFECTS;
      ISectionPalette.KeySerializer KEY_SERIALIZER;
      ToIntFunction<ByteBuf> KEY_DESERIALIZER;
         ;
         ;
      Fluid EMPTY;
         ;
      Fluid UNKNOWN;
     AssetStore<String, Fluid, IndexedLookupTableAssetMap<String, Fluid>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
     unknown;
       ;
    BlockTypeTextures[] textures;
    ShaderType[] effect;
   
    Opacity opacity;
     requiresAlphaBlending;
    String fluidFXId;
      fluidFXIndex;
    FluidTicker ticker;
     damageToEntities;
    ColorLight light;
    Color particleColor;
    String blockSoundSetId;
      blockSoundSetIndex;
    String blockParticleSetId;
    Map<InteractionType, String> interactions;
      isTrigger;

     AssetStore<String, Fluid, IndexedLookupTableAssetMap<String, Fluid>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, Fluid, IndexedLookupTableAssetMap<String, Fluid>>getAssetStore(Fluid.class);
      }

       ASSET_STORE;
   }

     IndexedLookupTableAssetMap<String, Fluid>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

     {
      .opacity = Opacity.Solid;
      .requiresAlphaBlending = ;
      .fluidFXId = ;
      .fluidFXIndex = ;
      .ticker = DefaultFluidTicker.INSTANCE;
      .blockSoundSetId = ;
      .blockSoundSetIndex = ;
      .interactions = Collections.emptyMap();
   }

     {
      .opacity = Opacity.Solid;
      .requiresAlphaBlending = ;
      .fluidFXId = ;
      .fluidFXIndex = ;
      .ticker = DefaultFluidTicker.INSTANCE;
      .blockSoundSetId = ;
      .blockSoundSetIndex = ;
      .interactions = Collections.emptyMap();
      .id = id;
   }

     {
      .opacity = Opacity.Solid;
      .requiresAlphaBlending = ;
      .fluidFXId = ;
      .fluidFXIndex = ;
      .ticker = DefaultFluidTicker.INSTANCE;
      .blockSoundSetId = ;
      .blockSoundSetIndex = ;
      .interactions = Collections.emptyMap();
      .data = other.data;
      .id = other.id;
      .unknown = other.unknown;
      .maxFluidLevel = other.maxFluidLevel;
      .textures = other.textures;
      .effect = other.effect;
      .opacity = other.opacity;
      .requiresAlphaBlending = other.requiresAlphaBlending;
      .fluidFXId = other.fluidFXId;
      .damageToEntities = other.damageToEntities;
      .light = other.light;
      .particleColor = other.particleColor;
      .blockSoundSetId = other.blockSoundSetId;
      .interactions = other.interactions;
      .isTrigger = other.isTrigger;
      .processConfig();
   }

    AssetExtraInfo.Data  {
       .data;
   }

    String  {
       .id;
   }

      {
       .unknown;
   }

      {
       .maxFluidLevel;
   }

    FluidTicker  {
       .ticker;
   }

      {
       .damageToEntities;
   }

    String  {
       .fluidFXId;
   }

      {
       .fluidFXIndex;
   }

    ColorLight  {
       .light;
   }

    Color  {
       .particleColor;
   }

      {
       .isTrigger;
   }

    Map<InteractionType, String>  {
       .interactions;
   }

      {
      .fluidFXIndex = .fluidFXId.equals() ?  : FluidFX.getAssetMap().getIndex(.fluidFXId);
      .blockSoundSetIndex = .blockSoundSetId.equals() ?  : BlockSoundSet.getAssetMap().getIndex(.blockSoundSetId);

      (InteractionType type : .interactions.keySet()) {
          (InteractionTypeUtils.isCollisionType(type)) {
            .isTrigger = ;
            ;
         }
      }

   }

   
     Fluid  {
       UNKNOWN.clone(key);
   }

   
    Fluid  {
       (.id !=  && .id.equals(newKey)) {
          ;
      }  {
             ();
         fluid.id = newKey;
          fluid;
      }
   }

       {
       getFluidIdOrUnknown(getAssetMap(), key, message, params);
   }

       {
         assetMap.getIndex(key);
       (fluidId == -) {
         HytaleLogger.getLogger().at(Level.WARNING).logVarargs(message, params);
         AssetRegistry.getAssetStore(Fluid.class).loadAssets(, Collections.singletonList(getUnknownFor(key)));
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         fluidId = index;
      }

       fluidId;
   }

   
    com.hypixel.hytale.protocol.Fluid  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.Fluid();
      packet.id = .id;
      packet.maxFluidLevel = .maxFluidLevel;
      packet.fluidFXIndex = .fluidFXIndex;
      packet.opacity = .opacity;
      packet.light = .light;
       (.effect !=  && .effect.length > ) {
         packet.shaderEffect = .effect;
      }  {
         packet.shaderEffect = DEFAULT_SHADER_EFFECTS;
      }

       (.textures !=  && .textures.length > ) {
            ;

         (BlockTypeTextures texture : .textures) {
            totalWeight = ()(()totalWeight + texture.getWeight());
         }

         BlockTextures[] texturePackets =  [.textures.length];

         (   ; i < .textures.length; ++i) {
            texturePackets[i] = .textures[i].toPacket(()totalWeight);
         }

         packet.cubeTextures = texturePackets;
      }  {
         packet.cubeTextures = UNKNOWN_BLOCK_TEXTURES;
      }

      packet.requiresAlphaBlending = .requiresAlphaBlending;
      packet.blockSoundSetIndex = .blockSoundSetIndex;
      packet.blockParticleSetId = .blockParticleSetId;
      packet.particleColor = .particleColor;
      packet.fluidFXIndex = .fluidFXIndex;
       (.data != ) {
            .data.getExpandedTagIndexes();
          (tags != ) {
            packet.tagIndexes = tags.toIntArray();
         }
      }

       packet;
   }

   
   
   
     String  {
      String var10000;
       (fluidName) {
           -> var10000 = level ==  ?  : ;
           -> var10000 = ;
           -> var10000 = level ==  ?  : ;
           -> var10000 = level ==  ?  : ;
           -> var10000 = level ==  ?  : ;
           -> var10000 = level ==  ?  : ;
          -> var10000 = ;
      }

       var10000;
   }

   
   
   
     ConversionResult  {
         blockTypeStr.indexOf();
       (fluidPos != -) {
            blockTypeStr.indexOf(, fluidPos + );
         String fluidName;
          (fluidNameEnd != -) {
            fluidName = blockTypeStr.substring(fluidPos + .length(), fluidNameEnd);
               blockTypeStr.substring(, fluidPos);
            blockTypeStr = var19 + blockTypeStr.substring(fluidNameEnd);
         }  {
            fluidName = blockTypeStr.substring(fluidPos + .length());
            blockTypeStr = blockTypeStr.substring(, fluidPos);
         }

            blockTypeStr.indexOf();
          fluidLevel;
          (fluidLevelStart != -) {
               blockTypeStr.indexOf(, fluidLevelStart + );
            String fluidLevelStr;
             (fluidLevelEnd != -) {
               fluidLevelStr = blockTypeStr.substring(fluidLevelStart + .length(), fluidLevelEnd);
                  blockTypeStr.substring(, fluidLevelStart);
               blockTypeStr = var20 + blockTypeStr.substring(fluidLevelEnd);
            }  {
               fluidLevelStr = blockTypeStr.substring(fluidLevelStart + .length());
               blockTypeStr = blockTypeStr.substring(, fluidLevelStart);
            }

            fluidLevel = Byte.parseByte(fluidLevelStr);
         }  {
            fluidLevel = ;
         }

         fluidName = convertLegacyName(fluidName, fluidLevel);
            getFluidIdOrUnknown(fluidName, , fluidName);
         fluidLevel = fluidLevel ==  ? ()((Fluid)getAssetMap().getAsset(fluidId)).getMaxFluidLevel() : fluidLevel;
           (blockTypeStr, fluidId, fluidLevel);
      }   (blockTypeStr.startsWith()) {
            blockTypeStr.indexOf();
          fluidLevel;
          (fluidLevelStart != -) {
               blockTypeStr.indexOf(, fluidLevelStart + );
            String fluidLevelStr;
             (fluidLevelEnd != -) {
               fluidLevelStr = blockTypeStr.substring(fluidLevelStart + .length(), fluidLevelEnd);
                  blockTypeStr.substring(, fluidLevelStart);
               blockTypeStr = var10000 + blockTypeStr.substring(fluidLevelEnd);
            }  {
               fluidLevelStr = blockTypeStr.substring(fluidLevelStart + .length());
               blockTypeStr = blockTypeStr.substring(, fluidLevelStart);
            }

            fluidLevel = Byte.parseByte(fluidLevelStr);
         }  {
            fluidLevel = ;
         }

            convertLegacyName(blockTypeStr, fluidLevel);
            getFluidIdOrUnknown(newFluidName, , newFluidName);
         fluidLevel = fluidLevel ==  ? ()((Fluid)getAssetMap().getAsset(fluidId)).getMaxFluidLevel() : fluidLevel;
           ((String), fluidId, fluidLevel);
      }  {
          ;
      }
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(Fluid.class, Fluid::, Codec.STRING, (t, k) -> t.id = k, (t) -> t.id, (asset, data) -> asset.data = data, (asset) -> asset.data).appendInherited( (, Codec.INTEGER), (asset, v) -> asset.maxFluidLevel = v, (asset) -> asset.maxFluidLevel, (asset, parent) -> asset.maxFluidLevel = parent.maxFluidLevel).addValidator(Validators.range(, )).add()).appendInherited( (,  (BlockTypeTextures.CODEC, (x$) ->  [x$])), (fluid, o) -> fluid.textures = o, (fluid) -> fluid.textures, (fluid, parent) -> fluid.textures = parent.textures).metadata( ()).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS, UIRebuildCaches.ClientCache.BLOCK_TEXTURES})).add()).appendInherited( (,  ( (ShaderType.class), (x$) ->  [x$])), (fluid, o) -> fluid.effect = o, (fluid) -> fluid.effect, (fluid, parent) -> fluid.effect = parent.effect).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).add()).appendInherited( (,  (Opacity.class)), (fluid, o) -> fluid.opacity = o, (fluid) -> fluid.opacity, (fluid, parent) -> fluid.opacity = parent.opacity).addValidator(Validators.nonNull()).add()).appendInherited( (, Codec.BOOLEAN), (fluid, o) -> fluid.requiresAlphaBlending = o, (fluid) -> fluid.requiresAlphaBlending, (fluid, parent) -> fluid.requiresAlphaBlending = parent.requiresAlphaBlending).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).add()).appendInherited( (, Codec.STRING), (fluid, o) -> fluid.fluidFXId = o, (fluid) -> fluid.fluidFXId, (fluid, parent) -> fluid.fluidFXId = parent.fluidFXId).addValidator(FluidFX.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, FluidTicker.CODEC), (fluid, o) -> fluid.ticker = o, (fluid) -> fluid.ticker, (fluid, parent) -> fluid.ticker = parent.ticker).add()).appendInherited( (, ProtocolCodecs.COLOR_LIGHT), (fluid, o) -> fluid.light = o, (fluid) -> fluid.light, (fluid, parent) -> fluid.light = parent.light).add()).appendInherited( (, Codec.INTEGER), (fluid, s) -> fluid.damageToEntities = s, (fluid) -> fluid.damageToEntities, (fluid, parent) -> fluid.damageToEntities = parent.damageToEntities).add()).appendInherited( (, Codec.STRING), (fluid, s) -> fluid.blockParticleSetId = s, (fluid) -> fluid.blockParticleSetId, (fluid, parent) -> fluid.blockParticleSetId = parent.blockParticleSetId).documentation().addValidator(BlockParticleSet.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, ProtocolCodecs.COLOR), (fluid, s) -> fluid.particleColor = s, (fluid) -> fluid.particleColor, (fluid, parent) -> fluid.particleColor = parent.particleColor).add()).appendInherited( (, Codec.STRING), (fluid, o) -> fluid.blockSoundSetId = o, (fluid) -> fluid.blockSoundSetId, (fluid, parent) -> fluid.blockSoundSetId = parent.blockSoundSetId).documentation().addValidator(BlockSoundSet.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (,  (InteractionType.class, RootInteraction.CHILD_ASSET_CODEC)), (item, v) -> item.interactions = v, (item) -> item.interactions, (item, parent) -> item.interactions = parent.interactions).addValidator(RootInteraction.VALIDATOR_CACHE.getMapValueValidator()).metadata( ()).add()).afterDecode(Fluid::processConfig)).build();
      VALIDATOR_CACHE =  <String>( (Fluid::getAssetStore));
      UNKNOWN_BLOCK_TEXTURES =  []{ (, , , , , , )};
      DEFAULT_SHADER_EFFECTS =  []{ShaderType.None};
      KEY_SERIALIZER = (buf, id) -> {
            ((Fluid)getAssetMap().getAssetOrDefault(id, UNKNOWN)).getId();
         ByteBufUtil.writeUTF(buf, key);
      };
      KEY_DESERIALIZER = (byteBuf) -> {
            ByteBufUtil.readUTF(byteBuf);
          getFluidIdOrUnknown(fluid, , fluid);
      };
      EMPTY =  () {
         {
            .processConfig();
         }
      };
      UNKNOWN =  () {
         {
            .unknown = ;
            .processConfig();
         }
      };
   }

   
   
       {
       String blockTypeStr;
        fluidId;
        fluidLevel;

        {
         .blockTypeStr = blockTypeStr;
         .fluidId = fluidId;
         .fluidLevel = fluidLevel;
      }
   }
}

com/hypixel/hytale/server/core/asset/type/fluid/FluidTicker.java

package com.hypixel.hytale.server.core.asset.type.fluid;

import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.lookup.CodecMapCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.component.CommandBuffer;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.math.shape.Box;
import com.hypixel.hytale.math.util.ChunkUtil;
import com.hypixel.hytale.math.util.HashUtil;
import com.hypixel.hytale.math.vector.Vector2i;
import com.hypixel.hytale.protocol.BlockMaterial;
import com.hypixel.hytale.protocol.DrawType;
import com.hypixel.hytale.server.core.asset.type.blockhitbox.BlockBoundingBoxes;
import com.hypixel.hytale.server.core.asset.type.blocktick.BlockTickStrategy;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.universe.world.chunk.AbstractCachedAccessor;
import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
import com.hypixel.hytale.server.core.universe.world.chunk.section.FluidSection;
import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
import com.hypixel.hytale.server.core.util.FillerBlockUtil;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public abstract class  {
      BuilderCodec<FluidTicker> BASE_CODEC;
      CodecMapCodec<FluidTicker> CODEC;
      Vector2i[] ORTO_OFFSETS;
         ;
         ;
         ;
         ;
         ;
         ;
         ;
       ;
       ;
    String supportedBy;
        ;

     {
   }

      {
       (.supportedById == ) {
          (.supportedBy != ) {
            .supportedById = Fluid.getAssetMap().getIndex(.supportedBy);
         }  {
            .supportedById = -;
         }
      }

       .supportedById;
   }

    BlockTickStrategy  {
         blockSection.get(worldX, worldY, worldZ);
       (isFullySolid((BlockType)BlockType.getAssetMap().getAsset(block))) {
         fluidSection.setFluid(worldX, worldY, worldZ, , ());
         setTickingSurrounding(cachedAccessor, blockSection, worldX, worldY, worldZ);
          BlockTickStrategy.SLEEP;
      }  {
            ((ChunkStore)commandBuffer.getExternalData()).getWorld();
            HashUtil.rehash(()worldX, ()worldY, ()worldZ, );
            ((ChunkStore)commandBuffer.getExternalData()).getWorld().getTick();
            Math.round(.flowRate * ()world.getTps());
          (hash + tick) % ()flowRateLimitTicks !=  ? BlockTickStrategy.CONTINUE : .process(world, tick, cachedAccessor, fluidSection, blockSection, fluid, fluidId, worldX, worldY, worldZ);
      }
   }

    BlockTickStrategy  {
         fluidSection.getFluidLevel(worldX, worldY, worldZ);
       (.isAlive(accessor, fluidSection, blockSection, fluid, fluidId, fluidLevel, worldX, worldY, worldZ).ordinal()) {
          :
             .spread(world, tick, accessor, fluidSection, blockSection, fluid, fluidId, fluidLevel, worldX, worldY, worldZ);
          :
             (fluidLevel == ) {
               fluidSection.setFluid(worldX, worldY, worldZ, , ());
               setTickingSurrounding(accessor, blockSection, worldX, worldY, worldZ);
                BlockTickStrategy.SLEEP;
            }

            fluidSection.setFluid(worldX, worldY, worldZ, fluidId, ()((fluidLevel ==  ? fluid.getMaxFluidLevel() : fluidLevel) - ));
            setTickingSurrounding(accessor, blockSection, worldX, worldY, worldZ);
             BlockTickStrategy.SLEEP;
          :
             BlockTickStrategy.WAIT_FOR_ADJACENT_CHUNK_LOAD;
         :
             BlockTickStrategy.SLEEP;
      }
   }

   
    AliveStatus  {
       (!.canDemote) {
          FluidTicker.AliveStatus.ALIVE;
      }  {
            .getSupportedById();
         BlockTypeAssetMap<String, BlockType> blockMap = BlockType.getAssetMap();
            ChunkUtil.chunkCoordinate(worldY + ) == fluidSection.getY() ? fluidSection : accessor.getFluidSectionByBlock(worldX, worldY + , worldZ);
          (aboveFluidSection == ) {
             FluidTicker.AliveStatus.WAIT_FOR_ADJACENT_CHUNK;
         }  {
               aboveFluidSection.getFluidId(worldX, worldY + , worldZ);
             (fluidAbove != fluidId && fluidAbove != supportId) {
                  blockMap.getAsset(blockSection.get(worldX, worldY, worldZ));
                  blockSection.getRotationIndex(worldX, worldY, worldZ);
                  blockSection.getFiller(worldX, worldY, worldZ);
                  ;

               (Vector2i offset : ORTO_OFFSETS) {
                     offset.x;
                     offset.y;
                     x + worldX;
                     z + worldZ;
                     !ChunkUtil.isSameChunkSection(worldX, worldY, worldZ, blockX, worldY, blockZ);
                     isDifferentSection ? accessor.getFluidSectionByBlock(blockX, worldY, blockZ) : fluidSection;
                     isDifferentSection ? accessor.getBlockSectionByBlock(blockX, worldY, blockZ) : blockSection;
                   (otherFluidSection !=  && otherBlockSection != ) {
                        otherFluidSection.getFluidId(blockX, worldY, blockZ);
                      (supportId != - && otherFluid == supportId) {
                           blockMap.getAsset(otherBlockSection.get(blockX, worldY, blockZ));
                         (sourceBlock != ) {
                              otherBlockSection.getRotationIndex(blockX, worldY, blockZ);
                              otherBlockSection.getFiller(blockX, worldY, blockZ);
                            (!blocksFluidFrom(sourceBlock, sourceRotation, x, z, sourceFiller) && !blocksFluidFrom(thisBlock, thisRotation, -x, -z, thisFiller)) {
                               FluidTicker.AliveStatus.ALIVE;
                           }
                        }
                     }  {
                           otherFluidSection.getFluidLevel(blockX, worldY, blockZ);
                         (otherFluid !=  && otherFluid == fluidId && otherFluidLevel > fluidLevel) {
                              blockMap.getAsset(otherBlockSection.get(blockX, worldY, blockZ));
                            (sourceBlock != ) {
                                 otherBlockSection.getRotationIndex(blockX, worldY, blockZ);
                                 otherBlockSection.getFiller(blockX, worldY, blockZ);
                               (!blocksFluidFrom(sourceBlock, sourceRotation, x, z, sourceFiller) && !blocksFluidFrom(thisBlock, thisRotation, -x, -z, thisFiller)) {
                                  FluidTicker.AliveStatus.ALIVE;
                              }
                           }
                        }
                     }
                  }  {
                     chunkNotLoaded = ;
                  }
               }

                (chunkNotLoaded) {
                   FluidTicker.AliveStatus.WAIT_FOR_ADJACENT_CHUNK;
               }  {
                   FluidTicker.AliveStatus.DEMOTE;
               }
            }  {
                FluidTicker.AliveStatus.ALIVE;
            }
         }
      }
   }

     BlockTickStrategy ;

       {
      (   -; y <= ; ++y) {
         (   -; z <= ; ++z) {
            (   -; x <= ; ++x) {
                  worldX + x;
                  worldY + y;
                  worldZ + z;
                  ChunkUtil.isSameChunkSection(worldX, worldY, worldZ, bx, by, bz) ? blockSection : accessor.getBlockSectionByBlock(bx, by, bz);
                (chunk != ) {
                  chunk.setTicking(bx, by, bz, );
               }
            }
         }
      }

   }

      {
         ;
         ;
       (worldY <= ) {
          offsets;
      }  {
         (   ; i < offsetArray.length; ++i) {
               offsetArray[i];
               .distanceToDrop(blockMap, accessor, fluidSection, blockSection, worldX, worldY, worldZ, offset, fluidId, maxDropDistance);
             (distance == ) {
                ;
            }

             (distance < shortestDistanceToDrop) {
               offsets = ;
               shortestDistanceToDrop = distance;
            }

             (distance <= shortestDistanceToDrop && distance != ) {
               offsets |=  << i;
            }
         }

          offsets;
      }
   }

      {
         offset.x;
         offset.y;
         worldY - ;
         fluidSection;
         blockSection;
         fluidSection.getY() != ChunkUtil.chunkCoordinate(yMinus1);
       (isBelowDifferent) {
         belowFluidSection = accessor.getFluidSectionByBlock(worldX, yMinus1, worldZ);
         belowBlockSection = accessor.getBlockSectionByBlock(worldX, yMinus1, worldZ);
      }

         worldX;
         worldZ;
         .getSupportedById();

      (   ; i < maxDropDistance; ++i) {
            worldX + ox * i;
            worldZ + oz * i;
          (!ChunkUtil.isSameChunk(curX, curZ, blockX, blockZ)) {
            curX = blockX;
            curZ = blockZ;
            fluidSection = accessor.getFluidSectionByBlock(blockX, worldY, blockZ);
            blockSection = accessor.getBlockSectionByBlock(blockX, worldY, blockZ);
             (isBelowDifferent) {
               belowFluidSection = accessor.getFluidSectionByBlock(worldX, yMinus1, worldZ);
               belowBlockSection = accessor.getBlockSectionByBlock(worldX, yMinus1, worldZ);
            }  {
               belowFluidSection = fluidSection;
               belowBlockSection = blockSection;
            }
         }

          (fluidSection ==  || blockSection ==  || belowFluidSection ==  || belowBlockSection == ) {
             ;
         }

            fluidSection.getFluidId(blockX, worldY, blockZ);
            blockMap.getAsset(blockSection.get(blockX, worldY, blockZ));
          (otherFluidId !=  && (otherFluidId != fluidId || otherFluidId == supportedById || supportedById == -) || otherFluidId ==  && isSolid(block)) {
            ;
         }

            blockMap.getAsset(belowBlockSection.get(blockX, yMinus1, blockZ));
          (!isSolid(belowBlock)) {
             i;
         }
      }

       ;
   }

       {
         blockType.getDrawType();
       blockType.getMaterial() == BlockMaterial.Solid && (drawType == DrawType.Cube || drawType == DrawType.CubeWithModel);
   }

       {
         blockType.getDrawType();
       drawType == DrawType.Cube || drawType == DrawType.CubeWithModel;
   }

       {
       blocksFluidFrom(blockType, rotationIndex, offsetX, offsetZ, );
   }

       {
       (blockType.getMaterial() != BlockMaterial.Solid) {
          ;
      }   (isFullySolid(blockType)) {
          ;
      }  {
            blockType.getHitboxTypeIndex();
            (BlockBoundingBoxes)BlockBoundingBoxes.getAssetMap().getAsset(hitboxIndex);
          (hitboxAsset == ) {
             ;
         }  {
            BlockBoundingBoxes.   hitboxAsset.get(rotationIndex);
               rotatedHitbox.getBoundingBox();
             (!hitboxAsset.protrudesUnitBox() && filler == ) {
                  boundingBox.max.x - boundingBox.min.x;
                  boundingBox.max.y - boundingBox.min.y;
                  boundingBox.max.z - boundingBox.min.z;
                  height > ;
                (!isTall) {
                   ;
               }  {
                     depth > ;
                     width < ;
                   (isPartialWidth && isFullDepth) {
                      (offsetX != ) {
                         (offsetX > ) {
                            boundingBox.min.x < ;
                        }  {
                            boundingBox.max.x > ;
                        }
                     }  {
                         ;
                     }
                  }  {
                        width > ;
                        depth < ;
                      (isFullWidth && isPartialDepth) {
                         (offsetZ != ) {
                            (offsetZ > ) {
                               boundingBox.min.z < ;
                           }  {
                               boundingBox.max.z > ;
                           }
                        }  {
                            ;
                        }
                     }  {
                        Box[] detailBoxes = rotatedHitbox.getDetailBoxes();
                         (detailBoxes.length > ) {
                            boxesBlockFace(detailBoxes, offsetX, offsetZ);
                        }  {
                              ;
                            (offsetX >  && boundingBox.min.x < ) {
                              faceCoverage = height * depth;
                           }   (offsetX <  && boundingBox.max.x > ) {
                              faceCoverage = height * depth;
                           }   (offsetZ >  && boundingBox.min.z < ) {
                              faceCoverage = height * width;
                           }   (offsetZ <  && boundingBox.max.z > ) {
                              faceCoverage = height * width;
                           }

                            faceCoverage > ;
                        }
                     }
                  }
               }
            }  {
                  FillerBlockUtil.unpackX(filler);
                  FillerBlockUtil.unpackY(filler);
                  FillerBlockUtil.unpackZ(filler);
               Box[] detailBoxes = rotatedHitbox.getDetailBoxes();
                  ;

               (Box box : detailBoxes) {
                     Math.max(box.min.x, ()fillerX);
                     Math.min(box.max.x, ()(fillerX + ));
                     Math.max(box.min.y, ()fillerY);
                     Math.min(box.max.y, ()(fillerY + ));
                     Math.max(box.min.z, ()fillerZ);
                     Math.min(box.max.z, ()(fillerZ + ));
                   (!(clampedMaxX <= clampedMinX) && !(clampedMaxY <= clampedMinY) && !(clampedMaxZ <= clampedMinZ)) {
                        clampedMaxX - clampedMinX;
                        clampedMaxY - clampedMinY;
                        clampedMaxZ - clampedMinZ;
                        ;
                      (offsetX != ) {
                        crossSectionCoverage = boxHeight * boxDepth;
                     }   (offsetZ != ) {
                        crossSectionCoverage = boxHeight * boxWidth;
                     }

                     maxCrossSectionCoverage = Math.max(maxCrossSectionCoverage, crossSectionCoverage);
                  }
               }

                maxCrossSectionCoverage > ;
            }
         }
      }
   }

       {
         ;

      (Box box : boxes) {
            ;
          (offsetX >  && box.min.x < ) {
               box.max.y - box.min.y;
               box.max.z - box.min.z;
            areaOnFace = height * depth;
         }   (offsetX <  && box.max.x > ) {
               box.max.y - box.min.y;
               box.max.z - box.min.z;
            areaOnFace = height * depth;
         }   (offsetZ >  && box.min.z < ) {
               box.max.y - box.min.y;
               box.max.x - box.min.x;
            areaOnFace = height * width;
         }   (offsetZ <  && box.max.z > ) {
               box.max.y - box.min.y;
               box.max.x - box.min.x;
            areaOnFace = height * width;
         }

         totalArea += areaOnFace;
      }

       totalArea > ;
   }

      {
       selfFluidId == otherFluidId || otherFluidId == .getSupportedById();
   }

      {
       .canDemote;
   }

    {
      BASE_CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.abstractBuilder(FluidTicker.class).appendInherited( (, Codec.FLOAT), (ticker, r) -> ticker.flowRate = r, (ticker) -> ticker.flowRate, (ticker, parent) -> ticker.flowRate = parent.flowRate).documentation().addValidator(Validators.greaterThan()).add()).appendInherited( (, Codec.BOOLEAN), (ticker, o) -> ticker.canDemote = o, (ticker) -> ticker.canDemote, (ticker, parent) -> ticker.canDemote = parent.canDemote).documentation().add()).appendInherited( (, Codec.STRING), (ticker, o) -> ticker.supportedBy = o, (ticker) -> ticker.supportedBy, (ticker, parent) -> ticker.supportedBy = parent.supportedBy).add()).build();
      CODEC =  <FluidTicker>(, );
      ORTO_OFFSETS =  []{ (-, ),  (, ),  (, -),  (, )};
   }

       {
      ALIVE,
      DEMOTE,
      WAIT_FOR_ADJACENT_CHUNK;

        {
      }
   }

      {
      
      FluidSection ;

      
       FluidSection  {
          .getFluidSection(ChunkUtil.chunkCoordinate(bx), ChunkUtil.chunkCoordinate(by), ChunkUtil.chunkCoordinate(bz));
      }

      
      BlockSection ;

      
       BlockSection  {
          .getBlockSection(ChunkUtil.chunkCoordinate(bx), ChunkUtil.chunkCoordinate(by), ChunkUtil.chunkCoordinate(bz));
      }

      
      
       ;
   }

           {
         ThreadLocal<CachedAccessor> THREAD_LOCAL = ThreadLocal.withInitial(CachedAccessor::);
            ;
            ;
       CommandBuffer<ChunkStore> commandBuffer;
       FluidSection selfFluidSection;
       BlockSection selfBlockSection;

        {
         ();
      }

      
        CachedAccessor  {
            (CachedAccessor)THREAD_LOCAL.get();
         accessor.init(commandBuffer, section, blockSection, radius);
         accessor.insertSectionComponent(, section, section.getX(), section.getY(), section.getZ());
         accessor.insertSectionComponent(, blockSection, section.getX(), section.getY(), section.getZ());
          accessor;
      }

         {
         .init(commandBuffer, section.getX(), section.getY(), section.getZ(), radius);
         .commandBuffer = commandBuffer;
         .selfFluidSection = section;
         .selfBlockSection = blockSection;
      }

       FluidSection  {
          (FluidSection).getComponentSection(cx, cy, cz, , FluidSection.getComponentType());
      }

       BlockSection  {
          (BlockSection).getComponentSection(cx, cy, cz, , BlockSection.getComponentType());
      }

         {
         Ref<ChunkStore> chunk = .getChunk(ChunkUtil.chunkCoordinate(x), ChunkUtil.chunkCoordinate(z));
          (chunk !=  && chunk.isValid()) {
            .commandBuffer.run((store) -> {
                (chunk.isValid()) {
                     (WorldChunk)store.getComponent(chunk, WorldChunk.getComponentType());
                   (wc != ) {
                     wc.setBlock(x, y, z, blockId);
                  }
               }
            });
         }
      }
   }
}

com/hypixel/hytale/server/core/asset/type/fluid/FluidTypePacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.fluid;

import com.hypixel.hytale.assetstore.AssetUpdateQuery;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateFluids;
import com.hypixel.hytale.server.core.asset.packet.AssetPacketGenerator;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class FluidTypePacketGenerator extends AssetPacketGenerator<String, Fluid, IndexedLookupTableAssetMap<String, Fluid>> {
   public FluidTypePacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull IndexedLookupTableAssetMap<String, Fluid> assetMap, @Nonnull Map<String, Fluid> assets) {
      UpdateFluids packet = new UpdateFluids();
      packet.type = UpdateType.Init;
      HashMap<Integer, com.hypixel.hytale.protocol.Fluid> fluidTypes = new HashMap();

      for(Map.Entry<String, Fluid> entry : assets.entrySet()) {
         int index = assetMap.getIndex((String)entry.getKey());
         if (index == -2147483648) {
              ( + (String)entry.getKey());
         }

         fluidTypes.put(index, ((Fluid)entry.getValue()).toPacket());
      }

      packet.fluids = fluidTypes;
      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      HashMap<Integer, com.hypixel.hytale.protocol.Fluid> fluidTypes =  ();

      (Map.Entry<String, Fluid> entry : loadedAssets.entrySet()) {
            assetMap.getIndex((String)entry.getKey());
          (index == -) {
              ( + (String)entry.getKey());
         }

         fluidTypes.put(index, ((Fluid)entry.getValue()).toPacket());
      }

      packet.fluids = fluidTypes;
      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      HashMap<Integer, com.hypixel.hytale.protocol.Fluid> fluidTypes =  ();

      (String key : removed) {
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

             (key);
         fluidTypes.put(index, fluid.toPacket());
      }

      packet.fluids = fluidTypes;
      packet.maxId = assetMap.getNextIndex();
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/fluidfx/FluidFXPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.fluidfx;

import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateFluidFX;
import com.hypixel.hytale.server.core.asset.packet.SimpleAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.fluidfx.config.FluidFX;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class FluidFXPacketGenerator extends SimpleAssetPacketGenerator<String, FluidFX, IndexedLookupTableAssetMap<String, FluidFX>> {
   public FluidFXPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull IndexedLookupTableAssetMap<String, FluidFX> assetMap, @Nonnull Map<String, FluidFX> assets) {
      UpdateFluidFX packet = new UpdateFluidFX();
      packet.type = UpdateType.Init;
      packet.fluidFX = new Int2ObjectOpenHashMap();

      for(Map.Entry<String, FluidFX> entry : assets.entrySet()) {
         String key = (String)entry.getKey();
         int index  assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.fluidFX.put(index, ((FluidFX)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.fluidFX =  ();

      (Map.Entry<String, FluidFX> entry : loadedAssets.entrySet()) {
            (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.fluidFX.put(index, ((FluidFX)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.fluidFX =  ();

      (String key : removed) {
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.fluidFX.put(index, (Object));
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/fluidfx/config/FluidFX.java

package com.hypixel.hytale.server.core.asset.type.fluidfx.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.Color;
import com.hypixel.hytale.protocol.FluidFXMovementSettings;
import com.hypixel.hytale.protocol.FluidFog;
import com.hypixel.hytale.protocol.NearFar;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.lang.ref.SoftReference;
import java.util.Arrays;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class FluidFX implements JsonAssetWithMap<String, IndexedLookupTableAssetMap<String, FluidFX>>, NetworkSerializable<com.hypixel.hytale.protocol.FluidFX> {
   public static final AssetBuilderCodec<String, FluidFX> CODEC;
      Color DEFAULT_FOG_COLOR;
      [] DEFAULT_FOG_DISTANCE;
      [] DEFAULT_COLORS_FILTER;
         ;
         ;
      FluidFX EMPTY_FLUID_FX;
      ValidatorCache<String> VALIDATOR_CACHE;
     AssetStore<String, FluidFX, IndexedLookupTableAssetMap<String, FluidFX>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
   
    FluidFog fog;
    Color fogColor;
    [] fogDistance;
     fogDepthStart;
     fogDepthFalloff;
     colorsSaturation;
    [] colorsFilter;
     distortionAmplitude;
     distortionFrequency;
    FluidParticle particle;
    FluidFXMovementSettings movementSettings;
    SoftReference<com.hypixel.hytale.protocol.FluidFX> cachedPacket;

     AssetStore<String, FluidFX, IndexedLookupTableAssetMap<String, FluidFX>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, FluidFX, IndexedLookupTableAssetMap<String, FluidFX>>getAssetStore(FluidFX.class);
      }

       ASSET_STORE;
   }

     IndexedLookupTableAssetMap<String, FluidFX>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

     {
      .fog = FluidFog.Color;
      .fogColor = DEFAULT_FOG_COLOR;
      .fogDistance = DEFAULT_FOG_DISTANCE;
      .fogDepthStart = ;
      .fogDepthFalloff = ;
      .colorsSaturation = ;
      .colorsFilter = DEFAULT_COLORS_FILTER;
      .distortionAmplitude = ;
      .distortionFrequency = ;
      .id = id;
      .fog = fog;
      .fogColor = fogColor;
      .fogDistance = fogDistance;
      .fogDepthStart = fogDepthStart;
      .fogDepthFalloff = fogDepthFalloff;
      .colorsSaturation = colorsSaturation;
      .colorsFilter = colorsFilter;
      .distortionAmplitude = distortionAmplitude;
      .distortionFrequency = distortionFrequency;
      .particle = particle;
      .movementSettings = movementSettings;
   }

     {
      .fog = FluidFog.Color;
      .fogColor = DEFAULT_FOG_COLOR;
      .fogDistance = DEFAULT_FOG_DISTANCE;
      .fogDepthStart = ;
      .fogDepthFalloff = ;
      .colorsSaturation = ;
      .colorsFilter = DEFAULT_COLORS_FILTER;
      .distortionAmplitude = ;
      .distortionFrequency = ;
      .id = id;
   }

     {
      .fog = FluidFog.Color;
      .fogColor = DEFAULT_FOG_COLOR;
      .fogDistance = DEFAULT_FOG_DISTANCE;
      .fogDepthStart = ;
      .fogDepthFalloff = ;
      .colorsSaturation = ;
      .colorsFilter = DEFAULT_COLORS_FILTER;
      .distortionAmplitude = ;
      .distortionFrequency = ;
   }

   
    com.hypixel.hytale.protocol.FluidFX  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.FluidFX).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.FluidFX();
         packet.id = .id;
         packet.fogMode = .fog;
         packet.fogColor = .fogColor;
         packet.fogDistance =  (.fogDistance[], .fogDistance[]);
         packet.fogDepthStart = .fogDepthStart;
         packet.fogDepthFalloff = .fogDepthFalloff;
         packet.colorFilter =  (()(()(.colorsFilter[] * )), ()(()(.colorsFilter[] * )), ()(()(.colorsFilter[] * )));
         packet.colorSaturation = .colorsSaturation;
         packet.distortionAmplitude = .distortionAmplitude;
         packet.distortionFrequency = .distortionFrequency;
          (.particle != ) {
            packet.particle = .particle.toPacket();
         }

          (.movementSettings != ) {
            packet.movementSettings = .movementSettings;
         }

         .cachedPacket =  (packet);
          packet;
      }
   }

    String  {
       .id;
   }

    FluidFog  {
       .fog;
   }

    Color  {
       .fogColor;
   }

    [] getFogDistance() {
       .fogDistance;
   }

      {
       .colorsSaturation;
   }

    [] getColorsFilter() {
       .colorsFilter;
   }

      {
       .distortionAmplitude;
   }

      {
       .distortionFrequency;
   }

      {
       .fogDepthStart;
   }

      {
       .fogDepthFalloff;
   }

    FluidParticle  {
       .particle;
   }

    FluidFXMovementSettings  {
       .movementSettings;
   }

      {
       ( == o) {
          ;
      }   (o !=  && .getClass() == o.getClass()) {
            (FluidFX)o;
          .id !=  ? .id.equals(fluidFX.id) : fluidFX.id == ;
      }  {
          ;
      }
   }

      {
       .id !=  ? .id.hashCode() : ;
   }

   
    String  {
         .id;
        + var10000 +  + String.valueOf(.fog) +  + String.valueOf(.fogColor) +  + Arrays.toString(.fogDistance) +  + .fogDepthStart +  + .fogDepthFalloff +  + .colorsSaturation +  + Arrays.toString(.colorsFilter) +  + .distortionAmplitude +  + .distortionFrequency +  + String.valueOf(.particle) +  + String.valueOf(.movementSettings) + ;
   }

   
     FluidFX  {
        (unknownId);
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(FluidFX.class, FluidFX::, Codec.STRING, (fluidFX, s) -> fluidFX.id = s, (fluidFX) -> fluidFX.id, (asset, data) -> asset.data = data, (asset) -> asset.data).appendInherited( (,  (FluidFog.class)), (fluidFX, fluidFog) -> fluidFX.fog = fluidFog, (fluidFX) -> fluidFX.fog, (fluidFX, parent) -> fluidFX.fog = parent.fog).addValidator(Validators.nonNull()).add()).appendInherited( (, ProtocolCodecs.COLOR), (fluidFX, o) -> fluidFX.fogColor = o, (fluidFX) -> fluidFX.fogColor, (fluidFX, parent) -> fluidFX.fogColor = parent.fogColor).add()).appendInherited( (, Codec.DOUBLE_ARRAY), (weather, o) -> {
         weather.fogDistance =  [];
         weather.fogDistance[] = ()o[];
         weather.fogDistance[] = ()o[];
      }, (weather) ->  []{()weather.fogDistance[], ()weather.fogDistance[]}, (weather, parent) -> weather.fogDistance = parent.fogDistance).addValidator(Validators.doubleArraySize()).add()).appendInherited( (, Codec.DOUBLE), (fluidFX, s) -> fluidFX.fogDepthStart = s.floatValue(), (fluidFX) -> ()fluidFX.fogDepthStart, (fluidFX, parent) -> fluidFX.fogDepthStart = parent.fogDepthStart).add()).appendInherited( (, Codec.DOUBLE), (fluidFX, s) -> fluidFX.fogDepthFalloff = s.floatValue(), (fluidFX) -> ()fluidFX.fogDepthFalloff, (fluidFX, parent) -> fluidFX.fogDepthFalloff = parent.fogDepthFalloff).add()).appendInherited( (, Codec.DOUBLE), (fluidFX, s) -> fluidFX.colorsSaturation = s.floatValue(), (fluidFX) -> ()fluidFX.colorsSaturation, (fluidFX, parent) -> fluidFX.colorsSaturation = parent.colorsSaturation).add()).appendInherited( (, Codec.DOUBLE_ARRAY), (weather, o) -> {
         weather.colorsFilter =  [];
         weather.colorsFilter[] = ()o[];
         weather.colorsFilter[] = ()o[];
         weather.colorsFilter[] = ()o[];
      }, (weather) ->  []{()weather.colorsFilter[], ()weather.colorsFilter[], ()weather.colorsFilter[]}, (weather, parent) -> weather.colorsFilter = parent.colorsFilter).addValidator(Validators.doubleArraySize()).add()).appendInherited( (, Codec.DOUBLE), (fluidFX, s) -> fluidFX.distortionAmplitude = s.floatValue(), (fluidFX) -> ()fluidFX.distortionAmplitude, (fluidFX, parent) -> fluidFX.distortionAmplitude = parent.distortionAmplitude).add()).appendInherited( (, Codec.DOUBLE), (fluidFX, s) -> fluidFX.distortionFrequency = s.floatValue(), (fluidFX) -> ()fluidFX.distortionFrequency, (fluidFX, parent) -> fluidFX.distortionFrequency = parent.distortionFrequency).add()).appendInherited( (, FluidParticle.CODEC), (fluidFX, s) -> fluidFX.particle = s, (fluidFX) -> fluidFX.particle, (fluidFX, parent) -> fluidFX.particle = parent.particle).add()).appendInherited( (, ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(FluidFXMovementSettings.class, FluidFXMovementSettings::).append( (, Codec.DOUBLE), (movementSettings, val) -> movementSettings.swimUpSpeed = val.floatValue(), (movementSettings) -> ()movementSettings.swimUpSpeed).add()).append( (, Codec.DOUBLE), (movementSettings, val) -> movementSettings.swimDownSpeed = val.floatValue(), (movementSettings) -> ()movementSettings.swimDownSpeed).add()).append( (, Codec.DOUBLE), (movementSettings, val) -> movementSettings.sinkSpeed = val.floatValue(), (movementSettings) -> ()movementSettings.sinkSpeed).add()).append( (, Codec.DOUBLE), (movementSettings, val) -> movementSettings.horizontalSpeedMultiplier = val.floatValue(), (movementSettings) -> ()movementSettings.horizontalSpeedMultiplier).add()).append( (, Codec.DOUBLE), (movementSettings, val) -> movementSettings.fieldOfViewMultiplier = val.floatValue(), (movementSettings) -> ()movementSettings.fieldOfViewMultiplier).add()).append( (, Codec.DOUBLE), (movementSettings, val) -> movementSettings.entryVelocityMultiplier = val.floatValue(), (movementSettings) -> ()movementSettings.entryVelocityMultiplier).add()).build()), (fluidFX, movementSettings) -> fluidFX.movementSettings = movementSettings, (fluidFX) -> fluidFX.movementSettings, (fluidFX, parent) -> fluidFX.movementSettings = parent.movementSettings).add()).build();
      DEFAULT_FOG_COLOR =  (()-, ()-, ()-);
      DEFAULT_FOG_DISTANCE =  []{, };
      DEFAULT_COLORS_FILTER =  []{, , };
      EMPTY_FLUID_FX = getUnknownFor();
      VALIDATOR_CACHE =  <String>( (FluidFX::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/fluidfx/config/FluidParticle.java

package com.hypixel.hytale.server.core.asset.type.fluidfx.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.Color;
import com.hypixel.hytale.server.core.asset.type.particle.config.ParticleSystem;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.lang.ref.SoftReference;
import javax.annotation.Nonnull;

public class FluidParticle implements NetworkSerializable<com.hypixel.hytale.protocol.FluidParticle> {
   public static final BuilderCodec<FluidParticle> CODEC;
   protected String systemId;
   protected Color color;
   protected float scale = 1.0F;
   private SoftReference<com.hypixel.hytale.protocol.FluidParticle> cachedPacket;

   public FluidParticle(String systemId, Color color, float scale) {
      this.systemId = systemId;
      this.color = color;
      this.scale = scale;
   }

   protected FluidParticle() {
   }

   public String getSystemId {
       .systemId;
   }

    Color  {
       .color;
   }

      {
       .scale;
   }

   
    com.hypixel.hytale.protocol.FluidParticle  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.FluidParticle).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.FluidParticle();
         packet.systemId = .systemId;
         packet.color = .color;
         packet.scale = .scale;
         .cachedPacket =  (packet);
          packet;
      }
   }

   
    String  {
         .systemId;
        + var10000 +  + String.valueOf(.color) +  + .scale + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(FluidParticle.class, FluidParticle::).documentation()).append( (, Codec.STRING), (particle, s) -> particle.systemId = s, (particle) -> particle.systemId).documentation().addValidator(Validators.nonNull()).addValidator(ParticleSystem.VALIDATOR_CACHE.getValidator()).add()).append( (, ProtocolCodecs.COLOR), (particle, o) -> particle.color = o, (particle) -> particle.color).documentation().add()).append( (, Codec.FLOAT), (particle, f) -> particle.scale = f, (particle) -> particle.scale).documentation().add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/gamemode/GameModeType.java

package com.hypixel.hytale.server.core.asset.type.gamemode;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.common.util.ArrayUtil;
import com.hypixel.hytale.protocol.GameMode;
import com.hypixel.hytale.server.core.modules.interaction.interaction.config.RootInteraction;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class GameModeType implements JsonAssetWithMap<String, DefaultAssetMap<String, GameModeType>> {
   @Nonnull
   public static final AssetBuilderCodec<String, GameModeType> CODEC;
   private static AssetStore<String, GameModeType, DefaultAssetMap<String, GameModeType>> ASSET_STORE;
   @Nonnull
   public static final ValidatorCache<String> VALIDATOR_CACHE;
   protected AssetExtraInfo.Data data;
   protected String id;
   private String[] permissionGroups;
   private String interactionsOnEnter;

   
     AssetStore<String, GameModeType, DefaultAssetMap<String, GameModeType>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, GameModeType, DefaultAssetMap<String, GameModeType>>getAssetStore(GameModeType.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, GameModeType>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

   
     GameModeType  {
         (GameModeType)((DefaultAssetMap)getAssetStore().getAssetMap()).getAsset(gameMode.name());
       type ==  ?  () : type;
   }

     {
   }

   
    String  {
       .interactionsOnEnter;
   }

   
    String[] getPermissionGroups() {
       .permissionGroups ==  ? ArrayUtil.EMPTY_STRING_ARRAY : .permissionGroups;
   }

    String  {
       .id;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(GameModeType.class, GameModeType::, Codec.STRING, (gmType, s) -> gmType.id = s, (gmType) -> gmType.id, (gmType, data) -> gmType.data = data, (gmType) -> gmType.data).append( (, Codec.STRING_ARRAY), (gmType, o) -> gmType.permissionGroups = o, (gmType) -> gmType.permissionGroups).add()).append( (, RootInteraction.CHILD_ASSET_CODEC), (gmType, interactions) -> gmType.interactionsOnEnter = interactions, (gmType) -> gmType.interactionsOnEnter).addValidatorLate(() -> RootInteraction.VALIDATOR_CACHE.getValidator().late()).add()).build();
      VALIDATOR_CACHE =  <String>( (GameModeType::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/gameplay/BrokenPenalties.java

package com.hypixel.hytale.server.core.asset.type.gameplay;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import javax.annotation.Nonnull;

public class BrokenPenalties {
   public static final BrokenPenalties DEFAULT = new BrokenPenalties();
   @Nonnull
   public static final BuilderCodec<BrokenPenalties> CODEC;
   private Double tool;
   private Double armor;
   private Double weapon;

   public BrokenPenalties() {
   }

   public double getTool(double defaultValue) {
      return this.tool == null ? defaultValue : this.tool;
   }

   public double getArmor(double defaultValue) {
      return this.armor == null ? defaultValue : this.armor;
   }

   public double  {
       .weapon ==  ? defaultValue : .weapon;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(BrokenPenalties.class, BrokenPenalties::).addField( (, Codec.DOUBLE), (o, i) -> o.tool = i, (o) -> o.tool)).addField( (, Codec.DOUBLE), (o, i) -> o.armor = i, (o) -> o.armor)).addField( (, Codec.DOUBLE), (o, i) -> o.weapon = i, (o) -> o.weapon)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/gameplay/CameraEffectsConfig.java

package com.hypixel.hytale.server.core.asset.type.gameplay;

import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.server.core.asset.type.camera.CameraEffect;
import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
import it.unimi.dsi.fastutil.ints.Int2IntMap;
import it.unimi.dsi.fastutil.ints.Int2IntMaps;
import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.Nonnull;

public class CameraEffectsConfig {
   @Nonnull
   public static final BuilderCodec<CameraEffectsConfig> CODEC;
   protected Map<String, String> damageEffectIds;
   @Nonnull
   protected transient Int2IntMap damageEffectIndices;

   public CameraEffectsConfig() {
      this.damageEffectIndices = Int2IntMaps.EMPTY_MAP;
   }

   public int getCameraEffectIndex(int damageCauseIndex) {
      return this.damageEffectIndices.getOrDefault(damageCauseIndex, -2147483648);
   }

   static {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(CameraEffectsConfig.class, CameraEffectsConfig::new).appendInherited( (,  (CameraEffect.CHILD_ASSET_CODEC, HashMap::)), (config, damageEffectIds) -> config.damageEffectIds = damageEffectIds, (config) -> config.damageEffectIds, (config, parent) -> config.damageEffectIds = parent.damageEffectIds).addValidator(DamageCause.VALIDATOR_CACHE.getMapKeyValidator()).addValidator(CameraEffect.VALIDATOR_CACHE.getMapValueValidator()).documentation().add()).afterDecode((config) -> {
          (config.damageEffectIds != ) {
            config.damageEffectIndices =  ();

            (Map.Entry<String, String> entry : config.damageEffectIds.entrySet()) {
                  DamageCause.getAssetMap().getIndex((String)entry.getKey());
                  CameraEffect.getAssetMap().getIndex((String)entry.getValue());
               config.damageEffectIndices.put(key, effectIndex);
            }
         }

      })).build();
   }
}

com/hypixel/hytale/server/core/asset/type/gameplay/CombatConfig.java

package com.hypixel.hytale.server.core.asset.type.gameplay;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.server.core.asset.type.entityeffect.config.EntityEffect;
import java.time.Duration;
import javax.annotation.Nonnull;

public class CombatConfig {
   @Nonnull
   public static final BuilderCodec<CombatConfig> CODEC;
   @Nonnull
   protected Duration outOfCombatDelay = Duration.ofMillis(5000L);
   protected String staminaBrokenEffectId = "Stamina_Broken";
   private int staminaBrokenEffectIndex;
   protected boolean displayHealthBars = true;
   protected boolean displayCombatText = true;
   protected boolean disableNpcIncomingDamage = false;
   protected boolean   ;

     {
      .staminaBrokenEffectIndex = EntityEffect.getAssetMap().getIndex(.staminaBrokenEffectId);
   }

   
    Duration  {
       .outOfCombatDelay;
   }

      {
       .staminaBrokenEffectIndex;
   }

      {
       .displayHealthBars;
   }

      {
       .displayCombatText;
   }

      {
       .disableNpcIncomingDamage;
   }

      {
       .disablePlayerIncomingDamage;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(CombatConfig.class, CombatConfig::).appendInherited( (, Codec.DURATION_SECONDS), (combatConfig, v) -> combatConfig.outOfCombatDelay = v, (combatConfig) -> combatConfig.outOfCombatDelay, (combatConfig, parent) -> combatConfig.outOfCombatDelay = parent.outOfCombatDelay).documentation().addValidator(Validators.greaterThanOrEqual(Duration.ZERO)).add()).appendInherited( (, Codec.STRING), (combatConfig, s) -> combatConfig.staminaBrokenEffectId = s, (combatConfig) -> combatConfig.staminaBrokenEffectId, (combatConfig, parent) -> combatConfig.staminaBrokenEffectId = parent.staminaBrokenEffectId).documentation().addValidator(Validators.nonNull()).addValidator(EntityEffect.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, Codec.BOOLEAN), (combatConfig, v) -> combatConfig.displayHealthBars = v, (combatConfig) -> combatConfig.displayHealthBars, (combatConfig, parent) -> combatConfig.displayHealthBars = parent.displayHealthBars).documentation().add()).appendInherited( (, Codec.BOOLEAN), (combatConfig, v) -> combatConfig.displayCombatText = v, (combatConfig) -> combatConfig.displayCombatText, (combatConfig, parent) -> combatConfig.displayCombatText = parent.displayCombatText).documentation().add()).afterDecode((combatConfig) -> combatConfig.staminaBrokenEffectIndex = EntityEffect.getAssetMap().getIndex(combatConfig.staminaBrokenEffectId))).appendInherited( (, Codec.BOOLEAN), (combatConfig, v) -> combatConfig.disableNpcIncomingDamage = v, (combatConfig) -> combatConfig.disableNpcIncomingDamage, (combatConfig, parent) -> combatConfig.disableNpcIncomingDamage = parent.disableNpcIncomingDamage).documentation().add()).appendInherited( (, Codec.BOOLEAN), (combatConfig, v) -> combatConfig.disablePlayerIncomingDamage = v, (combatConfig) -> combatConfig.disablePlayerIncomingDamage, (combatConfig, parent) -> combatConfig.disablePlayerIncomingDamage = parent.disablePlayerIncomingDamage).documentation().add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/gameplay/CraftingConfig.java

package com.hypixel.hytale.server.core.asset.type.gameplay;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import javax.annotation.Nonnull;

public class CraftingConfig {
   @Nonnull
   public static final BuilderCodec<CraftingConfig> CODEC;
   protected int benchMaterialHorizontalChestSearchRadius = 14;
   protected int benchMaterialVerticalChestSearchRadius = 6;
   protected int benchMaterialChestLimit = 100;

   public CraftingConfig() {
   }

   public int getBenchMaterialHorizontalChestSearchRadius() {
      return this.benchMaterialHorizontalChestSearchRadius;
   }

   public int getBenchMaterialVerticalChestSearchRadius() {
      return this.benchMaterialVerticalChestSearchRadius;
   }

   public int  {
       .benchMaterialChestLimit;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(CraftingConfig.class, CraftingConfig::).appendInherited( (, Codec.INTEGER), (gameplayConfig, o) -> gameplayConfig.benchMaterialHorizontalChestSearchRadius = o, (gameplayConfig) -> gameplayConfig.benchMaterialHorizontalChestSearchRadius, (gameplayConfig, parent) -> gameplayConfig.benchMaterialHorizontalChestSearchRadius = parent.benchMaterialHorizontalChestSearchRadius).addValidator(Validators.range(, )).documentation().add()).appendInherited( (, Codec.INTEGER), (gameplayConfig, o) -> gameplayConfig.benchMaterialVerticalChestSearchRadius = o, (gameplayConfig) -> gameplayConfig.benchMaterialVerticalChestSearchRadius, (gameplayConfig, parent) -> gameplayConfig.benchMaterialVerticalChestSearchRadius = parent.benchMaterialVerticalChestSearchRadius).addValidator(Validators.range(, )).documentation().add()).appendInherited( (, Codec.INTEGER), (gameplayConfig, o) -> gameplayConfig.benchMaterialChestLimit = o, (gameplayConfig) -> gameplayConfig.benchMaterialChestLimit, (gameplayConfig, parent) -> gameplayConfig.benchMaterialChestLimit = parent.benchMaterialChestLimit).addValidator(Validators.range(, )).documentation().add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/gameplay/DeathConfig.java

package com.hypixel.hytale.server.core.asset.type.gameplay;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.server.core.asset.type.gameplay.respawn.HomeOrSpawnPoint;
import com.hypixel.hytale.server.core.asset.type.gameplay.respawn.RespawnController;
import javax.annotation.Nonnull;

public class DeathConfig {
   public static final EnumCodec<ItemsLossMode> LOSS_MODE_CODEC = new EnumCodec<ItemsLossMode>(ItemsLossMode.class);
   @Nonnull
   public static final BuilderCodec<DeathConfig> CODEC;
   @Nonnull
   protected RespawnController respawnController;
   protected ItemsLossMode itemsLossMode;
   protected double itemsAmountLossPercentage;
   protected double itemsDurabilityLossPercentage;

   public DeathConfig() {
      this.respawnController = HomeOrSpawnPoint.INSTANCE;
      this.itemsLossMode = DeathConfig.ItemsLossMode.NONE;
      this.itemsAmountLossPercentage = 10.0;
      this.itemsDurabilityLossPercentage = 10.0;
   }

   @Nonnull
    RespawnController  {
       .respawnController;
   }

    ItemsLossMode  {
       .itemsLossMode;
   }

      {
       .itemsAmountLossPercentage;
   }

      {
       .itemsDurabilityLossPercentage;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(DeathConfig.class, DeathConfig::).appendInherited( (, RespawnController.CODEC), (o, i) -> o.respawnController = i, (o) -> o.respawnController, (o, p) -> o.respawnController = p.respawnController).addValidator(Validators.nonNull()).documentation().add()).appendInherited( (, LOSS_MODE_CODEC), (deathConfig, o) -> deathConfig.itemsLossMode = o, (deathConfig) -> deathConfig.itemsLossMode, (o, p) -> o.itemsLossMode = p.itemsLossMode).documentation().add()).appendInherited( (, Codec.DOUBLE), (deathConfig, aDouble) -> deathConfig.itemsAmountLossPercentage = aDouble, (deathConfig) -> deathConfig.itemsAmountLossPercentage, (deathConfig, parent) -> deathConfig.itemsAmountLossPercentage = parent.itemsAmountLossPercentage).addValidator(Validators.range(, )).documentation().add()).appendInherited( (, Codec.DOUBLE), (deathConfig, aDouble) -> deathConfig.itemsDurabilityLossPercentage = aDouble, (deathConfig) -> deathConfig.itemsDurabilityLossPercentage, (deathConfig, parent) -> deathConfig.itemsDurabilityLossPercentage = parent.itemsDurabilityLossPercentage).addValidator(Validators.range(, )).documentation().add()).build();
   }

       {
      NONE,
      ALL,
      CONFIGURED;

        {
      }
   }
}

com/hypixel/hytale/server/core/asset/type/gameplay/GameplayConfig.java

package com.hypixel.hytale.server.core.asset.type.gameplay;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.lookup.MapKeyMapCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemEntityConfig;
import com.hypixel.hytale.server.core.asset.type.soundset.config.SoundSet;
import javax.annotation.Nonnull;

public class GameplayConfig implements JsonAssetWithMap<String, DefaultAssetMap<String, GameplayConfig>> {
   public static final String DEFAULT_ID = "Default";
   public static final GameplayConfig DEFAULT = new GameplayConfig();
   @Nonnull
   public static  MapKeyMapCodec<Object> PLUGIN_CODEC =  <Object>();
   
      AssetBuilderCodec<String, GameplayConfig> CODEC;
     AssetStore<String, GameplayConfig, DefaultAssetMap<String, GameplayConfig>> ASSET_STORE;
   
      ValidatorCache<String> VALIDATOR_CACHE;
    AssetExtraInfo.Data data;
    String id;
        ();
        ();
        ();
        ();
        ();
        ();
        ();
        ();
    MapKeyMapCodec.TypeMap<Object> pluginConfig = MapKeyMapCodec.TypeMap.<Object>empty();
        ();
        ();
        ();
        ();
    String creativePlaySoundSet;
       ;
      creativePlaySoundSetIndex;
       ;

     {
   }

     AssetStore<String, GameplayConfig, DefaultAssetMap<String, GameplayConfig>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, GameplayConfig, DefaultAssetMap<String, GameplayConfig>>getAssetStore(GameplayConfig.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, GameplayConfig>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

    GatheringConfig  {
       .gatheringConfig;
   }

    WorldConfig  {
       .worldConfig;
   }

    WorldMapConfig  {
       .worldMapConfig;
   }

    DeathConfig  {
       .deathConfig;
   }

      {
       .showItemPickupNotifications;
   }

    ItemDurabilityConfig  {
       .itemDurabilityConfig;
   }

    ItemEntityConfig  {
       .itemEntityConfig;
   }

    RespawnConfig  {
       .respawnConfig;
   }

    CombatConfig  {
       .combatConfig;
   }

    MapKeyMapCodec.TypeMap<Object>  {
       .pluginConfig;
   }

    PlayerConfig  {
       .playerConfig;
   }

    CameraEffectsConfig  {
       .cameraEffectsConfig;
   }

    String  {
       .creativePlaySoundSet;
   }

      {
       .creativePlaySoundSetIndex;
   }

    CraftingConfig  {
       .craftingConfig;
   }

      {
       .maxEnvironmentalNPCSpawns;
   }

   
    SpawnConfig  {
       .spawnConfig;
   }

      {
       (.creativePlaySoundSet != ) {
         .creativePlaySoundSetIndex = SoundSet.getAssetMap().getIndex(.creativePlaySoundSet);
      }

   }

    String  {
       .id;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(GameplayConfig.class, GameplayConfig::, Codec.STRING, (gameplayConfig, s) -> gameplayConfig.id = s, GameplayConfig::getId, (asset, data) -> asset.data = data, (asset) -> asset.data).appendInherited( (, GatheringConfig.CODEC), (gameplayConfig, o) -> gameplayConfig.gatheringConfig = o, (gameplayConfig) -> gameplayConfig.gatheringConfig, (gameplayConfig, parent) -> gameplayConfig.gatheringConfig = parent.gatheringConfig).add()).appendInherited( (, WorldConfig.CODEC), (gameplayConfig, o) -> gameplayConfig.worldConfig = o, (gameplayConfig) -> gameplayConfig.worldConfig, (gameplayConfig, parent) -> gameplayConfig.worldConfig = parent.worldConfig).add()).appendInherited( (, WorldMapConfig.CODEC), (gameplayConfig, o) -> gameplayConfig.worldMapConfig = o, (gameplayConfig) -> gameplayConfig.worldMapConfig, (gameplayConfig, parent) -> gameplayConfig.worldMapConfig = parent.worldMapConfig).add()).appendInherited( (, DeathConfig.CODEC), (gameplayConfig, o) -> gameplayConfig.deathConfig = o, (gameplayConfig) -> gameplayConfig.deathConfig, (gameplayConfig, parent) -> gameplayConfig.deathConfig = parent.deathConfig).add()).appendInherited( (, RespawnConfig.CODEC), (gameplayConfig, o) -> gameplayConfig.respawnConfig = o, (gameplayConfig) -> gameplayConfig.respawnConfig, (gameplayConfig, parent) -> gameplayConfig.respawnConfig = parent.respawnConfig).add()).appendInherited( (, Codec.BOOLEAN), (gameplayConfig, showItemPickupNotifications) -> gameplayConfig.showItemPickupNotifications = showItemPickupNotifications, (gameplayConfig) -> gameplayConfig.showItemPickupNotifications, (gameplayConfig, parent) -> gameplayConfig.showItemPickupNotifications = parent.showItemPickupNotifications).add()).appendInherited( (, ItemDurabilityConfig.CODEC), (gameplayConfig, o) -> gameplayConfig.itemDurabilityConfig = o, (gameplayConfig) -> gameplayConfig.itemDurabilityConfig, (gameplayConfig, parent) -> gameplayConfig.itemDurabilityConfig = parent.itemDurabilityConfig).add()).appendInherited( (, ItemEntityConfig.CODEC), (gameplayConfig, itemEntityConfig) -> gameplayConfig.itemEntityConfig = itemEntityConfig, (gameplayConfig) -> gameplayConfig.itemEntityConfig, (gameplayConfig, parent) -> gameplayConfig.itemEntityConfig = parent.itemEntityConfig).add()).appendInherited( (, CombatConfig.CODEC), (gameplayConfig, combatConfig) -> gameplayConfig.combatConfig = combatConfig, (gameplayConfig) -> gameplayConfig.combatConfig, (gameplayConfig, parent) -> gameplayConfig.combatConfig = parent.combatConfig).add()).appendInherited( (, PLUGIN_CODEC), (o, i) -> {
          (o.pluginConfig.isEmpty()) {
            o.pluginConfig = i;
         }  {
            MapKeyMapCodec.TypeMap<Object> temp = o.pluginConfig;
            o.pluginConfig =  .TypeMap<Object>(PLUGIN_CODEC);
            o.pluginConfig.putAll(temp);
            o.pluginConfig.putAll(i);
         }
      }, (o) -> o.pluginConfig, (o, p) -> o.pluginConfig = p.pluginConfig).addValidator(Validators.nonNull()).add()).appendInherited( (, PlayerConfig.CODEC), (gameplayConfig, playerConfig) -> gameplayConfig.playerConfig = playerConfig, (gameplayConfig) -> gameplayConfig.playerConfig, (gameplayConfig, parent) -> gameplayConfig.playerConfig = parent.playerConfig).add()).appendInherited( (, CameraEffectsConfig.CODEC), (o, i) -> o.cameraEffectsConfig = i, (o) -> o.cameraEffectsConfig, (o, p) -> o.cameraEffectsConfig = p.cameraEffectsConfig).addValidator(Validators.nonNull()).add()).appendInherited( (, SoundSet.CHILD_ASSET_CODEC), (o, i) -> o.creativePlaySoundSet = i, (o) -> o.creativePlaySoundSet, (o, p) -> o.creativePlaySoundSet = p.creativePlaySoundSet).addValidator(SoundSet.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, CraftingConfig.CODEC), (gameplayConfig, o) -> gameplayConfig.craftingConfig = o, (gameplayConfig) -> gameplayConfig.craftingConfig, (gameplayConfig, parent) -> gameplayConfig.craftingConfig = parent.craftingConfig).add()).appendInherited( (, SpawnConfig.CODEC), (o, v) -> o.spawnConfig = v, (o) -> o.spawnConfig, (o, p) -> o.spawnConfig = p.spawnConfig).add()).appendInherited( (, Codec.INTEGER), (o, v) -> o.maxEnvironmentalNPCSpawns = v, (o) -> o.maxEnvironmentalNPCSpawns, (o, p) -> o.maxEnvironmentalNPCSpawns = p.maxEnvironmentalNPCSpawns).documentation().add()).afterDecode(GameplayConfig::processConfig)).build();
      VALIDATOR_CACHE =  <String>( (GameplayConfig::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/gameplay/GatheringConfig.java

package com.hypixel.hytale.server.core.asset.type.gameplay;

import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import javax.annotation.Nonnull;

public class GatheringConfig {
   @Nonnull
   public static final BuilderCodec<GatheringConfig> CODEC;
   @Nonnull
   protected GatheringEffectsConfig unbreakableBlockConfig = new GatheringEffectsConfig();
   @Nonnull
   protected GatheringEffectsConfig incorrectToolConfig = new GatheringEffectsConfig();

   public GatheringConfig() {
   }

   @Nonnull
   public GatheringEffectsConfig getUnbreakableBlockConfig() {
      return this.unbreakableBlockConfig;
   }

   @Nonnull
   public GatheringEffectsConfig getIncorrectToolConfig() {
      return this.incorrectToolConfig;
   }

   static {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(GatheringConfig.class, GatheringConfig::new).appendInherited(new (, GatheringEffectsConfig.CODEC), (gameplayConfig, o) -> gameplayConfig.unbreakableBlockConfig = o, (gameplayConfig) -> gameplayConfig.unbreakableBlockConfig, (gameplayConfig, parent) -> gameplayConfig.unbreakableBlockConfig = parent.unbreakableBlockConfig).add()).appendInherited( (, GatheringEffectsConfig.CODEC), (gameplayConfig, o) -> gameplayConfig.incorrectToolConfig = o, (gameplayConfig) -> gameplayConfig.incorrectToolConfig, (gameplayConfig, parent) -> gameplayConfig.incorrectToolConfig = parent.incorrectToolConfig).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/gameplay/GatheringEffectsConfig.java

package com.hypixel.hytale.server.core.asset.type.gameplay;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.server.core.asset.type.particle.config.ParticleSystem;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
import javax.annotation.Nonnull;

public class GatheringEffectsConfig {
   @Nonnull
   public static final BuilderCodec<GatheringEffectsConfig> CODEC;
   protected String particleSystemId;
   protected String soundEventId;
   protected transient int soundEventIndex;

   public GatheringEffectsConfig() {
   }

   public String getParticleSystemId() {
      return this.particleSystemId;
   }

   public String getSoundEventId() {
      return this.soundEventId;
   }

   public int getSoundEventIndex() {
      return this.soundEventIndex;
   }

   protected void processConfig() {
       (.soundEventId != ) {
         .soundEventIndex = SoundEvent.getAssetMap().getIndex(.soundEventId);
      }

   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(GatheringEffectsConfig.class, GatheringEffectsConfig::).append( (, Codec.STRING), (unbreakableBlockConfig, o) -> unbreakableBlockConfig.particleSystemId = o, (unbreakableBlockConfig) -> unbreakableBlockConfig.particleSystemId).addValidator(ParticleSystem.VALIDATOR_CACHE.getValidator()).add()).append( (, Codec.STRING), (unbreakableBlockConfig, o) -> unbreakableBlockConfig.soundEventId = o, (unbreakableBlockConfig) -> unbreakableBlockConfig.soundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).add()).afterDecode(GatheringEffectsConfig::processConfig)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/gameplay/ItemDurabilityConfig.java

package com.hypixel.hytale.server.core.asset.type.gameplay;

import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import javax.annotation.Nonnull;

public class ItemDurabilityConfig {
   @Nonnull
   public static final BuilderCodec<ItemDurabilityConfig> CODEC;
   @Nonnull
   protected BrokenPenalties brokenPenalties;

   public ItemDurabilityConfig() {
      this.brokenPenalties = BrokenPenalties.DEFAULT;
   }

   @Nonnull
   public BrokenPenalties getBrokenPenalties() {
      return this.brokenPenalties;
   }

   static {
      CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(ItemDurabilityConfig.class, ItemDurabilityConfig::new).appendInherited(new KeyedCodec("BrokenPenalties", BrokenPenalties.CODEC), (itemDurabilityConfig, itemTypeDoubleMap) -> itemDurabilityConfig.brokenPenalties = itemTypeDoubleMap, (itemDurabilityConfig) -> itemDurabilityConfig.brokenPenalties, (o, p) -> o.brokenPenalties = p.brokenPenalties).addValidator(Validators.nonNull()).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/gameplay/PlayerConfig.java

package com.hypixel.hytale.server.core.asset.type.gameplay;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.server.core.entity.entities.player.movement.MovementConfig;
import com.hypixel.hytale.server.core.modules.entity.hitboxcollision.HitboxCollisionConfig;
import com.hypixel.hytale.server.core.modules.entity.repulsion.RepulsionConfig;
import javax.annotation.Nonnull;

public class PlayerConfig {
   @Nonnull
   public static final BuilderCodec<PlayerConfig> CODEC;
   protected String hitboxCollisionConfigId;
   protected String repulsionConfigId;
   protected String movementConfigId = "BuiltinDefault";
   protected int hitboxCollisionConfigIndex = -1;
   protected int repulsionConfigIndex = -1;
   protected int movementConfigIndex = 0;
   protected int maxDeployableEntities = -1;

   public PlayerConfig {
   }

      {
       .hitboxCollisionConfigIndex;
   }

      {
       .repulsionConfigIndex;
   }

      {
       .movementConfigIndex;
   }

    String  {
       .movementConfigId;
   }

      {
       .maxDeployableEntities;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(PlayerConfig.class, PlayerConfig::).appendInherited( (, Codec.STRING), (playerConfig, s) -> playerConfig.hitboxCollisionConfigId = s, (playerConfig) -> playerConfig.hitboxCollisionConfigId, (playerConfig, parent) -> playerConfig.hitboxCollisionConfigId = parent.hitboxCollisionConfigId).documentation().addValidator(HitboxCollisionConfig.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, Codec.STRING), (playerConfig, s) -> playerConfig.repulsionConfigId = s, (playerConfig) -> playerConfig.repulsionConfigId, (playerConfig, parent) -> playerConfig.repulsionConfigId = parent.repulsionConfigId).documentation().addValidator(RepulsionConfig.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, Codec.STRING), (playerConfig, s) -> playerConfig.movementConfigId = s, (playerConfig) -> playerConfig.movementConfigId, (playerConfig, parent) -> playerConfig.movementConfigId = parent.movementConfigId).addValidator(MovementConfig.VALIDATOR_CACHE.getValidator()).documentation().add()).appendInherited( (, Codec.INTEGER), (playerConfig, s) -> playerConfig.maxDeployableEntities = s, (playerConfig) -> playerConfig.maxDeployableEntities, (playerConfig, parent) -> playerConfig.maxDeployableEntities = parent.maxDeployableEntities).add()).afterDecode((playerConfig) -> {
          (playerConfig.hitboxCollisionConfigId != ) {
            playerConfig.hitboxCollisionConfigIndex = HitboxCollisionConfig.getAssetMap().getIndexOrDefault(playerConfig.hitboxCollisionConfigId, -);
         }

          (playerConfig.repulsionConfigId != ) {
            playerConfig.repulsionConfigIndex = RepulsionConfig.getAssetMap().getIndexOrDefault(playerConfig.repulsionConfigId, -);
         }

          (playerConfig.movementConfigId != ) {
            playerConfig.movementConfigIndex = MovementConfig.getAssetMap().getIndexOrDefault(playerConfig.movementConfigId, );
         }

      })).build();
   }
}

com/hypixel/hytale/server/core/asset/type/gameplay/RespawnConfig.java

package com.hypixel.hytale.server.core.asset.type.gameplay;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import javax.annotation.Nonnull;

public class RespawnConfig {
   @Nonnull
   public static BuilderCodec<RespawnConfig> CODEC;
   protected int radiusLimitRespawnPoint = 500;
   protected int maxRespawnPointsPerPlayer = 3;

   public RespawnConfig() {
   }

   public int getRadiusLimitRespawnPoint() {
      return this.radiusLimitRespawnPoint;
   }

   public int getMaxRespawnPointsPerPlayer() {
      return this.maxRespawnPointsPerPlayer;
   }

   static {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(RespawnConfig.class, RespawnConfig::new).append(new KeyedCodec("RadiusLimitRespawnPoint", Codec.INTEGER), (worldConfig, integer) -> worldConfig.radiusLimitRespawnPoint = integer, (worldConfig) -> worldConfig.radiusLimitRespawnPoint).addValidator(Validators.greaterThan()).add()).append( (, Codec.INTEGER), (worldConfig, integer) -> worldConfig.maxRespawnPointsPerPlayer = integer, (worldConfig) -> worldConfig.maxRespawnPointsPerPlayer).addValidator(Validators.greaterThan()).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/gameplay/SleepConfig.java

package com.hypixel.hytale.server.core.asset.type.gameplay;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import java.time.Duration;
import java.time.LocalDateTime;
import java.time.LocalTime;
import javax.annotation.Nullable;

public class SleepConfig {
   public static final BuilderCodec<SleepConfig> CODEC;
   public static final SleepConfig DEFAULT;
   private float wakeUpHour = 5.5F;
   private double[] allowedSleepHoursRange;

   public SleepConfig() {
   }

   public float getWakeUpHour() {
      return this.wakeUpHour;
   }

   @Nullable
   public double[] getAllowedSleepHoursRange() {
      return this.allowedSleepHoursRange;
   }

   @Nullable
   public LocalTime getSleepStartTime() {
      if (.allowedSleepHoursRange == ) {
          ;
      }  {
            .allowedSleepHoursRange[];
            ()sleepStartHour;
            ()((sleepStartHour - ()hour) * );
          LocalTime.of(hour, minute);
      }
   }

      {
       (.allowedSleepHoursRange == ) {
          ;
      }  {
            getFractionalHourOfDay(gameTime);
            .allowedSleepHoursRange[];
            .allowedSleepHoursRange[];
          (()hour - min + ) %  <= (max - min + ) % ;
      }
   }

    Duration  {
       (.allowedSleepHoursRange == ) {
          Duration.ZERO;
      }  {
            getFractionalHourOfDay(now);
            .allowedSleepHoursRange[];
            (sleepStartHour - ()currentHour + ) % ;
            ()(hoursUntilSleep * );
          Duration.ofSeconds(seconds);
      }
   }

       {
       ()dateTime.getHour() + ()dateTime.getMinute() /  + ()dateTime.getSecond() / ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(SleepConfig.class, SleepConfig::).append( (, Codec.FLOAT), (sleepConfig, i) -> sleepConfig.wakeUpHour = i, (o) -> o.wakeUpHour).documentation().add()).append( (, Codec.DOUBLE_ARRAY), (sleepConfig, i) -> sleepConfig.allowedSleepHoursRange = i, (o) -> o.allowedSleepHoursRange).addValidator(Validators.doubleArraySize()).documentation().add()).build();
      DEFAULT =  ();
   }
}

com/hypixel/hytale/server/core/asset/type/gameplay/SpawnConfig.java

package com.hypixel.hytale.server.core.asset.type.gameplay;

import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.server.core.asset.type.particle.config.WorldParticle;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class SpawnConfig {
   @Nonnull
   public static final BuilderCodec<SpawnConfig> CODEC;
   protected WorldParticle[] firstSpawnParticles;
   protected WorldParticle[] spawnParticles;

   public SpawnConfig() {
   }

   @Nullable
   public WorldParticle[] getFirstSpawnParticles() {
      return this.firstSpawnParticles;
   }

   @Nullable
   public WorldParticle[] getSpawnParticles() {
      return this.spawnParticles;
   }

   static {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(SpawnConfig.class, SpawnConfig::new).appendInherited(new KeyedCodec("FirstSpawnParticles", new ArrayCodec(WorldParticle.CODEC, (x$0) -> new WorldParticle[x$0])), (o, v) -> o.firstSpawnParticles = v, (o) -> o.firstSpawnParticles, (o, p) -> o.firstSpawnParticles = p.firstSpawnParticles).add()).appendInherited( (,  (WorldParticle.CODEC, (x$) ->  [x$])), (o, v) -> o.spawnParticles = v, (o) -> o.spawnParticles, (o, p) -> o.spawnParticles = p.spawnParticles).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/gameplay/WorldConfig.java

package com.hypixel.hytale.server.core.asset.type.gameplay;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import javax.annotation.Nonnull;

public class WorldConfig {
   @Nonnull
   public static final BuilderCodec<WorldConfig> CODEC;
   public static final int DEFAULT_TOTAL_DAY_DURATION_SECONDS = 2880;
   public static final int DEFAULT_DAYTIME_DURATION_SECONDS = 1728;
   public static final int DEFAULT_NIGHTTIME_DURATION_SECONDS = 1728;
   protected boolean allowBlockBreaking = true;
   protected boolean allowBlockGathering = true;
   protected boolean allowBlockPlacement = true;
   protected    ;
       ;
       ;
     blockPlacementFragilityTimer;
    SleepConfig sleepConfig;

     {
      .sleepConfig = SleepConfig.DEFAULT;
   }

      {
       .allowBlockBreaking;
   }

      {
       .allowBlockGathering;
   }

      {
       .allowBlockPlacement;
   }

      {
       .daytimeDurationSeconds;
   }

      {
       .nighttimeDurationSeconds;
   }

      {
       .totalMoonPhases;
   }

      {
       .blockPlacementFragilityTimer;
   }

    SleepConfig  {
       .sleepConfig;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(WorldConfig.class, WorldConfig::).append( (, Codec.BOOLEAN), (worldConfig, o) -> worldConfig.allowBlockBreaking = o, (worldConfig) -> worldConfig.allowBlockBreaking).add()).append( (, Codec.BOOLEAN), (worldConfig, o) -> worldConfig.allowBlockGathering = o, (worldConfig) -> worldConfig.allowBlockGathering).add()).append( (, Codec.BOOLEAN), (worldConfig, o) -> worldConfig.allowBlockPlacement = o, (worldConfig) -> worldConfig.allowBlockPlacement).add()).append( (, Codec.DOUBLE), (worldConfig, d) -> worldConfig.blockPlacementFragilityTimer = d.floatValue(), (worldConfig) -> ()worldConfig.blockPlacementFragilityTimer).documentation().add()).append( (, Codec.INTEGER), (worldConfig, i) -> worldConfig.daytimeDurationSeconds = i, (worldConfig) -> worldConfig.daytimeDurationSeconds).documentation().add()).append( (, Codec.INTEGER), (worldConfig, i) -> worldConfig.nighttimeDurationSeconds = i, (worldConfig) -> worldConfig.nighttimeDurationSeconds).documentation().add()).append( (, Codec.INTEGER), (worldConfig, i) -> worldConfig.totalMoonPhases = i, (o) -> o.totalMoonPhases).add()).append( (, SleepConfig.CODEC), (worldConfig, sleepConfig) -> worldConfig.sleepConfig = sleepConfig, (o) -> o.sleepConfig).documentation().add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/gameplay/WorldMapConfig.java

package com.hypixel.hytale.server.core.asset.type.gameplay;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import javax.annotation.Nonnull;

public class WorldMapConfig {
   @Nonnull
   public static final BuilderCodec<WorldMapConfig> CODEC;
   protected boolean displaySpawn = true;
   protected boolean displayHome = true;
   protected boolean displayWarps = true;
   protected boolean displayDeathMarker = true;
   protected boolean displayPlayers = true;

   public WorldMapConfig() {
   }

   public boolean isDisplaySpawn() {
      return this.displaySpawn;
   }

   public boolean  {
       .displayHome;
   }

      {
       .displayWarps;
   }

      {
       .displayDeathMarker;
   }

      {
       .displayPlayers;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(WorldMapConfig.class, WorldMapConfig::).addField( (, Codec.BOOLEAN), (worldMapConfig, o) -> worldMapConfig.displaySpawn = o, (worldMapConfig) -> worldMapConfig.displaySpawn)).addField( (, Codec.BOOLEAN), (worldMapConfig, o) -> worldMapConfig.displayHome = o, (worldMapConfig) -> worldMapConfig.displayHome)).addField( (, Codec.BOOLEAN), (worldMapConfig, o) -> worldMapConfig.displayWarps = o, (worldMapConfig) -> worldMapConfig.displayWarps)).addField( (, Codec.BOOLEAN), (worldMapConfig, o) -> worldMapConfig.displayDeathMarker = o, (worldMapConfig) -> worldMapConfig.displayDeathMarker)).addField( (, Codec.BOOLEAN), (worldMapConfig, o) -> worldMapConfig.displayPlayers = o, (worldMapConfig) -> worldMapConfig.displayPlayers)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/gameplay/respawn/HomeOrSpawnPoint.java

package com.hypixel.hytale.server.core.asset.type.gameplay.respawn;

import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.component.CommandBuffer;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.math.vector.Transform;
import com.hypixel.hytale.server.core.entity.entities.Player;
import com.hypixel.hytale.server.core.modules.entity.teleport.Teleport;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import javax.annotation.Nonnull;

public class HomeOrSpawnPoint implements RespawnController {
   @Nonnull
   public static final HomeOrSpawnPoint INSTANCE = new HomeOrSpawnPoint();
   @Nonnull
   public static final BuilderCodec<HomeOrSpawnPoint> CODEC = BuilderCodec.builder(HomeOrSpawnPoint.class, () -> INSTANCE).build();

   public HomeOrSpawnPoint() {
   }

   public void respawnPlayer(@Nonnull World world, @Nonnull Ref<EntityStore> playerReference, @Nonnull CommandBuffer<EntityStore> commandBuffer) {
      Transform homeTransform  Player.getRespawnPosition(playerReference, world.getName(), commandBuffer);
         Teleport.createForPlayer(homeTransform);
      commandBuffer.addComponent(playerReference, Teleport.getComponentType(), teleportComponent);
   }
}

com/hypixel/hytale/server/core/asset/type/gameplay/respawn/RespawnController.java

package com.hypixel.hytale.server.core.asset.type.gameplay.respawn;

import com.hypixel.hytale.codec.lookup.CodecMapCodec;
import com.hypixel.hytale.component.CommandBuffer;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import javax.annotation.Nonnull;

public interface RespawnController {
   @Nonnull
   CodecMapCodec<RespawnController> CODEC = new CodecMapCodec<RespawnController>("Type");

   void respawnPlayer(@Nonnull World var1, @Nonnull Ref<EntityStore> var2, @Nonnull CommandBuffer<EntityStore> var3);
}

com/hypixel/hytale/server/core/asset/type/gameplay/respawn/WorldSpawnPoint.java

package com.hypixel.hytale.server.core.asset.type.gameplay.respawn;

import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.component.CommandBuffer;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.math.vector.Transform;
import com.hypixel.hytale.server.core.modules.entity.teleport.Teleport;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.universe.world.spawn.ISpawnProvider;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import javax.annotation.Nonnull;

public class WorldSpawnPoint implements RespawnController {
   public static final WorldSpawnPoint INSTANCE = new WorldSpawnPoint();
   @Nonnull
   public static final BuilderCodec<WorldSpawnPoint> CODEC = BuilderCodec.builder(WorldSpawnPoint.class, () -> INSTANCE).build();

   public WorldSpawnPoint() {
   }

   public void respawnPlayer(@Nonnull World world, @Nonnull Ref<EntityStore> playerReference, @Nonnull CommandBuffer<EntityStore> commandBuffer) {
      ISpawnProvider spawnProvider = world.getWorldConfig().getSpawnProvider();

       spawnProvider != ;

         spawnProvider.getSpawnPoint(playerReference, commandBuffer);
         Teleport.createForPlayer(spawnPoint);
      commandBuffer.addComponent(playerReference, Teleport.getComponentType(), teleportComponent);
   }
}

com/hypixel/hytale/server/core/asset/type/item/DroplistCommand.java

package com.hypixel.hytale.server.core.asset.type.item;

import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.server.core.Message;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemDropList;
import com.hypixel.hytale.server.core.command.system.CommandContext;
import com.hypixel.hytale.server.core.command.system.arguments.system.OptionalArg;
import com.hypixel.hytale.server.core.command.system.arguments.system.RequiredArg;
import com.hypixel.hytale.server.core.command.system.arguments.types.ArgTypes;
import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.modules.item.ItemModule;
import java.util.LinkedHashMap;
import java.util.Map;
import javax.annotation.Nonnull;

public class DroplistCommand extends CommandBase {
   @Nonnull
   private final RequiredArg<String> itemDroplistArg;
   private final OptionalArg<Integer> countArg;

   public DroplistCommand() {
      super("droplist", "server.commands.droplist.desc");
      this.itemDroplistArg = this.withRequiredArg("droplist", "server.commands.droplist.set.droplist.desc", ArgTypes.STRING);
      this.countArg = (OptionalArg)this.withOptionalArg(, , ArgTypes.INTEGER).addValidator(Validators.greaterThan());
   }

      {
         (String).itemDroplistArg.get(context);
         (ItemDropList)ItemDropList.getAssetMap().getAsset(droplistId);
       (itemDropList == ) {
         context.sendMessage(Message.translation().param(, droplistId));
      }  {
            .countArg.provided(context) ? (Integer).countArg.get(context) : ;
         LinkedHashMap<String, Integer> accumulatedDrops =  ();

         (   ; i < count; ++i) {
            (ItemStack itemStack : ItemModule.get().getRandomItemDrops(droplistId)) {
               accumulatedDrops.merge(itemStack.getItemId(), itemStack.getQuantity(), Integer::sum);
            }
         }

          (accumulatedDrops.isEmpty()) {
            context.sendMessage(Message.translation().param(, droplistId));
         }  {
            context.sendMessage(Message.translation().param(, droplistId));

            (Map.Entry<String, Integer> entry : accumulatedDrops.entrySet()) {
                  Message.translation().param(, (String)entry.getKey()).param(, (Integer)entry.getValue());
               context.sendMessage(message);
            }

         }
      }
   }
}

com/hypixel/hytale/server/core/asset/type/item/FieldcraftCategoryPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.item;

import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.protocol.ItemCategory;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateFieldcraftCategories;
import com.hypixel.hytale.server.core.asset.packet.DefaultAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.item.config.FieldcraftCategory;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class FieldcraftCategoryPacketGenerator extends DefaultAssetPacketGenerator<String, FieldcraftCategory> {
   public FieldcraftCategoryPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull DefaultAssetMap<String, FieldcraftCategory> assetMap, @Nonnull Map<String, FieldcraftCategory> assets) {
      Map<String, FieldcraftCategory> assetsFromMap = assetMap.getAssetMap();
      if (assets.size() != assetsFromMap.size()) {
         throw new UnsupportedOperationException("Item categories can not handle partial init packets!!!");
      } else {
         UpdateFieldcraftCategories packet = new UpdateFieldcraftCategories();
         packet.type = UpdateType.Init;
         ItemCategory[] arr =  [assets.size()];
            ;

         (FieldcraftCategory itemCategory : assets.values()) {
            arr[i++] = itemCategory.toPacket();
         }

         packet.itemCategories = arr;
          packet;
      }
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      ItemCategory[] arr =  [assets.size()];
         ;

      (FieldcraftCategory itemCategory : assets.values()) {
         arr[i++] = itemCategory.toPacket();
      }

      packet.itemCategories = arr;
       packet;
   }

    Packet  {
        ();
   }
}

com/hypixel/hytale/server/core/asset/type/item/ItemCategoryPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.item;

import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateItemCategories;
import com.hypixel.hytale.server.core.asset.packet.DefaultAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemCategory;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class ItemCategoryPacketGenerator extends DefaultAssetPacketGenerator<String, ItemCategory> {
   public ItemCategoryPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull DefaultAssetMap<String, ItemCategory> assetMap, @Nonnull Map<String, ItemCategory> assets) {
      Map<String, ItemCategory> assetsFromMap = assetMap.getAssetMap();
      if (assets.size() != assetsFromMap.size()) {
         throw new UnsupportedOperationException("Item categories can not handle partial init packets!!!");
      } else {
         UpdateItemCategories packet = new UpdateItemCategories();
         packet.type = UpdateType.Init;
         com.hypixel.hytale.protocol.ItemCategory[] arr = new com.hypixel.hytale.protocol.ItemCategory[assets.size()];
            ;

         (ItemCategory itemCategory : assets.values()) {
            arr[i++] = itemCategory.toPacket();
         }

         packet.itemCategories = arr;
          packet;
      }
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      com.hypixel.hytale.protocol.ItemCategory[] arr =  .hypixel.hytale.protocol.ItemCategory[assets.size()];
         ;

      (ItemCategory itemCategory : assets.values()) {
         arr[i++] = itemCategory.toPacket();
      }

      packet.itemCategories = arr;
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      com.hypixel.hytale.protocol.ItemCategory[] arr =  .hypixel.hytale.protocol.ItemCategory[removed.size()];
         ;

      (String id : removed) {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ItemCategory();
         itemCategory.id = id;
         arr[i++] = itemCategory;
      }

      packet.itemCategories = arr;
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/item/ResourceTypePacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.item;

import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateResourceTypes;
import com.hypixel.hytale.server.core.asset.packet.DefaultAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.item.config.ResourceType;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class ResourceTypePacketGenerator extends DefaultAssetPacketGenerator<String, ResourceType> {
   public ResourceTypePacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull DefaultAssetMap<String, ResourceType> assetMap, @Nonnull Map<String, ResourceType> assets) {
      Map<String, ResourceType> assetsFromMap = assetMap.getAssetMap();
      if (assets.size() != assetsFromMap.size()) {
         throw new UnsupportedOperationException("Resource types can not handle partial init packets!!!");
      } else {
         UpdateResourceTypes packet = new UpdateResourceTypes();
         packet.type = UpdateType.Init;
         packet.resourceTypes =  <String, com.hypixel.hytale.protocol.ResourceType>();

         (Map.Entry<String, ResourceType> entry : assets.entrySet()) {
            packet.resourceTypes.put((String)entry.getKey(), ((ResourceType)entry.getValue()).toPacket());
         }

          packet;
      }
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.resourceTypes =  <String, com.hypixel.hytale.protocol.ResourceType>();

      (Map.Entry<String, ResourceType> entry : loadedAssets.entrySet()) {
         packet.resourceTypes.put((String)entry.getKey(), ((ResourceType)entry.getValue()).toPacket());
      }

       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.resourceTypes =  <String, com.hypixel.hytale.protocol.ResourceType>();

      (String key : removed) {
         packet.resourceTypes.put(key, (Object));
      }

       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/AssetIconProperties.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.math.vector.Vector2d;
import com.hypixel.hytale.math.vector.Vector3d;
import com.hypixel.hytale.protocol.Vector2f;
import com.hypixel.hytale.protocol.Vector3f;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class AssetIconProperties implements NetworkSerializable<com.hypixel.hytale.protocol.AssetIconProperties> {
   public static final BuilderCodec<AssetIconProperties> CODEC;
   private float scale;
   @Nullable
   private Vector2f translation;
   @Nullable
   private Vector3f rotation;

   AssetIconProperties() {
   }

   public AssetIconProperties(float scale, Vector2f translation, Vector3f rotation) {
      this.scale = scale;
      this.translation = translation;
      this.rotation = rotation;
   }

   public float getScale() {
      return this.scale;
   }

   @Nullable
    Vector2f  {
       .translation;
   }

   
    Vector3f  {
       .rotation;
   }

   
    com.hypixel.hytale.protocol.AssetIconProperties  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.AssetIconProperties();
      packet.scale = .scale;
      packet.translation = .translation;
      packet.rotation = .rotation;
       packet;
   }

   
    String  {
         .scale;
        + var10000 +  + String.valueOf(.translation) +  + String.valueOf(.rotation) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(AssetIconProperties.class, AssetIconProperties::).addField( (, Codec.DOUBLE), (props, scale) -> props.scale = scale.floatValue(), (props) -> ()props.scale)).addField( (, Vector2d.AS_ARRAY_CODEC), (props, translation) -> props.translation = translation ==  ?  :  (()translation.getX(), ()translation.getY()), (props) -> props.translation ==  ?  :  (()props.translation.x, ()props.translation.y))).addField( (, Vector3d.AS_ARRAY_CODEC), (props, rot) -> props.rotation = rot ==  ?  :  (()rot.getX(), ()rot.getY(), ()rot.getZ()), (props) -> props.rotation ==  ?  :  (()props.rotation.x, ()props.rotation.y, ()props.rotation.z))).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/BlockGroup.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.codec.AssetCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.common.util.ArrayUtil;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

/** @deprecated */
@Deprecated
public class BlockGroup implements JsonAssetWithMap<String, DefaultAssetMap<String, BlockGroup>>, NetworkSerializable<com.hypixel.hytale.protocol.BlockGroup> {
   private static final String[] DEFAULT_BLOCK_LIST = new String[0];
   public static final AssetCodec<String, BlockGroup> CODEC;
   private String id;
   private AssetExtraInfo.Data data;
   private String[] blocks;

   public BlockGroup() {
      this.blocks = DEFAULT_BLOCK_LIST;
   }

   @Nullable
     BlockGroup  {
         item.getBlockId();
       (blockId == ) {
          ;
      }  {
         (BlockGroup group : ((DefaultAssetMap)AssetRegistry.getAssetStore(BlockGroup.class).getAssetMap()).getAssetMap().values()) {
             (ArrayUtil.contains(group.blocks, blockId)) {
                group;
            }
         }

          ;
      }
   }

    String  {
       .id;
   }

    String  {
       .blocks[index];
   }

      {
       .blocks.length;
   }

      {
         item.getBlockId();
       ArrayUtil.indexOf(.blocks, id);
   }

   
    com.hypixel.hytale.protocol.BlockGroup  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.BlockGroup();
      packet.names = .blocks;
       packet;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(BlockGroup.class, BlockGroup::, Codec.STRING, (t, k) -> t.id = k, (t) -> t.id, (asset, data) -> asset.data = data, (asset) -> asset.data).addField( (, Codec.STRING_ARRAY), (blockSet, strings) -> blockSet.blocks = strings, (blockSet) -> blockSet.blocks)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/BlockSelectorToolData.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;

public class BlockSelectorToolData implements NetworkSerializable<com.hypixel.hytale.protocol.BlockSelectorToolData> {
   public static final BuilderCodec<BlockSelectorToolData> CODEC;
   protected double durabilityLossOnUse;

   protected BlockSelectorToolData() {
   }

   @Nonnull
   public com.hypixel.hytale.protocol.BlockSelectorToolData toPacket() {
      com.hypixel.hytale.protocol.BlockSelectorToolData packet = new com.hypixel.hytale.protocol.BlockSelectorToolData();
      packet.durabilityLossOnUse = (float)this.durabilityLossOnUse;
      return packet;
   }

   public double getDurabilityLossOnUse() {
      return this.durabilityLossOnUse;
   }

   static {
      CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(BlockSelectorToolData.class, BlockSelectorToolData::new).append( (, Codec.DOUBLE), (data, x) -> data.durabilityLossOnUse = ()x.floatValue(), (data) -> data.durabilityLossOnUse).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/BuilderToolItemReferenceAsset.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.codec.AssetCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import javax.annotation.Nonnull;

public class BuilderToolItemReferenceAsset implements JsonAssetWithMap<String, DefaultAssetMap<String, BuilderToolItemReferenceAsset>> {
   private static AssetStore<String, BuilderToolItemReferenceAsset, DefaultAssetMap<String, BuilderToolItemReferenceAsset>> ASSET_STORE;
   @Nonnull
   public static final AssetCodec<String, BuilderToolItemReferenceAsset> CODEC;
   private String id;
   protected String[] itemIds;
   private AssetExtraInfo.Data data;

   public BuilderToolItemReferenceAsset() {
   }

   public static DefaultAssetMap<String, BuilderToolItemReferenceAsset> getAssetMap() {
      return (DefaultAssetMap)getAssetStore().getAssetMap();
   }

   public  AssetStore<String, BuilderToolItemReferenceAsset, DefaultAssetMap<String, BuilderToolItemReferenceAsset>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, BuilderToolItemReferenceAsset, DefaultAssetMap<String, BuilderToolItemReferenceAsset>>getAssetStore(BuilderToolItemReferenceAsset.class);
      }

       ASSET_STORE;
   }

    String[] getItems() {
       .itemIds;
   }

    String  {
       .id;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(BuilderToolItemReferenceAsset.class, BuilderToolItemReferenceAsset::, Codec.STRING, (t, k) -> t.id = k, (t) -> t.id, (asset, data) -> asset.data = data, (asset) -> asset.data).append( (,  (Codec.STRING, (x$) ->  [x$])), (i, itemIds) -> i.itemIds = itemIds, (i) -> i.itemIds).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/CraftingRecipe.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.common.util.ArrayUtil;
import com.hypixel.hytale.protocol.BenchRequirement;
import com.hypixel.hytale.protocol.BenchType;
import com.hypixel.hytale.server.core.inventory.MaterialQuantity;
import java.util.Arrays;
import javax.annotation.Nonnull;

public class CraftingRecipe implements JsonAssetWithMap<String, DefaultAssetMap<String, CraftingRecipe>> {
   public static final String FIELDCRAFT_REQUIREMENT = "Fieldcraft";
   public static final AssetBuilderCodec<String, CraftingRecipe> CODEC;
   private static final MaterialQuantity[] EMPTY_OUTPUT;
     AssetStore<String, CraftingRecipe, DefaultAssetMap<String, CraftingRecipe>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
    MaterialQuantity[] input;
    MaterialQuantity[] outputs;
    MaterialQuantity primaryOutput;
     primaryOutputQuantity;
    BenchRequirement[] benchRequirement;
     timeSeconds;
     knowledgeRequired;
     requiredMemoriesLevel;

     AssetStore<String, CraftingRecipe, DefaultAssetMap<String, CraftingRecipe>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, CraftingRecipe, DefaultAssetMap<String, CraftingRecipe>>getAssetStore(CraftingRecipe.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, CraftingRecipe>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

     {
      .outputs = EMPTY_OUTPUT;
      .primaryOutputQuantity = ;
      .requiredMemoriesLevel = ;
      .input = input;
      .primaryOutput = primaryOutput;
      .outputs = outputs;
      .primaryOutputQuantity = outputQuantity;
      .benchRequirement = benchRequirement;
      .timeSeconds = timeSeconds;
      .knowledgeRequired = knowledgeRequired;
      .requiredMemoriesLevel = requiredMemoriesLevel;
   }

     {
      .outputs = EMPTY_OUTPUT;
      .primaryOutputQuantity = ;
      .requiredMemoriesLevel = ;
      .input = other.input;
      .primaryOutput = other.primaryOutput;
      .outputs = other.outputs;
      .primaryOutputQuantity = other.primaryOutputQuantity;
      .benchRequirement = other.benchRequirement;
      .timeSeconds = other.timeSeconds;
      .knowledgeRequired = other.knowledgeRequired;
      .requiredMemoriesLevel = other.requiredMemoriesLevel;
   }

     {
      .outputs = EMPTY_OUTPUT;
      .primaryOutputQuantity = ;
      .requiredMemoriesLevel = ;
   }

     String  {
       item.id +  + i;
   }

   
    com.hypixel.hytale.protocol.CraftingRecipe  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.CraftingRecipe();
      packet.id = id;
       (.input !=  && .input.length > ) {
         packet.inputs = (com.hypixel.hytale.protocol.MaterialQuantity[])ArrayUtil.copyAndMutate(.input, MaterialQuantity::toPacket, (x$) ->  .hypixel.hytale.protocol.MaterialQuantity[x$]);
      }

      packet.primaryOutput = .primaryOutput.toPacket();
       (.outputs !=  && .outputs.length > ) {
         packet.outputs = (com.hypixel.hytale.protocol.MaterialQuantity[])ArrayUtil.copyAndMutate(.outputs, MaterialQuantity::toPacket, (x$) ->  .hypixel.hytale.protocol.MaterialQuantity[x$]);
      }

       (.benchRequirement !=  && .benchRequirement.length > ) {
         packet.benchRequirement = .benchRequirement;
      }

      packet.knowledgeRequired = .knowledgeRequired;
      packet.timeSeconds = .timeSeconds;
      packet.requiredMemoriesLevel = .requiredMemoriesLevel;
       packet;
   }

      {
       ((.outputs ==  || .outputs.length == ) && .primaryOutput != ) {
         .outputs =  []{.primaryOutput};
      }

   }

    MaterialQuantity[] getInput() {
       .input;
   }

    MaterialQuantity[] getOutputs() {
       .outputs;
   }

    BenchRequirement[] getBenchRequirement() {
       .benchRequirement;
   }

      {
       .timeSeconds;
   }

      {
       .knowledgeRequired;
   }

      {
       .requiredMemoriesLevel;
   }

    MaterialQuantity  {
       .primaryOutput;
   }

      {
       (.benchRequirement == ) {
          ;
      }  {
         (BenchRequirement b : .benchRequirement) {
             (benchId.equals(b.id) && tierLevel < b.requiredTierLevel) {
                ;
            }
         }

          ;
      }
   }

   
    String  {
         Arrays.toString(.input);
        + var10000 +  + Arrays.toString(.outputs) +  + String.valueOf(.primaryOutput) +  + .primaryOutputQuantity +  + Arrays.toString(.benchRequirement) +  + .timeSeconds +  + .knowledgeRequired +  + .requiredMemoriesLevel + ;
   }

    String  {
       .id;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(CraftingRecipe.class, CraftingRecipe::, Codec.STRING, (recipe, blockTypeKey) -> recipe.id = blockTypeKey, (recipe) -> recipe.id, (asset, data) -> asset.data = data, (asset) -> asset.data).append( (,  (MaterialQuantity.CODEC, (x$) ->  [x$])), (craftingRecipe, objects) -> craftingRecipe.input = objects, (craftingRecipe) -> craftingRecipe.input).addValidator(Validators.nonNull()).add()).append( (,  (MaterialQuantity.CODEC, (x$) ->  [x$])), (craftingRecipe, objects) -> craftingRecipe.outputs = objects, (craftingRecipe) -> craftingRecipe.outputs).add()).append( (, MaterialQuantity.CODEC), (craftingRecipe, objects) -> craftingRecipe.primaryOutput = objects, (craftingRecipe) -> craftingRecipe.primaryOutput).add()).append( (, Codec.INTEGER), (craftingRecipe, quantity) -> craftingRecipe.primaryOutputQuantity = quantity, (craftingRecipe) -> craftingRecipe.primaryOutputQuantity).add()).append( (,  (((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(BenchRequirement.class, BenchRequirement::).append( (,  (BenchType.class)), (benchRequirement, benchType) -> benchRequirement.type = benchType, (benchRequirement) -> benchRequirement.type).add()).append( (, Codec.STRING), (benchRequirement, s) -> benchRequirement.id = s, (benchRequirement) -> benchRequirement.id).add()).append( (, Codec.STRING_ARRAY), (benchRequirement, s) -> benchRequirement.categories = s, (benchRequirement) -> benchRequirement.categories).add()).appendInherited( (, Codec.INTEGER), (benchRequirement, s) -> benchRequirement.requiredTierLevel = s, (benchRequirement) -> benchRequirement.requiredTierLevel, (benchRequirement, parent) -> benchRequirement.requiredTierLevel = parent.requiredTierLevel).add()).build(), (x$) ->  [x$])), (craftingRecipe, objects) -> craftingRecipe.benchRequirement = objects, (craftingRecipe) -> craftingRecipe.benchRequirement).add()).append( (, Codec.DOUBLE), (craftingRecipe, d) -> craftingRecipe.timeSeconds = d.floatValue(), (craftingRecipe) -> ()craftingRecipe.timeSeconds).addValidator(Validators.min()).add()).append( (, Codec.BOOLEAN), (craftingRecipe, b) -> craftingRecipe.knowledgeRequired = b, (craftingRecipe) -> craftingRecipe.knowledgeRequired).add()).append( (, Codec.INTEGER), (craftingRecipe, integer) -> craftingRecipe.requiredMemoriesLevel = integer, (craftingRecipe) -> craftingRecipe.requiredMemoriesLevel).documentation().addValidator(Validators.greaterThanOrEqual()).add()).validator((craftingRecipe, results) -> {
         BenchRequirement[] benchRequirements = craftingRecipe.getBenchRequirement();
          (benchRequirements != ) {
            (BenchRequirement benchRequirement : benchRequirements) {
                (craftingRecipe.isKnowledgeRequired() && benchRequirement.type != BenchType.Crafting && benchRequirement.type != BenchType.DiagramCrafting) {
                  results.fail();
               }

                (benchRequirement.type == BenchType.DiagramCrafting && craftingRecipe.getOutputs() !=  && craftingRecipe.getOutputs().length > ) {
                  results.fail();
               }

                (.equals(benchRequirement.id) && craftingRecipe.getTimeSeconds() > ) {
                  results.warn(String.format(, ));
               }
            }
         }

      })).afterDecode(CraftingRecipe::processConfig)).build();
      EMPTY_OUTPUT =  [];
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/FieldcraftCategory.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.lang.ref.SoftReference;
import javax.annotation.Nonnull;

public class FieldcraftCategory implements JsonAssetWithMap<String, DefaultAssetMap<String, FieldcraftCategory>>, NetworkSerializable<com.hypixel.hytale.protocol.ItemCategory> {
   public static final AssetBuilderCodec<String, FieldcraftCategory> CODEC;
   private static DefaultAssetMap<String, FieldcraftCategory> ASSET_MAP;
   protected AssetExtraInfo.Data data;
   protected String id;
   protected String name;
   protected String icon;
   protected int order;
   private SoftReference<com.hypixel.hytale.protocol.ItemCategory> cachedPacket;

   public static DefaultAssetMap<String, FieldcraftCategory> getAssetMap() {
      if (ASSET_MAP == null) {
         ASSET_MAP = (DefaultAssetMap)AssetRegistry.getAssetStore(FieldcraftCategory.class).getAssetMap();
      }

       ASSET_MAP;
   }

     {
   }

   
    com.hypixel.hytale.protocol.ItemCategory  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.ItemCategory).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ItemCategory();
         packet.id = .id;
         packet.icon = .icon;
         packet.name = .name;
         packet.order = .order;
         .cachedPacket =  (packet);
          packet;
      }
   }

    String  {
       .id;
   }

    String  {
       .name;
   }

    String  {
       .icon;
   }

   
    String  {
        + .id +  + .name +  + .icon +  + .order + ;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(FieldcraftCategory.class, FieldcraftCategory::, Codec.STRING, (itemCategory, k) -> itemCategory.id = k, (itemCategory) -> itemCategory.id, (asset, data) -> asset.data = data, (asset) -> asset.data).addField( (, Codec.STRING), (itemCategory, s) -> itemCategory.name = s, (itemCategory) -> itemCategory.name)).append( (, Codec.STRING), (itemCategory, s) -> itemCategory.icon = s, (itemCategory) -> itemCategory.icon).addValidator(CommonAssetValidator.ICON_CRAFTING).add()).addField( (, Codec.INTEGER), (itemCategory, s) -> itemCategory.order = s, (itemCategory) -> itemCategory.order)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/Item.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.codec.AssetCodec;
import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.codecs.map.EnumMapCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.codec.schema.metadata.AllowEmptyObject;
import com.hypixel.hytale.codec.schema.metadata.ui.UIButton;
import com.hypixel.hytale.codec.schema.metadata.ui.UICreateButtons;
import com.hypixel.hytale.codec.schema.metadata.ui.UIDefaultCollapsedState;
import com.hypixel.hytale.codec.schema.metadata.ui.UIDisplayMode;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditor;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditorPreview;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditorSectionStart;
import com.hypixel.hytale.codec.schema.metadata.ui.UIPropertyTitle;
import com.hypixel.hytale.codec.schema.metadata.ui.UIRebuildCaches;
import com.hypixel.hytale.codec.schema.metadata.ui.UISidebarButtons;
 com.hypixel.hytale.codec.schema.metadata.ui.UITypeIcon;
 com.hypixel.hytale.codec.validation.ValidatorCache;
 com.hypixel.hytale.codec.validation.Validators;
 com.hypixel.hytale.common.util.MapUtil;
 com.hypixel.hytale.protocol.ColorLight;
 com.hypixel.hytale.protocol.InteractionType;
 com.hypixel.hytale.protocol.ItemBase;
 com.hypixel.hytale.protocol.ItemResourceType;
 com.hypixel.hytale.protocol.ModelTrail;
 com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
 com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
 com.hypixel.hytale.server.core.asset.type.buildertool.config.BuilderToolData;
 com.hypixel.hytale.server.core.asset.type.itemanimation.config.ItemPlayerAnimations;
 com.hypixel.hytale.server.core.asset.type.itemsound.config.ItemSoundSet;
 com.hypixel.hytale.server.core.asset.type.model.config.ModelAsset;
 com.hypixel.hytale.server.core.asset.type.model.config.ModelParticle;
 com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
 com.hypixel.hytale.server.core.codec.ProtocolCodecs;
 com.hypixel.hytale.server.core.inventory.MaterialQuantity;
 com.hypixel.hytale.server.core.io.NetworkSerializable;
 com.hypixel.hytale.server.core.modules.entitystats.EntityStatsModule;
 com.hypixel.hytale.server.core.modules.entitystats.asset.EntityStatType;
 com.hypixel.hytale.server.core.modules.interaction.interaction.UnarmedInteractions;
 com.hypixel.hytale.server.core.modules.interaction.interaction.config.InteractionConfiguration;
 com.hypixel.hytale.server.core.modules.interaction.interaction.config.RootInteraction;
 com.hypixel.hytale.server.core.modules.interaction.interaction.config.none.ChangeActiveSlotInteraction;
 it.unimi.dsi.fastutil.ints.IntSet;
 it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
 it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
 java.lang.ref.SoftReference;
 java.util.Collection;
 java.util.Collections;
 java.util.EnumMap;
 java.util.HashMap;
 java.util.Map;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;
 org.bson.BsonDocument;

    <String, DefaultAssetMap<String, Item>>, NetworkSerializable<ItemBase> {
      AssetBuilderCodec.Builder<String, Item> CODEC_BUILDER;
      AssetCodec<String, Item> CODEC;
      ValidatorCache<String> VALIDATOR_CACHE;
     AssetStore<String, Item, DefaultAssetMap<String, Item>> ASSET_STORE;
         ;
      Item UNKNOWN;
    AssetExtraInfo.Data data;
    String id;
    String icon;
    AssetIconProperties iconProperties;
    ItemTranslationProperties translationProperties;
    String reticleId;
       ;
     itemLevel;
       -;
    String qualityId;
       ;
    CraftingRecipe recipeToGenerate;
    String blockId;
     hasBlockType;
     consumable;
     variant;
    ItemTool tool;
    BlockSelectorToolData blockSelectorToolData;
    BuilderToolData builderToolData;
    ItemWeapon weapon;
    ItemArmor armor;
    ItemGlider glider;
    ItemUtility utility;
    ItemStackContainerConfig itemStackContainerConfig;
    PortalKey portalKey;
    String playerAnimationsId;
     usePlayerAnimations;
    String model;
     scale;
    String texture;
    String animation;
    String[] categories;
    String set;
    String soundEventId;
      soundEventIndex;
    String itemSoundSetId;
      itemSoundSetIndex;
    ModelParticle[] particles;
    ModelParticle[] firstPersonParticles;
    ModelTrail[] trails;
    ColorLight light;
    ItemResourceType[] resourceTypes;
    Map<String, String> stateToBlock;
    Map<String, String> blockToState;
    Map<InteractionType, String> interactions;
    Map<String, String> interactionVars;
    InteractionConfiguration interactionConfig;
    ItemEntityConfig itemEntityConfig;
    String droppedItemAnimation;
     maxDurability;
     fuelQuality;
     durabilityLossOnHit;
    Map<String, ItemAppearanceCondition[]> itemAppearanceConditions;
    String[] rawDisplayEntityStatsHUD;
   
    [] displayEntityStatsHUD;
    ItemPullbackConfig pullbackConfig;
     clipsGeometry;
     renderDeployablePreview;
     dropOnDeath;
     SoftReference<ItemBase> cachedPacket;

     AssetStore<String, Item, DefaultAssetMap<String, Item>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, Item, DefaultAssetMap<String, Item>>getAssetStore(Item.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, Item>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

     {
      .utility = ItemUtility.DEFAULT;
      .itemStackContainerConfig = ItemStackContainerConfig.DEFAULT;
      .playerAnimationsId = ;
      .usePlayerAnimations = ;
      .scale = ;
      .texture = ;
      .itemSoundSetId = ;
      .interactions = Collections.emptyMap();
      .interactionVars = Collections.emptyMap();
      .fuelQuality = ;
   }

     {
      .utility = ItemUtility.DEFAULT;
      .itemStackContainerConfig = ItemStackContainerConfig.DEFAULT;
      .playerAnimationsId = ;
      .usePlayerAnimations = ;
      .scale = ;
      .texture = ;
      .itemSoundSetId = ;
      .interactions = Collections.emptyMap();
      .interactionVars = Collections.emptyMap();
      .fuelQuality = ;
      .id = id;
   }

     {
      .utility = ItemUtility.DEFAULT;
      .itemStackContainerConfig = ItemStackContainerConfig.DEFAULT;
      .playerAnimationsId = ;
      .usePlayerAnimations = ;
      .scale = ;
      .texture = ;
      .itemSoundSetId = ;
      .interactions = Collections.emptyMap();
      .interactionVars = Collections.emptyMap();
      .fuelQuality = ;
      .data = other.data;
      .id = other.id;
      .icon = other.icon;
      .iconProperties = other.iconProperties;
      .translationProperties = other.translationProperties;
      .reticleId = other.reticleId;
      .itemLevel = other.itemLevel;
      .maxStack = other.maxStack;
      .qualityId = other.qualityId;
      .recipeToGenerate = other.recipeToGenerate;
      .consumable = other.consumable;
      .variant = other.variant;
      .playerAnimationsId = other.playerAnimationsId;
      .usePlayerAnimations = other.usePlayerAnimations;
      .model = other.model;
      .scale = other.scale;
      .texture = other.texture;
      .animation = other.animation;
      .tool = other.tool;
      .blockSelectorToolData = other.blockSelectorToolData;
      .builderToolData = other.builderToolData;
      .weapon = other.weapon;
      .armor = other.armor;
      .utility = other.utility;
      .portalKey = other.portalKey;
      .categories = other.categories;
      .set = other.set;
      .soundEventId = other.soundEventId;
      .soundEventIndex = other.soundEventIndex;
      .itemSoundSetId = other.itemSoundSetId;
      .itemSoundSetIndex = other.itemSoundSetIndex;
      .particles = other.particles;
      .firstPersonParticles = other.firstPersonParticles;
      .trails = other.trails;
      .light = other.light;
      .resourceTypes = other.resourceTypes;
      .interactions = other.interactions;
      .interactionVars = other.interactionVars;
      .interactionConfig = other.interactionConfig;
      .droppedItemAnimation = other.droppedItemAnimation;
      .itemEntityConfig = other.itemEntityConfig;
      .stateToBlock = other.stateToBlock;
      .blockId = other.blockId;
      .hasBlockType = other.hasBlockType;
      .displayEntityStatsHUD = other.displayEntityStatsHUD;
      .pullbackConfig = other.pullbackConfig;
      .clipsGeometry = other.clipsGeometry;
      .renderDeployablePreview = other.renderDeployablePreview;
      .dropOnDeath = other.dropOnDeath;
   }

   
    ItemBase  {
         .cachedPacket ==  ?  : (ItemBase).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
             ();
         packet.id = .id;
          (.icon != ) {
            packet.icon = .icon;
         }

          (.iconProperties != ) {
            packet.iconProperties = .iconProperties.toPacket();
         }

          (.translationProperties != ) {
            packet.translationProperties = .translationProperties.toPacket();
         }

          (.model != ) {
            packet.model = .model;
         }

         packet.scale = .scale;
          (.texture != ) {
            packet.texture = .texture;
         }

          (.animation != ) {
            packet.animation = .animation;
         }

         packet.playerAnimationsId = .playerAnimationsId;
         packet.usePlayerAnimations = .usePlayerAnimations;
         packet.reticleIndex = .reticleIndex;
         packet.maxStack = .maxStack;
         packet.itemLevel = .itemLevel;
         packet.qualityIndex = .qualityIndex;
          (.blockId != ) {
            packet.blockId = BlockType.getAssetMap().getIndexOrDefault(.blockId, );
             (packet.blockId == ) {
                 ();
            }
         }

         packet.consumable = .consumable;
         packet.variant = .variant;
          (.tool != ) {
            packet.tool = .tool.toPacket();
         }

          (.blockSelectorToolData != ) {
            packet.blockSelectorTool = .blockSelectorToolData.toPacket();
         }

          (.builderToolData != ) {
            packet.builderToolData = .builderToolData.toPacket();
         }

          (.weapon != ) {
            packet.weapon = .weapon.toPacket();
         }

          (.armor != ) {
            packet.armor = .armor.toPacket();
         }

          (.glider != ) {
            packet.gliderConfig = .glider.toPacket();
         }

          (.utility != ) {
            packet.utility = .utility.toPacket();
         }

          (.categories !=  && .categories.length > ) {
            packet.categories = .categories;
         }

          (.set != ) {
            packet.set = .set;
         }

         packet.soundEventIndex = .soundEventIndex;
         packet.itemSoundSetIndex = .itemSoundSetIndex;
          (.particles !=  && .particles.length > ) {
            packet.particles =  .hypixel.hytale.protocol.ModelParticle[.particles.length];

            (   ; i < .particles.length; ++i) {
               packet.particles[i] = .particles[i].toPacket();
            }
         }

          (.firstPersonParticles !=  && .firstPersonParticles.length > ) {
            packet.firstPersonParticles =  .hypixel.hytale.protocol.ModelParticle[.firstPersonParticles.length];

            (   ; i < .firstPersonParticles.length; ++i) {
               packet.firstPersonParticles[i] = .firstPersonParticles[i].toPacket();
            }
         }

          (.trails !=  && .trails.length > ) {
            packet.trails = .trails;
         }

          (.light != ) {
            packet.light = .light;
         }

          (.resourceTypes !=  && .resourceTypes.length > ) {
            packet.resourceTypes = .resourceTypes;
         }

         Object2IntOpenHashMap<InteractionType> interactionsIntMap =  <InteractionType>();

         (Map.Entry<InteractionType, String> e : .interactions.entrySet()) {
            interactionsIntMap.put((InteractionType)e.getKey(), RootInteraction.getRootInteractionIdOrUnknown((String)e.getValue()));
         }

         packet.interactions = interactionsIntMap;
         Object2IntOpenHashMap<String> interactionVarsIntMap =  <String>();

         (Map.Entry<String, String> e : .interactionVars.entrySet()) {
            interactionVarsIntMap.put((String)e.getKey(), RootInteraction.getRootInteractionIdOrUnknown((String)e.getValue()));
         }

         packet.interactionVars = interactionVarsIntMap;
         packet.interactionConfig = .interactionConfig.toPacket();
         packet.durability = .getMaxDurability();
         packet.itemEntity = .itemEntityConfig.toPacket();
          (.droppedItemAnimation != ) {
            packet.droppedItemAnimation = .droppedItemAnimation;
         }

          (.itemAppearanceConditions != ) {
            HashMap<Integer, com.hypixel.hytale.protocol.ItemAppearanceCondition[]> map =  ();

            (Map.Entry<String, ItemAppearanceCondition[]> entry : .itemAppearanceConditions.entrySet()) {
               ItemAppearanceCondition[] conditions = (ItemAppearanceCondition[])entry.getValue();
               com.hypixel.hytale.protocol.ItemAppearanceCondition[] protocolConditions =  .hypixel.hytale.protocol.ItemAppearanceCondition[conditions.length];

               (   ; i < conditions.length; ++i) {
                  protocolConditions[i] = conditions[i].toPacket();
               }

               map.put(EntityStatType.getAssetMap().getIndex((String)entry.getKey()), protocolConditions);
            }

            packet.itemAppearanceConditions = map;
         }

          (.data != ) {
               .data.getExpandedTagIndexes();
             (expandedTagIndexes != ) {
               packet.tagIndexes = expandedTagIndexes.toIntArray();
            }
         }

         packet.displayEntityStatsHUD = .displayEntityStatsHUD;
          (.pullbackConfig != ) {
            packet.pullbackConfig = .pullbackConfig.toPacket();
         }

         packet.clipsGeometry = .clipsGeometry;
         packet.renderDeployablePreview = .renderDeployablePreview;
         .cachedPacket =  (packet);
          packet;
      }
   }

   
    String  {
       .stateToBlock !=  ? (String).stateToBlock.get(state) : ;
   }

   
    Item  {
         .getItemIdForState(state);
       id ==  ?  : (Item)getAssetMap().getAsset(id);
   }

      {
       .getStateForItem(.id) != ;
   }

   
    String  {
       .getStateForItem(item.getId());
   }

   
    String  {
       .blockToState !=  ? (String).blockToState.get(key) : ;
   }

    AssetExtraInfo.Data  {
       .data;
   }

    String  {
       .id;
   }

    String  {
       .blockId;
   }

   
    String  {
       (.translationProperties != ) {
            .translationProperties.getName();
          (nameTranslation != ) {
             nameTranslation;
         }
      }

        + .id + ;
   }

   
    String  {
       (.translationProperties != ) {
            .translationProperties.getDescription();
          (descriptionTranslation != ) {
             descriptionTranslation;
         }
      }

        + .id + ;
   }

    String  {
       .model;
   }

    String  {
       .texture;
   }

      {
       .consumable;
   }

      {
       .variant;
   }

      {
       .usePlayerAnimations;
   }

    String  {
       .playerAnimationsId;
   }

    String  {
       .icon;
   }

    AssetIconProperties  {
       .iconProperties;
   }

    ItemTranslationProperties  {
       .translationProperties;
   }

      {
       .scale;
   }

    String  {
       .reticleId;
   }

      {
       .itemLevel;
   }

      {
       .maxStack;
   }

      {
       .qualityIndex;
   }

    ItemTool  {
       .tool;
   }

    BlockSelectorToolData  {
       .blockSelectorToolData;
   }

    BuilderToolData  {
       .builderToolData;
   }

    ItemArmor  {
       .armor;
   }

    ItemGlider  {
       .glider;
   }

   
    ItemUtility  {
       .utility;
   }

   
    PortalKey  {
       .portalKey;
   }

   
    ItemStackContainerConfig  {
       .itemStackContainerConfig;
   }

    String[] getCategories() {
       .categories;
   }

    String  {
       .soundEventId;
   }

      {
       .soundEventIndex;
   }

      {
       .blockId != ;
   }

    ItemWeapon  {
       .weapon;
   }

    ItemResourceType[] getResourceTypes() {
       .resourceTypes;
   }

      {
       .maxDurability;
   }

    ColorLight  {
       .light;
   }

    Map<InteractionType, String>  {
       .interactions;
   }

    Map<String, String>  {
       .interactionVars;
   }

    ItemEntityConfig  {
       .itemEntityConfig;
   }

    String  {
       .droppedItemAnimation;
   }

      {
       .durabilityLossOnHit;
   }

    [] getDisplayEntityStatsHUD() {
       .displayEntityStatsHUD;
   }

    ItemPullbackConfig  {
       .pullbackConfig;
   }

      {
       .clipsGeometry;
   }

      {
       .renderDeployablePreview;
   }

      {
       .fuelQuality;
   }

    InteractionConfiguration  {
       .interactionConfig;
   }

      {
       .itemSoundSetIndex;
   }

      {
       (.recipeToGenerate != ) {
         recipes.add(.recipeToGenerate);
      }

   }

      {
       .recipeToGenerate != ;
   }

      {
       .dropOnDeath;
   }

      {
       (.hasBlockType) {
         .blockId = .id;
      }

       (.maxStack == -) {
          (.tool ==  && .weapon ==  && .armor ==  && .builderToolData ==  && .blockSelectorToolData == ) {
            .maxStack = ;
         }  {
            .maxStack = ;
         }
      }

      Map<InteractionType, String> interactions = .interactions.isEmpty() ?  (InteractionType.class) :  (.interactions);
      DefaultAssetMap<String, UnarmedInteractions> unarmedInteractionsAssetMap = UnarmedInteractions.getAssetMap();
         .playerAnimationsId !=  ? (UnarmedInteractions)unarmedInteractionsAssetMap.getAsset(.playerAnimationsId) : ;
       (fallbackInteractions != ) {
         (Map.Entry<InteractionType, String> entry : fallbackInteractions.getInteractions().entrySet()) {
            interactions.putIfAbsent((InteractionType)entry.getKey(), (String)entry.getValue());
         }
      }

         unarmedInteractionsAssetMap.getAsset();
       (defaultUnarmedInteractions != ) {
         (Map.Entry<InteractionType, String> entry : defaultUnarmedInteractions.getInteractions().entrySet()) {
            interactions.putIfAbsent((InteractionType)entry.getKey(), (String)entry.getValue());
         }
      }

      .interactions = Collections.unmodifiableMap(interactions);
       (.reticleId != ) {
         .reticleIndex = ItemReticleConfig.getAssetMap().getIndexOrDefault(.reticleId, );
      }

      IndexedLookupTableAssetMap<String, ItemQuality> itemQualityAssetMap = ItemQuality.getAssetMap();
       (.qualityId != ) {
         .qualityIndex = itemQualityAssetMap.getIndexOrDefault(.qualityId, );
            itemQualityAssetMap.getAsset(.qualityIndex);
          (itemQuality != ) {
            .itemEntityConfig = itemQuality.getItemEntityConfig();
         }
      }

       (.itemEntityConfig == ) {
          (.blockId != ) {
            .itemEntityConfig = ItemEntityConfig.DEFAULT_BLOCK;
         }  {
            .itemEntityConfig = ItemEntityConfig.DEFAULT;
         }
      }

       (.interactionConfig == ) {
          (.weapon != ) {
            .interactionConfig = InteractionConfiguration.DEFAULT_WEAPON;
         }  {
            .interactionConfig = InteractionConfiguration.DEFAULT;
         }
      }

       (.soundEventId != ) {
         .soundEventIndex = SoundEvent.getAssetMap().getIndex(.soundEventId);
      }

      .itemSoundSetIndex = ItemSoundSet.getAssetMap().getIndex(.itemSoundSetId);
       (.stateToBlock != ) {
         Map<String, String> map =  <String, String>();

         (Map.Entry<String, String> entry : .stateToBlock.entrySet()) {
            map.put((String)entry.getValue(), (String)entry.getKey());
         }

         .blockToState = Collections.unmodifiableMap(map);
      }

       (.recipeToGenerate != ) {
            .recipeToGenerate;
             (recipe);
             (.id, (String), (String), newRecipe.primaryOutputQuantity, (BsonDocument));
          (newRecipe.outputs ==  || newRecipe.outputs.length == ) {
            newRecipe.outputs =  []{primaryOutput};
         }

         newRecipe.primaryOutput = primaryOutput;
         newRecipe.id = CraftingRecipe.generateIdFromItemRecipe(, );
         .recipeToGenerate = newRecipe;
      }

      .displayEntityStatsHUD = EntityStatsModule.resolveEntityStats(.rawDisplayEntityStatsHUD);
   }

    {
      CODEC_BUILDER = (AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(Item.class, Item::, Codec.STRING, (item, blockTypeKey) -> item.id = blockTypeKey, (item) -> item.id, (asset, data) -> asset.data = data, (asset) -> asset.data).metadata( (UIEditorPreview.PreviewType.ITEM))).metadata( ())).metadata( (,  .ClientCache[]{UIRebuildCaches.ClientCache.MODELS, UIRebuildCaches.ClientCache.BLOCK_TEXTURES, UIRebuildCaches.ClientCache.MODEL_TEXTURES, UIRebuildCaches.ClientCache.MAP_GEOMETRY, UIRebuildCaches.ClientCache.ITEM_ICONS}))).metadata( ( []{ (, )}))).metadata( ( []{ (, )}))).appendInherited( (, Codec.STRING), (item, s) -> item.icon = s, (item) -> item.icon, (item, parent) -> item.icon = parent.icon).addValidator(CommonAssetValidator.ICON_ITEM).metadata( ( .Icon(, , ))).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.ITEM_ICONS})).add()).appendInherited( (, ( (Codec.STRING, (x$) ->  [x$])).metadata( ( .Dropdown()))), (item, s) -> item.categories = s, (item) -> item.categories, (item, parent) -> item.categories = parent.categories).addValidatorLate(() -> ItemCategory.VALIDATOR_CACHE.getArrayValidator().late()).documentation().add()).appendInherited( (, AssetIconProperties.CODEC), (item, s) -> item.iconProperties = s, (item) -> item.iconProperties, (item, parent) -> item.iconProperties = parent.iconProperties).metadata(UIDisplayMode.HIDDEN).add()).appendInherited( (, ItemTranslationProperties.CODEC), (item, s) -> item.translationProperties = s, (item) -> item.translationProperties, (item, parent) -> item.translationProperties = parent.translationProperties).documentation().add()).appendInherited( (, Codec.INTEGER), (item, s) -> item.itemLevel = s, (item) -> item.itemLevel, (item, parent) -> item.itemLevel = parent.itemLevel).add()).appendInherited( (,  (ItemReticleConfig.class, ItemReticleConfig.CODEC)), (item, s) -> item.reticleId = s, (item) -> item.reticleId, (item, parent) -> item.reticleId = parent.reticleId).addValidator(ItemReticleConfig.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, Codec.INTEGER), (item, s) -> item.maxStack = s, (item) -> item.maxStack, (item, parent) -> item.maxStack = parent.maxStack).metadata( ()).documentation().addValidator(Validators.greaterThan()).add()).append( (, Codec.STRING), (item, s) -> item.qualityId = s, (item) -> item.qualityId).addValidator(ItemQuality.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, ItemEntityConfig.CODEC), (item, itemEntityConfig) -> item.itemEntityConfig = itemEntityConfig, (item) -> item.itemEntityConfig, (item, parent) -> item.itemEntityConfig = parent.itemEntityConfig).addValidator(Validators.nonNull()).add()).appendInherited( (, Codec.STRING), (item, s) -> item.soundEventId = s, (item) -> item.soundEventId, (item, parent) -> item.soundEventId = parent.soundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, Codec.STRING), (item, s) -> item.itemSoundSetId = s, (item) -> item.itemSoundSetId, (item, parent) -> item.itemSoundSetId = parent.itemSoundSetId).addValidator(Validators.nonNull()).addValidator(ItemSoundSet.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, Codec.STRING), (item, s) -> item.set = s, (item) -> item.set, (item, parent) -> item.set = parent.set).add()).appendInherited( (, Codec.STRING), (item, s) -> item.model = s, (item) -> item.model, (item, parent) -> item.model = parent.model).addValidator(CommonAssetValidator.MODEL_ITEM).metadata( ()).metadata( (,  .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).metadata( ()).documentation().add()).appendInherited( (, Codec.DOUBLE), (item, s) -> item.scale = s.floatValue(), (item) -> ()item.scale, (item, parent) -> item.scale = parent.scale).metadata( ()).add()).appendInherited( (, Codec.STRING), (item, s) -> item.texture = s, (item) -> item.texture, (item, parent) -> item.texture = parent.texture).addValidator(CommonAssetValidator.TEXTURE_ITEM).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).metadata( ()).documentation().add()).appendInherited( (, Codec.STRING), (item, s) -> item.animation = s, (item) -> item.animation, (item, parent) -> item.animation = parent.animation).addValidator(CommonAssetValidator.ANIMATION_ITEM_BLOCK).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).metadata( ()).documentation().add()).appendInherited( (, Codec.BOOLEAN), (item, s) -> item.usePlayerAnimations = s, (item) -> item.usePlayerAnimations, (item, parent) -> item.usePlayerAnimations = parent.usePlayerAnimations).add()).appendInherited( (, ItemPlayerAnimations.CHILD_CODEC), (item, s) -> item.playerAnimationsId = s, (item) -> item.playerAnimationsId, (item, parent) -> item.playerAnimationsId = parent.playerAnimationsId).addValidator(Validators.nonNull()).addValidator(ItemPlayerAnimations.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, Codec.STRING), (item, animation) -> item.droppedItemAnimation = animation, (item) -> item.droppedItemAnimation, (item, parent) -> item.droppedItemAnimation = parent.droppedItemAnimation).addValidator(CommonAssetValidator.ANIMATION_ITEM_BLOCK).add()).appendInherited( (, ModelParticle.ARRAY_CODEC), (item, s) -> item.particles = s, (item) -> item.particles, (item, parent) -> item.particles = parent.particles).metadata( ()).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).documentation().add()).appendInherited( (, ModelParticle.ARRAY_CODEC), (item, s) -> item.firstPersonParticles = s, (item) -> item.firstPersonParticles, (item, parent) -> item.firstPersonParticles = parent.firstPersonParticles).metadata( ()).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).documentation().add()).appendInherited( (, ModelAsset.MODEL_TRAIL_ARRAY_CODEC), (item, s) -> item.trails = s, (item) -> item.trails, (item, parent) -> item.trails = parent.trails).metadata( ()).documentation().add()).appendInherited( (, ProtocolCodecs.COLOR_LIGHT), (item, o) -> item.light = o, (item) -> item.light, (item, parent) -> item.light = parent.light).metadata( ()).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.MODELS})).documentation().add()).append( (, CraftingRecipe.CODEC), (item, s) -> item.recipeToGenerate = s, (item) -> item.recipeToGenerate).metadata( ()).add()).appendInherited( (,  (((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ItemResourceType.class, ItemResourceType::).append( (, Codec.STRING), (itemResourceType, s) -> itemResourceType.id = s, (itemResourceType) -> itemResourceType.id).addValidator(ResourceType.VALIDATOR_CACHE.getValidator()).addValidator(Validators.nonNull()).add()).append( (, Codec.INTEGER), (itemResourceType, s) -> itemResourceType.quantity = s, (itemResourceType) -> itemResourceType.quantity).addValidator(Validators.greaterThan()).add()).build(), (x$) ->  [x$])), (item, s) -> item.resourceTypes = s, (item) -> item.resourceTypes, (item, parent) -> item.resourceTypes = parent.resourceTypes).add()).appendInherited( (, ItemTool.CODEC), (item, s) -> item.tool = s, (item) -> item.tool, (item, parent) -> item.tool = parent.tool).metadata( ()).add()).appendInherited( (, BlockSelectorToolData.CODEC), (item, s) -> item.blockSelectorToolData = s, (item) -> item.blockSelectorToolData, (item, parent) -> item.blockSelectorToolData = parent.blockSelectorToolData).add()).appendInherited( (, BuilderToolData.CODEC), (item, s) -> item.builderToolData = s, (item) -> item.builderToolData, (item, parent) -> item.builderToolData = parent.builderToolData).add()).appendInherited( (, ItemWeapon.CODEC), (item, s) -> item.weapon = s, (item) -> item.weapon, (item, parent) -> item.weapon = parent.weapon).metadata(AllowEmptyObject.INSTANCE).add()).appendInherited( (, ItemArmor.CODEC), (item, s) -> item.armor = s, (item) -> item.armor, (item, parent) -> item.armor = parent.armor).add()).appendInherited( (, ItemGlider.CODEC), (item, s) -> item.glider = s, (item) -> item.glider, (item, parent) -> item.glider = parent.glider).add()).appendInherited( (, ItemUtility.CODEC), (item, s) -> item.utility = s, (item) -> item.utility, (item, parent) -> item.utility = parent.utility).addValidator(Validators.nonNull()).add()).appendInherited( (, PortalKey.CODEC), (item, s) -> item.portalKey = s, (item) -> item.portalKey, (item, parent) -> item.portalKey = parent.portalKey).add()).appendInherited( (, ItemStackContainerConfig.CODEC), (item, s) -> item.itemStackContainerConfig = s, (item) -> item.itemStackContainerConfig, (item, parent) -> item.itemStackContainerConfig = parent.itemStackContainerConfig).addValidator(Validators.nonNull()).add()).appendInherited( (, Codec.BOOLEAN), (item, s) -> item.consumable = s, (item) -> item.consumable, (item, parent) -> item.consumable = parent.consumable).add()).appendInherited( (, Codec.BOOLEAN), (item, b) -> item.variant = b, (item) -> item.variant, (item, parent) -> item.variant = parent.variant).documentation().add()).appendInherited( (, Codec.DOUBLE), (item, s) -> item.maxDurability = s, (item) -> item.maxDurability, (item, parent) -> item.maxDurability = parent.maxDurability).add()).appendInherited( (, Codec.DOUBLE), (item, s) -> item.fuelQuality = s, (item) -> item.fuelQuality, (item, parent) -> item.fuelQuality = parent.fuelQuality).add()).appendInherited( (, Codec.DOUBLE), (item, s) -> item.durabilityLossOnHit = s, (item) -> item.durabilityLossOnHit, (item, parent) -> item.durabilityLossOnHit = parent.durabilityLossOnHit).add()).appendInherited( (,  (BlockType.class, BlockType.CODEC, ContainedAssetCodec.Mode.INHERIT_ID_AND_PARENT)), (item, s) -> item.hasBlockType = , (item) -> item.blockId, (item, parent) -> item.blockId = parent.blockId).metadata( ()).metadata( (,  .ClientCache[]{UIRebuildCaches.ClientCache.MODELS, UIRebuildCaches.ClientCache.BLOCK_TEXTURES, UIRebuildCaches.ClientCache.MODEL_TEXTURES})).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (,  (InteractionType.class, RootInteraction.CHILD_ASSET_CODEC)), (item, v) -> item.interactions = MapUtil.combineUnmodifiable(item.interactions, v, () ->  (InteractionType.class)), (item) -> item.interactions, (item, parent) -> item.interactions = parent.interactions).addValidator(RootInteraction.VALIDATOR_CACHE.getMapValueValidator()).metadata( ()).add()).appendInherited( (, InteractionConfiguration.CODEC), (item, v) -> item.interactionConfig = v, (item) -> item.interactionConfig, (item, parent) -> item.interactionConfig = parent.interactionConfig).addValidator(Validators.nonNull()).add()).appendInherited( (,  (RootInteraction.CHILD_ASSET_CODEC, HashMap::)), (item, v) -> item.interactionVars = MapUtil.<String, String>combineUnmodifiable(item.interactionVars, v), (item) -> item.interactionVars, (item, parent) -> item.interactionVars = parent.interactionVars).addValidator(RootInteraction.VALIDATOR_CACHE.getMapValueValidator()).add()).appendInherited( (,  ( (ItemAppearanceCondition.CODEC, (x$) ->  [x$]), HashMap::)), (item, stringMap) -> item.itemAppearanceConditions = stringMap, (item) -> item.itemAppearanceConditions, (item, parent) -> item.itemAppearanceConditions = parent.itemAppearanceConditions).documentation().addValidator(EntityStatType.VALIDATOR_CACHE.getMapKeyValidator().late()).add()).appendInherited( (, Codec.STRING_ARRAY), (item, strings) -> item.rawDisplayEntityStatsHUD = strings, (item) -> item.rawDisplayEntityStatsHUD, (item, parent) -> item.rawDisplayEntityStatsHUD = parent.rawDisplayEntityStatsHUD).documentation().add()).appendInherited( (, ItemPullbackConfig.CODEC), (item, s) -> item.pullbackConfig = s, (item) -> item.pullbackConfig, (item, parent) -> item.pullbackConfig = parent.pullbackConfig).documentation().add()).appendInherited( (, Codec.BOOLEAN), (item, s) -> item.clipsGeometry = s, (item) -> item.clipsGeometry, (item, parent) -> item.clipsGeometry = parent.clipsGeometry).add()).appendInherited( (, Codec.BOOLEAN), (item, s) -> item.renderDeployablePreview = s, (item) -> item.renderDeployablePreview, (item, parent) -> item.renderDeployablePreview = parent.renderDeployablePreview).add()).appendInherited( (, Codec.BOOLEAN), (item, aBoolean) -> item.dropOnDeath = aBoolean, (item) -> item.dropOnDeath, (item, parent) -> item.dropOnDeath = parent.dropOnDeath).add()).afterDecode(Item::processConfig);
      CODEC = CODEC_BUILDER.build();
      CODEC_BUILDER.appendInherited( (,  ( (Item.class, CODEC, ContainedAssetCodec.Mode.INJECT_PARENT), HashMap::)), (item, m) -> item.stateToBlock = m, (item) -> item.stateToBlock, (item, parent) -> item.stateToBlock = parent.stateToBlock).metadata( ()).add();
      VALIDATOR_CACHE =  <String>( (Item::getAssetStore));
      UNKNOWN =  () {
         {
            .playerAnimationsId = ;
            .model = ;
            .texture = ;
            .maxStack = ;
            .itemEntityConfig = ItemEntityConfig.DEFAULT;
            .interactionConfig = InteractionConfiguration.DEFAULT;
            .interactions = Map.of(InteractionType.SwapFrom, ChangeActiveSlotInteraction.DEFAULT_ROOT.getId());
         }
      };
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/ItemAppearanceCondition.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.math.range.FloatRange;
import com.hypixel.hytale.protocol.ValueType;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import com.hypixel.hytale.server.core.asset.type.model.config.ModelParticle;
import com.hypixel.hytale.server.core.asset.type.modelvfx.config.ModelVFX;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
import com.hypixel.hytale.server.core.asset.type.soundevent.validator.SoundEventValidators;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.util.Arrays;
import javax.annotation.Nonnull;

public class ItemAppearanceCondition implements NetworkSerializable<com.hypixel.hytale.protocol.ItemAppearanceCondition> {
   public static final BuilderCodec<ItemAppearanceCondition> CODEC;
   protected ModelParticle[] particles;
   protected ModelParticle[] firstPersonParticles;
   protected String worldSoundEventId;
   protected transient int worldSoundEventIndex = 0;
   protected String localSoundEventId;
   protected     ;
    String model;
    String texture;
    FloatRange condition;
   
    ValueType conditionValueType;
    String modelVFXId;

     {
      .conditionValueType = ValueType.Absolute;
   }

    ModelParticle[] getParticles() {
       .particles;
   }

    String  {
       .model;
   }

    String  {
       .texture;
   }

    FloatRange  {
       .condition;
   }

    ValueType  {
       .conditionValueType;
   }

    String  {
       .modelVFXId;
   }

    String  {
       .worldSoundEventId;
   }

      {
       .worldSoundEventIndex;
   }

    String  {
       .localSoundEventId;
   }

      {
       .localSoundEventIndex;
   }

   
    com.hypixel.hytale.protocol.ItemAppearanceCondition  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ItemAppearanceCondition();
       (.particles !=  && .particles.length > ) {
         packet.particles =  .hypixel.hytale.protocol.ModelParticle[.particles.length];

         (   ; i < .particles.length; ++i) {
            packet.particles[i] = .particles[i].toPacket();
         }
      }

       (.firstPersonParticles !=  && .firstPersonParticles.length > ) {
         packet.firstPersonParticles =  .hypixel.hytale.protocol.ModelParticle[.firstPersonParticles.length];

         (   ; i < .firstPersonParticles.length; ++i) {
            packet.firstPersonParticles[i] = .firstPersonParticles[i].toPacket();
         }
      }

      packet.model = .model;
      packet.texture = .texture;
      packet.condition =  .hypixel.hytale.protocol.FloatRange(.condition.getInclusiveMin(), .condition.getInclusiveMax());
      packet.conditionValueType = .conditionValueType;
      packet.modelVFXId = .modelVFXId;
      packet.localSoundEventId = .localSoundEventIndex !=  ? .localSoundEventIndex : .worldSoundEventIndex;
      packet.worldSoundEventId = .worldSoundEventIndex;
       packet;
   }

   
    String  {
         Arrays.toString(.particles);
        + var10000 +  + Arrays.toString(.firstPersonParticles) +  + .worldSoundEventId +  + .localSoundEventId +  + .model +  + .texture +  + String.valueOf(.condition) +  + String.valueOf(.conditionValueType) +  + .modelVFXId + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ItemAppearanceCondition.class, ItemAppearanceCondition::).append( (, ModelParticle.ARRAY_CODEC), (itemAppearanceCondition, modelParticles) -> itemAppearanceCondition.particles = modelParticles, (itemAppearanceCondition) -> itemAppearanceCondition.particles).add()).append( (, ModelParticle.ARRAY_CODEC), (itemAppearanceCondition, modelParticles) -> itemAppearanceCondition.firstPersonParticles = modelParticles, (itemAppearanceCondition) -> itemAppearanceCondition.firstPersonParticles).add()).append( (, Codec.STRING), (itemAppearanceCondition, s) -> itemAppearanceCondition.model = s, (itemAppearanceCondition) -> itemAppearanceCondition.model).addValidator(CommonAssetValidator.MODEL_CHARACTER).add()).append( (, Codec.STRING), (itemAppearanceCondition, s) -> itemAppearanceCondition.texture = s, (itemAppearanceCondition) -> itemAppearanceCondition.texture).addValidator(CommonAssetValidator.TEXTURE_CHARACTER).add()).append( (, Codec.STRING), (itemAppearanceCondition, s) -> itemAppearanceCondition.modelVFXId = s, (itemAppearanceCondition) -> itemAppearanceCondition.modelVFXId).addValidator(ModelVFX.VALIDATOR_CACHE.getValidator()).add()).append( (, Codec.STRING), (activationEffects, s) -> activationEffects.worldSoundEventId = s, (activationEffects) -> activationEffects.worldSoundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.MONO).addValidator(SoundEventValidators.LOOPING).documentation().add()).append( (, Codec.STRING), (activationEffects, s) -> activationEffects.localSoundEventId = s, (activationEffects) -> activationEffects.localSoundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.LOOPING).documentation().add()).append( (, FloatRange.CODEC), (itemAppearanceCondition, intRange) -> itemAppearanceCondition.condition = intRange, (itemAppearanceCondition) -> itemAppearanceCondition.condition).documentation().addValidator(Validators.nonNull()).add()).append( (,  (ValueType.class)), (itemAppearanceCondition, conditionValueType) -> itemAppearanceCondition.conditionValueType = conditionValueType, (itemAppearanceCondition) -> itemAppearanceCondition.conditionValueType).documentation().addValidator(Validators.nonNull()).add()).afterDecode((condition) -> {
          (condition.worldSoundEventId != ) {
            condition.worldSoundEventIndex = SoundEvent.getAssetMap().getIndex(condition.worldSoundEventId);
         }

          (condition.localSoundEventId != ) {
            condition.localSoundEventIndex = SoundEvent.getAssetMap().getIndex(condition.localSoundEventId);
         }

      })).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/ItemArmor.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.codecs.map.EnumMapCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.protocol.Cosmetic;
import com.hypixel.hytale.protocol.ItemArmorSlot;
import com.hypixel.hytale.protocol.Modifier;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
import com.hypixel.hytale.server.core.modules.entitystats.EntityStatMap;
import com.hypixel.hytale.server.core.modules.entitystats.EntityStatsModule;
import com.hypixel.hytale.server.core.modules.entitystats.RegeneratingValue;
import com.hypixel.hytale.server.core.modules.entitystats.asset.EntityStatType;
import com.hypixel.hytale.server.core.modules.entitystats.modifier.StaticModifier;
import com.hypixel.hytale.server.core.modules.interaction.interaction.config.server.combat.DamageClass;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
 java.util.Map;
 java.util.logging.Level;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;

    <com.hypixel.hytale.protocol.ItemArmor> {
      BuilderCodec<ItemArmor> CODEC;
   
    ItemArmorSlot armorSlot;
   
    Map<String, StaticModifier[]> damageResistanceValuesRaw;
   
    Map<DamageCause, StaticModifier[]> damageResistanceValues;
   
    Map<String, StaticModifier[]> damageEnhancementValuesRaw;
   
    Map<DamageCause, StaticModifier[]> damageEnhancementValues;
     baseDamageResistance;
   
    Map<String, StaticModifier[]> rawStatModifiers;
   
    Int2ObjectMap<StaticModifier[]> statModifiers;
    Cosmetic[] cosmeticsToHide;
   
    Map<String, EntityStatType.Regenerating[]> regenerating;
   
    Int2ObjectMap<List<RegeneratingValue>> regeneratingValues;
   
    Map<String, Float> knockbackResistancesRaw;
   
    Map<DamageCause, Float> knockbackResistances;
   
    Map<String, Float> knockbackEnhancementsRaw;
   
    Map<DamageCause, Float> knockbackEnhancements;
   
    Map<String, Map<String, StaticModifier>> interactionModifiersRaw;
   
    Map<String, Int2ObjectMap<StaticModifier>> interactionModifiers;
   
    Map<DamageClass, StaticModifier[]> damageClassEnhancement;

     {
      .armorSlot = ItemArmorSlot.Head;
      .damageClassEnhancement = Collections.emptyMap();
      .armorSlot = armorSlot;
      .baseDamageResistance = baseDamageResistance;
      .statModifiers = statModifiers;
      .cosmeticsToHide = cosmeticsToHide;
   }

     {
      .armorSlot = ItemArmorSlot.Head;
      .damageClassEnhancement = Collections.emptyMap();
   }

   
    com.hypixel.hytale.protocol.ItemArmor  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ItemArmor();
      packet.armorSlot = .armorSlot;
      packet.cosmeticsToHide = .cosmeticsToHide;
      packet.statModifiers = EntityStatMap.toPacket(.statModifiers);
      packet.baseDamageResistance = .baseDamageResistance;
       (.damageResistanceValues !=  && !.damageResistanceValues.isEmpty()) {
         Map<String, Modifier[]> damageResistanceMap =  <String, Modifier[]>();

         (Map.Entry<DamageCause, StaticModifier[]> entry : .damageResistanceValues.entrySet()) {
             (entry.getKey() !=  && entry.getValue() != ) {
               Modifier[] modifiers =  [((StaticModifier[])entry.getValue()).length];

               (   ; i < ((StaticModifier[])entry.getValue()).length; ++i) {
                  modifiers[i] = ((StaticModifier[])entry.getValue())[i].toPacket();
               }

               damageResistanceMap.put(((DamageCause)entry.getKey()).getId(), modifiers);
            }
         }

         packet.damageResistance = damageResistanceMap.isEmpty() ?  : damageResistanceMap;
      }

       (.damageClassEnhancement !=  && !.damageClassEnhancement.isEmpty()) {
         Map<String, Modifier[]> damageClassEnhancementMap =  <String, Modifier[]>();

         (Map.Entry<DamageClass, StaticModifier[]> entry : .damageClassEnhancement.entrySet()) {
             (entry.getKey() !=  && entry.getValue() != ) {
               Modifier[] modifiers =  [((StaticModifier[])entry.getValue()).length];

               (   ; i < ((StaticModifier[])entry.getValue()).length; ++i) {
                  modifiers[i] = ((StaticModifier[])entry.getValue())[i].toPacket();
               }

               damageClassEnhancementMap.put(((DamageClass)entry.getKey()).name().toLowerCase(), modifiers);
            }
         }

         packet.damageClassEnhancement = damageClassEnhancementMap.isEmpty() ?  : damageClassEnhancementMap;
      }

       (.damageEnhancementValues !=  && !.damageEnhancementValues.isEmpty()) {
         Map<String, Modifier[]> damageEnhancementMap =  <String, Modifier[]>();

         (Map.Entry<DamageCause, StaticModifier[]> entry : .damageEnhancementValues.entrySet()) {
             (entry.getKey() !=  && entry.getValue() != ) {
               Modifier[] modifiers =  [((StaticModifier[])entry.getValue()).length];

               (   ; i < ((StaticModifier[])entry.getValue()).length; ++i) {
                  modifiers[i] = ((StaticModifier[])entry.getValue())[i].toPacket();
               }

               damageEnhancementMap.put(((DamageCause)entry.getKey()).getId(), modifiers);
            }
         }

         packet.damageEnhancement = damageEnhancementMap.isEmpty() ?  : damageEnhancementMap;
      }

       packet;
   }

    ItemArmorSlot  {
       .armorSlot;
   }

      {
       .baseDamageResistance;
   }

   
    Int2ObjectMap<List<RegeneratingValue>>  {
       .regeneratingValues;
   }

   
    Int2ObjectMap<StaticModifier[]> getStatModifiers() {
       .statModifiers;
   }

   
    Map<DamageCause, StaticModifier[]> getDamageResistanceValues() {
       .damageResistanceValues;
   }

   
    Map<DamageCause, StaticModifier[]> getDamageEnhancementValues() {
       .damageEnhancementValues;
   }

   
    Map<DamageClass, StaticModifier[]> getDamageClassEnhancement() {
       .damageClassEnhancement;
   }

   
    Map<DamageCause, Float>  {
       .knockbackEnhancements;
   }

   
    Map<DamageCause, Float>  {
       .knockbackResistances;
   }

   
    Int2ObjectMap<StaticModifier>  {
       .interactionModifiers ==  ?  : (Int2ObjectMap).interactionModifiers.get(Key);
   }

       {
      processStatModifiers(item);
      processRegenModifiers(item);
      processInteractionModifiers(item);
      item.damageResistanceValues = convertStringKeyToDamageCause(item.damageResistanceValuesRaw);
      item.damageEnhancementValues = convertStringKeyToDamageCause(item.damageEnhancementValuesRaw);
      item.knockbackResistances = convertStringKeyToDamageCause(item.knockbackResistancesRaw);
      item.knockbackEnhancements = convertStringKeyToDamageCause(item.knockbackEnhancementsRaw);
   }

       {
      item.statModifiers = EntityStatsModule.resolveEntityStats(item.rawStatModifiers);
   }

       {
       (item.regenerating != ) {
         Int2ObjectMap<List<RegeneratingValue>> values =  <List<RegeneratingValue>>();

         (Map.Entry<String, EntityStatType.Regenerating[]> entry : item.regenerating.entrySet()) {
               EntityStatType.getAssetMap().getIndex((String)entry.getKey());
             (index != -) {
               EntityStatType.Regenerating[] entryValue = (EntityStatType.Regenerating[])entry.getValue();
               List<RegeneratingValue> operatingEntry = (List)values.computeIfAbsent(index, ArrayList::);

               (EntityStatType.Regenerating regen : entryValue) {
                  operatingEntry.add( (regen));
               }
            }
         }

         item.regeneratingValues = values;
      }
   }

       {
       (item.interactionModifiersRaw != ) {
         Map<String, Int2ObjectMap<StaticModifier>> values =  <String, Int2ObjectMap<StaticModifier>>();

         (Map.Entry<String, Map<String, StaticModifier>> entry : item.interactionModifiersRaw.entrySet()) {
               (String)entry.getKey();

            (Map.Entry<String, StaticModifier> stat : ((Map)entry.getValue()).entrySet()) {
                  EntityStatType.getAssetMap().getIndex((String)stat.getKey());
                (index != -) {
                     (StaticModifier)stat.getValue();
                  Int2ObjectMap<StaticModifier> statModMap = (Int2ObjectMap)values.computeIfAbsent(key, (k) ->  ());
                   (statModMap.get(index) == ) {
                     statModMap.put(index,  (statValue.getTarget(), statValue.getCalculationType(), statValue.getAmount()));
                  }  {
                        HytaleLogger.forEnclosingClass();
                     LOGGER.at(Level.SEVERE).log(, key, stat.getKey(), item.armorSlot.name());
                  }
               }
            }
         }

         item.interactionModifiers = values;
      }
   }

     <T> Map<DamageCause, T>  {
      Map<DamageCause, T> values =  <DamageCause, T>();
       (rawData == ) {
          ;
      }  {
         (Map.Entry<String, T> entry : rawData.entrySet()) {
               (DamageCause)DamageCause.getAssetMap().getAsset((String)entry.getKey());
             (cause != ) {
               values.put(cause, entry.getValue());
            }
         }

          values;
      }
   }

   
    String  {
         String.valueOf(.armorSlot);
        + var10000 +  + String.valueOf(.damageResistanceValues) +  + String.valueOf(.damageEnhancementValues) +  + .baseDamageResistance +  + String.valueOf(.rawStatModifiers) +  + String.valueOf(.statModifiers) +  + Arrays.toString(.cosmeticsToHide) +  + String.valueOf(.regenerating) +  + String.valueOf(.regeneratingValues) +  + String.valueOf(.knockbackResistances) +  + String.valueOf(.knockbackEnhancements) +  + String.valueOf(.interactionModifiersRaw) +  + String.valueOf(.interactionModifiers) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ItemArmor.class, ItemArmor::).append( (,  (ItemArmorSlot.class)), (itemArmor, itemArmorSlot) -> itemArmor.armorSlot = itemArmorSlot, (itemArmor) -> itemArmor.armorSlot).addValidator(Validators.nonNull()).add()).append( (,  ( (StaticModifier.CODEC, (x$) ->  [x$]), HashMap::)), (itemArmor, map) -> itemArmor.damageResistanceValuesRaw = map, (itemArmor) -> itemArmor.damageResistanceValuesRaw).addValidator(DamageCause.VALIDATOR_CACHE.getMapKeyValidator()).add()).append( (,  ( (StaticModifier.CODEC, (x$) ->  [x$]), HashMap::)), (itemArmor, map) -> itemArmor.damageEnhancementValuesRaw = map, (itemArmor) -> itemArmor.damageEnhancementValuesRaw).addValidator(DamageCause.VALIDATOR_CACHE.getMapKeyValidator()).add()).appendInherited( (,  (DamageClass.class,  (StaticModifier.CODEC, (x$) ->  [x$]))), (o, v) -> o.damageClassEnhancement = v, (o) -> o.damageClassEnhancement, (o, p) -> o.damageClassEnhancement = p.damageClassEnhancement).addValidator(Validators.nonNull()).add()).append( (,  (Codec.FLOAT, HashMap::)), (itemArmor, map) -> itemArmor.knockbackResistancesRaw = map, (itemArmor) -> itemArmor.knockbackResistancesRaw).addValidator(DamageCause.VALIDATOR_CACHE.getMapKeyValidator()).add()).append( (,  (Codec.FLOAT, HashMap::)), (itemArmor, map) -> itemArmor.knockbackEnhancementsRaw = map, (itemArmor) -> itemArmor.knockbackEnhancementsRaw).addValidator(DamageCause.VALIDATOR_CACHE.getMapKeyValidator()).add()).append( (,  ( (EntityStatType.Regenerating.CODEC, (x$) ->  .Regenerating[x$]), HashMap::)), (itemArmor, map) -> itemArmor.regenerating = map, (itemArmor) -> itemArmor.regenerating).addValidator(EntityStatType.VALIDATOR_CACHE.getMapKeyValidator()).add()).append( (, Codec.DOUBLE), (itemArmor, d) -> itemArmor.baseDamageResistance = d, (itemArmor) -> itemArmor.baseDamageResistance).add()).append( (,  ( (StaticModifier.CODEC, (x$) ->  [x$]), HashMap::)), (itemArmor, map) -> itemArmor.rawStatModifiers = map, (itemArmor) -> itemArmor.rawStatModifiers).add()).append( (,  ( (StaticModifier.CODEC, HashMap::), HashMap::)), (itemArmor, map) -> itemArmor.interactionModifiersRaw = map, (itemArmor) -> itemArmor.interactionModifiersRaw).add()).append( (,  ( (Cosmetic.class), (x$) ->  [x$])), (item, s) -> item.cosmeticsToHide = s, (item) -> item.cosmeticsToHide).add()).afterDecode((item) -> processConfig(item))).build();
   }

       {
      Dodge;

        {
      }
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/ItemCategory.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.common.util.ArrayUtil;
import com.hypixel.hytale.protocol.ItemGridInfoDisplayMode;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.lang.ref.SoftReference;
import java.util.Arrays;
import java.util.Comparator;
import javax.annotation.Nonnull;

public class ItemCategory implements JsonAssetWithMap<String, DefaultAssetMap<String, ItemCategory>>, NetworkSerializable<com.hypixel.hytale.protocol.ItemCategory> {
   private static final AssetBuilderCodec.Builder<String, ItemCategory> CODEC_BUILDER;
   public static final AssetBuilderCodec<String, ItemCategory> CODEC;
     AssetStore<String, ItemCategory, DefaultAssetMap<String, ItemCategory>> ASSET_STORE;
      ValidatorCache<String> VALIDATOR_CACHE;
    AssetExtraInfo.Data data;
    String id;
    String name;
    String icon;
     order;
   
    ItemGridInfoDisplayMode infoDisplayMode;
    ItemCategory[] children;
    SoftReference<com.hypixel.hytale.protocol.ItemCategory> cachedPacket;

     AssetStore<String, ItemCategory, DefaultAssetMap<String, ItemCategory>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, ItemCategory, DefaultAssetMap<String, ItemCategory>>getAssetStore(ItemCategory.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, ItemCategory>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

     {
      .infoDisplayMode = ItemGridInfoDisplayMode.Tooltip;
      .id = id;
      .name = name;
      .icon = icon;
      .infoDisplayMode = infoDisplayMode;
      .children = children;
   }

     {
      .infoDisplayMode = ItemGridInfoDisplayMode.Tooltip;
   }

   
    com.hypixel.hytale.protocol.ItemCategory  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.ItemCategory).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ItemCategory();
         packet.id = .id;
         packet.name = .name;
         packet.icon = .icon;
         packet.order = .order;
         packet.infoDisplayMode = .infoDisplayMode;
          (.children !=  && .children.length > ) {
            packet.children = (com.hypixel.hytale.protocol.ItemCategory[])ArrayUtil.copyAndMutate(.children, ItemCategory::toPacket, (x$) ->  .hypixel.hytale.protocol.ItemCategory[x$]);
         }

         .cachedPacket =  (packet);
          packet;
      }
   }

    String  {
       .id;
   }

    String  {
       .name;
   }

    String  {
       .icon;
   }

      {
       .order;
   }

    ItemGridInfoDisplayMode  {
       .infoDisplayMode;
   }

    ItemCategory[] getChildren() {
       .children;
   }

   
    String  {
         .id;
        + var10000 +  + .name +  + .icon +  + .order +  + String.valueOf(.infoDisplayMode) +  + Arrays.toString(.children) + ;
   }

    {
      CODEC_BUILDER = (AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(ItemCategory.class, ItemCategory::, Codec.STRING, (itemCategory, k) -> itemCategory.id = k, (itemCategory) -> itemCategory.id, (asset, data) -> asset.data = data, (asset) -> asset.data).addField( (, Codec.STRING), (itemCategory, s) -> itemCategory.id = s, (itemCategory) -> itemCategory.id)).addField( (, Codec.STRING), (itemCategory, s) -> itemCategory.name = s, (itemCategory) -> itemCategory.name)).append( (, Codec.STRING), (itemCategory, s) -> itemCategory.icon = s, (itemCategory) -> itemCategory.icon).addValidator(CommonAssetValidator.ICON_ITEM_CATEGORIES).add()).append( (,  (ItemGridInfoDisplayMode.class), , ), (itemCategory, s) -> itemCategory.infoDisplayMode = s, (itemCategory) -> itemCategory.infoDisplayMode).addValidator(Validators.nonNull()).add()).addField( (, Codec.INTEGER), (itemCategory, s) -> itemCategory.order = s, (itemCategory) -> itemCategory.order)).afterDecode((itemCategory) -> {
          (itemCategory.children != ) {
            Arrays.sort(itemCategory.children, Comparator.comparingInt((value) -> value.order));
         }

      });
      CODEC = CODEC_BUILDER.build();
      CODEC_BUILDER.addField( (,  (CODEC, (x$) ->  [x$])), (itemCategory, l) -> itemCategory.children = l, (itemCategory) -> itemCategory.children);
      VALIDATOR_CACHE =  <String>( (ItemCategory::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/ItemDrop.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.codec.validation.validator.RangeRefValidator;
import java.util.Random;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDocument;

public class ItemDrop {
   public static final BuilderCodec<ItemDrop> CODEC;
   protected String itemId;
   protected BsonDocument metadata;
   protected int quantityMin = 1;
   protected int quantityMax = 1;

   public ItemDrop(String itemId, BsonDocument metadata, int quantityMin, int quantityMax) {
      this.itemId = itemId;
      this.metadata = metadata;
      this.quantityMin = quantityMin;
      this.quantityMax = quantityMax;
   }

   protected ItemDrop() {
   }

   public String getItemId {
       .itemId;
   }

   
    BsonDocument  {
       .metadata ==  ?  : .metadata.clone();
   }

      {
       .quantityMin;
   }

      {
       .quantityMax;
   }

      {
       random.nextInt(Math.max(.quantityMax - .quantityMin + , )) + .quantityMin;
   }

   
    String  {
         .itemId;
        + var10000 +  + String.valueOf(.metadata) +  + .quantityMin +  + .quantityMax + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ItemDrop.class, ItemDrop::).append( (, Codec.STRING), (itemDrop, s) -> itemDrop.itemId = s, (itemDrop) -> itemDrop.itemId).addValidatorLate(() -> Item.VALIDATOR_CACHE.getValidator().late()).add()).addField( (, Codec.BSON_DOCUMENT), (itemDrop, document) -> itemDrop.metadata = document, (itemDrop) -> itemDrop.metadata)).append( (, Codec.INTEGER), (itemDrop, i) -> itemDrop.quantityMin = i, (itemDrop) -> itemDrop.quantityMin).addValidator( ((String), , )).add()).append( (, Codec.INTEGER), (itemDrop, i) -> itemDrop.quantityMax = i, (itemDrop) -> itemDrop.quantityMax).addValidator(Validators.greaterThan()).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/ItemDropList.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.server.core.asset.type.item.config.container.ItemDropContainer;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.util.List;
import javax.annotation.Nonnull;

public class ItemDropList implements JsonAssetWithMap<String, DefaultAssetMap<String, ItemDropList>> {
   public static final AssetBuilderCodec<String, ItemDropList> CODEC;
   public static final Codec<String> CHILD_ASSET_CODEC;
   public static final ValidatorCache<String> VALIDATOR_CACHE;
   private static AssetStore<String, ItemDropList, DefaultAssetMap<String, ItemDropList>> ASSET_STORE;
   protected AssetExtraInfo.Data data;
   protected String id;
   protected ItemDropContainer container;

     AssetStore<String, ItemDropList, DefaultAssetMap<String, ItemDropList>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, ItemDropList, DefaultAssetMap<String, ItemDropList>>getAssetStore(ItemDropList.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, ItemDropList>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

     {
      .id = id;
      .container = container;
   }

     {
   }

    String  {
       .id;
   }

    ItemDropContainer  {
       .container;
   }

   
    String  {
         .id;
        + var10000 +  + String.valueOf(.container) + ;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(ItemDropList.class, ItemDropList::, Codec.STRING, (itemDropList, s) -> itemDropList.id = s, (itemDropList) -> itemDropList.id, (asset, data) -> asset.data = data, (asset) -> asset.data).appendInherited( (, ItemDropContainer.CODEC), (itemDropList, o) -> itemDropList.container = o, (itemDropList) -> itemDropList.container, (itemDropList, parent) -> itemDropList.container = parent.container).add()).validator((asset, results) -> {
            asset.getContainer();
          (container != ) {
            List<ItemDrop> allDrops = container.getAllDrops( ());
             (allDrops.isEmpty()) {
               results.fail();
            }

         }
      })).build();
      CHILD_ASSET_CODEC =  (ItemDropList.class, CODEC);
      VALIDATOR_CACHE =  <String>( (ItemDropList::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/ItemEntityConfig.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.Color;
import com.hypixel.hytale.server.core.asset.type.particle.config.ParticleSystem;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import com.hypixel.hytale.server.core.modules.physics.component.PhysicsValues;
import javax.annotation.Nonnull;

public class ItemEntityConfig implements NetworkSerializable<com.hypixel.hytale.protocol.ItemEntityConfig> {
   public static final String DEFAULT_PARTICLE_SYSTEM_ID = "Item";
   public static final ItemEntityConfig DEFAULT = new ItemEntityConfig("Item", (Color)null, true);
   public static final ItemEntityConfig DEFAULT_BLOCK = new ItemEntityConfig((String)null, (Color)null, );
      BuilderCodec<ItemEntityConfig> CODEC;
        (, , );
       ;
    Float ttl;
       ;
    Color particleColor;
       ;

     {
   }

     {
      .particleSystemId = particleSystemId;
      .particleColor = particleColor;
      .showItemParticles = showItemParticles;
   }

    PhysicsValues  {
       .physicsValues;
   }

      {
       .pickupRadius;
   }

    Float  {
       .ttl;
   }

   
    com.hypixel.hytale.protocol.ItemEntityConfig  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ItemEntityConfig();
      packet.particleSystemId = .particleSystemId;
      packet.particleColor = .particleColor;
      packet.showItemParticles = .showItemParticles;
       packet;
   }

   
    String  {
         String.valueOf(.physicsValues);
        + var10000 +  + .pickupRadius +  + .ttl + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ItemEntityConfig.class, ItemEntityConfig::).appendInherited( (, PhysicsValues.CODEC), (itemEntityConfig, physicsValues) -> itemEntityConfig.physicsValues = physicsValues, (itemEntityConfig) -> itemEntityConfig.physicsValues, (o, p) -> o.physicsValues = p.physicsValues).add()).appendInherited( (, Codec.FLOAT), (itemEntityConfig, box) -> itemEntityConfig.pickupRadius = box, (itemEntityConfig) -> itemEntityConfig.pickupRadius, (o, p) -> o.pickupRadius = p.pickupRadius).add()).appendInherited( (, Codec.FLOAT), (itemEntityConfig, v) -> itemEntityConfig.ttl = v, (itemEntityConfig) -> itemEntityConfig.ttl, (o, p) -> o.ttl = p.ttl).add()).appendInherited( (, Codec.STRING), (o, i) -> o.particleSystemId = i, (o) -> o.particleSystemId, (o, p) -> o.particleSystemId = p.particleSystemId).addValidator(ParticleSystem.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, ProtocolCodecs.COLOR), (o, i) -> o.particleColor = i, (o) -> o.particleColor, (o, p) -> o.particleColor = p.particleColor).add()).appendInherited( (, Codec.BOOLEAN), (o, i) -> o.showItemParticles = i, (o) -> o.showItemParticles, (o, p) -> o.showItemParticles = p.showItemParticles).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/ItemGlider.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.server.core.io.NetworkSerializable;

public class ItemGlider implements NetworkSerializable<com.hypixel.hytale.protocol.ItemGlider> {
   public static final BuilderCodec<ItemGlider> CODEC;
   protected float terminalVelocity;
   protected float fallSpeedMultiplier;
   protected float horizontalSpeedMultiplier;
   protected float speed;

   public ItemGlider() {
   }

   public float getTerminalVelocity() {
      return this.terminalVelocity;
   }

   public float getFallSpeedMultiplier() {
      return this.fallSpeedMultiplier;
   }

   public float getHorizontalSpeedMultiplier() {
      return this.horizontalSpeedMultiplier;
   }

   public float  {
       .speed;
   }

    com.hypixel.hytale.protocol.ItemGlider  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ItemGlider();
      packet.terminalVelocity = .terminalVelocity;
      packet.fallSpeedMultiplier = .fallSpeedMultiplier;
      packet.horizontalSpeedMultiplier = .horizontalSpeedMultiplier;
      packet.speed = .speed;
       packet;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ItemGlider.class, ItemGlider::).appendInherited( (, Codec.FLOAT), (o, i) -> o.terminalVelocity = i, (o) -> o.terminalVelocity, (o, p) -> o.terminalVelocity = p.terminalVelocity).documentation().add()).appendInherited( (, Codec.FLOAT), (o, i) -> o.fallSpeedMultiplier = i, (o) -> o.fallSpeedMultiplier, (o, p) -> o.fallSpeedMultiplier = p.fallSpeedMultiplier).documentation().add()).appendInherited( (, Codec.FLOAT), (o, i) -> o.horizontalSpeedMultiplier = i, (o) -> o.horizontalSpeedMultiplier, (o, p) -> o.horizontalSpeedMultiplier = p.horizontalSpeedMultiplier).documentation().add()).appendInherited( (, Codec.FLOAT), (o, i) -> o.speed = i, (o) -> o.speed, (o, p) -> o.speed = p.speed).documentation().add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/ItemPullbackConfig.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.math.vector.Vector3d;
import com.hypixel.hytale.protocol.ItemPullbackConfiguration;
import com.hypixel.hytale.protocol.Vector3f;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ItemPullbackConfig implements NetworkSerializable<ItemPullbackConfiguration> {
   public static final BuilderCodec<ItemPullbackConfig> CODEC;
   @Nullable
   protected Vector3f leftOffsetOverride;
   @Nullable
   protected Vector3f leftRotationOverride;
   @Nullable
   protected Vector3f rightOffsetOverride;
   @Nullable
   protected Vector3f rightRotationOverride;

   ItemPullbackConfig() {
   }

   public ItemPullbackConfig(Vector3f leftOffsetOverride, Vector3f leftRotationOverride, Vector3f rightOffsetOverride, Vector3f rightRotationOverride) {
      this.leftOffsetOverride = leftOffsetOverride;
      this.leftRotationOverride = leftRotationOverride;
      this.rightOffsetOverride = rightOffsetOverride;
      this.rightRotationOverride = rightRotationOverride;
   }

   @Nonnull
   public ItemPullbackConfiguration toPacket {
          ();
      packet.leftOffsetOverride = .leftOffsetOverride;
      packet.leftRotationOverride = .leftRotationOverride;
      packet.rightOffsetOverride = .rightOffsetOverride;
      packet.rightRotationOverride = .rightRotationOverride;
       packet;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ItemPullbackConfig.class, ItemPullbackConfig::).append( (, Vector3d.AS_ARRAY_CODEC), (pullbackConfig, offOverride) -> pullbackConfig.leftOffsetOverride = offOverride ==  ?  :  (()offOverride.getX(), ()offOverride.getY(), ()offOverride.getZ()), (pullbackConfig) -> pullbackConfig.leftOffsetOverride ==  ?  :  (()pullbackConfig.leftOffsetOverride.x, ()pullbackConfig.leftOffsetOverride.y, ()pullbackConfig.leftOffsetOverride.z)).add()).append( (, Vector3d.AS_ARRAY_CODEC), (pullbackConfig, rotOverride) -> pullbackConfig.leftRotationOverride = rotOverride ==  ?  :  (()rotOverride.getX(), ()rotOverride.getY(), ()rotOverride.getZ()), (pullbackConfig) -> pullbackConfig.leftRotationOverride ==  ?  :  (()pullbackConfig.leftRotationOverride.x, ()pullbackConfig.leftRotationOverride.y, ()pullbackConfig.leftRotationOverride.z)).add()).append( (, Vector3d.AS_ARRAY_CODEC), (pullbackConfig, offOverride) -> pullbackConfig.rightOffsetOverride = offOverride ==  ?  :  (()offOverride.getX(), ()offOverride.getY(), ()offOverride.getZ()), (pullbackConfig) -> pullbackConfig.rightOffsetOverride ==  ?  :  (()pullbackConfig.rightOffsetOverride.x, ()pullbackConfig.rightOffsetOverride.y, ()pullbackConfig.rightOffsetOverride.z)).add()).append( (, Vector3d.AS_ARRAY_CODEC), (pullbackConfig, rotOverride) -> pullbackConfig.rightRotationOverride = rotOverride ==  ?  :  (()rotOverride.getX(), ()rotOverride.getY(), ()rotOverride.getZ()), (pullbackConfig) -> pullbackConfig.rightRotationOverride ==  ?  :  (()pullbackConfig.rightRotationOverride.x, ()pullbackConfig.rightRotationOverride.y, ()pullbackConfig.rightRotationOverride.z)).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/ItemQuality.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditor;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.Color;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import com.hypixel.hytale.server.core.asset.util.ColorParseUtil;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.lang.ref.SoftReference;
import javax.annotation.Nonnull;

public class ItemQuality implements JsonAssetWithMap<String, IndexedLookupTableAssetMap<String, ItemQuality>>, NetworkSerializable<com.hypixel.hytale.protocol.ItemQuality> {
   @Nonnull
   public static final AssetBuilderCodec<String, ItemQuality> CODEC;
   public static final int DEFAULT_INDEX  ;
         ;
   
      ItemQuality DEFAULT_ITEM_QUALITY;
   
      ValidatorCache<String> VALIDATOR_CACHE;
     AssetStore<String, ItemQuality, IndexedLookupTableAssetMap<String, ItemQuality>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
     qualityValue;
    String itemTooltipTexture;
    String itemTooltipArrowTexture;
    String slotTexture;
    String blockSlotTexture;
    String specialSlotTexture;
    Color textColor;
    String localizationKey;
     visibleQualityLabel;
     renderSpecialSlot;
    ItemEntityConfig itemEntityConfig;
       ;
     SoftReference<com.hypixel.hytale.protocol.ItemQuality> cachedPacket;

   
     AssetStore<String, ItemQuality, IndexedLookupTableAssetMap<String, ItemQuality>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, ItemQuality, IndexedLookupTableAssetMap<String, ItemQuality>>getAssetStore(ItemQuality.class);
      }

       ASSET_STORE;
   }

   
     IndexedLookupTableAssetMap<String, ItemQuality>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

     {
      .id = id;
      .qualityValue = qualityValue;
      .itemTooltipTexture = itemTooltipTexture;
      .itemTooltipArrowTexture = itemTooltipArrowTexture;
      .slotTexture = slotTexture;
      .blockSlotTexture = blockSlotTexture;
      .specialSlotTexture = specialSlotTexture;
      .textColor = textColor;
      .localizationKey = localizationKey;
      .visibleQualityLabel = visibleQualityLabel;
      .renderSpecialSlot = renderSpecialSlot;
      .hideFromSearch = hideFromSearch;
      .itemEntityConfig = itemEntityConfig;
   }

     {
      .id = id;
   }

     {
   }

    String  {
       .id;
   }

      {
       .qualityValue;
   }

    String  {
       .itemTooltipTexture;
   }

    String  {
       .itemTooltipArrowTexture;
   }

    String  {
       .slotTexture;
   }

    String  {
       .blockSlotTexture;
   }

    String  {
       .specialSlotTexture;
   }

    Color  {
       .textColor;
   }

    String  {
       .localizationKey;
   }

      {
       .visibleQualityLabel;
   }

      {
       .renderSpecialSlot;
   }

      {
       .hideFromSearch;
   }

    ItemEntityConfig  {
       .itemEntityConfig;
   }

   
    com.hypixel.hytale.protocol.ItemQuality  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.ItemQuality).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ItemQuality();
         packet.id = .id;
         packet.itemTooltipTexture = .itemTooltipTexture;
         packet.itemTooltipArrowTexture = .itemTooltipArrowTexture;
         packet.slotTexture = .slotTexture;
         packet.blockSlotTexture = .blockSlotTexture;
         packet.specialSlotTexture = .specialSlotTexture;
         packet.textColor = .textColor;
         packet.localizationKey = .localizationKey;
         packet.visibleQualityLabel = .visibleQualityLabel;
         packet.renderSpecialSlot = .renderSpecialSlot;
         packet.hideFromSearch = .hideFromSearch;
         .cachedPacket =  (packet);
          packet;
      }
   }

   
    String  {
         .id;
        + var10000 +  + .qualityValue +  + .itemTooltipTexture +  + .itemTooltipArrowTexture +  + .slotTexture +  + .blockSlotTexture +  + .specialSlotTexture +  + String.valueOf(.textColor) +  + .localizationKey +  + .visibleQualityLabel +  + .renderSpecialSlot +  + String.valueOf(.itemEntityConfig) +  + .hideFromSearch + ;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(ItemQuality.class, ItemQuality::, Codec.STRING, (itemQuality, s) -> itemQuality.id = s, ItemQuality::getId, (itemQuality, data) -> itemQuality.data = data, (itemQuality) -> itemQuality.data).append( (, Codec.INTEGER), (itemQuality, integer) -> itemQuality.qualityValue = integer, (itemQuality) -> itemQuality.qualityValue).documentation().add()).append( (, Codec.STRING), (itemQuality, s) -> itemQuality.itemTooltipTexture = s, (itemQuality) -> itemQuality.itemTooltipTexture).documentation().addValidator(Validators.nonNull()).addValidator(Validators.nonEmptyString()).addValidator(CommonAssetValidator.TEXTURE_ITEM_QUALITY).add()).append( (, Codec.STRING), (itemQuality, s) -> itemQuality.itemTooltipArrowTexture = s, (itemQuality) -> itemQuality.itemTooltipArrowTexture).documentation().addValidator(Validators.nonNull()).addValidator(Validators.nonEmptyString()).addValidator(CommonAssetValidator.TEXTURE_ITEM_QUALITY).add()).append( (, Codec.STRING), (itemQuality, s) -> itemQuality.slotTexture = s, (itemQuality) -> itemQuality.slotTexture).documentation().addValidator(Validators.nonNull()).addValidator(Validators.nonEmptyString()).addValidator(CommonAssetValidator.TEXTURE_ITEM_QUALITY).add()).append( (, Codec.STRING), (itemQuality, s) -> itemQuality.blockSlotTexture = s, (itemQuality) -> itemQuality.blockSlotTexture).documentation().addValidator(Validators.nonNull()).addValidator(Validators.nonEmptyString()).addValidator(CommonAssetValidator.TEXTURE_ITEM_QUALITY).add()).append( (, Codec.STRING), (itemQuality, s) -> itemQuality.specialSlotTexture = s, (itemQuality) -> itemQuality.specialSlotTexture).documentation().addValidator(Validators.nonNull()).addValidator(Validators.nonEmptyString()).addValidator(CommonAssetValidator.TEXTURE_ITEM_QUALITY).add()).append( (, ProtocolCodecs.COLOR), (itemQuality, s) -> itemQuality.textColor = s, (itemQuality) -> itemQuality.textColor).documentation().addValidator(Validators.nonNull()).add()).append( (, Codec.STRING), (itemQuality, s) -> itemQuality.localizationKey = s, (itemQuality) -> itemQuality.localizationKey).documentation().addValidator(Validators.nonNull()).addValidator(Validators.nonEmptyString()).metadata( ( .LocalizationKeyField(, ))).add()).append( (, Codec.BOOLEAN), (itemQuality, aBoolean) -> itemQuality.visibleQualityLabel = aBoolean, (itemQuality) -> itemQuality.visibleQualityLabel).documentation().add()).append( (, Codec.BOOLEAN), (itemQuality, aBoolean) -> itemQuality.renderSpecialSlot = aBoolean, (itemQuality) -> itemQuality.renderSpecialSlot).documentation().add()).append( (, ItemEntityConfig.CODEC), (itemQuality, itemEntityConfig) -> itemQuality.itemEntityConfig = itemEntityConfig, (itemQuality) -> itemQuality.itemEntityConfig).documentation().add()).append( (, Codec.BOOLEAN), (itemQuality, aBoolean) -> itemQuality.hideFromSearch = aBoolean, (itemQuality) -> itemQuality.hideFromSearch).documentation().add()).build();
      DEFAULT_ITEM_QUALITY =  () {
         {
            .qualityValue = -;
            .itemTooltipTexture = ;
            .itemTooltipArrowTexture = ;
            .slotTexture = ;
            .blockSlotTexture = ;
            .specialSlotTexture = ;
            .textColor = ColorParseUtil.hexStringToColor();
            .localizationKey = ;
            .hideFromSearch = ;
         }
      };
      VALIDATOR_CACHE =  <String>( (ItemQuality::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/ItemReticleConfig.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.codecs.map.EnumMapCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.ItemReticleClientEvent;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.lang.ref.SoftReference;
import java.util.Arrays;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.Nonnull;

public class ItemReticleConfig implements JsonAssetWithMap<String, IndexedLookupTableAssetMap<String, ItemReticleConfig>>, NetworkSerializable<com.hypixel.hytale.protocol.ItemReticleConfig> {
      AssetBuilderCodec<String, ItemReticleConfig> CODEC;
         ;
         ;
      ItemReticleConfig DEFAULT;
      ValidatorCache<String> VALIDATOR_CACHE;
     AssetStore<String, ItemReticleConfig, IndexedLookupTableAssetMap<String, ItemReticleConfig>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
    String[] base;
    Map<String, ItemReticleWithDuration> serverEvents;
    Int2ObjectMap<ItemReticleWithDuration> indexedServerEvents;
    Map<ItemReticleClientEvent, ItemReticle> clientEvents;
    SoftReference<com.hypixel.hytale.protocol.ItemReticleConfig> cachedPacket;

     AssetStore<String, ItemReticleConfig, IndexedLookupTableAssetMap<String, ItemReticleConfig>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, ItemReticleConfig, IndexedLookupTableAssetMap<String, ItemReticleConfig>>getAssetStore(ItemReticleConfig.class);
      }

       ASSET_STORE;
   }

     IndexedLookupTableAssetMap<String, ItemReticleConfig>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

     {
   }

     {
      .id = id;
   }

      {
       (.serverEvents !=  && !.serverEvents.isEmpty()) {
         .indexedServerEvents =  <ItemReticleWithDuration>();
         .serverEvents.forEach((event, config) -> .indexedServerEvents.put(AssetRegistry.getOrCreateTagIndex(event), config));
      }

   }

    String  {
       .id;
   }

   
    com.hypixel.hytale.protocol.ItemReticleConfig  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.ItemReticleConfig).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ItemReticleConfig();
         packet.base = .base;
          (.indexedServerEvents != ) {
            packet.serverEvents =  ();

            (Int2ObjectMap.Entry<ItemReticleWithDuration> event : .indexedServerEvents.int2ObjectEntrySet()) {
               packet.serverEvents.put(event.getIntKey(), ((ItemReticleWithDuration)event.getValue()).toPacket());
            }
         }

          (.clientEvents != ) {
            packet.clientEvents =  (ItemReticleClientEvent.class);

            (Map.Entry<ItemReticleClientEvent, ItemReticle> event : .clientEvents.entrySet()) {
               packet.clientEvents.put((ItemReticleClientEvent)event.getKey(), ((ItemReticle)event.getValue()).toPacket());
            }
         }

         .cachedPacket =  (packet);
          packet;
      }
   }

   
    String  {
         .id;
        + var10000 +  + Arrays.toString(.base) +  + String.valueOf(.serverEvents) +  + String.valueOf(.indexedServerEvents) +  + String.valueOf(.clientEvents) + ;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(ItemReticleConfig.class, ItemReticleConfig::, Codec.STRING, (itemReticleConfig, s) -> itemReticleConfig.id = s, (itemReticleConfig) -> itemReticleConfig.id, (asset, data) -> asset.data = data, (asset) -> asset.data).appendInherited( (,  (Codec.STRING, (x$) ->  [x$])), (itemReticleConfig, o) -> itemReticleConfig.base = o, (itemReticleConfig) -> itemReticleConfig.base, (itemReticleConfig, parent) -> itemReticleConfig.base = parent.base).documentation().addValidator(Validators.nonNull()).addValidator(Validators.nonEmptyArray()).addValidator(CommonAssetValidator.UI_RETICLE_PARTS_ARRAY).add()).appendInherited( (,  (ItemReticleConfig.ItemReticleWithDuration.CODEC, HashMap::)), (itemReticleConfig, o) -> itemReticleConfig.serverEvents = o, (itemReticleConfig) -> itemReticleConfig.serverEvents, (itemReticleConfig, parent) -> itemReticleConfig.serverEvents = parent.serverEvents).documentation().add()).appendInherited( (,  (ItemReticleClientEvent.class, ItemReticleConfig.ItemReticle.CODEC)), (itemReticleConfig, o) -> itemReticleConfig.clientEvents = o, (itemReticleConfig) -> itemReticleConfig.clientEvents, (itemReticleConfig, parent) -> itemReticleConfig.clientEvents = parent.clientEvents).documentation().add()).afterDecode(ItemReticleConfig::processConfig)).build();
      DEFAULT =  () {
         {
            .base =  []{};
         }
      };
      VALIDATOR_CACHE =  <String>( (ItemReticleConfig::getAssetStore));
   }

       <com.hypixel.hytale.protocol.ItemReticle> {
         BuilderCodec<ItemReticle> CODEC;
        hideBase;
       String[] parts;

        {
         .hideBase = hideBase;
         .parts = parts;
      }

        {
      }

      
       com.hypixel.hytale.protocol.ItemReticle  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ItemReticle();
         packet.hideBase = .hideBase;
         packet.parts = .parts;
          packet;
      }

      
       String  {
            .hideBase;
           + var10000 +  + Arrays.toString(.parts) + ;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ItemReticle.class, ItemReticle::).append( (, Codec.BOOLEAN), (itemReticle, o) -> itemReticle.hideBase = o, (itemReticle) -> itemReticle.hideBase).documentation().add()).append( (,  (Codec.STRING, (x$) ->  [x$])), (itemReticle, o) -> itemReticle.parts = o, (itemReticle) -> itemReticle.parts).documentation().addValidator(Validators.nonNull()).addValidator(Validators.nonEmptyArray()).addValidator(CommonAssetValidator.UI_RETICLE_PARTS_ARRAY).add()).build();
      }
   }

        {
         BuilderCodec<ItemReticleWithDuration> CODEC;
          ;

        {
         .hideBase = hideBase;
         .parts = parts;
         .duration = duration;
      }

        {
      }

      
       com.hypixel.hytale.protocol.ItemReticle  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ItemReticle();
         packet.hideBase = .hideBase;
         packet.parts = .parts;
         packet.duration = .duration;
          packet;
      }

      
       String  {
            .duration;
           + var10000 +  + .toString();
      }

       {
         CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(ItemReticleWithDuration.class, ItemReticleWithDuration::, ItemReticleConfig.ItemReticle.CODEC).append( (, Codec.FLOAT), (itemReticle, value) -> itemReticle.duration = value, (itemReticle) -> itemReticle.duration).documentation().addValidator(Validators.greaterThan()).add()).build();
      }
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/ItemStackContainerConfig.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterType;
import javax.annotation.Nonnull;

public class ItemStackContainerConfig {
   public static final ItemStackContainerConfig DEFAULT = new ItemStackContainerConfig();
   public static final BuilderCodec<ItemStackContainerConfig> CODEC;
   protected short capacity = 0;
   protected FilterType globalFilter;
   protected String tag;
   protected volatile int tagIndex;

   public ItemStackContainerConfig() {
      this.globalFilter = FilterType.ALLOW_ALL;
      this.tagIndex = -2147483648;
   }

   public short getCapacity() {
      return this.capacity;
   }

   public FilterType  {
       .globalFilter;
   }

      {
       .tagIndex;
   }

   
    String  {
         .capacity;
        + var10000 +  + String.valueOf(.globalFilter) +  + .tag + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ItemStackContainerConfig.class, ItemStackContainerConfig::).append( (, Codec.SHORT), (itemTool, s) -> itemTool.capacity = s, (itemTool) -> itemTool.capacity).add()).append( (, FilterType.CODEC), (itemTool, s) -> itemTool.globalFilter = s, (itemTool) -> itemTool.globalFilter).add()).append( (, Codec.STRING), (materialQuantity, s) -> materialQuantity.tag = s, (materialQuantity) -> materialQuantity.tag).add()).afterDecode((config, extraInfo) -> {
          (config.tag != ) {
            config.tagIndex = AssetRegistry.getOrCreateTagIndex(config.tag);
         }

      })).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/ItemTool.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.common.util.ArrayUtil;
import com.hypixel.hytale.server.core.asset.type.blockset.config.BlockSet;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
import com.hypixel.hytale.server.core.asset.type.soundevent.validator.SoundEventValidators;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.util.Arrays;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ItemTool implements NetworkSerializable<com.hypixel.hytale.protocol.ItemTool> {
   public static final BuilderCodec<ItemTool> CODEC;
   protected ItemToolSpec[] specs;
   protected float speed;
   protected DurabilityLossBlockTypes[] durabilityLossBlockTypes;
   @Nullable
   protected String hitSoundLayerId = null;
   protected transient int hitSoundLayerIndex = 0;
   
       ;
        ;

     {
      .specs = specs;
      .speed = speed;
      .durabilityLossBlockTypes = durabilityLossBlockTypes;
   }

     {
   }

      {
       (.hitSoundLayerId != ) {
         .hitSoundLayerIndex = SoundEvent.getAssetMap().getIndex(.hitSoundLayerId);
      }

       (.incorrectMaterialSoundLayerId != ) {
         .incorrectMaterialSoundLayerIndex = SoundEvent.getAssetMap().getIndex(.incorrectMaterialSoundLayerId);
      }

   }

   
    com.hypixel.hytale.protocol.ItemTool  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ItemTool();
       (.specs !=  && .specs.length > ) {
         packet.specs = (com.hypixel.hytale.protocol.ItemToolSpec[])ArrayUtil.copyAndMutate(.specs, ItemToolSpec::toPacket, (x$) ->  .hypixel.hytale.protocol.ItemToolSpec[x$]);
      }

      packet.speed = .speed;
       packet;
   }

    ItemToolSpec[] getSpecs() {
       .specs;
   }

      {
       .speed;
   }

    DurabilityLossBlockTypes[] getDurabilityLossBlockTypes() {
       .durabilityLossBlockTypes;
   }

      {
       .hitSoundLayerIndex;
   }

      {
       .incorrectMaterialSoundLayerIndex;
   }

   
    String  {
         Arrays.toString(.specs);
        + var10000 +  + .speed +  + Arrays.toString(.durabilityLossBlockTypes) +  + .hitSoundLayerId +  + .hitSoundLayerIndex +  + .incorrectMaterialSoundLayerId +  + .incorrectMaterialSoundLayerIndex + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ItemTool.class, ItemTool::).addField( (,  (ItemToolSpec.CODEC, (x$) ->  [x$])), (itemTool, s) -> itemTool.specs = s, (itemTool) -> itemTool.specs)).addField( (, Codec.DOUBLE), (itemTool, d) -> itemTool.speed = d.floatValue(), (itemTool) -> ()itemTool.speed)).addField( (,  (ItemTool.DurabilityLossBlockTypes.CODEC, (x$) ->  [x$])), (item, s) -> item.durabilityLossBlockTypes = s, (item) -> item.durabilityLossBlockTypes)).appendInherited( (, Codec.STRING), (item, s) -> item.hitSoundLayerId = s, (item) -> item.hitSoundLayerId, (item, parent) -> item.hitSoundLayerId = parent.hitSoundLayerId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.MONO).documentation().add()).appendInherited( (, Codec.STRING), (item, s) -> item.incorrectMaterialSoundLayerId = s, (item) -> item.incorrectMaterialSoundLayerId, (item, parent) -> item.incorrectMaterialSoundLayerId = parent.incorrectMaterialSoundLayerId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.MONO).documentation().add()).afterDecode(ItemTool::processConfig)).build();
   }

       {
         BuilderCodec<DurabilityLossBlockTypes> CODEC;
       String[] blockTypes;
       String[] blockSets;
        durabilityLossOnHit;
       [] blockTypeIndexes;
       [] blockSetIndexes;

        {
      }

        {
         .blockTypes = blockTypes;
         .blockSets = blockSets;
         .durabilityLossOnHit = durabilityLossOnHit;
      }

       String[] getBlockTypes() {
          .blockTypes;
      }

       String[] getBlockSets() {
          .blockSets;
      }

         {
          .durabilityLossOnHit;
      }

       [] getBlockTypeIndexes() {
          (.blockTypes !=  && .blockTypeIndexes == ) {
            [] blockTypeIndexes =  [.blockTypes.length];

            (   ; i < .blockTypes.length; ++i) {
                  .blockTypes[i];
                  BlockType.getAssetMap().getIndex(key);
                (index == -) {
                    ( + key);
               }

               blockTypeIndexes[i] = index;
            }

            .blockTypeIndexes = blockTypeIndexes;
         }

          .blockTypeIndexes;
      }

       [] getBlockSetIndexes() {
          .blockSetIndexes;
      }

      
       String  {
            Arrays.toString(.blockTypes);
           + var10000 +  + Arrays.toString(.blockSets) +  + .durabilityLossOnHit + ;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(DurabilityLossBlockTypes.class, DurabilityLossBlockTypes::).addField( (,  (Codec.STRING, (x$) ->  [x$])), (item, s) -> item.blockTypes = s, (item) -> item.blockTypes)).addField( (, Codec.STRING_ARRAY), (item, s) -> item.blockSets = s, (item) -> item.blockSets)).addField( (, Codec.DOUBLE), (item, s) -> item.durabilityLossOnHit = s, (item) -> item.durabilityLossOnHit)).afterDecode((item) -> {
             (item.blockSets != ) {
               item.blockSetIndexes =  [item.blockSets.length];

               (   ; i < item.blockSets.length; ++i) {
                     item.blockSets[i];
                     BlockSet.getAssetMap().getIndex(blockSet);
                   (index == -) {
                       ( + blockSet);
                  }

                  item.blockSetIndexes[i] = index;
               }
            }

         })).build();
      }
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/ItemToolSpec.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.codec.AssetCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
import com.hypixel.hytale.server.core.asset.type.soundevent.validator.SoundEventValidators;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.lang.ref.SoftReference;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ItemToolSpec implements JsonAssetWithMap<String, DefaultAssetMap<String, ItemToolSpec>>, NetworkSerializable<com.hypixel.hytale.protocol.ItemToolSpec> {
   public static final AssetCodec<String, ItemToolSpec> CODEC;
   public static final ValidatorCache<String> VALIDATOR_CACHE;
   private static AssetStore<String, ItemToolSpec, DefaultAssetMap<String, ItemToolSpec>> ASSET_STORE;
   protected AssetExtraInfo.Data data;
   protected String gatherType;
     power;
     quality;
     incorrect;
   
       ;
        ;
    SoftReference<com.hypixel.hytale.protocol.ItemToolSpec> cachedPacket;

     AssetStore<String, ItemToolSpec, DefaultAssetMap<String, ItemToolSpec>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, ItemToolSpec, DefaultAssetMap<String, ItemToolSpec>>getAssetStore(ItemToolSpec.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, ItemToolSpec>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

     {
      .gatherType = gatherType;
      .power = power;
      .quality = quality;
   }

     {
   }

      {
       (.hitSoundLayerId != ) {
         .hitSoundLayerIndex = SoundEvent.getAssetMap().getIndex(.hitSoundLayerId);
      }

   }

   
    com.hypixel.hytale.protocol.ItemToolSpec  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.ItemToolSpec).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ItemToolSpec();
         packet.gatherType = .gatherType;
         packet.power = .power;
         packet.quality = .quality;
         .cachedPacket =  (packet);
          packet;
      }
   }

    String  {
       .gatherType;
   }

    String  {
       .gatherType;
   }

      {
       .power;
   }

      {
       .quality;
   }

      {
       .incorrect;
   }

      {
       .hitSoundLayerIndex;
   }

   
    String  {
        + .gatherType +  + .power +  + .quality +  + .incorrect +  + .hitSoundLayerId +  + .hitSoundLayerIndex + ;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(ItemToolSpec.class, ItemToolSpec::, Codec.STRING, (itemToolSpec, s) -> itemToolSpec.gatherType = s, (itemToolSpec) -> itemToolSpec.gatherType, (asset, data) -> asset.data = data, (asset) -> asset.data).addField( (, Codec.STRING), (itemToolSpec, s) -> itemToolSpec.gatherType = s, (itemToolSpec) -> itemToolSpec.gatherType)).addField( (, Codec.DOUBLE), (itemToolSpec, d) -> itemToolSpec.power = d.floatValue(), (itemToolSpec) -> ()itemToolSpec.power)).addField( (, Codec.INTEGER), (itemToolSpec, i) -> itemToolSpec.quality = i, (itemToolSpec) -> itemToolSpec.quality)).addField( (, Codec.BOOLEAN), (itemToolSpec, i) -> itemToolSpec.incorrect = i, (itemToolSpec) -> itemToolSpec.incorrect)).appendInherited( (, Codec.STRING), (spec, s) -> spec.hitSoundLayerId = s, (spec) -> spec.hitSoundLayerId, (spec, parent) -> spec.hitSoundLayerId = parent.hitSoundLayerId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.MONO).documentation().add()).afterDecode(ItemToolSpec::processConfig)).build();
      VALIDATOR_CACHE =  <String>( (ItemToolSpec::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/ItemTranslationProperties.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditor;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ItemTranslationProperties implements NetworkSerializable<com.hypixel.hytale.protocol.ItemTranslationProperties> {
   public static final BuilderCodec<ItemTranslationProperties> CODEC;
   @Nullable
   private String name;
   @Nullable
   private String description;

   ItemTranslationProperties() {
   }

   public ItemTranslationProperties(@Nonnull String name, @Nonnull String description) {
      this.name = name;
      this.description = description;
   }

   @Nullable
   public String getName() {
      return this.name;
   }

   @Nullable
   public String getDescription() {
      return this.description;
   }

   @Nonnull
   public com.hypixel.hytale.protocol.ItemTranslationProperties  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ItemTranslationProperties();
      packet.name = .name;
      packet.description = .description;
       packet;
   }

   
    String  {
        + .name +  + .description + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ItemTranslationProperties.class, ItemTranslationProperties::).appendInherited( (, Codec.STRING), (data, s) -> data.name = s, (data) -> data.name, (o, p) -> o.name = p.name).documentation().metadata( ( .LocalizationKeyField(, ))).add()).appendInherited( (, Codec.STRING), (data, s) -> data.description = s, (data) -> data.description, (o, p) -> o.description = p.description).documentation().metadata( ( .LocalizationKeyField())).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/ItemUtility.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import com.hypixel.hytale.server.core.modules.entitystats.EntityStatMap;
import com.hypixel.hytale.server.core.modules.entitystats.EntityStatsModule;
import com.hypixel.hytale.server.core.modules.entitystats.asset.EntityStatType;
import com.hypixel.hytale.server.core.modules.entitystats.modifier.StaticModifier;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ItemUtility implements NetworkSerializable<com.hypixel.hytale.protocol.ItemUtility> {
   public static final ItemUtility DEFAULT = new ItemUtility();
   public static final BuilderCodec<ItemUtility> CODEC;
   protected boolean usable;
   protected boolean compatible;
   @Nullable
    Map<String, StaticModifier[]> rawStatModifiers;
   
    Int2ObjectMap<StaticModifier[]> statModifiers;
    String[] rawEntityStatsToClear;
   
    [] entityStatsToClear;

     {
   }

      {
       .usable;
   }

      {
       .compatible;
   }

   
    Int2ObjectMap<StaticModifier[]> getStatModifiers() {
       .statModifiers;
   }

    [] getEntityStatsToClear() {
       .entityStatsToClear;
   }

   
    com.hypixel.hytale.protocol.ItemUtility  {
        .hypixel.hytale.protocol.ItemUtility(.usable, .compatible, .entityStatsToClear, EntityStatMap.toPacket(.statModifiers));
   }

   
    String  {
         .usable;
        + var10000 +  + .compatible +  + String.valueOf(.rawStatModifiers) +  + String.valueOf(.statModifiers) +  + Arrays.toString(.rawEntityStatsToClear) +  + Arrays.toString(.entityStatsToClear) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ItemUtility.class, ItemUtility::).append( (, Codec.BOOLEAN), (o, v) -> o.usable = v, (o) -> o.usable).add()).append( (, Codec.BOOLEAN), (o, v) -> o.compatible = v, (o) -> o.compatible).add()).append( (,  ( (StaticModifier.CODEC, (x$) ->  [x$]), HashMap::)), (itemArmor, map) -> itemArmor.rawStatModifiers = map, (itemArmor) -> itemArmor.rawStatModifiers).addValidator(EntityStatType.VALIDATOR_CACHE.getMapKeyValidator().late()).add()).append( (, Codec.STRING_ARRAY), (itemUtility, strings) -> itemUtility.rawEntityStatsToClear = strings, (itemUtility) -> itemUtility.rawEntityStatsToClear).add()).afterDecode((item) -> {
         item.statModifiers = EntityStatsModule.resolveEntityStats(item.rawStatModifiers);
         item.entityStatsToClear = EntityStatsModule.resolveEntityStats(item.rawEntityStatsToClear);
      })).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/ItemWeapon.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import com.hypixel.hytale.server.core.modules.entitystats.EntityStatMap;
import com.hypixel.hytale.server.core.modules.entitystats.EntityStatsModule;
import com.hypixel.hytale.server.core.modules.entitystats.asset.EntityStatType;
import com.hypixel.hytale.server.core.modules.entitystats.modifier.StaticModifier;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ItemWeapon implements NetworkSerializable<com.hypixel.hytale.protocol.ItemWeapon> {
   public static final BuilderCodec<ItemWeapon> CODEC;
   @Nullable
   protected Map<String, StaticModifier[]> rawStatModifiers;
   @Nullable
   protected Int2ObjectMap<StaticModifier[]> statModifiers;
   protected String[] rawEntityStatsToClear;
   @Nullable
   protected int[] entityStatsToClear;
   protected boolean renderDualWielded;

     {
   }

   
    Int2ObjectMap<StaticModifier[]> getStatModifiers() {
       .statModifiers;
   }

    [] getEntityStatsToClear() {
       .entityStatsToClear;
   }

   
    com.hypixel.hytale.protocol.ItemWeapon  {
        .hypixel.hytale.protocol.ItemWeapon(.entityStatsToClear, EntityStatMap.toPacket(.statModifiers), .renderDualWielded);
   }

   
    String  {
         String.valueOf(.rawStatModifiers);
        + var10000 +  + String.valueOf(.statModifiers) +  + Arrays.toString(.rawEntityStatsToClear) +  + Arrays.toString(.entityStatsToClear) +  + .renderDualWielded + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ItemWeapon.class, ItemWeapon::).append( (,  ( (StaticModifier.CODEC, (x$) ->  [x$]), HashMap::)), (itemArmor, map) -> itemArmor.rawStatModifiers = map, (itemArmor) -> itemArmor.rawStatModifiers).addValidator(EntityStatType.VALIDATOR_CACHE.getMapKeyValidator().late()).add()).append( (, Codec.STRING_ARRAY), (itemWeapon, strings) -> itemWeapon.rawEntityStatsToClear = strings, (itemWeapon) -> itemWeapon.rawEntityStatsToClear).add()).append( (, Codec.BOOLEAN), (itemWeapon, value) -> itemWeapon.renderDualWielded = value, (itemWeapon) -> itemWeapon.renderDualWielded).add()).afterDecode((item) -> {
         item.statModifiers = EntityStatsModule.resolveEntityStats(item.rawStatModifiers);
         item.entityStatsToClear = EntityStatsModule.resolveEntityStats(item.rawEntityStatsToClear);
      })).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/PortalKey.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.server.core.asset.type.portalworld.PortalType;

public class PortalKey {
   public static final BuilderCodec<PortalKey> CODEC;
   private String portalTypeId;
   private int timeLimitSeconds = -1;

   public PortalKey() {
   }

   public String getPortalTypeId() {
      return this.portalTypeId;
   }

   public int getTimeLimitSeconds() {
      return this.timeLimitSeconds;
   }

   public String toString() {
      return "PortalKey{instanceId='" + this.portalTypeId + "', timeLimitSeconds=" + this.timeLimitSeconds + "}";
   }

   static {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(PortalKey.class, PortalKey::new).appendInherited( (, Codec.STRING), (portalKey, o) -> portalKey.portalTypeId = o, (portalKey) -> portalKey.portalTypeId, (portalKey, parent) -> portalKey.portalTypeId = parent.portalTypeId).documentation().addValidator(Validators.nonNull()).addValidator(PortalType.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, Codec.INTEGER), (portalKey, o) -> portalKey.timeLimitSeconds = o, (portalKey) -> portalKey.timeLimitSeconds, (portalKey, parent) -> portalKey.timeLimitSeconds = parent.timeLimitSeconds).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/ResourceType.java

package com.hypixel.hytale.server.core.asset.type.item.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.lang.ref.SoftReference;
import javax.annotation.Nonnull;

public class ResourceType implements JsonAssetWithMap<String, DefaultAssetMap<String, ResourceType>>, NetworkSerializable<com.hypixel.hytale.protocol.ResourceType> {
   public static final AssetBuilderCodec<String, ResourceType> CODEC;
   public static final ValidatorCache<String> VALIDATOR_CACHE;
   private static AssetStore<String, ResourceType, DefaultAssetMap<String, ResourceType>> ASSET_STORE;
   protected AssetExtraInfo.Data data;
   protected String id;
   protected String name;
   protected String description;
   protected String icon;
   private SoftReference<com.hypixel.hytale.protocol.ResourceType> cachedPacket;

     AssetStore<String, ResourceType, DefaultAssetMap<String, ResourceType>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, ResourceType, DefaultAssetMap<String, ResourceType>>getAssetStore(ResourceType.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, ResourceType>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

     {
      .id = id;
      .name = name;
      .description = description;
      .icon = icon;
   }

     {
   }

    String  {
       .id;
   }

    String  {
       .name;
   }

    String  {
       .description;
   }

    String  {
       .icon;
   }

   
    com.hypixel.hytale.protocol.ResourceType  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.ResourceType).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ResourceType(.id, .icon);
         .cachedPacket =  (packet);
          packet;
      }
   }

   
    String  {
        + .id +  + .name +  + .description +  + .icon + ;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(ResourceType.class, ResourceType::, Codec.STRING, (resourceType, k) -> resourceType.id = k, (resourceType) -> resourceType.id, (asset, data) -> asset.data = data, (asset) -> asset.data).appendInherited( (, Codec.STRING), (resourceType, s) -> resourceType.name = s, (resourceType) -> resourceType.name, (resourceType, parent) -> resourceType.name = parent.name).add()).appendInherited( (, Codec.STRING), (resourceType, s) -> resourceType.description = s, (resourceType) -> resourceType.description, (resourceType, parent) -> resourceType.description = parent.description).add()).appendInherited( (, Codec.STRING), (resourceType, s) -> resourceType.icon = s, (resourceType) -> resourceType.icon, (resourceType, parent) -> resourceType.icon = parent.icon).addValidator(CommonAssetValidator.ICON_RESOURCE).add()).build();
      VALIDATOR_CACHE =  <String>( (ResourceType::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/container/ChoiceItemDropContainer.java

package com.hypixel.hytale.server.core.asset.type.item.config.container;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.common.map.IWeightedMap;
import com.hypixel.hytale.common.map.WeightedMap;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemDrop;
import com.hypixel.hytale.server.core.codec.WeightedMapCodec;
import java.util.List;
import java.util.Set;
import java.util.function.DoubleSupplier;
import javax.annotation.Nonnull;

public class ChoiceItemDropContainer extends ItemDropContainer {
   public static final BuilderCodec<ChoiceItemDropContainer> CODEC;
   protected IWeightedMap<ItemDropContainer> containers;
   protected int rollsMin = 1;
   protected int rollsMax = 1;

   public ChoiceItemDropContainer(ItemDropContainer[] containers, double chance) {
      super(chance);
      this.containers = WeightedMap.<ItemDropContainer>builder(ItemDropContainer.EMPTY_ARRAY).putAll(containers, ItemDropContainer::getWeight).build();
   }

   public ChoiceItemDropContainer {
   }

      {
         .rollsMin + ()(chanceProvider.getAsDouble() * ()(.rollsMax - .rollsMin + ));

      (   ; i < count; ++i) {
            (ItemDropContainer).containers.get(chanceProvider);
         drop.populateDrops(drops, chanceProvider, droplistReferences);
      }

   }

    List<ItemDrop>  {
      (ItemDropContainer container : (ItemDropContainer[]).containers.internalKeys()) {
         container.getAllDrops(list);
      }

       list;
   }

   
    String  {
         .weight;
        + var10000 +  + String.valueOf(.containers) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ChoiceItemDropContainer.class, ChoiceItemDropContainer::, ItemDropContainer.DEFAULT_CODEC).addField( (,  (ItemDropContainer.CODEC, ItemDropContainer.EMPTY_ARRAY)), (choiceItemDropContainer, o) -> choiceItemDropContainer.containers = o, (choiceItemDropContainer) -> choiceItemDropContainer.containers)).addField( (, Codec.INTEGER), (choiceItemDropContainer, i) -> choiceItemDropContainer.rollsMin = i, (choiceItemDropContainer) -> choiceItemDropContainer.rollsMin)).addField( (, Codec.INTEGER), (choiceItemDropContainer, i) -> choiceItemDropContainer.rollsMax = i, (choiceItemDropContainer) -> choiceItemDropContainer.rollsMax)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/container/DroplistItemDropContainer.java

package com.hypixel.hytale.server.core.asset.type.item.config.container;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemDrop;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemDropList;
import java.util.List;
import java.util.Set;
import java.util.function.DoubleSupplier;

public class DroplistItemDropContainer extends ItemDropContainer {
   public static final BuilderCodec<DroplistItemDropContainer> CODEC;
   String droplistId;

   public DroplistItemDropContainer() {
   }

   protected void populateDrops(List<ItemDrop> drops, DoubleSupplier chanceProvider, Set<String> droplistReferences) {
      if (droplistReferences.add(this.droplistId)) {
         ItemDropList droplist = (ItemDropList)ItemDropList.getAssetMap().getAsset(this.droplistId);
         if (droplist != null) {
            droplist.getContainer().populateDrops(drops, chanceProvider, droplistReferences);
         }
      }
   }

   public List<ItemDrop> getAllDrops(List<ItemDrop> list) {
      ItemDropList   (ItemDropList)ItemDropList.getAssetMap().getAsset(.droplistId);
       (droplist == ) {
          list;
      }  {
         droplist.getContainer().getAllDrops(list);
          list;
      }
   }

    String  {
        + .droplistId +  + .weight + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(DroplistItemDropContainer.class, DroplistItemDropContainer::, ItemDropContainer.DEFAULT_CODEC).append( (, Codec.STRING), (droplistItemDropContainer, s) -> droplistItemDropContainer.droplistId = s, (droplistItemDropContainer) -> droplistItemDropContainer.droplistId).addValidator(Validators.nonNull()).addValidatorLate(() -> ItemDropList.VALIDATOR_CACHE.getValidator().late()).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/container/EmptyItemDropContainer.java

package com.hypixel.hytale.server.core.asset.type.item.config.container;

import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemDrop;
import java.util.List;
import java.util.Set;
import java.util.function.DoubleSupplier;
import javax.annotation.Nonnull;

public class EmptyItemDropContainer extends ItemDropContainer {
   public static final BuilderCodec<EmptyItemDropContainer> CODEC;

   public EmptyItemDropContainer() {
   }

   protected void populateDrops(List<ItemDrop> drops, @Nonnull DoubleSupplier chanceProvider, Set<String> droplistReferences) {
   }

   public List<ItemDrop> getAllDrops(List<ItemDrop> list) {
      return list;
   }

   public String toString() {
      return "EmptyItemDropContainer{}";
   }

   static {
      CODEC = BuilderCodec.builder(EmptyItemDropContainer.class, EmptyItemDropContainer::new, ItemDropContainer.DEFAULT_CODEC).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/container/ItemDropContainer.java

package com.hypixel.hytale.server.core.asset.type.item.config.container;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.lookup.CodecMapCodec;
import com.hypixel.hytale.common.map.IWeightedElement;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemDrop;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.function.DoubleSupplier;

public abstract class ItemDropContainer implements IWeightedElement {
   public static final BuilderCodec<ItemDropContainer> DEFAULT_CODEC;
   public static final CodecMapCodec<ItemDropContainer> CODEC;
   public static final ItemDropContainer[] EMPTY_ARRAY;
   protected double weight = 100.0;

   public ItemDropContainer(double weight) {
      this.weight = weight;
   }

   protected ItemDropContainer() {
   }

   public double getWeight {
       .weight;
   }

      {
      Set<String> droplistReferences =  ();
      droplistReferences.add(droplistId);
      .populateDrops(drops, chanceProvider, droplistReferences);
   }

      ;

     List<ItemDrop> ;

    {
      DEFAULT_CODEC = ((BuilderCodec.Builder)BuilderCodec.abstractBuilder(ItemDropContainer.class).addField( (, Codec.DOUBLE), (itemDropContainer, aDouble) -> itemDropContainer.weight = aDouble, (itemDropContainer) -> itemDropContainer.weight)).build();
      CODEC =  <ItemDropContainer>();
      EMPTY_ARRAY =  [];
      CODEC.register((String), MultipleItemDropContainer.class, MultipleItemDropContainer.CODEC);
      CODEC.register((String), ChoiceItemDropContainer.class, ChoiceItemDropContainer.CODEC);
      CODEC.register((String), SingleItemDropContainer.class, SingleItemDropContainer.CODEC);
      CODEC.register((String), DroplistItemDropContainer.class, DroplistItemDropContainer.CODEC);
      CODEC.register((String), EmptyItemDropContainer.class, EmptyItemDropContainer.CODEC);
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/container/MultipleItemDropContainer.java

package com.hypixel.hytale.server.core.asset.type.item.config.container;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.math.util.MathUtil;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemDrop;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.function.DoubleSupplier;
import javax.annotation.Nonnull;

public class MultipleItemDropContainer extends ItemDropContainer {
   public static final BuilderCodec<MultipleItemDropContainer> CODEC;
   protected ItemDropContainer[] containers;
   protected int minCount = 1;
   protected int maxCount = 1;

   public MultipleItemDropContainer(ItemDropContainer[] containers, double chance, int minCount, int maxCount) {
      super(chance);
      this.containers = containers;
      this.minCount = minCount;
      this.maxCount = maxCount;
   }

     {
   }

      {
         ()MathUtil.fastRound(chanceProvider.getAsDouble() * ()(.maxCount - .minCount) + ().minCount);

      (   ; i < count; ++i) {
         (ItemDropContainer container : .containers) {
             (container.getWeight() >= chanceProvider.getAsDouble() * ) {
               container.populateDrops(drops, chanceProvider, droplistReferences);
            }
         }
      }

   }

    List<ItemDrop>  {
      (ItemDropContainer container : .containers) {
         container.getAllDrops(list);
      }

       list;
   }

   
    String  {
         .weight;
        + var10000 +  + Arrays.toString(.containers) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(MultipleItemDropContainer.class, MultipleItemDropContainer::, ItemDropContainer.DEFAULT_CODEC).addField( (, Codec.INTEGER), (multipleItemDropContainer, integer) -> multipleItemDropContainer.minCount = integer, (multipleItemDropContainer) -> multipleItemDropContainer.minCount)).addField( (, Codec.INTEGER), (multipleItemDropContainer, integer) -> multipleItemDropContainer.maxCount = integer, (multipleItemDropContainer) -> multipleItemDropContainer.maxCount)).addField( (,  (ItemDropContainer.CODEC, (x$) ->  [x$])), (multipleItemDropContainer, o) -> multipleItemDropContainer.containers = o, (multipleItemDropContainer) -> multipleItemDropContainer.containers)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/container/SingleItemDropContainer.java

package com.hypixel.hytale.server.core.asset.type.item.config.container;

import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemDrop;
import java.util.List;
import java.util.Set;
import java.util.function.DoubleSupplier;
import javax.annotation.Nonnull;

public class SingleItemDropContainer extends ItemDropContainer {
   public static final BuilderCodec<SingleItemDropContainer> CODEC;
   @Nonnull
   protected ItemDrop drop;

   public SingleItemDropContainer(@Nonnull ItemDrop drop, double chance) {
      super(chance);
      this.drop = drop;
   }

   protected SingleItemDropContainer() {
   }

   @Nonnull
   public ItemDrop getDrop() {
      return this.drop;
   }

   protected void populateDrops(@Nonnull List<ItemDrop> drops, DoubleSupplier chanceProvider, Set<String> droplistReferences) {
      drops.add(this.drop);
   }

   
    List<ItemDrop>  {
      list.add(.drop);
       list;
   }

   
    String  {
         String.valueOf(.drop);
        + var10000 +  + .weight + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(SingleItemDropContainer.class, SingleItemDropContainer::, ItemDropContainer.DEFAULT_CODEC).append( (, ItemDrop.CODEC), (singleItemDropContainer, itemDrop) -> singleItemDropContainer.drop = itemDrop, (singleItemDropContainer) -> singleItemDropContainer.drop).addValidator(Validators.nonNull()).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/item/config/metadata/AdventureMetadata.java

package com.hypixel.hytale.server.core.asset.type.item.config.metadata;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;

public class AdventureMetadata {
   public static final String KEY = "Adventure";
   public static final BuilderCodec<AdventureMetadata> CODEC;
   public static final KeyedCodec<AdventureMetadata> KEYED_CODEC;
   private boolean cursed;

   public AdventureMetadata() {
   }

   public boolean isCursed() {
      return this.cursed;
   }

   public void setCursed(boolean cursed) {
      this.cursed = cursed;
   }

   static {
      CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(AdventureMetadata.class, AdventureMetadata::new).appendInherited(new KeyedCodec("Cursed", Codec.BOOLEAN), (meta, s) -> meta.cursed = s, (meta) -> meta.cursed ? Boolean.TRUE : null, (meta, parent) -> meta.cursed = parent.cursed).add()).build();
      KEYED_CODEC =  <AdventureMetadata>(, CODEC);
   }
}

com/hypixel/hytale/server/core/asset/type/itemanimation/ItemPlayerAnimationsPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.itemanimation;

import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateItemPlayerAnimations;
import com.hypixel.hytale.server.core.asset.packet.DefaultAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.itemanimation.config.ItemPlayerAnimations;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class ItemPlayerAnimationsPacketGenerator extends DefaultAssetPacketGenerator<String, ItemPlayerAnimations> {
   public ItemPlayerAnimationsPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(DefaultAssetMap<String, ItemPlayerAnimations> assetMap, @Nonnull Map<String, ItemPlayerAnimations> assets) {
      UpdateItemPlayerAnimations packet = new UpdateItemPlayerAnimations();
      packet.type = UpdateType.Init;
      packet.itemPlayerAnimations = new Object2ObjectOpenHashMap<String, com.hypixel.hytale.protocol.ItemPlayerAnimations>(assets.size());

      for(ItemPlayerAnimations itemPlayerAnimation : assets.values()) {
         packet.itemPlayerAnimations.put(itemPlayerAnimation.getId(), itemPlayerAnimation.toPacket());
      }

      return packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.itemPlayerAnimations =  <String, com.hypixel.hytale.protocol.ItemPlayerAnimations>(loadedAssets.size());

      (ItemPlayerAnimations itemPlayerAnimation : loadedAssets.values()) {
         packet.itemPlayerAnimations.put(itemPlayerAnimation.getId(), itemPlayerAnimation.toPacket());
      }

       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.itemPlayerAnimations =  <String, com.hypixel.hytale.protocol.ItemPlayerAnimations>(removed.size());

      (String key : removed) {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ItemPlayerAnimations();
         itemPlayerAnimation.id = key;
         packet.itemPlayerAnimations.put(key, itemPlayerAnimation);
      }

       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/itemanimation/config/ItemPlayerAnimations.java

package com.hypixel.hytale.server.core.asset.type.itemanimation.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.common.util.MapUtil;
import com.hypixel.hytale.protocol.ItemAnimation;
import com.hypixel.hytale.protocol.WiggleWeights;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemPullbackConfig;
import com.hypixel.hytale.server.core.asset.type.model.config.camera.CameraSettings;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.lang.ref.SoftReference;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.Nonnull;

public class ItemPlayerAnimations implements JsonAssetWithMap<String, DefaultAssetMap<String, ItemPlayerAnimations>>, NetworkSerializable<com.hypixel.hytale.protocol.ItemPlayerAnimations> {
         ;
      BuilderCodec<WiggleWeights> WIGGLE_WEIGHTS_CODEC;
      AssetBuilderCodec<String, ItemPlayerAnimations> CODEC;
      Codec<String> CHILD_CODEC;
      ValidatorCache<String> VALIDATOR_CACHE;
     AssetStore<String, ItemPlayerAnimations, DefaultAssetMap<String, ItemPlayerAnimations>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
    Map<String, ItemAnimation> animations = Collections.emptyMap();
    WiggleWeights wiggleWeights;
    CameraSettings camera;
    ItemPullbackConfig pullbackConfig;
     useFirstPersonOverrides;
    SoftReference<com.hypixel.hytale.protocol.ItemPlayerAnimations> cachedPacket;

     AssetStore<String, ItemPlayerAnimations, DefaultAssetMap<String, ItemPlayerAnimations>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, ItemPlayerAnimations, DefaultAssetMap<String, ItemPlayerAnimations>>getAssetStore(ItemPlayerAnimations.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, ItemPlayerAnimations>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

     {
      .id = id;
      .animations = animations;
      .wiggleWeights = wiggleWeights;
      .camera = camera;
      .pullbackConfig = pullbackConfig;
      .useFirstPersonOverrides = useFirstPersonOverrides;
   }

     {
   }

    String  {
       .id;
   }

    Map<String, ItemAnimation>  {
       .animations;
   }

    WiggleWeights  {
       .wiggleWeights;
   }

    CameraSettings  {
       .camera;
   }

   
    com.hypixel.hytale.protocol.ItemPlayerAnimations  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.ItemPlayerAnimations).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ItemPlayerAnimations();
         packet.id = .id;
         packet.animations = .animations;
         packet.wiggleWeights = .wiggleWeights;
          (.camera != ) {
            packet.camera = .camera.toPacket();
         }

          (.pullbackConfig != ) {
            packet.pullbackConfig = .pullbackConfig.toPacket();
         }

         packet.useFirstPersonOverride = .useFirstPersonOverrides;
         .cachedPacket =  (packet);
          packet;
      }
   }

   
    String  {
         .id;
        + var10000 +  + String.valueOf(.animations) +  + String.valueOf(.wiggleWeights) +  + String.valueOf(.camera) +  + String.valueOf(.pullbackConfig) +  + .useFirstPersonOverrides + ;
   }

    {
      WIGGLE_WEIGHTS_CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(WiggleWeights.class, WiggleWeights::).addField( (, Codec.DOUBLE), (wiggleWeight, d) -> wiggleWeight.x = d.floatValue(), (wiggleWeight) -> ()wiggleWeight.x)).addField( (, Codec.DOUBLE), (wiggleWeight, d) -> wiggleWeight.xDeceleration = d.floatValue(), (wiggleWeight) -> ()wiggleWeight.xDeceleration)).addField( (, Codec.DOUBLE), (wiggleWeight, d) -> wiggleWeight.y = d.floatValue(), (wiggleWeight) -> ()wiggleWeight.y)).addField( (, Codec.DOUBLE), (wiggleWeight, d) -> wiggleWeight.yDeceleration = d.floatValue(), (wiggleWeight) -> ()wiggleWeight.yDeceleration)).addField( (, Codec.DOUBLE), (wiggleWeight, d) -> wiggleWeight.z = d.floatValue(), (wiggleWeight) -> ()wiggleWeight.z)).addField( (, Codec.DOUBLE), (wiggleWeight, d) -> wiggleWeight.zDeceleration = d.floatValue(), (wiggleWeight) -> ()wiggleWeight.zDeceleration)).addField( (, Codec.DOUBLE), (wiggleWeight, d) -> wiggleWeight.roll = d.floatValue(), (wiggleWeight) -> ()wiggleWeight.roll)).addField( (, Codec.DOUBLE), (wiggleWeight, d) -> wiggleWeight.rollDeceleration = d.floatValue(), (wiggleWeight) -> ()wiggleWeight.rollDeceleration)).addField( (, Codec.DOUBLE), (wiggleWeight, d) -> wiggleWeight.pitch = d.floatValue(), (wiggleWeight) -> ()wiggleWeight.pitch)).addField( (, Codec.DOUBLE), (wiggleWeight, d) -> wiggleWeight.pitchDeceleration = d.floatValue(), (wiggleWeight) -> ()wiggleWeight.pitchDeceleration)).build();
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(ItemPlayerAnimations.class, ItemPlayerAnimations::, Codec.STRING, (t, k) -> t.id = k, (t) -> t.id, (asset, data) -> asset.data = data, (asset) -> asset.data).appendInherited( (,  (ProtocolCodecs.ITEM_ANIMATION_CODEC, HashMap::)), (itemPlayerAnimations, map) -> itemPlayerAnimations.animations = MapUtil.<String, ItemAnimation>combineUnmodifiable(itemPlayerAnimations.animations, map), (itemPlayerAnimations) -> itemPlayerAnimations.animations, (itemPlayerAnimations, parent) -> itemPlayerAnimations.animations = parent.animations).addValidator(Validators.nonNull()).add()).appendInherited( (, WIGGLE_WEIGHTS_CODEC), (itemPlayerAnimations, map) -> itemPlayerAnimations.wiggleWeights = map, (itemPlayerAnimations) -> itemPlayerAnimations.wiggleWeights, (itemPlayerAnimations, parent) -> itemPlayerAnimations.wiggleWeights = parent.wiggleWeights).addValidator(Validators.nonNull()).add()).appendInherited( (, CameraSettings.CODEC), (itemPlayerAnimations, o) -> itemPlayerAnimations.camera = o, (itemPlayerAnimations) -> itemPlayerAnimations.camera, (itemPlayerAnimations, parent) -> itemPlayerAnimations.camera = parent.camera).add()).appendInherited( (, ItemPullbackConfig.CODEC), (itemPlayerAnimations, s) -> itemPlayerAnimations.pullbackConfig = s, (itemPlayerAnimations) -> itemPlayerAnimations.pullbackConfig, (itemPlayerAnimations, parent) -> itemPlayerAnimations.pullbackConfig = parent.pullbackConfig).documentation().add()).appendInherited( (, Codec.BOOLEAN), (itemPlayerAnimations, s) -> itemPlayerAnimations.useFirstPersonOverrides = s, (itemPlayerAnimations) -> itemPlayerAnimations.useFirstPersonOverrides, (itemPlayerAnimations, parent) -> itemPlayerAnimations.useFirstPersonOverrides = parent.useFirstPersonOverrides).documentation().add()).build();
      CHILD_CODEC =  (ItemPlayerAnimations.class, CODEC);
      VALIDATOR_CACHE =  <String>( (ItemPlayerAnimations::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/itemsound/ItemSoundSetPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.itemsound;

import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateItemSoundSets;
import com.hypixel.hytale.server.core.asset.packet.SimpleAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.itemsound.config.ItemSoundSet;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class ItemSoundSetPacketGenerator extends SimpleAssetPacketGenerator<String, ItemSoundSet, IndexedLookupTableAssetMap<String, ItemSoundSet>> {
   public ItemSoundSetPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull IndexedLookupTableAssetMap<String, ItemSoundSet> assetMap, @Nonnull Map<String, ItemSoundSet> assets) {
      UpdateItemSoundSets packet = new UpdateItemSoundSets();
      packet.type = UpdateType.Init;
      packet.itemSoundSets = new Int2ObjectOpenHashMap();

      for(Map.Entry<String, ItemSoundSet> entry : assets.entrySet()) {
         String key = (String)entry.getKey();
         int   assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.itemSoundSets.put(index, ((ItemSoundSet)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.itemSoundSets =  ();

      (Map.Entry<String, ItemSoundSet> entry : loadedAssets.entrySet()) {
            (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.itemSoundSets.put(index, ((ItemSoundSet)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.itemSoundSets =  ();

      (String key : removed) {
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.itemSoundSets.put(index, (Object));
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/itemsound/config/ItemSoundSet.java

package com.hypixel.hytale.server.core.asset.type.itemsound.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.map.EnumMapCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIDefaultCollapsedState;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.ItemSoundEvent;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
import com.hypixel.hytale.server.core.asset.type.soundevent.validator.SoundEventValidators;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import it.unimi.dsi.fastutil.objects.Object2IntMap;
import it.unimi.dsi.fastutil.objects.Object2IntMaps;
import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
import java.lang.ref.SoftReference;
import java.util.Collections;
import java.util.Map;
import javax.annotation.Nonnull;

public class ItemSoundSet implements JsonAssetWithMap<String, IndexedLookupTableAssetMap<String, ItemSoundSet>>, NetworkSerializable<com.hypixel.hytale.protocol.ItemSoundSet> {
      AssetBuilderCodec<String, ItemSoundSet> CODEC;
      ValidatorCache<String> VALIDATOR_CACHE;
     AssetStore<String, ItemSoundSet, IndexedLookupTableAssetMap<String, ItemSoundSet>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
    Map<ItemSoundEvent, String> soundEventIds = Collections.emptyMap();
     Object2IntMap<ItemSoundEvent> soundEventIndices = Object2IntMaps.<ItemSoundEvent>emptyMap();
    SoftReference<com.hypixel.hytale.protocol.ItemSoundSet> cachedPacket;

     AssetStore<String, ItemSoundSet, IndexedLookupTableAssetMap<String, ItemSoundSet>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, ItemSoundSet, IndexedLookupTableAssetMap<String, ItemSoundSet>>getAssetStore(ItemSoundSet.class);
      }

       ASSET_STORE;
   }

     IndexedLookupTableAssetMap<String, ItemSoundSet>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

     {
      .id = id;
      .soundEventIds = soundEventIds;
   }

     {
      .id = id;
   }

     {
   }

   
    com.hypixel.hytale.protocol.ItemSoundSet  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.ItemSoundSet).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ItemSoundSet();
         packet.id = .id;
         packet.soundEventIndices = .soundEventIndices;
         .cachedPacket =  (packet);
          packet;
      }
   }

    String  {
       .id;
   }

    Map<ItemSoundEvent, String>  {
       .soundEventIds;
   }

    Object2IntMap<ItemSoundEvent>  {
       .soundEventIndices;
   }

      {
       (!.soundEventIds.isEmpty()) {
         .soundEventIndices =  <ItemSoundEvent>();

         (Map.Entry<ItemSoundEvent, String> entry : .soundEventIds.entrySet()) {
            .soundEventIndices.put((ItemSoundEvent)entry.getKey(), SoundEvent.getAssetMap().getIndex((String)entry.getValue()));
         }
      }

   }

   
    String  {
         .id;
        + var10000 +  + String.valueOf(.soundEventIds) +  + String.valueOf(.soundEventIndices) + ;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(ItemSoundSet.class, ItemSoundSet::, Codec.STRING, (itemSounds, s) -> itemSounds.id = s, (itemSounds) -> itemSounds.id, (asset, data) -> asset.data = data, (asset) -> asset.data).appendInherited( (,  (ItemSoundEvent.class, Codec.STRING)), (itemParticleSet, s) -> itemParticleSet.soundEventIds = s, (itemParticleSet) -> itemParticleSet.soundEventIds, (itemParticleSet, parent) -> itemParticleSet.soundEventIds = parent.soundEventIds).addValidator(Validators.nonNull()).addValidator(SoundEvent.VALIDATOR_CACHE.getMapValueValidator()).addValidator(SoundEventValidators.STEREO_VALIDATOR_CACHE.getMapValueValidator()).addValidator(SoundEventValidators.ONESHOT_VALIDATOR_CACHE.getMapValueValidator()).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).afterDecode(ItemSoundSet::processConfig)).build();
      VALIDATOR_CACHE =  <String>( (ItemSoundSet::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/model/config/DetailBox.java

package com.hypixel.hytale.server.core.asset.type.model.config;

import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.math.shape.Box;
import com.hypixel.hytale.math.vector.Vector3d;
import com.hypixel.hytale.protocol.Vector3f;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import com.hypixel.hytale.server.core.io.NetworkSerializers;
import javax.annotation.Nonnull;

public class DetailBox implements NetworkSerializable<com.hypixel.hytale.protocol.DetailBox> {
   public static final BuilderCodec<DetailBox> CODEC;
   protected Vector3d offset;
   protected Box box;

   public DetailBox() {
      this.offset = Vector3d.ZERO;
      this.box = Box.UNIT;
   }

   public DetailBox(Vector3d offset, Box box) {
      this.offset = Vector3d.ZERO;
      this.box = Box.UNIT;
      this.offset = offset;
      this.box = box;
   }

   public DetailBox(DetailBox other) {
      this.offset = Vector3d.ZERO;
      this.box = Box.UNIT;
      this.offset.assign(other.offset);
      .box.assign(other.box);
   }

    Vector3d  {
       .offset;
   }

    Box  {
       .box;
   }

    DetailBox  {
        (.offset.clone().scale(()scale), .box.clone().scale(scale));
   }

   
    com.hypixel.hytale.protocol.DetailBox  {
        .hypixel.hytale.protocol.DetailBox( (().offset.x, ().offset.y, ().offset.z), NetworkSerializers.BOX.toPacket(.box));
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(DetailBox.class, DetailBox::).appendInherited( (, Vector3d.CODEC), (o, i) -> o.offset = i, (o) -> o.offset, (o, p) -> o.offset = p.offset).addValidator(Validators.nonNull()).add()).appendInherited( (, Box.CODEC), (o, i) -> o.box = i, (o) -> o.box, (o, p) -> o.box = p.box).addValidator(Validators.nonNull()).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/model/config/Model.java

package com.hypixel.hytale.server.core.asset.type.model.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.component.ComponentAccessor;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.math.shape.Box;
import com.hypixel.hytale.protocol.AnimationSet;
import com.hypixel.hytale.protocol.ColorLight;
import com.hypixel.hytale.protocol.ModelTrail;
import com.hypixel.hytale.protocol.MovementStates;
import com.hypixel.hytale.protocol.Phobia;
import com.hypixel.hytale.protocol.Vector3f;
import com.hypixel.hytale.server.core.asset.type.model.config.camera.CameraSettings;
import com.hypixel.hytale.server.core.entity.movement.MovementStatesComponent;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import com.hypixel.hytale.server.core.io.NetworkSerializers;
import com.hypixel.hytale.server.core.modules.physics.component.PhysicsValues;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.lang.ref.SoftReference;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class Model implements <com.hypixel.hytale.protocol.Model> {
         ;
     String modelAssetId;
      scale;
     Map<String, String> randomAttachmentIds;
     ModelAttachment[] attachments;
   
     Box boundingBox;
   
     Box crouchBoundingBox;
     String model;
     String texture;
     String gradientSet;
     String gradientId;
      eyeHeight;
      crouchOffset;
     Map<String, ModelAsset.AnimationSet> animationSetMap;
     CameraSettings camera;
     ColorLight light;
     ModelParticle[] particles;
     ModelTrail[] trails;
     PhysicsValues physicsValues;
     Map<String, DetailBox[]> detailBoxes;
     Phobia phobia;
     String phobiaModelAssetId;
     SoftReference<com.hypixel.hytale.protocol.Model> cachedPacket;

     {
      .modelAssetId = modelAssetId;
      .scale = scale;
      .randomAttachmentIds = randomAttachmentIds;
      .attachments = attachments;
      .boundingBox = boundingBox;
      .model = model;
      .texture = texture;
      .gradientSet = gradientSet;
      .gradientId = gradientId;
      .eyeHeight = eyeHeight;
      .crouchOffset = crouchOffset;
      .animationSetMap = animationSetMap;
      .camera = camera;
      .light = light;
      .particles = particles;
      .trails = trails;
      .physicsValues = physicsValues;
      .detailBoxes = detailBoxes;
      .crouchBoundingBox = boundingBox ==  ?  :  (boundingBox.min.clone(), boundingBox.max.clone().add(, ()crouchOffset, ));
      .phobia = phobia;
      .phobiaModelAssetId = phobiaModelAssetId;
   }

     {
      .modelAssetId = other.modelAssetId;
      .scale = other.scale;
      .randomAttachmentIds = other.randomAttachmentIds;
      .attachments = other.attachments;
      .boundingBox = other.boundingBox;
      .model = other.model;
      .texture = other.texture;
      .gradientSet = other.gradientSet;
      .gradientId = other.gradientId;
      .eyeHeight = other.eyeHeight;
      .crouchOffset = other.crouchOffset;
      .animationSetMap = other.animationSetMap;
      .camera = other.camera;
      .light = other.light;
      .particles = other.particles;
      .trails = other.trails;
      .physicsValues = other.physicsValues;
      .crouchBoundingBox = other.crouchBoundingBox;
      .detailBoxes = other.detailBoxes;
      .phobia = other.phobia;
      .phobiaModelAssetId = other.phobiaModelAssetId;
   }

   
    com.hypixel.hytale.protocol.Model  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.Model).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.Model();
          (.modelAssetId != ) {
            packet.assetId = .modelAssetId;
         }

          (.model != ) {
            packet.path = .model;
         }

          (.texture != ) {
            packet.texture = .texture;
         }   (.model == ) {
            packet.texture = ;
         }  {
            packet.texture = .model.replace(, );
         }

         packet.gradientSet = .gradientSet;
         packet.gradientId = .gradientId;
          (.scale > ) {
            packet.scale = .scale;
         }

          (.eyeHeight > ) {
            packet.eyeHeight = .eyeHeight;
         }

          (.crouchOffset != ) {
            packet.crouchOffset = .crouchOffset;
         }

          (.animationSetMap != ) {
            Map<String, AnimationSet> map =  <String, AnimationSet>(.animationSetMap.size());

            (Map.Entry<String, ModelAsset.AnimationSet> entry : .animationSetMap.entrySet()) {
               map.put((String)entry.getKey(), ((ModelAsset.AnimationSet)entry.getValue()).toPacket((String)entry.getKey()));
            }

            packet.animationSets = map;
         }

          (.attachments !=  && .attachments.length > ) {
            packet.attachments =  .hypixel.hytale.protocol.ModelAttachment[.attachments.length];

            (   ; i < .attachments.length; ++i) {
               packet.attachments[i] = .attachments[i].toPacket();
            }
         }

          (.boundingBox != ) {
            packet.hitbox = NetworkSerializers.BOX.toPacket(.boundingBox);
         }

         packet.light = .light;
          (.particles !=  && .particles.length > ) {
            packet.particles =  .hypixel.hytale.protocol.ModelParticle[.particles.length];

            (   ; i < .particles.length; ++i) {
               packet.particles[i] = .particles[i].toPacket();
            }
         }

         packet.trails = .trails;
          (.camera != ) {
            packet.camera = .camera.toPacket();
         }

          (.detailBoxes != ) {
            Map<String, com.hypixel.hytale.protocol.DetailBox[]> map = packet.detailBoxes =  <String, com.hypixel.hytale.protocol.DetailBox[]>(.detailBoxes.size());

            (Map.Entry<String, DetailBox[]> entry : .detailBoxes.entrySet()) {
               map.put((String)entry.getKey(), (com.hypixel.hytale.protocol.DetailBox[])Arrays.stream((DetailBox[])entry.getValue()).map(NetworkSerializable::toPacket).toArray((x$) ->  .hypixel.hytale.protocol.DetailBox[x$]));
            }
         }

          (.phobia != Phobia.None && .phobiaModelAssetId != ) {
               (ModelAsset)ModelAsset.getAssetMap().getAsset(.phobiaModelAssetId);
             (modelAsset != ) {
                  createUnitScaleModel(modelAsset, .boundingBox);
               packet.phobiaModel = model.toPacket();
               packet.phobia = .phobia;
            }
         }

         .cachedPacket =  (packet);
          packet;
      }
   }

    String  {
       .modelAssetId;
   }

      {
       .scale;
   }

    Map<String, String>  {
       .randomAttachmentIds;
   }

    ModelAttachment[] getAttachments() {
       .attachments;
   }

   
    Box  {
       (movementStates == ) {
          .boundingBox;
      }  {
          !movementStates.crouching && !movementStates.forcedCrouching ? .boundingBox : .crouchBoundingBox;
      }
   }

   
    Box  {
       .boundingBox;
   }

   
    Box  {
       .crouchBoundingBox;
   }

    String  {
       .model;
   }

    String  {
       .texture;
   }

    String  {
       .gradientSet;
   }

    String  {
       .gradientId;
   }

      {
       .eyeHeight;
   }

      {
       .crouchOffset;
   }

    Map<String, ModelAsset.AnimationSet> getAnimationSetMap() {
       .animationSetMap !=  ? .animationSetMap : Collections.emptyMap();
   }

   
    String  {
       (id !=  && .animationSetMap.containsKey(id)) {
          id;
      }  {
          fallbackId !=  && .animationSetMap.containsKey(fallbackId) ? fallbackId : ;
      }
   }

   
    String  {
      (String animationId : preferenceOrder) {
          (animationId !=  && .animationSetMap.containsKey(animationId)) {
             animationId;
         }
      }

       ;
   }

    CameraSettings  {
       .camera;
   }

    ColorLight  {
       .light;
   }

    ModelParticle[] getParticles() {
       .particles;
   }

    ModelTrail[] getTrails() {
       .trails;
   }

    PhysicsValues  {
       .physicsValues;
   }

    Map<String, DetailBox[]> getDetailBoxes() {
       .detailBoxes;
   }

    Phobia  {
       .phobia;
   }

    String  {
       .phobiaModelAssetId;
   }

   
    ModelReference  {
       .equals(.modelAssetId) ? Model.ModelReference.DEFAULT_PLAYER_MODEL :  (.modelAssetId, .scale, .randomAttachmentIds, .animationSetMap == );
   }

      {
       (ref !=  && componentAccessor !=  && ref.isValid()) {
            (MovementStatesComponent)componentAccessor.getComponent(ref, MovementStatesComponent.getComponentType());
          (movementStatesComponent == ) {
             .getEyeHeight();
         }  {
               movementStatesComponent.getMovementStates();
             movementStates.crouching ? .getEyeHeight() + .getCrouchOffset() : .getEyeHeight();
         }
      }  {
          .getEyeHeight();
      }
   }

      {
       ( == o) {
          ;
      }   (o !=  && .getClass() == o.getClass()) {
            (Model)o;
          (Float.compare(model1.scale, .scale) != ) {
             ;
         }   (Float.compare(model1.eyeHeight, .eyeHeight) != ) {
             ;
         }   (Float.compare(model1.crouchOffset, .crouchOffset) != ) {
             ;
         }   (!Objects.equals(.modelAssetId, model1.modelAssetId)) {
             ;
         }   (!Objects.equals(.randomAttachmentIds, model1.randomAttachmentIds)) {
             ;
         }   (!Arrays.equals(.attachments, model1.attachments)) {
             ;
         }   (!Objects.equals(.boundingBox, model1.boundingBox)) {
             ;
         }   (!Objects.equals(.model, model1.model)) {
             ;
         }   (!Objects.equals(.texture, model1.texture)) {
             ;
         }   (!Objects.equals(.gradientSet, model1.gradientSet)) {
             ;
         }   (!Objects.equals(.gradientId, model1.gradientId)) {
             ;
         }   (!Objects.equals(.animationSetMap, model1.animationSetMap)) {
             ;
         }   (!Objects.equals(.camera, model1.camera)) {
             ;
         }   (!Objects.equals(.light, model1.light)) {
             ;
         }   (!Arrays.equals(.particles, model1.particles)) {
             ;
         }  {
             !Arrays.equals(.trails, model1.trails) ?  : Objects.equals(.physicsValues, model1.physicsValues);
         }
      }  {
          ;
      }
   }

      {
         .modelAssetId !=  ? .modelAssetId.hashCode() : ;
      result =  * result + (.scale !=  ? Float.floatToIntBits(.scale) : );
      result =  * result + (.randomAttachmentIds !=  ? .randomAttachmentIds.hashCode() : );
      result =  * result + Arrays.hashCode(.attachments);
      result =  * result + (.boundingBox !=  ? .boundingBox.hashCode() : );
      result =  * result + (.model !=  ? .model.hashCode() : );
      result =  * result + (.texture !=  ? .texture.hashCode() : );
      result =  * result + (.gradientSet !=  ? .gradientSet.hashCode() : );
      result =  * result + (.gradientId !=  ? .gradientId.hashCode() : );
      result =  * result + (.eyeHeight !=  ? Float.floatToIntBits(.eyeHeight) : );
      result =  * result + (.crouchOffset !=  ? Float.floatToIntBits(.crouchOffset) : );
      result =  * result + (.animationSetMap !=  ? .animationSetMap.hashCode() : );
      result =  * result + (.camera !=  ? .camera.hashCode() : );
      result =  * result + (.light !=  ? .light.hashCode() : );
      result =  * result + Arrays.hashCode(.particles);
      result =  * result + Arrays.hashCode(.trails);
      result =  * result + (.physicsValues !=  ? .physicsValues.hashCode() : );
       result;
   }

    String  {
         .modelAssetId;
        + var10000 +  + .scale +  + String.valueOf(.randomAttachmentIds) +  + Arrays.toString(.attachments) +  + String.valueOf(.boundingBox) +  + String.valueOf(.crouchBoundingBox) +  + .model +  + .texture +  + .gradientSet +  + .gradientId +  + .eyeHeight +  + .crouchOffset +  + String.valueOf(.animationSetMap) +  + String.valueOf(.camera) +  + String.valueOf(.light) +  + Arrays.toString(.particles) +  + Arrays.toString(.trails) +  + String.valueOf(.physicsValues) +  + String.valueOf(.detailBoxes) +  + String.valueOf(.phobia) +  + .phobiaModelAssetId + ;
   }

   
     Model  {
       createScaledModel(modelAsset, modelAsset.generateRandomScale());
   }

   
     Model  {
       createScaledModel(modelAsset, scale, modelAsset.generateRandomAttachmentIds(), (Box), );
   }

   
     Model  {
       createScaledModel(modelAsset, , (Map));
   }

   
     Model  {
       createScaledModel(modelAsset, , (Map), boundingBox);
   }

   
     Model  {
       createScaledModel(modelAsset, scale, modelAsset.generateRandomAttachmentIds());
   }

   
     Model  {
       createScaledModel(modelAsset, scale, randomAttachmentIds, (Box), );
   }

   
     Model  {
       createScaledModel(modelAsset, scale, randomAttachmentIds, overrideBoundingBox, );
   }

   
     Model  {
      Objects.requireNonNull(modelAsset, );
       (scale <= ) {
           ();
      }  {
            overrideBoundingBox !=  ? overrideBoundingBox : modelAsset.getBoundingBox();
         Map<String, DetailBox[]> detailBoxes = modelAsset.getDetailBoxes();
            modelAsset.getEyeHeight();
            modelAsset.getCrouchOffset();
            modelAsset.getCamera();
            modelAsset.getPhysicsValues();
         ModelParticle[] particles = modelAsset.getParticles();
         ModelTrail[] trails = modelAsset.getTrails();
          (scale != ) {
            boundingBox = boundingBox.clone().scale(scale);
             (detailBoxes != ) {
               HashMap<String, DetailBox[]> scaledDetailBoxes =  (detailBoxes.size());

               (Map.Entry<String, DetailBox[]> entry : detailBoxes.entrySet()) {
                  scaledDetailBoxes.put((String)entry.getKey(), (DetailBox[])Arrays.stream((DetailBox[])entry.getValue()).map((v) -> v.scaled(scale)).toArray((x$) ->  [x$]));
               }

               detailBoxes = scaledDetailBoxes;
            }

            eyeHeight *= scale;
            crouchOffset *= scale;
             (camera != ) {
               camera = camera.clone().scale(scale);
            }

             (physicsValues != ) {
               physicsValues =  (physicsValues);
               physicsValues.scale(scale);
            }

             (particles != ) {
               ModelParticle[] scaledParticules =  [particles.length];

               (   ; i < particles.length; ++i) {
                  scaledParticules[i] = particles[i].clone().scale(scale);
               }

               particles = scaledParticules;
            }

             (trails != ) {
               ModelTrail[] scaledTrails =  [trails.length];

               (   ; i < trails.length; ++i) {
                     trails[i];
                      (trail);
                   (trail.positionOffset != ) {
                     scaledTrail.positionOffset =  ();
                     scaledTrail.positionOffset.x = trail.positionOffset.x * scale;
                     scaledTrail.positionOffset.y = trail.positionOffset.y * scale;
                     scaledTrail.positionOffset.z = trail.positionOffset.z * scale;
                  }

                  scaledTrails[i] = scaledTrail;
               }

               trails = scaledTrails;
            }
         }

         ModelAttachment[] attachments = modelAsset.getAttachments(randomAttachmentIds);
         Map<String, ModelAsset.AnimationSet> animationSetMap = staticModel ?  : modelAsset.getAnimationSetMap();
           (modelAsset.getId(), scale, randomAttachmentIds, attachments, boundingBox, modelAsset.getModel(), modelAsset.getTexture(), modelAsset.getGradientSet(), modelAsset.getGradientId(), eyeHeight, crouchOffset, animationSetMap, camera, modelAsset.getLight(), particles, trails, physicsValues, detailBoxes, modelAsset.getPhobia(), modelAsset.getPhobiaModelAssetId());
      }
   }

       {
         BuilderCodec<ModelReference> CODEC;
         ModelReference DEFAULT_PLAYER_MODEL;
       String modelAssetId;
        scale;
       Map<String, String> randomAttachmentIds;
        staticModel;

        {
         (modelAssetId, scale, randomAttachmentIds, );
      }

        {
         .modelAssetId = modelAssetId;
         .scale = scale;
         .randomAttachmentIds = randomAttachmentIds;
         .staticModel = staticModel;
      }

        {
      }

       String  {
          .modelAssetId;
      }

         {
          .scale;
      }

       Map<String, String>  {
          .randomAttachmentIds;
      }

         {
          .staticModel;
      }

      
       Model  {
          (.modelAssetId == ) {
             ;
         }  {
               (ModelAsset)ModelAsset.getAssetMap().getAsset(.modelAssetId);
             (modelAsset == ) {
               modelAsset = ModelAsset.DEBUG;
            }

             Model.createScaledModel(modelAsset, .scale, .randomAttachmentIds, (Box), .staticModel);
         }
      }

         {
          ( == o) {
             ;
         }   (o !=  && .getClass() == o.getClass()) {
               (ModelReference)o;
             (Float.compare(that.scale, .scale) != ) {
                ;
            }   (.staticModel != that.staticModel) {
                ;
            }  {
                !Objects.equals(.modelAssetId, that.modelAssetId) ?  : Objects.equals(.randomAttachmentIds, that.randomAttachmentIds);
            }
         }  {
             ;
         }
      }

         {
            .modelAssetId !=  ? .modelAssetId.hashCode() : ;
         result =  * result + (.scale !=  ? Float.floatToIntBits(.scale) : );
         result =  * result + (.randomAttachmentIds !=  ? .randomAttachmentIds.hashCode() : );
         result =  * result + (.staticModel ?  : );
          result;
      }

      
       String  {
            .modelAssetId;
           + var10000 +  + .scale +  + String.valueOf(.randomAttachmentIds) +  + .staticModel + ;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ModelReference.class, ModelReference::).addField( (, Codec.STRING), (modelReference, s) -> modelReference.modelAssetId = s, (modelReference) -> modelReference.modelAssetId)).addField( (, Codec.DOUBLE), (modelReference, aDouble) -> modelReference.scale = aDouble.floatValue(), (modelReference) -> ()modelReference.scale)).addField( (, MapCodec.STRING_HASH_MAP_CODEC), (modelReference, stringStringMap) -> modelReference.randomAttachmentIds = stringStringMap, (modelReference) -> modelReference.randomAttachmentIds)).addField( (, Codec.BOOLEAN), (modelReference, b) -> modelReference.staticModel = b, (modelReference) -> modelReference.staticModel)).build();
         DEFAULT_PLAYER_MODEL =  (, -, (Map), );
      }
   }
}

com/hypixel/hytale/server/core/asset/type/model/config/ModelAsset.java

package com.hypixel.hytale.server.core.asset.type.model.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.codecs.array.IntArrayCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIButton;
import com.hypixel.hytale.codec.schema.metadata.ui.UICreateButtons;
import com.hypixel.hytale.codec.schema.metadata.ui.UIDefaultCollapsedState;
import com.hypixel.hytale.codec.schema.metadata.ui.UIDisplayMode;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditor;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditorPreview;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditorSectionStart;
import com.hypixel.hytale.codec.schema.metadata.ui.UIRebuildCaches;
import com.hypixel.hytale.codec.schema.metadata.ui.UISidebarButtons;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.codec.validation.validator.IntArrayValidator;
 com.hypixel.hytale.common.map.IWeightedMap;
 com.hypixel.hytale.common.map.WeightedMap;
 com.hypixel.hytale.common.util.ArrayUtil;
 com.hypixel.hytale.common.util.MapUtil;
 com.hypixel.hytale.math.shape.Box;
 com.hypixel.hytale.math.util.MathUtil;
 com.hypixel.hytale.math.vector.Vector3d;
 com.hypixel.hytale.protocol.ColorLight;
 com.hypixel.hytale.protocol.EntityPart;
 com.hypixel.hytale.protocol.ModelTrail;
 com.hypixel.hytale.protocol.Phobia;
 com.hypixel.hytale.protocol.Rangef;
 com.hypixel.hytale.protocol.Vector3f;
 com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
 com.hypixel.hytale.server.core.asset.type.item.config.AssetIconProperties;
 com.hypixel.hytale.server.core.asset.type.model.config.camera.CameraAxis;
 com.hypixel.hytale.server.core.asset.type.model.config.camera.CameraSettings;
 com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
 com.hypixel.hytale.server.core.asset.type.soundevent.validator.SoundEventValidators;
 com.hypixel.hytale.server.core.asset.type.trail.config.Trail;
 com.hypixel.hytale.server.core.codec.ProtocolCodecs;
 com.hypixel.hytale.server.core.modules.physics.component.PhysicsValues;
 it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
 it.unimi.dsi.fastutil.objects.ObjectArrayList;
 java.util.Arrays;
 java.util.Collections;
 java.util.HashMap;
 java.util.List;
 java.util.Map;
 java.util.Random;
 java.util.concurrent.ThreadLocalRandom;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;

    <String, DefaultAssetMap<String, ModelAsset>> {
      BuilderCodec<ModelTrail> MODEL_TRAIL_CODEC;
      ArrayCodec<ModelTrail> MODEL_TRAIL_ARRAY_CODEC;
      AssetBuilderCodec<String, ModelAsset> CODEC;
      ModelAsset DEBUG;
      ValidatorCache<String> VALIDATOR_CACHE;
     AssetStore<String, ModelAsset, DefaultAssetMap<String, ModelAsset>> ASSET_STORE;
    AssetExtraInfo.Data extraData;
    String id;
    String model;
    String texture;
    String gradientSet;
    String gradientId;
     eyeHeight;
     crouchOffset;
    Map<String, AnimationSet> animationSetMap = Collections.emptyMap();
    CameraSettings camera;
    Box boundingBox;
    ColorLight light;
    ModelParticle[] particles;
    ModelTrail[] trails;
        (, , );
    ModelAttachment[] defaultAttachments;
    Map<String, Map<String, ModelAttachment>> randomAttachmentSets;
       ;
       ;
    String icon;
    AssetIconProperties iconProperties;
    Map<String, DetailBox[]> detailBoxes = Collections.emptyMap();
    Map<String, IWeightedMap<String>> weightedRandomAttachmentSets;
   
    Phobia phobia;
    String phobiaModelAssetId;

     {
      .phobia = Phobia.None;
   }

     AssetStore<String, ModelAsset, DefaultAssetMap<String, ModelAsset>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, ModelAsset, DefaultAssetMap<String, ModelAsset>>getAssetStore(ModelAsset.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, ModelAsset>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

    String  {
       .id;
   }

    String  {
       .model;
   }

    String  {
       .texture;
   }

    String  {
       .gradientId;
   }

    String  {
       .gradientSet;
   }

      {
       .eyeHeight;
   }

      {
       .crouchOffset;
   }

    Map<String, AnimationSet>  {
       .animationSetMap;
   }

    CameraSettings  {
       .camera;
   }

   
    Box  {
       .boundingBox;
   }

    ColorLight  {
       .light;
   }

    ModelParticle[] getParticles() {
       .particles;
   }

    ModelTrail[] getTrails() {
       .trails;
   }

    PhysicsValues  {
       .physicsValues;
   }

    ModelAttachment[] getDefaultAttachments() {
       .defaultAttachments;
   }

    Map<String, Map<String, ModelAttachment>>  {
       .randomAttachmentSets;
   }

      {
       .minScale;
   }

      {
       .maxScale;
   }

    AssetIconProperties  {
       .iconProperties;
   }

    String  {
       .icon;
   }

      {
       MathUtil.randomFloat(.minScale, .maxScale);
   }

   
    Map<String, String>  {
       (.weightedRandomAttachmentSets == ) {
          ;
      }  {
            ThreadLocalRandom.current();
         Map<String, String> randomAttachmentIds =  <String, String>();

         (Map.Entry<String, IWeightedMap<String>> entry : .weightedRandomAttachmentSets.entrySet()) {
               (String)entry.getKey();
               (String)((IWeightedMap)entry.getValue()).get((Random)random);
             (attachmentId != ) {
               randomAttachmentIds.put(attachmentSetId, attachmentId);
            }
         }

          randomAttachmentIds;
      }
   }

    ModelAttachment[] getAttachments( Map<String, String> randomAttachmentIds) {
       (randomAttachmentIds !=  && !randomAttachmentIds.isEmpty() && .randomAttachmentSets != ) {
         List<ModelAttachment> attachments =  <ModelAttachment>((.defaultAttachments ==  ?  : .defaultAttachments.length) + randomAttachmentIds.size());
          (.defaultAttachments != ) {
            Collections.addAll(attachments, .defaultAttachments);
         }

         (Map.Entry<String, String> entry : randomAttachmentIds.entrySet()) {
            Map<String, ModelAttachment> attachmentSet = (Map).randomAttachmentSets.get(entry.getKey());
             (attachmentSet != ) {
                  (ModelAttachment)attachmentSet.get(entry.getValue());
                (attachment !=  && attachment.getModel() !=  && attachment.getTexture() != ) {
                  attachments.add(attachment);
               }
            }
         }

          (ModelAttachment[])attachments.toArray((x$) ->  [x$]);
      }  {
          .defaultAttachments;
      }
   }

    Map<String, DetailBox[]> getDetailBoxes() {
       .detailBoxes;
   }

    Phobia  {
       .phobia;
   }

    String  {
       .phobiaModelAssetId;
   }

    String  {
         .id;
        + var10000 +  + .model +  + .texture +  + .gradientSet +  + .gradientId +  + .eyeHeight +  + .crouchOffset +  + String.valueOf(.animationSetMap) +  + String.valueOf(.camera) +  + String.valueOf(.boundingBox) +  + String.valueOf(.light) +  + Arrays.toString(.particles) +  + Arrays.toString(.trails) +  + String.valueOf(.physicsValues) +  + Arrays.toString(.defaultAttachments) +  + String.valueOf(.randomAttachmentSets) +  + .minScale +  + .maxScale +  + .icon +  + String.valueOf(.iconProperties) +  + String.valueOf(.detailBoxes) +  + String.valueOf(.weightedRandomAttachmentSets) +  + String.valueOf(.phobia) +  + .phobiaModelAssetId + ;
   }

    {
      MODEL_TRAIL_CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ModelTrail.class, ModelTrail::).append( (,  (Trail.class, Trail.CODEC)), (trail, s) -> trail.trailId = s, (trail) -> trail.trailId).addValidator(Trail.VALIDATOR_CACHE.getValidator()).add()).addField( (,  (EntityPart.class)), (trail, s) -> trail.targetEntityPart = s, (trail) -> trail.targetEntityPart)).addField( (, Codec.STRING), (trail, s) -> trail.targetNodeName = s, (trail) -> trail.targetNodeName)).addField( (, ProtocolCodecs.VECTOR3F), (trail, s) -> trail.positionOffset = s, (trail) -> trail.positionOffset)).addField( (, ProtocolCodecs.DIRECTION), (trail, s) -> trail.rotationOffset = s, (trail) -> trail.rotationOffset)).addField( (, Codec.BOOLEAN), (trail, s) -> trail.fixedRotation = s, (trail) -> trail.fixedRotation)).build();
      MODEL_TRAIL_ARRAY_CODEC =  <ModelTrail>(MODEL_TRAIL_CODEC, (x$) ->  [x$]);
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(ModelAsset.class, ModelAsset::, Codec.STRING, (modelAsset, s) -> modelAsset.id = s, (modelAsset) -> modelAsset.id, (modelAsset, data) -> modelAsset.extraData = data, (modelAsset) -> modelAsset.extraData).metadata( (UIEditorPreview.PreviewType.MODEL))).metadata( ( []{ (, ),  (, )}))).metadata( ( []{ (, )}))).appendInherited( (, Codec.STRING), (model, s) -> model.model = s, (model) -> model.model, (model, parent) -> model.model = parent.model).addValidator(CommonAssetValidator.MODEL_CHARACTER).add()).appendInherited( (, Codec.STRING), (model, s) -> model.texture = s, (model) -> model.texture, (model, parent) -> model.texture = parent.texture).addValidator(CommonAssetValidator.TEXTURE_CHARACTER).add()).appendInherited( (, Codec.STRING), (model, s) -> model.gradientSet = s, (model) -> model.gradientSet, (model, parent) -> model.gradientSet = parent.gradientSet).metadata( ( .Dropdown())).add()).appendInherited( (, Codec.STRING), (model, s) -> model.gradientId = s, (model) -> model.gradientId, (model, parent) -> model.gradientId = parent.gradientId).metadata( ( .Dropdown())).add()).appendInherited( (, Codec.STRING), (item, s) -> item.icon = s, (item) -> item.icon, (item, parent) -> item.icon = parent.icon).addValidator(CommonAssetValidator.ICON_MODEL).metadata( ( .Icon(, , ))).metadata( ( .ClientCache[]{UIRebuildCaches.ClientCache.ITEM_ICONS})).add()).appendInherited( (, AssetIconProperties.CODEC), (item, s) -> item.iconProperties = s, (item) -> item.iconProperties, (item, parent) -> item.iconProperties = parent.iconProperties).metadata(UIDisplayMode.HIDDEN).add()).appendInherited( (, ProtocolCodecs.COLOR_LIGHT), (model, l) -> model.light = l, (model) -> model.light, (model, parent) -> model.light = parent.light).add()).appendInherited( (, PhysicsValues.CODEC), (model, l) -> model.physicsValues = l, (model) -> model.physicsValues, (model, parent) -> model.physicsValues = parent.physicsValues).add()).appendInherited( (, Codec.DOUBLE), (modelAsset, d) -> modelAsset.minScale = d.floatValue(), (modelAsset) -> ()modelAsset.minScale, (modelAsset, parent) -> modelAsset.minScale = parent.minScale).metadata( ()).add()).appendInherited( (, Codec.DOUBLE), (modelAsset, d) -> modelAsset.maxScale = d.floatValue(), (modelAsset) -> ()modelAsset.maxScale, (modelAsset, parent) -> modelAsset.maxScale = parent.maxScale).add()).appendInherited( (, Codec.DOUBLE), (model, d) -> model.eyeHeight = d.floatValue(), (model) -> ()model.eyeHeight, (model, parent) -> model.eyeHeight = parent.eyeHeight).add()).appendInherited( (, Box.CODEC), (model, o) -> model.boundingBox = o, (model) -> model.boundingBox, (model, parent) -> model.boundingBox = parent.boundingBox).addValidator(Validators.nonNull()).add()).appendInherited( (,  ( (DetailBox.CODEC, (x$) ->  [x$]), HashMap::)), (o, i) -> o.detailBoxes = i, (o) -> o.detailBoxes, (o, p) -> o.detailBoxes = p.detailBoxes).add()).appendInherited( (, Codec.DOUBLE), (model, d) -> model.crouchOffset = d.floatValue(), (model) -> ()model.crouchOffset, (model, parent) -> model.crouchOffset = parent.crouchOffset).metadata( ()).add()).appendInherited( (, CameraSettings.CODEC), (model, o) -> model.camera = o, (model) -> model.camera, (model, parent) -> model.camera = parent.camera).add()).appendInherited( (,  (ModelAttachment.CODEC, (x$) ->  [x$])), (modelAsset, l) -> modelAsset.defaultAttachments = l, (modelAsset) -> modelAsset.defaultAttachments, (modelAsset, parent) -> modelAsset.defaultAttachments = parent.defaultAttachments).metadata( ()).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (,  ( (ModelAttachment.CODEC, HashMap::), HashMap::)), (modelAsset, l) -> modelAsset.randomAttachmentSets = l, (modelAsset) -> modelAsset.randomAttachmentSets, (modelAsset, parent) -> modelAsset.randomAttachmentSets = parent.randomAttachmentSets).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (,  (ModelAsset.AnimationSet.CODEC, HashMap::)), (model, m) -> model.animationSetMap = MapUtil.<String, AnimationSet>combineUnmodifiable(model.animationSetMap, m), (model) -> model.animationSetMap, (model, parent) -> model.animationSetMap = parent.animationSetMap).metadata( ()).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, ModelParticle.ARRAY_CODEC), (model, l) -> model.particles = l, (model) -> model.particles, (model, parent) -> model.particles = parent.particles).metadata( ()).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, MODEL_TRAIL_ARRAY_CODEC), (model, l) -> model.trails = l, (model) -> model.trails, (model, parent) -> model.trails = parent.trails).metadata( ()).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (,  (Phobia.class)), (modelAsset, phobia) -> modelAsset.phobia = phobia, (modelAsset) -> modelAsset.phobia, (modelAsset, parent) -> modelAsset.phobia = parent.phobia).addValidator(Validators.nonNull()).documentation().add()).appendInherited( (, Codec.STRING), (modelAsset, s) -> modelAsset.phobiaModelAssetId = s, (modelAsset) -> modelAsset.phobiaModelAssetId, (modelAsset, parent) -> modelAsset.phobiaModelAssetId = parent.phobiaModelAssetId).documentation().addValidatorLate(() -> VALIDATOR_CACHE.getValidator().late()).add()).afterDecode((modelAsset) -> {
          (modelAsset.randomAttachmentSets !=  && !modelAsset.randomAttachmentSets.isEmpty()) {
            Map<String, IWeightedMap<String>> weightedRandomAttachmentSets =  <String, IWeightedMap<String>>();

            (Map.Entry<String, Map<String, ModelAttachment>> entry : modelAsset.randomAttachmentSets.entrySet()) {
               WeightedMap.Builder<String> builder = WeightedMap.<String>builder(ArrayUtil.EMPTY_STRING_ARRAY);

               (Map.Entry<String, ModelAttachment> attachmentEntry : ((Map)entry.getValue()).entrySet()) {
                  builder.put((String)attachmentEntry.getKey(), ((ModelAttachment)attachmentEntry.getValue()).weight);
               }

               weightedRandomAttachmentSets.put((String)entry.getKey(), builder.build());
            }

            modelAsset.weightedRandomAttachmentSets = weightedRandomAttachmentSets;
         }

      })).build();
      DEBUG =  () {
         {
            .id = ;
            .model = ;
            .texture = ;
            .camera =  ((Vector3f), CameraAxis.STATIC_HEAD, CameraAxis.STATIC_HEAD);
            .boundingBox =  ( (, , ),  (, , ));
            .minScale = ;
            .maxScale = ;
         }
      };
      VALIDATOR_CACHE =  <String>( (ModelAsset::getAssetStore));
   }

       {
         BuilderCodec<AnimationSet> CODEC;
         Rangef DEFAULT_NEXT_ANIMATION_DELAY;
       Animation[] animations;
       Rangef nextAnimationDelay;

        {
         .nextAnimationDelay = DEFAULT_NEXT_ANIMATION_DELAY;
         .animations = animations;
         .nextAnimationDelay = nextAnimationDelay;
      }

        {
         .nextAnimationDelay = DEFAULT_NEXT_ANIMATION_DELAY;
      }

       Animation[] getAnimations() {
          .animations;
      }

       Rangef  {
          .nextAnimationDelay;
      }

      
       com.hypixel.hytale.protocol.AnimationSet  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.AnimationSet();
         packet.id = id;
         packet.animations = (com.hypixel.hytale.protocol.Animation[])ArrayUtil.copyAndMutate(.animations, Animation::toPacket, (x$) ->  .hypixel.hytale.protocol.Animation[x$]);
         packet.nextAnimationDelay = .nextAnimationDelay;
          packet;
      }

      
       String  {
            Arrays.toString(.animations);
           + var10000 +  + String.valueOf(.nextAnimationDelay) + ;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(AnimationSet.class, AnimationSet::).append( (,  (ModelAsset.Animation.CODEC, (x$) ->  [x$])), (animationSet, animations) -> animationSet.animations = animations, (animationSet) -> animationSet.animations).addValidator(Validators.nonEmptyArray()).add()).addField( (, ProtocolCodecs.RANGEF), (animationSet, rangef) -> animationSet.nextAnimationDelay = rangef, (animationSet) -> animationSet.nextAnimationDelay)).build();
         DEFAULT_NEXT_ANIMATION_DELAY =  (, );
      }
   }

       {
         BuilderCodec<Animation> CODEC;
       String animation;
          ;
          ;
          ;
          ;
       [] footstepIntervals;
       String soundEventId;
         soundEventIndex;
        passiveLoopCount;

        {
         .footstepIntervals = IntArrayCodec.EMPTY_INT_ARRAY;
         .passiveLoopCount = ;
         .animation = animation;
         .speed = speed;
         .blendingDuration = blendingDuration;
         .looping = looping;
         .weight = weight;
         .footstepIntervals = footstepIntervals;
         .soundEventId = soundEventId;
      }

        {
         .footstepIntervals = IntArrayCodec.EMPTY_INT_ARRAY;
         .passiveLoopCount = ;
      }

       String  {
          .animation;
      }

         {
          .speed;
      }

         {
          .blendingDuration;
      }

         {
          .looping;
      }

         {
          ().weight;
      }

       String  {
          .soundEventId;
      }

         {
          .soundEventIndex;
      }

      
       com.hypixel.hytale.protocol.Animation  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.Animation();
         packet.name = .animation;
         packet.speed = .speed;
         packet.blendingDuration = .blendingDuration;
         packet.looping = .looping;
         packet.weight = .weight;
         packet.footstepIntervals = .footstepIntervals;
         packet.soundEventIndex = .soundEventIndex;
         packet.passiveLoopCount = .passiveLoopCount;
          packet;
      }

         {
          (.soundEventId != ) {
            .soundEventIndex = SoundEvent.getAssetMap().getIndex(.soundEventId);
         }

      }

      
       String  {
            .animation;
           + var10000 +  + .speed +  + .blendingDuration +  + .looping +  + .weight +  + Arrays.toString(.footstepIntervals) +  + .soundEventId +  + .soundEventIndex +  + .passiveLoopCount + ;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(Animation.class, Animation::).append( (, Codec.STRING), (animation, s) -> animation.animation = s, (animation) -> animation.animation).addValidator(Validators.nonNull()).addValidator(CommonAssetValidator.ANIMATION_CHARACTER).add()).append( (, Codec.DOUBLE), (animation, s) -> animation.speed = s.floatValue(), (animation) -> ()animation.speed).addValidator(Validators.greaterThan()).add()).append( (, Codec.DOUBLE), (animation, s) -> animation.blendingDuration = s.floatValue(), (animation) -> ()animation.blendingDuration).addValidator(Validators.min()).add()).addField( (, Codec.BOOLEAN), (animation, s) -> animation.looping = s, (animation) -> animation.looping)).addField( (, Codec.DOUBLE), (animation, aDouble) -> animation.weight = aDouble.floatValue(), (animation) -> ()animation.weight)).append( (, Codec.INT_ARRAY), (animation, a) -> animation.footstepIntervals = a, (animation) -> animation.footstepIntervals).documentation().addValidator( (Validators.range(, ))).add()).append( (, Codec.STRING), (animation, s) -> animation.soundEventId = s, (animation) -> animation.soundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.MONO).add()).append( (, Codec.INTEGER), (animation, integer) -> animation.passiveLoopCount = integer, (animation) -> animation.passiveLoopCount).addValidator(Validators.greaterThan()).add()).afterDecode(Animation::processConfig)).build();
      }
   }
}

com/hypixel/hytale/server/core/asset/type/model/config/ModelAttachment.java

package com.hypixel.hytale.server.core.asset.type.model.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditor;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import com.hypixel.hytale.server.core.cosmetics.CosmeticAssetValidator;
import com.hypixel.hytale.server.core.cosmetics.CosmeticType;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;

public class ModelAttachment implements NetworkSerializable<com.hypixel.hytale.protocol.ModelAttachment> {
   public static final BuilderCodec<ModelAttachment> CODEC;
   protected String model;
   protected String texture;
   protected String gradientSet;
   protected String gradientId;
   protected double weight = 1.0;

   public ModelAttachment(String model, String texture, String gradientSet, String gradientId, double weight) {
      this.model = model;
      this.texture = texture;
      this.gradientSet = gradientSet;
      this.gradientId = gradientId;
      this.weight = weight;
   }

   protected ModelAttachment {
   }

    String  {
       .model;
   }

    String  {
       .texture;
   }

    String  {
       .gradientId;
   }

    String  {
       .gradientSet;
   }

      {
       .weight;
   }

   
    com.hypixel.hytale.protocol.ModelAttachment  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ModelAttachment();
      packet.model = .model;
      packet.texture = .texture;
      packet.gradientSet = .gradientSet;
      packet.gradientId = .gradientId;
       packet;
   }

   
    String  {
        + .model +  + .texture +  + .gradientSet +  + .gradientId +  + .weight + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ModelAttachment.class, ModelAttachment::).append( (, Codec.STRING), (modelAttachment, s) -> modelAttachment.model = s, (modelAttachment) -> modelAttachment.model).addValidator(CommonAssetValidator.MODEL_CHARACTER_ATTACHMENT).add()).append( (, Codec.STRING), (modelAttachment, s) -> modelAttachment.texture = s, (modelAttachment) -> modelAttachment.texture).addValidator(CommonAssetValidator.TEXTURE_CHARACTER_ATTACHMENT).add()).append( (, Codec.STRING), (modelAttachment, s) -> modelAttachment.gradientSet = s, (modelAttachment) -> modelAttachment.gradientSet).metadata( ( .Dropdown())).addValidator( (CosmeticType.GRADIENT_SETS)).add()).append( (, Codec.STRING), (modelAttachment, s) -> modelAttachment.gradientId = s, (modelAttachment) -> modelAttachment.gradientId).metadata( ( .Dropdown())).add()).addField( (, Codec.DOUBLE), (modelAttachment, aDouble) -> modelAttachment.weight = aDouble, (modelAttachment) -> modelAttachment.weight)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/model/config/ModelParticle.java

package com.hypixel.hytale.server.core.asset.type.model.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.Color;
import com.hypixel.hytale.protocol.Direction;
import com.hypixel.hytale.protocol.EntityPart;
import com.hypixel.hytale.protocol.Vector3f;
import com.hypixel.hytale.server.core.asset.type.particle.config.ParticleSystem;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;

public class ModelParticle implements NetworkSerializable<com.hypixel.hytale.protocol.ModelParticle> {
   public static final BuilderCodec<ModelParticle> CODEC;
   public static final ArrayCodec<ModelParticle> ARRAY_CODEC;
   protected String systemId;
   @Nonnull
   protected EntityPart targetEntityPart;
   protected String targetNodeName;
   protected Color color;
   protected float scale;
   protected Vector3f positionOffset;
   protected Direction rotationOffset;
   protected  detachedFromModel;

     {
      .targetEntityPart = EntityPart.Self;
      .scale = ;
      .systemId = systemId;
      .targetEntityPart = targetEntityPart;
      .targetNodeName = targetNodeName;
      .color = color;
      .scale = scale;
      .positionOffset = positionOffset;
      .rotationOffset = rotationOffset;
      .detachedFromModel = detachedFromModel;
   }

     {
      .targetEntityPart = EntityPart.Self;
      .scale = ;
      .systemId = other.systemId;
      .targetEntityPart = other.targetEntityPart;
      .targetNodeName = other.targetNodeName;
      .color = other.color;
      .scale = other.scale;
      .positionOffset = other.positionOffset;
      .rotationOffset = other.rotationOffset;
      .detachedFromModel = other.detachedFromModel;
   }

     {
      .targetEntityPart = EntityPart.Self;
      .scale = ;
   }

   
    com.hypixel.hytale.protocol.ModelParticle  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ModelParticle();
      packet.systemId = .systemId;
      packet.targetEntityPart = .targetEntityPart;
      packet.targetNodeName = .targetNodeName;
      packet.color = .color;
      packet.scale = .scale;
      packet.positionOffset = .positionOffset;
      packet.rotationOffset = .rotationOffset;
      packet.detachedFromModel = .detachedFromModel;
       packet;
   }

    String  {
       .systemId;
   }

    EntityPart  {
       .targetEntityPart;
   }

    String  {
       .targetNodeName;
   }

    Color  {
       .color;
   }

      {
       .scale;
   }

    Vector3f  {
       .positionOffset;
   }

    Direction  {
       .rotationOffset;
   }

      {
       .detachedFromModel;
   }

    ModelParticle  {
      .scale *= scale;
       (.positionOffset != ) {
            .positionOffset;
         var10000.x *= scale;
         var10000 = .positionOffset;
         var10000.y *= scale;
         var10000 = .positionOffset;
         var10000.z *= scale;
      }

       ;
   }

   
    String  {
         .systemId;
        + var10000 +  + String.valueOf(.targetEntityPart) +  + .targetNodeName +  + String.valueOf(.color) +  + .scale +  + String.valueOf(.positionOffset) +  + String.valueOf(.rotationOffset) +  + .detachedFromModel + ;
   }

    ModelParticle  {
        ();
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ModelParticle.class, ModelParticle::).append( (, Codec.STRING), (particle, s) -> particle.systemId = s, (particle) -> particle.systemId).addValidator(Validators.nonNull()).addValidator(ParticleSystem.VALIDATOR_CACHE.getValidator()).add()).append( (,  (EntityPart.class)), (particle, o) -> particle.targetEntityPart = o, (particle) -> particle.targetEntityPart).addValidator(Validators.nonNull()).add()).append( (, Codec.STRING), (particle, s) -> particle.targetNodeName = s, (particle) -> particle.targetNodeName).add()).append( (, ProtocolCodecs.COLOR), (particle, o) -> particle.color = o, (particle) -> particle.color).add()).append( (, Codec.DOUBLE), (particle, o) -> particle.scale = o.floatValue(), (particle) -> ()particle.scale).addValidator(Validators.greaterThan()).add()).append( (, ProtocolCodecs.VECTOR3F), (particle, s) -> particle.positionOffset = s, (particle) -> particle.positionOffset).add()).append( (, ProtocolCodecs.DIRECTION), (particle, s) -> particle.rotationOffset = s, (particle) -> particle.rotationOffset).add()).append( (, Codec.BOOLEAN), (modelParticle, aBoolean) -> modelParticle.detachedFromModel = aBoolean, (modelParticle) -> modelParticle.detachedFromModel).documentation().add()).build();
      ARRAY_CODEC =  <ModelParticle>(CODEC, (x$) ->  [x$]);
   }
}

com/hypixel/hytale/server/core/asset/type/model/config/camera/CameraAxis.java

package com.hypixel.hytale.server.core.asset.type.model.config.camera;

import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.CameraNode;
import com.hypixel.hytale.protocol.Rangef;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.util.Arrays;
import javax.annotation.Nonnull;

public class CameraAxis implements NetworkSerializable<com.hypixel.hytale.protocol.CameraAxis> {
   public static final BuilderCodec<CameraAxis> CODEC;
   public static final CameraAxis STATIC_HEAD;
   protected Rangef angleRange;
   protected CameraNode[] targetNodes;

   protected CameraAxis() {
   }

   public CameraAxis(Rangef angleRange, CameraNode[] targetNodes) {
      this.angleRange = angleRange;
      this.targetNodes = targetNodes;
   }

   @Nonnull
   public com.hypixel.hytale.protocol.CameraAxis toPacket() {
      com.hypixel.hytale.protocol.CameraAxis    .hypixel.hytale.protocol.CameraAxis();
      packet.angleRange = .angleRange;
      packet.targetNodes = .targetNodes;
       packet;
   }

    Rangef  {
       .angleRange;
   }

    CameraNode[] getTargetNodes() {
       .targetNodes;
   }

   
    String  {
         String.valueOf(.angleRange);
        + var10000 +  + Arrays.toString(.targetNodes) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(CameraAxis.class, CameraAxis::).append( (, ProtocolCodecs.RANGEF), (cameraAxis, s) -> cameraAxis.angleRange = s, (cameraAxis) -> cameraAxis.angleRange).add()).append( (,  ( (CameraNode.class), (x$) ->  [x$])), (cameraAxis, s) -> cameraAxis.targetNodes = s, (cameraAxis) -> cameraAxis.targetNodes).addValidator(Validators.nonNull()).add()).build();
      STATIC_HEAD =  ( (, ),  []{CameraNode.Head});
   }
}

com/hypixel/hytale/server/core/asset/type/model/config/camera/CameraSettings.java

package com.hypixel.hytale.server.core.asset.type.model.config.camera;

import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.Vector3f;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class CameraSettings implements NetworkSerializable<com.hypixel.hytale.protocol.CameraSettings> {
   public static final BuilderCodec<CameraSettings> CODEC;
   @Nullable
   protected Vector3f positionOffset;
   protected CameraAxis yaw;
   protected CameraAxis pitch;

   protected CameraSettings() {
   }

   public CameraSettings(Vector3f positionOffset, CameraAxis yaw, CameraAxis pitch) {
      this.positionOffset = positionOffset;
      this.yaw = yaw;
      this.pitch = pitch;
   }

   public CameraSettings(CameraSettings other) {
      this.positionOffset = other.positionOffset != null ? new Vector3f(other.positionOffset) : null;
      this.yaw = other.yaw;
      this.pitch = other.pitch;
   }

   
    com.hypixel.hytale.protocol.CameraSettings  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.CameraSettings();
      packet.positionOffset = .positionOffset;
       (.yaw != ) {
         packet.yaw = .yaw.toPacket();
      }

       (.pitch != ) {
         packet.pitch = .pitch.toPacket();
      }

       packet;
   }

    Vector3f  {
       .positionOffset;
   }

    CameraAxis  {
       .yaw;
   }

    CameraAxis  {
       .pitch;
   }

    CameraSettings  {
       (.positionOffset != ) {
            .positionOffset;
         var10000.x *= scale;
         var10000 = .positionOffset;
         var10000.y *= scale;
         var10000 = .positionOffset;
         var10000.z *= scale;
      }

       ;
   }

   
    String  {
         String.valueOf(.positionOffset);
        + var10000 +  + String.valueOf(.yaw) +  + String.valueOf(.pitch) + ;
   }

    CameraSettings  {
        ();
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(CameraSettings.class, CameraSettings::).addField( (, ProtocolCodecs.VECTOR3F), (cameraSettings, s) -> cameraSettings.positionOffset = s, (cameraSettings) -> cameraSettings.positionOffset)).addField( (, CameraAxis.CODEC), (cameraSettings, s) -> cameraSettings.yaw = s, (cameraSettings) -> cameraSettings.yaw)).addField( (, CameraAxis.CODEC), (cameraSettings, s) -> cameraSettings.pitch = s, (cameraSettings) -> cameraSettings.pitch)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/modelvfx/ModelVFXPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.modelvfx;

import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateModelvfxs;
import com.hypixel.hytale.server.core.asset.packet.SimpleAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.modelvfx.config.ModelVFX;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class ModelVFXPacketGenerator extends SimpleAssetPacketGenerator<String, ModelVFX, IndexedLookupTableAssetMap<String, ModelVFX>> {
   public ModelVFXPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull IndexedLookupTableAssetMap<String, ModelVFX> assetMap, @Nonnull Map<String, ModelVFX> assets) {
      UpdateModelvfxs packet = new UpdateModelvfxs();
      packet.type = UpdateType.Init;
      packet.modelVFXs = new Int2ObjectOpenHashMap(assets.size());

      for(Map.Entry<String, ModelVFX> entry : assets.entrySet()) {
         String key = (String)entry.getKey();
         int   assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.modelVFXs.put(index, ((ModelVFX)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.modelVFXs =  (loadedAssets.size());

      (Map.Entry<String, ModelVFX> entry : loadedAssets.entrySet()) {
            (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.modelVFXs.put(index, ((ModelVFX)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.modelVFXs =  (removed.size());

      (String key : removed) {
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.modelVFXs.put(index, (Object));
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/modelvfx/config/ModelVFX.java

package com.hypixel.hytale.server.core.asset.type.modelvfx.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.Color;
import com.hypixel.hytale.protocol.CurveType;
import com.hypixel.hytale.protocol.EffectDirection;
import com.hypixel.hytale.protocol.LoopOption;
import com.hypixel.hytale.protocol.SwitchTo;
import com.hypixel.hytale.protocol.Vector2f;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;

public class ModelVFX implements JsonAssetWithMap<String, IndexedLookupTableAssetMap<String, ModelVFX>>, NetworkSerializable<com.hypixel.hytale.protocol.ModelVFX> {
   public static final AssetBuilderCodec<String, ModelVFX> CODEC;
      Codec<String> CHILD_ASSET_CODEC;
      Codec<String[]> CHILD_ASSET_CODEC_ARRAY;
     AssetStore<String, ModelVFX, IndexedLookupTableAssetMap<String, ModelVFX>> STORE;
      ValidatorCache<String> VALIDATOR_CACHE;
    AssetExtraInfo.Data data;
    String id;
   
    SwitchTo switchTo;
   
    EffectDirection effectDirection;
     animationDuration;
    Vector2f animationRange;
   
    LoopOption loopOption;
   
    CurveType curveType;
    Color highlightColor;
     highlightThickness;
     useBloomOnHighlight;
     useProgressiveHighlight;
    Vector2f noiseScale;
    Vector2f noiseScrollSpeed;
    Color postColor;
     postColorOpacity;

     AssetStore<String, ModelVFX, IndexedLookupTableAssetMap<String, ModelVFX>>  {
       (STORE == ) {
         STORE = AssetRegistry.<String, ModelVFX, IndexedLookupTableAssetMap<String, ModelVFX>>getAssetStore(ModelVFX.class);
      }

       STORE;
   }

     IndexedLookupTableAssetMap<String, ModelVFX>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

     {
      .switchTo = SwitchTo.Disappear;
      .effectDirection = EffectDirection.None;
      .animationRange =  (, );
      .loopOption = LoopOption.PlayOnce;
      .curveType = CurveType.Linear;
      .highlightColor =  (()-, ()-, ()-);
      .noiseScale =  (, );
      .postColor =  (()-, ()-, ()-);
      .postColorOpacity = ;
      .id = id;
      .switchTo = switchTo;
      .effectDirection = effectDirection;
      .animationDuration = animationDuration;
      .animationRange = animationRange;
      .loopOption = loopOption;
      .curveType = curveType;
      .highlightColor = highlightColor;
      .highlightThickness = highlightThickness;
      .useBloomOnHighlight = useBloomOnHighlight;
      .useProgressiveHighlight = useProgressiveHighlight;
      .noiseScale = noiseScale;
      .noiseScrollSpeed = noiseScrollSpeed;
      .postColor = postColor;
      .postColorOpacity = postColorOpacity;
   }

     {
      .switchTo = SwitchTo.Disappear;
      .effectDirection = EffectDirection.None;
      .animationRange =  (, );
      .loopOption = LoopOption.PlayOnce;
      .curveType = CurveType.Linear;
      .highlightColor =  (()-, ()-, ()-);
      .noiseScale =  (, );
      .postColor =  (()-, ()-, ()-);
      .postColorOpacity = ;
      .id = id;
   }

     {
      .switchTo = SwitchTo.Disappear;
      .effectDirection = EffectDirection.None;
      .animationRange =  (, );
      .loopOption = LoopOption.PlayOnce;
      .curveType = CurveType.Linear;
      .highlightColor =  (()-, ()-, ()-);
      .noiseScale =  (, );
      .postColor =  (()-, ()-, ()-);
      .postColorOpacity = ;
   }

   
    com.hypixel.hytale.protocol.ModelVFX  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ModelVFX();
      packet.id = .id;
      packet.switchTo = .switchTo;
      packet.effectDirection = .effectDirection;
      packet.animationDuration = .animationDuration;
       (.animationRange != ) {
         packet.animationRange = .animationRange;
      }

      packet.loopOption = .loopOption;
      packet.curveType = .curveType;
      packet.highlightColor = .highlightColor;
      packet.useBloomOnHighlight = .useBloomOnHighlight;
      packet.useProgessiveHighlight = .useProgressiveHighlight;
      packet.highlightThickness = .highlightThickness;
       (.noiseScale != ) {
         packet.noiseScale = .noiseScale;
      }

       (.noiseScrollSpeed != ) {
         packet.noiseScrollSpeed = .noiseScrollSpeed;
      }

      packet.postColor = .postColor;
      packet.postColorOpacity = .postColorOpacity;
       packet;
   }

    String  {
       .id;
   }

    SwitchTo  {
       .switchTo;
   }

    EffectDirection  {
       .effectDirection;
   }

      {
       .animationDuration;
   }

    Vector2f  {
       .animationRange;
   }

    LoopOption  {
       .loopOption;
   }

    CurveType  {
       .curveType;
   }

    Color  {
       .highlightColor;
   }

      {
       .useBloomOnHighlight;
   }

      {
       .useProgressiveHighlight;
   }

      {
       .highlightThickness;
   }

    Vector2f  {
       .noiseScale;
   }

    Vector2f  {
       .noiseScrollSpeed;
   }

    Color  {
       .postColor;
   }

      {
       .postColorOpacity;
   }

   
    String  {
         .id;
        + var10000 +  + String.valueOf(.switchTo) +  + String.valueOf(.effectDirection) +  + .animationDuration +  + String.valueOf(.animationRange) +  + String.valueOf(.loopOption) +  + String.valueOf(.curveType) +  + String.valueOf(.highlightColor) +  + .useBloomOnHighlight +  + .useProgressiveHighlight +  + .highlightThickness +  + String.valueOf(.noiseScale) +  + String.valueOf(.noiseScrollSpeed) +  + String.valueOf(.postColor) +  + .postColorOpacity + ;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(ModelVFX.class, ModelVFX::, Codec.STRING, (modelVFX, s) -> modelVFX.id = s, (modelVFX) -> modelVFX.id, (asset, data) -> asset.data = data, (asset) -> asset.data).append( (,  (SwitchTo.class)), (modelVFX, s) -> modelVFX.switchTo = s, (modelVFX) -> modelVFX.switchTo).addValidator(Validators.nonNull()).add()).append( (,  (EffectDirection.class)), (modelVFX, s) -> modelVFX.effectDirection = s, (modelVFX) -> modelVFX.effectDirection).addValidator(Validators.nonNull()).add()).addField( (, Codec.FLOAT), (modelVFX, d) -> modelVFX.animationDuration = d, (modelVFX) -> modelVFX.animationDuration)).addField( (, ProtocolCodecs.VECTOR2F), (modelVFX, d) -> modelVFX.animationRange = d, (modelVFX) -> modelVFX.animationRange)).append( (,  (LoopOption.class)), (modelVFX, s) -> modelVFX.loopOption = s, (modelVFX) -> modelVFX.loopOption).addValidator(Validators.nonNull()).add()).append( (,  (CurveType.class)), (modelVFX, s) -> modelVFX.curveType = s, (modelVFX) -> modelVFX.curveType).addValidator(Validators.nonNull()).add()).addField( (, ProtocolCodecs.COLOR), (modelVFX, o) -> modelVFX.highlightColor = o, (modelVFX) -> modelVFX.highlightColor)).addField( (, Codec.FLOAT), (modelVFX, d) -> modelVFX.highlightThickness = d, (modelVFX) -> modelVFX.highlightThickness)).addField( (, Codec.BOOLEAN), (modelVFX, b) -> modelVFX.useBloomOnHighlight = b, (modelVFX) -> modelVFX.useBloomOnHighlight)).addField( (, Codec.BOOLEAN), (modelVFX, b) -> modelVFX.useProgressiveHighlight = b, (modelVFX) -> modelVFX.useProgressiveHighlight)).addField( (, ProtocolCodecs.VECTOR2F), (modelVFX, d) -> modelVFX.noiseScale = d, (modelVFX) -> modelVFX.noiseScale)).addField( (, ProtocolCodecs.VECTOR2F), (modelVFX, d) -> modelVFX.noiseScrollSpeed = d, (modelVFX) -> modelVFX.noiseScrollSpeed)).addField( (, ProtocolCodecs.COLOR), (modelVFX, o) -> modelVFX.postColor = o, (modelVFX) -> modelVFX.postColor)).append( (, Codec.FLOAT), (modelVFX, d) -> modelVFX.postColorOpacity = d, (modelVFX) -> modelVFX.postColorOpacity).addValidator(Validators.range(, )).add()).build();
      CHILD_ASSET_CODEC =  (ModelVFX.class, CODEC);
      CHILD_ASSET_CODEC_ARRAY =  <String[]>(CHILD_ASSET_CODEC, (x$) ->  [x$]);
      VALIDATOR_CACHE =  <String>( (ModelVFX::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/particle/ParticleSpawnerPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.particle;

import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateParticleSpawners;
import com.hypixel.hytale.server.core.asset.packet.DefaultAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.particle.config.ParticleSpawner;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class ParticleSpawnerPacketGenerator extends DefaultAssetPacketGenerator<String, ParticleSpawner> {
   public ParticleSpawnerPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(DefaultAssetMap<String, ParticleSpawner> assetMap, @Nonnull Map<String, ParticleSpawner> assets) {
      UpdateParticleSpawners packet = new UpdateParticleSpawners();
      packet.type = UpdateType.Init;
      packet.particleSpawners = new Object2ObjectOpenHashMap<String, com.hypixel.hytale.protocol.ParticleSpawner>();

      for(Map.Entry<String, ParticleSpawner> entry : assets.entrySet()) {
         packet.particleSpawners.put((String)entry.getKey(), ((ParticleSpawner)entry.getValue()).toPacket());
      }

      return packet;
   }

   @Nonnull
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.particleSpawners =  <String, com.hypixel.hytale.protocol.ParticleSpawner>();

      (Map.Entry<String, ParticleSpawner> entry : loadedAssets.entrySet()) {
         packet.particleSpawners.put((String)entry.getKey(), ((ParticleSpawner)entry.getValue()).toPacket());
      }

       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.removedParticleSpawners = (String[])removed.toArray((x$) ->  [x$]);
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/particle/ParticleSystemPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.particle;

import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateParticleSystems;
import com.hypixel.hytale.server.core.asset.packet.DefaultAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.particle.config.ParticleSystem;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class ParticleSystemPacketGenerator extends DefaultAssetPacketGenerator<String, ParticleSystem> {
   public ParticleSystemPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(DefaultAssetMap<String, ParticleSystem> assetMap, @Nonnull Map<String, ParticleSystem> assets) {
      UpdateParticleSystems packet = new UpdateParticleSystems();
      packet.type = UpdateType.Init;
      packet.particleSystems = new Object2ObjectOpenHashMap<String, com.hypixel.hytale.protocol.ParticleSystem>();

      for(Map.Entry<String, ParticleSystem> entry : assets.entrySet()) {
         packet.particleSystems.put((String)entry.getKey(), ((ParticleSystem)entry.getValue()).toPacket());
      }

      return packet;
   }

   @Nonnull
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.particleSystems =  <String, com.hypixel.hytale.protocol.ParticleSystem>();

      (Map.Entry<String, ParticleSystem> entry : loadedAssets.entrySet()) {
         packet.particleSystems.put((String)entry.getKey(), ((ParticleSystem)entry.getValue()).toPacket());
      }

       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.removedParticleSystems = (String[])removed.toArray((x$) ->  [x$]);
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/particle/commands/ParticleCommand.java

package com.hypixel.hytale.server.core.asset.type.particle.commands;

import com.hypixel.hytale.server.core.command.system.basecommands.AbstractCommandCollection;

public class ParticleCommand extends AbstractCommandCollection {
   public ParticleCommand() {
      super("particle", "server.commands.particle.desc");
      this.addSubCommand(new ParticleSpawnCommand());
   }
}

com/hypixel/hytale/server/core/asset/type/particle/commands/ParticleSpawnCommand.java

package com.hypixel.hytale.server.core.asset.type.particle.commands;

import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.component.Store;
import com.hypixel.hytale.component.spatial.SpatialResource;
import com.hypixel.hytale.math.vector.Vector3d;
import com.hypixel.hytale.server.core.asset.type.particle.config.ParticleSystem;
import com.hypixel.hytale.server.core.asset.type.particle.pages.ParticleSpawnPage;
import com.hypixel.hytale.server.core.command.system.CommandContext;
import com.hypixel.hytale.server.core.command.system.arguments.system.RequiredArg;
import com.hypixel.hytale.server.core.command.system.arguments.types.ArgTypes;
import com.hypixel.hytale.server.core.command.system.basecommands.AbstractTargetPlayerCommand;
import com.hypixel.hytale.server.core.entity.entities.Player;
import com.hypixel.hytale.server.core.modules.entity.EntityModule;
import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
import com.hypixel.hytale.server.core.universe.PlayerRef;
import com.hypixel.hytale.server.core.universe.world.ParticleUtil;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import it.unimi.dsi.fastutil.objects.ObjectList;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ParticleSpawnCommand extends AbstractTargetPlayerCommand {
   @Nonnull
   private final RequiredArg<ParticleSystem> particleSystemArg;

   public ParticleSpawnCommand {
      (, );
      .particleSystemArg = .withRequiredArg(, , ArgTypes.PARTICLE_SYSTEM);
      .addUsageVariant( ());
   }

      {
         (ParticleSystem).particleSystemArg.get(context);
         (TransformComponent)store.getComponent(ref, TransformComponent.getComponentType());

       transformComponent != ;

         transformComponent.getPosition();
      SpatialResource<Ref<EntityStore>, EntityStore> playerSpatialResource = (SpatialResource)store.getResource(EntityModule.get().getPlayerSpatialResourceType());
      ObjectList<Ref<EntityStore>> results = SpatialResource.getThreadLocalReferenceList();
      playerSpatialResource.getSpatialStructure().collect(position, , results);
      ParticleUtil.spawnParticleEffect((String)particleSystem.getId(), position, transformComponent.getRotation(), results, store);
   }

         {
        {
         ();
      }

         {
            (Player)store.getComponent(ref, Player.getComponentType());

          playerComponent != ;

         playerComponent.getPageManager().openCustomPage(ref, store,  (playerRef));
      }
   }
}

com/hypixel/hytale/server/core/asset/type/particle/config/Particle.java

package com.hypixel.hytale.server.core.asset.type.particle.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.codecs.map.Int2ObjectMapCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIDefaultCollapsedState;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditorSectionStart;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.codec.validation.validator.MapKeyValidator;
import com.hypixel.hytale.protocol.ParticleScaleRatioConstraint;
import com.hypixel.hytale.protocol.ParticleUVOption;
import com.hypixel.hytale.protocol.Size;
import com.hypixel.hytale.protocol.SoftParticle;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import javax.annotation.Nonnull;

public class Particle implements NetworkSerializable<com.hypixel.hytale.protocol.Particle> {
   public static final BuilderCodec<Particle> CODEC;
   protected String texture;
   protected Size frameSize;
   @Nonnull
   protected ParticleUVOption uvOption;
   @Nonnull
    ParticleScaleRatioConstraint scaleRatioConstraint;
   
    SoftParticle softParticle;
     softParticlesFadeFactor;
     useSpriteBlending;
    ParticleAnimationFrame initialAnimationFrame;
    ParticleAnimationFrame collisionAnimationFrame;
    Int2ObjectMap<ParticleAnimationFrame> animation;

     {
      .uvOption = ParticleUVOption.None;
      .scaleRatioConstraint = ParticleScaleRatioConstraint.OneToOne;
      .softParticle = SoftParticle.Enable;
      .softParticlesFadeFactor = ;
      .texture = texture;
      .frameSize = frameSize;
      .uvOption = uvOption;
      .scaleRatioConstraint = scaleRatioConstraint;
      .softParticle = softParticle;
      .softParticlesFadeFactor = softParticlesFadeFactor;
      .useSpriteBlending = useSpriteBlending;
      .initialAnimationFrame = initialAnimationFrame;
      .collisionAnimationFrame = collisionAnimationFrame;
      .animation = animation;
   }

     {
      .uvOption = ParticleUVOption.None;
      .scaleRatioConstraint = ParticleScaleRatioConstraint.OneToOne;
      .softParticle = SoftParticle.Enable;
      .softParticlesFadeFactor = ;
   }

    String  {
       .texture;
   }

    Size  {
       .frameSize;
   }

    ParticleUVOption  {
       .uvOption;
   }

    ParticleScaleRatioConstraint  {
       .scaleRatioConstraint;
   }

    SoftParticle  {
       .softParticle;
   }

      {
       .softParticlesFadeFactor;
   }

      {
       .useSpriteBlending;
   }

    ParticleAnimationFrame  {
       .initialAnimationFrame;
   }

    ParticleAnimationFrame  {
       .collisionAnimationFrame;
   }

    Int2ObjectMap<ParticleAnimationFrame>  {
       .animation;
   }

   
    com.hypixel.hytale.protocol.Particle  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.Particle();
      packet.texturePath = .texture;
      packet.frameSize = .frameSize;
      packet.uvOption = .uvOption;
      packet.scaleRatioConstraint = .scaleRatioConstraint;
      packet.softParticles = .softParticle;
      packet.softParticlesFadeFactor = .softParticlesFadeFactor;
      packet.useSpriteBlending = .useSpriteBlending;
       (.initialAnimationFrame != ) {
         packet.initialAnimationFrame = .initialAnimationFrame.toPacket();
      }

       (.collisionAnimationFrame != ) {
         packet.collisionAnimationFrame = .collisionAnimationFrame.toPacket();
      }

       (.animation != ) {
         packet.animationFrames =  ();

         (Int2ObjectMap.Entry<ParticleAnimationFrame> entry : .animation.int2ObjectEntrySet()) {
            packet.animationFrames.put(entry.getIntKey(), ((ParticleAnimationFrame)entry.getValue()).toPacket());
         }
      }

       packet;
   }

   
    String  {
         .texture;
        + var10000 +  + String.valueOf(.frameSize) +  + String.valueOf(.uvOption) +  + String.valueOf(.scaleRatioConstraint) +  + String.valueOf(.softParticle) +  + .softParticlesFadeFactor +  + .useSpriteBlending +  + String.valueOf(.initialAnimationFrame) +  + String.valueOf(.collisionAnimationFrame) +  + String.valueOf(.animation) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(Particle.class, Particle::).append( (, Codec.STRING), (particle, s) -> particle.texture = s, (particle) -> particle.texture).addValidator(Validators.nonNull()).addValidator(CommonAssetValidator.TEXTURE_PARTICLES).metadata( ()).add()).addField( (, ProtocolCodecs.SIZE), (particle, o) -> particle.frameSize = o, (particle) -> particle.frameSize)).append( (,  (SoftParticle.class)), (particle, o) -> particle.softParticle = o, (particle) -> particle.softParticle).addValidator(Validators.nonNull()).add()).append( (, Codec.FLOAT), (particle, f) -> particle.softParticlesFadeFactor = f, (particle) -> particle.softParticlesFadeFactor).addValidator(Validators.range(, )).add()).appendInherited( (, Codec.BOOLEAN), (particle, s) -> particle.useSpriteBlending = s, (particle) -> particle.useSpriteBlending, (particle, parent) -> particle.useSpriteBlending = parent.useSpriteBlending).add()).append( (,  (ParticleAnimationFrame.CODEC, Int2ObjectOpenHashMap::)), (particle, o) -> particle.animation = o, (particle) -> particle.animation).addValidator(Validators.nonNull()).addValidator(Validators.nonEmptyMap()).addValidator( (Validators.range(, ))).metadata( ()).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).append( (, ParticleAnimationFrame.CODEC), (particle, o) -> particle.collisionAnimationFrame = o, (particle) -> particle.collisionAnimationFrame).add()).append( (,  (ParticleUVOption.class)), (particle, o) -> particle.uvOption = o, (particle) -> particle.uvOption).addValidator(Validators.nonNull()).metadata( ()).add()).append( (,  (ParticleScaleRatioConstraint.class)), (particle, o) -> particle.scaleRatioConstraint = o, (particle) -> particle.scaleRatioConstraint).addValidator(Validators.nonNull()).add()).append( (, ParticleAnimationFrame.CODEC), (particle, o) -> particle.initialAnimationFrame = o, (particle) -> particle.initialAnimationFrame).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/particle/config/ParticleAnimationFrame.java

package com.hypixel.hytale.server.core.asset.type.particle.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.Color;
import com.hypixel.hytale.protocol.Range;
import com.hypixel.hytale.protocol.RangeVector2f;
import com.hypixel.hytale.protocol.RangeVector3f;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;

public class ParticleAnimationFrame implements NetworkSerializable<com.hypixel.hytale.protocol.ParticleAnimationFrame> {
   public static final int UNASSIGNED_OPACITY = -1;
   public static final BuilderCodec<ParticleAnimationFrame> CODEC;
   protected Range frameIndex;
   protected RangeVector2f scale;
   protected RangeVector3f rotation;
   protected Color color;
   protected float opacity = -1.0F;

   public ParticleAnimationFrame(Range frameIndex, RangeVector2f scale, RangeVector3f rotation, Color color,  opacity) {
      .frameIndex = frameIndex;
      .scale = scale;
      .rotation = rotation;
      .color = color;
      .opacity = opacity;
   }

     {
   }

    Range  {
       .frameIndex;
   }

    RangeVector2f  {
       .scale;
   }

    RangeVector3f  {
       .rotation;
   }

    Color  {
       .color;
   }

      {
       .opacity;
   }

   
    com.hypixel.hytale.protocol.ParticleAnimationFrame  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ParticleAnimationFrame();
      packet.frameIndex = .frameIndex;
      packet.scale = .scale;
      packet.rotation = .rotation;
      packet.color = .color;
      packet.opacity = .opacity;
       packet;
   }

   
    String  {
         String.valueOf(.frameIndex);
        + var10000 +  + String.valueOf(.scale) +  + String.valueOf(.rotation) +  + String.valueOf(.color) +  + .opacity + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ParticleAnimationFrame.class, ParticleAnimationFrame::).addField( (, ProtocolCodecs.RANGE), (animationFrame, s) -> animationFrame.frameIndex = s, (animationFrame) -> animationFrame.frameIndex)).addField( (, ProtocolCodecs.RANGE_VECTOR2F), (animationFrame, o) -> animationFrame.scale = o, (animationFrame) -> animationFrame.scale)).addField( (, ProtocolCodecs.RANGE_VECTOR3F), (animationFrame, o) -> animationFrame.rotation = o, (animationFrame) -> animationFrame.rotation)).addField( (, ProtocolCodecs.COLOR), (animationFrame, o) -> animationFrame.color = o, (animationFrame) -> animationFrame.color)).append( (, Codec.FLOAT), (animationFrame, f) -> animationFrame.opacity = f, (animationFrame) -> animationFrame.opacity).addValidator(Validators.or(Validators.range(, ), Validators.equal(-))).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/particle/config/ParticleAttractor.java

package com.hypixel.hytale.server.core.asset.type.particle.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.Vector3f;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;

public class ParticleAttractor implements NetworkSerializable<com.hypixel.hytale.protocol.ParticleAttractor> {
   public static final BuilderCodec<ParticleAttractor> CODEC;
   protected Vector3f position;
   protected Vector3f radialAxis;
   protected float trailPositionMultiplier;
   protected float radius;
   protected float radialAcceleration;
   protected float radialTangentAcceleration;
   protected Vector3f linearAcceleration;
   protected float radialImpulse;
   protected float radialTangentImpulse;
   protected Vector3f linearImpulse;
   protected Vector3f dampingMultiplier;

   public ParticleAttractor(Vector3f position, Vector3f radialAxis, float trailPositionMultiplier, float radius,  radialAcceleration,  radialTangentAcceleration, Vector3f linearAcceleration,  radialImpulse,  radialTangentImpulse, Vector3f linearImpulse, Vector3f dampingMultiplier) {
      .position = position;
      .radialAxis = radialAxis;
      .trailPositionMultiplier = trailPositionMultiplier;
      .radius = radius;
      .radialAcceleration = radialAcceleration;
      .radialTangentAcceleration = radialTangentAcceleration;
      .linearAcceleration = linearAcceleration;
      .radialImpulse = radialImpulse;
      .radialTangentImpulse = radialTangentImpulse;
      .linearImpulse = linearImpulse;
      .dampingMultiplier = dampingMultiplier;
   }

     {
   }

    Vector3f  {
       .position;
   }

    Vector3f  {
       .radialAxis;
   }

      {
       .trailPositionMultiplier;
   }

      {
       .radius;
   }

      {
       .radialAcceleration;
   }

      {
       .radialTangentAcceleration;
   }

    Vector3f  {
       .linearAcceleration;
   }

      {
       .radialImpulse;
   }

      {
       .radialTangentImpulse;
   }

    Vector3f  {
       .linearImpulse;
   }

    Vector3f  {
       .dampingMultiplier;
   }

   
    com.hypixel.hytale.protocol.ParticleAttractor  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ParticleAttractor();
       (.position != ) {
         packet.position = .position;
      }

       (.radialAxis != ) {
         packet.radialAxis = .radialAxis;
      }

      packet.trailPositionMultiplier = .trailPositionMultiplier;
      packet.radius = .radius;
      packet.radialAcceleration = .radialAcceleration;
      packet.radialTangentAcceleration = .radialTangentAcceleration;
       (.linearAcceleration != ) {
         packet.linearAcceleration = .linearAcceleration;
      }

      packet.radialImpulse = .radialImpulse;
      packet.radialTangentImpulse = .radialTangentImpulse;
       (.linearImpulse != ) {
         packet.linearImpulse = .linearImpulse;
      }

       (.dampingMultiplier != ) {
         packet.dampingMultiplier = .dampingMultiplier;
      }

       packet;
   }

   
    String  {
         String.valueOf(.position);
        + var10000 +  + String.valueOf(.radialAxis) +  + .trailPositionMultiplier +  + .radius +  + .radialAcceleration +  + .radialTangentAcceleration +  + String.valueOf(.linearAcceleration) +  + .radialImpulse +  + .radialTangentImpulse +  + String.valueOf(.linearImpulse) +  + String.valueOf(.dampingMultiplier) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ParticleAttractor.class, ParticleAttractor::).addField( (, ProtocolCodecs.VECTOR3F), (particleAttractor, o) -> particleAttractor.position = o, (particleAttractor) -> particleAttractor.position)).addField( (, ProtocolCodecs.VECTOR3F), (particleAttractor, o) -> particleAttractor.radialAxis = o, (particleAttractor) -> particleAttractor.radialAxis)).append( (, Codec.FLOAT), (particleAttractor, f) -> particleAttractor.trailPositionMultiplier = f, (particleAttractor) -> particleAttractor.trailPositionMultiplier).addValidator(Validators.range(, )).add()).addField( (, Codec.FLOAT), (particleAttractor, f) -> particleAttractor.radius = f, (particleAttractor) -> particleAttractor.radius)).addField( (, Codec.FLOAT), (particleAttractor, f) -> particleAttractor.radialAcceleration = f, (particleAttractor) -> particleAttractor.radialAcceleration)).addField( (, Codec.FLOAT), (particleAttractor, f) -> particleAttractor.radialTangentAcceleration = f, (particleAttractor) -> particleAttractor.radialTangentAcceleration)).addField( (, ProtocolCodecs.VECTOR3F), (particleAttractor, o) -> particleAttractor.linearAcceleration = o, (particleAttractor) -> particleAttractor.linearAcceleration)).addField( (, Codec.FLOAT), (particleAttractor, f) -> particleAttractor.radialImpulse = f, (particleAttractor) -> particleAttractor.radialImpulse)).addField( (, Codec.FLOAT), (particleAttractor, f) -> particleAttractor.radialTangentImpulse = f, (particleAttractor) -> particleAttractor.radialTangentImpulse)).addField( (, ProtocolCodecs.VECTOR3F), (particleAttractor, o) -> particleAttractor.linearImpulse = o, (particleAttractor) -> particleAttractor.linearImpulse)).addField( (, ProtocolCodecs.VECTOR3F), (particleAttractor, o) -> particleAttractor.dampingMultiplier = o, (particleAttractor) -> particleAttractor.dampingMultiplier)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/particle/config/ParticleCollision.java

package com.hypixel.hytale.server.core.asset.type.particle.config;

import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.ParticleCollisionAction;
import com.hypixel.hytale.protocol.ParticleCollisionBlockType;
import com.hypixel.hytale.protocol.ParticleRotationInfluence;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;

public class ParticleCollision implements NetworkSerializable<com.hypixel.hytale.protocol.ParticleCollision> {
   public static final BuilderCodec<ParticleCollision> CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ParticleCollision.class, ParticleCollision::new).append(new KeyedCodec("BlockType", new EnumCodec(ParticleCollisionBlockType.class)), (particleCollision, o) -> particleCollision.blockType = o, (particleCollision) -> particleCollision.blockType).addValidator(Validators.nonNull()).add()).append(new KeyedCodec("Action", new EnumCodec(ParticleCollisionAction.class)), (particleCollision, o) -> particleCollision.action = o, (particleCollision) -> particleCollision.action).addValidator(Validators.nonNull()).add()).append(new KeyedCodec("ParticleRotationInfluence", new (ParticleRotationInfluence.class)), (particleCollision, o) -> particleCollision.particleRotationInfluence = o, (particleCollision) -> particleCollision.particleRotationInfluence).add()).build();
   
    ParticleCollisionBlockType blockType;
   
    ParticleCollisionAction action;
    ParticleRotationInfluence particleRotationInfluence;

     {
      .blockType = ParticleCollisionBlockType.None;
      .action = ParticleCollisionAction.Expire;
      .blockType = blockType;
      .action = action;
      .particleRotationInfluence = particleRotationInfluence;
   }

     {
      .blockType = ParticleCollisionBlockType.None;
      .action = ParticleCollisionAction.Expire;
   }

    ParticleCollisionBlockType  {
       .blockType;
   }

    ParticleCollisionAction  {
       .action;
   }

    ParticleRotationInfluence  {
       .particleRotationInfluence;
   }

   
    com.hypixel.hytale.protocol.ParticleCollision  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ParticleCollision();
      packet.blockType = .blockType;
      packet.action = .action;
      packet.particleRotationInfluence = .particleRotationInfluence !=  ? .particleRotationInfluence : ParticleRotationInfluence.None;
       packet;
   }

   
    String  {
         String.valueOf(.blockType);
        + var10000 +  + String.valueOf(.action) +  + String.valueOf(.particleRotationInfluence) + ;
   }
}

com/hypixel/hytale/server/core/asset/type/particle/config/ParticleSpawner.java

package com.hypixel.hytale.server.core.asset.type.particle.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIDefaultCollapsedState;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditorSectionStart;
import com.hypixel.hytale.codec.schema.metadata.ui.UITypeIcon;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.common.util.ArrayUtil;
import com.hypixel.hytale.protocol.EmitShape;
import com.hypixel.hytale.protocol.FXRenderMode;
import com.hypixel.hytale.protocol.InitialVelocity;
import com.hypixel.hytale.protocol.IntersectionHighlight;
import com.hypixel.hytale.protocol.ParticleRotationInfluence;
import com.hypixel.hytale.protocol.Range;
import com.hypixel.hytale.protocol.RangeVector3f;
import com.hypixel.hytale.protocol.Rangef;
import com.hypixel.hytale.protocol.UVMotion;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
 java.lang.ref.SoftReference;
 java.util.Arrays;
 javax.annotation.Nonnull;

    <String, DefaultAssetMap<String, ParticleSpawner>>, NetworkSerializable<com.hypixel.hytale.protocol.ParticleSpawner> {
         ;
         ;
      AssetBuilderCodec<String, ParticleSpawner> CODEC;
      ValidatorCache<String> VALIDATOR_CACHE;
     AssetStore<String, ParticleSpawner, DefaultAssetMap<String, ParticleSpawner>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
    Particle particle;
   
    FXRenderMode renderMode;
   
    EmitShape shape;
    RangeVector3f emitOffset;
     useEmitDirection;
     cameraOffset;
   
    ParticleRotationInfluence particleRotationInfluence;
     particleRotateWithSpawner;
     isLowRes;
     trailSpawnerPositionMultiplier;
     trailSpawnerRotationMultiplier;
    ParticleCollision particleCollision;
     lightInfluence;
     linearFiltering;
    Range totalParticles;
     lifeSpan;
     maxConcurrentParticles;
    Rangef particleLifeSpan;
    Rangef spawnRate;
     spawnBurst;
    Rangef waveDelay;
    InitialVelocity initialVelocity;
     velocityStretchMultiplier;
    UVMotion uvMotion;
    ParticleAttractor[] attractors;
    IntersectionHighlight intersectionHighlight;
    SoftReference<com.hypixel.hytale.protocol.ParticleSpawner> cachedPacket;

     AssetStore<String, ParticleSpawner, DefaultAssetMap<String, ParticleSpawner>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, ParticleSpawner, DefaultAssetMap<String, ParticleSpawner>>getAssetStore(ParticleSpawner.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, ParticleSpawner>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

     {
      .renderMode = FXRenderMode.BlendLinear;
      .shape = EmitShape.Sphere;
      .particleRotationInfluence = ParticleRotationInfluence.None;
      .id = id;
      .particle = particle;
      .renderMode = renderMode;
      .shape = shape;
      .emitOffset = emitOffset;
      .useEmitDirection = useEmitDirection;
      .cameraOffset = cameraOffset;
      .particleRotationInfluence = particleRotationInfluence;
      .particleRotateWithSpawner = particleRotateWithSpawner;
      .isLowRes = isLowRes;
      .trailSpawnerPositionMultiplier = trailSpawnerPositionMultiplier;
      .trailSpawnerRotationMultiplier = trailSpawnerRotationMultiplier;
      .particleCollision = particleCollision;
      .lightInfluence = lightInfluence;
      .linearFiltering = linearFiltering;
      .totalParticles = totalParticles;
      .lifeSpan = lifeSpan;
      .maxConcurrentParticles = maxConcurrentParticles;
      .particleLifeSpan = particleLifeSpan;
      .spawnRate = spawnRate;
      .spawnBurst = spawnBurst;
      .waveDelay = waveDelay;
      .initialVelocity = initialVelocity;
      .velocityStretchMultiplier = velocityStretchMultiplier;
      .uvMotion = uvMotion;
      .attractors = attractors;
      .intersectionHighlight = intersectionHighlight;
   }

     {
      .renderMode = FXRenderMode.BlendLinear;
      .shape = EmitShape.Sphere;
      .particleRotationInfluence = ParticleRotationInfluence.None;
   }

   
    com.hypixel.hytale.protocol.ParticleSpawner  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.ParticleSpawner).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ParticleSpawner();
         packet.id = .id;
          (.particle != ) {
            packet.particle = .particle.toPacket();
         }

         packet.shape = .shape;
         packet.renderMode = .renderMode;
         packet.emitOffset = .emitOffset;
         packet.useEmitDirection = .useEmitDirection;
         packet.cameraOffset = .cameraOffset;
         packet.particleRotationInfluence = .particleRotationInfluence;
         packet.particleRotateWithSpawner = .particleRotateWithSpawner;
         packet.isLowRes = .isLowRes;
         packet.trailSpawnerPositionMultiplier = .trailSpawnerPositionMultiplier;
         packet.trailSpawnerRotationMultiplier = .trailSpawnerRotationMultiplier;
          (.particleCollision != ) {
            packet.particleCollision = .particleCollision.toPacket();
             (.particleCollision.getParticleRotationInfluence() == ) {
               packet.particleCollision.particleRotationInfluence = .particleRotationInfluence;
            }
         }

         packet.lightInfluence = .lightInfluence;
         packet.linearFiltering = .linearFiltering;
         packet.totalParticles = .totalParticles;
         packet.lifeSpan = .lifeSpan;
         packet.maxConcurrentParticles = .maxConcurrentParticles;
          (.particleLifeSpan != ) {
            packet.particleLifeSpan = .particleLifeSpan;
         }

          (.spawnRate != ) {
            packet.spawnRate = .spawnRate;
         }

         packet.spawnBurst = .spawnBurst;
          (.waveDelay != ) {
            packet.waveDelay = .waveDelay;
         }

         packet.initialVelocity = .initialVelocity;
         packet.velocityStretchMultiplier = .velocityStretchMultiplier;
         packet.uvMotion = .uvMotion;
          (.attractors !=  && .attractors.length > ) {
            packet.attractors = (com.hypixel.hytale.protocol.ParticleAttractor[])ArrayUtil.copyAndMutate(.attractors, ParticleAttractor::toPacket, (x$) ->  .hypixel.hytale.protocol.ParticleAttractor[x$]);
         }

         packet.intersectionHighlight = .intersectionHighlight;
         .cachedPacket =  (packet);
          packet;
      }
   }

    String  {
       .id;
   }

    Particle  {
       .particle;
   }

    FXRenderMode  {
       .renderMode;
   }

    EmitShape  {
       .shape;
   }

    RangeVector3f  {
       .emitOffset;
   }

      {
       .useEmitDirection;
   }

      {
       .cameraOffset;
   }

    ParticleRotationInfluence  {
       .particleRotationInfluence;
   }

      {
       .particleRotateWithSpawner;
   }

      {
       .isLowRes;
   }

      {
       .trailSpawnerPositionMultiplier;
   }

      {
       .trailSpawnerRotationMultiplier;
   }

    ParticleCollision  {
       .particleCollision;
   }

      {
       .lightInfluence;
   }

      {
       .linearFiltering;
   }

    Range  {
       .totalParticles;
   }

      {
       .lifeSpan;
   }

      {
       .maxConcurrentParticles;
   }

    Rangef  {
       .particleLifeSpan;
   }

    Rangef  {
       .spawnRate;
   }

      {
       .spawnBurst;
   }

    Rangef  {
       .waveDelay;
   }

    InitialVelocity  {
       .initialVelocity;
   }

      {
       .velocityStretchMultiplier;
   }

    UVMotion  {
       .uvMotion;
   }

    ParticleAttractor[] getAttractors() {
       .attractors;
   }

    IntersectionHighlight  {
       .intersectionHighlight;
   }

   
    String  {
         .id;
        + var10000 +  + String.valueOf(.particle) +  + String.valueOf(.renderMode) +  + String.valueOf(.shape) +  + String.valueOf(.emitOffset) +  + .useEmitDirection +  + .cameraOffset +  + String.valueOf(.particleRotationInfluence) +  + .particleRotateWithSpawner +  + .isLowRes +  + .trailSpawnerPositionMultiplier +  + .trailSpawnerRotationMultiplier +  + String.valueOf(.particleCollision) +  + .lightInfluence +  + .linearFiltering +  + String.valueOf(.totalParticles) +  + .lifeSpan +  + .maxConcurrentParticles +  + String.valueOf(.particleLifeSpan) +  + String.valueOf(.spawnRate) +  + .spawnBurst +  + String.valueOf(.waveDelay) +  + String.valueOf(.initialVelocity) +  + .velocityStretchMultiplier +  + String.valueOf(.uvMotion) +  + Arrays.toString(.attractors) +  + String.valueOf(.intersectionHighlight) + ;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(ParticleSpawner.class, ParticleSpawner::, Codec.STRING, (particleSpawner, s) -> particleSpawner.id = s, (particleSpawner) -> particleSpawner.id, (asset, data) -> asset.data = data, (asset) -> asset.data).metadata( ())).appendInherited( (,  (EmitShape.class)), (particleSpawner, s) -> particleSpawner.shape = s, (particleSpawner) -> particleSpawner.shape, (particleSpawner, parent) -> particleSpawner.shape = parent.shape).addValidator(Validators.nonNull()).add()).appendInherited( (, ProtocolCodecs.RANGE_VECTOR3F), (particleSpawner, s) -> particleSpawner.emitOffset = s, (particleSpawner) -> particleSpawner.emitOffset, (particleSpawner, parent) -> particleSpawner.emitOffset = parent.emitOffset).add()).appendInherited( (, Codec.BOOLEAN), (particleSpawner, b) -> particleSpawner.useEmitDirection = b, (particleSpawner) -> particleSpawner.useEmitDirection, (particleSpawner, parent) -> particleSpawner.useEmitDirection = parent.useEmitDirection).documentation().add()).appendInherited( (, ProtocolCodecs.RANGE), (particleSpawner, s) -> particleSpawner.totalParticles = s, (particleSpawner) -> particleSpawner.totalParticles, (particleSpawner, parent) -> particleSpawner.totalParticles = parent.totalParticles).add()).appendInherited( (, Codec.FLOAT), (particleSpawner, f) -> particleSpawner.lifeSpan = f, (particleSpawner) -> particleSpawner.lifeSpan, (particleSpawner, parent) -> particleSpawner.lifeSpan = parent.lifeSpan).add()).appendInherited( (, Codec.INTEGER), (particleSpawner, s) -> particleSpawner.maxConcurrentParticles = s, (particleSpawner) -> particleSpawner.maxConcurrentParticles, (particleSpawner, parent) -> particleSpawner.maxConcurrentParticles = parent.maxConcurrentParticles).add()).appendInherited( (, ProtocolCodecs.RANGEF), (particleSpawner, s) -> particleSpawner.particleLifeSpan = s, (particleSpawner) -> particleSpawner.particleLifeSpan, (particleSpawner, parent) -> particleSpawner.particleLifeSpan = parent.particleLifeSpan).add()).appendInherited( (, ProtocolCodecs.RANGEF), (particleSpawner, s) -> particleSpawner.spawnRate = s, (particleSpawner) -> particleSpawner.spawnRate, (particleSpawner, parent) -> particleSpawner.spawnRate = parent.spawnRate).add()).appendInherited( (, Codec.BOOLEAN), (particleSpawner, b) -> particleSpawner.spawnBurst = b, (particleSpawner) -> particleSpawner.spawnBurst, (particleSpawner, parent) -> particleSpawner.spawnRate = parent.spawnRate).add()).append( (, ProtocolCodecs.RANGEF), (particleSpawner, b) -> particleSpawner.waveDelay = b, (particleSpawner) -> particleSpawner.waveDelay).add()).appendInherited( (, ProtocolCodecs.INITIAL_VELOCITY), (particleSpawner, s) -> particleSpawner.initialVelocity = s, (particleSpawner) -> particleSpawner.initialVelocity, (particleSpawner, parent) -> particleSpawner.initialVelocity = parent.initialVelocity).add()).appendInherited( (,  (ParticleRotationInfluence.class)), (particleSpawner, s) -> particleSpawner.particleRotationInfluence = s, (particleSpawner) -> particleSpawner.particleRotationInfluence, (particleSpawner, parent) -> particleSpawner.particleRotationInfluence = parent.particleRotationInfluence).addValidator(Validators.nonNull()).metadata( ()).add()).appendInherited( (, Codec.BOOLEAN), (particleSpawner, s) -> particleSpawner.particleRotateWithSpawner = s, (particleSpawner) -> particleSpawner.particleRotateWithSpawner, (particleSpawner, parent) -> particleSpawner.particleRotateWithSpawner = parent.particleRotateWithSpawner).add()).appendInherited( (, Codec.FLOAT), (particleSpawner, f) -> particleSpawner.trailSpawnerPositionMultiplier = f, (particleSpawner) -> particleSpawner.trailSpawnerPositionMultiplier, (particleSpawner, parent) -> particleSpawner.trailSpawnerPositionMultiplier = parent.trailSpawnerPositionMultiplier).addValidator(Validators.range(, )).add()).appendInherited( (, Codec.FLOAT), (particleSpawner, f) -> particleSpawner.trailSpawnerRotationMultiplier = f, (particleSpawner) -> particleSpawner.trailSpawnerRotationMultiplier, (particleSpawner, parent) -> particleSpawner.trailSpawnerRotationMultiplier = parent.trailSpawnerRotationMultiplier).addValidator(Validators.range(, )).add()).append( (, Codec.FLOAT), (particleSpawner, f) -> particleSpawner.velocityStretchMultiplier = f, (particleSpawner) -> particleSpawner.velocityStretchMultiplier).add()).appendInherited( (,  (ParticleAttractor.CODEC, (x$) ->  [x$])), (particleSpawner, o) -> particleSpawner.attractors = o, (particleSpawner) -> particleSpawner.attractors, (particleSpawner, parent) -> particleSpawner.attractors = parent.attractors).metadata( ()).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (,  (FXRenderMode.class)), (particleSpawner, s) -> particleSpawner.renderMode = s, (particleSpawner) -> particleSpawner.renderMode, (particleSpawner, parent) -> particleSpawner.renderMode = parent.renderMode).addValidator(Validators.nonNull()).metadata( ()).add()).appendInherited( (, Codec.FLOAT), (particleSpawner, f) -> particleSpawner.lightInfluence = f, (particleSpawner) -> particleSpawner.lightInfluence, (particleSpawner, parent) -> particleSpawner.lightInfluence = parent.lightInfluence).add()).appendInherited( (, ProtocolCodecs.INTERSECTION_HIGHLIGHT), (particleSpawner, s) -> particleSpawner.intersectionHighlight = s, (particleSpawner) -> particleSpawner.intersectionHighlight, (particleSpawner, parent) -> particleSpawner.intersectionHighlight = parent.intersectionHighlight).add()).appendInherited( (, Codec.BOOLEAN), (particleSpawner, s) -> particleSpawner.linearFiltering = s, (particleSpawner) -> particleSpawner.linearFiltering, (particleSpawner, parent) -> particleSpawner.linearFiltering = parent.linearFiltering).add()).appendInherited( (, ProtocolCodecs.UV_MOTION), (particleSpawner, s) -> particleSpawner.uvMotion = s, (particleSpawner) -> particleSpawner.uvMotion, (particleSpawner, parent) -> particleSpawner.uvMotion = parent.uvMotion).add()).append( (, Codec.FLOAT), (particleSpawner, f) -> particleSpawner.cameraOffset = f, (particleSpawner) -> particleSpawner.cameraOffset).addValidator(Validators.range(-, )).add()).appendInherited( (, ParticleCollision.CODEC), (particleSpawner, s) -> particleSpawner.particleCollision = s, (particleSpawner) -> particleSpawner.particleCollision, (particleSpawner, parent) -> particleSpawner.particleCollision = parent.particleCollision).metadata( ()).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, Codec.BOOLEAN), (particleSpawner, s) -> particleSpawner.isLowRes = s, (particleSpawner) -> particleSpawner.isLowRes, (particleSpawner, parent) -> particleSpawner.isLowRes = parent.isLowRes).metadata( ()).add()).appendInherited( (, Particle.CODEC), (particleSpawner, o) -> particleSpawner.particle = o, (particleSpawner) -> particleSpawner.particle, (particleSpawner, parent) -> particleSpawner.particle = parent.particle).addValidator(Validators.nonNull()).metadata( ()).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).build();
      VALIDATOR_CACHE =  <String>( (ParticleSpawner::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/particle/config/ParticleSpawnerGroup.java

package com.hypixel.hytale.server.core.asset.type.particle.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.common.util.ArrayUtil;
import com.hypixel.hytale.protocol.Direction;
import com.hypixel.hytale.protocol.InitialVelocity;
import com.hypixel.hytale.protocol.RangeVector3f;
import com.hypixel.hytale.protocol.Rangef;
import com.hypixel.hytale.protocol.Vector3f;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.util.Arrays;
import javax.annotation.Nonnull;

public class ParticleSpawnerGroup implements NetworkSerializable<com.hypixel.hytale.protocol.ParticleSpawnerGroup> {
   public static final BuilderCodec<ParticleSpawnerGroup> CODEC;
   protected String spawnerId;
   protected Vector3f positionOffset;
   protected Direction rotationOffset;
   protected boolean fixedRotation;
   protected Rangef spawnRate;
   protected Rangef lifeSpan;
   protected float startDelay;
   protected Rangef waveDelay;
   protected int totalSpawners = ;
     maxConcurrent;
    InitialVelocity initialVelocity;
    RangeVector3f emitOffset;
    ParticleAttractor[] attractors;

     {
      .spawnerId = spawnerId;
      .positionOffset = positionOffset;
      .rotationOffset = rotationOffset;
      .fixedRotation = fixedRotation;
      .spawnRate = spawnRate;
      .startDelay = startDelay;
      .lifeSpan = lifeSpan;
      .waveDelay = waveDelay;
      .totalSpawners = totalSpawners;
      .maxConcurrent = maxConcurrent;
      .initialVelocity = initialVelocity;
      .emitOffset = emitOffset;
      .attractors = attractors;
   }

     {
   }

   
    com.hypixel.hytale.protocol.ParticleSpawnerGroup  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ParticleSpawnerGroup();
      packet.spawnerId = .spawnerId;
      packet.positionOffset = .positionOffset;
      packet.rotationOffset = .rotationOffset;
       (.spawnRate != ) {
         packet.spawnRate = .spawnRate;
      }

       (.lifeSpan != ) {
         packet.lifeSpan = .lifeSpan;
      }

       (.waveDelay != ) {
         packet.waveDelay = .waveDelay;
      }

      packet.startDelay = .startDelay;
      packet.maxConcurrent = .maxConcurrent;
      packet.totalSpawners = .totalSpawners;
      packet.initialVelocity = .initialVelocity;
      packet.emitOffset = .emitOffset;
       (.attractors !=  && .attractors.length > ) {
         packet.attractors = (com.hypixel.hytale.protocol.ParticleAttractor[])ArrayUtil.copyAndMutate(.attractors, ParticleAttractor::toPacket, (x$) ->  .hypixel.hytale.protocol.ParticleAttractor[x$]);
      }

      packet.fixedRotation = .fixedRotation;
       packet;
   }

    String  {
       .spawnerId;
   }

    Vector3f  {
       .positionOffset;
   }

    Direction  {
       .rotationOffset;
   }

      {
       .fixedRotation;
   }

    Rangef  {
       .spawnRate;
   }

    Rangef  {
       .lifeSpan;
   }

      {
       .startDelay;
   }

    Rangef  {
       .waveDelay;
   }

      {
       .totalSpawners;
   }

      {
       .maxConcurrent;
   }

    InitialVelocity  {
       .initialVelocity;
   }

    RangeVector3f  {
       .emitOffset;
   }

    ParticleAttractor[] getAttractors() {
       .attractors;
   }

   
    String  {
         .spawnerId;
        + var10000 +  + String.valueOf(.positionOffset) +  + String.valueOf(.rotationOffset) +  + .fixedRotation +  + String.valueOf(.spawnRate) +  + String.valueOf(.lifeSpan) +  + .startDelay +  + String.valueOf(.waveDelay) +  + .totalSpawners +  + .maxConcurrent +  + String.valueOf(.initialVelocity) +  + String.valueOf(.emitOffset) +  + Arrays.toString(.attractors) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ParticleSpawnerGroup.class, ParticleSpawnerGroup::).append( (, Codec.STRING), (particleSpawnerGroup, s) -> particleSpawnerGroup.spawnerId = s, (particleSpawnerGroup) -> particleSpawnerGroup.spawnerId).addValidator(ParticleSpawner.VALIDATOR_CACHE.getValidator()).add()).addField( (, ProtocolCodecs.VECTOR3F), (particleSpawnerGroup, o) -> particleSpawnerGroup.positionOffset = o, (particleSpawnerGroup) -> particleSpawnerGroup.positionOffset)).addField( (, ProtocolCodecs.DIRECTION), (particleSpawnerGroup, o) -> particleSpawnerGroup.rotationOffset = o, (particleSpawnerGroup) -> particleSpawnerGroup.rotationOffset)).addField( (, Codec.BOOLEAN), (particleSpawnerGroup, b) -> particleSpawnerGroup.fixedRotation = b, (particleSpawnerGroup) -> particleSpawnerGroup.fixedRotation)).addField( (, ProtocolCodecs.RANGEF), (particleSpawnerGroup, b) -> particleSpawnerGroup.spawnRate = b, (particleSpawnerGroup) -> particleSpawnerGroup.spawnRate)).addField( (, ProtocolCodecs.RANGEF), (particleSpawnerGroup, b) -> particleSpawnerGroup.lifeSpan = b, (particleSpawnerGroup) -> particleSpawnerGroup.lifeSpan)).addField( (, Codec.FLOAT), (particleSpawner, f) -> particleSpawner.startDelay = f, (particleSpawner) -> particleSpawner.startDelay)).addField( (, ProtocolCodecs.RANGEF), (particleSpawnerGroup, b) -> particleSpawnerGroup.waveDelay = b, (particleSpawnerGroup) -> particleSpawnerGroup.waveDelay)).addField( (, Codec.INTEGER), (particleSpawnerGroup, i) -> particleSpawnerGroup.totalSpawners = i, (particleSpawnerGroup) -> particleSpawnerGroup.totalSpawners)).addField( (, Codec.INTEGER), (particleSpawnerGroup, i) -> particleSpawnerGroup.maxConcurrent = i, (particleSpawnerGroup) -> particleSpawnerGroup.maxConcurrent)).addField( (, ProtocolCodecs.INITIAL_VELOCITY), (particleSpawnerGroup, o) -> particleSpawnerGroup.initialVelocity = o, (particleSpawnerGroup) -> particleSpawnerGroup.initialVelocity)).addField( (, ProtocolCodecs.RANGE_VECTOR3F), (particleSpawnerGroup, o) -> particleSpawnerGroup.emitOffset = o, (particleSpawnerGroup) -> particleSpawnerGroup.emitOffset)).addField( (,  (ParticleAttractor.CODEC, (x$) ->  [x$])), (particleSpawnerGroup, o) -> particleSpawnerGroup.attractors = o, (particleSpawnerGroup) -> particleSpawnerGroup.attractors)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/particle/config/ParticleSystem.java

package com.hypixel.hytale.server.core.asset.type.particle.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIDefaultCollapsedState;
import com.hypixel.hytale.codec.schema.metadata.ui.UITypeIcon;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.common.util.ArrayUtil;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.lang.ref.SoftReference;
import java.util.Arrays;
import javax.annotation.Nonnull;

public class ParticleSystem implements JsonAssetWithMap<String, DefaultAssetMap<String, ParticleSystem>>, NetworkSerializable<com.hypixel.hytale.protocol.ParticleSystem> {
   public static final AssetBuilderCodec<String, ParticleSystem> CODEC;
   public static final ValidatorCache<String> VALIDATOR_CACHE;
   private static AssetStore<String, ParticleSystem, DefaultAssetMap<String, ParticleSystem>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
     lifeSpan;
    ParticleSpawnerGroup[] spawners;
     cullDistance;
     boundingRadius;
     isImportant;
    SoftReference<com.hypixel.hytale.protocol.ParticleSystem> cachedPacket;

     AssetStore<String, ParticleSystem, DefaultAssetMap<String, ParticleSystem>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, ParticleSystem, DefaultAssetMap<String, ParticleSystem>>getAssetStore(ParticleSystem.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, ParticleSystem>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

     {
      .id = id;
      .lifeSpan = lifeSpan;
      .spawners = spawners;
      .cullDistance = cullDistance;
      .boundingRadius = boundingRadius;
      .isImportant = isImportant;
   }

     {
   }

   
    com.hypixel.hytale.protocol.ParticleSystem  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.ParticleSystem).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ParticleSystem();
         packet.id = .id;
         packet.lifeSpan = .lifeSpan;
          (.spawners !=  && .spawners.length > ) {
            packet.spawners = (com.hypixel.hytale.protocol.ParticleSpawnerGroup[])ArrayUtil.copyAndMutate(.spawners, ParticleSpawnerGroup::toPacket, (x$) ->  .hypixel.hytale.protocol.ParticleSpawnerGroup[x$]);
         }

         packet.cullDistance = .cullDistance;
         packet.boundingRadius = .boundingRadius;
         packet.isImportant = .isImportant;
         .cachedPacket =  (packet);
          packet;
      }
   }

    String  {
       .id;
   }

      {
       .lifeSpan;
   }

    ParticleSpawnerGroup[] getSpawners() {
       .spawners;
   }

      {
       .cullDistance;
   }

      {
       .boundingRadius;
   }

      {
       .isImportant;
   }

   
    String  {
         .id;
        + var10000 +  + .lifeSpan +  + Arrays.toString(.spawners) +  + .cullDistance +  + .boundingRadius +  + .isImportant + ;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(ParticleSystem.class, ParticleSystem::, Codec.STRING, (particleSystem, s) -> particleSystem.id = s, (particleSystem) -> particleSystem.id, (asset, data) -> asset.data = data, (asset) -> asset.data).metadata( ())).appendInherited( (,  (ParticleSpawnerGroup.CODEC, (x$) ->  [x$])), (particleSystem, o) -> particleSystem.spawners = o, (particleSystem) -> particleSystem.spawners, (particleSystem, parent) -> particleSystem.spawners = parent.spawners).metadata(UIDefaultCollapsedState.UNCOLLAPSED).addValidator(Validators.nonEmptyArray()).add()).appendInherited( (, Codec.FLOAT), (particleSystem, f) -> particleSystem.lifeSpan = f, (particleSystem) -> particleSystem.lifeSpan, (particleSystem, parent) -> particleSystem.lifeSpan = parent.lifeSpan).add()).appendInherited( (, Codec.FLOAT), (particleSystem, f) -> particleSystem.cullDistance = f, (particleSystem) -> particleSystem.cullDistance, (particleSystem, parent) -> particleSystem.cullDistance = parent.cullDistance).add()).appendInherited( (, Codec.FLOAT), (particleSystem, f) -> particleSystem.boundingRadius = f, (particleSystem) -> particleSystem.boundingRadius, (particleSystem, parent) -> particleSystem.boundingRadius = parent.boundingRadius).add()).appendInherited( (, Codec.BOOLEAN), (particleSystem, b) -> particleSystem.isImportant = b, (particleSystem) -> particleSystem.isImportant, (particleSystem, parent) -> particleSystem.isImportant = parent.isImportant).add()).build();
      VALIDATOR_CACHE =  <String>( (ParticleSystem::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/particle/config/WorldParticle.java

package com.hypixel.hytale.server.core.asset.type.particle.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.Color;
import com.hypixel.hytale.protocol.Direction;
import com.hypixel.hytale.protocol.Vector3f;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;

public class WorldParticle implements NetworkSerializable<com.hypixel.hytale.protocol.WorldParticle> {
   public static final String SYSTEM_ID_DOC = "The id of the particle system.";
   public static final String COLOR_DOC = "The colour used if none was specified in the particle settings.";
   public static final String SCALE_DOC = "The scale of the particle system.";
   public static final String   ;
         ;
      BuilderCodec<WorldParticle> CODEC;
      ArrayCodec<WorldParticle> ARRAY_CODEC;
    String systemId;
    Color color;
       ;
    Vector3f positionOffset;
    Direction rotationOffset;

     {
      .systemId = systemId;
      .color = color;
      .scale = scale;
      .positionOffset = positionOffset;
      .rotationOffset = rotationOffset;
   }

     {
   }

    String  {
       .systemId;
   }

    Color  {
       .color;
   }

      {
       .scale;
   }

    Vector3f  {
       .positionOffset;
   }

    Direction  {
       .rotationOffset;
   }

   
    com.hypixel.hytale.protocol.WorldParticle  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.WorldParticle();
      packet.systemId = .systemId;
      packet.color = .color;
      packet.scale = .scale;
      packet.positionOffset = .positionOffset;
      packet.rotationOffset = .rotationOffset;
       packet;
   }

   
    String  {
         .systemId;
        + var10000 +  + String.valueOf(.color) +  + .scale +  + String.valueOf(.positionOffset) +  + String.valueOf(.rotationOffset) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(WorldParticle.class, WorldParticle::).documentation()).append( (, Codec.STRING), (particle, s) -> particle.systemId = s, (particle) -> particle.systemId).documentation().addValidator(Validators.nonNull()).addValidator(ParticleSystem.VALIDATOR_CACHE.getValidator()).add()).append( (, ProtocolCodecs.COLOR), (particle, o) -> particle.color = o, (particle) -> particle.color).documentation().add()).append( (, Codec.FLOAT), (particle, f) -> particle.scale = f, (particle) -> particle.scale).documentation().add()).append( (, ProtocolCodecs.VECTOR3F), (particle, s) -> particle.positionOffset = s, (particle) -> particle.positionOffset).documentation().add()).append( (, ProtocolCodecs.DIRECTION), (particle, s) -> particle.rotationOffset = s, (particle) -> particle.rotationOffset).documentation().add()).build();
      ARRAY_CODEC =  <WorldParticle>(CODEC, (x$) ->  [x$]);
   }
}

com/hypixel/hytale/server/core/asset/type/particle/pages/ParticleSpawnPage.java

package com.hypixel.hytale.server.core.asset.type.particle.pages;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.common.util.StringCompareUtil;
import com.hypixel.hytale.component.AddReason;
import com.hypixel.hytale.component.Holder;
import com.hypixel.hytale.component.NonSerialized;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.component.RemoveReason;
import com.hypixel.hytale.component.Store;
import com.hypixel.hytale.component.spatial.SpatialResource;
import com.hypixel.hytale.math.vector.Transform;
import com.hypixel.hytale.math.vector.Vector3d;
import com.hypixel.hytale.math.vector.Vector3f;
import com.hypixel.hytale.protocol.Rangef;
import com.hypixel.hytale.protocol.packets.interface_.CustomPageLifetime;
import com.hypixel.hytale.protocol.packets.interface_.CustomUIEventBindingType;
import com.hypixel.hytale.server.core.asset.type.particle.config.ParticleSpawnerGroup;
import com.hypixel.hytale.server.core.asset.type.particle.config.ParticleSystem;
import com.hypixel.hytale.server.core.entity.entities.player.pages.InteractiveCustomUIPage;
import com.hypixel.hytale.server.core.modules.entity.EntityModule;
import com.hypixel.hytale.server.core.modules.entity.component.HeadRotation;
import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
import com.hypixel.hytale.server.core.ui.Value;
import com.hypixel.hytale.server.core.ui.builder.EventData;
import com.hypixel.hytale.server.core.ui.builder.UICommandBuilder;
 com.hypixel.hytale.server.core.ui.builder.UIEventBuilder;
 com.hypixel.hytale.server.core.universe.PlayerRef;
 com.hypixel.hytale.server.core.universe.world.ParticleUtil;
 com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
 com.hypixel.hytale.server.core.util.TargetUtil;
 it.unimi.dsi.fastutil.objects.Object2IntMap;
 it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
 it.unimi.dsi.fastutil.objects.ObjectList;
 java.util.Comparator;
 java.util.List;
 java.util.Locale;
 java.util.Objects;
 java.util.Set;
 java.util.stream.Collectors;
 java.util.stream.Stream;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;

    <ParticleSpawnPageEventData> {
         ;
      Value<String> BUTTON_LABEL_STYLE = Value.<String>ref(, );
      Value<String> BUTTON_LABEL_STYLE_SELECTED = Value.<String>ref(, );
   
       ;
    List<String> particleSystemIds;
   
    String selectedParticleSystemId;
   
    Ref<EntityStore> particleSystemPreview;
    Vector3d position;
    Vector3f rotation;

     {
      (playerRef, CustomPageLifetime.CanDismiss, ParticleSpawnPage.ParticleSpawnPageEventData.CODEC);
   }

      {
      commandBuilder.append();
      eventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, , EventData.of(, ), );
      eventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, , ( ()).append(, ).append(, ), );
      eventBuilder.addEventBinding(CustomUIEventBindingType.Activating, , ( ()).append(, ), );
      .buildParticleList(ref, commandBuilder, eventBuilder, store);
   }

      {
       (data.searchQuery != ) {
         .searchQuery = data.searchQuery.trim().toLowerCase();
             ();
             ();
         .buildParticleList(ref, commandBuilder, eventBuilder, store);
         .sendUpdate(commandBuilder, eventBuilder, );
      }  {
          (data.action) {
             :
                (data.particleSystemId != ) {
                      ();
                  .selectParticleSystem(ref, store, data.particleSystemId, commandBuilder);
                  .sendUpdate(commandBuilder, (UIEventBuilder), );
               }
               ;
             :
                (.particleSystemPreview.isValid()) {
                     (TransformComponent)store.getComponent(.particleSystemPreview, TransformComponent.getComponentType());
                  transform.getRotation().setYaw(.rotation.getYaw() + ()Math.toRadians(()data.rotationOffset));
                     (HeadRotation)store.getComponent(.particleSystemPreview, HeadRotation.getComponentType());
                   (headRotation != ) {
                     headRotation.getRotation().setYaw(.rotation.getYaw() + ()Math.toRadians(()data.rotationOffset));
                  }
               }
               ;
             :
                (.selectedParticleSystemId != ) {
                   (.particleSystemPreview.isValid()) {
                     store.removeEntity(.particleSystemPreview, RemoveReason.REMOVE);
                  }

                  SpatialResource<Ref<EntityStore>, EntityStore> playerSpatialResource = (SpatialResource)store.getResource(EntityModule.get().getPlayerSpatialResourceType());
                  ObjectList<Ref<EntityStore>> results = SpatialResource.getThreadLocalReferenceList();
                  playerSpatialResource.getSpatialStructure().collect(.position, , results);
                  ParticleUtil.spawnParticleEffect((String).selectedParticleSystemId, .position, .rotation, results, store);
               }
         }
      }

   }

      {
       (.particleSystemPreview.isValid()) {
         store.removeEntity(.particleSystemPreview, RemoveReason.REMOVE);
      }

   }

      {
      commandBuilder.clear();
      Set<String> roleTemplateNames = ParticleSystem.getAssetMap().getAssetMap().keySet();
       (!.searchQuery.isEmpty()) {
         Object2IntMap<String> map =  <String>(roleTemplateNames.size());

         (String value : roleTemplateNames) {
               StringCompareUtil.getFuzzyDistance(value, .searchQuery, Locale.ENGLISH);
             (fuzzyDistance > ) {
               map.put(value, fuzzyDistance);
            }
         }

            map.keySet().stream().sorted();
         Objects.requireNonNull(map);
         .particleSystemIds = (List)var10001.sorted(Comparator.comparingInt(map::getInt).reversed()).limit().collect(Collectors.toList());
      }  {
         .particleSystemIds = (List)roleTemplateNames.stream().sorted(String::compareTo).collect(Collectors.toList());
      }

         ;

      (   .particleSystemIds.size(); i < bound; ++i) {
            (String).particleSystemIds.get(i);
             + i + ;
         commandBuilder.append(, );
         commandBuilder.set(selector + , id);
         eventBuilder.addEventBinding(CustomUIEventBindingType.Activating, selector + , ( ()).append(, ).append(, id), );
      }

       (!.particleSystemIds.isEmpty()) {
          (!.particleSystemIds.contains(.selectedParticleSystemId)) {
            .selectParticleSystem(ref, store, (String).particleSystemIds.getFirst(), commandBuilder);
         }   (.selectedParticleSystemId != ) {
            .selectParticleSystem(ref, store, .selectedParticleSystemId, commandBuilder);
         }
      }

   }

      {
       (.selectedParticleSystemId !=  && .particleSystemIds.contains(.selectedParticleSystemId)) {
         commandBuilder.set( + .particleSystemIds.indexOf(.selectedParticleSystemId) + , BUTTON_LABEL_STYLE);
      }

         .particleSystemIds.indexOf(particleSystemId);
      commandBuilder.set( + var10001 + , BUTTON_LABEL_STYLE_SELECTED);
      commandBuilder.set(, particleSystemId);
         (ParticleSystem)ParticleSystem.getAssetMap().getAsset(particleSystemId);
         particleSystem.getLifeSpan();
      commandBuilder.set(, lifeSpan <=  ?  : String.valueOf(lifeSpan));
         ;
         -;

      (ParticleSpawnerGroup spawner : particleSystem.getSpawners()) {
            spawner.getLifeSpan();
          (groupLifespawn != ) {
            lifeSpanMin = Math.min(lifeSpanMin, groupLifespawn.min);
            lifeSpanMax = Math.max(lifeSpanMax, groupLifespawn.max);
         }  {
            lifeSpanMin = -;
            lifeSpanMax = ;
         }
      }

      commandBuilder.set(, String.format(, lifeSpanMin <  ?  : String.valueOf(lifeSpanMin), lifeSpanMax >=  ?  : (lifeSpanMax <  ?  : String.valueOf(lifeSpanMax))));
      .selectedParticleSystemId = particleSystemId;
       (.particleSystemPreview !=  && .particleSystemPreview.isValid()) {
          (.particleSystemPreview !=  && .particleSystemPreview.isValid()) {
         }
      }  {
            (TransformComponent)store.getComponent(ref, TransformComponent.getComponentType());

          transformComponent != ;

            (HeadRotation)store.getComponent(ref, HeadRotation.getComponentType());

          headRotationComponent != ;

            transformComponent.getPosition();
            headRotationComponent.getRotation();
            TargetUtil.getTargetLocation(ref, , store);
          (previewPosition == ) {
            previewPosition = playerPosition.clone().add(Transform.getDirection(headRotation.getPitch(), headRotation.getYaw()).scale());
         }

            TargetUtil.getTargetLocation(((EntityStore)store.getExternalData()).getWorld(), (blockId) -> blockId != , previewPosition.x, previewPosition.y, previewPosition.z, , -, , );
          (targetGround != ) {
            previewPosition = targetGround;
         }

         previewPosition.add(, ()particleSystem.getBoundingRadius(), );
            playerPosition.clone().subtract(previewPosition);
         relativePos.setY();
            Vector3f.lookAt(relativePos);
         .position = previewPosition;
         .rotation = previewRotation;
         Holder<EntityStore> holder = store.getRegistry().newHolder();
         holder.addComponent(EntityStore.REGISTRY.getNonSerializedComponentType(), NonSerialized.get());
         holder.addComponent(NetworkId.getComponentType(),  (((EntityStore)store.getExternalData()).takeNextNetworkId()));
         holder.addComponent(TransformComponent.getComponentType(),  (previewPosition, previewRotation));
         .particleSystemPreview = store.addEntity(holder, AddReason.SPAWN);
      }

   }

       {
           ;
           ;
           ;
           ;
         BuilderCodec<ParticleSpawnPageEventData> CODEC;
       String particleSystemId;
       String action;
       String searchQuery;
        rotationOffset;

        {
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ParticleSpawnPageEventData.class, ParticleSpawnPageEventData::).append( (, Codec.STRING), (entry, s) -> entry.action = s, (entry) -> entry.action).add()).append( (, Codec.STRING), (entry, s) -> entry.particleSystemId = s, (entry) -> entry.particleSystemId).add()).append( (, Codec.STRING), (entry, s) -> entry.searchQuery = s, (entry) -> entry.searchQuery).add()).append( (, Codec.FLOAT), (entry, s) -> entry.rotationOffset = s, (entry) -> entry.rotationOffset).add()).build();
      }
   }
}

com/hypixel/hytale/server/core/asset/type/portalworld/PillTag.java

package com.hypixel.hytale.server.core.asset.type.portalworld;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.Color;
import com.hypixel.hytale.server.core.Message;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;

public class PillTag {
   public static final BuilderCodec<PillTag> CODEC;
   public static final PillTag[] EMPTY_LIST;
   private String translationKey;
   private Color color;

   public PillTag() {
   }

   public String getTranslationKey() {
      return this.translationKey;
   }

   public Message getMessage() {
      return Message.translation(this.translationKey);
   }

   public Color getColor() {
      return this.color;
   }

   public String toString() {
      String var10000 = this.translationKey;
      return  + var10000 +  + String.valueOf(.color) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(PillTag.class, PillTag::).appendInherited( (, Codec.STRING), (pillTag, o) -> pillTag.translationKey = o, (pillTag) -> pillTag.translationKey, (pillTag, parent) -> pillTag.translationKey = parent.translationKey).documentation().add()).appendInherited( (, ProtocolCodecs.COLOR), (pillTag, o) -> pillTag.color = o, (pillTag) -> pillTag.color, (pillTag, parent) -> pillTag.color = parent.color).add()).build();
      EMPTY_LIST =  [];
   }
}

com/hypixel/hytale/server/core/asset/type/portalworld/PortalDescription.java

package com.hypixel.hytale.server.core.asset.type.portalworld;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.common.util.ArrayUtil;
import com.hypixel.hytale.protocol.Color;
import com.hypixel.hytale.server.core.Message;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class PortalDescription {
   public static final BuilderCodec<PortalDescription> CODEC;
   private String displayNameKey;
   private String flavorTextKey;
   private Color themeColor;
   private PillTag[] pillTags;
   private String[] objectivesKeys;
   private String[] wisdomKeys;
   private String splashImageFilename;

   public PortalDescription() {
   }

   public String getDisplayNameKey() {
      return this.displayNameKey;
   }

   public Message getDisplayName() {
      return Message.translation(this.displayNameKey);
   }

   public String  {
       .flavorTextKey;
   }

    Message  {
       Message.translation(.flavorTextKey);
   }

    Color  {
       .themeColor;
   }

    List<PillTag>  {
       .pillTags ==  ? Collections.emptyList() : Arrays.asList(.pillTags);
   }

    String[] getObjectivesKeys() {
       .objectivesKeys ==  ? ArrayUtil.EMPTY_STRING_ARRAY : .objectivesKeys;
   }

    String[] getWisdomKeys() {
       .wisdomKeys ==  ? ArrayUtil.EMPTY_STRING_ARRAY : .wisdomKeys;
   }

    String  {
       .splashImageFilename;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(PortalDescription.class, PortalDescription::).append( (, Codec.STRING), (portalType, o) -> portalType.displayNameKey = o, (portalType) -> portalType.displayNameKey).documentation().add()).append( (, Codec.STRING), (portalType, o) -> portalType.flavorTextKey = o, (portalType) -> portalType.flavorTextKey).documentation().add()).append( (, ProtocolCodecs.COLOR), (portalType, o) -> portalType.themeColor = o, (portalType) -> portalType.themeColor).documentation().add()).append( (,  (PillTag.CODEC, (x$) ->  [x$])), (portalType, o) -> portalType.pillTags = o, (portalType) -> portalType.pillTags).documentation().add()).append( (, Codec.STRING_ARRAY), (portalType, o) -> portalType.objectivesKeys = o, (portalType) -> portalType.objectivesKeys).documentation().add()).append( (, Codec.STRING_ARRAY), (portalType, o) -> portalType.wisdomKeys = o, (portalType) -> portalType.wisdomKeys).documentation().add()).append( (, Codec.STRING), (portalType, o) -> portalType.splashImageFilename = o, (portalType) -> portalType.splashImageFilename).documentation().add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/portalworld/PortalSpawn.java

package com.hypixel.hytale.server.core.asset.type.portalworld;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.math.vector.Vector3i;

public class PortalSpawn {
   public static final BuilderCodec<PortalSpawn> CODEC;
   private Vector3i center;
   private int scanHeight;
   private int checkSpawnY;
   private int minRadius;
   private int maxRadius;
   private int chunkDartThrows;
   private int checksPerChunk;

   public PortalSpawn() {
      this.center = Vector3i.ZERO.clone();
      this.scanHeight = 16;
      this.chunkDartThrows = 20;
      this.checksPerChunk = 5;
   }

   public Vector3i getCenter() {
      return this.center;
   }

   public int getCheckSpawnY() {
      return this.checkSpawnY;
   }

      {
       .scanHeight;
   }

      {
       .minRadius;
   }

      {
       .maxRadius;
   }

      {
       .chunkDartThrows;
   }

      {
       .checksPerChunk;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(PortalSpawn.class, PortalSpawn::).append( (, Codec.INTEGER), (spawn, o) -> spawn.checkSpawnY = o, (spawn) -> spawn.checkSpawnY).documentation().add()).append( (, Codec.INTEGER), (spawn, o) -> spawn.scanHeight = o, (spawn) -> spawn.scanHeight).documentation().add()).append( (, Codec.INTEGER), (spawn, o) -> spawn.minRadius = o, (spawn) -> spawn.minRadius).documentation().add()).append( (, Codec.INTEGER), (spawn, o) -> spawn.maxRadius = o, (spawn) -> spawn.maxRadius).documentation().add()).append( (, Vector3i.CODEC), (spawn, o) -> spawn.center = o, (spawn) -> spawn.center).documentation().add()).append( (, Codec.INTEGER), (spawn, o) -> spawn.chunkDartThrows = o, (spawn) -> spawn.chunkDartThrows).documentation().add()).append( (, Codec.INTEGER), (spawn, o) -> spawn.checksPerChunk = o, (spawn) -> spawn.checksPerChunk).documentation().add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/portalworld/PortalType.java

package com.hypixel.hytale.server.core.asset.type.portalworld;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.server.core.Message;
import com.hypixel.hytale.server.core.asset.type.gameplay.GameplayConfig;
import java.util.Collections;
import java.util.Set;
import javax.annotation.Nullable;

public class PortalType implements JsonAssetWithMap<String, DefaultAssetMap<String, PortalType>> {
   public static final AssetBuilderCodec<String, PortalType> CODEC;
   private static AssetStore<String, PortalType, DefaultAssetMap<String, PortalType>> ASSET_STORE;
   public static final ValidatorCache<String> VALIDATOR_CACHE;
   private AssetExtraInfo.Data data;
   private String id;
   private String instanceId;
   private PortalDescription description;
   private String gameplayConfig  ;
       ;
    PortalSpawn portalSpawn;
    Set<String> cursedItems = Collections.emptySet();

     {
   }

     AssetStore<String, PortalType, DefaultAssetMap<String, PortalType>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, PortalType, DefaultAssetMap<String, PortalType>>getAssetStore(PortalType.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, PortalType>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

    String  {
       .id;
   }

    String  {
       .instanceId;
   }

    Message  {
       .description.getDisplayName();
   }

    PortalDescription  {
       .description;
   }

   
    PortalSpawn  {
       .portalSpawn;
   }

    Set<String>  {
       .cursedItems;
   }

    String  {
       .gameplayConfig;
   }

      {
       .voidInvasionEnabled;
   }

   
    GameplayConfig  {
       (GameplayConfig)GameplayConfig.getAssetMap().getAsset(.gameplayConfig);
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(PortalType.class, PortalType::, Codec.STRING, (portalType, s) -> portalType.id = s, (portalType) -> portalType.id, (asset, data) -> asset.data = data, (asset) -> asset.data).append( (, Codec.STRING), (portalType, o) -> portalType.instanceId = o, (portalType) -> portalType.instanceId).documentation().add()).append( (, PortalDescription.CODEC), (portalType, o) -> portalType.description = o, (portalType) -> portalType.description).documentation().add()).append( (, PortalSpawn.CODEC), (portalType, o) -> portalType.portalSpawn = o, (portalType) -> portalType.portalSpawn).documentation().add()).append( (, Codec.STRING_ARRAY), (portalType, o) -> portalType.cursedItems = o ==  ? Collections.emptySet() : Set.of(o), (portalType) -> (String[])portalType.cursedItems.toArray((x$) ->  [x$])).documentation().add()).append( (, Codec.BOOLEAN), (portalType, o) -> portalType.voidInvasionEnabled = o, (portalType) -> portalType.voidInvasionEnabled).documentation().add()).append( (, Codec.STRING), (config, o) -> config.gameplayConfig = o, (config) -> config.gameplayConfig).documentation().add()).build();
      VALIDATOR_CACHE =  <String>( (PortalType::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/projectile/config/Projectile.java

package com.hypixel.hytale.server.core.asset.type.projectile.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.server.core.asset.type.model.config.ModelAsset;
import com.hypixel.hytale.server.core.asset.type.particle.config.WorldParticle;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
import com.hypixel.hytale.server.core.asset.type.soundevent.validator.SoundEventValidators;
import com.hypixel.hytale.server.core.entity.ExplosionConfig;
import com.hypixel.hytale.server.core.modules.physics.SimplePhysicsProvider;
import com.hypixel.hytale.server.core.modules.projectile.config.BallisticData;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

/** @deprecated */
@Deprecated
public class Projectile implements JsonAssetWithMap<String, DefaultAssetMap<String, Projectile>>, BallisticData {
   public static final AssetBuilderCodec<String, Projectile> CODEC;
     AssetStore<String, Projectile, DefaultAssetMap<String, Projectile>> ASSET_STORE;
      ValidatorCache<String> VALIDATOR_CACHE;
    AssetExtraInfo.Data data;
    String id;
    String appearance;
     radius;
     height;
     verticalCenterShot;
     horizontalCenterShot;
     depthShot;
     pitchAdjustShot;
     muzzleVelocity;
     terminalVelocity;
     gravity;
     bounciness;
     impactSlowdown;
     sticksVertically;
       ;
       ;
       ;
    SimplePhysicsProvider.ROTATION_MODE rotationMode;
     timeToLive;
    String bounceSoundEventId;
      bounceSoundEventIndex;
   
    WorldParticle bounceParticles;
    String hitSoundEventId;
      hitSoundEventIndex;
   
    WorldParticle hitParticles;
     damage;
     deadTime;
    String missSoundEventId;
      missSoundEventIndex;
    WorldParticle missParticles;
     deadTimeMiss;
    String deathSoundEventId;
      deathSoundEventIndex;
   
    WorldParticle deathParticles;
     deathEffectsOnHit;
   
    ExplosionConfig explosionConfig;
    density;
    waterTerminalVelocityMultiplier;
    waterHitImpulseLoss;
    dampingRotation;
    rotationSpeedVelocityRatio;
    swimmingDampingFactor;

     AssetStore<String, Projectile, DefaultAssetMap<String, Projectile>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, Projectile, DefaultAssetMap<String, Projectile>>getAssetStore(Projectile.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, Projectile>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

     {
      .rotationMode = SimplePhysicsProvider.ROTATION_MODE.Velocity;
      .deadTimeMiss = ;
      .density = ;
      .waterTerminalVelocityMultiplier = ;
      .waterHitImpulseLoss = ;
      .dampingRotation = ;
      .rotationSpeedVelocityRatio = ;
      .swimmingDampingFactor = ;
   }

    String  {
       .id;
   }

    String  {
       .appearance;
   }

      {
       .radius;
   }

      {
       .height;
   }

      {
       .verticalCenterShot;
   }

      {
       .horizontalCenterShot;
   }

      {
       .depthShot;
   }

      {
       .pitchAdjustShot;
   }

      {
       .sticksVertically;
   }

      {
       .muzzleVelocity;
   }

      {
       .terminalVelocity;
   }

      {
       .gravity;
   }

      {
       .bounciness;
   }

      {
       .impactSlowdown;
   }

      {
       .timeToLive;
   }

      {
       .damage;
   }

      {
       .deadTime;
   }

      {
       .deadTimeMiss;
   }

    String  {
       .bounceSoundEventId;
   }

      {
       .bounceSoundEventIndex;
   }

    String  {
       .hitSoundEventId;
   }

      {
       .hitSoundEventIndex;
   }

    String  {
       .missSoundEventId;
   }

      {
       .missSoundEventIndex;
   }

    String  {
       .deathSoundEventId;
   }

      {
       .deathSoundEventIndex;
   }

   
    WorldParticle  {
       .bounceParticles;
   }

   
    WorldParticle  {
       .missParticles;
   }

   
    WorldParticle  {
       .deathParticles;
   }

   
    WorldParticle  {
       .hitParticles;
   }

      {
       .deathEffectsOnHit;
   }

      {
       .computeYaw;
   }

      {
       .computePitch;
   }

      {
       .computeRoll;
   }

    SimplePhysicsProvider.ROTATION_MODE  {
       .rotationMode;
   }

      {
       .density;
   }

      {
       .waterTerminalVelocityMultiplier;
   }

      {
       .waterHitImpulseLoss;
   }

      {
       .dampingRotation;
   }

      {
       .rotationSpeedVelocityRatio;
   }

      {
       .swimmingDampingFactor;
   }

      {
       (.bounceSoundEventId != ) {
         .bounceSoundEventIndex = SoundEvent.getAssetMap().getIndex(.bounceSoundEventId);
      }

       (.hitSoundEventId != ) {
         .hitSoundEventIndex = SoundEvent.getAssetMap().getIndex(.hitSoundEventId);
      }

       (.missSoundEventId != ) {
         .missSoundEventIndex = SoundEvent.getAssetMap().getIndex(.missSoundEventId);
      }

       (.deathSoundEventId != ) {
         .deathSoundEventIndex = SoundEvent.getAssetMap().getIndex(.deathSoundEventId);
      }

   }

      {
       ( == o) {
          ;
      }   (o !=  && .getClass() == o.getClass()) {
            (Projectile)o;
          (Double.compare(that.radius, .radius) != ) {
             ;
         }   (Double.compare(that.height, .height) != ) {
             ;
         }   (Double.compare(that.verticalCenterShot, .verticalCenterShot) != ) {
             ;
         }   (Double.compare(that.horizontalCenterShot, .horizontalCenterShot) != ) {
             ;
         }   (Double.compare(that.depthShot, .depthShot) != ) {
             ;
         }   (.pitchAdjustShot != that.pitchAdjustShot) {
             ;
         }   (Double.compare(that.muzzleVelocity, .muzzleVelocity) != ) {
             ;
         }   (Double.compare(that.terminalVelocity, .terminalVelocity) != ) {
             ;
         }   (Double.compare(that.gravity, .gravity) != ) {
             ;
         }   (Double.compare(that.bounciness, .bounciness) != ) {
             ;
         }   (Double.compare(that.impactSlowdown, .impactSlowdown) != ) {
             ;
         }   (.sticksVertically != that.sticksVertically) {
             ;
         }   (.computeYaw != that.computeYaw) {
             ;
         }   (.computePitch != that.computePitch) {
             ;
         }   (.computeRoll != that.computeRoll) {
             ;
         }   (Double.compare(that.timeToLive, .timeToLive) != ) {
             ;
         }   (.bounceSoundEventIndex != that.bounceSoundEventIndex) {
             ;
         }   (.hitSoundEventIndex != that.hitSoundEventIndex) {
             ;
         }   (.damage != that.damage) {
             ;
         }   (Double.compare(that.deadTime, .deadTime) != ) {
             ;
         }   (.missSoundEventIndex != that.missSoundEventIndex) {
             ;
         }   (Double.compare(that.deadTimeMiss, .deadTimeMiss) != ) {
             ;
         }   (.deathSoundEventIndex != that.deathSoundEventIndex) {
             ;
         }   (.deathEffectsOnHit != that.deathEffectsOnHit) {
             ;
         }   (.explosionConfig != that.explosionConfig) {
             ;
         }   (Double.compare(that.density, .density) != ) {
             ;
         }   (Double.compare(that.waterTerminalVelocityMultiplier, .waterTerminalVelocityMultiplier) != ) {
             ;
         }   (Double.compare(that.waterHitImpulseLoss, .waterHitImpulseLoss) != ) {
             ;
         }   (Double.compare(that.dampingRotation, .dampingRotation) != ) {
             ;
         }   (Double.compare(that.rotationSpeedVelocityRatio, .rotationSpeedVelocityRatio) != ) {
             ;
         }   (Double.compare(that.swimmingDampingFactor, .swimmingDampingFactor) != ) {
             ;
         }   (!.id.equals(that.id)) {
             ;
         }  {
             (.appearance != ) {
                (!.appearance.equals(that.appearance)) {
                   ;
               }
            }   (that.appearance != ) {
                ;
            }

             (.rotationMode != that.rotationMode) {
                ;
            }  {
                (.bounceSoundEventId != ) {
                   (!.bounceSoundEventId.equals(that.bounceSoundEventId)) {
                      ;
                  }
               }   (that.bounceSoundEventId != ) {
                   ;
               }

                (.bounceParticles != ) {
                   (!.bounceParticles.equals(that.bounceParticles)) {
                      ;
                  }
               }   (that.bounceParticles != ) {
                   ;
               }

                (.hitSoundEventId != ) {
                   (!.hitSoundEventId.equals(that.hitSoundEventId)) {
                      ;
                  }
               }   (that.hitSoundEventId != ) {
                   ;
               }

                (.hitParticles != ) {
                   (!.hitParticles.equals(that.hitParticles)) {
                      ;
                  }
               }   (that.hitParticles != ) {
                   ;
               }

                (.missSoundEventId != ) {
                   (!.missSoundEventId.equals(that.missSoundEventId)) {
                      ;
                  }
               }   (that.missSoundEventId != ) {
                   ;
               }

                (.missParticles != ) {
                   (!.missParticles.equals(that.missParticles)) {
                      ;
                  }
               }   (that.missParticles != ) {
                   ;
               }

                (.deathSoundEventId != ) {
                   (!.deathSoundEventId.equals(that.deathSoundEventId)) {
                      ;
                  }
               }   (that.deathSoundEventId != ) {
                   ;
               }

                .deathParticles !=  ? !.deathParticles.equals(that.deathParticles) : that.deathParticles != ;
            }
         }
      }  {
          ;
      }
   }

      {
         .id.hashCode();
      result =  * result + (.appearance !=  ? .appearance.hashCode() : );
         Double.doubleToLongBits(.radius);
      result =  * result + ()(temp ^ temp >>> );
      temp = Double.doubleToLongBits(.height);
      result =  * result + ()(temp ^ temp >>> );
      temp = Double.doubleToLongBits(.verticalCenterShot);
      result =  * result + ()(temp ^ temp >>> );
      temp = Double.doubleToLongBits(.horizontalCenterShot);
      result =  * result + ()(temp ^ temp >>> );
      temp = Double.doubleToLongBits(.depthShot);
      result =  * result + ()(temp ^ temp >>> );
      result =  * result + (.pitchAdjustShot ?  : );
      temp = Double.doubleToLongBits(.muzzleVelocity);
      result =  * result + ()(temp ^ temp >>> );
      temp = Double.doubleToLongBits(.terminalVelocity);
      result =  * result + ()(temp ^ temp >>> );
      temp = Double.doubleToLongBits(.gravity);
      result =  * result + ()(temp ^ temp >>> );
      temp = Double.doubleToLongBits(.bounciness);
      result =  * result + ()(temp ^ temp >>> );
      temp = Double.doubleToLongBits(.impactSlowdown);
      result =  * result + ()(temp ^ temp >>> );
      result =  * result + (.sticksVertically ?  : );
      result =  * result + (.computeYaw ?  : );
      result =  * result + (.computePitch ?  : );
      result =  * result + (.computeRoll ?  : );
      result =  * result + (.rotationMode !=  ? .rotationMode.hashCode() : );
      temp = Double.doubleToLongBits(.timeToLive);
      result =  * result + ()(temp ^ temp >>> );
      result =  * result + (.bounceSoundEventId !=  ? .bounceSoundEventId.hashCode() : );
      result =  * result + .bounceSoundEventIndex;
      result =  * result + (.bounceParticles !=  ? .bounceParticles.hashCode() : );
      result =  * result + (.hitSoundEventId !=  ? .hitSoundEventId.hashCode() : );
      result =  * result + .hitSoundEventIndex;
      result =  * result + (.hitParticles !=  ? .hitParticles.hashCode() : );
      result =  * result + .damage;
      temp = Double.doubleToLongBits(.deadTime);
      result =  * result + ()(temp ^ temp >>> );
      result =  * result + (.missSoundEventId !=  ? .missSoundEventId.hashCode() : );
      result =  * result + .missSoundEventIndex;
      result =  * result + (.missParticles !=  ? .missParticles.hashCode() : );
      temp = Double.doubleToLongBits(.deadTimeMiss);
      result =  * result + ()(temp ^ temp >>> );
      result =  * result + (.deathSoundEventId !=  ? .deathSoundEventId.hashCode() : );
      result =  * result + .deathSoundEventIndex;
      result =  * result + (.deathParticles !=  ? .deathParticles.hashCode() : );
      result =  * result + (.deathEffectsOnHit ?  : );
      result =  * result + ()(temp ^ temp >>> );
      temp = Double.doubleToLongBits(.density);
      result =  * result + ()(temp ^ temp >>> );
      temp = Double.doubleToLongBits(.waterTerminalVelocityMultiplier);
      result =  * result + ()(temp ^ temp >>> );
      temp = Double.doubleToLongBits(.waterHitImpulseLoss);
      result =  * result + ()(temp ^ temp >>> );
      temp = Double.doubleToLongBits(.dampingRotation);
      result =  * result + ()(temp ^ temp >>> );
      temp = Double.doubleToLongBits(.rotationSpeedVelocityRatio);
      result =  * result + ()(temp ^ temp >>> );
      temp = Double.doubleToLongBits(.swimmingDampingFactor);
      result =  * result + ()(temp ^ temp >>> );
       result;
   }

   
    String  {
         .id;
        + var10000 +  + .appearance +  + .radius +  + .height +  + .verticalCenterShot +  + .horizontalCenterShot +  + .depthShot +  + .pitchAdjustShot +  + .muzzleVelocity +  + .terminalVelocity +  + .gravity +  + .bounciness +  + .impactSlowdown +  + .sticksVertically +  + .computeYaw +  + .computePitch +  + .computeRoll +  + String.valueOf(.rotationMode) +  + .timeToLive +  + .bounceSoundEventId +  + String.valueOf(.bounceParticles) +  + .hitSoundEventId +  + String.valueOf(.hitParticles) +  + .damage +  + .deadTime +  + .missSoundEventId +  + String.valueOf(.missParticles) +  + .deadTimeMiss +  + .deathSoundEventId +  + String.valueOf(.deathParticles) +  + .deathEffectsOnHit +  + .density +  + .waterTerminalVelocityMultiplier +  + .waterHitImpulseLoss +  + .dampingRotation +  + .rotationSpeedVelocityRatio +  + .swimmingDampingFactor + ;
   }

   
    ExplosionConfig  {
       .explosionConfig;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(Projectile.class, Projectile::, Codec.STRING, (projectile, s) -> projectile.id = s, (projectile) -> projectile.id, (asset, data) -> asset.data = data, (asset) -> asset.data).appendInherited( (, Codec.STRING), (projectile, s) -> projectile.appearance = s, (projectile) -> projectile.appearance, (projectile, parent) -> projectile.appearance = parent.appearance).addValidator(ModelAsset.VALIDATOR_CACHE.getValidator()).add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.radius = s, (projectile) -> projectile.radius, (projectile, parent) -> projectile.radius = parent.radius).add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.height = s, (projectile) -> projectile.height, (projectile, parent) -> projectile.height = parent.height).add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.verticalCenterShot = s, (projectile) -> projectile.verticalCenterShot, (projectile, parent) -> projectile.verticalCenterShot = parent.verticalCenterShot).add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.horizontalCenterShot = s, (projectile) -> projectile.horizontalCenterShot, (projectile, parent) -> projectile.horizontalCenterShot = parent.horizontalCenterShot).add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.depthShot = s, (projectile) -> projectile.depthShot, (projectile, parent) -> projectile.depthShot = parent.depthShot).add()).appendInherited( (, Codec.BOOLEAN), (projectile, s) -> projectile.pitchAdjustShot = s, (projectile) -> projectile.pitchAdjustShot, (projectile, parent) -> projectile.pitchAdjustShot = parent.pitchAdjustShot).add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.muzzleVelocity = s, (projectile) -> projectile.muzzleVelocity, (projectile, parent) -> projectile.muzzleVelocity = parent.muzzleVelocity).add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.terminalVelocity = s, (projectile) -> projectile.terminalVelocity, (projectile, parent) -> projectile.terminalVelocity = parent.terminalVelocity).add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.gravity = s, (projectile) -> projectile.gravity, (projectile, parent) -> projectile.gravity = parent.gravity).add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.bounciness = s, (projectile) -> projectile.bounciness, (projectile, parent) -> projectile.bounciness = parent.bounciness).add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.impactSlowdown = s, (projectile) -> projectile.impactSlowdown, (projectile, parent) -> projectile.impactSlowdown = parent.impactSlowdown).add()).appendInherited( (, Codec.BOOLEAN), (projectile, s) -> projectile.sticksVertically = s, (projectile) -> projectile.sticksVertically, (projectile, parent) -> projectile.sticksVertically = parent.sticksVertically).add()).appendInherited( (, Codec.BOOLEAN), (projectile, s) -> projectile.computeYaw = s, (projectile) -> projectile.computeYaw, (projectile, parent) -> projectile.computeYaw = parent.computeYaw).add()).appendInherited( (, Codec.BOOLEAN), (projectile, s) -> projectile.computePitch = s, (projectile) -> projectile.computePitch, (projectile, parent) -> projectile.computePitch = parent.computePitch).add()).appendInherited( (, Codec.BOOLEAN), (projectile, s) -> projectile.computeRoll = s, (projectile) -> projectile.computeRoll, (projectile, parent) -> projectile.computeRoll = parent.computeRoll).add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.timeToLive = s, (projectile) -> projectile.timeToLive, (projectile, parent) -> projectile.timeToLive = parent.timeToLive).add()).appendInherited( (, Codec.STRING), (projectile, s) -> projectile.bounceSoundEventId = s, (projectile) -> projectile.bounceSoundEventId, (projectile, parent) -> projectile.bounceSoundEventId = parent.bounceSoundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.MONO).add()).appendInherited( (, WorldParticle.CODEC), (projectile, s) -> projectile.bounceParticles = s, (projectile) -> projectile.bounceParticles, (projectile, parent) -> projectile.bounceParticles = parent.bounceParticles).add()).appendInherited( (, Codec.STRING), (projectile, s) -> projectile.hitSoundEventId = s, (projectile) -> projectile.hitSoundEventId, (projectile, parent) -> projectile.hitSoundEventId = parent.hitSoundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.MONO).add()).appendInherited( (, WorldParticle.CODEC), (projectile, s) -> projectile.hitParticles = s, (projectile) -> projectile.hitParticles, (projectile, parent) -> projectile.hitParticles = parent.hitParticles).add()).appendInherited( (, Codec.INTEGER), (projectile, s) -> projectile.damage = s, (projectile) -> projectile.damage, (projectile, parent) -> projectile.damage = parent.damage).add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.deadTime = s, (projectile) -> projectile.deadTime, (projectile, parent) -> projectile.deadTime = parent.deadTime).add()).appendInherited( (, Codec.STRING), (projectile, s) -> projectile.missSoundEventId = s, (projectile) -> projectile.missSoundEventId, (projectile, parent) -> projectile.missSoundEventId = parent.missSoundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.MONO).add()).appendInherited( (, WorldParticle.CODEC), (projectile, s) -> projectile.missParticles = s, (projectile) -> projectile.missParticles, (projectile, parent) -> projectile.missParticles = parent.missParticles).add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.deadTimeMiss = s, (projectile) -> projectile.deadTimeMiss, (projectile, parent) -> projectile.deadTimeMiss = parent.deadTimeMiss).add()).appendInherited( (, Codec.STRING), (projectile, s) -> projectile.deathSoundEventId = s, (projectile) -> projectile.deathSoundEventId, (projectile, parent) -> projectile.deathSoundEventId = parent.deathSoundEventId).addValidator(SoundEvent.VALIDATOR_CACHE.getValidator()).addValidator(SoundEventValidators.MONO).add()).appendInherited( (, WorldParticle.CODEC), (projectile, s) -> projectile.deathParticles = s, (projectile) -> projectile.deathParticles, (projectile, parent) -> projectile.deathParticles = parent.deathParticles).add()).appendInherited( (, Codec.BOOLEAN), (projectile, b) -> projectile.deathEffectsOnHit = b, (projectile) -> projectile.deathEffectsOnHit, (projectile, parent) -> projectile.deathEffectsOnHit = parent.deathEffectsOnHit).add()).appendInherited( (, ExplosionConfig.CODEC), (projectile, s) -> projectile.explosionConfig = s, (projectile) -> projectile.explosionConfig, (projectile, parent) -> projectile.explosionConfig = parent.explosionConfig).documentation().add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.density = s, (projectile) -> projectile.density, (projectile, parent) -> projectile.density = parent.density).add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.waterTerminalVelocityMultiplier = s, (projectile) -> projectile.waterTerminalVelocityMultiplier, (projectile, parent) -> projectile.waterTerminalVelocityMultiplier = parent.waterTerminalVelocityMultiplier).add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.waterHitImpulseLoss = s, (projectile) -> projectile.waterHitImpulseLoss, (projectile, parent) -> projectile.waterHitImpulseLoss = parent.waterHitImpulseLoss).add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.dampingRotation = s, (projectile) -> projectile.dampingRotation, (projectile, parent) -> projectile.dampingRotation = parent.dampingRotation).add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.rotationSpeedVelocityRatio = s, (projectile) -> projectile.rotationSpeedVelocityRatio, (projectile, parent) -> projectile.rotationSpeedVelocityRatio = parent.rotationSpeedVelocityRatio).add()).appendInherited( (, Codec.DOUBLE), (projectile, s) -> projectile.swimmingDampingFactor = s, (projectile) -> projectile.swimmingDampingFactor, (projectile, parent) -> projectile.swimmingDampingFactor = parent.swimmingDampingFactor).add()).appendInherited( (,  (SimplePhysicsProvider.ROTATION_MODE.class)), (projectile, type) -> projectile.rotationMode = type, (projectile) -> projectile.rotationMode, (projectile, parent) -> projectile.rotationMode = parent.rotationMode).add()).afterDecode(Projectile::processConfig)).build();
      VALIDATOR_CACHE =  <String>( (Projectile::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/responsecurve/ScaledResponseCurve.java

package com.hypixel.hytale.server.core.asset.type.responsecurve;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.codec.AssetCodecMapCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.lookup.Priority;
import javax.annotation.Nonnull;

public abstract class ScaledResponseCurve implements JsonAssetWithMap<String, DefaultAssetMap<String, ScaledResponseCurve>> {
   public static final AssetCodecMapCodec<String, ScaledResponseCurve> CODEC;
   protected AssetExtraInfo.Data data;
   protected String id;

   public ScaledResponseCurve(String id) {
      this.id = id;
   }

   protected ScaledResponseCurve() {
   }

   public abstract double computeY(double var1);

   public String getId() {
      return this.id;
   }

   @Nonnull
   public String toString() {
      String   String.valueOf(.data);
        + var10000 +  + .id + ;
   }

    {
      CODEC = ( <String, ScaledResponseCurve>(Codec.STRING, (t, k) -> t.id = k, (t) -> t.id, (t, data) -> t.data = data, (t) -> t.data, )).register(Priority.DEFAULT, , ScaledXResponseCurve.class, ScaledXResponseCurve.CODEC);
      CODEC.register(, ScaledSwitchResponseCurve.class, ScaledSwitchResponseCurve.CODEC);
   }
}

com/hypixel/hytale/server/core/asset/type/responsecurve/ScaledSwitchResponseCurve.java

package com.hypixel.hytale.server.core.asset.type.responsecurve;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import javax.annotation.Nonnull;

public class ScaledSwitchResponseCurve extends ScaledResponseCurve {
   public static final BuilderCodec<ScaledSwitchResponseCurve> CODEC;
   protected double initialState = 0.0;
   protected double finalState = 1.0;
   protected double switchPoint;

   protected ScaledSwitchResponseCurve() {
   }

   public double computeY(double x) {
      return x < this.switchPoint ? this.initialState : this.finalState;
   }

   @Nonnull
   public String toString() {
      double var10000 = this.initialState;
        + var10000 +  + .finalState +  + .switchPoint +  + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ScaledSwitchResponseCurve.class, ScaledSwitchResponseCurve::).documentation()).append( (, Codec.DOUBLE), (curve, d) -> curve.initialState = d, (curve) -> curve.initialState).addValidator(Validators.range(, )).documentation().add()).append( (, Codec.DOUBLE), (curve, d) -> curve.finalState = d, (curve) -> curve.finalState).addValidator(Validators.range(, )).documentation().add()).append( (, Codec.DOUBLE), (curve, d) -> curve.switchPoint = d, (curve) -> curve.switchPoint).addValidator(Validators.nonNull()).documentation().add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/responsecurve/ScaledXResponseCurve.java

package com.hypixel.hytale.server.core.asset.type.responsecurve;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.math.util.MathUtil;
import com.hypixel.hytale.server.core.asset.type.responsecurve.config.ResponseCurve;
import java.util.Arrays;
import javax.annotation.Nonnull;

public class ScaledXResponseCurve extends ScaledResponseCurve {
   public static final BuilderCodec<ScaledXResponseCurve> CODEC;
   public static final double[] DEFAULT_RANGE;
   protected String responseCurve;
   protected ResponseCurve.Reference responseCurveReference;
   protected double[] xRange;

   public ScaledXResponseCurve(String responseCurve, double[] xRange) {
      this.xRange = DEFAULT_RANGE;
      this.responseCurve = responseCurve;
      this.xRange = xRange;
   }

   protected ScaledXResponseCurve() {
      this.xRange = DEFAULT_RANGE;
   }

   public String getResponseCurve() {
      return .responseCurve;
   }

    [] getXRange() {
       .xRange;
   }

      {
       MathUtil.clamp(.computeNormalisedY(x), , );
   }

      {
         .responseCurveReference.get();
         .xRange[];
         .xRange[];
      x = MathUtil.clamp(x, minX, maxX);
         (x - minX) / (maxX - minX);
       curve.computeY(normalisedX);
   }

   
    String  {
         .responseCurve;
        + var10000 +  + Arrays.toString(.xRange) +  + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ScaledXResponseCurve.class, ScaledXResponseCurve::).documentation()).append( (, Codec.STRING), (curve, s) -> curve.responseCurve = s, (curve) -> curve.responseCurve).documentation().addValidator(Validators.nonNull()).addValidator(ResponseCurve.VALIDATOR_CACHE.getValidator()).add()).append( (, Codec.DOUBLE_ARRAY), (curve, o) -> curve.xRange = o, (curve) ->  []{curve.xRange[], curve.xRange[]}).documentation().addValidator(Validators.doubleArraySize()).addValidator(Validators.monotonicSequentialDoubleArrayValidator()).add()).afterDecode((curve) -> {
          (curve.responseCurve != ) {
               ResponseCurve.getAssetMap().getIndex(curve.responseCurve);
            curve.responseCurveReference =  .Reference(index, (ResponseCurve)ResponseCurve.getAssetMap().getAsset(index));
         }

      })).build();
      DEFAULT_RANGE =  []{, };
   }
}

com/hypixel/hytale/server/core/asset/type/responsecurve/ScaledXYResponseCurve.java

package com.hypixel.hytale.server.core.asset.type.responsecurve;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.math.util.MathUtil;
import java.util.Arrays;
import javax.annotation.Nonnull;

public class ScaledXYResponseCurve extends ScaledXResponseCurve {
   public static final BuilderCodec<ScaledXYResponseCurve> CODEC;
   protected double[] yRange;

   public ScaledXYResponseCurve(String responseCurve, double[] xRange, double[] yRange) {
      super(responseCurve, xRange);
      this.yRange = DEFAULT_RANGE;
      this.yRange = yRange;
   }

   protected ScaledXYResponseCurve() {
      this.yRange = DEFAULT_RANGE;
   }

   public double[] getYRange() {
      return this.yRange;
   }

   public double computeY(double x) {
      double normalisedY = this.computeNormalisedY(x);
         .yRange[];
         .yRange[];
       MathUtil.clamp(minY + (maxY - minY) * normalisedY, minY, maxY);
   }

   
    String  {
         Arrays.toString(.yRange);
        + var10000 +  + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ScaledXYResponseCurve.class, ScaledXYResponseCurve::, ScaledXResponseCurve.CODEC).documentation()).append( (, Codec.DOUBLE_ARRAY), (curve, o) -> curve.yRange = o, (curve) ->  []{curve.yRange[], curve.yRange[]}).documentation().addValidator(Validators.doubleArraySize()).addValidator(Validators.monotonicSequentialDoubleArrayValidator()).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/responsecurve/config/ExponentialResponseCurve.java

package com.hypixel.hytale.server.core.asset.type.responsecurve.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import javax.annotation.Nonnull;

public class ExponentialResponseCurve extends ResponseCurve {
   public static final BuilderCodec<ExponentialResponseCurve> CODEC;
   protected double slope = 1.0;
   protected double exponent = 1.0;
   protected double horizontalShift;
   protected double verticalShift;

   public ExponentialResponseCurve(double slope, double exponent, double horizontalShift, double verticalShift) {
      this.slope = slope;
      this.exponent = exponent;
      this.horizontalShift = horizontalShift;
      this.verticalShift = verticalShift;
   }

   public ExponentialResponseCurve(String id) {
      super(id);
   }

   protected  {
   }

      {
       (!(x < ) && !(x > )) {
          .slope * Math.pow(x - .horizontalShift, .exponent) + .verticalShift;
      }  {
           ();
      }
   }

      {
       .slope;
   }

      {
       .exponent;
   }

      {
       .horizontalShift;
   }

      {
       .verticalShift;
   }

   
    String  {
         .slope;
        + var10000 +  + .exponent +  + .horizontalShift +  + .verticalShift +  + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ExponentialResponseCurve.class, ExponentialResponseCurve::, BASE_CODEC).documentation()).appendInherited( (, Codec.DOUBLE), (curve, d) -> curve.slope = d, (curve) -> curve.slope, (curve, parent) -> curve.slope = parent.slope).documentation().add()).appendInherited( (, Codec.DOUBLE), (curve, d) -> curve.exponent = d, (curve) -> curve.exponent, (curve, parent) -> curve.exponent = parent.exponent).documentation().add()).appendInherited( (, Codec.DOUBLE), (curve, d) -> curve.horizontalShift = d, (curve) -> curve.horizontalShift, (curve, parent) -> curve.horizontalShift = parent.horizontalShift).documentation().addValidator(Validators.range(-, )).add()).appendInherited( (, Codec.DOUBLE), (curve, d) -> curve.verticalShift = d, (curve) -> curve.verticalShift, (curve, parent) -> curve.verticalShift = parent.verticalShift).documentation().addValidator(Validators.range(-, )).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/responsecurve/config/LogisticResponseCurve.java

package com.hypixel.hytale.server.core.asset.type.responsecurve.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import javax.annotation.Nonnull;

public class LogisticResponseCurve extends ResponseCurve {
   public static final BuilderCodec<LogisticResponseCurve> CODEC;
   protected double rateOfChange = 1.0;
   protected double ceiling = 1.0;
   protected double horizontalShift = 0.5;
   protected double verticalShift = 0.0;

   public LogisticResponseCurve(double rateOfChange, double ceiling, double horizontalShift, double verticalShift) {
      this.rateOfChange = rateOfChange;
      this.ceiling = ceiling;
      this.horizontalShift = horizontalShift;
      this.verticalShift = verticalShift;
   }

   protected LogisticResponseCurve {
   }

      {
       (!(x < ) && !(x > )) {
          .ceiling / ( + Math.pow(,  * .rateOfChange * (.horizontalShift - x))) + .verticalShift;
      }  {
           ();
      }
   }

      {
       .rateOfChange;
   }

      {
       .ceiling;
   }

      {
       .horizontalShift;
   }

      {
       .verticalShift;
   }

   
    String  {
         .rateOfChange;
        + var10000 +  + .ceiling +  + .horizontalShift +  + .verticalShift +  + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(LogisticResponseCurve.class, LogisticResponseCurve::, BASE_CODEC).documentation()).appendInherited( (, Codec.DOUBLE), (curve, d) -> curve.rateOfChange = d, (curve) -> curve.rateOfChange, (curve, parent) -> curve.rateOfChange = parent.rateOfChange).documentation().add()).appendInherited( (, Codec.DOUBLE), (curve, d) -> curve.ceiling = d, (curve) -> curve.ceiling, (curve, parent) -> curve.ceiling = parent.ceiling).documentation().add()).appendInherited( (, Codec.DOUBLE), (curve, d) -> curve.horizontalShift = d, (curve) -> curve.horizontalShift, (curve, parent) -> curve.horizontalShift = parent.horizontalShift).documentation().add()).appendInherited( (, Codec.DOUBLE), (curve, d) -> curve.verticalShift = d, (curve) -> curve.verticalShift, (curve, parent) -> curve.verticalShift = parent.verticalShift).documentation().add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/responsecurve/config/ResponseCurve.java

package com.hypixel.hytale.server.core.asset.type.responsecurve.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetCodecMapCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import java.lang.ref.WeakReference;
import javax.annotation.Nonnull;

public abstract class ResponseCurve implements JsonAssetWithMap<String, IndexedLookupTableAssetMap<String, ResponseCurve>> {
   public static final AssetCodecMapCodec<String, ResponseCurve> CODEC;
   public static final BuilderCodec<ResponseCurve> BASE_CODEC;
   public static final ValidatorCache<String> VALIDATOR_CACHE;
   private static AssetStore<String, ResponseCurve, IndexedLookupTableAssetMap<String, ResponseCurve>> ASSET_STORE;
   protected AssetExtraInfo.Data extraData;
   protected String id;
   protected WeakReference<ResponseCurve> reference;

   public static AssetStore<String, ResponseCurve, IndexedLookupTableAssetMap<String, ResponseCurve>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, ResponseCurve, IndexedLookupTableAssetMap<String, ResponseCurve>>getAssetStore(ResponseCurve.class);
      }

       ASSET_STORE;
   }

     IndexedLookupTableAssetMap<String, ResponseCurve>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

     {
      .id = id;
   }

     {
   }

    String  {
       .id;
   }

    WeakReference<ResponseCurve>  {
       .reference;
   }

      ;

   
    String  {
        + .id + ;
   }

    {
      CODEC =  <String, ResponseCurve>(Codec.STRING, (t, k) -> t.id = k, (t) -> t.id, (t, data) -> t.extraData = data, (t) -> t.extraData);
      BASE_CODEC = ((BuilderCodec.Builder)BuilderCodec.abstractBuilder(ResponseCurve.class).afterDecode((responseCurve) -> responseCurve.reference =  (responseCurve))).build();
      VALIDATOR_CACHE =  <String>( (ResponseCurve::getAssetStore));
      CODEC.register(, ExponentialResponseCurve.class, ExponentialResponseCurve.CODEC);
      CODEC.register(, LogisticResponseCurve.class, LogisticResponseCurve.CODEC);
      CODEC.register(, SineWaveResponseCurve.class, SineWaveResponseCurve.CODEC);
   }

       {
        index;
       WeakReference<ResponseCurve> reference;

        {
         .index = index;
         .reference = responseCurve.getReference();
      }

      
       ResponseCurve  {
            (ResponseCurve).reference.get();
          (responseCurve == ) {
            responseCurve = (ResponseCurve)ResponseCurve.getAssetMap().getAsset(.index);
            .reference = responseCurve.getReference();
         }

          responseCurve;
      }
   }
}

com/hypixel/hytale/server/core/asset/type/responsecurve/config/SineWaveResponseCurve.java

package com.hypixel.hytale.server.core.asset.type.responsecurve.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.math.util.TrigMathUtil;
import javax.annotation.Nonnull;

public class SineWaveResponseCurve extends ResponseCurve {
   public static final BuilderCodec<SineWaveResponseCurve> CODEC;
   protected double amplitude = 1.0;
   protected double frequency = 0.5;
   protected double horizontalShift;
   protected double verticalShift;

   protected SineWaveResponseCurve() {
   }

   public double computeY(double x) {
      if (!(x < 0.0) && !(x > 1.0)) {
         return this.amplitude * (double)TrigMathUtil.sin(6.2831854820251465 * this.frequency * x + .horizontalShift) + .verticalShift;
      }  {
           ();
      }
   }

      {
       .amplitude;
   }

      {
       .frequency;
   }

      {
       .horizontalShift;
   }

      {
       .verticalShift;
   }

   
    String  {
         .amplitude;
        + var10000 +  + .frequency +  + .horizontalShift +  + .verticalShift +  + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(SineWaveResponseCurve.class, SineWaveResponseCurve::, BASE_CODEC).documentation()).appendInherited( (, Codec.DOUBLE), (curve, d) -> curve.amplitude = d, (curve) -> curve.amplitude, (curve, parent) -> curve.amplitude = parent.amplitude).documentation().add()).appendInherited( (, Codec.DOUBLE), (curve, d) -> curve.frequency = d, (curve) -> curve.frequency, (curve, parent) -> curve.frequency = parent.frequency).documentation().add()).appendInherited( (, Codec.DOUBLE), (curve, d) -> curve.horizontalShift = d, (curve) -> curve.horizontalShift, (curve, parent) -> curve.horizontalShift = parent.horizontalShift).documentation().addValidator(Validators.range(-, )).add()).appendInherited( (, Codec.DOUBLE), (curve, d) -> curve.verticalShift = d, (curve) -> curve.verticalShift, (curve, parent) -> curve.verticalShift = parent.verticalShift).documentation().addValidator(Validators.range(-, )).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/reverbeffect/ReverbEffectPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.reverbeffect;

import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateReverbEffects;
import com.hypixel.hytale.server.core.asset.packet.SimpleAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.reverbeffect.config.ReverbEffect;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class ReverbEffectPacketGenerator extends SimpleAssetPacketGenerator<String, ReverbEffect, IndexedLookupTableAssetMap<String, ReverbEffect>> {
   public ReverbEffectPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull IndexedLookupTableAssetMap<String, ReverbEffect> assetMap, @Nonnull Map<String, ReverbEffect> assets) {
      UpdateReverbEffects packet = new UpdateReverbEffects();
      packet.type = UpdateType.Init;
      packet.effects = new Int2ObjectOpenHashMap(assets.size());

      for(Map.Entry<String, ReverbEffect> entry : assets.entrySet()) {
         String key = (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.effects.put(index, ((ReverbEffect)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.effects =  (loadedAssets.size());

      (Map.Entry<String, ReverbEffect> entry : loadedAssets.entrySet()) {
            (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.effects.put(index, ((ReverbEffect)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.effects =  (removed.size());

      (String key : removed) {
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.effects.put(index, (Object));
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/reverbeffect/config/ReverbEffect.java

package com.hypixel.hytale.server.core.asset.type.reverbeffect.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditor;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditorPreview;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.common.util.AudioUtil;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.lang.ref.SoftReference;
import javax.annotation.Nonnull;

public class ReverbEffect implements JsonAssetWithMap<String, IndexedLookupTableAssetMap<String, ReverbEffect>>, NetworkSerializable<com.hypixel.hytale.protocol.ReverbEffect> {
   public static final int EMPTY_ID = 0;
   public static final String EMPTY = "EMPTY";
          ();
      AssetBuilderCodec<String, ReverbEffect> CODEC;
      ValidatorCache<String> VALIDATOR_CACHE;
     AssetStore<String, ReverbEffect, IndexedLookupTableAssetMap<String, ReverbEffect>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
       AudioUtil.decibelsToLinearGain();
       ;
       ;
       AudioUtil.decibelsToLinearGain(-);
       AudioUtil.decibelsToLinearGain(-);
       ;
       ;
       AudioUtil.decibelsToLinearGain(-);
       ;
       AudioUtil.decibelsToLinearGain();
       ;
       ;
       AudioUtil.decibelsToLinearGain(-);
       ;
    SoftReference<com.hypixel.hytale.protocol.ReverbEffect> cachedPacket;

     AssetStore<String, ReverbEffect, IndexedLookupTableAssetMap<String, ReverbEffect>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, ReverbEffect, IndexedLookupTableAssetMap<String, ReverbEffect>>getAssetStore(ReverbEffect.class);
      }

       ASSET_STORE;
   }

     IndexedLookupTableAssetMap<String, ReverbEffect>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

     {
      .id = id;
   }

     {
   }

    String  {
       .id;
   }

      {
       .dryGain;
   }

      {
       .modalDensity;
   }

      {
       .diffusion;
   }

      {
       .gain;
   }

      {
       .highFrequencyGain;
   }

      {
       .decayTime;
   }

      {
       .highFrequencyDecayRatio;
   }

      {
       .reflectionGain;
   }

      {
       .reflectionDelay;
   }

      {
       .lateReverbGain;
   }

      {
       .lateReverbDelay;
   }

      {
       .roomRolloffFactor;
   }

      {
       .airAbsorptionHighFrequencyGain;
   }

      {
       .limitDecayHighFrequency;
   }

   
    String  {
        + .id +  + .dryGain +  + .modalDensity +  + .diffusion +  + .gain +  + .highFrequencyGain +  + .decayTime +  + .highFrequencyDecayRatio +  + .reflectionGain +  + .reflectionDelay +  + .lateReverbGain +  + .lateReverbDelay +  + .roomRolloffFactor +  + .airAbsorptionHighFrequencyGain +  + .limitDecayHighFrequency + ;
   }

   
    com.hypixel.hytale.protocol.ReverbEffect  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.ReverbEffect).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.ReverbEffect();
         packet.id = .id;
         packet.dryGain = .dryGain;
         packet.modalDensity = .modalDensity;
         packet.diffusion = .diffusion;
         packet.gain = .gain;
         packet.highFrequencyGain = .highFrequencyGain;
         packet.decayTime = .decayTime;
         packet.highFrequencyDecayRatio = .highFrequencyDecayRatio;
         packet.reflectionGain = .reflectionGain;
         packet.reflectionDelay = .reflectionDelay;
         packet.lateReverbGain = .lateReverbGain;
         packet.lateReverbDelay = .lateReverbDelay;
         packet.roomRolloffFactor = .roomRolloffFactor;
         packet.airAbsorptionHighFrequencyGain = .airAbsorptionHighFrequencyGain;
         packet.limitDecayHighFrequency = .limitDecayHighFrequency;
         .cachedPacket =  (packet);
          packet;
      }
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(ReverbEffect.class, ReverbEffect::, Codec.STRING, (t, k) -> t.id = k, (t) -> t.id, (asset, data) -> asset.data = data, (asset) -> asset.data).documentation()).metadata( (UIEditorPreview.PreviewType.REVERB_EFFECT))).appendInherited( (, Codec.FLOAT), (reverb, f) -> reverb.dryGain = AudioUtil.decibelsToLinearGain(f), (reverb) -> AudioUtil.linearGainToDecibels(reverb.dryGain), (reverb, parent) -> reverb.dryGain = parent.dryGain).metadata( ( .FormattedNumber((Double), , (Integer)))).addValidator(Validators.range(-, )).documentation().add()).appendInherited( (, Codec.FLOAT), (reverb, f) -> reverb.modalDensity = f, (reverb) -> reverb.modalDensity, (reverb, parent) -> reverb.modalDensity = parent.modalDensity).addValidator(Validators.range(, )).documentation().add()).appendInherited( (, Codec.FLOAT), (reverb, f) -> reverb.diffusion = f, (reverb) -> reverb.diffusion, (reverb, parent) -> reverb.diffusion = parent.diffusion).addValidator(Validators.range(, )).documentation().add()).appendInherited( (, Codec.FLOAT), (reverb, f) -> reverb.gain = AudioUtil.decibelsToLinearGain(f), (reverb) -> AudioUtil.linearGainToDecibels(reverb.gain), (reverb, parent) -> reverb.gain = parent.gain).metadata( ( .FormattedNumber((Double), , (Integer)))).addValidator(Validators.range(-, )).documentation().add()).appendInherited( (, Codec.FLOAT), (reverb, f) -> reverb.highFrequencyGain = AudioUtil.decibelsToLinearGain(f), (reverb) -> AudioUtil.linearGainToDecibels(reverb.highFrequencyGain), (reverb, parent) -> reverb.highFrequencyGain = parent.highFrequencyGain).metadata( ( .FormattedNumber((Double), , (Integer)))).addValidator(Validators.range(-, )).documentation().add()).appendInherited( (, Codec.FLOAT), (reverb, f) -> reverb.decayTime = f, (reverb) -> reverb.decayTime, (reverb, parent) -> reverb.decayTime = parent.decayTime).addValidator(Validators.range(, )).documentation().add()).appendInherited( (, Codec.FLOAT), (reverb, f) -> reverb.highFrequencyDecayRatio = f, (reverb) -> reverb.highFrequencyDecayRatio, (reverb, parent) -> reverb.highFrequencyDecayRatio = parent.highFrequencyDecayRatio).addValidator(Validators.range(, )).documentation().add()).appendInherited( (, Codec.FLOAT), (reverb, f) -> reverb.reflectionGain = AudioUtil.decibelsToLinearGain(f), (reverb) -> AudioUtil.linearGainToDecibels(reverb.reflectionGain), (reverb, parent) -> reverb.reflectionGain = parent.reflectionGain).metadata( ( .FormattedNumber((Double), , (Integer)))).addValidator(Validators.range(-, )).documentation().add()).appendInherited( (, Codec.FLOAT), (reverb, f) -> reverb.reflectionDelay = f, (reverb) -> reverb.reflectionDelay, (reverb, parent) -> reverb.reflectionDelay = parent.reflectionDelay).addValidator(Validators.range(, )).documentation().add()).appendInherited( (, Codec.FLOAT), (reverb, f) -> reverb.lateReverbGain = AudioUtil.decibelsToLinearGain(f), (reverb) -> AudioUtil.linearGainToDecibels(reverb.lateReverbGain), (reverb, parent) -> reverb.lateReverbGain = parent.lateReverbGain).metadata( ( .FormattedNumber((Double), , (Integer)))).addValidator(Validators.range(-, )).documentation().add()).appendInherited( (, Codec.FLOAT), (reverb, f) -> reverb.lateReverbDelay = f, (reverb) -> reverb.lateReverbDelay, (reverb, parent) -> reverb.lateReverbDelay = parent.lateReverbDelay).addValidator(Validators.range(, )).documentation().add()).appendInherited( (, Codec.FLOAT), (reverb, f) -> reverb.roomRolloffFactor = f, (reverb) -> reverb.roomRolloffFactor, (reverb, parent) -> reverb.roomRolloffFactor = parent.roomRolloffFactor).addValidator(Validators.range(, )).documentation().add()).appendInherited( (, Codec.FLOAT), (reverb, f) -> reverb.airAbsorptionHighFrequencyGain = AudioUtil.decibelsToLinearGain(f), (reverb) -> AudioUtil.linearGainToDecibels(reverb.airAbsorptionHighFrequencyGain), (reverb, parent) -> reverb.airAbsorptionHighFrequencyGain = parent.airAbsorptionHighFrequencyGain).metadata( ( .FormattedNumber((Double), , (Integer)))).addValidator(Validators.range(-, )).documentation().add()).appendInherited( (, Codec.BOOLEAN), (reverb, b) -> reverb.limitDecayHighFrequency = b, (reverb) -> reverb.limitDecayHighFrequency, (reverb, parent) -> reverb.limitDecayHighFrequency = parent.limitDecayHighFrequency).documentation().add()).build();
      VALIDATOR_CACHE =  <String>( (ReverbEffect::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/soundevent/SoundEventPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.soundevent;

import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateSoundEvents;
import com.hypixel.hytale.server.core.asset.packet.SimpleAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class SoundEventPacketGenerator extends SimpleAssetPacketGenerator<String, SoundEvent, IndexedLookupTableAssetMap<String, SoundEvent>> {
   public SoundEventPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull IndexedLookupTableAssetMap<String, SoundEvent> assetMap, @Nonnull Map<String, SoundEvent> assets) {
      UpdateSoundEvents packet = new UpdateSoundEvents();
      packet.type = UpdateType.Init;
      packet.soundEvents = new Int2ObjectOpenHashMap(assets.size());

      for(Map.Entry<String, SoundEvent> entry : assets.entrySet()) {
         String key = (String)entry.getKey();
         int   assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.soundEvents.put(index, ((SoundEvent)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.soundEvents =  (loadedAssets.size());

      (Map.Entry<String, SoundEvent> entry : loadedAssets.entrySet()) {
            (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.soundEvents.put(index, ((SoundEvent)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.soundEvents =  (removed.size());

      (String key : removed) {
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.soundEvents.put(index, (Object));
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/soundevent/config/SoundEvent.java

package com.hypixel.hytale.server.core.asset.type.soundevent.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditor;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.common.util.AudioUtil;
import com.hypixel.hytale.server.core.asset.type.audiocategory.config.AudioCategory;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.lang.ref.SoftReference;
import java.util.Arrays;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class SoundEvent implements JsonAssetWithMap<String, IndexedLookupTableAssetMap<String, SoundEvent>>, NetworkSerializable<com.hypixel.hytale.protocol.SoundEvent> {
   public static final int EMPTY_ID = 0;
   public static     ;
          ();
      AssetBuilderCodec<String, SoundEvent> CODEC;
      ValidatorCache<String> VALIDATOR_CACHE;
     AssetStore<String, SoundEvent, IndexedLookupTableAssetMap<String, SoundEvent>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
        ;
        ;
        ;
        ;
       ;
       ;
       ;
       ;
    SoundEventLayer[] layers;
   
       ;
        ;
        ;
    SoftReference<com.hypixel.hytale.protocol.SoundEvent> cachedPacket;

     AssetStore<String, SoundEvent, IndexedLookupTableAssetMap<String, SoundEvent>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, SoundEvent, IndexedLookupTableAssetMap<String, SoundEvent>>getAssetStore(SoundEvent.class);
      }

       ASSET_STORE;
   }

     IndexedLookupTableAssetMap<String, SoundEvent>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

      {
       (.audioCategoryId != ) {
         .audioCategoryIndex = AudioCategory.getAssetMap().getIndex(.audioCategoryId);
      }

       (.layers != ) {
         (SoundEventLayer layer : .layers) {
             (layer.highestNumberOfChannels > .highestNumberOfChannels) {
               .highestNumberOfChannels = layer.highestNumberOfChannels;
            }
         }
      }

   }

     {
      .id = id;
      .volume = volume;
      .pitch = pitch;
      .musicDuckingVolume = musicDuckingVolume;
      .ambientDuckingVolume = ambientDuckingVolume;
      .startAttenuationDistance = startAttenuationDistance;
      .maxDistance = maxDistance;
      .maxInstance = maxInstance;
      .preventSoundInterruption = preventSoundInterruption;
      .layers = layers;
   }

     {
      .id = id;
   }

     {
   }

    String  {
       .id;
   }

      {
       .volume;
   }

      {
       .pitch;
   }

      {
       .musicDuckingVolume;
   }

      {
       .ambientDuckingVolume;
   }

      {
       .startAttenuationDistance;
   }

      {
       .maxDistance;
   }

      {
       .maxInstance;
   }

      {
       .preventSoundInterruption;
   }

    SoundEventLayer[] getLayers() {
       .layers;
   }

   
    String  {
       .audioCategoryId;
   }

      {
       .audioCategoryIndex;
   }

      {
       .highestNumberOfChannels;
   }

   
    String  {
         .id;
        + var10000 +  + .volume +  + .pitch +  + .musicDuckingVolume +  + .ambientDuckingVolume +  + .startAttenuationDistance +  + .maxDistance +  + .maxInstance +  + .preventSoundInterruption +  + Arrays.toString(.layers) +  + .audioCategoryId +  + .audioCategoryIndex +  + .highestNumberOfChannels + ;
   }

   
    com.hypixel.hytale.protocol.SoundEvent  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.SoundEvent).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.SoundEvent();
         packet.id = .id;
         packet.volume = .volume;
         packet.pitch = .pitch;
         packet.musicDuckingVolume = .musicDuckingVolume;
         packet.ambientDuckingVolume = .ambientDuckingVolume;
         packet.startAttenuationDistance = .startAttenuationDistance;
         packet.maxDistance = .maxDistance;
         packet.maxInstance = .maxInstance;
         packet.preventSoundInterruption = .preventSoundInterruption;
         packet.audioCategory = .audioCategoryIndex;
          (.layers !=  && .layers.length > ) {
            packet.layers =  .hypixel.hytale.protocol.SoundEventLayer[.layers.length];

            (   ; i < .layers.length; ++i) {
               packet.layers[i] = .layers[i].toPacket();
            }
         }

         .cachedPacket =  (packet);
          packet;
      }
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(SoundEvent.class, SoundEvent::, Codec.STRING, (t, k) -> t.id = k, (t) -> t.id, (asset, data) -> asset.data = data, (asset) -> asset.data).appendInherited( (, Codec.FLOAT), (soundEvent, f) -> soundEvent.volume = AudioUtil.decibelsToLinearGain(f), (soundEvent) -> AudioUtil.linearGainToDecibels(soundEvent.volume), (soundEvent, parent) -> soundEvent.volume = parent.volume).metadata( ( .FormattedNumber((Double), , (Integer)))).addValidator(Validators.range(-, )).documentation().add()).appendInherited( (, Codec.FLOAT), (soundEvent, f) -> soundEvent.pitch = AudioUtil.semitonesToLinearPitch(f), (soundEvent) -> AudioUtil.linearPitchToSemitones(soundEvent.pitch), (soundEvent, parent) -> soundEvent.pitch = parent.pitch).addValidator(Validators.range(-, )).documentation().add()).appendInherited( (, Codec.FLOAT), (soundEvent, f) -> soundEvent.musicDuckingVolume = AudioUtil.decibelsToLinearGain(f), (soundEvent) -> AudioUtil.linearGainToDecibels(soundEvent.musicDuckingVolume), (soundEvent, parent) -> soundEvent.musicDuckingVolume = parent.musicDuckingVolume).addValidator(Validators.range(-, )).documentation().add()).appendInherited( (, Codec.FLOAT), (soundEvent, f) -> soundEvent.ambientDuckingVolume = AudioUtil.decibelsToLinearGain(f), (soundEvent) -> AudioUtil.linearGainToDecibels(soundEvent.ambientDuckingVolume), (soundEvent, parent) -> soundEvent.ambientDuckingVolume = parent.ambientDuckingVolume).addValidator(Validators.range(-, )).documentation().add()).appendInherited( (, Codec.FLOAT), (soundEvent, f) -> soundEvent.startAttenuationDistance = f, (soundEvent) -> soundEvent.startAttenuationDistance, (soundEvent, parent) -> soundEvent.startAttenuationDistance = parent.startAttenuationDistance).documentation().add()).appendInherited( (, Codec.FLOAT), (soundEvent, f) -> soundEvent.maxDistance = f, (soundEvent) -> soundEvent.maxDistance, (soundEvent, parent) -> soundEvent.maxDistance = parent.maxDistance).documentation().add()).appendInherited( (, Codec.INTEGER), (soundEvent, i) -> soundEvent.maxInstance = i, (soundEvent) -> soundEvent.maxInstance, (soundEvent, parent) -> soundEvent.maxInstance = parent.maxInstance).addValidator(Validators.range(, )).documentation().add()).appendInherited( (, Codec.BOOLEAN), (soundEvent, b) -> soundEvent.preventSoundInterruption = b, (soundEvent) -> soundEvent.preventSoundInterruption, (soundEvent, parent) -> soundEvent.preventSoundInterruption = parent.preventSoundInterruption).documentation().add()).appendInherited( (,  (SoundEventLayer.CODEC, (x$) ->  [x$])), (soundEvent, objects) -> soundEvent.layers = objects, (soundEvent) -> soundEvent.layers, (soundEvent, parent) -> soundEvent.layers = parent.layers).addValidator(Validators.nonEmptyArray()).documentation().add()).appendInherited( (, Codec.STRING), (soundEvent, s) -> soundEvent.audioCategoryId = s, (soundEvent) -> soundEvent.audioCategoryId, (soundEvent, parent) -> soundEvent.audioCategoryId = parent.audioCategoryId).addValidator(AudioCategory.VALIDATOR_CACHE.getValidator()).documentation().add()).afterDecode(SoundEvent::processConfig)).build();
      VALIDATOR_CACHE =  <String>( (SoundEvent::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/soundevent/config/SoundEventLayer.java

package com.hypixel.hytale.server.core.asset.type.soundevent.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditor;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.codec.validation.validator.ArrayValidator;
import com.hypixel.hytale.common.util.AudioUtil;
import com.hypixel.hytale.protocol.SoundEventLayerRandomSettings;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import com.hypixel.hytale.server.core.asset.common.OggVorbisInfoCache;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.util.Arrays;
import javax.annotation.Nonnull;

public class SoundEventLayer implements NetworkSerializable<com.hypixel.hytale.protocol.SoundEventLayer> {
   public static final Codec<SoundEventLayer> CODEC;
   protected transient float volume = 1.0F;
   protected float startDelay = 0.0F;
   protected boolean looping = false;
   protected int   ;
       ;
    RandomSettings randomSettings;
    String[] files;
     roundRobinHistorySize;
      highestNumberOfChannels;

     {
      .randomSettings = SoundEventLayer.RandomSettings.DEFAULT;
      .roundRobinHistorySize = ;
      .highestNumberOfChannels = ;
      .volume = volume;
      .startDelay = startDelay;
      .looping = looping;
      .probability = probability;
      .probabilityRerollDelay = probabilityRerollDelay;
      .randomSettings = randomSettings;
      .files = files;
      .roundRobinHistorySize = roundRobinHistorySize;
   }

     {
      .randomSettings = SoundEventLayer.RandomSettings.DEFAULT;
      .roundRobinHistorySize = ;
      .highestNumberOfChannels = ;
   }

      {
       .volume;
   }

      {
       .startDelay;
   }

      {
       .looping;
   }

      {
       .probability;
   }

      {
       .probabilityRerollDelay;
   }

    RandomSettings  {
       .randomSettings;
   }

    String[] getFiles() {
       .files;
   }

      {
       .roundRobinHistorySize;
   }

      {
       .highestNumberOfChannels;
   }

   
    com.hypixel.hytale.protocol.SoundEventLayer  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.SoundEventLayer();
      packet.volume = .volume;
      packet.startDelay = .startDelay;
      packet.looping = .looping;
      packet.probability = .probability;
      packet.probabilityRerollDelay = .probabilityRerollDelay;
      packet.randomSettings =  ();
      packet.randomSettings.minVolume = .randomSettings.minVolume;
      packet.randomSettings.maxVolume = .randomSettings.maxVolume;
      packet.randomSettings.minPitch = .randomSettings.minPitch;
      packet.randomSettings.maxPitch = .randomSettings.maxPitch;
      packet.randomSettings.maxStartOffset = .randomSettings.maxStartOffset;
      packet.files = .files;
      packet.roundRobinHistorySize = .roundRobinHistorySize;
       packet;
   }

   
    String  {
         .volume;
        + var10000 +  + .startDelay +  + .looping +  + .probability +  + .probabilityRerollDelay +  + String.valueOf(.randomSettings) +  + Arrays.toString(.files) +  + .roundRobinHistorySize +  + .highestNumberOfChannels + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(SoundEventLayer.class, SoundEventLayer::).append( (, Codec.FLOAT), (soundEventLayer, f) -> soundEventLayer.volume = AudioUtil.decibelsToLinearGain(f), (soundEventLayer) -> AudioUtil.linearGainToDecibels(soundEventLayer.volume)).metadata( ( .FormattedNumber((Double), , (Integer)))).addValidator(Validators.range(-, )).documentation().add()).append( (, Codec.FLOAT), (soundEventLayer, f) -> soundEventLayer.startDelay = f, (soundEventLayer) -> soundEventLayer.startDelay).documentation().add()).append( (, Codec.BOOLEAN), (soundEventLayer, b) -> soundEventLayer.looping = b, (soundEventLayer) -> soundEventLayer.looping).documentation().add()).append( (, Codec.INTEGER), (soundEventLayer, i) -> soundEventLayer.probability = i, (soundEventLayer) -> soundEventLayer.probability).documentation().add()).append( (, Codec.FLOAT), (soundEventLayer, f) -> soundEventLayer.probabilityRerollDelay = f, (soundEventLayer) -> soundEventLayer.probabilityRerollDelay).documentation().add()).append( (, SoundEventLayer.RandomSettings.CODEC), (soundEventLayer, o) -> soundEventLayer.randomSettings = o, (soundEventLayer) -> soundEventLayer.randomSettings).documentation().add()).append( (, Codec.STRING_ARRAY), (soundEventLayer, s) -> soundEventLayer.files = s, (soundEventLayer) -> soundEventLayer.files).addValidator(Validators.nonEmptyArray()).addValidator( (CommonAssetValidator.SOUNDS)).documentation().add()).append( (, Codec.INTEGER), (soundEventLayer, i) -> soundEventLayer.roundRobinHistorySize = i, (soundEventLayer) -> soundEventLayer.roundRobinHistorySize).addValidator(Validators.range(, )).documentation().add()).afterDecode((layer) -> {
          (layer.files != ) {
            (String file : layer.files) {
               OggVorbisInfoCache.   OggVorbisInfoCache.getNow(file);
                (info !=  && info.channels > layer.highestNumberOfChannels) {
                  layer.highestNumberOfChannels = info.channels;
               }
            }

         }
      })).build();
   }

       {
         Codec<RandomSettings> CODEC;
         RandomSettings DEFAULT;
           ;
           ;
           ;
           ;
        maxStartOffset;

        {
      }

         {
          .minVolume;
      }

         {
          .maxVolume;
      }

         {
          .minPitch;
      }

         {
          .maxPitch;
      }

         {
          .maxStartOffset;
      }

      
       String  {
           + .minVolume +  + .maxVolume +  + .minPitch +  + .maxPitch +  + .maxStartOffset + ;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(RandomSettings.class, RandomSettings::).append( (, Codec.FLOAT), (soundEventLayer, f) -> soundEventLayer.minVolume = AudioUtil.decibelsToLinearGain(f), (soundEventLayer) -> AudioUtil.linearGainToDecibels(soundEventLayer.minVolume)).addValidator(Validators.range(-, )).documentation().add()).append( (, Codec.FLOAT), (soundEventLayer, f) -> soundEventLayer.maxVolume = AudioUtil.decibelsToLinearGain(f), (soundEventLayer) -> AudioUtil.linearGainToDecibels(soundEventLayer.maxVolume)).addValidator(Validators.range(, )).documentation().add()).append( (, Codec.FLOAT), (soundEventLayer, f) -> soundEventLayer.minPitch = AudioUtil.semitonesToLinearPitch(f), (soundEventLayer) -> AudioUtil.linearPitchToSemitones(soundEventLayer.minPitch)).addValidator(Validators.range(-, )).documentation().add()).append( (, Codec.FLOAT), (soundEventLayer, f) -> soundEventLayer.maxPitch = AudioUtil.semitonesToLinearPitch(f), (soundEventLayer) -> AudioUtil.linearPitchToSemitones(soundEventLayer.maxPitch)).addValidator(Validators.range(, )).documentation().add()).append( (, Codec.FLOAT), (soundEventLayer, f) -> soundEventLayer.maxStartOffset = f, (soundEventLayer) -> soundEventLayer.maxStartOffset).addValidator(Validators.range(, )).documentation().add()).build();
         DEFAULT =  ();
      }
   }
}

com/hypixel/hytale/server/core/asset/type/soundevent/validator/SoundEventValidators.java

package com.hypixel.hytale.server.core.asset.type.soundevent.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.server.core.asset.common.SoundFileValidators;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEventLayer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class SoundEventValidators {
   public static final LoopValidator LOOPING = new LoopValidator(true);
   public static final LoopValidator ONESHOT = new LoopValidator(false);
   public static final ChannelValidator MONO = new ChannelValidator(1);
   public static      ();
      ValidatorCache<String> MONO_VALIDATOR_CACHE;
      ValidatorCache<String> STEREO_VALIDATOR_CACHE;
      ValidatorCache<String> ONESHOT_VALIDATOR_CACHE;

     {
   }

    {
      MONO_VALIDATOR_CACHE =  <String>(MONO);
      STEREO_VALIDATOR_CACHE =  <String>(STEREO);
      ONESHOT_VALIDATOR_CACHE =  <String>(ONESHOT);
   }

        <String> {
         channelCount;

        {
          channelCount ==  || channelCount == ;

         .channelCount = channelCount;
      }

         {
          (s != ) {
               (SoundEvent)SoundEvent.getAssetMap().getAsset(s);
             (soundEvent == ) {
               results.fail( + s + );
            }  {
                (soundEvent.getHighestNumberOfChannels() != .channelCount) {
                  results.fail( + s +  + SoundFileValidators.getEncoding(soundEvent.getHighestNumberOfChannels()) +  + SoundFileValidators.getEncoding(.channelCount));
               }

            }
         }
      }

         {
      }
   }

        <String> {
         looping;

        {
         .looping = looping;
      }

         {
          (s != ) {
               (SoundEvent)SoundEvent.getAssetMap().getAsset(s);
             (soundEvent == ) {
               results.fail( + s + );
            }   (soundEvent.getLayers() != ) {
                (.looping) {
                  (SoundEventLayer layer : soundEvent.getLayers()) {
                      (layer.isLooping()) {
                        ;
                     }
                  }

                  results.fail( + s + );
               }  {
                  (SoundEventLayer layer : soundEvent.getLayers()) {
                      (layer.isLooping()) {
                        results.fail( + s + );
                        ;
                     }
                  }
               }

            }
         }
      }

         {
      }
   }
}

com/hypixel/hytale/server/core/asset/type/soundset/SoundSetPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.soundset;

import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateSoundSets;
import com.hypixel.hytale.server.core.asset.packet.SimpleAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.soundset.config.SoundSet;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class SoundSetPacketGenerator extends SimpleAssetPacketGenerator<String, SoundSet, IndexedLookupTableAssetMap<String, SoundSet>> {
   public SoundSetPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull IndexedLookupTableAssetMap<String, SoundSet> assetMap, @Nonnull Map<String, SoundSet> assets) {
      UpdateSoundSets packet = new UpdateSoundSets();
      packet.type = UpdateType.Init;
      packet.soundSets = new Int2ObjectOpenHashMap(assets.size());

      for(Map.Entry<String, SoundSet> entry : assets.entrySet()) {
         String key = (String)entry.getKey();
         int   assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.soundSets.put(index, ((SoundSet)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.soundSets =  (loadedAssets.size());

      (Map.Entry<String, SoundSet> entry : loadedAssets.entrySet()) {
            (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.soundSets.put(index, ((SoundSet)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.soundSets =  (removed.size());

      (String key : removed) {
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.soundSets.put(index, (Object));
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/soundset/config/SoundSet.java

package com.hypixel.hytale.server.core.asset.type.soundset.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIDefaultCollapsedState;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.SoundCategory;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import it.unimi.dsi.fastutil.objects.Object2IntMap;
import it.unimi.dsi.fastutil.objects.Object2IntMaps;
import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
import java.lang.ref.SoftReference;
import java.util.Collections;
import java.util.Map;
import javax.annotation.Nonnull;

public class SoundSet implements JsonAssetWithMap<String, IndexedLookupTableAssetMap<String, SoundSet>>, NetworkSerializable<com.hypixel.hytale.protocol.SoundSet> {
         ;
         ;
          ();
      AssetBuilderCodec<String, SoundSet> CODEC;
      Codec<String> CHILD_ASSET_CODEC;
      ValidatorCache<String> VALIDATOR_CACHE;
     AssetStore<String, SoundSet, IndexedLookupTableAssetMap<String, SoundSet>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
    Map<String, String> soundEventIds = Collections.emptyMap();
     Object2IntMap<String> soundEventIndices = Object2IntMaps.<String>emptyMap();
   
    SoundCategory category;
    SoftReference<com.hypixel.hytale.protocol.SoundSet> cachedPacket;

     AssetStore<String, SoundSet, IndexedLookupTableAssetMap<String, SoundSet>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, SoundSet, IndexedLookupTableAssetMap<String, SoundSet>>getAssetStore(SoundSet.class);
      }

       ASSET_STORE;
   }

     IndexedLookupTableAssetMap<String, SoundSet>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

     {
      .category = SoundCategory.SFX;
      .id = id;
      .soundEventIds = soundEventIds;
      .category = category;
   }

     {
      .category = SoundCategory.SFX;
      .id = id;
   }

     {
      .category = SoundCategory.SFX;
   }

    String  {
       .id;
   }

    Map<String, String>  {
       .soundEventIds;
   }

    Object2IntMap<String>  {
       .soundEventIndices;
   }

      {
       (!.soundEventIds.isEmpty()) {
         .soundEventIndices =  <String>();

         (Map.Entry<String, String> entry : .soundEventIds.entrySet()) {
            .soundEventIndices.put((String)entry.getKey(), SoundEvent.getAssetMap().getIndex((String)entry.getValue()));
         }
      }

   }

   
    String  {
         .id;
        + var10000 +  + String.valueOf(.soundEventIds) +  + String.valueOf(.soundEventIndices) +  + String.valueOf(.category) + ;
   }

   
    com.hypixel.hytale.protocol.SoundSet  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.SoundSet).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.SoundSet();
         packet.id = .id;
         packet.sounds = .soundEventIndices;
         packet.category = .category;
         .cachedPacket =  (packet);
          packet;
      }
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(SoundSet.class, SoundSet::, Codec.STRING, (t, k) -> t.id = k, (t) -> t.id, (asset, data) -> asset.data = data, (asset) -> asset.data).appendInherited( (, MapCodec.STRING_HASH_MAP_CODEC), (soundSet, s) -> soundSet.soundEventIds = s, (soundSet) -> soundSet.soundEventIds, (soundSet, parent) -> soundSet.soundEventIds = parent.soundEventIds).addValidator(Validators.nonNull()).addValidator(SoundEvent.VALIDATOR_CACHE.getMapValueValidator()).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (,  (SoundCategory.class)), (soundSet, s) -> soundSet.category = s, (soundSet) -> soundSet.category, (soundSet, parent) -> soundSet.category = parent.category).addValidator(Validators.nonNull()).add()).afterDecode(SoundSet::processConfig)).build();
      CHILD_ASSET_CODEC =  (SoundSet.class, CODEC);
      VALIDATOR_CACHE =  <String>( (SoundSet::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/tagpattern/TagPatternPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.tagpattern;

import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateTagPatterns;
import com.hypixel.hytale.server.core.asset.packet.SimpleAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.tagpattern.config.TagPattern;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class TagPatternPacketGenerator extends SimpleAssetPacketGenerator<String, TagPattern, IndexedLookupTableAssetMap<String, TagPattern>> {
   public TagPatternPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull IndexedLookupTableAssetMap<String, TagPattern> assetMap, @Nonnull Map<String, TagPattern> assets) {
      UpdateTagPatterns packet = new UpdateTagPatterns();
      packet.type = UpdateType.Init;
      packet.patterns = new Int2ObjectOpenHashMap(assets.size());

      for(Map.Entry<String, TagPattern> entry : assets.entrySet()) {
         String key = (String)entry.getKey();
         int   assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.patterns.put(index, (com.hypixel.hytale.protocol.TagPattern)((TagPattern)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.patterns =  (loadedAssets.size());

      (Map.Entry<String, TagPattern> entry : loadedAssets.entrySet()) {
            (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.patterns.put(index, (com.hypixel.hytale.protocol.TagPattern)((TagPattern)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.patterns =  (removed.size());

      (String key : removed) {
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.patterns.put(index, (Object));
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/tagpattern/config/AndPatternOp.java

package com.hypixel.hytale.server.core.asset.type.tagpattern.config;

import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.TagPatternType;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.IntSet;
import java.lang.ref.SoftReference;
import javax.annotation.Nonnull;

public class AndPatternOp extends MultiplePatternOp {
   @Nonnull
   public static BuilderCodec<AndPatternOp> CODEC;

   public AndPatternOp() {
   }

   public boolean test(Int2ObjectMap<IntSet> tags) {
      for(int i = 0; i < this.patterns.length; ++i) {
         if (!this.patterns[i].test(tags)) {
            return false;
         }
      }

      return true;
   }

   public com.hypixel.hytale.protocol.TagPattern toPacket() {
      com.hypixel.hytale.protocol.TagPattern cached = this.cachedPacket == null ? null : (com.hypixel.hytale.protocol.TagPattern).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.   .toPacket();
         packet.type = TagPatternType.And;
         .cachedPacket =  (packet);
          packet;
      }
   }

   
    String  {
        + .toString();
   }

    {
      CODEC = BuilderCodec.builder(AndPatternOp.class, AndPatternOp::, MultiplePatternOp.CODEC).build();
   }
}

com/hypixel/hytale/server/core/asset/type/tagpattern/config/EqualsTagOp.java

package com.hypixel.hytale.server.core.asset.type.tagpattern.config;

import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.TagPatternType;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.IntSet;
import java.lang.ref.SoftReference;
import javax.annotation.Nonnull;

public class EqualsTagOp extends TagPattern {
   @Nonnull
   public static BuilderCodec<EqualsTagOp> CODEC;
   protected String tag;
   protected int tagIndex;

   public EqualsTagOp(String tag) {
      this.tag = tag;
   }

   protected EqualsTagOp() {
   }

   public boolean test(@Nonnull Int2ObjectMap<IntSet> tags) {
      return tags.containsKey(this.tagIndex);
   }

   public com.hypixel.hytale.protocol.TagPattern toPacket() {
      com.hypixel.hytale.protocol.TagPattern cached  .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.TagPattern).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.TagPattern();
         packet.type = TagPatternType.Equals;
         packet.tagIndex = .tagIndex;
         .cachedPacket =  (packet);
          packet;
      }
   }

   
    String  {
         .tag;
        + var10000 +  + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(EqualsTagOp.class, EqualsTagOp::, TagPattern.BASE_CODEC).append( (, Codec.STRING), (singleTagOp, s) -> singleTagOp.tag = s, (singleTagOp) -> singleTagOp.tag).addValidator(Validators.nonNull()).add()).afterDecode((singleTagOp) -> {
          (singleTagOp.tag != ) {
            singleTagOp.tagIndex = AssetRegistry.getOrCreateTagIndex(singleTagOp.tag);
         }
      })).build();
   }
}

com/hypixel/hytale/server/core/asset/type/tagpattern/config/MultiplePatternOp.java

package com.hypixel.hytale.server.core.asset.type.tagpattern.config;

import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.validation.Validators;
import java.util.Arrays;
import javax.annotation.Nonnull;

public abstract class MultiplePatternOp extends TagPattern {
   @Nonnull
   public static BuilderCodec<MultiplePatternOp> CODEC;
   protected TagPattern[] patterns;

   public MultiplePatternOp() {
   }

   public com.hypixel.hytale.protocol.TagPattern toPacket() {
      com.hypixel.hytale.protocol.TagPattern packet = new com.hypixel.hytale.protocol.TagPattern();
      packet.operands = new com.hypixel.hytale.protocol.TagPattern[this.patterns.length];

      for(int i = 0; i < this.patterns.length; ++i) {
         packet.operands[i] = (com.hypixel.hytale.protocol.TagPattern)this.patterns[i].toPacket();
      }

      return packet;
   }

   @Nonnull
   public String  {
         Arrays.toString(.patterns);
        + var10000 +  + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)BuilderCodec.abstractBuilder(MultiplePatternOp.class, TagPattern.BASE_CODEC).append( (,  (TagPattern.CODEC, (x$) ->  [x$])), (tagPattern, tagPatterns) -> tagPattern.patterns = tagPatterns, (tagPattern) -> tagPattern.patterns).addValidator(Validators.nonEmptyArray()).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/tagpattern/config/NotPatternOp.java

package com.hypixel.hytale.server.core.asset.type.tagpattern.config;

import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.TagPatternType;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.IntSet;
import java.lang.ref.SoftReference;
import javax.annotation.Nonnull;

public class NotPatternOp extends TagPattern {
   @Nonnull
   public static BuilderCodec<NotPatternOp> CODEC;
   protected TagPattern pattern;

   public NotPatternOp() {
   }

   public boolean test(Int2ObjectMap<IntSet> tags) {
      return !this.pattern.test(tags);
   }

   public com.hypixel.hytale.protocol.TagPattern toPacket() {
      com.hypixel.hytale.protocol.TagPattern cached = this.cachedPacket == null ? null : (com.hypixel.hytale.protocol.TagPattern)this.cachedPacket.get();
      if (cached != null) {
         return cached;
      } else {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.TagPattern();
         packet.type = TagPatternType.Not;
         packet.not = (com.hypixel.hytale.protocol.TagPattern).pattern.toPacket();
         .cachedPacket =  (packet);
          packet;
      }
   }

   
    String  {
         String.valueOf(.pattern);
        + var10000 +  + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(NotPatternOp.class, NotPatternOp::, TagPattern.BASE_CODEC).append( (, TagPattern.CODEC), (singleTagOp, s) -> singleTagOp.pattern = s, (singleTagOp) -> singleTagOp.pattern).addValidator(Validators.nonNull()).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/tagpattern/config/OrPatternOp.java

package com.hypixel.hytale.server.core.asset.type.tagpattern.config;

import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.TagPatternType;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.IntSet;
import java.lang.ref.SoftReference;
import javax.annotation.Nonnull;

public class OrPatternOp extends MultiplePatternOp {
   @Nonnull
   public static BuilderCodec<OrPatternOp> CODEC;

   public OrPatternOp() {
   }

   public boolean test(Int2ObjectMap<IntSet> tags) {
      for(int i = 0; i < this.patterns.length; ++i) {
         if (this.patterns[i].test(tags)) {
            return true;
         }
      }

      return false;
   }

   public com.hypixel.hytale.protocol.TagPattern toPacket() {
      com.hypixel.hytale.protocol.TagPattern cached = this.cachedPacket == null ? null : (com.hypixel.hytale.protocol.TagPattern).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.   .toPacket();
         packet.type = TagPatternType.Or;
         .cachedPacket =  (packet);
          packet;
      }
   }

   
    String  {
        + .toString();
   }

    {
      CODEC = BuilderCodec.builder(OrPatternOp.class, OrPatternOp::, MultiplePatternOp.CODEC).build();
   }
}

com/hypixel/hytale/server/core/asset/type/tagpattern/config/TagPattern.java

package com.hypixel.hytale.server.core.asset.type.tagpattern.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetCodecMapCodec;
import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.IntSet;
import java.lang.ref.SoftReference;
import javax.annotation.Nonnull;

public abstract class TagPattern implements JsonAssetWithMap<String, IndexedLookupTableAssetMap<String, TagPattern>>, NetworkSerializable<com.hypixel.hytale.protocol.TagPattern> {
   public static final AssetCodecMapCodec<String, TagPattern> CODEC;
   public static final BuilderCodec<TagPattern> BASE_CODEC;
   public static final Codec<String> CHILD_ASSET_CODEC;
   public static final ValidatorCache<String> VALIDATOR_CACHE;
     AssetStore<String, TagPattern, IndexedLookupTableAssetMap<String, TagPattern>> ASSET_STORE;
    AssetExtraInfo.Data data;
    String id;
    SoftReference<com.hypixel.hytale.protocol.TagPattern> cachedPacket;

     {
   }

     AssetStore<String, TagPattern, IndexedLookupTableAssetMap<String, TagPattern>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, TagPattern, IndexedLookupTableAssetMap<String, TagPattern>>getAssetStore(TagPattern.class);
      }

       ASSET_STORE;
   }

     IndexedLookupTableAssetMap<String, TagPattern>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

    String  {
       .id;
   }

      ;

   
    String  {
        + .id + ;
   }

    {
      CODEC =  <String, TagPattern>(, Codec.STRING, (t, k) -> t.id = k, (t) -> t.id, (t, data) -> t.data = data, (t) -> t.data);
      BASE_CODEC = BuilderCodec.abstractBuilder(TagPattern.class).build();
      CHILD_ASSET_CODEC =  (TagPattern.class, CODEC);
      VALIDATOR_CACHE =  <String>( (TagPattern::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/trail/TrailPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.trail;

import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateTrails;
import com.hypixel.hytale.server.core.asset.packet.DefaultAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.trail.config.Trail;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class TrailPacketGenerator extends DefaultAssetPacketGenerator<String, Trail> {
   public TrailPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(DefaultAssetMap<String, Trail> assetMap, @Nonnull Map<String, Trail> assets) {
      UpdateTrails packet = new UpdateTrails();
      packet.type = UpdateType.Init;
      packet.trails = new Object2ObjectOpenHashMap<String, com.hypixel.hytale.protocol.Trail>();

      for(Map.Entry<String, Trail> entry : assets.entrySet()) {
         packet.trails.put((String)entry.getKey(), ((Trail)entry.getValue()).toPacket());
      }

      return packet;
   }

   @Nonnull
   public Packet generateUpdatePacket {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.trails =  <String, com.hypixel.hytale.protocol.Trail>();

      (Map.Entry<String, Trail> entry : loadedAssets.entrySet()) {
         packet.trails.put((String)entry.getKey(), ((Trail)entry.getValue()).toPacket());
      }

       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.trails =  <String, com.hypixel.hytale.protocol.Trail>();

      (String key : removed) {
         packet.trails.put(key, (Object));
      }

       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/trail/config/Animation.java

package com.hypixel.hytale.server.core.asset.type.trail.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.math.vector.Vector2i;
import com.hypixel.hytale.protocol.Range;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import javax.annotation.Nonnull;

public class Animation {
   public static final BuilderCodec<Animation> CODEC;
   private Vector2i frameSize;
   private Range frameRange;
   private int frameLifeSpan;

   public Animation() {
   }

   public Vector2i getFrameSize() {
      return this.frameSize;
   }

   public Range getFrameRange() {
      return this.frameRange;
   }

   public int getFrameLifeSpan() {
      return this.frameLifeSpan;
   }

   @Nonnull
   public String toString() {
      String var10000 = String.valueOf(.frameSize);
        + var10000 +  + String.valueOf(.frameRange) +  + .frameLifeSpan + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(Animation.class, Animation::).appendInherited( (, Vector2i.CODEC), (animation, b) -> animation.frameSize = b, (animation) -> animation.frameSize, (animation, parent) -> animation.frameSize = parent.frameSize).add()).appendInherited( (, ProtocolCodecs.RANGE), (animation, b) -> animation.frameRange = b, (animation) -> animation.frameRange, (animation, parent) -> animation.frameRange = parent.frameRange).add()).appendInherited( (, Codec.INTEGER), (animation, i) -> animation.frameLifeSpan = i, (animation) -> animation.frameLifeSpan, (animation, parent) -> animation.frameLifeSpan = parent.frameLifeSpan).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/trail/config/Edge.java

package com.hypixel.hytale.server.core.asset.type.trail.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.protocol.ColorAlpha;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import javax.annotation.Nonnull;

public class Edge {
   public static final BuilderCodec<Edge> CODEC;
   private float width;
   private ColorAlpha color = new ColorAlpha((byte)-1, (byte)-1, (byte)-1, (byte)-1);

   public Edge() {
   }

   @Nonnull
   public com.hypixel.hytale.protocol.Edge toPacket() {
      com.hypixel.hytale.protocol.Edge packet = new com.hypixel.hytale.protocol.Edge();
      packet.color = this.color;
      packet.width = this.width;
      return packet;
   }

   public float  {
       .width;
   }

    ColorAlpha  {
       .color;
   }

   
    String  {
         .width;
        + var10000 +  + String.valueOf(.color) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(Edge.class, Edge::).appendInherited( (, Codec.DOUBLE), (edge, d) -> edge.width = d.floatValue(), (edge) -> ()edge.width, (edge, parent) -> edge.width = parent.width).add()).appendInherited( (, ProtocolCodecs.COLOR_AlPHA), (edge, o) -> edge.color = o, (edge) -> edge.color, (edge, parent) -> edge.color = parent.color).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/trail/config/Trail.java

package com.hypixel.hytale.server.core.asset.type.trail.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIDefaultCollapsedState;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.math.vector.Vector2i;
import com.hypixel.hytale.protocol.FXRenderMode;
import com.hypixel.hytale.protocol.IntersectionHighlight;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.lang.ref.SoftReference;
import javax.annotation.Nonnull;

public class Trail implements JsonAssetWithMap<String, DefaultAssetMap<String, Trail>>, NetworkSerializable<com.hypixel.hytale.protocol.Trail> {
   public static final AssetBuilderCodec<String, Trail> CODEC;
   private static AssetStore<String, Trail, DefaultAssetMap<String, Trail>> ASSET_STORE;
      ValidatorCache<String> VALIDATOR_CACHE;
    AssetExtraInfo.Data data;
    String id;
    String texture;
   
    FXRenderMode renderMode;
    IntersectionHighlight intersectionHighlight;
     lifeSpan;
     roll;
     lightInfluence;
     smooth;
    Edge start;
    Edge end;
    Animation animation;
    SoftReference<com.hypixel.hytale.protocol.Trail> cachedPacket;

     AssetStore<String, Trail, DefaultAssetMap<String, Trail>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, Trail, DefaultAssetMap<String, Trail>>getAssetStore(Trail.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, Trail>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

     {
      .renderMode = FXRenderMode.BlendLinear;
      .id = id;
      .texture = texture;
      .renderMode = renderMode;
      .intersectionHighlight = intersectionHighlight;
      .lifeSpan = lifeSpan;
      .roll = roll;
      .lightInfluence = lightInfluence;
      .smooth = smooth;
      .start = start;
      .end = end;
      .animation = animation;
   }

     {
      .renderMode = FXRenderMode.BlendLinear;
   }

   
    com.hypixel.hytale.protocol.Trail  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.Trail).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.Trail();
         packet.id = .id;
         packet.texture = .texture;
         packet.lifeSpan = .lifeSpan;
         packet.roll = .roll;
         packet.lightInfluence = .lightInfluence;
         packet.renderMode = .renderMode;
         packet.intersectionHighlight = .intersectionHighlight;
         packet.smooth = .smooth;
          (.start != ) {
            packet.start = .start.toPacket();
         }

          (.end != ) {
            packet.end = .end.toPacket();
         }

          (.animation != ) {
               .animation.getFrameSize();
             (frameSize != ) {
               packet.frameSize =  .hypixel.hytale.protocol.Vector2i(frameSize.getX(), frameSize.getY());
            }

             (.animation.getFrameRange() != ) {
               packet.frameRange = .animation.getFrameRange();
            }

            packet.frameLifeSpan = .animation.getFrameLifeSpan();
         }

         .cachedPacket =  (packet);
          packet;
      }
   }

    String  {
       .id;
   }

    String  {
       .texture;
   }

    FXRenderMode  {
       .renderMode;
   }

    IntersectionHighlight  {
       .intersectionHighlight;
   }

      {
       .lifeSpan;
   }

      {
       .roll;
   }

      {
       .lightInfluence;
   }

      {
       .smooth;
   }

    Edge  {
       .start;
   }

    Edge  {
       .end;
   }

    Animation  {
       .animation;
   }

   
    String  {
         .id;
        + var10000 +  + .texture +  + String.valueOf(.renderMode) +  + String.valueOf(.intersectionHighlight) +  + .lifeSpan +  + .roll +  + .lightInfluence +  + .smooth +  + String.valueOf(.start) +  + String.valueOf(.end) +  + String.valueOf(.animation) + ;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(Trail.class, Trail::, Codec.STRING, (trail, s) -> trail.id = s, (trail) -> trail.id, (asset, data) -> asset.data = data, (asset) -> asset.data).appendInherited( (, Codec.STRING), (trail, s) -> trail.texture = s, (trail) -> trail.texture, (trail, parent) -> trail.texture = parent.texture).addValidator(Validators.nonNull()).addValidator(CommonAssetValidator.TEXTURE_TRAIL).add()).appendInherited( (, Codec.INTEGER), (trail, i) -> trail.lifeSpan = i, (trail) -> trail.lifeSpan, (trail, parent) -> trail.lifeSpan = parent.lifeSpan).add()).appendInherited( (, Codec.DOUBLE), (trail, d) -> trail.roll = d.floatValue(), (trail) -> ()trail.roll, (trail, parent) -> trail.roll = parent.roll).add()).appendInherited( (, Edge.CODEC), (trail, o) -> trail.start = o, (trail) -> trail.start, (trail, parent) -> trail.start = parent.start).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, Edge.CODEC), (trail, o) -> trail.end = o, (trail) -> trail.end, (trail, parent) -> trail.end = parent.end).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, Codec.DOUBLE), (trail, d) -> trail.lightInfluence = d.floatValue(), (trail) -> ()trail.lightInfluence, (trail, parent) -> trail.lightInfluence = parent.lightInfluence).addValidator(Validators.range(, )).add()).appendInherited( (,  (FXRenderMode.class)), (trail, s) -> trail.renderMode = s, (trail) -> trail.renderMode, (trail, parent) -> trail.renderMode = parent.renderMode).addValidator(Validators.nonNull()).add()).appendInherited( (, ProtocolCodecs.INTERSECTION_HIGHLIGHT), (trail, s) -> trail.intersectionHighlight = s, (trail) -> trail.intersectionHighlight, (trail, parent) -> trail.intersectionHighlight = parent.intersectionHighlight).add()).appendInherited( (, Codec.BOOLEAN), (trail, b) -> trail.smooth = b, (trail) -> trail.smooth, (trail, parent) -> trail.smooth = parent.smooth).add()).appendInherited( (, Animation.CODEC), (trail, b) -> trail.animation = b, (trail) -> trail.animation, (trail, parent) -> trail.animation = parent.animation).add()).build();
      VALIDATOR_CACHE =  <String>( (Trail::getAssetStore));
   }
}

com/hypixel/hytale/server/core/asset/type/weather/WeatherPacketGenerator.java

package com.hypixel.hytale.server.core.asset.type.weather;

import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.UpdateType;
import com.hypixel.hytale.protocol.packets.assets.UpdateWeathers;
import com.hypixel.hytale.server.core.asset.packet.SimpleAssetPacketGenerator;
import com.hypixel.hytale.server.core.asset.type.weather.config.Weather;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;

public class WeatherPacketGenerator extends SimpleAssetPacketGenerator<String, Weather, IndexedLookupTableAssetMap<String, Weather>> {
   public WeatherPacketGenerator() {
   }

   @Nonnull
   public Packet generateInitPacket(@Nonnull IndexedLookupTableAssetMap<String, Weather> assetMap, @Nonnull Map<String, Weather> assets) {
      UpdateWeathers packet = new UpdateWeathers();
      packet.type = UpdateType.Init;
      packet.weathers = new Int2ObjectOpenHashMap();

      for(Map.Entry<String, Weather> entry : assets.entrySet()) {
         String key = (String)entry.getKey();
         int index  assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.weathers.put(index, ((Weather)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.AddOrUpdate;
      packet.weathers =  ();

      (Map.Entry<String, Weather> entry : loadedAssets.entrySet()) {
            (String)entry.getKey();
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.weathers.put(index, ((Weather)entry.getValue()).toPacket());
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }

   
    Packet  {
          ();
      packet.type = UpdateType.Remove;
      packet.weathers =  ();

      (String key : removed) {
            assetMap.getIndex(key);
          (index == -) {
              ( + key);
         }

         packet.weathers.put(index, (Object));
      }

      packet.maxId = assetMap.getNextIndex();
       packet;
   }
}

com/hypixel/hytale/server/core/asset/type/weather/config/Cloud.java

package com.hypixel.hytale.server.core.asset.type.weather.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditor;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import java.util.Arrays;
import javax.annotation.Nonnull;

public class Cloud implements NetworkSerializable<com.hypixel.hytale.protocol.Cloud> {
   public static final BuilderCodec<Cloud> CODEC;
   protected String texture;
   protected TimeColorAlpha[] colors;
   protected TimeFloat[] speeds;

   public Cloud(String texture, TimeColorAlpha[] colors, TimeFloat[] speeds) {
      this.texture = texture;
      this.colors = colors;
      this.speeds = speeds;
   }

   protected Cloud() {
   }

   @Nonnull
   public com.hypixel.hytale.protocol.Cloud toPacket() {
      com.hypixel.hytale.protocol.Cloud packet = new com.hypixel.hytale.protocol.Cloud();
      packet.texture = .texture;
      packet.colors = Weather.toColorAlphaMap(.colors);
      packet.speeds = Weather.toFloatMap(.speeds);
       packet;
   }

    String  {
       .texture;
   }

    TimeColorAlpha[] getColors() {
       .colors;
   }

    TimeFloat[] getSpeeds() {
       .speeds;
   }

   
    String  {
         .texture;
        + var10000 +  + Arrays.toString(.colors) +  + Arrays.toString(.speeds) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(Cloud.class, Cloud::).append( (, Codec.STRING), (cloud, s) -> cloud.texture = s, Cloud::getTexture).addValidator(CommonAssetValidator.TEXTURE_SKY).add()).append( (,  (TimeColorAlpha.CODEC, (x$) ->  [x$])), (cloud, s) -> cloud.colors = s, Cloud::getColors).metadata( (UIEditor.TIMELINE)).add()).append( (,  (TimeFloat.CODEC, (x$) ->  [x$])), (cloud, s) -> cloud.speeds = s, Cloud::getSpeeds).metadata( (UIEditor.TIMELINE)).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/weather/config/DayTexture.java

package com.hypixel.hytale.server.core.asset.type.weather.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import javax.annotation.Nonnull;

public class DayTexture {
   public static final BuilderCodec<DayTexture> CODEC;
   protected int day;
   protected String texture;

   public DayTexture(int day, String texture) {
      this.day = day;
      this.texture = texture;
   }

   protected DayTexture() {
   }

   public int getDay() {
      return this.day;
   }

   public String getTexture() {
      return this.texture;
   }

   @Nonnull
   public String toString() {
      return "DayTexture{day=" + this.day + ", texture='" + this.texture + "'}";
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(DayTexture.class, DayTexture::).addField( (, Codec.INTEGER), (dayTexture, i) -> dayTexture.day = i, DayTexture::getDay)).append( (, Codec.STRING), (dayTexture, s) -> dayTexture.texture = s, DayTexture::getTexture).addValidator(CommonAssetValidator.TEXTURE_SKY).add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/weather/config/FogOptions.java

package com.hypixel.hytale.server.core.asset.type.weather.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import javax.annotation.Nullable;

public class FogOptions {
   public static final BuilderCodec<FogOptions> CODEC;
   private boolean ignoreFogLimits = false;
   private float effectiveViewDistanceMultiplier = 1.0F;
   private Float fogHeightCameraFixed = null;
   private float fogHeightCameraOffset = 0.0F;

   public FogOptions() {
   }

   public boolean isIgnoreFogLimits() {
      return this.ignoreFogLimits;
   }

   public float getEffectiveViewDistanceMultiplier() {
      return this.effectiveViewDistanceMultiplier;
   }

   @Nullable
    Float  {
       .fogHeightCameraFixed;
   }

      {
       .fogHeightCameraOffset;
   }

    com.hypixel.hytale.protocol.FogOptions  {
      com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.FogOptions();
      proto.ignoreFogLimits = .ignoreFogLimits;
      proto.effectiveViewDistanceMultiplier = .effectiveViewDistanceMultiplier;
       (.fogHeightCameraFixed == ) {
         proto.fogHeightCameraOverriden = ;
      }  {
         proto.fogHeightCameraOverriden = ;
         proto.fogHeightCameraFixed = .fogHeightCameraFixed;
      }

      proto.fogHeightCameraOffset = .fogHeightCameraOffset;
       proto;
   }

    String  {
        + .ignoreFogLimits +  + .effectiveViewDistanceMultiplier +  + .fogHeightCameraFixed +  + .fogHeightCameraOffset + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(FogOptions.class, FogOptions::).appendInherited( (, Codec.BOOLEAN), (opt, s) -> opt.ignoreFogLimits = s, (opt) -> opt.ignoreFogLimits, (opt, parent) -> opt.ignoreFogLimits = parent.ignoreFogLimits).documentation().add()).appendInherited( (, Codec.FLOAT), (opt, s) -> opt.effectiveViewDistanceMultiplier = s, (opt) -> opt.effectiveViewDistanceMultiplier, (opt, parent) -> opt.effectiveViewDistanceMultiplier = parent.effectiveViewDistanceMultiplier).documentation().add()).appendInherited( (, Codec.FLOAT), (opt, s) -> opt.fogHeightCameraFixed = s, (opt) -> opt.fogHeightCameraFixed, (opt, parent) -> opt.fogHeightCameraFixed = parent.fogHeightCameraFixed).documentation().add()).appendInherited( (, Codec.FLOAT), (opt, s) -> opt.fogHeightCameraOffset = s, (opt) -> opt.fogHeightCameraOffset, (opt, parent) -> opt.fogHeightCameraOffset = parent.fogHeightCameraOffset).documentation().add()).build();
   }
}

com/hypixel/hytale/server/core/asset/type/weather/config/TimeColor.java

package com.hypixel.hytale.server.core.asset.type.weather.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.Color;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import javax.annotation.Nonnull;

public class TimeColor {
   public static final BuilderCodec<TimeColor> CODEC;
   public static final ArrayCodec<TimeColor> ARRAY_CODEC;
   protected float hour;
   protected Color color;

   public TimeColor(float hour, Color color) {
      this.hour = hour;
      this.color = color;
   }

   protected TimeColor() {
   }

   public float getHour() {
      return this.hour;
   }

   public Color getColor() {
      return this.color;
   }

   @Nonnull
   public String  {
         .hour;
        + var10000 +  + String.valueOf(.color) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(TimeColor.class, TimeColor::).append( (, Codec.DOUBLE), (timeColor, i) -> timeColor.hour = i.floatValue(), (timeColor) -> ()timeColor.getHour()).addValidator(Validators.range(, )).add()).addField( (, ProtocolCodecs.COLOR), (timeColor, o) -> timeColor.color = o, TimeColor::getColor)).build();
      ARRAY_CODEC =  <TimeColor>(CODEC, (x$) ->  [x$]);
   }
}

com/hypixel/hytale/server/core/asset/type/weather/config/TimeColorAlpha.java

package com.hypixel.hytale.server.core.asset.type.weather.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.protocol.ColorAlpha;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import javax.annotation.Nonnull;

public class TimeColorAlpha {
   public static final BuilderCodec<TimeColorAlpha> CODEC;
   public static final ArrayCodec<TimeColorAlpha> ARRAY_CODEC;
   protected float hour;
   protected ColorAlpha color;

   public TimeColorAlpha(float hour, ColorAlpha color) {
      this.hour = hour;
      this.color = color;
   }

   protected TimeColorAlpha() {
   }

   public float getHour() {
      return this.hour;
   }

   public ColorAlpha getColor() {
      return this.color;
   }

   @Nonnull
    String  {
         .hour;
        + var10000 +  + String.valueOf(.color) + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(TimeColorAlpha.class, TimeColorAlpha::).append( (, Codec.DOUBLE), (timeColorAlpha, i) -> timeColorAlpha.hour = i.floatValue(), (timeColorAlpha) -> ()timeColorAlpha.getHour()).addValidator(Validators.range(, )).add()).addField( (, ProtocolCodecs.COLOR_AlPHA), (timeColorAlpha, o) -> timeColorAlpha.color = o, TimeColorAlpha::getColor)).build();
      ARRAY_CODEC =  <TimeColorAlpha>(CODEC, (x$) ->  [x$]);
   }
}

com/hypixel/hytale/server/core/asset/type/weather/config/TimeFloat.java

package com.hypixel.hytale.server.core.asset.type.weather.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import javax.annotation.Nonnull;

public class TimeFloat {
   public static final BuilderCodec<TimeFloat> CODEC;
   protected float hour;
   protected float value;

   public TimeFloat(float hour, float value) {
      this.hour = hour;
      this.value = value;
   }

   protected TimeFloat() {
   }

   public float getHour() {
      return this.hour;
   }

   public float getValue() {
      return this.value;
   }

   @Nonnull
   public String toString() {
      return "TimeFloat{hour=" + this.hour + ", value='" + .value + ;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(TimeFloat.class, TimeFloat::).append( (, Codec.DOUBLE), (timeFloat, i) -> timeFloat.hour = i.floatValue(), (timeFloat) -> ()timeFloat.getHour()).addValidator(Validators.range(, )).add()).addField( (, Codec.DOUBLE), (timeFloat, d) -> timeFloat.value = d.floatValue(), (timeFloat) -> ()timeFloat.value)).build();
   }
}

com/hypixel/hytale/server/core/asset/type/weather/config/Weather.java

package com.hypixel.hytale.server.core.asset.type.weather.config;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.schema.metadata.ui.UIDefaultCollapsedState;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditor;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditorFeatures;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditorSectionStart;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.common.util.ArrayUtil;
import com.hypixel.hytale.protocol.Color;
import com.hypixel.hytale.protocol.ColorAlpha;
import com.hypixel.hytale.protocol.NearFar;
import com.hypixel.hytale.protocol.WeatherParticle;
import com.hypixel.hytale.server.core.asset.common.CommonAssetValidator;
import com.hypixel.hytale.server.core.asset.type.particle.config.ParticleSystem;
import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import it.unimi.dsi.fastutil.ints.IntSet;
import java.lang.ref.SoftReference;
 java.util.Arrays;
 java.util.Map;
 java.util.stream.Collectors;
 javax.annotation.Nonnull;

    <String, IndexedLookupTableAssetMap<String, Weather>>, NetworkSerializable<com.hypixel.hytale.protocol.Weather> {
      BuilderCodec<WeatherParticle> PARTICLE_CODEC;
      AssetBuilderCodec<String, Weather> CODEC;
      ValidatorCache<String> VALIDATOR_CACHE;
     AssetStore<String, Weather, IndexedLookupTableAssetMap<String, Weather>> ASSET_STORE;
      [] DEFAULT_FOG_DISTANCE;
         ;
      Weather UNKNOWN;
    AssetExtraInfo.Data data;
    String id;
    DayTexture[] moons;
    Cloud[] clouds;
    TimeFloat[] sunlightDampingMultiplier;
    TimeColor[] sunlightColors;
    TimeColor[] sunColors;
    TimeColorAlpha[] moonColors;
    TimeColorAlpha[] sunGlowColors;
    TimeColorAlpha[] moonGlowColors;
    TimeFloat[] sunScales;
    TimeFloat[] moonScales;
    TimeColorAlpha[] skyTopColors;
    TimeColorAlpha[] skyBottomColors;
    TimeColorAlpha[] skySunsetColors;
    TimeColor[] fogColors;
    TimeFloat[] fogHeightFalloffs;
    TimeFloat[] fogDensities;
    TimeColor[] waterTints;
    [] fogDistance;
    FogOptions fogOptions;
    String screenEffect;
    TimeColorAlpha[] screenEffectColors;
    TimeColor[] colorFilters;
    String stars;
    WeatherParticle particle;
    SoftReference<com.hypixel.hytale.protocol.Weather> cachedPacket;

     AssetStore<String, Weather, IndexedLookupTableAssetMap<String, Weather>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, Weather, IndexedLookupTableAssetMap<String, Weather>>getAssetStore(Weather.class);
      }

       ASSET_STORE;
   }

     IndexedLookupTableAssetMap<String, Weather>  {
       (IndexedLookupTableAssetMap)getAssetStore().getAssetMap();
   }

     {
      .fogDistance = DEFAULT_FOG_DISTANCE;
      .id = id;
      .moons = moons;
      .clouds = clouds;
      .sunlightDampingMultiplier = sunlightDampingMultiplier;
      .sunlightColors = sunlightColors;
      .sunColors = sunColors;
      .moonColors = moonColors;
      .sunGlowColors = sunGlowColors;
      .moonGlowColors = moonGlowColors;
      .sunScales = sunScales;
      .moonScales = moonScales;
      .skyTopColors = skyTopColors;
      .skyBottomColors = skyBottomColors;
      .skySunsetColors = skySunsetColors;
      .fogColors = fogColors;
      .fogHeightFalloffs = fogHeightFalloffs;
      .fogDensities = fogDensities;
      .waterTints = waterTints;
      .fogDistance = fogDistance;
      .fogOptions = fogOptions;
      .screenEffect = screenEffect;
      .screenEffectColors = screenEffectColors;
      .colorFilters = colorFilters;
      .stars = stars;
      .particle = particle;
   }

     {
      .fogDistance = DEFAULT_FOG_DISTANCE;
      .id = id;
   }

     {
      .fogDistance = DEFAULT_FOG_DISTANCE;
   }

   
    com.hypixel.hytale.protocol.Weather  {
      com.hypixel.hytale.protocol.   .cachedPacket ==  ?  : (com.hypixel.hytale.protocol.Weather).cachedPacket.get();
       (cached != ) {
          cached;
      }  {
         com.hypixel.hytale.protocol.    .hypixel.hytale.protocol.Weather();
         packet.id = .id;
          (.moons !=  && .moons.length > ) {
            packet.moons = toStringMap(.moons);
         }

          (.clouds !=  && .clouds.length > ) {
            packet.clouds = (com.hypixel.hytale.protocol.Cloud[])ArrayUtil.copyAndMutate(.clouds, Cloud::toPacket, (x$) ->  .hypixel.hytale.protocol.Cloud[x$]);
         }

          (.sunlightDampingMultiplier !=  && .sunlightDampingMultiplier.length > ) {
            packet.sunlightDampingMultiplier = toFloatMap(.sunlightDampingMultiplier);
         }

          (.sunlightColors !=  && .sunlightColors.length > ) {
            packet.sunlightColors = toColorMap(.sunlightColors);
         }

          (.sunColors !=  && .sunColors.length > ) {
            packet.sunColors = toColorMap(.sunColors);
         }

          (.sunGlowColors !=  && .sunGlowColors.length > ) {
            packet.sunGlowColors = toColorAlphaMap(.sunGlowColors);
         }

          (.sunScales !=  && .sunScales.length > ) {
            packet.sunScales = toFloatMap(.sunScales);
         }

          (.moonColors !=  && .moonColors.length > ) {
            packet.moonColors = toColorAlphaMap(.moonColors);
         }

          (.moonGlowColors !=  && .moonGlowColors.length > ) {
            packet.moonGlowColors = toColorAlphaMap(.moonGlowColors);
         }

          (.moonScales !=  && .moonScales.length > ) {
            packet.moonScales = toFloatMap(.moonScales);
         }

          (.skyTopColors !=  && .skyTopColors.length > ) {
            packet.skyTopColors = toColorAlphaMap(.skyTopColors);
         }

          (.skyBottomColors !=  && .skyBottomColors.length > ) {
            packet.skyBottomColors = toColorAlphaMap(.skyBottomColors);
         }

          (.skySunsetColors !=  && .skySunsetColors.length > ) {
            packet.skySunsetColors = toColorAlphaMap(.skySunsetColors);
         }

          (.fogColors !=  && .fogColors.length > ) {
            packet.fogColors = toColorMap(.fogColors);
         }

          (.fogHeightFalloffs !=  && .fogHeightFalloffs.length > ) {
            packet.fogHeightFalloffs = toFloatMap(.fogHeightFalloffs);
         }

          (.fogDensities !=  && .fogDensities.length > ) {
            packet.fogDensities = toFloatMap(.fogDensities);
         }

         packet.screenEffect = .screenEffect;
          (.screenEffectColors !=  && .screenEffectColors.length > ) {
            packet.screenEffectColors = toColorAlphaMap(.screenEffectColors);
         }

          (.colorFilters !=  && .colorFilters.length > ) {
            packet.colorFilters = toColorMap(.colorFilters);
         }

          (.waterTints !=  && .waterTints.length > ) {
            packet.waterTints = toColorMap(.waterTints);
         }

          (.fogOptions != ) {
            packet.fogOptions = .fogOptions.toPacket();
         }

         packet.fog =  (.fogDistance[], .fogDistance[]);
         packet.stars = .stars;
          (.particle != ) {
            packet.particle = .particle;
         }

          (.data != ) {
               .data.getExpandedTagIndexes();
            packet.tagIndexes = tags.toIntArray();
         }

         .cachedPacket =  (packet);
          packet;
      }
   }

    String  {
       .id;
   }

    DayTexture[] getMoons() {
       .moons;
   }

    Cloud[] getClouds() {
       .clouds;
   }

    TimeFloat[] getSunlightDampingMultiplier() {
       .sunlightDampingMultiplier;
   }

    TimeColor[] getSunlightColors() {
       .sunlightColors;
   }

    TimeColor[] getSunColors() {
       .sunColors;
   }

    TimeColorAlpha[] getMoonColors() {
       .moonColors;
   }

    TimeColorAlpha[] getSunGlowColors() {
       .sunGlowColors;
   }

    TimeColorAlpha[] getMoonGlowColors() {
       .moonGlowColors;
   }

    TimeFloat[] getSunScales() {
       .sunScales;
   }

    TimeFloat[] getMoonScales() {
       .moonScales;
   }

    TimeColorAlpha[] getSkyTopColors() {
       .skyTopColors;
   }

    TimeColorAlpha[] getSkyBottomColors() {
       .skyBottomColors;
   }

    TimeColorAlpha[] getSkySunsetColors() {
       .skySunsetColors;
   }

    TimeColor[] getFogColors() {
       .fogColors;
   }

    TimeFloat[] getFogHeightFalloffs() {
       .fogHeightFalloffs;
   }

    TimeFloat[] getFogDensities() {
       .fogDensities;
   }

    TimeColor[] getWaterTints() {
       .waterTints;
   }

    [] getFogDistance() {
       .fogDistance;
   }

    FogOptions  {
       .fogOptions;
   }

    String  {
       .screenEffect;
   }

    TimeColorAlpha[] getScreenEffectColors() {
       .screenEffectColors;
   }

    TimeColor[] getColorFilters() {
       .colorFilters;
   }

    String  {
       .stars;
   }

    WeatherParticle  {
       .particle;
   }

   
    String  {
         .id;
        + var10000 +  + Arrays.toString(.moons) +  + Arrays.toString(.clouds) +  + Arrays.toString(.sunlightDampingMultiplier) +  + Arrays.toString(.sunlightColors) +  + Arrays.toString(.sunColors) +  + Arrays.toString(.sunGlowColors) +  + Arrays.toString(.sunScales) +  + Arrays.toString(.moonColors) +  + Arrays.toString(.moonGlowColors) +  + Arrays.toString(.moonScales) +  + Arrays.toString(.skyTopColors) +  + Arrays.toString(.skyBottomColors) +  + Arrays.toString(.skySunsetColors) +  + Arrays.toString(.fogColors) +  + Arrays.toString(.fogHeightFalloffs) +  + Arrays.toString(.fogDensities) +  + Arrays.toString(.fogDistance) +  + String.valueOf(.fogOptions) +  + .screenEffect +  + Arrays.toString(.screenEffectColors) +  + Arrays.toString(.colorFilters) +  + Arrays.toString(.waterTints) +  + .stars +  + String.valueOf(.particle) + ;
   }

   
     Map<Integer, String>  {
       (Map)Arrays.stream(dayTexture).collect(Collectors.toMap(DayTexture::getDay, DayTexture::getTexture));
   }

   
     Map<Float, Float>  {
       (Map)Arrays.stream(timeFloat).collect(Collectors.toMap(TimeFloat::getHour, TimeFloat::getValue));
   }

   
     Map<Float, Color>  {
       (Map)Arrays.stream(timeColor).collect(Collectors.toMap(TimeColor::getHour, TimeColor::getColor));
   }

   
     Map<Float, ColorAlpha>  {
       (Map)Arrays.stream(timeColorAlpha).collect(Collectors.toMap(TimeColorAlpha::getHour, TimeColorAlpha::getColor));
   }

    {
      PARTICLE_CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(WeatherParticle.class, WeatherParticle::).documentation()).append( (, Codec.STRING), (particle, s) -> particle.systemId = s, (particle) -> particle.systemId).addValidator(Validators.nonNull()).addValidator(ParticleSystem.VALIDATOR_CACHE.getValidator()).add()).append( (, ProtocolCodecs.COLOR), (particle, o) -> particle.color = o, (particle) -> particle.color).documentation().add()).append( (, Codec.FLOAT), (particle, f) -> particle.scale = f, (particle) -> particle.scale).documentation().add()).append( (, Codec.BOOLEAN), (particle, s) -> particle.isOvergroundOnly = s, (particle) -> particle.isOvergroundOnly).documentation().add()).append( (, Codec.FLOAT), (particle, f) -> particle.positionOffsetMultiplier = f, (particle) -> particle.positionOffsetMultiplier).documentation().add()).build();
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(Weather.class, Weather::, Codec.STRING, (weather, s) -> weather.id = s, (weather) -> weather.id, (asset, data) -> asset.data = data, (asset) -> asset.data).metadata( ( .EditorFeature[]{UIEditorFeatures.EditorFeature.WEATHER_DAYTIME_BAR, UIEditorFeatures.EditorFeature.WEATHER_PREVIEW_LOCAL}))).appendInherited( (, Codec.STRING), (weather, o) -> weather.stars = o, (weather) -> weather.stars, (weather, parent) -> weather.stars = parent.stars).addValidator(CommonAssetValidator.TEXTURE_SKY).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, Codec.STRING), (weather, o) -> weather.screenEffect = o, (weather) -> weather.screenEffect, (weather, parent) -> weather.screenEffect = parent.screenEffect).addValidator(CommonAssetValidator.UI_SCREEN_EFFECT).add()).appendInherited( (, Codec.DOUBLE_ARRAY), (weather, o) -> {
         weather.fogDistance =  [];
         weather.fogDistance[] = ()o[];
         weather.fogDistance[] = ()o[];
      }, (weather) ->  []{()weather.fogDistance[], ()weather.fogDistance[]}, (weather, parent) -> weather.fogDistance = parent.fogDistance).addValidator(Validators.nonNull()).addValidator(Validators.doubleArraySize()).addValidator(Validators.monotonicSequentialDoubleArrayValidator()).documentation().add()).appendInherited( (, FogOptions.CODEC), (weather, o) -> weather.fogOptions = o, (weather) -> weather.fogOptions, (weather, parent) -> weather.fogOptions = parent.fogOptions).documentation().add()).appendInherited( (, PARTICLE_CODEC), (weather, o) -> weather.particle = o, (weather) -> weather.particle, (weather, parent) -> weather.particle = parent.particle).add()).appendInherited( (, TimeColorAlpha.ARRAY_CODEC), (weather, o) -> weather.screenEffectColors = o, (weather) -> weather.screenEffectColors, (weather, parent) -> weather.screenEffectColors = parent.screenEffectColors).metadata( (UIEditor.TIMELINE)).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (,  (TimeFloat.CODEC, (x$) ->  [x$])), (weather, o) -> weather.sunlightDampingMultiplier = o, (weather) -> weather.sunlightDampingMultiplier, (weather, parent) -> weather.sunlightDampingMultiplier = parent.sunlightDampingMultiplier).metadata( ()).metadata( (UIEditor.TIMELINE)).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, TimeColor.ARRAY_CODEC), (weather, o) -> weather.sunlightColors = o, (weather) -> weather.sunlightColors, (weather, parent) -> weather.sunlightColors = parent.sunlightColors).metadata( (UIEditor.TIMELINE)).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, TimeColor.ARRAY_CODEC), (weather, o) -> weather.sunColors = o, (weather) -> weather.sunColors, (weather, parent) -> weather.sunColors = parent.sunColors).metadata( (UIEditor.TIMELINE)).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, TimeColorAlpha.ARRAY_CODEC), (weather, o) -> weather.moonColors = o, (weather) -> weather.moonColors, (weather, parent) -> weather.moonColors = parent.moonColors).metadata( (UIEditor.TIMELINE)).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, TimeColorAlpha.ARRAY_CODEC), (weather, o) -> weather.sunGlowColors = o, (weather) -> weather.sunGlowColors, (weather, parent) -> weather.sunGlowColors = parent.sunGlowColors).metadata( (UIEditor.TIMELINE)).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, TimeColorAlpha.ARRAY_CODEC), (weather, o) -> weather.moonGlowColors = o, (weather) -> weather.moonGlowColors, (weather, parent) -> weather.moonGlowColors = parent.moonGlowColors).metadata( (UIEditor.TIMELINE)).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (,  (TimeFloat.CODEC, (x$) ->  [x$])), (weather, o) -> weather.sunScales = o, (weather) -> weather.sunScales, (weather, parent) -> weather.sunScales = parent.sunScales).metadata( (UIEditor.TIMELINE)).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (,  (TimeFloat.CODEC, (x$) ->  [x$])), (weather, o) -> weather.moonScales = o, (weather) -> weather.moonScales, (weather, parent) -> weather.moonScales = parent.moonScales).metadata( (UIEditor.TIMELINE)).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, TimeColorAlpha.ARRAY_CODEC), (weather, o) -> weather.skyTopColors = o, (weather) -> weather.skyTopColors, (weather, parent) -> weather.skyTopColors = parent.skyTopColors).metadata( (UIEditor.TIMELINE)).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, TimeColorAlpha.ARRAY_CODEC), (weather, o) -> weather.skyBottomColors = o, (weather) -> weather.skyBottomColors, (weather, parent) -> weather.skyBottomColors = parent.skyBottomColors).metadata( (UIEditor.TIMELINE)).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, TimeColorAlpha.ARRAY_CODEC), (weather, o) -> weather.skySunsetColors = o, (weather) -> weather.skySunsetColors, (weather, parent) -> weather.skySunsetColors = parent.skySunsetColors).metadata( (UIEditor.TIMELINE)).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, TimeColor.ARRAY_CODEC), (weather, o) -> weather.fogColors = o, (weather) -> weather.fogColors, (weather, parent) -> weather.fogColors = parent.fogColors).metadata( (UIEditor.TIMELINE)).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (,  (TimeFloat.CODEC, (x$) ->  [x$])), (weather, o) -> weather.fogHeightFalloffs = o, (weather) -> weather.fogHeightFalloffs, (weather, parent) -> weather.fogHeightFalloffs = parent.fogHeightFalloffs).metadata( (UIEditor.TIMELINE)).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (,  (TimeFloat.CODEC, (x$) ->  [x$])), (weather, o) -> weather.fogDensities = o, (weather) -> weather.fogDensities, (weather, parent) -> weather.fogDensities = parent.fogDensities).metadata( (UIEditor.TIMELINE)).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, TimeColor.ARRAY_CODEC), (weather, o) -> weather.waterTints = o, (weather) -> weather.waterTints, (weather, parent) -> weather.waterTints = parent.waterTints).metadata( (UIEditor.TIMELINE)).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (, TimeColor.ARRAY_CODEC), (weather, o) -> weather.colorFilters = o, (weather) -> weather.colorFilters, (weather, parent) -> weather.colorFilters = parent.colorFilters).metadata( (UIEditor.TIMELINE)).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (,  (DayTexture.CODEC, (x$) ->  [x$])), (weather, o) -> weather.moons = o, (weather) -> weather.moons, (weather, parent) -> weather.moons = parent.moons).metadata( ()).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).appendInherited( (,  (Cloud.CODEC, (x$) ->  [x$])), (weather, o) -> weather.clouds = o, (weather) -> weather.clouds, (weather, parent) -> weather.clouds = parent.clouds).metadata( ()).metadata(UIDefaultCollapsedState.UNCOLLAPSED).add()).build();
      VALIDATOR_CACHE =  <String>( (Weather::getAssetStore));
      DEFAULT_FOG_DISTANCE =  []{-, };
      UNKNOWN =  ();
   }
}

com/hypixel/hytale/server/core/asset/type/wordlist/WordList.java

package com.hypixel.hytale.server.core.asset.type.wordlist;

import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.assetstore.AssetKeyValidator;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.AssetStore;
import com.hypixel.hytale.assetstore.codec.AssetBuilderCodec;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.validation.ValidatorCache;
import com.hypixel.hytale.server.core.modules.i18n.I18nModule;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.Set;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class WordList implements JsonAssetWithMap<String, DefaultAssetMap<String, WordList>> {
   private static final String WORDLISTS_TRANSLATION_FILE = "wordlists";
   public static final AssetBuilderCodec<String, WordList> CODEC;
   private static AssetStore<String, WordList, DefaultAssetMap<String, WordList>> ASSET_STORE;
   public   ValidatorCache<String> VALIDATOR_CACHE;
      WordList EMPTY;
    AssetExtraInfo.Data data;
    String id;
    String[] translationKeys;

     AssetStore<String, WordList, DefaultAssetMap<String, WordList>>  {
       (ASSET_STORE == ) {
         ASSET_STORE = AssetRegistry.<String, WordList, DefaultAssetMap<String, WordList>>getAssetStore(WordList.class);
      }

       ASSET_STORE;
   }

     DefaultAssetMap<String, WordList>  {
       (DefaultAssetMap)getAssetStore().getAssetMap();
   }

     WordList  {
       (assetKey !=  && !assetKey.isEmpty()) {
            (WordList)getAssetMap().getAsset(assetKey);
          wordList ==  ? EMPTY : wordList;
      }  {
          EMPTY;
      }
   }

     {
   }

    String  {
       .id;
   }

      {
       (.translationKeys != ) {
            .id.toLowerCase();
         String[] remappedTranslationKeys =  [.translationKeys.length];

         (   ; i < .translationKeys.length; ++i) {
            remappedTranslationKeys[i] =  + idLower +  + .translationKeys[i];
         }

         .translationKeys = remappedTranslationKeys;
      }

   }

   
    String  {
         .pickTranslationKey(random, alreadyUsedTranslated, );
       translationKey ==  ?  : I18nModule.get().getMessage(, translationKey);
   }

   
    String  {
      List<String> available = toKeysListMinusTranslated(.translationKeys, alreadyUsedTranslated, languageForAlreadyUsed);
       available.isEmpty() ?  : (String)available.get(random.nextInt(available.size()));
   }

   
     <T> List<T>  {
       (array !=  && array.length != ) {
         List<T> result =  <T>(array.length);

         (T elem : array) {
             (!set.contains(elem)) {
               result.add(elem);
            }
         }

          result;
      }  {
          Collections.emptyList();
      }
   }

   
     List<String>  {
       (translationKeys !=  && translationKeys.length != ) {
         List<String> result =  <String>(translationKeys.length);

         (String translationKey : translationKeys) {
               I18nModule.get().getMessage(language, translationKey);
             (translated !=  && !alreadyUsedTranslated.contains(translated)) {
               result.add(translationKey);
            }
         }

          result;
      }  {
          Collections.emptyList();
      }
   }

   
    String  {
         .id;
        + var10000 +  + String.valueOf(.translationKeys) + ;
   }

    {
      CODEC = ((AssetBuilderCodec.Builder)((AssetBuilderCodec.Builder)AssetBuilderCodec.builder(WordList.class, WordList::, Codec.STRING, (wordList, s) -> wordList.id = s, (wordList) -> wordList.id, (asset, data) -> asset.data = data, (asset) -> asset.data).appendInherited( (, Codec.STRING_ARRAY), (wordList, o) -> wordList.translationKeys = o, (wordList) -> wordList.translationKeys, (wordList, parent) -> wordList.translationKeys = parent.translationKeys).documentation().add()).afterDecode(WordList::processConfig)).build();
      VALIDATOR_CACHE =  <String>( (WordList::getAssetStore));
      EMPTY =  ();
   }
}

com/hypixel/hytale/server/core/asset/util/ColorParseUtil.java

package com.hypixel.hytale.server.core.asset.util;

import com.hypixel.hytale.codec.util.RawJsonReader;
import com.hypixel.hytale.math.util.MathUtil;
import com.hypixel.hytale.protocol.Color;
import com.hypixel.hytale.protocol.ColorAlpha;
import com.hypixel.hytale.protocol.ColorLight;
import java.io.IOException;
import java.util.Objects;
import java.util.regex.Pattern;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ColorParseUtil {
   public static final Pattern HEX_COLOR_PATTERN = Pattern.compile("^\\s*#([0-9a-fA-F]{3}){1,2}\\s*$");
   public static final Pattern HEX_ALPHA_COLOR_PATTERN = Pattern.compile("^\\s*#([0-9a-fA-F]{4}){1,2}\\s*$");
   public static final Pattern RGB_COLOR_PATTERN = Pattern.compile("^\\s*rgb\\((\\s*[0-9]{1,3}\\s*,){2}\\s*[0-9]{1,3}\\s*\\)\\s*$");
   public static final Pattern RGBA_COLOR_PATTERN = Pattern.compile("^\\s*rgba\\((\\s*[0-9]{1,3}\\s*,){3}\\s*[0,1](.[0-9]*)?\\s*\\)\\s*$");
   public      Pattern.compile();

     {
   }

   
     ColorAlpha   IOException {
      reader.consumeWhiteSpace();
      ColorAlpha var10000;
       (reader.peek()) {
           -> var10000 = readHexStringToColorAlpha(reader);
           -> var10000 = readRgbaStringToColorAlpha(reader);
          -> var10000 = ;
      }

       var10000;
   }

   
     ColorAlpha  {
       (HEX_ALPHA_COLOR_PATTERN.matcher(stringValue).matches()) {
          hexStringToColorAlpha(stringValue);
      }   (RGBA_HEX_COLOR_PATTERN.matcher(stringValue).matches()) {
          rgbaHexStringToColor(stringValue);
      }  {
          RGBA_COLOR_PATTERN.matcher(stringValue).matches() ? rgbaDecimalStringToColor(stringValue) : ;
      }
   }

   
     Color   IOException {
      reader.consumeWhiteSpace();
      Color var10000;
       (reader.peek()) {
           -> var10000 = readHexStringToColor(reader);
           -> var10000 = readRgbStringToColor(reader);
          -> var10000 = ;
      }

       var10000;
   }

   
     Color  {
       (HEX_COLOR_PATTERN.matcher(stringValue).matches()) {
          hexStringToColor(stringValue);
      }  {
          RGB_COLOR_PATTERN.matcher(stringValue).matches() ? rgbStringToColor(stringValue) : ;
      }
   }

   
     Color   IOException {
         readHexAlphaStringToRGBAInt(reader);
        (()(rgba >>  & ), ()(rgba >>  & ), ()(rgba >>  & ));
   }

   
     Color  {
         hexAlphaStringToRGBAInt(color);
        (()(rgba >>  & ), ()(rgba >>  & ), ()(rgba >>  & ));
   }

   
     ColorAlpha   IOException {
         readHexAlphaStringToRGBAInt(reader);
        (()(rgba & ), ()(rgba >>  & ), ()(rgba >>  & ), ()(rgba >>  & ));
   }

   
     ColorAlpha  {
         hexAlphaStringToRGBAInt(color);
        (()(rgba & ), ()(rgba >>  & ), ()(rgba >>  & ), ()(rgba >>  & ));
   }

        IOException {
      reader.consumeWhiteSpace();
      reader.expect();
      reader.mark();

       var13;
       {
            reader.readIntValue();
            reader.getMarkDistance();
          (size) {
             :
               value <<= ;
               value |= ;
             :
               ;
             :
             :
            :
                 ( + size);
             :
               var13 = value <<  | ;
                var13;
             :
               var13 = value;
                var13;
         }

            value >>  & ;
            value >>  & ;
            value >>  & ;
            value & ;
         var13 = red <<  | red <<  | green <<  | green <<  | blue <<  | blue <<  | alpha <<  | alpha;
      }  {
         reader.unmark();
         reader.consumeWhiteSpace();
      }

       var13;
   }

       {
      Objects.requireNonNull(color, );
      color = color.trim();
       (!color.isEmpty() && color.charAt() == ) {
         color = color.substring();
            ()Long.parseLong(color, );
          (color.length()) {
             :
               value <<= ;
               value |= ;
             :
                  value >>  & ;
                  value >>  & ;
                  value >>  & ;
                  value & ;
                red <<  | red <<  | green <<  | green <<  | blue <<  | blue <<  | alpha <<  | alpha;
             :
             :
            :
                 ( + color + );
             :
                value <<  | ;
             :
                value;
         }
      }  {
           ();
      }
   }

        IOException {
       readHexAlphaStringToRGBAInt(reader) >>> ;
   }

       {
       hexAlphaStringToRGBAInt(color) >>> ;
   }

   
     String  {
       color ==  ?  : toHexString(color.red, color.green, color.blue);
   }

   
     String  {
       color ==  ?  : toHexAlphaString(color.red, color.green, color.blue, color.alpha);
   }

   
     Color   IOException {
      reader.consumeWhiteSpace();
      reader.expect(, );
      reader.consumeWhiteSpace();
         reader.readByteValue();
      reader.consumeWhiteSpace();
      reader.expect();
      reader.consumeWhiteSpace();
         reader.readByteValue();
      reader.consumeWhiteSpace();
      reader.expect();
      reader.consumeWhiteSpace();
         reader.readByteValue();
      reader.consumeWhiteSpace();
      reader.expect();
      reader.consumeWhiteSpace();
        (red, green, blue);
   }

   
     Color  {
      Objects.requireNonNull(color, );
      color = color.trim();
       (color.startsWith() && color.charAt(color.length() - ) == ) {
         color = color.substring(, color.length() - );
         String[] channels = color.split();
            channels.length;
          (channelLength != ) {
              ();
         }  {
               ()Integer.parseInt(channels[].trim());
               ()Integer.parseInt(channels[].trim());
               ()Integer.parseInt(channels[].trim());
              (red, green, blue);
         }
      }  {
           ();
      }
   }

   
     ColorAlpha   IOException {
      reader.consumeWhiteSpace();
      reader.expect(, );
      reader.consumeWhiteSpace();
       reader.peek() ==  ? readRgbaHexStringToColor(reader, ) : readRgbaDecimalStringToColor(reader, );
   }

   
     ColorAlpha   IOException {
       readRgbaDecimalStringToColor(reader, );
   }

   
     ColorAlpha   IOException {
       (readStart) {
         reader.consumeWhiteSpace();
         reader.expect(, );
         reader.consumeWhiteSpace();
      }

         reader.readByteValue();
      reader.consumeWhiteSpace();
      reader.expect();
      reader.consumeWhiteSpace();
         reader.readByteValue();
      reader.consumeWhiteSpace();
      reader.expect();
      reader.consumeWhiteSpace();
         reader.readByteValue();
      reader.consumeWhiteSpace();
      reader.expect();
      reader.consumeWhiteSpace();
         ()(()MathUtil.clamp(reader.readFloatValue() * , , ));
      reader.consumeWhiteSpace();
      reader.expect();
      reader.consumeWhiteSpace();
        (alpha, red, green, blue);
   }

   
     ColorAlpha  {
      Objects.requireNonNull(color, );
      color = color.trim();
       (color.startsWith() && color.charAt(color.length() - ) == ) {
         color = color.substring(, color.length() - );
         String[] channels = color.split();
            channels.length;
          (channelLength != ) {
              ();
         }  {
               ()MathUtil.clamp(Integer.parseInt(channels[].trim()), , );
               ()MathUtil.clamp(Integer.parseInt(channels[].trim()), , );
               ()MathUtil.clamp(Integer.parseInt(channels[].trim()), , );
               ()(()MathUtil.clamp(Float.parseFloat(channels[]) * , , ));
              (alpha, red, green, blue);
         }
      }  {
           ();
      }
   }

   
     ColorAlpha   IOException {
       readRgbaHexStringToColor(reader, );
   }

   
     ColorAlpha   IOException {
       (readStart) {
         reader.consumeWhiteSpace();
         reader.expect(, );
         reader.consumeWhiteSpace();
      }

         ()readHexAlphaStringToRGBAInt(reader);
      reader.consumeWhiteSpace();
      reader.expect();
      reader.consumeWhiteSpace();
         ()(()MathUtil.clamp(reader.readFloatValue() * , , ));
      reader.consumeWhiteSpace();
      reader.expect();
      reader.consumeWhiteSpace();
        (alpha, ()(()(val >>  & )), ()(()(val >>  & )), ()(()(val >>  & )));
   }

   
     ColorAlpha  {
      Objects.requireNonNull(color, );
      color = color.trim();
       (color.startsWith() && color.charAt(color.length() - ) == ) {
         color = color.substring(, color.length() - );
         String[] channels = color.split();
            channels.length;
          (channelLength != ) {
              ();
         }  {
               ()hexAlphaStringToRGBAInt(channels[].trim());
               ()(()MathUtil.clamp(Float.parseFloat(channels[]) * , , ));
              (alpha, ()(()(val >>  & )), ()(()(val >>  & )), ()(()(val >>  & )));
         }
      }  {
           ();
      }
   }

   
     String  {
       (color == ) {
          ;
      }  {
            color.getRGB();
            argb & ;
          toHexString(rgb);
      }
   }

   
     String  {
       (color == ) {
          ;
      }  {
            color.getRGB();
            argb >>  & ;
            argb & ;
            rgb <<  | alpha;
          toHexAlphaString(rgba);
      }
   }

       {
       color ==  ? - : - | (color.red & ) <<  | (color.green & ) <<  | color.blue & ;
   }

       {
       (color.length() == ) {
         colorLight.red = Byte.parseByte(color.substring(, ), );
         colorLight.green = Byte.parseByte(color.substring(, ), );
         colorLight.blue = Byte.parseByte(color.substring(, ), );
      }  {
         colorLight.red = ()(Integer.parseInt(color.substring(, ), ) / );
         colorLight.green = ()(Integer.parseInt(color.substring(, ), ) / );
         colorLight.blue = ()(Integer.parseInt(color.substring(, ), ) / );
      }

   }

   
     String  {
       toHexString(()(colorLight.red * ), ()(colorLight.green * ), ()(colorLight.blue * ));
   }

   
     String  {
       toHexString((red & ) <<  | (green & ) <<  | blue & );
   }

   
     String  {
         Integer.toHexString(rgb);
         .repeat( - hexString.length());
        + var10000 + hexString;
   }

   
     String  {
       toHexAlphaString((red & ) <<  | (green & ) <<  | (blue & ) <<  | alpha & );
   }

   
     String  {
         Integer.toHexString(rgba);
         .repeat( - hexString.length());
        + var10000 + hexString;
   }
}