StateSupport.java

package com.hypixel.hytale.server.npc.role.support;

import com.hypixel.hytale.component.ComponentAccessor;
import com.hypixel.hytale.component.ComponentType;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.component.Store;
import com.hypixel.hytale.protocol.ComponentUpdate;
import com.hypixel.hytale.protocol.ComponentUpdateType;
import com.hypixel.hytale.protocol.GameMode;
import com.hypixel.hytale.server.core.entity.entities.Player;
import com.hypixel.hytale.server.core.entity.group.EntityGroup;
import com.hypixel.hytale.server.core.modules.entity.component.Interactable;
import com.hypixel.hytale.server.core.modules.entity.player.PlayerSettings;
import com.hypixel.hytale.server.core.modules.entity.tracker.EntityTrackerSystems;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import com.hypixel.hytale.server.flock.FlockPlugin;
import com.hypixel.hytale.server.npc.NPCPlugin;
import com.hypixel.hytale.server.npc.asset.builder.BuilderSupport;
import com.hypixel.hytale.server.npc.asset.builder.StateMappingHelper;
import com.hypixel.hytale.server.npc.entities.NPCEntity;
import com.hypixel.hytale.server.npc.role.Role;
import com.hypixel.hytale.server.npc.role.builders.BuilderRole;
import com.hypixel.hytale.server.npc.statetransition.StateTransitionController;
import it.unimi.dsi.fastutil.ints.Int2IntMap;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.IntSet;
 java.util.BitSet;
 java.util.HashMap;
 java.util.HashSet;
 java.util.Iterator;
 java.util.Map;
 java.util.Set;
 java.util.logging.Level;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;

   {
         -;
   
      ComponentType<EntityStore, NPCEntity> NPC_COMPONENT_TYPE = NPCEntity.getComponentType();
     StateMappingHelper stateHelper;
      startState;
      startSubState;
     state;
     subState;
    Int2IntMap componentLocalStateMachines;
    BitSet localStateMachineAutoResetStates;
     Int2ObjectMap<IntSet> busyStates;
     HashSet<String> missingStates =  ();
     needClearOnce;
    Set<Ref<EntityStore>> interactablePlayers;
    Set<Ref<EntityStore>> interactedPlayers;
    Map<Ref<EntityStore>, String> contextualInteractions;
   
    Ref<EntityStore> interactionIterationTarget;
   
     StateTransitionController stateTransitionController;

     {
      .stateHelper = builder.getStateMappingHelper();
      .busyStates = builder.getBusyStates();
      .stateTransitionController = builder.getStateTransitionController(support);
      .startState = builder.getStartStateIndex();
      .startSubState = builder.getStartSubStateIndex();
   }

   
    StateTransitionController  {
       .stateTransitionController;
   }

    StateMappingHelper  {
       .stateHelper;
   }

      {
       (builderSupport.hasComponentLocalStateMachines()) {
         .componentLocalStateMachines = builderSupport.getComponentLocalStateMachines();
         .localStateMachineAutoResetStates = builderSupport.getLocalStateMachineAutoResetStates();
      }

       (builderSupport.isTrackInteractions()) {
         .interactedPlayers =  ();
         .interactablePlayers =  ();
         .contextualInteractions =  ();
      }

       (.busyStates != ) {
            .stateHelper.getDefaultSubState();
         .busyStates.forEach((key, value) -> {
               .stateHelper.getSubStateIndex(key, defaultSubState);
             (value.contains(defaultSubStateIndex) && value.size() == ) {
                  .stateHelper.getHighestSubStateIndex(key);

               (   ; i <= maxIndex; ++i) {
                  value.add(i);
               }
            }

         });
      }

   }

      {
       (.contextualInteractions != ) {
         .contextualInteractions.clear();
      }

       (.interactablePlayers != ) {
         Iterator<Ref<EntityStore>> it = .interactablePlayers.iterator();

         (it.hasNext()) {
            Ref<EntityStore> ref = (Ref)it.next();
             (ref.isValid()) {
                  (Player)componentAccessor.getComponent(ref, Player.getComponentType());
                (playerComponent == ) {
                  it.remove();
               }   (playerComponent.getGameMode() == GameMode.Creative) {
                     (PlayerSettings)componentAccessor.getComponent(ref, PlayerSettings.getComponentType());
                   (playerSettingsComponent ==  || !playerSettingsComponent.creativeSettings().allowNPCDetection()) {
                     it.remove();
                  }
               }
            }
         }
      }

   }

      {
         .needClearOnce;
      .needClearOnce = ;
       ret;
   }

      {
       .state == state;
   }

      {
       .subState == subState;
   }

      {
       .inState(state) && (subState == - || .inSubState(subState));
   }

      {
         .stateHelper.getStateIndex(state);
       (stateIndex < ) {
          ;
      }  {
            .stateHelper.getSubStateIndex(stateIndex, subState);
          subStateIndex >=  && .inState(stateIndex, subStateIndex);
      }
   }

   
    String  {
       .getStateName(.state, .subState);
   }

   
    String  {
         .stateHelper.getStateName(state);
       var10000 +  + .stateHelper.getSubStateName(state, subState);
   }

      {
       .state;
   }

      {
       .subState;
   }

      {
      builder.append(.stateHelper.getStateName(.state)).append().append(.stateHelper.getSubStateName(.state, .subState));
   }

      {
         .state;
      .state = state;
      .subState = subState;
       (clearOnce) {
         .needClearOnce = ;
      }

       (!skipTransition && oldState != state && .stateTransitionController != ) {
         .stateTransitionController.initiateStateTransition(oldState, state);
      }

   }

      {
         .stateHelper.getStateIndex(state);
       (index >= ) {
          (subState == ) {
            subState = .stateHelper.getDefaultSubState();
         }

            .stateHelper.getSubStateIndex(index, subState);
          (subStateIndex >= ) {
            .setState(index, subStateIndex, , );
            ;
         }
      }

       (!.missingStates.add(state)) {
            (NPCEntity)componentAccessor.getComponent(ref, NPCEntity.getComponentType());

          npcComponent != ;

         NPCPlugin.get().getLogger().at(Level.WARNING).log(, state, subState, npcComponent.getRoleName());
      }

   }

      {
         .stateHelper.getSubStateIndex(.state, subState);
       (subStateIndex >= ) {
         .setState(.state, subStateIndex, , );
      }

   }

      {
         .componentLocalStateMachines.get(componentIndex);
       (state == -) {
           ();
      }  {
          state == targetState;
      }
   }

      {
      .componentLocalStateMachines.put(componentIndex, targetState);
   }

      {
       (.localStateMachineAutoResetStates != ) {
         (   .localStateMachineAutoResetStates.nextSetBit(); i >= ; i = .localStateMachineAutoResetStates.nextSetBit(i + )) {
            .componentLocalStateMachines.put(i, );
             (i == ) {
               ;
            }
         }

      }
   }

      {
      Ref<EntityStore> flockReference = FlockPlugin.getFlockReference(ref, componentAccessor);
       (flockReference != ) {
            (EntityGroup)componentAccessor.getComponent(flockReference, EntityGroup.getComponentType());

          entityGroupComponent != ;

         entityGroupComponent.forEachMemberExcludingSelf((member, sender, _state, _substate) -> {
            Store<EntityStore> memberStore = member.getStore();
               (NPCEntity)memberStore.getComponent(member, NPC_COMPONENT_TYPE);
             (npcComponent != ) {
               npcComponent.onFlockSetState(member, _state, _substate, memberStore);
            }
         }, ref, state, subState);
      }
   }

      {
       (.busyStates == ) {
          ;
      }  {
            (IntSet).busyStates.get(.state);
          busySubStates !=  && busySubStates.contains(.subState);
      }
   }

      {
       (.contextualInteractions != ) {
         .contextualInteractions.put(playerRef, context);
      }

   }

      {
         (String).contextualInteractions.get(playerReference);
       contextualInteraction ==  ?  : contextualInteraction.equals(context);
   }

      {
      .interactedPlayers.add(player.getReference());
   }

      {
       .interactedPlayers.remove(playerReference);
   }

      {
       (interactable) {
         .interactablePlayers.add(playerReference);
      }  {
         .interactablePlayers.remove(playerReference);
      }

   }

      {
         .interactablePlayers.contains(playerReference);
       (interactable) {
         .interactablePlayers.add(playerReference);
      }  {
         .interactablePlayers.remove(playerReference);
      }

       (showPrompt) {
            store.getArchetype(entityRef).contains(Interactable.getComponentType());
          (interactable) {
               !wasInteractable && hint != ;
             (!hasComponent) {
               store.ensureComponent(entityRef, Interactable.getComponentType());
               needsHint = hint != ;
            }

             (needsHint) {
               .sendInteractionHintToPlayer(entityRef, playerReference, hint, store);
            }
         }   (hasComponent && .interactablePlayers.isEmpty()) {
            store.removeComponent(entityRef, Interactable.getComponentType());
         }
      }

   }

      {
      EntityTrackerSystems.   (EntityTrackerSystems.EntityViewer)store.getComponent(playerReference, EntityTrackerSystems.EntityViewer.getComponentType());
       (viewerComponent !=  && viewerComponent.visible.contains(entityRef)) {
             ();
         update.type = ComponentUpdateType.Interactable;
         update.interactionHint = hint;
         viewerComponent.queueUpdate(entityRef, update);
      }
   }

      {
      .interactionIterationTarget = playerReference;
   }

   
    Ref<EntityStore>  {
       .interactionIterationTarget;
   }

      {
       .interactablePlayers !=  && .interactablePlayers.contains(playerReference) && !.isInBusyState();
   }

      {
       .stateTransitionController ==  ?  : .stateTransitionController.runTransitionActions(ref, role, dt, store);
   }

      {
       .stateTransitionController !=  && .stateTransitionController.isRunningTransitionActions();
   }

      {
      .setState(.startState, .startSubState, , );
   }
}