DamageData.java

package com.hypixel.hytale.server.npc.util;

import com.hypixel.hytale.component.CommandBuffer;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.math.vector.Vector3d;
import com.hypixel.hytale.protocol.GameMode;
import com.hypixel.hytale.server.core.entity.entities.Player;
import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
import com.hypixel.hytale.server.core.modules.entity.player.PlayerSettings;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import it.unimi.dsi.fastutil.doubles.DoubleBinaryOperator;
import it.unimi.dsi.fastutil.objects.Object2DoubleMap;
import it.unimi.dsi.fastutil.objects.Object2DoubleOpenHashMap;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class DamageData {
   private final Map<Ref<EntityStore>, Vector3d> kills = new HashMap();
   private final Object2DoubleMap<Ref<EntityStore>> damageInflicted = new Object2DoubleOpenHashMap<Ref<EntityStore>>();
   private final Object2DoubleMap<Ref<EntityStore>> damageSuffered = new <Ref<EntityStore>>();
     Object2DoubleMap<DamageCause> damageByCause =  <DamageCause>();
     maxDamageSuffered;
     maxDamageInflicted;
   
    Ref<EntityStore> mostPersistentAttacker;
   
    Ref<EntityStore> mostDamagedVictim;

     {
      .reset();
   }

      {
      .kills.clear();
      .damageInflicted.clear();
      .damageSuffered.clear();
      .damageByCause.clear();
      .maxDamageInflicted = ;
      .maxDamageSuffered = ;
      .mostPersistentAttacker = ;
      .mostDamagedVictim = ;
   }

      {
         .damageInflicted.mergeDouble(target, amount, (DoubleBinaryOperator)(Double::sum));
       (d > .maxDamageInflicted) {
         .maxDamageInflicted = d;
         .mostDamagedVictim = target;
      }

   }

      {
      .damageByCause.mergeDouble(damage.getCause(), ()damage.getAmount(), (DoubleBinaryOperator)(Double::sum));
       (damage.getSource()  Damage.EntitySource) {
         Ref<EntityStore> ref = ((Damage.EntitySource)damage.getSource()).getRef();
          (ref.isValid()) {
               (Player)commandBuffer.getComponent(ref, Player.getComponentType());
             (playerComponent !=  && playerComponent.getGameMode() == GameMode.Creative) {
                  (PlayerSettings)commandBuffer.getComponent(ref, PlayerSettings.getComponentType());
                (playerSettingsComponent ==  || !playerSettingsComponent.creativeSettings().allowNPCDetection()) {
                  ;
               }
            }

               .damageSuffered.mergeDouble(ref, ()damage.getAmount(), (DoubleBinaryOperator)(Double::sum));
             (damageByEntity > .maxDamageSuffered) {
               .maxDamageSuffered = damageByEntity;
               .mostPersistentAttacker = ref;
            }

         }
      }
   }

      {
      .kills.put(victim, position);
   }

      {
       !.kills.isEmpty();
   }

      {
       .kills.containsKey(entity);
   }

   
    Ref<EntityStore>  {
       (.kills.isEmpty()) {
          ;
      }  {
         (Ref<EntityStore> kill : .kills.keySet()) {
             (kill.isValid()) {
                kill;
            }
         }

          ;
      }
   }

    Vector3d  {
       (Vector3d).kills.get(entity);
   }

      {
       .maxDamageInflicted;
   }

      {
       .maxDamageSuffered;
   }

      {
       .damageByCause.getDouble(cause);
   }

      {
       .damageByCause.containsKey(cause);
   }

   
    Ref<EntityStore>  {
       .mostDamagedVictim !=  && .mostDamagedVictim.isValid() ? .mostDamagedVictim : ;
   }

   
    Ref<EntityStore>  {
       .mostPersistentAttacker !=  && .mostPersistentAttacker.isValid() ? .mostPersistentAttacker : ;
   }

   
    Ref<EntityStore>  {
       (.damageSuffered.isEmpty()) {
          ;
      }  {
         (Ref<EntityStore> attacker : .damageSuffered.keySet()) {
             (attacker.isValid()) {
                attacker;
            }
         }

          ;
      }
   }

   
    DamageData  {
          ();
      damageData.kills.putAll(.kills);
      damageData.damageInflicted.putAll(.damageInflicted);
      damageData.damageSuffered.putAll(.damageSuffered);
      damageData.damageByCause.putAll(.damageByCause);
      damageData.maxDamageSuffered = .maxDamageSuffered;
      damageData.maxDamageInflicted = .maxDamageInflicted;
      damageData.mostPersistentAttacker = .mostPersistentAttacker;
      damageData.mostDamagedVictim = .mostDamagedVictim;
       damageData;
   }

   
    String  {
         String.valueOf(.kills);
        + var10000 +  + String.valueOf(.damageInflicted) +  + String.valueOf(.damageSuffered) +  + String.valueOf(.damageByCause) +  + .maxDamageSuffered +  + .maxDamageInflicted +  + String.valueOf(.mostPersistentAttacker) +  + String.valueOf(.mostDamagedVictim) + ;
   }
}