ReputationPlugin.java

package com.hypixel.hytale.builtin.adventure.reputation;

import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.builtin.adventure.reputation.assets.ReputationGroup;
import com.hypixel.hytale.builtin.adventure.reputation.assets.ReputationRank;
import com.hypixel.hytale.builtin.adventure.reputation.choices.ReputationRequirement;
import com.hypixel.hytale.builtin.adventure.reputation.command.ReputationCommand;
import com.hypixel.hytale.builtin.adventure.reputation.store.ReputationDataResource;
import com.hypixel.hytale.component.ComponentAccessor;
import com.hypixel.hytale.component.ComponentType;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.component.ResourceType;
import com.hypixel.hytale.component.Store;
import com.hypixel.hytale.math.util.MathUtil;
import com.hypixel.hytale.server.core.asset.HytaleAssetStore;
import com.hypixel.hytale.server.core.asset.type.attitude.Attitude;
import com.hypixel.hytale.server.core.asset.type.gameplay.GameplayConfig;
import com.hypixel.hytale.server.core.entity.entities.Player;
import com.hypixel.hytale.server.core.entity.entities.player.data.PlayerConfigData;
import com.hypixel.hytale.server.core.entity.entities.player.pages.choices.ChoiceRequirement;
import com.hypixel.hytale.server.core.plugin.JavaPlugin;
import com.hypixel.hytale.server.core.plugin.JavaPluginInit;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
 it.unimi.dsi.fastutil.objects.Object2IntMap;
 it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
 it.unimi.dsi.fastutil.objects.ObjectArrayList;
 java.util.Comparator;
 java.util.List;
 java.util.logging.Level;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;

     {
     ReputationPlugin instance;
    ComponentType<EntityStore, ReputationGroupComponent> reputationGroupComponentType;
    ResourceType<EntityStore, ReputationDataResource> reputationDataResourceType;
    List<ReputationRank> reputationRanks;
       -;
       ;
         -;

     ReputationPlugin  {
       instance;
   }

     {
      (init);
   }

    ComponentType<EntityStore, ReputationGroupComponent>  {
       .reputationGroupComponentType;
   }

      {
      instance = ;
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(ReputationRank.class,  ()).setPath()).setCodec(ReputationRank.CODEC)).setKeyFunction(ReputationRank::getId)).build());
      AssetRegistry.register(((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(ReputationGroup.class,  ()).setPath()).setCodec(ReputationGroup.CODEC)).setKeyFunction(ReputationGroup::getId)).build());
      .getCommandRegistry().registerCommand( ());
      ChoiceRequirement.CODEC.register((String), ReputationRequirement.class, ReputationRequirement.CODEC);
      .reputationDataResourceType = .getEntityStoreRegistry().registerResource(ReputationDataResource.class, , ReputationDataResource.CODEC);
      .reputationGroupComponentType = .getEntityStoreRegistry().registerComponent(ReputationGroupComponent.class, () -> {
           ();
      });
      GameplayConfig.PLUGIN_CODEC.register(ReputationGameplayConfig.class, , ReputationGameplayConfig.CODEC);
   }

      {
      .reputationRanks =  <ReputationRank>(ReputationRank.getAssetMap().getAssetMap().values());
       (.reputationRanks.size() > ) {
         .reputationRanks.sort(Comparator.comparingInt(ReputationRank::getMinValue));
            ((ReputationRank).reputationRanks.getFirst()).getMaxValue();

         (   ; i < .reputationRanks.size(); ++i) {
               (ReputationRank).reputationRanks.get(i);
             (previousMaxValue < reputationRank.getMinValue()) {
               .getLogger().at(Level.WARNING).log(, reputationRank.getId(), ((ReputationRank).reputationRanks.get(i - )).getId());
            }

             (previousMaxValue > reputationRank.getMinValue()) {
               .getLogger().at(Level.WARNING).log(, reputationRank.getId(), ((ReputationRank).reputationRanks.get(i - )).getId());
            }

            previousMaxValue = reputationRank.getMaxValue();
         }

         .minReputationValue = ((ReputationRank).reputationRanks.getFirst()).getMinValue();
         .maxReputationValue = ((ReputationRank).reputationRanks.getLast()).getMaxValue();
      }
   }

      {
         (ReputationGroupComponent)componentAccessor.getComponent(npcRef, .reputationGroupComponentType);
       reputationGroupComponent ==  ? - : .changeReputation(player, reputationGroupComponent.getReputationGroupId(), value, componentAccessor);
   }

      {
         ((EntityStore)componentAccessor.getExternalData()).getWorld();
         ReputationGameplayConfig.getOrDefault(world.getGameplayConfig());
       (reputationGameplayConfig.getReputationStorageType() == ReputationGameplayConfig.ReputationStorageType.PerPlayer) {
            (ReputationGroup)ReputationGroup.getAssetMap().getAsset(reputationGroupId);
          (reputationGroup == ) {
             -;
         }  {
               player.getPlayerConfigData();
            Object2IntOpenHashMap<String> reputationData =  <String>(playerConfigData.getReputationData());
               .computeReputation(reputationData, reputationGroup, value);
            playerConfigData.setReputationData(reputationData);
             newReputationValue;
         }
      }  {
          .changeReputation(world, reputationGroupId, value);
      }
   }

      {
         ReputationGameplayConfig.getOrDefault(world.getGameplayConfig());
       (reputationGameplayConfig.getReputationStorageType() != ReputationGameplayConfig.ReputationStorageType.PerWorld) {
          -;
      }  {
            (ReputationGroup)ReputationGroup.getAssetMap().getAsset(reputationGroupId);
          (reputationGroup == ) {
             -;
         }  {
               (ReputationDataResource)world.getEntityStore().getStore().getResource(.reputationDataResourceType);
             .computeReputation(reputationDataResource.getReputationStats(), reputationGroup, value);
         }
      }
   }

      {
       (Integer)reputationData.compute(reputationGroup.getId(), (k, oldValue) -> {
            oldValue ==  ? reputationGroup.getInitialReputationValue() + value : oldValue + value;
          MathUtil.clamp(newValue, .minReputationValue, .maxReputationValue - );
      });
   }

      {
         (ReputationGroupComponent)store.getComponent(npcEntityRef, .reputationGroupComponentType);
       reputationGroupComponent ==  ? - : .getReputationValue(store, playerEntityRef, reputationGroupComponent.getReputationGroupId());
   }

      {
         ((EntityStore)store.getExternalData()).getWorld();
         (Player)store.getComponent(playerEntityRef, Player.getComponentType());
         ReputationGameplayConfig.getOrDefault(world.getGameplayConfig());
       (reputationGameplayConfig.getReputationStorageType() == ReputationGameplayConfig.ReputationStorageType.PerPlayer) {
            (ReputationGroup)ReputationGroup.getAssetMap().getAsset(reputationGroupId);
          (reputationGroup != ) {
            Object2IntMap<String> reputationData = playerComponent.getPlayerConfigData().getReputationData();
             .getReputationValueForGroup(reputationData, reputationGroup);
         }  {
             -;
         }
      }  {
          .getReputationValue(store, reputationGroupId);
      }
   }

      {
         ((ReputationGroupComponent)store.getComponent(npcRef, .reputationGroupComponentType)).getReputationGroupId();
       .getReputationValue(store, reputationGroupId);
   }

      {
         ((EntityStore)store.getExternalData()).getWorld();
         ReputationGameplayConfig.getOrDefault(world.getGameplayConfig());
       (reputationGameplayConfig.getReputationStorageType() != ReputationGameplayConfig.ReputationStorageType.PerWorld) {
          -;
      }  {
            (ReputationGroup)ReputationGroup.getAssetMap().getAsset(reputationGroupId);
          (reputationGroup == ) {
             -;
         }  {
            Object2IntMap<String> reputationData = ((ReputationDataResource)world.getEntityStore().getStore().getResource(.reputationDataResourceType)).getReputationStats();
             .getReputationValueForGroup(reputationData, reputationGroup);
         }
      }
   }

      {
       reputationData.getOrDefault(reputationGroup.getId(), reputationGroup.getInitialReputationValue());
   }

   
    ReputationRank  {
         (ReputationGroupComponent)store.getComponent(npcRef, .reputationGroupComponentType);
       (reputationGroupComponent == ) {
          ;
      }  {
            reputationGroupComponent.getReputationGroupId();
          .getReputationRank(store, ref, reputationGroupId);
      }
   }

   
    ReputationRank  {
         .getReputationValue(store, ref, reputationGroupId);
       .getReputationRankFromValue(value);
   }

   
    ReputationRank  {
       (value == -) {
          ;
      }  {
         (   ; i < .reputationRanks.size(); ++i) {
             (((ReputationRank).reputationRanks.get(i)).containsValue(value)) {
                (ReputationRank).reputationRanks.get(i);
            }
         }

          ;
      }
   }

   
    ReputationRank  {
         ((EntityStore)store.getExternalData()).getWorld();
         ReputationGameplayConfig.getOrDefault(world.getGameplayConfig());
       (reputationGameplayConfig.getReputationStorageType() != ReputationGameplayConfig.ReputationStorageType.PerWorld) {
          ;
      }  {
            .getReputationValue(store, npcRef);
          .getReputationRankFromValue(value);
      }
   }

   
    Attitude  {
         .getReputationRank(store, ref, npc);
       reputationRank !=  ? reputationRank.getAttitude() : ;
   }

   
    Attitude  {
         .getReputationRank(store, npcRef);
       reputationRank !=  ? reputationRank.getAttitude() : ;
   }
}