Пакеты / com.hypixel.hytale.server.core.modules.entity / LegacyEntityRefSystem

LegacyEntityRefSystem class

Пакет: com.hypixel.hytale.server.core.modules.entity

Файл: com/hypixel/hytale/server/core/modules/entity/EntityModule.java

extends: RefSystem<EntityStore>

Поля (2)

МодификаторыТипИмя
private final ComponentType<EntityStore, T> componentType
Entity var5

Методы (5)

МодификаторыВозвратСигнатура
public Set<Dependency<EntityStore>> getDependenciespublic Set<Dependency<EntityStore>> getDependencies()
public Query<EntityStore> getQuerypublic Query<EntityStore> getQuery()
public void onEntityAddedpublic void onEntityAdded(@Nonnull Ref<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4)
public void onEntityRemovepublic void onEntityRemove(@Nonnull Ref<EntityStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4)
public String toStringpublic String toString()

Исходный код

Показать/скрыть 
class="kw">package com.hypixel.hytale.server.core.modules.entity;

class="kw">import com.hypixel.hytale.assetstore.AssetRegistry;
class="kw">import com.hypixel.hytale.assetstore.event.LoadedAssetsEvent;
class="kw">import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
class="kw">import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
class="kw">import com.hypixel.hytale.codec.DirectDecodeCodec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.common.plugin.PluginManifest;
class="kw">import com.hypixel.hytale.component.AddReason;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.ComponentRegistryProxy;
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.ResourceType;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.component.SystemGroup;
class="kw">import com.hypixel.hytale.component.SystemType;
class="kw">import com.hypixel.hytale.component.dependency.Dependency;
class="kw">import com.hypixel.hytale.component.dependency.Order;
class="kw">import com.hypixel.hytale.component.dependency.RootDependency;
class="kw">import com.hypixel.hytale.component.dependency.SystemDependency;
class="kw">import com.hypixel.hytale.component.query.Query;
class="kw">import com.hypixel.hytale.component.spatial.KDTree;
class="kw">import com.hypixel.hytale.component.spatial.SpatialResource;
class="kw">import com.hypixel.hytale.component.system.HolderSystem;
class="kw">import com.hypixel.hytale.component.system.ISystem;
class="kw">import com.hypixel.hytale.component.system.RefChangeSystem;
class="kw">import com.hypixel.hytale.component.system.RefSystem;
class="kw">import com.hypixel.hytale.protocol.packets.player.UpdateMovementSettings;
class="kw">import com.hypixel.hytale.server.core.HytaleServer;
class="kw">import com.hypixel.hytale.server.core.Message;
class="kw">import com.hypixel.hytale.server.core.asset.HytaleAssetStore;
class="kw">import com.hypixel.hytale.server.core.asset.type.gameplay.GameplayConfig;
class="kw">import com.hypixel.hytale.server.core.entity.Dirty;
class="kw">import com.hypixel.hytale.server.core.entity.Entity;
class="kw">import com.hypixel.hytale.server.core.entity.EntityRemovalSystem;
class="kw">import com.hypixel.hytale.server.core.entity.EntitySavingSystem;
class="kw">import com.hypixel.hytale.server.core.entity.EntityUtils;
class="kw">import com.hypixel.hytale.server.core.entity.Frozen;
class="kw">import com.hypixel.hytale.server.core.entity.UUIDComponent;
class="kw">import com.hypixel.hytale.server.core.entity.damage.DamageDataComponent;
class="kw">import com.hypixel.hytale.server.core.entity.damage.DamageDataSetupSystem;
class="kw">import com.hypixel.hytale.server.core.entity.effect.EffectControllerComponent;
class="kw">import com.hypixel.hytale.server.core.entity.entities.BlockEntity;
class="kw">import com.hypixel.hytale.server.core.entity.entities.Player;
class="kw">import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.CameraManager;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.data.UniqueItemUsagesComponent;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.movement.MovementConfig;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.movement.MovementManager;
class="kw">import com.hypixel.hytale.server.core.entity.group.EntityGroup;
class="kw">import com.hypixel.hytale.server.core.entity.knockback.KnockbackComponent;
class="kw">import com.hypixel.hytale.server.core.entity.movement.MovementStatesComponent;
class="kw">import com.hypixel.hytale.server.core.entity.movement.MovementStatesSystems;
class="kw">import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
class="kw">import com.hypixel.hytale.server.core.entity.nameplate.NameplateSystems;
class="kw">import com.hypixel.hytale.server.core.entity.reference.PersistentRefCount;
class="kw">import com.hypixel.hytale.server.core.inventory.InventoryComponent;
class="kw">import com.hypixel.hytale.server.core.inventory.InventorySystems;
class="kw">import com.hypixel.hytale.server.core.io.PacketHandler;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CollisionModule;
class="kw">import com.hypixel.hytale.server.core.modules.collision.TangiableEntitySpatialSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.ActiveAnimationComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.AudioComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.BoundingBox;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.BreathingComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.CachedStatsComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.CollisionResultComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.DisplayNameComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.DynamicLight;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.EntityScaleComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.FromPrefab;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.FromPrefabInstance;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.FromWorldGen;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.HeadRotation;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.HealthRegenState;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.HiddenFromAdventurePlayers;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.Intangible;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.Interactable;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.Invulnerable;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.ModelComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.ModelRotateBoundingBoxComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.MovementAudioComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.NPCMarkerComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.NewSpawnComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.PersistentDisplayName;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.PersistentDynamicLight;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.PersistentGameModeType;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.PersistentModel;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.PersistentPrefabPreview;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.PlayerLives;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.PositionDataComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.PrefabPreview;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.PreventEmotes;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.PreventInventoryAccess;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.PropComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.RespondToHit;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.RotateObjectComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.SnapshotBuffer;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.Spectating;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.WorldGenId;
class="kw">import com.hypixel.hytale.server.core.modules.entity.condition.AliveCondition;
class="kw">import com.hypixel.hytale.server.core.modules.entity.condition.ChargingCondition;
class="kw">import com.hypixel.hytale.server.core.modules.entity.condition.CheckPlayerGameModeCondition;
class="kw">import com.hypixel.hytale.server.core.modules.entity.condition.Condition;
class="kw">import com.hypixel.hytale.server.core.modules.entity.condition.EnvironmentCondition;
class="kw">import com.hypixel.hytale.server.core.modules.entity.condition.GlidingCondition;
class="kw">import com.hypixel.hytale.server.core.modules.entity.condition.HasEffectCondition;
class="kw">import com.hypixel.hytale.server.core.modules.entity.condition.InFluidCondition;
class="kw">import com.hypixel.hytale.server.core.modules.entity.condition.IsPlayerCondition;
class="kw">import com.hypixel.hytale.server.core.modules.entity.condition.LogicCondition;
class="kw">import com.hypixel.hytale.server.core.modules.entity.condition.NoDamageTakenCondition;
class="kw">import com.hypixel.hytale.server.core.modules.entity.condition.OutOfCombatCondition;
class="kw">import com.hypixel.hytale.server.core.modules.entity.condition.RegenHealthCondition;
class="kw">import com.hypixel.hytale.server.core.modules.entity.condition.SprintingCondition;
class="kw">import com.hypixel.hytale.server.core.modules.entity.condition.StatCondition;
class="kw">import com.hypixel.hytale.server.core.modules.entity.condition.SuffocatingCondition;
class="kw">import com.hypixel.hytale.server.core.modules.entity.condition.WieldingCondition;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.dynamiclight.DynamicLightSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.gamemode.GameModeTypeSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.hitboxcollision.HitboxCollision;
class="kw">import com.hypixel.hytale.server.core.modules.entity.hitboxcollision.HitboxCollisionConfig;
class="kw">import com.hypixel.hytale.server.core.modules.entity.hitboxcollision.HitboxCollisionConfigPacketGenerator;
class="kw">import com.hypixel.hytale.server.core.modules.entity.hitboxcollision.HitboxCollisionSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.item.DropItemsComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.item.DropItemsSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.item.ItemComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.item.ItemMergeSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.item.ItemPhysicsComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.item.ItemPhysicsSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.item.ItemPrePhysicsSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.item.ItemSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.item.PickupItemComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.item.PickupItemSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.item.PreventItemMerging;
class="kw">import com.hypixel.hytale.server.core.modules.entity.item.PreventPickup;
class="kw">import com.hypixel.hytale.server.core.modules.entity.livingentity.LivingEntityEffectClearChangesSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.livingentity.LivingEntityEffectSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.ApplyRandomSkinPersistedComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.ChunkTracker;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.CreativeEraserSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.KnockbackPredictionSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.KnockbackSimulation;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerCameraAddSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerChunkTrackerSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerHudManagerSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerInput;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerItemEntityPickupSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerMovementManagerSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerProcessMovementSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerSavingSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerSendInventorySystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerSettings;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerSkinComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.prefabpreview.PrefabPreviewSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.repulsion.Repulsion;
class="kw">import com.hypixel.hytale.server.core.modules.entity.repulsion.RepulsionConfig;
class="kw">import com.hypixel.hytale.server.core.modules.entity.repulsion.RepulsionConfigPacketGenerator;
class="kw">import com.hypixel.hytale.server.core.modules.entity.repulsion.RepulsionSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.spectator.SpectatorSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.AudioSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.DisplayNameSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.EntityInteractableSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.EntitySpatialSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.EntitySystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.HideEntitySystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.IntangibleSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.InvulnerableSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.ItemSpatialSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.MarkerReplicationSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.ModelSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.NetworkSendableSpatialSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.PlayerCollisionResultAddSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.PlayerSpatialSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.PreventEmotesSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.PreventInventoryAccessSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.RespondToHitSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.RotateObjectSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.SnapshotSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.TransformSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.UpdateEntitySeedSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.UpdateLocationSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.teleport.PendingTeleport;
class="kw">import com.hypixel.hytale.server.core.modules.entity.teleport.Teleport;
class="kw">import com.hypixel.hytale.server.core.modules.entity.teleport.TeleportRecord;
class="kw">import com.hypixel.hytale.server.core.modules.entity.teleport.TeleportSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.tracker.EntityTrackerSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
class="kw">import com.hypixel.hytale.server.core.modules.physics.component.PhysicsValues;
class="kw">import com.hypixel.hytale.server.core.modules.physics.component.Velocity;
class="kw">import com.hypixel.hytale.server.core.modules.physics.systems.GenericVelocityInstructionSystem;
class="kw">import com.hypixel.hytale.server.core.modules.physics.systems.IVelocityModifyingSystem;
class="kw">import com.hypixel.hytale.server.core.modules.physics.systems.PhysicsValuesAddSystem;
class="kw">import com.hypixel.hytale.server.core.modules.physics.systems.VelocitySystems;
class="kw">import com.hypixel.hytale.server.core.modules.serverplayerlist.ServerPlayerListSystems;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPlugin;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPluginInit;
class="kw">import com.hypixel.hytale.server.core.plugin.PluginState;
class="kw">import com.hypixel.hytale.server.core.prefab.PrefabCopyableComponent;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.Universe;
class="kw">import com.hypixel.hytale.server.core.universe.hardcore.HardcoreGameOver;
class="kw">import com.hypixel.hytale.server.core.universe.hardcore.HardcoreLivesHud;
class="kw">import com.hypixel.hytale.server.core.universe.hardcore.HardcoreState;
class="kw">import com.hypixel.hytale.server.core.universe.resources.UniverseResourceType;
class="kw">import com.hypixel.hytale.server.core.universe.system.PlayerVelocityInstructionSystem;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import java.util.Collections;
class="kw">import java.util.Map;
class="kw">import java.util.Set;
class="kw">import java.util.UUID;
class="kw">import java.util.concurrent.ConcurrentHashMap;
class="kw">import java.util.function.Function;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class EntityModule class="kw">extends JavaPlugin {
   class="kw">public class="kw">static class="kw">final PluginManifest MANIFEST = PluginManifest.corePlugin(EntityModule.class).depends(Universe.class).depends(CollisionModule.class).build();
   class="kw">public class="kw">static class="kw">final String MOUNT_MOVEMENT_SETTINGS_ASSET_ID = "Mount";
   class="kw">private class="kw">static EntityModule instance;
   class="kw">private class="kw">final Map<String, Class<? class="kw">extends Entity>> idMap = new ConcurrentHashMap<>();
   class="kw">private class="kw">final Map<Class<? class="kw">extends Entity>, String> classIdMap = new ConcurrentHashMap<>();
   class="kw">private class="kw">final Map<Class<? class="kw">extends Entity>, Function<World, ? class="kw">extends Entity>> classMap = new ConcurrentHashMap<>();
   class="kw">private class="kw">final Map<Class<? class="kw">extends Entity>, DirectDecodeCodec<? class="kw">extends Entity>> codecMap = new ConcurrentHashMap<>();
   @Deprecated
   class="kw">private class="kw">final Map<Class<? class="kw">extends Entity>, ComponentType<EntityStore, ? class="kw">extends Entity>> classToComponentType = new ConcurrentHashMap<>();
   class="kw">private ComponentType<EntityStore, UUIDComponent> uuidComponentType;
   class="kw">private ComponentType<EntityStore, TransformComponent> transformComponentType;
   class="kw">private ComponentType<EntityStore, HeadRotation> headRotationComponentType;
   class="kw">private ComponentType<EntityStore, NetworkId> networkIdComponentType;
   class="kw">private ComponentType<EntityStore, EntityScaleComponent> entityScaleComponentType;
   class="kw">private ComponentType<EntityStore, Player> playerComponentType;
   class="kw">private ComponentType<EntityStore, MovementManager> movementManagerComponentType;
   class="kw">private ComponentType<EntityStore, CameraManager> cameraManagerComponentType;
   class="kw">private ComponentType<EntityStore, Frozen> frozenComponentType;
   class="kw">private ComponentType<EntityStore, CollisionResultComponent> collisionResultComponentType;
   class="kw">private ComponentType<EntityStore, ChunkTracker> chunkTrackerComponentType;
   class="kw">private ComponentType<EntityStore, ProjectileComponent> projectileComponentType;
   class="kw">private ComponentType<EntityStore, BlockEntity> blockEntityComponentType;
   class="kw">private ComponentType<EntityStore, EffectControllerComponent> effectControllerComponentType;
   class="kw">private ComponentType<EntityStore, RotateObjectComponent> rotateObjectComponentType;
   class="kw">private ComponentType<EntityStore, Dirty> dirtyComponentType;
   class="kw">private ComponentType<EntityStore, ModelComponent> modelComponentType;
   class="kw">private ComponentType<EntityStore, ModelRotateBoundingBoxComponent> modelRotateBoundingBoxComponentType;
   class="kw">private ComponentType<EntityStore, PersistentModel> persistentModelComponentType;
   class="kw">private ComponentType<EntityStore, PropComponent> propComponentType;
   class="kw">private ComponentType<EntityStore, NPCMarkerComponent> npcMarkerComponentType;
   class="kw">private ComponentType<EntityStore, BoundingBox> boundingBoxComponentType;
   class="kw">private ComponentType<EntityStore, PlayerSkinComponent> playerSkinComponentType;
   class="kw">private ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> playerSpatialResourceType;
   class="kw">private ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> entitySpatialResourceType;
   class="kw">private ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> itemSpatialResourceType;
   class="kw">private ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> networkSendableSpatialResourceType;
   class="kw">private ComponentType<EntityStore, DisplayNameComponent> displayNameComponentType;
   class="kw">private ComponentType<EntityStore, PersistentDisplayName> persistentDisplayNameComponentType;
   class="kw">private ComponentType<EntityStore, EntityGroup> entityGroupComponentType;
   class="kw">private ComponentType<EntityStore, MovementStatesComponent> movementStatesComponentType;
   class="kw">private ComponentType<EntityStore, DamageDataComponent> damageDataComponentType;
   class="kw">private ComponentType<EntityStore, KnockbackComponent> knockbackComponentType;
   class="kw">private ComponentType<EntityStore, DespawnComponent> despawnComponentComponentType;
   class="kw">private ComponentType<EntityStore, EntityTrackerSystems.EntityViewer> entityViewerComponentType;
   class="kw">private ComponentType<EntityStore, EntityTrackerSystems.Visible> visibleComponentType;
   class="kw">private ResourceType<EntityStore, SnapshotSystems.SnapshotWorldInfo> snapshotWorldInfoResourceType;
   class="kw">private ComponentType<EntityStore, SnapshotBuffer> snapshotBufferComponentType;
   class="kw">private ComponentType<EntityStore, PersistentRefCount> persistentRefCountComponentType;
   class="kw">private ComponentType<EntityStore, Velocity> velocityComponentType;
   class="kw">private ComponentType<EntityStore, PhysicsValues> physicsValuesComponentType;
   class="kw">private ComponentType<EntityStore, FromPrefab> fromPrefabComponentType;
   class="kw">private ComponentType<EntityStore, FromWorldGen> fromWorldGenComponentType;
   class="kw">private ComponentType<EntityStore, FromPrefabInstance> fromPrefabInstanceComponentType;
   class="kw">private ComponentType<EntityStore, WorldGenId> worldGenIdComponentType;
   class="kw">private ComponentType<EntityStore, Interactable> interactableComponentType;
   class="kw">private ComponentType<EntityStore, Intangible> intangibleComponentType;
   class="kw">private ComponentType<EntityStore, PreventInventoryAccess> preventInventoryAccessComponentType;
   class="kw">private ComponentType<EntityStore, PreventEmotes> preventEmotesComponentType;
   class="kw">private ComponentType<EntityStore, PreventPickup> preventPickupComponentType;
   class="kw">private ComponentType<EntityStore, Invulnerable> invulnerableComponentType;
   class="kw">private ComponentType<EntityStore, RespondToHit> respondToHitComponentType;
   class="kw">private ResourceType<EntityStore, MarkerReplicationSystems.QueueResource> markerReplicationQueueResourceType;
   class="kw">private ComponentType<EntityStore, HiddenFromAdventurePlayers> hiddenFromAdventurePlayerComponentType;
   class="kw">private ComponentType<EntityStore, Spectating> spectatingComponentType;
   class="kw">private ComponentType<EntityStore, PersistentGameModeType> persistentGameModeTypeComponentType;
   class="kw">private ComponentType<EntityStore, PlayerLives> playerLivesComponentType;
   class="kw">private UniverseResourceType<HardcoreState> hardcoreStateResourceType;
   class="kw">private ComponentType<EntityStore, Nameplate> nameplateComponentType;
   class="kw">private ComponentType<EntityStore, HitboxCollision> hitboxCollisionComponentType;
   class="kw">private ComponentType<EntityStore, Repulsion> repulsionComponentType;
   class="kw">private ComponentType<EntityStore, Teleport> teleportComponentType;
   class="kw">private ComponentType<EntityStore, PendingTeleport> pendingTeleportComponentType;
   class="kw">private ComponentType<EntityStore, TeleportRecord> teleportRecordComponentType;
   class="kw">private ComponentType<EntityStore, ApplyRandomSkinPersistedComponent> applyRandomSkinPersistedComponent;
   class="kw">private SystemGroup<EntityStore> preClearMarkersGroup;
   class="kw">private ComponentType<EntityStore, PlayerInput> playerInputComponentType;
   class="kw">private ComponentType<EntityStore, KnockbackSimulation> knockbackSimulationComponentType;
   class="kw">private ComponentType<EntityStore, PlayerSettings> playerSettingsComponentType;
   class="kw">private SystemType<EntityStore, EntityModule.MigrationSystem> migrationSystemType;
   class="kw">private SystemType<EntityStore, ? class="kw">extends ISystem<EntityStore>> velocityModifyingSystemType;
   class="kw">private ComponentType<EntityStore, AudioComponent> audioComponentType;
   class="kw">private ComponentType<EntityStore, MovementAudioComponent> movementAudioComponentType;
   class="kw">private ComponentType<EntityStore, PositionDataComponent> positionDataComponentType;
   class="kw">private ComponentType<EntityStore, ActiveAnimationComponent> activeAnimationComponentType;
   class="kw">private ComponentType<EntityStore, CachedStatsComponent> cachedStatsComponentType;
   class="kw">private ComponentType<EntityStore, BreathingComponent> breathingComponentType;
   class="kw">private ComponentType<EntityStore, NewSpawnComponent> newSpawnComponentType;
   class="kw">private ComponentType<EntityStore, ItemComponent> itemComponentType;
   class="kw">private ComponentType<EntityStore, PickupItemComponent> pickupItemComponentType;
   class="kw">private ComponentType<EntityStore, PreventItemMerging> preventItemMergingType;
   class="kw">private ComponentType<EntityStore, ItemPhysicsComponent> itemPhysicsComponentType;
   class="kw">private ComponentType<EntityStore, DynamicLight> dynamicLightComponentType;
   class="kw">private ComponentType<EntityStore, PersistentDynamicLight> persistentDynamicLightComponentType;
   class="kw">private ComponentType<EntityStore, PrefabPreview> prefabPreviewComponentType;
   class="kw">private ComponentType<EntityStore, PersistentPrefabPreview> persistentPrefabPreviewComponentType;
   class="kw">private ComponentType<EntityStore, PrefabCopyableComponent> prefabCopyableComponentType;
   class="kw">private ComponentType<EntityStore, UniqueItemUsagesComponent> uniqueItemUsagesComponentType;
   class="kw">private ComponentType<EntityStore, InventoryComponent.Storage> storageInventoryComponentType;
   class="kw">private ComponentType<EntityStore, InventoryComponent.Armor> armorInventoryComponentType;
   class="kw">private ComponentType<EntityStore, InventoryComponent.Hotbar> hotbarInventoryComponentType;
   class="kw">private ComponentType<EntityStore, InventoryComponent.Utility> utilityInventoryComponentType;
   class="kw">private ComponentType<EntityStore, InventoryComponent.Backpack> backpackInventoryComponentType;
   class="kw">private ComponentType<EntityStore, InventoryComponent.Tool> toolInventoryComponentType;
   class="kw">private ComponentType<EntityStore, InventoryComponent.Combined> combinedInventoryComponentType;
   class="kw">private ComponentType<EntityStore, DropItemsComponent> dropItemsComponentType;
   class="kw">private ComponentType<EntityStore, HealthRegenState> healthRegenStateComponentType;

   class="kw">public class="kw">static EntityModule get() {
      class="kw">return instance;
   }

   class="kw">public EntityModule(@Nonnull JavaPluginInit var1) {
      super(var1);
      instance = this;
   }

   @Override
   class="kw">protected void setup() {
      ComponentRegistryProxy var1 = this.getEntityStoreRegistry();
      this.physicsValuesComponentType = var1.registerComponent(PhysicsValues.class, PhysicsValues::new);
      this.velocityComponentType = var1.registerComponent(Velocity.class, "Velocity", Velocity.CODEC);
      this.migrationSystemType = var1.registerSystemType(EntityModule.MigrationSystem.class);
      this.velocityModifyingSystemType = var1.registerSystemType(IVelocityModifyingSystem.class);
      this.boundingBoxComponentType = var1.registerComponent(BoundingBox.class, BoundingBox::new);
      this.entityScaleComponentType = var1.registerComponent(EntityScaleComponent.class, "EntityScale", EntityScaleComponent.CODEC);
      this.dirtyComponentType = var1.registerComponent(Dirty.class, Dirty::new);
      this.transformComponentType = var1.registerComponent(TransformComponent.class, "Transform", TransformComponent.CODEC);
      this.headRotationComponentType = var1.registerComponent(HeadRotation.class, "HeadRotation", HeadRotation.CODEC);
      this.uuidComponentType = var1.registerComponent(UUIDComponent.class, "UUID", UUIDComponent.CODEC);
      this.collisionResultComponentType = var1.registerComponent(CollisionResultComponent.class, CollisionResultComponent::new);
      this.networkIdComponentType = var1.registerComponent(NetworkId.class, () -> {
         throw new UnsupportedOperationException("Not implemented");
      });
      this.rotateObjectComponentType = var1.registerComponent(RotateObjectComponent.class, "RotateObject", RotateObjectComponent.CODEC);
      this.effectControllerComponentType = var1.registerComponent(EffectControllerComponent.class, "EffectController", EffectControllerComponent.CODEC);
      this.interactableComponentType = var1.registerComponent(Interactable.class, "Interactable", Interactable.CODEC);
      this.intangibleComponentType = var1.registerComponent(Intangible.class, "Intangible", Intangible.CODEC);
      this.preventInventoryAccessComponentType = var1.registerComponent(PreventInventoryAccess.class, () -> PreventInventoryAccess.INSTANCE);
      this.preventEmotesComponentType = var1.registerComponent(PreventEmotes.class, () -> PreventEmotes.INSTANCE);
      this.preventPickupComponentType = var1.registerComponent(PreventPickup.class, "PreventPickup", PreventPickup.CODEC);
      this.invulnerableComponentType = var1.registerComponent(Invulnerable.class, "Invulnerable", Invulnerable.CODEC);
      this.respondToHitComponentType = var1.registerComponent(RespondToHit.class, "RespondToHit", RespondToHit.CODEC);
      this.applyRandomSkinPersistedComponent = var1.registerComponent(
         ApplyRandomSkinPersistedComponent.class, "ApplyRandomSkinPersisted", ApplyRandomSkinPersistedComponent.CODEC
      );
      this.audioComponentType = var1.registerComponent(AudioComponent.class, AudioComponent::new);
      this.movementAudioComponentType = var1.registerComponent(MovementAudioComponent.class, MovementAudioComponent::new);
      this.positionDataComponentType = var1.registerComponent(PositionDataComponent.class, PositionDataComponent::new);
      this.activeAnimationComponentType = var1.registerComponent(ActiveAnimationComponent.class, ActiveAnimationComponent::new);
      this.cachedStatsComponentType = var1.registerComponent(CachedStatsComponent.class, CachedStatsComponent::new);
      this.breathingComponentType = var1.registerComponent(BreathingComponent.class, BreathingComponent::new);
      this.newSpawnComponentType = var1.registerComponent(NewSpawnComponent.class, () -> {
         throw new UnsupportedOperationException("Not implemented");
      });
      var1.registerSystem(new EntityStore.NetworkIdSystem());
      var1.registerSystem(new EntityStore.UUIDSystem());
      var1.registerSystem(new VelocitySystems.AddSystem(this.velocityComponentType));
      var1.registerSystem(new TangiableEntitySpatialSystem(CollisionModule.get().getTangibleEntitySpatialResourceType()));
      SystemGroup var2 = EntityTrackerSystems.FIND_VISIBLE_ENTITIES_GROUP;
      this.visibleComponentType = var1.registerComponent(EntityTrackerSystems.Visible.class, EntityTrackerSystems.Visible::new);
      var1.registerSystem(new TransformSystems.EntityTrackerUpdate());
      this.blockEntityComponentType = var1.registerComponent(BlockEntity.class, "BlockEntity", BlockEntity.CODEC);
      this.projectileComponentType = var1.registerComponent(ProjectileComponent.class, "ProjectileComponent", ProjectileComponent.CODEC);
      var1.registerSystem(new BlockEntitySystems.Ticking(this.blockEntityComponentType));
      var1.registerSystem(new BlockEntitySystems.BlockEntitySetupSystem(this.blockEntityComponentType));
      var1.registerSystem(
         new BlockEntitySystems.PositionMigrationSystem(this.blockEntityComponentType, this.transformComponentType, this.entityScaleComponentType)
      );
      var1.registerSystem(new LegacyProjectileSystems.OnAddRefSystem());
      var1.registerSystem(new LegacyProjectileSystems.OnAddHolderSystem());
      var1.registerSystem(
         new LegacyProjectileSystems.TickingSystem(
            this.projectileComponentType, this.transformComponentType, this.velocityComponentType, this.boundingBoxComponentType
         )
      );
      var1.registerSystem(new RotateObjectSystem(this.transformComponentType, this.rotateObjectComponentType));
      this.snapshotWorldInfoResourceType = var1.registerResource(SnapshotSystems.SnapshotWorldInfo.class, SnapshotSystems.SnapshotWorldInfo::new);
      this.snapshotBufferComponentType = var1.registerComponent(SnapshotBuffer.class, SnapshotBuffer::new);
      var1.registerSystem(new SnapshotSystems.Add());
      var1.registerSystem(new SnapshotSystems.Resize());
      var1.registerSystem(new SnapshotSystems.Capture());
      var1.registerSystem(new UpdateEntitySeedSystem());
      var1.registerSystem(new EntityModule.LegacyUUIDSystem());
      var1.registerSystem(new EntityModule.LegacyUUIDUpdateSystem());
      var1.registerSystem(new EntitySystems.UnloadEntityFromChunk());
      this.teleportComponentType = var1.registerComponent(Teleport.class, () -> {
         throw new UnsupportedOperationException("Teleport must be created directly");
      });
      this.pendingTeleportComponentType = var1.registerComponent(PendingTeleport.class, PendingTeleport::new);
      this.teleportRecordComponentType = var1.registerComponent(TeleportRecord.class, TeleportRecord::new);
      this.playerComponentType = var1.registerComponent(Player.class, "Player", Player.CODEC);
      this.frozenComponentType = var1.registerComponent(Frozen.class, "Frozen", Frozen.CODEC);
      var1.registerSystem(new PlayerCollisionResultAddSystem(this.playerComponentType, this.collisionResultComponentType));
      this.playerSettingsComponentType = var1.registerComponent(PlayerSettings.class, PlayerSettings::defaults);
      this.movementStatesComponentType = var1.registerComponent(MovementStatesComponent.class, MovementStatesComponent::new);
      var1.registerSystem(new MovementStatesSystems.AddSystem(this.movementStatesComponentType));
      var1.registerSystem(new MovementStatesSystems.PlayerInitSystem(this.playerComponentType, this.movementStatesComponentType));
      var1.registerSystem(new TeleportSystems.MoveSystem());
      var1.registerSystem(new TeleportSystems.PlayerMoveSystem());
      this.modelComponentType = var1.registerComponent(ModelComponent.class, () -> {
         throw new UnsupportedOperationException();
      });
      this.modelRotateBoundingBoxComponentType = var1.registerComponent(
         ModelRotateBoundingBoxComponent.class, "ModelRotateBoundingBox", ModelRotateBoundingBoxComponent.CODEC
      );
      this.persistentModelComponentType = var1.registerComponent(PersistentModel.class, "Model", PersistentModel.CODEC);
      this.propComponentType = var1.registerComponent(PropComponent.class, "Prop", PropComponent.CODEC);
      this.npcMarkerComponentType = var1.registerComponent(NPCMarkerComponent.class, NPCMarkerComponent::get);
      var1.registerSystem(new EntitySavingSystem());
      var1.registerSystem(new EntityRemovalSystem());
      var1.registerSystem(new EntityModule.LegacyEntityHolderSystem<>(this.playerComponentType), true);
      var1.registerSystem(new EntityModule.LegacyEntityRefSystem<>(this.playerComponentType), true);
      this.playerInputComponentType = var1.registerComponent(PlayerInput.class, PlayerInput::new);
      this.knockbackSimulationComponentType = var1.registerComponent(KnockbackSimulation.class, () -> {
         throw new UnsupportedOperationException();
      });
      this.movementManagerComponentType = var1.registerComponent(MovementManager.class, MovementManager::new);
      this.displayNameComponentType = var1.registerComponent(DisplayNameComponent.class, DisplayNameComponent::new);
      this.persistentDisplayNameComponentType = var1.registerComponent(PersistentDisplayName.class, "PersistentDisplayName", PersistentDisplayName.CODEC);
      var1.registerSystem(new DisplayNameSystems.HydrateDisplayName());
      var1.registerSystem(new DisplayNameSystems.MigratePlayerDisplayName());
      var1.registerSystem(new DisplayNameSystems.SyncDisplayName());
      var1.registerSystem(new PlayerSystems.PlayerSpawnedSystem());
      var1.registerSystem(new PlayerSystems.PlayerAddedSystem(this.movementManagerComponentType));
      var1.registerSystem(new PlayerSystems.PlayerRemovedSystem());
      var1.registerSystem(new PlayerSystems.ProcessPlayerInput());
      var1.registerSystem(new PlayerSystems.UpdatePlayerRef());
      var1.registerSystem(new PlayerSystems.BlockPausedMovementSystem());
      var1.registerSystem(new PlayerSystems.KillFeedKillerEventSystem());
      var1.registerSystem(new PlayerSystems.KillFeedDecedentEventSystem());
      var1.registerSystem(new KnockbackPredictionSystems.InitKnockback());
      var1.registerSystem(new KnockbackPredictionSystems.CaptureKnockbackInput());
      var1.registerSystem(new KnockbackPredictionSystems.SimulateKnockback());
      var1.registerSystem(new KnockbackPredictionSystems.ClearOnTeleport());
      var1.registerSystem(new KnockbackPredictionSystems.ClearOnRemove());
      this.preClearMarkersGroup = var1.registerSystemGroup();
      this.playerSkinComponentType = var1.registerComponent(PlayerSkinComponent.class, () -> {
         throw new UnsupportedOperationException("Not implemented");
      });
      this.fromPrefabComponentType = var1.registerComponent(FromPrefab.class, "FromPrefab", FromPrefab.CODEC);
      var1.registerSystem(new EntitySystems.ClearFromPrefabMarker(this.fromPrefabComponentType, this.preClearMarkersGroup));
      this.hiddenFromAdventurePlayerComponentType = var1.registerComponent(
         HiddenFromAdventurePlayers.class, "HiddenFromAdventurePlayer", HiddenFromAdventurePlayers.CODEC
      );
      var1.registerSystem(new PlayerMovementManagerSystems.AssignmentSystem());
      var1.registerSystem(new PlayerMovementManagerSystems.PostAssignmentSystem());
      this.cameraManagerComponentType = var1.registerComponent(CameraManager.class, CameraManager::new);
      var1.registerSystem(new PlayerCameraAddSystem());
      var1.registerSystem(new PlayerHudManagerSystems.InitializeSystem());
      this.fromWorldGenComponentType = var1.registerComponent(FromWorldGen.class, "FromWorldGen", FromWorldGen.CODEC);
      var1.registerSystem(new EntitySystems.ClearFromWorldGenMarker(this.fromWorldGenComponentType, this.preClearMarkersGroup));
      this.fromPrefabInstanceComponentType = var1.registerComponent(FromPrefabInstance.class, "FromPrefabInstance", FromPrefabInstance.CODEC);
      this.worldGenIdComponentType = var1.registerComponent(WorldGenId.class, "WorldGenId", WorldGenId.CODEC);
      var1.registerSystem(new EntitySystems.OnLoadFromExternal(this.fromPrefabComponentType, this.fromWorldGenComponentType, this.preClearMarkersGroup));
      this.playerSpatialResourceType = var1.registerSpatialResource(() -> new KDTree<>(Ref::isValid));
      var1.registerSystem(new PlayerSpatialSystem(this.playerSpatialResourceType));
      this.entitySpatialResourceType = var1.registerSpatialResource(() -> new KDTree<>(Ref::isValid));
      var1.registerSystem(new EntitySpatialSystem(this.entitySpatialResourceType));
      this.despawnComponentComponentType = var1.registerComponent(DespawnComponent.class, "Despawn", DespawnComponent.CODEC);
      this.dynamicLightComponentType = var1.registerComponent(DynamicLight.class, DynamicLight::new);
      this.persistentDynamicLightComponentType = var1.registerComponent(PersistentDynamicLight.class, "DynamicLight", PersistentDynamicLight.CODEC);
      this.prefabPreviewComponentType = var1.registerComponent(PrefabPreview.class, PrefabPreview::new);
      this.persistentPrefabPreviewComponentType = var1.registerComponent(PersistentPrefabPreview.class, "PrefabPreview", PersistentPrefabPreview.CODEC);
      this.preventItemMergingType = var1.registerComponent(PreventItemMerging.class, "PreventItemMerging", PreventItemMerging.CODEC);
      this.itemComponentType = var1.registerComponent(ItemComponent.class, "Item", ItemComponent.CODEC);
      this.itemPhysicsComponentType = var1.registerComponent(ItemPhysicsComponent.class, ItemPhysicsComponent::new);
      var1.registerSystem(new ItemSystems.EnsureRequiredComponents());
      var1.registerSystem(new ItemSystems.TrackerSystem(this.visibleComponentType));
      this.prefabCopyableComponentType = var1.registerComponent(PrefabCopyableComponent.class, "PrefabCopyable", PrefabCopyableComponent.CODEC);
      this.pickupItemComponentType = var1.registerComponent(PickupItemComponent.class, PickupItemComponent::new);
      this.dropItemsComponentType = var1.registerComponent(DropItemsComponent.class, DropItemsComponent::new);
      var1.registerSystem(new DropItemsSystem(this.dropItemsComponentType));
      var1.registerSystem(new DespawnSystem(this.despawnComponentComponentType));
      this.itemSpatialResourceType = var1.registerSpatialResource(() -> new KDTree<>(Ref::isValid));
      var1.registerSystem(new ItemSpatialSystem(this.itemSpatialResourceType));
      var1.registerSystem(new ItemMergeSystem(this.itemComponentType, this.interactableComponentType, this.itemSpatialResourceType));
      var1.registerSystem(new PlayerItemEntityPickupSystem(this.itemComponentType, this.playerComponentType, this.playerSpatialResourceType));
      var1.registerSystem(
         new ItemPrePhysicsSystem(
            this.itemComponentType, this.boundingBoxComponentType, this.velocityComponentType, this.transformComponentType, this.physicsValuesComponentType
         )
      );
      var1.registerSystem(new ItemPhysicsSystem(this.itemPhysicsComponentType, this.velocityComponentType, this.boundingBoxComponentType));
      var1.registerSystem(new PickupItemSystem(this.pickupItemComponentType, this.transformComponentType));
      var1.registerSystem(new LivingEntityEffectSystem());
      var1.registerSystem(new PlayerProcessMovementSystem(this.playerComponentType, this.velocityComponentType, this.collisionResultComponentType));
      this.chunkTrackerComponentType = var1.registerComponent(ChunkTracker.class, ChunkTracker::new);
      var1.registerSystem(new PlayerChunkTrackerSystems.AddSystem());
      var1.registerSystem(new PlayerChunkTrackerSystems.UpdateSystem());
      var1.registerSystem(new PlayerSystems.NameplateRefSystem());
      var1.registerSystem(new PlayerSystems.NameplateRefChangeSystem());
      this.entityViewerComponentType = var1.registerComponent(EntityTrackerSystems.EntityViewer.class, () -> {
         throw new UnsupportedOperationException("not supported");
      });
      var1.registerSystem(new EntityTrackerSystems.ClearEntityViewers(this.entityViewerComponentType));
      var1.registerSystem(new EntityTrackerSystems.ClearPreviouslyVisible(this.visibleComponentType));
      var1.registerSystem(new EntityTrackerSystems.EnsureVisibleComponent(this.entityViewerComponentType, this.visibleComponentType));
      var1.registerSystem(new EntityTrackerSystems.AddToVisible(this.entityViewerComponentType, this.visibleComponentType));
      var1.registerSystem(new EntityTrackerSystems.RemoveEmptyVisibleComponent(this.visibleComponentType));
      var1.registerSystem(new EntityTrackerSystems.RemoveVisibleComponent(this.visibleComponentType));
      var1.registerSystem(new EntityTrackerSystems.SendPackets(this.entityViewerComponentType));
      var1.registerSystem(new MovementStatesSystems.TickingSystem(this.visibleComponentType, this.movementStatesComponentType));
      this.networkSendableSpatialResourceType = var1.registerSpatialResource(() -> new KDTree<>(Ref::isValid));
      var1.registerSystem(new NetworkSendableSpatialSystem(this.networkSendableSpatialResourceType));
      var1.registerSystem(new EntityTrackerSystems.CollectVisible(this.entityViewerComponentType));
      var1.registerSystem(new EntityTrackerSystems.LODCull(this.entityViewerComponentType));
      var1.registerSystem(new EntityTrackerSystems.HideFromPlayer(this.entityViewerComponentType));
      var1.registerSystem(new EntityTrackerSystems.EntityModel(this.visibleComponentType));
      var1.registerSystem(new EntityTrackerSystems.EntitySkin(this.visibleComponentType, this.playerSkinComponentType));
      var1.registerSystem(new BlockEntitySystems.BlockEntityTrackerSystem(this.visibleComponentType, this.blockEntityComponentType));
      var1.registerSystem(new EntityTrackerSystems.EffectControllerSystem(this.visibleComponentType, this.effectControllerComponentType));
      var1.registerSystem(new EntitySystems.DynamicLightTracker(this.visibleComponentType));
      var1.registerSystem(new DynamicLightSystems.Setup());
      var1.registerSystem(new DynamicLightSystems.EntityTrackerRemove(this.visibleComponentType));
      var1.registerSystem(new PrefabPreviewSystems.PrefabPreviewSetup());
      var1.registerSystem(new PrefabPreviewSystems.PrefabPreviewTracker(this.visibleComponentType));
      var1.registerSystem(new PrefabPreviewSystems.PrefabPreviewEntityTrackerRemove(this.visibleComponentType));
      var1.registerSystem(new LivingEntityEffectClearChangesSystem());
      var1.registerSystem(new PlayerSendInventorySystem(this.playerComponentType));
      var1.registerSystem(new PlayerSavingSystems.WorldRemovedSystem(this.playerComponentType));
      var1.registerSystem(new PlayerSavingSystems.EntityRemovedSystem(this.playerComponentType));
      var1.registerSystem(new PlayerSavingSystems.TickingSystem(this.playerComponentType));
      this.entityGroupComponentType = var1.registerComponent(EntityGroup.class, () -> {
         throw new UnsupportedOperationException("Not implemented");
      });
      this.damageDataComponentType = var1.registerComponent(DamageDataComponent.class, DamageDataComponent::new);
      var1.registerSystem(new DamageDataSetupSystem(this.damageDataComponentType));
      this.knockbackComponentType = var1.registerComponent(KnockbackComponent.class, KnockbackComponent::new);
      var1.registerSystem(new UpdateLocationSystems.SpawnSystem());
      var1.registerSystem(new UpdateLocationSystems.TickingSystem());
      this.persistentRefCountComponentType = var1.registerComponent(PersistentRefCount.class, "RefId", PersistentRefCount.CODEC);
      this.nameplateComponentType = var1.registerComponent(Nameplate.class, "Nameplate", Nameplate.CODEC);
      var1.registerSystem(new NameplateSystems.EntityTrackerUpdate(this.visibleComponentType, this.nameplateComponentType));
      var1.registerSystem(new NameplateSystems.EntityTrackerRemove(this.visibleComponentType, this.nameplateComponentType));
      this.markerReplicationQueueResourceType = var1.registerResource(MarkerReplicationSystems.QueueResource.class, MarkerReplicationSystems.QueueResource::new);
      var1.registerSystem(new EntityInteractableSystems.EntityTrackerUpdate(this.visibleComponentType));
      var1.registerSystem(new EntityInteractableSystems.EntityTrackerAddAndRemove(this.visibleComponentType));
      var1.registerSystem(new IntangibleSystems.EntityTrackerUpdate(this.visibleComponentType));
      var1.registerSystem(new IntangibleSystems.EntityTrackerAddAndRemove(this.visibleComponentType));
      var1.registerSystem(new PreventInventoryAccessSystems.EntityTrackerUpdate(this.visibleComponentType));
      var1.registerSystem(new PreventInventoryAccessSystems.EntityTrackerAddAndRemove(this.visibleComponentType));
      var1.registerSystem(new PreventEmotesSystems.EntityTrackerUpdate(this.visibleComponentType));
      var1.registerSystem(new PreventEmotesSystems.EntityTrackerAddAndRemove(this.visibleComponentType));
      var1.registerSystem(new InvulnerableSystems.EntityTrackerUpdate(this.visibleComponentType));
      var1.registerSystem(new InvulnerableSystems.EntityTrackerAddAndRemove(this.visibleComponentType));
      var1.registerSystem(new RespondToHitSystems.EntityTrackerUpdate(this.visibleComponentType));
      var1.registerSystem(new RespondToHitSystems.EntityTrackerAddAndRemove(this.visibleComponentType));
      var1.registerSystem(new RespondToHitSystems.OnPlayerSettingsChange());
      var1.registerSystem(new CreativeEraserSystems.OnPlayerSettingsChange());
      var1.registerSystem(new CreativeEraserSystems.OnPlayerRemovedFromWorld());
      var1.registerSystem(new AudioSystems.EntityTrackerUpdate());
      var1.registerSystem(new AudioSystems.TickMovementAudio());
      var1.registerSystem(new ModelSystems.SetRenderedModel());
      var1.registerSystem(new ModelSystems.AssignNetworkIdToProps());
      var1.registerSystem(new ModelSystems.EnsurePropsPrefabCopyable());
      var1.registerSystem(new ModelSystems.ApplyRandomSkin());
      var1.registerSystem(new ModelSystems.ModelSpawned());
      var1.registerSystem(new ModelSystems.PlayerConnect());
      var1.registerSystem(new ModelSystems.ModelChange());
      var1.registerSystem(new ModelSystems.UpdateBoundingBox());
      var1.registerSystem(new ModelSystems.UpdateMovementStateBoundingBox());
      var1.registerSystem(new ModelSystems.PlayerUpdateMovementManager());
      var1.registerSystem(new ModelSystems.AnimationEntityTrackerUpdate());
      var1.registerSystem(new EntitySystems.NewSpawnEntityTrackerUpdate());
      var1.registerSystem(new HideEntitySystems.AdventurePlayerSystem());
      this.spectatingComponentType = var1.registerComponent(Spectating.class, () -> {
         throw new UnsupportedOperationException("Not implemented");
      });
      this.persistentGameModeTypeComponentType = var1.registerComponent(PersistentGameModeType.class, "GameModeType", PersistentGameModeType.CODEC);
      this.playerLivesComponentType = var1.registerComponent(PlayerLives.class, "PlayerLives", PlayerLives.CODEC);
      this.hardcoreStateResourceType = Universe.registerResource(HardcoreState.class, "Hardcore", HardcoreState.CODEC);
      var1.registerSystem(new GameModeTypeSystems.Setup());
      var1.registerSystem(new HardcoreGameOver.ApplyOnJoin());
      var1.registerSystem(new HardcoreLivesHud.ShowOnJoin());
      var1.registerSystem(new HardcoreLivesHud.ShowOnChange());
      var1.registerSystem(new PlayerLives.CancelRespawnWhenExhausted());
      var1.registerSystem(new SpectatorSystems.OnSpectatingChange());
      var1.registerSystem(new SpectatorSystems.HideFromNonSpectators());
      var1.registerSystem(new SpectatorSystems.FollowTarget());
      var1.registerSystem(new ServerPlayerListSystems.OnSpectatingChange());
      var1.registerSystem(new TransformSystems.OnRemove());
      var1.registerSystem(new PhysicsValuesAddSystem(this.physicsValuesComponentType));
      var1.registerSystem(new GenericVelocityInstructionSystem());
      var1.registerSystem(new PlayerVelocityInstructionSystem());
      AssetRegistry.register(
         ((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(
                           HitboxCollisionConfig.class, new IndexedLookupTableAssetMap<>(HitboxCollisionConfig[]::new)
                        )
                        .setPath("Entity/HitboxCollision"))
                     .setCodec(HitboxCollisionConfig.CODEC))
                  .setKeyFunction(HitboxCollisionConfig::getId))
               .setPacketGenerator(new HitboxCollisionConfigPacketGenerator())
               .setReplaceOnRemove(HitboxCollisionConfig::new))
            .build()
      );
      this.hitboxCollisionComponentType = var1.registerComponent(HitboxCollision.class, "HitboxCollision", HitboxCollision.CODEC);
      var1.registerSystem(new HitboxCollisionSystems.Setup(this.hitboxCollisionComponentType, this.playerComponentType));
      var1.registerSystem(new HitboxCollisionSystems.EntityTrackerUpdate(this.visibleComponentType, this.hitboxCollisionComponentType));
      var1.registerSystem(new HitboxCollisionSystems.EntityTrackerRemove(this.visibleComponentType, this.hitboxCollisionComponentType));
      AssetRegistry.register(
         ((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(
                           RepulsionConfig.class, new IndexedLookupTableAssetMap<>(RepulsionConfig[]::new)
                        )
                        .setPath("Entity/Repulsion"))
                     .setCodec(RepulsionConfig.CODEC))
                  .setKeyFunction(RepulsionConfig::getId))
               .setPacketGenerator(new RepulsionConfigPacketGenerator())
               .setReplaceOnRemove(RepulsionConfig::new))
            .build()
      );
      this.repulsionComponentType = var1.registerComponent(Repulsion.class, "Repulsion", Repulsion.CODEC);
      var1.registerSystem(new RepulsionSystems.PlayerSetup(this.repulsionComponentType, this.playerComponentType));
      var1.registerSystem(new RepulsionSystems.EntityTrackerUpdate(this.visibleComponentType, this.repulsionComponentType));
      var1.registerSystem(new RepulsionSystems.EntityTrackerRemove(this.visibleComponentType, this.repulsionComponentType));
      var1.registerSystem(new RepulsionSystems.RepulsionTicker(this.repulsionComponentType, this.transformComponentType, this.entitySpatialResourceType));
      var1.registerSystem(new EntitySystems.NewSpawnTick());
      var1.registerSystem(new EntitySystems.EnsureForSerializable());
      var1.registerSystem(new DamageSystems.InvulnerableBreathing(this.invulnerableComponentType, this.breathingComponentType));
      AssetRegistry.register(
         ((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(
                                 MovementConfig.class, new IndexedLookupTableAssetMap<>(MovementConfig[]::new)
                              )
                              .setPath("Entity/MovementConfig"))
                           .setCodec(MovementConfig.CODEC))
                        .setKeyFunction(MovementConfig::getId))
                     .setReplaceOnRemove(MovementConfig::new))
                  .loadsBefore(GameplayConfig.class))
               .preLoadAssets(Collections.singletonList(MovementConfig.DEFAULT_MOVEMENT)))
            .build()
      );
      this.getEventRegistry().register(LoadedAssetsEvent.class, MovementConfig.class, this::onMovementConfigLoadedAssetsEvent);
      this.getEventRegistry().register(LoadedAssetsEvent.class, GameplayConfig.class, this::onGameplayConfigLoadedAssetsEvent);
      this.uniqueItemUsagesComponentType = var1.registerComponent(UniqueItemUsagesComponent.class, "UniqueItemUsages", UniqueItemUsagesComponent.CODEC);
      this.storageInventoryComponentType = var1.registerComponent(InventoryComponent.Storage.class, "StorageInventory", InventoryComponent.Storage.CODEC);
      this.armorInventoryComponentType = var1.registerComponent(InventoryComponent.Armor.class, "ArmorInventory", InventoryComponent.Armor.CODEC);
      this.hotbarInventoryComponentType = var1.registerComponent(InventoryComponent.Hotbar.class, "HotbarInventory", InventoryComponent.Hotbar.CODEC);
      this.utilityInventoryComponentType = var1.registerComponent(InventoryComponent.Utility.class, "UtilityInventory", InventoryComponent.Utility.CODEC);
      this.backpackInventoryComponentType = var1.registerComponent(InventoryComponent.Backpack.class, "BackpackInventory", InventoryComponent.Backpack.CODEC);
      this.toolInventoryComponentType = var1.registerComponent(InventoryComponent.Tool.class, "ToolInventory", InventoryComponent.Tool.CODEC);
      this.combinedInventoryComponentType = var1.registerComponent(InventoryComponent.Combined.class, InventoryComponent.Combined::new);
      this.healthRegenStateComponentType = var1.registerComponent(HealthRegenState.class, HealthRegenState::new);
      InventoryComponent.setupCombined(
         this.storageInventoryComponentType,
         this.armorInventoryComponentType,
         this.hotbarInventoryComponentType,
         this.utilityInventoryComponentType,
         this.backpackInventoryComponentType,
         this.toolInventoryComponentType
      );
      var1.registerSystem(new InventorySystems.StorageChangeEventSystem());
      var1.registerSystem(new InventorySystems.ArmorChangeEventSystem());
      var1.registerSystem(new InventorySystems.HotbarChangeEventSystem());
      var1.registerSystem(new InventorySystems.UtilityChangeEventSystem());
      var1.registerSystem(new InventorySystems.BackpackChangeEventSystem());
      var1.registerSystem(new InventorySystems.ToolChangeEventSystem());
      var1.registerSystem(new InventorySystems.LegacyArmorChangeStatSystem());
      var1.registerSystem(new InventorySystems.LegacyHotbarChangeStatSystem());
      var1.registerSystem(new InventorySystems.LegacyUtilityChangeStatSystem());
      var1.registerSystem(new InventorySystems.PlayerInventoryChangeEventSystem());
      var1.registerSystem(new InventorySystems.ActiveSlotChangedToolsEventSystem());
      var1.registerSystem(new InventorySystems.ActiveSlotChangedEntityEventSystem());
      var1.registerSystem(new InventorySystems.ActiveSlotChangedToolsHolderEventSystem());
      var1.registerSystem(new InventorySystems.ActiveSlotChangedEntityHolderEventSystem());
      var1.registerSystem(new InventorySystems.SyncEquipmentSystem(this.visibleComponentType));
      var1.registerSystem(new PlayerSystems.PlayerInitSystem());
      Condition.CODEC.register("LogicCondition", LogicCondition.class, LogicCondition.CODEC);
      Condition.CODEC.register("RegenHealth", RegenHealthCondition.class, RegenHealthCondition.CODEC);
      Condition.CODEC.register("NoDamageTaken", NoDamageTakenCondition.class, NoDamageTakenCondition.CODEC);
      Condition.CODEC.register("Suffocating", SuffocatingCondition.class, SuffocatingCondition.CODEC);
      Condition.CODEC.register("Charging", ChargingCondition.class, ChargingCondition.CODEC);
      Condition.CODEC.register("Alive", AliveCondition.class, AliveCondition.CODEC);
      Condition.CODEC.register("Environment", EnvironmentCondition.class, EnvironmentCondition.CODEC);
      Condition.CODEC.register("CheckPlayerGameMode", CheckPlayerGameModeCondition.class, CheckPlayerGameModeCondition.CODEC);
      Condition.CODEC.register("OutOfCombat", OutOfCombatCondition.class, OutOfCombatCondition.CODEC);
      Condition.CODEC.register("Wielding", WieldingCondition.class, WieldingCondition.CODEC);
      Condition.CODEC.register("Sprinting", SprintingCondition.class, SprintingCondition.CODEC);
      Condition.CODEC.register("Gliding", GlidingCondition.class, GlidingCondition.CODEC);
      Condition.CODEC.register("Stat", StatCondition.class, StatCondition.CODEC);
      Condition.CODEC.register("InFluid", InFluidCondition.class, InFluidCondition.CODEC);
      Condition.CODEC.register("HasEffect", HasEffectCondition.class, HasEffectCondition.CODEC);
      Condition.CODEC.register("IsPlayer", IsPlayerCondition.class, IsPlayerCondition.CODEC);
   }

   @Override
   class="kw">protected void start() {
      DamageCause.PHYSICAL = DamageCause.getAssetMap().getAsset("Physical");
      DamageCause.PROJECTILE = DamageCause.getAssetMap().getAsset("Projectile");
      DamageCause.COMMAND = DamageCause.getAssetMap().getAsset("Command");
      DamageCause.DROWNING = DamageCause.getAssetMap().getAsset("Drowning");
      DamageCause.ENVIRONMENT = DamageCause.getAssetMap().getAsset("Environment");
      DamageCause.FALL = DamageCause.getAssetMap().getAsset("Fall");
      DamageCause.OUT_OF_WORLD = DamageCause.getAssetMap().getAsset("OutOfWorld");
      DamageCause.SUFFOCATION = DamageCause.getAssetMap().getAsset("Suffocation");
      if (DamageCause.PHYSICAL == null
         || DamageCause.PROJECTILE == null
         || DamageCause.COMMAND == null
         || DamageCause.DROWNING == null
         || DamageCause.ENVIRONMENT == null
         || DamageCause.FALL == null
         || DamageCause.OUT_OF_WORLD == null
         || DamageCause.SUFFOCATION == null) {
         throw new IllegalStateException("Missing class="kw">default DamageCause assets");
      }
   }

   class="kw">public SystemType<EntityStore, EntityModule.MigrationSystem> getMigrationSystemType() {
      class="kw">return this.migrationSystemType;
   }

   class="kw">public SystemType<EntityStore, ? class="kw">extends ISystem<EntityStore>> getVelocityModifyingSystemType() {
      class="kw">return this.velocityModifyingSystemType;
   }

   class="kw">public ComponentType<EntityStore, Player> getPlayerComponentType() {
      class="kw">return this.playerComponentType;
   }

   class="kw">public ComponentType<EntityStore, Frozen> getFrozenComponentType() {
      class="kw">return this.frozenComponentType;
   }

   class="kw">public ComponentType<EntityStore, ChunkTracker> getChunkTrackerComponentType() {
      class="kw">return this.chunkTrackerComponentType;
   }

   class="kw">public ComponentType<EntityStore, PlayerSkinComponent> getPlayerSkinComponentType() {
      class="kw">return this.playerSkinComponentType;
   }

   class="kw">public ComponentType<EntityStore, DisplayNameComponent> getDisplayNameComponentType() {
      class="kw">return this.displayNameComponentType;
   }

   class="kw">public ComponentType<EntityStore, PersistentDisplayName> getPersistentDisplayNameComponentType() {
      class="kw">return this.persistentDisplayNameComponentType;
   }

   class="kw">public ComponentType<EntityStore, ApplyRandomSkinPersistedComponent> getApplyRandomSkinPersistedComponent() {
      class="kw">return this.applyRandomSkinPersistedComponent;
   }

   class="kw">public ComponentType<EntityStore, EntityGroup> getEntityGroupComponentType() {
      class="kw">return this.entityGroupComponentType;
   }

   class="kw">public ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> getPlayerSpatialResourceType() {
      class="kw">return this.playerSpatialResourceType;
   }

   class="kw">public ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> getItemSpatialResourceType() {
      class="kw">return this.itemSpatialResourceType;
   }

   class="kw">public ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> getNetworkSendableSpatialResourceType() {
      class="kw">return this.networkSendableSpatialResourceType;
   }

   class="kw">public ComponentType<EntityStore, Dirty> getDirtyComponentType() {
      class="kw">return this.dirtyComponentType;
   }

   class="kw">public ComponentType<EntityStore, CollisionResultComponent> getCollisionResultComponentType() {
      class="kw">return this.collisionResultComponentType;
   }

   class="kw">public ComponentType<EntityStore, EntityTrackerSystems.EntityViewer> getEntityViewerComponentType() {
      class="kw">return this.entityViewerComponentType;
   }

   class="kw">public ComponentType<EntityStore, EntityTrackerSystems.Visible> getVisibleComponentType() {
      class="kw">return this.visibleComponentType;
   }

   class="kw">public ComponentType<EntityStore, DamageDataComponent> getDamageDataComponentType() {
      class="kw">return this.damageDataComponentType;
   }

   class="kw">public ComponentType<EntityStore, KnockbackComponent> getKnockbackComponentType() {
      class="kw">return this.knockbackComponentType;
   }

   class="kw">public ComponentType<EntityStore, DespawnComponent> getDespawnComponentType() {
      class="kw">return this.despawnComponentComponentType;
   }

   class="kw">public ResourceType<EntityStore, SnapshotSystems.SnapshotWorldInfo> getSnapshotWorldInfoResourceType() {
      class="kw">return this.snapshotWorldInfoResourceType;
   }

   class="kw">public ComponentType<EntityStore, SnapshotBuffer> getSnapshotBufferComponentType() {
      class="kw">return this.snapshotBufferComponentType;
   }

   class="kw">public ComponentType<EntityStore, Interactable> getInteractableComponentType() {
      class="kw">return this.interactableComponentType;
   }

   class="kw">public ComponentType<EntityStore, Intangible> getIntangibleComponentType() {
      class="kw">return this.intangibleComponentType;
   }

   class="kw">public ComponentType<EntityStore, PreventInventoryAccess> getPreventInventoryAccessComponentType() {
      class="kw">return this.preventInventoryAccessComponentType;
   }

   class="kw">public ComponentType<EntityStore, PreventEmotes> getPreventEmotesComponentType() {
      class="kw">return this.preventEmotesComponentType;
   }

   class="kw">public ComponentType<EntityStore, PreventPickup> getPreventPickupComponentType() {
      class="kw">return this.preventPickupComponentType;
   }

   class="kw">public ComponentType<EntityStore, Invulnerable> getInvulnerableComponentType() {
      class="kw">return this.invulnerableComponentType;
   }

   class="kw">public ComponentType<EntityStore, RespondToHit> getRespondToHitComponentType() {
      class="kw">return this.respondToHitComponentType;
   }

   class="kw">public ResourceType<EntityStore, MarkerReplicationSystems.QueueResource> getMarkerReplicationQueueResourceType() {
      class="kw">return this.markerReplicationQueueResourceType;
   }

   class="kw">public ComponentType<EntityStore, HiddenFromAdventurePlayers> getHiddenFromAdventurePlayerComponentType() {
      class="kw">return this.hiddenFromAdventurePlayerComponentType;
   }

   class="kw">public ComponentType<EntityStore, Spectating> getSpectatingComponentType() {
      class="kw">return this.spectatingComponentType;
   }

   class="kw">public ComponentType<EntityStore, PersistentGameModeType> getPersistentGameModeTypeComponentType() {
      class="kw">return this.persistentGameModeTypeComponentType;
   }

   class="kw">public ComponentType<EntityStore, PlayerLives> getPlayerLivesComponentType() {
      class="kw">return this.playerLivesComponentType;
   }

   class="kw">public UniverseResourceType<HardcoreState> getHardcoreStateResourceType() {
      class="kw">return this.hardcoreStateResourceType;
   }

   class="kw">public ComponentType<EntityStore, FromPrefab> getFromPrefabComponentType() {
      class="kw">return this.fromPrefabComponentType;
   }

   class="kw">public ComponentType<EntityStore, FromWorldGen> getFromWorldGenComponentType() {
      class="kw">return this.fromWorldGenComponentType;
   }

   class="kw">public ComponentType<EntityStore, FromPrefabInstance> getFromPrefabInstanceComponentType() {
      class="kw">return this.fromPrefabInstanceComponentType;
   }

   class="kw">public ComponentType<EntityStore, WorldGenId> getWorldGenIdComponentType() {
      class="kw">return this.worldGenIdComponentType;
   }

   class="kw">public ComponentType<EntityStore, MovementManager> getMovementManagerComponentType() {
      class="kw">return this.movementManagerComponentType;
   }

   class="kw">public ComponentType<EntityStore, Nameplate> getNameplateComponentType() {
      class="kw">return this.nameplateComponentType;
   }

   class="kw">public SystemGroup<EntityStore> getPreClearMarkersGroup() {
      class="kw">return this.preClearMarkersGroup;
   }

   class="kw">public ComponentType<EntityStore, PersistentRefCount> getPersistentRefCountComponentType() {
      class="kw">return this.persistentRefCountComponentType;
   }

   class="kw">public ComponentType<EntityStore, TransformComponent> getTransformComponentType() {
      class="kw">return this.transformComponentType;
   }

   class="kw">public ComponentType<EntityStore, HeadRotation> getHeadRotationComponentType() {
      class="kw">return this.headRotationComponentType;
   }

   class="kw">public ComponentType<EntityStore, NetworkId> getNetworkIdComponentType() {
      class="kw">return this.networkIdComponentType;
   }

   class="kw">public ComponentType<EntityStore, EffectControllerComponent> getEffectControllerComponentType() {
      class="kw">return this.effectControllerComponentType;
   }

   class="kw">public ComponentType<EntityStore, MovementStatesComponent> getMovementStatesComponentType() {
      class="kw">return this.movementStatesComponentType;
   }

   class="kw">public ComponentType<EntityStore, BlockEntity> getBlockEntityComponentType() {
      class="kw">return this.blockEntityComponentType;
   }

   class="kw">public ComponentType<EntityStore, EntityScaleComponent> getEntityScaleComponentType() {
      class="kw">return this.entityScaleComponentType;
   }

   class="kw">public ComponentType<EntityStore, CameraManager> getCameraManagerComponentType() {
      class="kw">return this.cameraManagerComponentType;
   }

   class="kw">public ComponentType<EntityStore, UUIDComponent> getUuidComponentType() {
      class="kw">return this.uuidComponentType;
   }

   class="kw">public ComponentType<EntityStore, PlayerInput> getPlayerInputComponentType() {
      class="kw">return this.playerInputComponentType;
   }

   class="kw">public ComponentType<EntityStore, KnockbackSimulation> getKnockbackSimulationComponentType() {
      class="kw">return this.knockbackSimulationComponentType;
   }

   class="kw">public ComponentType<EntityStore, Teleport> getTeleportComponentType() {
      class="kw">return this.teleportComponentType;
   }

   class="kw">public ComponentType<EntityStore, ProjectileComponent> getProjectileComponentType() {
      class="kw">return this.projectileComponentType;
   }

   class="kw">public ComponentType<EntityStore, PendingTeleport> getPendingTeleportComponentType() {
      class="kw">return this.pendingTeleportComponentType;
   }

   class="kw">public ComponentType<EntityStore, TeleportRecord> getTeleportRecordComponentType() {
      class="kw">return this.teleportRecordComponentType;
   }

   class="kw">public ComponentType<EntityStore, ModelComponent> getModelComponentType() {
      class="kw">return this.modelComponentType;
   }

   class="kw">public ComponentType<EntityStore, ModelRotateBoundingBoxComponent> getModelRotateBoundingBoxComponentType() {
      class="kw">return this.modelRotateBoundingBoxComponentType;
   }

   class="kw">public ComponentType<EntityStore, PersistentModel> getPersistentModelComponentType() {
      class="kw">return this.persistentModelComponentType;
   }

   class="kw">public ComponentType<EntityStore, PropComponent> getPropComponentType() {
      class="kw">return this.propComponentType;
   }

   class="kw">public ComponentType<EntityStore, NPCMarkerComponent> getNPCMarkerComponentType() {
      class="kw">return this.npcMarkerComponentType;
   }

   class="kw">public ComponentType<EntityStore, BoundingBox> getBoundingBoxComponentType() {
      class="kw">return this.boundingBoxComponentType;
   }

   class="kw">public ComponentType<EntityStore, HitboxCollision> getHitboxCollisionComponentType() {
      class="kw">return this.hitboxCollisionComponentType;
   }

   class="kw">public ComponentType<EntityStore, Velocity> getVelocityComponentType() {
      class="kw">return this.velocityComponentType;
   }

   class="kw">public ComponentType<EntityStore, PhysicsValues> getPhysicsValuesComponentType() {
      class="kw">return this.physicsValuesComponentType;
   }

   class="kw">public ComponentType<EntityStore, Repulsion> getRepulsionComponentType() {
      class="kw">return this.repulsionComponentType;
   }

   class="kw">public ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> getEntitySpatialResourceType() {
      class="kw">return this.entitySpatialResourceType;
   }

   class="kw">public ComponentType<EntityStore, ItemComponent> getItemComponentType() {
      class="kw">return this.itemComponentType;
   }

   class="kw">public ComponentType<EntityStore, PickupItemComponent> getPickupItemComponentType() {
      class="kw">return this.pickupItemComponentType;
   }

   class="kw">public ComponentType<EntityStore, PreventItemMerging> getPreventItemMergingType() {
      class="kw">return this.preventItemMergingType;
   }

   class="kw">public ComponentType<EntityStore, ItemPhysicsComponent> getItemPhysicsComponentType() {
      class="kw">return this.itemPhysicsComponentType;
   }

   class="kw">public ComponentType<EntityStore, DynamicLight> getDynamicLightComponentType() {
      class="kw">return this.dynamicLightComponentType;
   }

   class="kw">public ComponentType<EntityStore, PersistentDynamicLight> getPersistentDynamicLightComponentType() {
      class="kw">return this.persistentDynamicLightComponentType;
   }

   class="kw">public ComponentType<EntityStore, PrefabPreview> getPrefabPreviewComponentType() {
      class="kw">return this.prefabPreviewComponentType;
   }

   class="kw">public ComponentType<EntityStore, PersistentPrefabPreview> getPersistentPrefabPreviewComponentType() {
      class="kw">return this.persistentPrefabPreviewComponentType;
   }

   class="kw">public ComponentType<EntityStore, PrefabCopyableComponent> getPrefabCopyableComponentType() {
      class="kw">return this.prefabCopyableComponentType;
   }

   class="kw">public ComponentType<EntityStore, RotateObjectComponent> getRotateObjectComponentType() {
      class="kw">return this.rotateObjectComponentType;
   }

   class="kw">public ComponentType<EntityStore, NewSpawnComponent> getNewSpawnComponentType() {
      class="kw">return this.newSpawnComponentType;
   }

   class="kw">private void onMovementConfigLoadedAssetsEvent(@Nonnull LoadedAssetsEvent<String, MovementConfig, DefaultAssetMap<String, MovementConfig>> var1) {
      Universe.get().getWorlds().forEach((var1x, var2) -> var2.execute(() -> {
         World var2 = var2.getEntityStore().getStore();
         var2.forEachEntityParallel(MovementManager.getComponentType(), (var3, var4, var5) -> {
            String var6 = var2.getGameplayConfig().getPlayerConfig().getMovementConfigId();

            for (MovementConfig var8 : var1.getLoadedAssets().values()) {
               Ref var9 = var4.getReferenceTo(var3);
               Player var10 = var4.getComponent(var3, Player.getComponentType());
               assert var10 != null;
               PlayerRef var11 = var4.getComponent(var3, PlayerRef.getComponentType());
               assert var11 != null;
               PacketHandler var12 = var11.getPacketHandler();
               if (var8.getId().equals("Mount") && var10.getMountEntityId() > 0) {
                  var12.writeNoCache(new UpdateMovementSettings(var8.toPacket()));
                  class="kw">return;
               }

               if (var6.equals(var8.getId())) {
                  MovementManager var13 = var4.getComponent(var3, MovementManager.getComponentType());
                  assert var13 != null;
                  var13.setDefaultSettings(var8, EntityUtils.getPhysicsValues(var9, var2), var10.getGameMode());
                  var13.applyDefaultSettings();
                  var13.update(var12);
               }
            }
         });
      }));
   }

   class="kw">private void onGameplayConfigLoadedAssetsEvent(LoadedAssetsEvent<String, GameplayConfig, DefaultAssetMap<String, GameplayConfig>> var1) {
      Universe.get().getWorlds().forEach((var0, var1x) -> var1x.execute(() -> {
         Store var1 = var1x.getEntityStore().getStore();
         var1.forEachEntityParallel(MovementManager.getComponentType(), (var2, var3, var4) -> {
            Ref var5 = var3.getReferenceTo(var2);
            int var6 = var1x.getGameplayConfig().getPlayerConfig().getMovementConfigIndex();
            MovementManager var7 = var3.getComponent(var2, MovementManager.getComponentType());
            assert var7 != null;
            Player var8 = var3.getComponent(var2, Player.getComponentType());
            assert var8 != null;
            PlayerRef var9 = var3.getComponent(var2, PlayerRef.getComponentType());
            assert var9 != null;
            MovementConfig var10 = (MovementConfig)((IndexedLookupTableAssetMap)MovementConfig.getAssetStore().getAssetMap()).getAsset(var6);
            var7.setDefaultSettings(var10, EntityUtils.getPhysicsValues(var5, var1), var8.getGameMode());
            var7.applyDefaultSettings();
            PacketHandler var11 = var9.getPacketHandler();
            var7.update(var11);
         });
      }));
   }

   class="kw">public ComponentType<EntityStore, AudioComponent> getAudioComponentType() {
      class="kw">return this.audioComponentType;
   }

   class="kw">public ComponentType<EntityStore, MovementAudioComponent> getMovementAudioComponentType() {
      class="kw">return this.movementAudioComponentType;
   }

   class="kw">public ComponentType<EntityStore, PositionDataComponent> getPositionDataComponentType() {
      class="kw">return this.positionDataComponentType;
   }

   class="kw">public ComponentType<EntityStore, PlayerSettings> getPlayerSettingsComponentType() {
      class="kw">return this.playerSettingsComponentType;
   }

   class="kw">public ComponentType<EntityStore, UniqueItemUsagesComponent> getUniqueItemUsagesComponentType() {
      class="kw">return this.uniqueItemUsagesComponentType;
   }

   class="kw">public ComponentType<EntityStore, InventoryComponent.Storage> getStorageInventoryComponentType() {
      class="kw">return this.storageInventoryComponentType;
   }

   class="kw">public ComponentType<EntityStore, InventoryComponent.Armor> getArmorInventoryComponentType() {
      class="kw">return this.armorInventoryComponentType;
   }

   class="kw">public ComponentType<EntityStore, InventoryComponent.Hotbar> getHotbarInventoryComponentType() {
      class="kw">return this.hotbarInventoryComponentType;
   }

   class="kw">public ComponentType<EntityStore, InventoryComponent.Utility> getUtilityInventoryComponentType() {
      class="kw">return this.utilityInventoryComponentType;
   }

   class="kw">public ComponentType<EntityStore, InventoryComponent.Backpack> getBackpackInventoryComponentType() {
      class="kw">return this.backpackInventoryComponentType;
   }

   class="kw">public ComponentType<EntityStore, InventoryComponent.Tool> getToolInventoryComponentType() {
      class="kw">return this.toolInventoryComponentType;
   }

   class="kw">public ComponentType<EntityStore, InventoryComponent.Combined> getCombinedInventoryComponentType() {
      class="kw">return this.combinedInventoryComponentType;
   }

   class="kw">public ComponentType<EntityStore, DropItemsComponent> getDropItemsComponentType() {
      class="kw">return this.dropItemsComponentType;
   }

   class="kw">public ComponentType<EntityStore, ActiveAnimationComponent> getActiveAnimationComponentType() {
      class="kw">return this.activeAnimationComponentType;
   }

   class="kw">public ComponentType<EntityStore, CachedStatsComponent> getCachedStatsComponentType() {
      class="kw">return this.cachedStatsComponentType;
   }

   class="kw">public ComponentType<EntityStore, BreathingComponent> getBreathingComponentType() {
      class="kw">return this.breathingComponentType;
   }

   class="kw">public ComponentType<EntityStore, HealthRegenState> getHealthRegenStateComponentType() {
      class="kw">return this.healthRegenStateComponentType;
   }

   @Nullable
   class="kw">public <T class="kw">extends Entity> EntityRegistration registerEntity(
      @Nonnull String var1, @Nonnull Class<T> var2, Function<World, T> var3, @Nullable DirectDecodeCodec<T> var4
   ) {
      if (this.isDisabled()) {
         class="kw">return null;
      }

      this.idMap.put(var1, var2);
      this.classIdMap.put(var2, var1);
      this.classMap.put(var2, var3);
      if (var4 != null) {
         this.codecMap.put(var2, var4);
      }

      ComponentType var5;
      if (var4 != null) {
         var5 = this.getEntityStoreRegistry().registerComponent(var2, var1, (BuilderCodec<T>)var4, true);
      } else {
         var5 = this.getEntityStoreRegistry().registerComponent(var2, () -> {
            throw new UnsupportedOperationException("Not implemented!");
         });
      }

      this.classToComponentType.put(var2, var5);
      this.getEntityStoreRegistry().registerSystem(new EntityModule.LegacyEntityHolderSystem<>(var5), true);
      this.getEntityStoreRegistry().registerSystem(new EntityModule.LegacyEntityRefSystem<>(var5), true);
      class="kw">return new EntityRegistration(var2, () -> this.getState() == PluginState.ENABLED, () -> this.unregisterEntity(var2));
   }

   class="kw">private <T class="kw">extends Entity> void unregisterEntity(Class<T> var1) {
      if (!HytaleServer.get().isShuttingDown()) {
         String var2 = this.classIdMap.remove(var1);
         this.idMap.remove(var2);
         this.classMap.remove(var1);
         this.codecMap.remove(var1);
         ComponentType var3 = this.classToComponentType.remove(var1);
         EntityStore.REGISTRY.unregisterComponent(var3);
      }
   }

   @Nullable
   class="kw">public <T class="kw">extends Entity> Function<World, T> getConstructor(@Nullable Class<T> var1) {
      if (this.isDisabled()) {
         class="kw">return null;
      } else {
         class="kw">return (Function<World, T>)(var1 == null ? null : this.classMap.get(var1));
      }
   }

   @Nullable
   class="kw">public <T class="kw">extends Entity> DirectDecodeCodec<T> getCodec(@Nullable Class<T> var1) {
      if (this.isDisabled()) {
         class="kw">return null;
      } else {
         class="kw">return (DirectDecodeCodec<T>)(var1 == null ? null : this.codecMap.get(var1));
      }
   }

   @Nullable
   class="kw">public Class<? class="kw">extends Entity> getClass(@Nullable String var1) {
      if (this.isDisabled()) {
         class="kw">return null;
      } else {
         class="kw">return var1 == null ? null : this.idMap.get(var1);
      }
   }

   @Nullable
   class="kw">public String getIdentifier(@Nullable Class<? class="kw">extends Entity> var1) {
      if (this.isDisabled()) {
         class="kw">return null;
      } else {
         class="kw">return var1 == null ? null : this.classIdMap.get(var1);
      }
   }

   @Nullable
   class="kw">public <T class="kw">extends Entity> ComponentType<EntityStore, T> getComponentType(@Nullable Class<T> var1) {
      if (this.isDisabled()) {
         class="kw">return null;
      } else if (var1 == null) {
         class="kw">return null;
      } else if (var1.equals(Player.class)) {
         throw new IllegalArgumentException("Get player component type via #getPlayerComponentType()");
      } else {
         class="kw">return (ComponentType<EntityStore, T>)this.classToComponentType.get(var1);
      }
   }

   class="kw">public boolean isKnown(@Nullable Entity var1) {
      class="kw">return var1 != null && this.getConstructor(var1.getClass()) != null;
   }

   class="kw">public class="kw">static class LegacyEntityHolderSystem<T class="kw">extends Entity> class="kw">extends HolderSystem<EntityStore> {
      class="kw">private class="kw">final ComponentType<EntityStore, T> componentType;

      class="kw">public LegacyEntityHolderSystem(ComponentType<EntityStore, T> var1) {
         this.componentType = var1;
      }

      @Nonnull
      @Override
      class="kw">public Set<Dependency<EntityStore>> getDependencies() {
         class="kw">return RootDependency.firstSet();
      }

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

      @Override
      class="kw">public void onEntityAdd(@Nonnull Holder<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3) {
         Entity var4 = var1.getComponent(this.componentType);
         assert var4 != null;
         var4.loadIntoWorld(var3.getExternalData().getWorld());
         var1.putComponent(NetworkId.getComponentType(), new NetworkId(var4.getNetworkId()));
         if (var1.getComponent(Player.getComponentType()) != null) {
            String var5 = var4.getLegacyDisplayName();
            if (var5 != null && var1.getComponent(DisplayNameComponent.getComponentType()) == null) {
               var1.putComponent(DisplayNameComponent.getComponentType(), new DisplayNameComponent(Message.raw(var5)));
            }
         }
      }

      @Override
      class="kw">public void onEntityRemoved(@Nonnull Holder<EntityStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<EntityStore> var3) {
         Entity var4 = var1.getComponent(this.componentType);
         class="kw">switch (var2) {
            case REMOVE:
            case BUILDER_TOOLS_UNDO:
               if (!var4.wasRemoved()) {
                  var4.remove();
                  var4.unloadFromWorld();
               }
               break;
            case UNLOAD:
               var4.unloadFromWorld();
               var4.clearReference();
         }
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "LegacyEntityHolderSystem{componentType=" + this.componentType + "}";
      }
   }

   class="kw">public class="kw">static class LegacyEntityRefSystem<T class="kw">extends Entity> class="kw">extends RefSystem<EntityStore> {
      class="kw">private class="kw">final ComponentType<EntityStore, T> componentType;

      class="kw">public LegacyEntityRefSystem(ComponentType<EntityStore, T> var1) {
         this.componentType = var1;
      }

      @Nonnull
      @Override
      class="kw">public Set<Dependency<EntityStore>> getDependencies() {
         class="kw">return RootDependency.firstSet();
      }

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

      @Override
      class="kw">public void onEntityAdded(
         @Nonnull Ref<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         Entity var5 = var3.getComponent(var1, this.componentType);
         assert var5 != null;
         var5.setReference(var1);
      }

      @Override
      class="kw">public void onEntityRemove(
         @Nonnull Ref<EntityStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "LegacyEntityRefSystem{componentType=" + this.componentType + "}";
      }
   }

   class="kw">public class="kw">static class LegacyUUIDSystem class="kw">extends EntityModule.MigrationSystem {
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(
         new SystemDependency<>(Order.BEFORE, EntityStore.UUIDSystem.class), RootDependency.first()
      );

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

      @Override
      class="kw">public void onEntityAdd(@Nonnull Holder<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3) {
         UUIDComponent var4 = var1.getComponent(UUIDComponent.getComponentType());
         Entity var5 = EntityUtils.getEntity(var1);
         if (var4 == null) {
            UUID var6 = var5.getUuid();
            if (var6 != null) {
               var1.addComponent(UUIDComponent.getComponentType(), new UUIDComponent(var6));
            }
         } else {
            var5.setLegacyUUID(var4.getUuid());
         }
      }

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

      @Nonnull
      @Override
      class="kw">public Set<Dependency<EntityStore>> getDependencies() {
         class="kw">return this.dependencies;
      }

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

   class="kw">public class="kw">static class LegacyUUIDUpdateSystem class="kw">extends RefChangeSystem<EntityStore, UUIDComponent> {
      class="kw">public LegacyUUIDUpdateSystem() {
      }

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

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

      class="kw">public void onComponentAdded(
         @Nonnull Ref<EntityStore> var1, @Nonnull UUIDComponent var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         EntityUtils.getEntity(var1, var3).setLegacyUUID(var2.getUuid());
      }

      class="kw">public void onComponentSet(
         @Nonnull Ref<EntityStore> var1,
         UUIDComponent var2,
         @Nonnull UUIDComponent var3,
         @Nonnull Store<EntityStore> var4,
         @Nonnull CommandBuffer<EntityStore> var5
      ) {
         EntityUtils.getEntity(var1, var4).setLegacyUUID(var3.getUuid());
      }

      class="kw">public void onComponentRemoved(
         @Nonnull Ref<EntityStore> var1, @Nonnull UUIDComponent var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         EntityUtils.getEntity(var1, var3).setLegacyUUID(null);
      }
   }

   class="kw">public class="kw">abstract class="kw">static class MigrationSystem class="kw">extends HolderSystem<EntityStore> {
      class="kw">public MigrationSystem() {
      }
   }

   class="kw">public enum Type {
      PLAYERS,
      ALL;

      Type() {
      }
   }
}
last Загружено: 2026-09-03 в 20:47:25