StructuralCraftingWindow.java

package com.hypixel.hytale.builtin.crafting.window;

import com.google.gson.JsonArray;
import com.hypixel.hytale.builtin.crafting.CraftingPlugin;
import com.hypixel.hytale.builtin.crafting.component.CraftingManager;
import com.hypixel.hytale.builtin.crafting.state.BenchState;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.component.Store;
import com.hypixel.hytale.event.EventRegistration;
import com.hypixel.hytale.math.util.MathUtil;
import com.hypixel.hytale.protocol.BenchRequirement;
import com.hypixel.hytale.protocol.ItemSoundEvent;
import com.hypixel.hytale.protocol.SoundCategory;
import com.hypixel.hytale.protocol.packets.window.ChangeBlockAction;
import com.hypixel.hytale.protocol.packets.window.CraftRecipeAction;
import com.hypixel.hytale.protocol.packets.window.SelectSlotAction;
import com.hypixel.hytale.protocol.packets.window.WindowAction;
import com.hypixel.hytale.protocol.packets.window.WindowType;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.bench.StructuralCraftingBench;
import com.hypixel.hytale.server.core.asset.type.item.config.BlockGroup;
import com.hypixel.hytale.server.core.asset.type.item.config.CraftingRecipe;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.asset.type.itemsound.config.ItemSoundSet;
import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
import com.hypixel.hytale.server.core.entity.entities.Player;
 com.hypixel.hytale.server.core.entity.entities.player.windows.ItemContainerWindow;
 com.hypixel.hytale.server.core.inventory.Inventory;
 com.hypixel.hytale.server.core.inventory.ItemStack;
 com.hypixel.hytale.server.core.inventory.MaterialQuantity;
 com.hypixel.hytale.server.core.inventory.container.CombinedItemContainer;
 com.hypixel.hytale.server.core.inventory.container.ItemContainer;
 com.hypixel.hytale.server.core.inventory.container.SimpleItemContainer;
 com.hypixel.hytale.server.core.inventory.container.filter.FilterActionType;
 com.hypixel.hytale.server.core.inventory.container.filter.FilterType;
 com.hypixel.hytale.server.core.universe.PlayerRef;
 com.hypixel.hytale.server.core.universe.world.SoundUtil;
 com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
 it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 it.unimi.dsi.fastutil.objects.ObjectArrayList;
 it.unimi.dsi.fastutil.objects.ObjectList;
 java.util.List;
 java.util.Objects;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;

       {
         ;
         (());
     SimpleItemContainer optionsContainer;
     CombinedItemContainer combinedItemContainer;
     Int2ObjectMap<String> optionSlotToRecipeMap =  <String>();
     selectedSlot;
   
    EventRegistration inventoryRegistration;

     {
      (WindowType.StructuralCrafting, benchState);
      .inputContainer.registerChangeEvent((e) -> .updateRecipes());
      .inputContainer.setSlotFilter(FilterActionType.ADD, (), ::isValidInput);
      .optionsContainer =  (());
      .optionsContainer.setGlobalFilter(FilterType.DENY_ALL);
      .combinedItemContainer =  ( []{.inputContainer, .optionsContainer});
      .windowData.addProperty(, (Number).selectedSlot);
         (StructuralCraftingBench).bench;
      .windowData.addProperty(, structuralBench.shouldAllowBlockGroupCycling());
      .windowData.addProperty(, structuralBench.shouldAlwaysShowInventoryHints());
   }

      {
       (filterActionType != FilterActionType.ADD) {
          ;
      }  {
         ObjectList<CraftingRecipe> matchingRecipes = .getMatchingRecipes(itemStack);
          matchingRecipes !=  && !matchingRecipes.isEmpty();
      }
   }

       {
      matching.sort((a, b) -> {
            hasHeaderCategory(structuralBench, a);
            hasHeaderCategory(structuralBench, b);
          (aHasHeaderCategory != bHasHeaderCategory) {
             aHasHeaderCategory ? - : ;
         }  {
               getSortingPriority(structuralBench, a);
               getSortingPriority(structuralBench, b);
               Integer.compare(categoryA, categoryB);
             categoryCompare !=  ? categoryCompare : a.getId().compareTo(b.getId());
         }
      });
   }

       {
      (BenchRequirement requirement : recipe.getBenchRequirement()) {
          (requirement.type == bench.getType() && requirement.id.equals(bench.getId()) && requirement.categories != ) {
            (String category : requirement.categories) {
                (bench.isHeaderCategory(category)) {
                   ;
               }
            }
         }
      }

       ;
   }

       {
         ;

      (BenchRequirement requirement : recipe.getBenchRequirement()) {
          (requirement.type == bench.getType() && requirement.id.equals(bench.getId()) && requirement.categories != ) {
            (String category : requirement.categories) {
               priority = Math.min(priority, bench.getCategoryIndex(category));
            }
            ;
         }
      }

       priority;
   }

      {
         (CraftingManager)store.getComponent(ref, CraftingManager.getComponentType());
      Objects.requireNonNull(action);
         ;
      
      
      
      
       (action.typeSwitch<invokedynamic>(action, var6)) {
          :
               (SelectSlotAction)action;
               MathUtil.clamp(selectAction.slot, , .optionsContainer.getCapacity());
             (newSlot != .selectedSlot) {
               .selectedSlot = newSlot;
               .windowData.addProperty(, (Number).selectedSlot);
               .invalidate();
            }
            ;
          :
               (CraftRecipeAction)action;
               .optionsContainer.getItemStack(().selectedSlot);
             (output != ) {
                  craftAction.quantity;
                  (String).optionSlotToRecipeMap.get(.selectedSlot);
                (recipeId == ) {
                  ;
               }

                  (CraftingRecipe)CraftingRecipe.getAssetMap().getAsset(recipeId);
                (recipe == ) {
                  ;
               }

                  recipe.getPrimaryOutput();
                  primaryOutput.getItemId();
                (primaryOutputItemId != ) {
                     (Item)Item.getAssetMap().getAsset(primaryOutputItemId);
                   (primaryOutputItem != ) {
                     .playCraftSound(ref, store, primaryOutputItem);
                  }
               }

               craftingManager.queueCraft(ref, store, , , recipe, quantity, .inputContainer, CraftingManager.InputRemovalType.ORDERED);
               .invalidate();
            }
            ;
          :
               (ChangeBlockAction)action;
             (((StructuralCraftingBench).bench).shouldAllowBlockGroupCycling()) {
               .changeBlockType(ref, changeBlockAction.down, store);
            }
      }

   }

      {
         (ItemSoundSet)ItemSoundSet.getAssetMap().getAsset(item.getItemSoundSetIndex());
       (soundSet != ) {
            (String)soundSet.getSoundEventIds().get(ItemSoundEvent.Drop);
          (dragSound != ) {
               SoundEvent.getAssetMap().getIndex(dragSound);
             (dragSoundIndex != ) {
               SoundUtil.playSoundEvent2d(ref, dragSoundIndex, SoundCategory.UI, store);
            }
         }
      }
   }

      {
         .inputContainer.getItemStack(());
       (item != ) {
            BlockGroup.findItemGroup(item.getItem());
          (set != ) {
               -;

            (   ; i < set.size(); ++i) {
                (set.get(i).equals(item.getItem().getId())) {
                  currentIndex = i;
                  ;
               }
            }

             (currentIndex != -) {
                newIndex;
                (down) {
                  newIndex = (currentIndex -  + set.size()) % set.size();
               }  {
                  newIndex = (currentIndex + ) % set.size();
               }

                  set.get(newIndex);
                  (Item)Item.getAssetMap().getAsset(next);
                (desiredItem != ) {
                  .inputContainer.replaceItemStackInSlot((), item,  (next, item.getQuantity()));
                  .playCraftSound(ref, store, desiredItem);
               }
            }
         }
      }
   }

   
    ItemContainer  {
       .combinedItemContainer;
   }

      {
      .onOpen0();
         .getPlayerRef();
      Ref<EntityStore> ref = playerRef.getReference();
      Store<EntityStore> store = ref.getStore();
         (Player)store.getComponent(ref, Player.getComponentType());
         player.getInventory();
      .inventoryRegistration = inventory.getCombinedHotbarFirst().registerChangeEvent((event) -> {
         .windowData.add(, CraftingManager.generateInventoryHints(CraftingPlugin.getBenchRecipes(.bench), , inventory.getCombinedHotbarFirst()));
         .invalidate();
      });
      .windowData.add(, CraftingManager.generateInventoryHints(CraftingPlugin.getBenchRecipes(.bench), , inventory.getCombinedHotbarFirst()));
       ;
   }

      {
      .onClose0();
         .getPlayerRef();
      Ref<EntityStore> ref = playerRef.getReference();
      Store<EntityStore> store = ref.getStore();
         (Player)store.getComponent(ref, Player.getComponentType());
      List<ItemStack> itemStacks = .inputContainer.dropAllItemStacks();
      SimpleItemContainer.addOrDropItemStacks(store, ref, player.getInventory().getCombinedHotbarFirst(), itemStacks);
         (CraftingManager)store.getComponent(ref, CraftingManager.getComponentType());
      craftingManager.cancelAllCrafting(ref, store);
       (.inventoryRegistration != ) {
         .inventoryRegistration.unregister();
         .inventoryRegistration = ;
      }

   }

      {
      .invalidate();
      .optionsContainer.clear();
      .optionSlotToRecipeMap.clear();
         .inputContainer.getItemStack(());
      ObjectList<CraftingRecipe> matchingRecipes = .getMatchingRecipes(inputStack);
       (matchingRecipes != ) {
            (StructuralCraftingBench).bench;
         sortRecipes(matchingRecipes, structuralBench);

          dividerIndex;
         (dividerIndex = ; dividerIndex < matchingRecipes.size(); ++dividerIndex) {
               (CraftingRecipe)matchingRecipes.get(dividerIndex);
             (!hasHeaderCategory(structuralBench, recipe)) {
               ;
            }
         }

         .windowData.addProperty(, (Number)dividerIndex);
         .optionsContainer.clear();
            ;
            ;

         (   matchingRecipes.size(); i < bound; ++i) {
               (CraftingRecipe)matchingRecipes.get(i);

            (BenchRequirement requirement : match.getBenchRequirement()) {
                (requirement.type == .bench.getType() && requirement.id.equals(.bench.getId())) {
                  List<ItemStack> output = CraftingManager.getOutputItemStacks(match);
                  .optionsContainer.setItemStackForSlot(index, (ItemStack)output.getFirst(), );
                  .optionSlotToRecipeMap.put(index, match.getId());
                  ++index;
               }
            }
         }

             ();

         (   ; i < .optionsContainer.getCapacity(); ++i) {
               (String).optionSlotToRecipeMap.get(i);
             (recipeId != ) {
               optionSlotRecipes.add(recipeId);
            }
         }

         .windowData.add(, optionSlotRecipes);
      }
   }

   
    ObjectList<CraftingRecipe>  {
       (inputStack == ) {
          ;
      }  {
         List<CraftingRecipe> recipes = CraftingPlugin.getBenchRecipes(.bench.getType(), .bench.getId());
          (recipes.isEmpty()) {
             ;
         }  {
            ObjectList<CraftingRecipe> matchingRecipes =  <CraftingRecipe>();
               ;

            (   recipes.size(); i < bound; ++i) {
                  (CraftingRecipe)recipes.get(i);
               List<MaterialQuantity> inputMaterials = CraftingManager.getInputMaterials(recipe);
                (inputMaterials.size() ==  && CraftingManager.matches((MaterialQuantity)inputMaterials.getFirst(), inputStack)) {
                  matchingRecipes.add(recipe);
               }
            }

             (matchingRecipes.isEmpty()) {
                ;
            }  {
                matchingRecipes;
            }
         }
      }
   }
}