Documentation/content/world/entities/npc/npc-components.fr.md

title, type, weight

title	type	weight
Composants NPC	docs	2

Les composants NPC sont des composants ECS qui stockent les données et l'état des NPCs. Le système inclut plus de 300 composants de base pour diverses fonctionnalités NPC.

Package: com.hypixel.hytale.server.npc.corecomponents

Vue d'Ensemble des Composants

Les composants NPC suivent le pattern ECS où les composants sont des conteneurs de données pures attachés aux entity stores.

// Accéder aux composants NPC
EntityStore store = npc.getEntityStore();
NPCBrainComponent brain = store.getComponent(NPCBrainComponent.class);

Composants Cerveau

NPCBrainComponent

Le composant principal de traitement IA :

public class NPCBrainComponent {
    private DecisionMaker decisionMaker;
    private float thinkInterval;
    private float lastThinkTime;

    public void setDecisionMaker(DecisionMaker maker);
    public DecisionMaker getDecisionMaker();
    public boolean shouldThink(float currentTime);
}

NPCMemoryComponent

Stocke les mémoires et connaissances du NPC :

public class NPCMemoryComponent {
    private Map<String, Memory> memories;
    private float memoryDuration;

    public void remember(String key, Object value, float duration);
    public <T> T recall(String key, Class<T> type);
    public boolean hasMemory(String key);
    public void forget(String key);
}

Composants d'État

NPCStateComponent

État comportemental actuel :

public class NPCStateComponent {
    private NPCState currentState;
    private NPCState previousState;
    private float stateEnterTime;

    public enum NPCState {
        IDLE,
        WALKING,
        RUNNING,
        ATTACKING,
        FLEEING,
        INTERACTING,
        SLEEPING,
        DEAD
    }
}

NPCAlertComponent

Niveau de vigilance et de conscience :

public class NPCAlertComponent {
    private AlertLevel alertLevel;
    private float alertDecayRate;
    private Entity alertSource;

    public enum AlertLevel {
        RELAXED,     // État normal
        CURIOUS,     // Quelque chose a attiré l'attention
        ALERT,       // Investigation active
        ALARMED,     // Menace détectée
        COMBAT       // En combat
    }
}

Composants de Cible

NPCTargetComponent

Suivi de cible actuel :

public class NPCTargetComponent {
    private Ref<EntityStore> currentTarget;
    private TargetType targetType;
    private float targetAcquiredTime;
    private Vector3d lastKnownPosition;

    public enum TargetType {
        HOSTILE,
        FRIENDLY,
        NEUTRAL,
        OBJECT
    }
}

NPCFocusComponent

Point de focus visuel :

public class NPCFocusComponent {
    private Vector3d focusPoint;
    private Ref<EntityStore> focusEntity;
    private float focusStrength;
    private boolean shouldLookAt;
}

Composants de Mouvement

NPCMovementComponent

Configuration de mouvement :

public class NPCMovementComponent {
    private float walkSpeed;
    private float runSpeed;
    private float turnSpeed;
    private boolean canJump;
    private boolean canSwim;
    private boolean canClimb;
}

NPCPathComponent

Données de suivi de chemin :

public class NPCPathComponent {
    private List<Vector3d> currentPath;
    private int currentWaypointIndex;
    private float pathRecalculateInterval;
    private float lastPathTime;

    public Vector3d getCurrentWaypoint();
    public Vector3d getNextWaypoint();
    public boolean hasReachedWaypoint(Vector3d position, float threshold);
}

NPCNavigationComponent

Paramètres de navigation :

public class NPCNavigationComponent {
    private float avoidanceRadius;
    private float pathfindingRange;
    private int maxPathLength;
    private NavigationFlags flags;

    public static class NavigationFlags {
        public boolean avoidWater;
        public boolean avoidFire;
        public boolean canUseDoors;
        public boolean canBreakBlocks;
    }
}

Composants de Combat

NPCCombatComponent

Capacités de combat :

public class NPCCombatComponent {
    private float attackRange;
    private float attackCooldown;
    private float lastAttackTime;
    private DamageType preferredDamageType;
    private List<String> availableAttacks;
}

NPCAggroComponent

Gestion de l'aggro :

public class NPCAggroComponent {
    private Map<Ref<EntityStore>, Float> aggroTable;
    private float aggroDecayRate;
    private float aggroRange;

    public void addAggro(Ref<EntityStore> entity, float amount);
    public void removeAggro(Ref<EntityStore> entity);
    public Ref<EntityStore> getHighestAggroTarget();
}

Composants Sociaux

NPCFactionComponent

Affiliation de faction :

public class NPCFactionComponent {
    private String factionId;
    private Map<String, FactionRelation> relations;

    public enum FactionRelation {
        ALLIED,
        FRIENDLY,
        NEUTRAL,
        UNFRIENDLY,
        HOSTILE
    }

    public FactionRelation getRelation(String otherFaction);
}

NPCDialogueComponent

Capacités de dialogue :

public class NPCDialogueComponent {
    private String dialogueTreeId;
    private Map<String, Boolean> dialogueFlags;
    private Ref<EntityStore> currentSpeaker;

    public boolean hasDialogue();
    public void startDialogue(Player player);
}

Composants Utilitaires

NPCScheduleComponent

Programme journalier :

public class NPCScheduleComponent {
    private Map<Integer, ScheduleEntry> schedule;

    public static class ScheduleEntry {
        public int startHour;
        public int endHour;
        public String activity;
        public Vector3d location;
    }

    public ScheduleEntry getCurrentActivity(int worldHour);
}

NPCInventoryComponent

Inventaire NPC :

public class NPCInventoryComponent {
    private ItemContainer inventory;
    private ItemStack equippedWeapon;
    private ItemStack equippedArmor;

    public ItemStack getEquippedWeapon();
    public void equipItem(ItemStack item);
}

Enregistrer des Composants Personnalisés

public class MyPlugin extends JavaPlugin {
    @Override
    public void start() {
        // Enregistrer un composant NPC personnalisé
        getEntityStoreRegistry().registerComponent(
            "custom_npc_data",
            CustomNPCComponent.class,
            CustomNPCComponent::new
        );
    }
}

public class CustomNPCComponent {
    private String customData;
    private int customValue;

    // Champs de données du composant
}

Patterns d'Accès aux Composants

// Accès sécurisé aux composants
public void processNPC(NPCEntity npc) {
    EntityStore store = npc.getEntityStore();

    // Vérifier si le composant existe
    if (store.hasComponent(NPCCombatComponent.class)) {
        NPCCombatComponent combat = store.getComponent(NPCCombatComponent.class);
        // Traiter la logique de combat
    }

    // Obtenir ou créer un composant
    NPCStateComponent state = store.getOrCreateComponent(
        NPCStateComponent.class,
        NPCStateComponent::new
    );
}

Bonnes Pratiques

{{< callout type="info" >}} Directives des Composants :

• Les composants doivent être des données pures - pas de logique complexe
• Utilisez les composants pour l'état qui doit persister
• Accédez aux composants via EntityStore, pas directement
• Vérifiez l'existence du composant avant l'accès
• Utilisez le composant approprié pour chaque type de données {{< /callout >}}