class="kw">package com.hypixel.hytale.server.flock;

class="kw">import com.hypixel.hytale.component.AddReason;
class="kw">import com.hypixel.hytale.component.Archetype;
class="kw">import com.hypixel.hytale.component.ArchetypeChunk;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.RemoveReason;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.component.SystemGroup;
class="kw">import com.hypixel.hytale.component.query.Query;
class="kw">import com.hypixel.hytale.component.system.HolderSystem;
class="kw">import com.hypixel.hytale.component.system.RefChangeSystem;
class="kw">import com.hypixel.hytale.component.system.RefSystem;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.protocol.GameMode;
class="kw">import com.hypixel.hytale.server.core.entity.Dirty;
class="kw">import com.hypixel.hytale.server.core.entity.UUIDComponent;
class="kw">import com.hypixel.hytale.server.core.entity.entities.Player;
class="kw">import com.hypixel.hytale.server.core.entity.group.EntityGroup;
class="kw">import com.hypixel.hytale.server.core.modules.entity.EntityModule;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.FromWorldGen;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DamageEventSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.npc.entities.NPCEntity;
class="kw">import com.hypixel.hytale.server.npc.role.Role;
class="kw">import com.hypixel.hytale.server.npc.role.RoleDebugFlags;
class="kw">import com.hypixel.hytale.server.npc.role.support.DebugSupport;
class="kw">import java.util.EnumSet;
class="kw">import java.util.UUID;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class FlockMembershipSystems {
   class="kw">public FlockMembershipSystems() {
   }

   class="kw">public class="kw">static boolean canJoinFlock(@Nonnull Ref<EntityStore> var0, @Nonnull Ref<EntityStore> var1, @Nonnull Store<EntityStore> var2) {
      Flock var3 = var2.getComponent(var1, Flock.getComponentType());
      assert var3 != null;
      PersistentFlockData var4 = var3.getFlockData();
      if (var4 == null) {
         class="kw">return false;
      }

      EntityGroup var5 = var2.getComponent(var1, EntityGroup.getComponentType());
      assert var5 != null;
      if (var5.size() >= var4.getMaxGrowSize()) {
         class="kw">return false;
      }

      NPCEntity var6 = var2.getComponent(var0, NPCEntity.getComponentType());
      if (var6 == null) {
         class="kw">return false;
      }

      String var7 = var6.getRoleName();
      class="kw">return var7 != null && var4.isFlockAllowedRole(var7);
   }

   class="kw">public class="kw">static void join(@Nonnull Ref<EntityStore> var0, @Nonnull Ref<EntityStore> var1, @Nonnull Store<EntityStore> var2) {
      FlockMembership var3 = new FlockMembership();
      UUIDComponent var4 = var2.getComponent(var1, UUIDComponent.getComponentType());
      assert var4 != null;
      var3.setFlockId(var4.getUuid());
      var3.setFlockRef(var1);
      var3.setMembershipType(FlockMembership.Type.JOINING);
      var2.putComponent(var0, FlockMembership.getComponentType(), var3);
   }

   class="kw">private class="kw">static boolean canBecomeLeader(@Nonnull Ref<EntityStore> var0) {
      Store var1 = var0.getStore();
      if (var1.getComponent(var0, Player.getComponentType()) != null) {
         class="kw">return true;
      }

      NPCEntity var2 = var1.getComponent(var0, NPCEntity.getComponentType());
      class="kw">return var2 != null && var2.getRole() != null ? var2.getRole().isCanLeadFlock() : false;
   }

   class="kw">private class="kw">static void markChunkNeedsSaving(@Nonnull Ref<EntityStore> var0, @Nonnull Store<EntityStore> var1) {
      Dirty var2 = var1.getComponent(var0, Dirty.getComponentType());
      if (var2 != null) {
         var2.markDirty();
      }
   }

   class="kw">private class="kw">static void registerFlockDebugListener(
      @Nonnull Ref<EntityStore> var0, @Nonnull FlockMembership var1, @Nonnull Flock var2, @Nonnull ComponentAccessor<EntityStore> var3
   ) {
      NPCEntity var4 = var3.getComponent(var0, NPCEntity.getComponentType());
      if (var4 != null) {
         Role var5 = var4.getRole();
         if (var5 != null) {
            var1.registerAsDebugListener(DebugSupport.get(var0, var3), var2);
         }
      }
   }

   class="kw">private class="kw">static void unregisterFlockDebugListener(
      @Nonnull Ref<EntityStore> var0, @Nonnull FlockMembership var1, @Nonnull Flock var2, @Nonnull ComponentAccessor<EntityStore> var3
   ) {
      NPCEntity var4 = var3.getComponent(var0, NPCEntity.getComponentType());
      if (var4 != null) {
         Role var5 = var4.getRole();
         if (var5 != null) {
            var1.unregisterAsDebugListener(DebugSupport.get(var0, var3), var2);
         }
      }
   }

   class="kw">public class="kw">static class EntityRef class="kw">extends RefSystem<EntityStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, FlockMembership> flockMembershipComponentType;

      class="kw">public EntityRef(@Nonnull ComponentType<EntityStore, FlockMembership> var1) {
         this.flockMembershipComponentType = var1;
      }

      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.flockMembershipComponentType;
      }

      @Override
      class="kw">public void onEntityAdded(
         @Nonnull Ref<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         var4.run(var2x -> this.joinOrCreateFlock(var1, var2x));
      }

      class="kw">private void joinOrCreateFlock(@Nonnull Ref<EntityStore> var1, @Nonnull Store<EntityStore> var2) {
         FlockMembership var3 = var2.getComponent(var1, this.flockMembershipComponentType);
         assert var3 != null;
         UUID var4 = var3.getFlockId();
         Ref var7 = var2.getExternalData().getRefFromUUID(var4);
         EntityGroup var5;
         Flock var6;
         if (var7 != null) {
            var5 = var2.getComponent(var7, EntityGroup.getComponentType());
            assert var5 != null;
            var6 = var2.getComponent(var7, Flock.getComponentType());
            assert var6 != null;
         } else {
            var5 = new EntityGroup();
            var6 = new Flock();
            Holder var8 = EntityStore.REGISTRY.newHolder();
            var8.addComponent(UUIDComponent.getComponentType(), new UUIDComponent(var4));
            var8.addComponent(EntityGroup.getComponentType(), var5);
            var8.addComponent(Flock.getComponentType(), var6);
            var7 = var2.addEntity(var8, AddReason.LOAD);
         }

         var3.setFlockRef(var7);
         if (var5.isMember(var1)) {
            throw new IllegalStateException(String.format("Entity %s attempting to reload into group with ID %s despite already being a member", var1, var4));
         }

         var5.add(var1);
         FlockMembershipSystems.registerFlockDebugListener(var1, var3, var6, var2);
         if (var3.getMembershipType() == FlockMembership.Type.LEADER) {
            PersistentFlockData var11 = var2.getComponent(var1, PersistentFlockData.getComponentType());
            if (var11 != null) {
               var6.setFlockData(var11);
            } else {
               PersistentFlockData var9 = var6.getFlockData();
               if (var9 != null) {
                  var2.putComponent(var1, PersistentFlockData.getComponentType(), var9);
               }
            }

            Ref var12 = var5.getLeaderRef();
            var5.setLeaderRef(var1);
            if (var12 != null && !var12.equals(var1)) {
               FlockMembership var10 = var2.getComponent(var12, this.flockMembershipComponentType);
               if (var10 != null) {
                  var10.setMembershipType(FlockMembership.Type.MEMBER);
               }

               var2.tryRemoveComponent(var12, PersistentFlockData.getComponentType());
               FlockMembershipSystems.markChunkNeedsSaving(var12, var2);
            }

            markNeedsSave(var1, var2, var6);
            if (var6.isTrace()) {
               FlockPlugin.get().getLogger().at(Level.INFO).log("Flock %s: Set new leader, old=%s, new=%s, size=%s", var4, var12, var1, var5.size());
            }
         } else if (var5.getLeaderRef() == null) {
            setInterimLeader(var2, var3, var5, var1, var6, var4);
         }

         if (var6.isTrace()) {
            FlockPlugin.get().getLogger().at(Level.INFO).log("Flock %s: reference=%s, size=%s", var4, var1, var5.size());
         }
      }

      @Override
      class="kw">public void onEntityRemove(
         @Nonnull Ref<EntityStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         FlockMembership var5 = var3.getComponent(var1, this.flockMembershipComponentType);
         assert var5 != null;
         Ref var6 = var5.getFlockRef();
         if (var6 != null && var6.isValid()) {
            Flock var7 = var4.getComponent(var6, Flock.getComponentType());
            assert var7 != null;
            EntityGroup var8 = var4.getComponent(var6, EntityGroup.getComponentType());
            assert var8 != null;
            if (var8.isMember(var1)) {
               UUIDComponent var9 = var4.getComponent(var6, UUIDComponent.getComponentType());
               assert var9 != null;
               UUID var10 = var9.getUuid();
               if (var2 == RemoveReason.REMOVE || var3.getArchetype(var1).contains(Player.getComponentType())) {
                  FlockMembershipSystems.unregisterFlockDebugListener(var1, var5, var7, var3);
                  var8.remove(var1);
                  if (var7.isTrace()) {
                     FlockPlugin.get()
                        .getLogger()
                        .at(Level.INFO)
                        .log("Flock %s: Left flock, reference=%s, leader=%s, size=%s", var10, var1, var8.getLeaderRef(), var8.size());
                  }

                  if (!var8.isDissolved() && var8.size() < 2) {
                     var4.removeEntity(var6, RemoveReason.REMOVE);
                     class="kw">return;
                  }

                  if (var8.isDissolved()) {
                     class="kw">return;
                  }

                  PersistentFlockData var15 = var7.getFlockData();
                  if (var15 != null) {
                     var15.decreaseSize();
                  }

                  Ref var16 = var8.getLeaderRef();
                  if (var16 != null && !var16.equals(var1)) {
                     FlockMembershipSystems.markChunkNeedsSaving(var16, var3);
                     class="kw">return;
                  }

                  Ref var13 = var8.testMembers(FlockMembershipSystems::canBecomeLeader, true);
                  if (var13 == null) {
                     if (var7.isTrace()) {
                        FlockPlugin.get()
                           .getLogger()
                           .at(Level.INFO)
                           .log("Flock %s: Leave failed to get new leader, reference=%s, leader=%s, size=%s", var10, var1, var8.getLeaderRef(), var8.size());
                     }

                     var4.removeEntity(var6, RemoveReason.REMOVE);
                     class="kw">return;
                  }

                  var8.setLeaderRef(var13);
                  FlockMembership var14 = var3.getComponent(var13, this.flockMembershipComponentType);
                  assert var14 != null;
                  var14.setMembershipType(FlockMembership.Type.LEADER);
                  if (var15 != null) {
                     var4.putComponent(var13, PersistentFlockData.getComponentType(), var15);
                  }

                  markNeedsSave(var13, var3, var7);
                  if (var7.isTrace()) {
                     FlockPlugin.get().getLogger().at(Level.INFO).log("Flock %s: Set new leader, old=%s, new=%s, size=%s", var10, var1, var13, var8.size());
                  }
               } else if (var2 == RemoveReason.UNLOAD) {
                  FlockMembershipSystems.unregisterFlockDebugListener(var1, var5, var7, var3);
                  var8.remove(var1);
                  if (!var8.isDissolved() && var5.getMembershipType().isActingAsLeader()) {
                     Ref var11 = var8.testMembers(var0 -> true, true);
                     if (var11 != null) {
                        FlockMembership var12 = var3.getComponent(var11, this.flockMembershipComponentType);
                        if (var12 == null) {
                           throw new IllegalStateException("Member is missing FlockMembership component!");
                        }

                        setInterimLeader(var3, var12, var8, var11, var7, var10);
                     }
                  }

                  var5.unload();
                  if (var8.size() <= 0) {
                     var4.tryRemoveEntity(var6, RemoveReason.UNLOAD);
                  }

                  if (var7.isTrace()) {
                     FlockPlugin.get()
                        .getLogger()
                        .at(Level.INFO)
                        .log("Flock %s: Unloaded from flock, reference=%s, leader=%s, size=%s", var10, var1, var8.getLeaderRef(), var8.size());
                  }
               }
            }
         }
      }

      class="kw">private class="kw">static void markNeedsSave(@Nonnull Ref<EntityStore> var0, @Nonnull Store<EntityStore> var1, @Nonnull Flock var2) {
         NPCEntity var3 = var1.getComponent(var0, NPCEntity.getComponentType());
         if (var3 != null) {
            Role var4 = var3.getRole();
            if (var4 != null) {
               EnumSet var5 = DebugSupport.get(var0, var1).getDebugFlags();
               var2.setTrace(var5.contains(RoleDebugFlags.Flock));
            }
         }

         FlockMembershipSystems.markChunkNeedsSaving(var0, var1);
      }

      class="kw">private class="kw">static void setInterimLeader(
         @Nonnull Store<EntityStore> var0,
         @Nonnull FlockMembership var1,
         @Nonnull EntityGroup var2,
         Ref<EntityStore> var3,
         @Nonnull Flock var4,
         @Nonnull UUID var5
      ) {
         var1.setMembershipType(FlockMembership.Type.INTERIM_LEADER);
         var2.setLeaderRef(var3);
         markNeedsSave(var3, var0, var4);
         if (var4.isTrace()) {
            FlockPlugin.get()
               .getLogger()
               .at(Level.INFO)
               .log("Flock %s: Set new interim leader, old=%s, new=%s, size=%s", var5, var2.getLeaderRef(), var3, var2.size());
         }
      }
   }

   class="kw">public class="kw">static class FilterPlayerFlockDamageSystem class="kw">extends DamageEventSystem {
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query = Query.and(Player.getComponentType(), FlockMembership.getComponentType());

      class="kw">public FilterPlayerFlockDamageSystem() {
      }

      @Nullable
      @Override
      class="kw">public SystemGroup<EntityStore> getGroup() {
         class="kw">return DamageModule.get().getFilterDamageGroup();
      }

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.query;
      }

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         FlockMembership var6 = var2.getComponent(var1, FlockMembership.getComponentType());
         assert var6 != null;
         if (var5.getSource() class="kw">instanceof Damage.EntitySource var7) {
            Ref var11 = var6.getFlockRef();
            if (var11 != null && var11.isValid()) {
               Ref var9 = var7.getRef();
               if (var9.isValid()) {
                  EntityGroup var10 = var3.getComponent(var11, EntityGroup.getComponentType());
                  if (var10 != null && var10.isMember(var9)) {
                     var5.setCancelled(true);
                  }
               }
            }
         }
      }
   }

   class="kw">public class="kw">static class NPCAddedFromWorldGen class="kw">extends HolderSystem<EntityStore> {
      @Nullable
      class="kw">private class="kw">final ComponentType<EntityStore, NPCEntity> npcComponentType = NPCEntity.getComponentType();
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, FromWorldGen> fromWorldGenComponentType = FromWorldGen.getComponentType();
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, FlockMembership> flockMembershipComponentType = FlockMembership.getComponentType();
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query = Query.and(this.npcComponentType, this.fromWorldGenComponentType, this.flockMembershipComponentType);

      class="kw">public NPCAddedFromWorldGen() {
      }

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.query;
      }

      @Nullable
      @Override
      class="kw">public SystemGroup<EntityStore> getGroup() {
         class="kw">return EntityModule.get().getPreClearMarkersGroup();
      }

      @Override
      class="kw">public void onEntityAdd(@Nonnull Holder<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3) {
         var1.removeComponent(this.flockMembershipComponentType);
      }

      @Override
      class="kw">public void onEntityRemoved(@Nonnull Holder<EntityStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<EntityStore> var3) {
      }
   }

   class="kw">public class="kw">static class OnDamageDealt class="kw">extends DamageEventSystem {
      class="kw">public OnDamageDealt() {
      }

      @Nullable
      @Override
      class="kw">public SystemGroup<EntityStore> getGroup() {
         class="kw">return DamageModule.get().getInspectDamageGroup();
      }

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return Archetype.empty();
      }

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         if (var5.getSource() class="kw">instanceof Damage.EntitySource var6) {
            Ref var12 = var6.getRef();
            if (var12.isValid()) {
               FlockMembership var8 = var4.getComponent(var12, FlockMembership.getComponentType());
               if (var8 != null) {
                  Ref var9 = var8.getFlockRef();
                  if (var9 != null && var9.isValid()) {
                     Flock var10 = var4.getComponent(var9, Flock.getComponentType());
                     assert var10 != null;
                     Ref var11 = var2.getReferenceTo(var1);
                     var10.getNextDamageData().onInflictedDamage(var11, var5.getAmount());
                     if (var8.getMembershipType().isActingAsLeader()) {
                        var10.getNextLeaderDamageData().onInflictedDamage(var11, var5.getAmount());
                     }
                  }
               }
            }
         }
      }
   }

   class="kw">public class="kw">static class OnDamageReceived class="kw">extends DamageEventSystem {
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query = FlockMembership.getComponentType();

      class="kw">public OnDamageReceived() {
      }

      @Nullable
      @Override
      class="kw">public SystemGroup<EntityStore> getGroup() {
         class="kw">return DamageModule.get().getInspectDamageGroup();
      }

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.query;
      }

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         FlockMembership var6 = var2.getComponent(var1, FlockMembership.getComponentType());
         if (var6 != null) {
            Ref var7 = var6.getFlockRef();
            if (var7 != null && var7.isValid()) {
               Flock var8 = var4.getComponent(var7, Flock.getComponentType());
               assert var8 != null;
               var8.getNextDamageData().onSufferedDamage(var4, var5);
               if (var6.getMembershipType().isActingAsLeader()) {
                  var8.getNextLeaderDamageData().onSufferedDamage(var4, var5);
               }
            }
         }
      }
   }

   class="kw">public class="kw">static class RefChange class="kw">extends RefChangeSystem<EntityStore, FlockMembership> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, FlockMembership> flockMembershipComponentType;

      class="kw">public RefChange(@Nonnull ComponentType<EntityStore, FlockMembership> var1) {
         this.flockMembershipComponentType = var1;
      }

      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.flockMembershipComponentType;
      }

      @Nonnull
      @Override
      class="kw">public ComponentType<EntityStore, FlockMembership> componentType() {
         class="kw">return this.flockMembershipComponentType;
      }

      class="kw">public void onComponentAdded(
         @Nonnull Ref<EntityStore> var1, @Nonnull FlockMembership var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         this.doJoin(var1, var2, var3, var4);
      }

      class="kw">public void onComponentSet(
         @Nonnull Ref<EntityStore> var1,
         FlockMembership var2,
         @Nonnull FlockMembership var3,
         @Nonnull Store<EntityStore> var4,
         @Nonnull CommandBuffer<EntityStore> var5
      ) {
         assert var2 != null;
         if (var2.getMembershipType() == FlockMembership.Type.JOINING) {
            this.doJoin(var1, var3, var4, var5);
         } else {
            doLeave(var1, var2, var4, var5);
            var5.run(var5x -> this.doJoin(var1, var3, var4, var5));
         }
      }

      class="kw">public void onComponentRemoved(
         @Nonnull Ref<EntityStore> var1, @Nonnull FlockMembership var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         if (var2.getMembershipType() != FlockMembership.Type.JOINING) {
            doLeave(var1, var2, var3, var4);
         }
      }

      class="kw">private void doJoin(
         @Nonnull Ref<EntityStore> var1, @Nonnull FlockMembership var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         Ref var5 = var2.getFlockRef();
         if (var5 != null) {
            if (!var5.isValid()) {
               ((HytaleLogger.Api)FlockPlugin.get().getLogger().atWarning()).log("Entity %s attempting to join invalid flock with ref %s", var1, var5);
               var4.removeComponent(var1, this.flockMembershipComponentType);
            } else {
               Flock var6 = var4.getComponent(var5, Flock.getComponentType());
               assert var6 != null;
               EntityGroup var7 = var4.getComponent(var5, EntityGroup.getComponentType());
               assert var7 != null;
               UUIDComponent var8 = var4.getComponent(var5, UUIDComponent.getComponentType());
               assert var8 != null;
               UUID var9 = var8.getUuid();
               if (!var7.isMember(var1)) {
                  if (var2.getMembershipType() != FlockMembership.Type.JOINING) {
                     throw new IllegalStateException(
                        String.format("Entity %s attempting to join group with ID %s but has wrong membership status %s", var1, var9, var2.getMembershipType())
                     );
                  }

                  boolean var10 = var3.getArchetype(var1).contains(DeathComponent.getComponentType());
                  if (var1.isValid() && !var10) {
                     Player var11 = var4.getComponent(var1, Player.getComponentType());
                     if (var11 != null && var11.getGameMode() != GameMode.Adventure) {
                        if (var6.isTrace()) {
                           FlockPlugin.get().getLogger().at(Level.INFO).log("Flock %s: Failed to join, ref=%s. Player in creative mode.", var9, var1);
                        }

                        var4.removeComponent(var1, this.flockMembershipComponentType);
                     } else {
                        PersistentFlockData var12 = var6.getFlockData();
                        if (var12 == null) {
                           if (var6.isTrace()) {
                              FlockPlugin.get()
                                 .getLogger()
                                 .at(Level.INFO)
                                 .log("Flock %s: Rejected join entity due to leader not being loaded, ref=%s, size=%s", var9, var1, var7.size());
                           }

                           var4.removeComponent(var1, this.flockMembershipComponentType);
                        } else {
                           Ref var13 = var7.getLeaderRef();
                           boolean var14 = var13 == null;
                           boolean var15 = var14;
                           if (var11 != null) {
                              if (var13 != null && var3.getComponent(var13, Player.getComponentType()) != null) {
                                 if (var6.isTrace()) {
                                    FlockPlugin.get()
                                       .getLogger()
                                       .at(Level.INFO)
                                       .log("Flock %s: Failed join 2 players, ref=%s, size=%s", var9, var1, var7.size());
                                 }

                                 var4.removeComponent(var1, this.flockMembershipComponentType);
                                 class="kw">return;
                              }

                              var14 = true;
                           }

                           var7.add(var1);
                           FlockMembershipSystems.registerFlockDebugListener(var1, var2, var6, var3);
                           if (var14) {
                              setNewLeader(var9, var7, var6, var1, var3, var4);
                              if (var15 && var6.isTrace()) {
                                 FlockPlugin.get().getLogger().at(Level.INFO).log("Flock %s: Joined no leader, ref=%s, size=%s", var9, var1, var7.size());
                              }
                           } else {
                              var2.setMembershipType(FlockMembership.Type.MEMBER);
                           }

                           var12.increaseSize();
                           FlockMembershipSystems.markChunkNeedsSaving(var7.getLeaderRef(), var3);
                           if (var6.isTrace()) {
                              FlockPlugin.get().getLogger().at(Level.INFO).log("Flock %s: Joined join ref=%s, size=%s", var9, var1, var7.size());
                           }

                           FlockMembershipSystems.markChunkNeedsSaving(var1, var3);
                        }
                     }
                  } else {
                     if (var6.isTrace()) {
                        FlockPlugin.get().getLogger().at(Level.INFO).log("Flock %s: Failed to join entity ref=%s, size=%s", var9, var1, var7.size());
                     }

                     var4.removeComponent(var1, this.flockMembershipComponentType);
                  }
               }
            }
         }
      }

      class="kw">private class="kw">static void doLeave(
         @Nonnull Ref<EntityStore> var0, @Nonnull FlockMembership var1, @Nonnull Store<EntityStore> var2, @Nonnull CommandBuffer<EntityStore> var3
      ) {
         Ref var4 = var1.getFlockRef();
         if (var4 != null && var4.isValid()) {
            Flock var5 = var3.getComponent(var4, Flock.getComponentType());
            assert var5 != null;
            EntityGroup var6 = var3.getComponent(var4, EntityGroup.getComponentType());
            assert var6 != null;
            UUIDComponent var7 = var3.getComponent(var4, UUIDComponent.getComponentType());
            assert var7 != null;
            UUID var8 = var7.getUuid();
            FlockMembershipSystems.unregisterFlockDebugListener(var0, var1, var5, var2);
            var6.remove(var0);
            if (var5.isTrace()) {
               FlockPlugin.get()
                  .getLogger()
                  .at(Level.INFO)
                  .log("Flock %s: Left flock, reference=%s, leader=%s, size=%s", var8, var0, var6.getLeaderRef(), var6.size());
            }

            if (!var6.isDissolved() && var6.size() < 2) {
               var3.removeEntity(var4, RemoveReason.REMOVE);
            } else if (!var6.isDissolved()) {
               PersistentFlockData var9 = var5.getFlockData();
               if (var9 != null) {
                  var9.decreaseSize();
               }

               Ref var10 = var6.getLeaderRef();
               if (var10 != null && !var0.equals(var10)) {
                  FlockMembershipSystems.markChunkNeedsSaving(var10, var2);
               } else {
                  Ref var11 = var6.testMembers(FlockMembershipSystems::canBecomeLeader, true);
                  if (var11 == null) {
                     if (var5.isTrace()) {
                        FlockPlugin.get()
                           .getLogger()
                           .at(Level.INFO)
                           .log("Flock %s: Leave failed to get new leader, reference=%s, leader=%s, size=%s", var8, var0, var6.getLeaderRef(), var6.size());
                     }

                     var3.removeEntity(var4, RemoveReason.REMOVE);
                     class="kw">return;
                  }

                  setNewLeader(var8, var6, var5, var11, var2, var3);
               }
            }
         }
      }

      class="kw">private class="kw">static void setNewLeader(
         @Nonnull UUID var0,
         @Nonnull EntityGroup var1,
         @Nonnull Flock var2,
         @Nonnull Ref<EntityStore> var3,
         @Nonnull Store<EntityStore> var4,
         @Nonnull CommandBuffer<EntityStore> var5
      ) {
         Ref var6 = var1.getLeaderRef();
         if (var6 == null || !var6.equals(var3)) {
            var1.setLeaderRef(var3);
            if (var6 != null) {
               FlockMembership var7 = var4.getComponent(var6, FlockMembership.getComponentType());
               if (var7 != null) {
                  var7.setMembershipType(FlockMembership.Type.MEMBER);
               }

               var5.tryRemoveComponent(var6, PersistentFlockData.getComponentType());
               FlockMembershipSystems.markChunkNeedsSaving(var6, var4);
            }

            FlockMembership var11 = var4.getComponent(var3, FlockMembership.getComponentType());
            assert var11 != null;
            var11.setMembershipType(FlockMembership.Type.LEADER);
            NPCEntity var8 = var4.getComponent(var3, NPCEntity.getComponentType());
            if (var8 != null) {
               Role var9 = var8.getRole();
               if (var9 != null) {
                  EnumSet var10 = DebugSupport.get(var3, var4).getDebugFlags();
                  var2.setTrace(var10.contains(RoleDebugFlags.Flock));
               }
            }

            PersistentFlockData var12 = var2.getFlockData();
            if (var12 != null) {
               var5.putComponent(var3, PersistentFlockData.getComponentType(), var12);
            }

            FlockMembershipSystems.markChunkNeedsSaving(var3, var4);
            if (var2.isTrace()) {
               FlockPlugin.get().getLogger().at(Level.INFO).log("Flock %s: Set new leader, old=%s, new=%s, size=%s", var0, var6, var3, var1.size());
            }
         }
      }
   }
}