---
title: Memoires
type: docs
weight: 4
---

Le systeme de memoires fournit un suivi persistant des decouvertes collectibles pour les joueurs.

**Package:** `com.hypixel.hytale.builtin.adventure.memories`

## Architecture

```
MemoriesPlugin
├── Composants
│   └── PlayerMemories - Memoires collectees du joueur
├── Types de Memoire
│   ├── Memory - Interface de base
│   ├── MemoryProvider - Fournit les instances de memoire
│   └── NPCMemory/NPCMemoryProvider - Memoires basees sur NPCs
├── Stockage
│   └── RecordedMemories - Stockage persistant (memories.json)
├── UI
│   ├── MemoriesWindow - Fenetre client
│   ├── MemoriesPage - Page UI
│   └── MemoriesPageSupplier
├── Systemes
│   ├── PlayerAddedSystem - Initialiser a la connexion
│   ├── NPCMemory.GatherMemoriesSystem - Collecter memoires NPC
│   └── TempleRespawnPlayersSystem - Logique respawn temple
└── Commandes
    └── MemoriesCommand (capacity, clear, level, unlock)
```

## Concepts Cles

### Interface Memory

Interface de base pour tous les types de memoire:

```java
public interface Memory {
    // Codec pour serialisation
    static final Codec<Memory> CODEC;
}
```

### MemoryProvider

Fournit les instances et configuration de memoire:

```java
public interface MemoryProvider<T extends Memory> {
    String getId();
    BuilderCodec<T> getCodec();
    Map<String, Set<Memory>> getAllMemories();
}
```

### NPCMemory

Memoires decouvertes depuis les NPCs:

```java
public class NPCMemory implements Memory {
    // Collectee quand joueur approche NPC dans le rayon
}

public class NPCMemoryProvider implements MemoryProvider<NPCMemory> {
    public double getCollectionRadius();  // Depuis config
}
```

## Composant Player Memories

```java
ComponentType<EntityStore, PlayerMemories> type =
    MemoriesPlugin.get().getPlayerMemoriesComponentType();
```

Le composant `PlayerMemories` suit:
- Memoires decouvertes par le joueur
- Capacite de memoire
- Transfert vers memoires enregistrees

## Memoires Enregistrees

Stockage persistant de memoires sauvegarde dans `memories.json`:

```java
// Verifier si memoire est enregistree
boolean hasMemory = MemoriesPlugin.get().hasRecordedMemory(memory);

// Obtenir toutes les memoires enregistrees
Set<Memory> recorded = MemoriesPlugin.get().getRecordedMemories();

// Enregistrer les memoires du joueur
boolean recorded = MemoriesPlugin.get().recordPlayerMemories(playerMemories);

// Effacer toutes les memoires enregistrees
MemoriesPlugin.get().clearRecordedMemories();

// Enregistrer toutes les memoires possibles
MemoriesPlugin.get().recordAllMemories();
```

## Niveaux de Memoire

Le nombre de memoires determine le niveau du joueur:

```java
// Obtenir niveau actuel de memoires
int level = MemoriesPlugin.get().getMemoriesLevel(gameplayConfig);

// Obtenir memoires necessaires pour prochain niveau
int needed = MemoriesPlugin.get().getMemoriesForNextLevel(gameplayConfig);
```

### Configuration des Niveaux

```java
public class MemoriesGameplayConfig {
    int[] memoriesAmountPerLevel;  // Seuils pour chaque niveau
}
```

## Interactions

| Interaction | ID Type | Description |
|-------------|---------|-------------|
| `SetMemoriesCapacityInteraction` | `SetMemoriesCapacity` | Definir capacite memoire joueur |
| `MemoriesConditionInteraction` | `MemoriesCondition` | Condition basee sur memoires |

## Integration UI

### Fenetre Memoires

Fenetre demandable par le client pour voir les memoires:

```java
Window.CLIENT_REQUESTABLE_WINDOW_TYPES.put(WindowType.Memories, MemoriesWindow::new);
```

### Page UI Personnalisee

```java
OpenCustomUIInteraction.registerCustomPageSupplier(
    this,
    MemoriesPage.class,
    "Memories",
    new MemoriesPageSupplier()
);
```

## Commandes

| Commande | Description |
|----------|-------------|
| `/memories` | Commande memoires de base |
| `/memories capacity <amount>` | Definir capacite memoire |
| `/memories clear` | Effacer memoires enregistrees |
| `/memories level` | Afficher niveau actuel |
| `/memories unlock` | Debloquer toutes les memoires |

## Configuration

### Config Plugin

```java
public class MemoriesPluginConfig {
    // Rayon de collection par type de memoire
    Object2DoubleMap<String> collectionRadius;

    public Object2DoubleMap<String> getCollectionRadius();
}
```

### Config Gameplay

```yaml
# gameplay_config.json
{
  "Memories": {
    "MemoriesAmountPerLevel": [5, 15, 30, 50, 75, 100]
  }
}
```

## Systeme de Temple

Le systeme du Temple Oublie pour les respawns lies aux memoires:

```java
public class ForgottenTempleConfig {
    // Configuration temple pour respawn
}

public class TempleRespawnPlayersSystem {
    // Gere le respawn aux temples
}
```

## Evenements

Le statut de la fonctionnalite memoires est envoye a la connexion:

```java
// Envoye au client quand joueur rejoint
playerConnection.writeNoCache(new UpdateMemoriesFeatureStatus(isFeatureUnlocked));
```

## Utilisation de l'API

```java
MemoriesPlugin memories = MemoriesPlugin.get();

// Obtenir toutes les memoires disponibles
Map<String, Set<Memory>> allMemories = memories.getAllMemories();

// Enregistrer fournisseur de memoire personnalise
memories.registerMemoryProvider(new CustomMemoryProvider());

// Verifier composant memoires joueur
PlayerMemories playerMemories = store.getComponent(ref, PlayerMemories.getComponentType());
```