Espace de noms du moteur et de la logique de jeu. More...

Classes
struct	ExplorationSnapshot
	L'état d'exploration mis de côté le temps d'un combat. More...
struct	EncounterRun
	Une rencontre engagée : ce qu'on restituera, et ce qu'une victoire acquerra. More...
struct	EncounterTrigger
	Un déclencheur de rencontre relevé sur la carte : quoi engager, où, et ce qu'une victoire acquerra. More...
struct	EncounterCombatant
	Un combattant d'une rencontre : une créature du bestiaire, et sa case de départ. More...
struct	Encounter
	Une rencontre, telle que la donnée la décrit. More...
struct	EncounterCatalog
	Le catalogue des rencontres, et ce qui n'a pas pu être lu. More...
struct	CombatantPlacement
	Un combattant placé : sa créature, et sa case sur la carte. More...
class	Engine
	Fournit les informations globales du moteur. More...
struct	TextPosition
	Position d'un octet dans un texte, en ligne et colonne comptées à partir de 1. More...
struct	JsonDocument
	Résultat de la lecture de l'enveloppe commune d'un document JSON. More...
class	ConsoleLogSink
	Sink qui écrit les messages sur la sortie standard et, sous Windows, vers le débogueur. More...
class	FileLogSink
	Sink qui écrit chaque message dans un fichier, ligne par ligne. More...
class	ILogSink
	Destination vers laquelle un Logger diffuse ses messages. More...
class	Logger
	Filtre les messages par niveau minimal et les diffuse aux sinks enregistrés. More...
class	MemoryLogSink
	Sink de test : mémorise les messages reçus pour inspection. More...
class	ScopedLogLevel
	Relève le niveau minimal de `logger` à au moins `floor` pour la durée de vie de l'objet, et restaure le niveau précédent à la destruction. More...
struct	AnimationClip
	Clip d'animation : une suite d'images, une durée par image, une manière de finir. More...
class	ClipSet
	Ensemble nommé de clips, adressable par nom — l'unité que décrit un fichier nom-asset.anim.json (LOT-46 TACHE-03). More...
class	IComponentPool
	Interface type-effacée d'une pool de composants. More...
class	ComponentPool
	Stockage dense des composants d'un type T, indexé par entité (sparse set). More...
struct	Actor
	Marque une entité acteur — un personnage qui occupe une case et se déplace — et porte ce que ce déplacement laisse derrière lui : son orientation et sa masse. More...
struct	Animation
	État d'animation courant d'une entité : quel jeu de clips, quel clip, quelle image, depuis combien de temps. More...
struct	Collider
	Étendue physique d'une entité pour la collision : une boîte alignée aux axes (AABB). More...
struct	Interactable
	Marque une entité comme cible d'interaction et porte de quoi la désigner. More...
struct	Particle
	Particule visuelle pure : position, vitesse, durée de vie – aucun effet de gameplay (EX-ARCH-012). More...
struct	RpgActor
	Marque une entité comme acteur de jeu de rôle et la relie à sa fiche. More...
struct	AtlasRegion
	Région source dans l'atlas de textures, en pixels (origine haut-gauche). More...
struct	Color
	Couleur RVBA à composantes flottantes dans l'intervalle [0, 1]. More...
struct	Sprite
	Apparence 2D d'une entité : quelle région de l'atlas dessiner, dans quelle couche et avec quelle teinte. More...
struct	Transform
	Position, échelle et rotation d'une entité, en unités monde (EX-ARCH-020). More...
struct	Velocity
	Vitesse linéaire d'une entité, en unités monde par seconde. More...
struct	Entity
	Handle générationnel identifiant une entité de l'ECS. More...
class	EntityManager
	Crée, détruit et valide les entités de l'ECS. More...
class	ISystem
	Interface d'un système : porte la logique itérant sur les composants. More...
class	AnimationSystem
	Fait progresser l'animation de toute entité portant core::Animation, et projette l'état physique du personnage sur son clip cible. More...
class	MovementSystem
	Fait avancer chaque entité mobile selon sa vitesse, au pas de temps fixe. More...
struct	ParticleEffect
	Données décrivant un effet de particules : combien, à quelle vitesse, pendant combien de temps, avec quelle dispersion angulaire – en constantes nommées côté appelant, jamais de nombres magiques dispersés dans le code (LOT-53 TACHE-01). More...
class	ParticleSystem
	Émet et simule des particules visuelles au pas fixe, strictement déterministe. More...
class	View
	Sélection en lecture-écriture des entités possédant tous les composants demandés. More...
class	World
	Point d'entrée unique de la simulation : possède les entités, les composants et les systèmes. More...
struct	InteractionCandidate
	Une cible candidate : son composant et l'entité qui la porte. More...
struct	InteractionTarget
	Ce que la désignation a trouvé. More...
struct	InteractionOutcome
	Ce qu'une interaction a produit. More...
struct	InteractableKind
	Les types d'entité que ce lot sait rendre interactifs, et ce qu'ils consomment. More...
struct	TriggerWeight
	Poids posé sur un déclencheur par autre chose que le personnage (EX-GP-025, LOT-65 TACHE-06). More...
class	MechanismController
	Fait vivre les mécanismes interrupteur/plaque ↔ porte d'un niveau (EX-GP-020, EX-GP-021, EX-GP-025). More...
class	WorldFlags
	L'ensemble des faits acquis d'une partie : coffres ouverts, quêtes franchies, portes déverrouillées. More...
struct	CameraZone
	Rectangle de caméra dessiné à la main par le level designer (mode par salle), en cases. More...
struct	CameraFramingConfig
	Cadrage de caméra résolu d'un niveau : le mode retenu et ses paramètres. More...
struct	GridPosition
	Position d'une case dans la grille d'un niveau, en coordonnées entières. More...
struct	Mechanism
	Liaison d'un interrupteur à une porte, par positions résolues. More...
struct	TileTextureOverride
	Texture assignée explicitement à une case précise, prioritaire sur le skin de son type (EX-EDIT-043, LOT-42). More...
struct	LevelData
	Niveau complet en mémoire : nom, grille de tuiles, entrée/sortie et mécanismes. More...
class	Level
class	LevelDraft
	Niveau mutable en cours d'édition, distinct de Level (immuable, LOT-07). More...
struct	LevelLoadResult
	Résultat d'un chargement de niveau : soit un Level, soit une erreur décrite. More...
class	LevelLoader
	Charge un niveau au format JSON (objet {name, width, height, tiles} où tiles est une liste d'objets {x, y, type, …}), EX-LVL-001/EX-LVL-003. More...
class	LevelWriter
	Sérialise un niveau vers le format JSON défini par EX-LVL-003. More...
struct	MapEntity
	Une entité de carte — ce qui n'est pas une tuile. More...
struct	Plane
	Plan pictural : image couvrant tout le niveau, avec sa densité, sa parallaxe et sa profondeur (EX-DEC-040 à EX-DEC-043). More...
struct	TileLayer
	Une couche de tuiles : son rôle, sa grille, et ses propriétés libres. More...
class	TileMap
	Grille dense de tuiles typées (EX-GP-001), origine haut-gauche. More...
class	DeterministicRandom
	Générateur pseudo-aléatoire léger (SplitMix64), à graine explicite. More...
struct	Rect
	Rectangle aligné sur les axes (AABB) en unités monde. More...
struct	Vector2
	Vecteur bidimensionnel en coordonnées monde (composantes float). More...
struct	Aabb
	Rectangle aligné aux axes, décrit par ses coins min (haut-gauche) et max (bas-droite), en unités monde (origine haut-gauche, y vers le bas). More...
struct	PhysicsConfig
	Paramètres réglables de la physique du personnage, regroupés pour faciliter le tuning. More...
struct	PlayerInput
	Intention de déplacement transmise à la physique, dissociée de toute touche. More...
struct	SweepResult
	Résultat d'un balayage : où la boîte s'arrête et sur quels axes elle a été bloquée. More...
struct	TopDownConfig
	Paramètres réglables du déplacement top-down, regroupés pour faciliter le tuning. More...
struct	AssetFamilyDefinition
	Une famille d'assets d'entité : ce qu'elle illustre, et le contrat de dimensions. More...
struct	AssetFamilyTable
	La table des familles, et ce qui n'a pas pu être lu. More...
struct	AssetKey
	Une clé d'asset décomposée : sa famille, et ce qu'elle désigne dedans. More...
struct	ExpectedAssetKey
	Une clé attendue par le manifeste : ce qu'elle illustre, et d'où elle vient. More...
struct	MarkerColor
	Une couleur RVBA, sans dépendance au rendu — Core ne connaît ni Qt ni GPU (EX-ARCH-001). More...
struct	MarkerImage
	Les pixels d'un marqueur, en RVBA, ligne par ligne depuis le haut. More...
struct	CreatureTrait
	Un trait de créature : un nom et sa description, tels que le livre les écrit. More...
struct	CreatureAction
	Une action de créature, et ce que le moteur sait en jouer. More...
struct	CreatureSpeed
	Vitesses de déplacement d'une créature, en mètres. walk est toujours renseignée. More...
struct	Creature
	Un bloc de statistiques : ce que creature.schema.json décrit. More...
struct	Bestiary
	Le catalogue chargé, et ce qui n'a pas pu l'être. More...
struct	NamedTrait
	Un trait nommé, tel que le livre l'écrit — d'espèce ou d'historique. More...
struct	ProvisionalStatus
	Le statut provisoire d'une donnée (EX-CNT-032). More...
struct	Species
	Une espèce jouable : ce que species.schema.json décrit. More...
struct	Background
	Un historique : maîtrises, langues accordées et capacité. More...
struct	ClassLevel
	Une ligne de table de progression : ce qu'un niveau apporte. More...
struct	PlayableClass
	Une classe jouable et sa table de progression. More...
struct	CharacterOptions
	Les trois catalogues chargés, et ce qui n'a pas pu l'être. More...
struct	ExperienceLevel
	Une ligne de la table d'expérience : le seuil d'un niveau et son bonus de maîtrise. More...
struct	ExperienceTable
	La table d'expérience, du niveau 1 au niveau 20. More...
struct	CharacterCreationRules
	Les deux constantes de règle qu'une fiche emploie, lues dans la donnée. More...
struct	CharacterSheet
	La fiche d'une créature jouable ou non : héros, PNJ, ennemi. More...
struct	LevelUpResult
	Ce qu'une montée de niveau a produit — de quoi le dire au joueur (EX-DND-003). More...
struct	LoadedCharacterSheet
	Une fiche chargée depuis un fichier, et ce qui n'a pas pu l'être. More...
struct	SkillCheckModifier
	Le modificateur d'un jet de compétence. More...
struct	Modifier
	Un modificateur, avec son origine — sans quoi le jet n'est pas restituable. More...
struct	CheckResult
	Le résultat complet d'un jet, et de quoi le reconstituer (EX-DND-003). More...
struct	Dice
	Une expression de dés analysée : 2d6+3, 1d8, 4. More...
struct	DiceRoll
	Le détail d'un lancer, pour que le joueur puisse le reconstituer (EX-DND-003). More...
struct	Armor
	Une armure ou un bouclier du catalogue. More...
struct	Weapon
	Une arme du catalogue. More...
struct	EquipmentCatalog
	Les deux catalogues chargés, et ce qui n'a pas pu l'être. More...
struct	InventoryEntry
	Une ligne d'inventaire : un objet et sa quantité. More...
struct	Item
	Un objet du catalogue qui n'est ni une arme ni une armure : matériel, outil, monture, marchandise, babiole, objet magique. More...
struct	ItemCatalog
	Le catalogue d'objets, et ce qui n'a pas pu être lu. More...
struct	EncumbranceRules
	Les bornes de charge, lues dans la donnée (rules/encumbrance.json). More...
struct	InventoryStack
	Une ligne du sac : un identifiant de catalogue et une quantité. More...
struct	Inventory
	Ce qu'un personnage porte : son sac, et ce qu'il a sur lui. More...
struct	ItemLookup
	Les trois catalogues qu'un inventaire consulte pour peser et pour dériver. More...
struct	DerivedStats
	Ce que l'équipement porté produit — recalculé, jamais accumulé. More...
struct	SkillDefinition
	Une compétence et la caractéristique dont elle dépend. More...
struct	SkillCatalog
	Les compétences chargées, et ce qui n'a pas pu l'être. More...
class	FixedTimestep
	Convertit un temps réel écoulé variable en un nombre de pas de simulation fixes. More...
struct	RegionAppraisal
	Une appréciation d'un axe : une note, et la portée où elle vaut. More...
struct	RegionStatistic
	Un axe de statistique régionale : une ou plusieurs appréciations (EX-CNT-061). More...
struct	RegionSpeciesShare
	La part d'une espèce dans la population d'une région. More...
struct	RegionPopulation
	La population d'une région. More...
struct	Location
	Un lieu nommé d'une région : un nœud terminal du graphe, une carte à créer. More...
struct	Region
	Une région : un nœud du graphe de cartes. More...
struct	Atlas
	L'atlas chargé, et ce qui n'a pas pu l'être. More...
class	GridDistanceField
	Distance de plus court chemin en nombre de cases (4-connexité, respectant les cases statiquement solides d'un core::TileMap), pré-calculée une fois par BFS multi-source depuis une case cible. More...

Typedefs
using	AssertionHandler
	Signature d'un gestionnaire d'échec d'assertion.
using	PropertyValue = std::variant<bool, std::int64_t, double, std::string>
	Valeur d'une propriété libre : booléen, entier, réel ou chaîne.
using	PropertyMap = std::map<std::string, PropertyValue>
	Propriétés libres, indexées par nom.

Enumerations
enum class	CombatOutcome { Victory , Flight , Defeat }
	Comment un combat se termine. More...
enum class	JsonReadError { None , FileNotFound , ParseError , UnsupportedVersion , MalformedStructure }
	Catégorie d'échec de lecture d'un document JSON. More...
enum class	LogLevel { Trace , Info , Warning , Error }
	Niveau d'un message de journalisation (ordre croissant de gravité). More...
enum class	ClipEndMode { Loop , OneShot }
	Manière dont un clip se termine à la dernière image. More...
enum class	ParticleKind { DashTrail , LandingDust , Death }
	Effet visuel à l'origine d'une particule – tag opaque pour Core, exploité par le rendu (HMI) pour choisir calque, teinte et texture (LOT-53 TACHE-03), sans que Core n'ait à connaître ces notions de présentation (EX-NFR-011). More...
enum class	CameraFramingMode { WholeLevel , PerRoom , Follow }
	Mode de cadrage de caméra d'un niveau (EX-REN-016) : décision de conception, pas une règle déduite de ses dimensions. More...
enum class	LevelValidationError { None , ParseError , UnknownTileType , OutOfBounds , DuplicatePosition , MissingSwitchId , DuplicateSwitchId , InvalidEntryCount , InvalidExitCount , UnresolvedMechanism , FileNotFound , UnsupportedFormatVersion , InvalidCameraFraming }
	Catégorie d'échec de chargement/validation d'un niveau (LOT-15, EX-EDIT-012). More...
enum class	LevelOutcome { Playing , Won , Lost }
	Issue courante d'un niveau, déduite de la position du personnage. More...
enum class	PlaneDepth { Behind , Front }
	Position d'un plan dans l'ordonnancement de rendu, relativement au personnage (EX-DEC-042). More...
enum class	LayerKind { Ground , Decor , Collision , Legacy }
	Rôle d'une couche de tuiles dans une carte. More...
enum class	TileType { Empty , Solid , Danger , Entry , Exit , Switch , Door , PressurePlate , Block , Key , LockedDoor , Grass , Dirt , Sand , Water , DeepWater , Wall , Cliff , Bridge , Stairs }
	Type d'une tuile de la grille d'une carte (EX-GP-001). More...
enum class	Ability { Strength , Dexterity , Constitution , Intelligence , Wisdom , Charisma }
	Une des six caractéristiques d'un personnage ou d'une créature (EX-DND-010). More...
enum class	RollStance { Normal , Advantage , Disadvantage }
	Comment le d20 est lancé. More...
enum class	ArmorCategory { Light , Medium , Heavy , Shield }
	Catégorie d'armure. Ensemble fermé : le livre n'en connaît pas d'autre. More...
enum class	EncumbranceLevel { Unencumbered , Encumbered , HeavilyEncumbered , OverCapacity }
	État de charge d'un personnage, dans l'ordre croissant de gêne. More...
enum class	EquipmentSlot { Head , Neck , Cloak , Torso , Belt , Hands , RingLeft , RingRight , MainHand , OffHand , Ranged , Ammunition , Feet , Bracers , Pouch , Trinket }
	Les seize emplacements d'équipement de la planche 2 du corpus. More...
enum class	CasterProgression { None , Third , Half , Full , Pact }
	Rythme auquel une classe fait progresser le niveau de lanceur. More...
enum class	DamageType { Acid , Bludgeoning , Cold , Fire , Force , Lightning , Necrotic , Piercing , Poison , Psychic , Radiant , Slashing , Thunder }
	Type de dégâts infligés (EX-CBT-032, EX-CNT-011). More...
enum class	Condition { Blinded , Charmed , Deafened , Exhaustion , Frightened , Grappled , Incapacitated , Invisible , Paralyzed , Petrified , Poisoned , Prone , Restrained , Stunned , Unconscious }
	État affectant une créature (EX-DND-040, EX-CNT-011). More...
enum class	MagicSchool { Abjuration , Conjuration , Divination , Enchantment , Evocation , Illusion , Necromancy , Transmutation }
	École de magie d'un sort (EX-CNT-011). More...
enum class	CreatureSize { Tiny , Small , Medium , Large , Huge , Gargantuan }
	Catégorie de taille d'une créature (EX-CNT-011). More...
enum class	RegionGrade : std::uint8_t { VeryLow = 0 , Low , Normal , High , VeryHigh }
	Les cinq notes de l'encart « Regional Statistics » (EX-CNT-060). More...
enum class	RegionAxis : std::uint8_t { CitizenFreedom = 0 , CrimeAndViolence , EconomicProsperity , GovernmentCorruption , MagicAccess , MonsterPresence , PoliticalStability }
	Les sept axes, dans l'ordre où le livre les imprime. More...

Functions
EncounterRun	beginEncounter (const Encounter &encounter, const ExplorationSnapshot &exploration, GridPosition trigger, std::string defeatFlagKey)
	Engage `encounter` au point `trigger`, en mettant `exploration` de côté.
ExplorationSnapshot	endEncounter (const EncounterRun &run, CombatOutcome outcome, WorldFlags &flags)
	Termine `run`, et rend l'état d'exploration à restituer.
bool	encounterAlreadyCleared (const WorldFlags &flags, std::string_view defeatFlagKey)
	Vrai si cette rencontre a déjà été gagnée, et ne doit donc pas se redéclencher.
std::optional< EncounterTrigger >	encounterTriggerFor (const MapEntity &entity, std::string_view mapName)
	Lit `entity` comme un déclencheur de rencontre, s'il en est un.
EncounterCatalog	loadEncounters (const std::filesystem::path &encountersDir)
	Charge les rencontres depuis leur dossier (Rpg/encounters/).
std::vector< CombatantPlacement >	placeCombatants (const Encounter &encounter, GridPosition trigger)
	Place les combattants d'une rencontre autour de `trigger`.
TextPosition	positionOf (std::string_view text, std::size_t byteOffset)
	Convertit un décalage en octets en ligne et colonne.
JsonDocument	readJsonObject (std::string_view json, int supportedVersion, std::string_view origin={}, std::string_view versionField="version")
	Lit l'enveloppe commune d'un catalogue : JSON bien formé, racine objet, garde de version.
JsonDocument	readJsonObjectFromFile (const std::filesystem::path &path, int supportedVersion, std::string_view versionField="version")
	Comme readJsonObject, en lisant d'abord le fichier.
void	setAssertionHandler (AssertionHandler handler)
	Remplace le gestionnaire d'échec d'assertion (utile pour les tests).
void	handleAssertionFailure (const char condition, const char message, const char *file, int line)
	Invoque le gestionnaire d'échec d'assertion courant.
std::string_view	fileName (std::string_view path)
	Réduit un chemin source à son seul nom de fichier.
std::string	formatLogLine (std::string_view timestamp, LogLevel level, std::string_view category, std::string_view file, int line, std::string_view message)
	Compose une ligne de journalisation.
std::string	currentTimestamp ()
	Horodatage courant local, au format "HH:MM:SS".
Logger &	defaultLogger ()
	Journaliseur global de l'application (utilisé par les macros de log).
constexpr const char *	toString (LogLevel level)
	Convertit un niveau en libellé lisible.
std::optional< LogLevel >	parseLogLevel (std::string_view text)
	Convertit une chaîne en niveau de log (insensible à la casse).
std::shared_ptr< const ClipSet >	playerClipSet ()
	Jeu de clips du personnage, migré tel quel depuis l'ancien dispositif figé (LOT-18), étendu aux états aériens/dash livrés par LOT-10/LOT-11 (LOT-48 TACHE-02).
void	advanceAnimation (Animation &animation, float fixedDelta)
	Fait progresser une seule animation d'un pas fixe (image courante, bouclage/bascule).
void	updateTopDownMovement (World &world, Entity actor, const PlayerInput &input, const TileMap &collision, const TopDownConfig &config, float fixedDelta)
	Avance un acteur d'un pas fixe : intention → vitesse → balayage → position.
GridPosition	aimedCell (GridPosition from, Vector2 facing)
	La case que vise un personnage, d'après son orientation.
InteractionTarget	findInteractionTarget (GridPosition from, Vector2 facing, const TileMap &map, const std::vector< InteractionCandidate > &candidates, const WorldFlags &flags)
	Désigne la cible d'interaction d'un personnage.
InteractionOutcome	interact (const InteractionTarget &target, WorldFlags &flags)
	Résout une interaction sur une cible désignée, en levant son drapeau s'il y a lieu.
const std::vector< InteractableKind > &	knownInteractableKinds ()
	Les familles connues de ce lot. Le LOT-15 et le LOT-09 en ajouteront.
std::size_t	spawnMapEntities (World &world, const Level &level, std::string_view mapName, const std::function< void(Entity, const MapEntity &)> &onEntity={})
	Peuple un World d'une entité par objet de la couche objects.
std::string	keyForEntity (std::string_view mapName, std::string_view entityType, int column, int row)
	La clé de drapeau d'une entité de carte : "<carte>/<type>@<colonne>,<ligne>".
std::string_view	cameraFramingModeName (CameraFramingMode mode) noexcept
	Nom JSON du mode (symétrique à parseCameraFramingMode), pour la sérialisation.
std::optional< CameraFramingMode >	parseCameraFramingMode (std::string_view name) noexcept
	Reconnaît le nom JSON d'un mode ; std::nullopt si non reconnu (mode inconnu, EX-LVL-004).
CameraFramingConfig	resolveCameraFraming (const std::optional< CameraFramingConfig > &declared, int levelWidth, int levelHeight) noexcept
	Résout le cadrage effectif d'un niveau à partir du champ déclaré (peut être absent).
std::optional< std::string >	validateCameraFramingConfig (const CameraFramingConfig &config, int levelWidth, int levelHeight)
	Valide un cadrage déclaré (EX-LVL-004) : taille de vue nulle/négative ou supérieure au niveau, zone hors bornes ou de taille nulle, ou paramètre étranger au mode retenu (roomWidthTiles/roomHeightTiles hors PerRoom/Follow, zones hors PerRoom).
constexpr bool	operator== (GridPosition left, GridPosition right) noexcept
constexpr bool	operator!= (GridPosition left, GridPosition right) noexcept
LevelOutcome	evaluateOutcome (const Aabb &playerBox, const Level &level, const std::vector< Aabb > &extraDangerBoxes={})
	Détermine l'issue du niveau à partir de la boîte du personnage.
void	buildLevelScene (World &world, const Level &level, const std::function< AtlasRegion(TileType)> &regionForTile, const std::function< void(Entity, LayerKind, TileType, int, int)> &onTileEntity={})
	Peuple un World d'une entité par tuile non vide du niveau.
constexpr bool	isValidPlaneDensity (int pixelsPerUnit) noexcept
	Densité acceptée pour un plan (EX-DEC-041).
constexpr const char *	layerKindName (LayerKind kind) noexcept
	Nom JSON d'un rôle de couche.
constexpr bool	isSolid (TileType type) noexcept
	Indique si un type de tuile bloque le déplacement de manière statique.
std::string	tileTypeName (TileType type)
	Convertit un type de tuile en son nom textuel.
std::optional< TileType >	parseTileType (std::string_view name)
	Convertit un nom textuel en type de tuile.
constexpr std::uint64_t	splitMix64 (std::uint64_t value) noexcept
	Mélange (SplitMix64) un entier 64 bits en une valeur bien distribuée.
constexpr std::uint64_t	deriveSeed (std::uint64_t baseSeed, std::uint64_t step, std::uint64_t entityId) noexcept
	Combine une graine de base, un numéro de pas et un identifiant reproductible en une graine unique, propre à ce triplet (LOT-53 TACHE-01).
bool	approximatelyEqual (float lhs, float rhs, float tolerance=EPSILON)
	Compare deux flottants à une tolérance relative-absolue près.
Vector2	operator+ (const Vector2 &lhs, const Vector2 &rhs)
Vector2	operator- (const Vector2 &lhs, const Vector2 &rhs)
Vector2	operator* (const Vector2 &vector, float scalar)
Vector2	operator* (float scalar, const Vector2 &vector)
Vector2	operator/ (const Vector2 &vector, float scalar)
Vector2	operator- (const Vector2 &vector)
bool	operator== (const Vector2 &lhs, const Vector2 &rhs)
	Égalité approchée entre deux vecteurs (comparaison par tolérance).
bool	operator!= (const Vector2 &lhs, const Vector2 &rhs)
SweepResult	sweepAabbVsAabb (const Aabb &box, const Vector2 &delta, const Aabb &obstacle) noexcept
	Déplace `box` de `delta` en s'arrêtant au premier contact avec `obstacle`, une boîte fixe unique (pas une grille), puis en glissant le long de sa surface pour le déplacement résiduel.
Vector2	playerSize ()
Vector2	playerSpawnPosition (int column, int row)
	Coin haut-gauche du personnage centré dans la tuile (`column`, `row`).
SweepResult	sweepAabb (const Aabb &box, const Vector2 &delta, const TileMap &tiles)
	Déplace `box` de `delta` en s'arrêtant au premier contact avec une tuile solide, puis en glissant le long de la surface pour le déplacement résiduel.
bool	isValidAssetKey (std::string_view key)
	Vrai si `key` respecte la syntaxe d'une clé d'asset.
std::optional< AssetKey >	parseAssetKey (std::string_view key)
	Décompose `key`. std::nullopt si elle est malformée — jamais devinée.
std::string	defaultAssetKeyFor (std::string_view family, std::string_view id)
	La clé par défaut d'une entrée : famille/identifiant.
AssetFamilyTable	loadAssetFamilies (const std::filesystem::path &familiesFile)
	Charge la table des familles depuis Assets/Entities/families.json.
std::vector< ExpectedAssetKey >	expectedAssetKeys (const std::filesystem::path &rpgDir, const AssetFamilyTable &families, std::vector< std::string > &errors)
	Énumère les clés qu'attendent les catalogues de `rpgDir`, selon `families`.
std::uint32_t	stableAssetHash (std::string_view key)
	Le hachage stable dont assetMarker tire sa teinte.
MarkerImage	assetMarker (std::string_view key, int width, int height)
	Peint le marqueur d'une clé d'asset.
std::string_view	abilityName (Ability ability) noexcept
	Nom textuel d'une caractéristique, tel que les données l'écrivent.
std::optional< Ability >	parseAbility (std::string_view name) noexcept
	Inverse d'abilityName. std::nullopt si le nom est inconnu — jamais deviné.
std::span< const Ability >	allAbilities () noexcept
	Les six caractéristiques, dans l'ordre de la fiche.
constexpr int	abilityModifier (int score) noexcept
	Modificateur d'une valeur de caractéristique : (score - 10) / 2, arrondi vers le bas.
Bestiary	loadBestiary (const std::filesystem::path &directory)
	Charge toutes les créatures d'un dossier — un fichier JSON par créature.
int	abilityScoreWith (const Species &species, Ability which, int baseScore, int maximumScore)
	Applique les augmentations d'une espèce à une valeur de caractéristique.
CharacterOptions	loadCharacterOptions (const std::filesystem::path &speciesDir, const std::filesystem::path &backgroundsDir, const std::filesystem::path &classesDir)
	Charge les trois catalogues depuis leurs dossiers.
CharacterCreationRules	loadCharacterCreationRules (const std::filesystem::path &path)
	Charge les constantes depuis Source/Elements/Rpg/rules/character-creation.json.
ExperienceTable	loadExperienceTable (const std::filesystem::path &path)
	Charge la table d'expérience depuis Source/Elements/Rpg/rules/experience.json.
LoadedCharacterSheet	loadCharacterSheet (const std::filesystem::path &path, const CharacterOptions &options, const CharacterCreationRules &rules, const ExperienceTable &table)
	Charge un personnage depuis son fichier JSON (Source/Elements/Rpg/characters/, schéma character.schema.json) et construit sa fiche.
int	proficiencyBonus (const CharacterSheet &sheet, const ExperienceTable &table)
	Le bonus de maîtrise de la fiche, lu dans la table au niveau courant.
int	savingThrowModifier (const CharacterSheet &sheet, const ExperienceTable &table, Ability which)
	Le modificateur d'un jet de sauvegarde : caractéristique, plus la maîtrise si elle s'applique.
SkillCheckModifier	skillModifier (const CharacterSheet &sheet, const ExperienceTable &table, const SkillCatalog &catalog, std::string_view skillId)
int	maximumHitPointsFor (int hitDie, int level, int constitutionModifier)
	Les points de vie d'un niveau, selon la règle du livre.
LevelUpResult	gainExperience (CharacterSheet &sheet, const ExperienceTable &table, int hitDie, int amount)
	Ajoute des points d'expérience et applique la montée de niveau qui en découle.
CharacterSheet	buildCharacterSheet (std::string name, const std::array< int, 6 > &baseAbilities, const Species species, const PlayableClass playableClass, const Background *background, const CharacterCreationRules &rules, const ExperienceTable &table)
	Construit une fiche depuis une espèce, une classe et un historique.
CheckResult	rollCheck (int target, std::span< const Modifier > modifiers, RollStance stance, DeterministicRandom &random)
	Lance un d20 contre un seuil.
std::string_view	rollStanceName (RollStance stance) noexcept
	Nom textuel d'une posture, pour les journaux et la restitution.
constexpr RollStance	rollStance (int advantageSources, int disadvantageSources) noexcept
	Détermine la posture depuis le nombre de sources de chaque type (EX-DND-002).
std::optional< Dice >	parseDice (std::string_view notation)
	Analyse une notation NdF, NdF+M, NdF-M ou une valeur fixe.
std::string	formatDice (const Dice &dice)
	Réécrit une expression en notation canonique (2d6+3, 1d8, 4).
DiceRoll	rollDice (const Dice &dice, DeterministicRandom &random)
	Lance une expression avec un générateur déterministe.
std::string_view	armorCategoryName (ArmorCategory category)
	Nom textuel d'une catégorie d'armure, tel que la donnée l'écrit.
std::optional< ArmorCategory >	parseArmorCategory (std::string_view name)
	Inverse d'armorCategoryName. std::nullopt si le nom est inconnu — jamais deviné.
EquipmentCatalog	loadEquipment (const std::filesystem::path &weaponsDir, const std::filesystem::path &armorsDir)
	Charge les armes et les armures depuis leurs dossiers.
int	armorClassFor (const CharacterSheet &sheet, const CharacterCreationRules &rules, const Armor armor, const Armor shield)
	La classe d'armure d'un personnage, armure et bouclier compris.
int	totalWeightGrams (const std::vector< InventoryEntry > &entries)
	Le poids total d'un inventaire, en grammes.
std::string_view	equipmentSlotName (EquipmentSlot slot)
	Nom textuel d'un emplacement, tel que la donnée et les clés de traduction l'écrivent.
std::optional< EquipmentSlot >	parseEquipmentSlot (std::string_view name)
	Inverse d'equipmentSlotName. std::nullopt si le nom est inconnu — jamais deviné.
ItemCatalog	loadItems (const std::filesystem::path &itemsDir)
	Charge les objets depuis leur dossier (Rpg/items/).
EncumbranceRules	loadEncumbranceRules (const std::filesystem::path &rulesFile)
	Charge les bornes de charge depuis rules/encumbrance.json.
std::string	equip (Inventory &inventory, EquipmentSlot slot, std::string itemId)
	Équipe `itemId` à `slot`, et rend ce que l'emplacement portait.
std::string	unequip (Inventory &inventory, EquipmentSlot slot)
	Retire ce que `slot` porte.
void	addToBackpack (Inventory &inventory, const std::string &itemId, int quantity=1)
	Ajoute `quantity` exemplaires de `itemId` au sac, en empilant si la ligne existe déjà.
int	removeFromBackpack (Inventory &inventory, const std::string &itemId, int quantity=1)
	Retire `quantity` exemplaires de `itemId`.
int	carriedWeightGrams (const Inventory &inventory, const ItemLookup &lookup)
	Le poids total porté, sac et équipement compris, en grammes.
std::vector< std::string >	unknownIds (const Inventory &inventory, const ItemLookup &lookup)
	Les identifiants que les catalogues ne portent pas — un sac qui en contient ne pèse pas ce qu'il devrait, et le dire vaut mieux que de peser faux en silence.
DerivedStats	derivedStatsFor (const CharacterSheet &sheet, const Inventory &inventory, const ItemLookup &lookup, const CharacterCreationRules &creation, const EncumbranceRules &carrying)
	Calcule tout ce que l'équipement porté produit, depuis la fiche et les catalogues.
int	multiclassCasterLevel (std::span< const ClassLevel > classes)
	Niveau de lanceur cumulé d'un personnage multiclassé.
std::string_view	casterProgressionName (CasterProgression progression)
	Nom textuel d'une progression, tel que multiclassing.json l'écrit.
std::optional< CasterProgression >	parseCasterProgression (std::string_view name)
	Convertit le nom d'une progression, tel que la donnée l'écrit, en valeur.
constexpr float	tilesFromMeters (float meters) noexcept
	Convertit une distance en mètres — telle que le corpus l'écrit — en nombre de cases.
constexpr float	metersFromTiles (float tiles) noexcept
	Convertit un nombre de cases en mètres, pour l'affichage et les infobulles.
SkillCatalog	loadSkills (const std::filesystem::path &directory)
	Charge le catalogue des compétences depuis son dossier.
std::string_view	regionGradeName (RegionGrade grade)
	Le nom d'une note, tel que le schéma l'écrit (veryLow, normal, …).
std::optional< RegionGrade >	regionGradeFromName (std::string_view name)
	La note portant ce nom de schéma, ou std::nullopt.
std::string_view	regionAxisName (RegionAxis axis)
	Le nom d'un axe, tel que le schéma l'écrit (citizenFreedom, …).
Atlas	loadAtlas (const std::filesystem::path &directory)
	Charge l'atlas — regions/ et locations/ sous le dossier donné.
Noms textuels
Point unique de vérité de la correspondance valeur ↔ nom, partagé par les catalogues de données (Source/Elements/Rpg/), leurs schémas JSON et le moteur. Deux tables distinctes divergeraient au premier type ajouté — et le scénario qu'EX-CNT-011 décrit se produirait : la donnée déclare un type que le moteur ne connaît pas, la valeur tombe dans un cas par défaut, et le sort cesse de faire des dégâts sans que rien ne l'annonce. Chaque switch est exhaustif et sans default : ajouter une valeur à une énumération sans lui donner de nom devient une erreur de compilation (/W4 /WX), jamais un nom faux. Les noms sont ceux du lexique de traduction (LOT-30) : ce sont les termes anglais que la table d'autorité porte sous les catégories type de dégâts, état et école de magie.
std::string	damageTypeName (DamageType type)
std::string	conditionName (Condition condition)
std::string	magicSchoolName (MagicSchool school)
std::string	creatureSizeName (CreatureSize size)
Analyse d'un nom
Inverses exacts des fonctions ci-dessus : tout nom qu'elles produisent est accepté ici, et réciproquement. Un nom inconnu renvoie std::nullopt — c'est une donnée invalide à signaler, jamais une valeur devinée.
std::optional< DamageType >	parseDamageType (std::string_view name)
std::optional< Condition >	parseCondition (std::string_view name)
std::optional< MagicSchool >	parseMagicSchool (std::string_view name)
std::optional< CreatureSize >	parseCreatureSize (std::string_view name)
Énumération complète
Les valeurs de chaque énumération, dans l'ordre de déclaration. Ce sont ces vues qui permettent à un test de balayer une énumération sans coder en dur sa dernière valeur : la borne d'un parcours écrite à la main est la première chose qui vieillit, et un type ajouté après elle échapperait en silence à tous les contrôles.
std::span< const DamageType >	allDamageTypes ()
std::span< const Condition >	allConditions ()
std::span< const MagicSchool >	allMagicSchools ()
std::span< const CreatureSize >	allCreatureSizes ()

Variables
constexpr bool	DEVELOPER_BUILD = true
	Vrai dans les builds de développement (Debug), faux en Release.
constexpr std::string_view	ENCOUNTER_ENTITY_TYPE = "encounter"
	Type de la couche objects qui déclenche une rencontre.
constexpr Entity	INVALID_ENTITY {Entity::INVALID_INDEX, 0}
	Entité invalide conventionnelle : ne désigne jamais une entité vivante.
constexpr int	PLAYER_CLIP_IDLE = 0
	Index du clip « idle » dans core::playerClipSet() — ordre stable, seule source de vérité partagée avec hmi::TextureAtlas::playerFrameRegion (traduction en région d'atlas, LOT-46 TACHE-04) : ne pas réordonner sans mettre à jour HMI en conséquence.
constexpr int	PLAYER_CLIP_RUN = 1
	Index du clip « run » dans core::playerClipSet() (voir PLAYER_CLIP_IDLE).
constexpr int	PLAYER_CLIP_JUMP = 2
	Index du clip « jump » dans core::playerClipSet() (voir PLAYER_CLIP_IDLE).
constexpr int	PLAYER_CLIP_FALL = 3
	Index du clip « fall » (chute, distincte du saut, LOT-48) dans core::playerClipSet().
constexpr int	PLAYER_CLIP_LAND = 4
	Index du clip « land » (atterrissage, transition jouée une fois, LOT-48) dans core::playerClipSet().
constexpr int	PLAYER_CLIP_WALLSLIDE = 5
	Index du clip « wallslide » (glissade murale, LOT-48) dans core::playerClipSet().
constexpr int	PLAYER_CLIP_DASH = 6
	Index du clip « dash » dans core::playerClipSet() (voir PLAYER_CLIP_IDLE).
constexpr std::uint64_t	DEFAULT_PARTICLE_SEED = 0x504152544943454CULL
	Graine par défaut de core::ParticleSystem – fixe et documentée, jamais l'horloge système (EX-NFR-002) : deux sessions démarrées avec cette graine et soumises à la même séquence d'entrées produisent exactement les mêmes particules.
constexpr int	MAX_PARTICLES = 256
	Nombre maximal de particules simultanément vivantes (EX-NFR-005) : au-delà, spawn() recycle les plus anciennes plutôt que d'allouer sans borne.
constexpr float	LANDING_MIN_IMPACT_SPEED = 4.0f
	Vitesse d'impact (LOT-53 TACHE-02) en-dessous de laquelle un atterrissage ne produit aucune poussière – sans ce seuil, chaque petit pas en émettrait.
constexpr float	LANDING_MAX_IMPACT_SPEED = 14.0f
	Vitesse d'impact au-delà de laquelle l'intensité de la poussière plafonne (LANDING_DUST_MAX_ COUNT) : une chute extrême ne produit pas un nuage toujours plus dense.
constexpr int	LANDING_DUST_MIN_COUNT = 3
	Nombre de particules de poussière au seuil LANDING_MIN_IMPACT_SPEED (intensité minimale).
constexpr int	LANDING_DUST_MAX_COUNT = 10
	Nombre de particules de poussière au plafond LANDING_MAX_IMPACT_SPEED (intensité maximale).
constexpr int	DEFAULT_ROOM_WIDTH_TILES = 24
	Taille de salle par défaut du mode par salle, en cases.
constexpr int	DEFAULT_ROOM_HEIGHT_TILES = 14
constexpr int	LEVEL_FORMAT_VERSION = 3
	Version courante du format de niveau JSON (EX-LVL-005).
constexpr int	PLANE_NATIVE_PIXELS_PER_UNIT = 16
	Densité native d'un plan, en pixels par unité monde — même valeur que l'échelle de rendu (hmi::Camera2D::PIXELS_PER_UNIT), que Core ne peut pas inclure (EX-NFR-011).
constexpr std::size_t	MAX_PLANES_PER_LEVEL = 16
	Nombre maximal de plans par niveau (EX-DEC-044) : borne le coût dans le format, plutôt que de le laisser à l'usage.
constexpr int	MAX_PLANE_TEXTURE_EXTENT = 16384
	Dimension maximale, en pixels, d'une texture de plan sur un axe (EX-DEC-044) — limite de Direct3D 11 au feature level 11.
constexpr int	LAYER_KIND_COUNT = static_cast<int>(LayerKind::Legacy) + 1
	Nombre de valeurs de core::LayerKind — même convention que core::TILE_TYPE_COUNT : toute valeur ajoutée doit l'être avant le dernier énumérateur.
constexpr int	TILE_TYPE_COUNT = static_cast<int>(TileType::Stairs) + 1
	Nombre de valeurs de core::TileType — seule source de vérité de la fin de l'énumération (LOT-74 TACHE-02).
constexpr float	EPSILON = 1e-5f
	Tolérance par défaut pour les comparaisons de flottants issus de calculs.
constexpr float	COLLISION_SKIN = 1e-4F
	Tolérance géométrique des routines de balayage, en unités monde.
constexpr float	PLAYER_WIDTH = 0.4f
	Largeur du personnage, en unités monde (une tuile = 1 unité).
constexpr float	PLAYER_HEIGHT = 0.8f
	Hauteur du personnage, en unités monde.
constexpr int	D20_FACES = 20
	Nombre de faces du dé de résolution. Le d20 est la mécanique centrale du jeu.
constexpr std::size_t	EQUIPMENT_SLOT_COUNT = 16
	Nombre d'emplacements, pour dimensionner les tableaux qui les indexent.
constexpr float	METERS_PER_TILE = 1.5f
	Côté d'une case de la grille tactique, en mètres.
constexpr std::size_t	kRegionGradeCount = 5
	Nombre de notes — pour les parcours exhaustifs et les contrôles de couverture.
constexpr std::size_t	kRegionAxisCount = 7
	Nombre d'axes.

Detailed Description

Espace de noms du moteur et de la logique de jeu.

Typedef Documentation

◆ AssertionHandler

using core::AssertionHandler

Initial value:

std::function<void(const char* condition, const char* message, const char* file, int line)>

Signature d'un gestionnaire d'échec d'assertion.

◆ PropertyMap

using core::PropertyMap = std::map<std::string, PropertyValue>

Propriétés libres, indexées par nom.

C'est le mécanisme qui évite un version: 4. Un besoin découvert plus tard — terrain difficile, couverture, hauteur, dialogue d'un PNJ — s'exprime comme une propriété, jamais comme un nouveau champ du format. Le chargeur y range en outre toute clé qu'il ne reconnaît pas, et l'écrivain les réémet : un fichier produit par une version ultérieure de l'éditeur traverse donc une version antérieure sans rien perdre.

std::map (ordonné) et non unordered_map : l'écriture doit être déterministe, faute de quoi deux enregistrements du même niveau produiraient des fichiers différents et pollueraient chaque diff.

Note: Limite assumée : une valeur composite (objet ou tableau JSON) ne rentre pas dans PropertyValue et n'est donc pas préservée. Le format n'en produit aucune aujourd'hui ; le jour où il en faudra une, ce sera un champ à part entière, pas une propriété libre.

◆ PropertyValue

using core::PropertyValue = std::variant<bool, std::int64_t, double, std::string>

Valeur d'une propriété libre : booléen, entier, réel ou chaîne.

Volontairement un type de Core, jamais un nlohmann::json : Core ne connaît pas le format de fichier (EX-ARCH-001), et la bibliothèque JSON lui est liée en PRIVATE — l'exposer dans un en-tête la propagerait à tous ses consommateurs.

Enumeration Type Documentation

◆ Ability

enum class core::Ability

strong

Une des six caractéristiques d'un personnage ou d'une créature (EX-DND-010).

Ensemble fermé : six valeurs, fixées par les règles. Les noms textuels sont ceux du lexique (LOT-30) et de common.schema.json, et scripts/check_rpg_data.py vérifie que les trois listes coïncident.

Enumerator
Strength
Dexterity
Constitution
Intelligence
Wisdom
Charisma

◆ ArmorCategory

enum class core::ArmorCategory

strong

Catégorie d'armure. Ensemble fermé : le livre n'en connaît pas d'autre.

Enumerator
Light
Medium
Heavy
Shield	Le bouclier n'est pas une armure : il ajoute à la classe d'armure au lieu de la remplacer. Le ranger dans la même énumération vient du livre, qui le met dans la même table ; les confondre dans le calcul donnerait un personnage en bouclier seul avec une CA de 2.

◆ CameraFramingMode

enum class core::CameraFramingMode

strong

Mode de cadrage de caméra d'un niveau (EX-REN-016) : décision de conception, pas une règle déduite de ses dimensions.

Enumerator
WholeLevel	Le niveau entier tient dans le cadre (EX-REN-013).
PerRoom	Cadrage salle par salle, coupure nette au franchissement (EX-REN-015).
Follow	Caméra de suivi du personnage (zone morte, anticipation, bornage).

◆ CasterProgression

enum class core::CasterProgression

strong

Rythme auquel une classe fait progresser le niveau de lanceur.

Les valeurs viennent d'une phrase du Manuel des Joueurs (p. 166), citée mot pour mot dans scripts/sourcebook/options.py : « additionnez tous les niveaux dans vos classes de barde, de druide, de clerc, d'ensorceleur et de magicien, la moitié de vos niveaux (arrondis à l'entier inférieur) dans les classes de paladin et rôdeur, et un tiers de vos niveaux de guerrier et de roublard (arrondis à l'entier inférieur) si vous avez choisi l'archétype de chevalier occulte ou d'arnaqueur arcanique. »

La correspondance classe → progression est une donnée (Source/Elements/Rpg/rules/multiclassing.json) ; ce type n'en porte que le vocabulaire.

Enumerator
None	La classe n'apporte rien au niveau de lanceur — barbare, moine.
Third	Un tiers des niveaux, arrondi à l'inférieur — guerrier et roublard, sous archétype.
Half	La moitié des niveaux, arrondie à l'inférieur — paladin, rôdeur.
Full	La totalité des niveaux — barde, clerc, druide, ensorceleur, magicien.
Pact	Magie de pacte : n'entre pas dans la somme (EX-RPG-052).

◆ ClipEndMode

enum class core::ClipEndMode

strong

Manière dont un clip se termine à la dernière image.

Enumerator
Loop	Revient à la première image et continue (comportement historique, EX-REN-012).
OneShot	S'arrête à la dernière image puis bascule sur AnimationClip::nextClip (LOT-47).

◆ CombatOutcome

enum class core::CombatOutcome

strong

Comment un combat se termine.

Enumerator
Victory	Tous les ennemis sont hors de combat.
Flight	Le joueur a rompu le contact. Les ennemis restent sur la carte.
Defeat	Le groupe est tombé.

◆ Condition

enum class core::Condition

strong

État affectant une créature (EX-DND-040, EX-CNT-011).

Ensemble fermé : quinze valeurs. Exhaustion est la seule à ne pas être binaire — elle se mesure en six niveaux — mais elle reste une condition, et l'omettre de cette liste (comme le glossaire du corpus l'omettait de sa catégorie) reviendrait à la rendre invisible au moteur.

Note: L'énumération ne dit rien de l'effet d'une condition : c'est l'objet du catalogue Source/Elements/Rpg/conditions/, décrit par condition.schema.json. Une énumération qui porterait les effets les figerait dans le C++, ce qu'EX-VIS-007 interdit.

Enumerator
Blinded
Charmed
Deafened
Exhaustion
Frightened
Grappled
Incapacitated
Invisible
Paralyzed
Petrified
Poisoned
Prone
Restrained
Stunned
Unconscious

◆ CreatureSize

enum class core::CreatureSize

strong

Catégorie de taille d'une créature (EX-CNT-011).

Ensemble fermé : six valeurs, fixées par les règles. Ce n'est pas une donnée décorative — la taille détermine l'emprise sur la grille tactique (LOT-19) et ce qu'une créature peut agripper ou engloutir.

Note: Le lexique du LOT-30 n'en porte que cinq sous la catégorie taille : « Moyenne » manque à l'extraction du glossaire. C'est pourquoi la coïncidence de cette énumération se vérifie contre common.schema.json, qui les porte toutes les six, et non contre le lexique comme les trois autres.

Enumerator
Tiny
Small
Medium
Large
Huge
Gargantuan

◆ DamageType

enum class core::DamageType

strong

Type de dégâts infligés (EX-CBT-032, EX-CNT-011).

Ensemble fermé : treize valeurs, fixées par les règles et non par le corpus. Les trois premières sont les dégâts physiques — contondant, perforant, tranchant — dont dépend la résistance des créatures aux armes non magiques ; les dix autres sont élémentaires ou surnaturels. Un type inconnu du moteur ne doit jamais tomber dans un cas par défaut silencieux (EX-CBT-032) — d'où le switch exhaustif de Core/Rpg/RpgEnumNames.h.

Les noms textuels sont ceux du lexique de traduction (LOT-30), catégorie type de dégâts : scripts/check_rpg_data.py vérifie que les treize valeurs de cette énumération sont exactement les treize termes anglais que le lexique porte sous cette catégorie. Le moteur, les schémas et la table d'autorité de traduction disent donc le même mot pour la même chose, ou la CI échoue.

Enumerator
Acid
Bludgeoning
Cold
Fire
Force
Lightning
Necrotic
Piercing
Poison
Psychic
Radiant
Slashing
Thunder

◆ EncumbranceLevel

enum class core::EncumbranceLevel

strong

État de charge d'un personnage, dans l'ordre croissant de gêne.

Enumerator
Unencumbered	Rien ne le ralentit.
Encumbered	Au-delà du premier seuil : vitesse diminuée.
HeavilyEncumbered	Au-delà du second : vitesse diminuée davantage, et désavantage.
OverCapacity	Au-delà de la capacité de charge : il ne peut plus porter.

◆ EquipmentSlot

enum class core::EquipmentSlot

strong

Les seize emplacements d'équipement de la planche 2 du corpus.

L'ordre est celui de la feuille, colonne gauche puis colonne droite, et il est relevé et non choisi : c'est celui que l'écran d'inventaire suit pour poser ses lignes.

Enumerator
Head
Neck
Cloak
Torso
Belt
Hands
RingLeft
RingRight
MainHand
OffHand
Ranged
Ammunition
Feet
Bracers
Pouch
Trinket

◆ JsonReadError

enum class core::JsonReadError

strong

Catégorie d'échec de lecture d'un document JSON.

Les cinq catégories que les six lecteurs du dépôt avaient chacun redéfinies pour leur compte (hmi::SkinCatalogError, hmi::SoundCatalogError, hmi::AnimationCatalogError…). Elles sont ici une seule fois : deux définitions de « version non gérée » finissent par diverger sur ce qu'elles recouvrent.

Enumerator
None	Pas d'erreur.
FileNotFound	Fichier absent ou illisible.
ParseError	JSON malformé, ou racine qui n'est pas un objet.
UnsupportedVersion	Numéro de version supérieur à celui que le lecteur sait lire.
MalformedStructure	Structure inattendue (champ absent, type incorrect…).

◆ LayerKind

enum class core::LayerKind

strong

Rôle d'une couche de tuiles dans une carte.

Un RPG en vue de dessus a besoin d'au moins trois couches là où un jeu de plateforme se contentait d'une grille unique :

Ground — ce qu'on voit sous les pieds (herbe, dalle, eau) ;
Decor — dessiné au-dessus du sol, et devant ou derrière le personnage selon sa position (arbre, tonneau, tapis) ;
Collision — masque indépendant du visuel : un tapis se traverse, un tonneau non, et les deux peuvent reposer sur la même image de sol. C'est cette couche, et elle seule, que consomment le balayage AABB puis la grille de combat tactique (LOT-19).

Legacy désigne la grille unique d'une carte au format version: 2, promue telle quelle au chargement : elle vaut à la fois décor et collision, comme dans le format d'origine.

Enumerator
Ground
Decor
Collision
Legacy

◆ LevelOutcome

enum class core::LevelOutcome

strong

Issue courante d'un niveau, déduite de la position du personnage.

Enumerator
Playing	Partie en cours.
Won	Le personnage a atteint la sortie (EX-GP-030).
Lost	Le personnage a touché un danger ou est sorti par le bas (EX-GP-031).

◆ LevelValidationError

enum class core::LevelValidationError

strong

Catégorie d'échec de chargement/validation d'un niveau (LOT-15, EX-EDIT-012).

Complète le message technique (LevelLoadResult::error) d'un code programmatique, pour qu'un appelant (l'éditeur) puisse traduire une erreur en message non-codeur sans dépendre du texte exact du message — une correspondance de sous-chaînes s'y casserait silencieusement au moindre changement de formulation.

Enumerator
None	Pas d'erreur (chargement réussi).
ParseError	JSON malformé, champ obligatoire manquant, ou de mauvais type.
UnknownTileType	Type de tuile non reconnu.
OutOfBounds	Tuile positionnée hors des dimensions déclarées.
DuplicatePosition	Deux tuiles à la même position.
MissingSwitchId	Interrupteur sans identifiant.
DuplicateSwitchId	Deux interrupteurs partagent le même identifiant.
InvalidEntryCount	Zéro ou plusieurs tuiles d'entrée (une seule attendue).
InvalidExitCount	Zéro ou plusieurs tuiles de sortie (une seule attendue).
UnresolvedMechanism	Porte ou danger commuté lié à un identifiant d'interrupteur inexistant.
FileNotFound	Fichier de niveau introuvable sur disque.
UnsupportedFormatVersion	"version" du fichier supérieure à celle gérée (EX-LVL-005).
InvalidCameraFraming	Cadrage de caméra invalide (EX-LVL-006) : mode inconnu, taille de salle nulle/supérieure au niveau, ou paramètre étranger au mode retenu.

◆ LogLevel

enum class core::LogLevel

strong

Niveau d'un message de journalisation (ordre croissant de gravité).

Enumerator
Trace	Détails fins de débogage.
Info	Information de fonctionnement normal.
Warning	Anomalie non bloquante.
Error	Erreur nécessitant attention.

◆ MagicSchool

enum class core::MagicSchool

strong

École de magie d'un sort (EX-CNT-011).

Ensemble fermé : huit valeurs. Attention au faux ami que le lexique fige : Conjuration se traduit « invocation » en français, jamais « conjuration ».

Enumerator
Abjuration
Conjuration
Divination
Enchantment
Evocation
Illusion
Necromancy
Transmutation

◆ ParticleKind

enum class core::ParticleKind

strong

Effet visuel à l'origine d'une particule – tag opaque pour Core, exploité par le rendu (HMI) pour choisir calque, teinte et texture (LOT-53 TACHE-03), sans que Core n'ait à connaître ces notions de présentation (EX-NFR-011).

Enumerator
DashTrail	Traînée continue émise pendant un dash (LOT-53 TACHE-02).
LandingDust	Bouffée de poussière à l'atterrissage.
Death	Éclatement à la mort du personnage.

◆ PlaneDepth

enum class core::PlaneDepth

strong

Position d'un plan dans l'ordonnancement de rendu, relativement au personnage (EX-DEC-042).

Deux valeurs, pas trois. Le système de décors qu'il remplace en déclarait trois (Background, Decor, Foreground) mais la projection vers les calques de rendu en écrasait déjà deux sur la même : les trois couches de conception n'exprimaient que deux intentions de superposition. On acte la simplification plutôt que de la reproduire.

Core ne connaît pas hmi::RenderLayer (EX-NFR-011) : la projection vers les calques de rendu est le travail de HMI.

Enumerator
Behind	Derrière les tuiles physiques.
Front	Devant le personnage (EX-DEC-042) : c'est le moyen de lecture qui distingue d'un coup d'œil le décor traversable du décor physique.

◆ RegionAxis

enum class core::RegionAxis : std::uint8_t

strong

Les sept axes, dans l'ordre où le livre les imprime.

Enumerator
CitizenFreedom
CrimeAndViolence
EconomicProsperity
GovernmentCorruption
MagicAccess
MonsterPresence
PoliticalStability

◆ RegionGrade

enum class core::RegionGrade : std::uint8_t

strong

Les cinq notes de l'encart « Regional Statistics » (EX-CNT-060).

Fermée, et ordonnée du plus bas au plus haut : une note se compare, et c'est tout l'intérêt de la typer. monsterPresence >= RegionGrade::High doit vouloir dire quelque chose, sinon autant garder la chaîne du livre.

Les valeurs coïncident avec l'énumération de region.schema.json ; test_atlas.cpp le vérifie (EX-CNT-011).

Enumerator
VeryLow
Low
Normal
High
VeryHigh

◆ RollStance

enum class core::RollStance

strong

Comment le d20 est lancé.

Advantage et Disadvantage ne se cumulent pas (EX-DND-002) : plusieurs sources d'avantage donnent un avantage, et une source de chaque s'annule entièrement. C'est rollStance qui applique cette règle, à partir du décompte des sources — jamais l'appelant, qui aurait à arbitrer une pile de bonus contre toutes les autres à chaque capacité ajoutée.

Enumerator
Normal
Advantage
Disadvantage

◆ TileType

enum class core::TileType

strong

Type d'une tuile de la grille d'une carte (EX-GP-001).

Empty est la case traversable par défaut ; Solid bloque le déplacement ; Danger provoque l'échec au contact ; Entry/Exit sont l'apparition et la sortie. Switch, PressurePlate et Door sont les mécanismes classiques — l'interrupteur bascule au contact, la plaque reste active tant qu'un poids y repose, les deux ouvrant une porte liée. Key/LockedDoor sont la seconde paire déclencheur↔cible, la clé ouvrant sa porte définitivement. Block est un bloc poussable.

Le LOT-08 y ajoute le vocabulaire du terrain en vue de dessus (EX-EXP-005) : Grass, Dirt, Sand, Water et DeepWater (sols, les quatre premiers traversables), Wall et Cliff (obstacles), Bridge et Stairs (passages). Il ajoute sans rien remplacer : le vocabulaire de puzzle hérité sert tel quel au RPG.

Note: Le LOT-01 avait retiré les types propres au jeu de plateforme (pentes, arrondis, blocs réduits, plateformes mobiles, blocs volatils, dangers directionnels, mobiles et temporisés), sans objet en vue de dessus.

Enumerator
Empty
Solid
Danger
Entry
Exit
Switch
Door
PressurePlate
Block
Key
LockedDoor
Grass	Herbe : le sol par défaut d'une carte extérieure.
Dirt	Terre battue : chemins, cours, sols d'intérieur sommaires.
Sand	Sable : plages et déserts. Traversable, comme l'herbe et la terre.
Water	Eau peu profonde : traversable — on y patauge. Sa distinction d'avec DeepWater est la seule chose qui permette à une rive d'exister.
DeepWater	Eau profonde : infranchissable tant qu'aucune règle de nage n'existe (isSolid).
Wall	Mur : la matière pleine bâtie, distincte de Solid (matière générique du socle) parce que l'éditeur et l'habillage doivent pouvoir les vêtir différemment.
Cliff	Falaise : rupture de relief infranchissable, l'obstacle naturel du décor extérieur.
Bridge	Pont : franchit l'eau ou un ravin. Traversable, et c'est tout son intérêt.
Stairs	Escalier : liaison verticale d'une carte à l'autre, traversable. Ce qu'il relie est une donnée du graphe de cartes (LOT-09), jamais du type de tuile.

Function Documentation

◆ abilityModifier()

int core::abilityModifier ( int score )

nodiscardconstexprnoexcept

Modificateur d'une valeur de caractéristique : (score - 10) / 2, arrondi vers le bas.

L'arrondi est le piège de cette fonction, et il ne se voit que sur les scores impairs inférieurs à 10. En C++, la division entière tronque vers zéro : (7 - 10) / 2 vaut -1, alors que la règle donne -2. Un personnage avec 7 en Force serait donc moins pénalisé qu'il ne doit l'être, sur chacun de ses jets, pendant toute la partie — et le défaut est invisible à la lecture puisque la formule a l'air juste.

L'implémentation décale donc de 1 vers le bas avant de diviser, ce qui revient au plancher pour les valeurs négatives comme positives.

Parameters

score Valeur de caractéristique, typiquement dans [1, 30].

Returns: Le modificateur : -5 pour 1, 0 pour 10 et 11, +5 pour 20.

◆ abilityName()

std::string_view core::abilityName ( Ability ability )

nodiscardnoexcept

Nom textuel d'une caractéristique, tel que les données l'écrivent.

◆ abilityScoreWith()

int core::abilityScoreWith	(	const Species &	species,
		Ability	which,
		int	baseScore,
		int	maximumScore )

nodiscard

Applique les augmentations d'une espèce à une valeur de caractéristique.

La seule opération que le moteur ait à faire sur une espèce, et elle est ici pour ne pas être réécrite à chaque écran qui affiche une fiche.

maximumScore est un paramètre et non une constante (EX-VIS-007) : le plafond vient de rules/character-creation.json, où il est extrait de la phrase qui l'atteste — « Vous ne pouvez pas augmenter une valeur de caractéristique au-delà de 20 », Basic Rules p. 11. Écrit ici, il ferait d'un ajustement d'équilibrage une recompilation.

◆ addToBackpack()

void core::addToBackpack	(	Inventory &	inventory,
		const std::string &	itemId,
		int	quantity )

Ajoute quantity exemplaires de itemId au sac, en empilant si la ligne existe déjà.

◆ advanceAnimation()

void core::advanceAnimation	(	Animation &	animation,
		float	fixedDelta )

Fait progresser une seule animation d'un pas fixe (image courante, bouclage/bascule).

Extrait de AnimationSystem::update pour être réutilisable hors ECS : LOT-46 TACHE-05 anime des tuiles partageant un même asset (eau, lave) via une horloge unique par asset plutôt qu'une entité par case, précisément pour éviter de répéter cette progression une fois par case. Sans effet si animation.clips est nul ou vide (EX-NFR-040).

Parameters

animation	État d'animation à faire progresser.
fixedDelta	Durée du pas de simulation, en secondes.

◆ aimedCell()

GridPosition core::aimedCell	(	GridPosition	from,
		Vector2	facing )

nodiscard

La case que vise un personnage, d'après son orientation.

L'orientation est un vecteur libre (core::Actor::facing) et la case visée est la voisine dans la direction dominante — jamais une diagonale. Un personnage qui regarde à 30° vise la case de droite, pas celle du coin : viser en diagonale rendrait la cible imprévisible sur une manette analogique, alors que le joueur doit savoir ce qu'il désigne avant d'appuyer.

Une orientation nulle ne vise rien et renvoie la case du personnage lui-même : c'est le cas d'un facing non initialisé, et rendre une voisine arbitraire ferait ouvrir un coffre que le joueur ne regarde pas.

◆ allAbilities()

std::span< const Ability > core::allAbilities ( )

nodiscardnoexcept

Les six caractéristiques, dans l'ordre de la fiche.

◆ allConditions()

std::span< const Condition > core::allConditions ( )

nodiscard

◆ allCreatureSizes()

std::span< const CreatureSize > core::allCreatureSizes ( )

nodiscard

◆ allDamageTypes()

std::span< const DamageType > core::allDamageTypes ( )

nodiscard

◆ allMagicSchools()

std::span< const MagicSchool > core::allMagicSchools ( )

nodiscard

◆ approximatelyEqual()

bool core::approximatelyEqual	(	float	lhs,
		float	rhs,
		float	tolerance = EPSILON )

inlinenodiscard

Compare deux flottants à une tolérance relative-absolue près.

Évite les faux négatifs des comparaisons == brutes sur des résultats calculés, tout en restant robuste pour les grandes magnitudes (tolérance mise à l'échelle par le plus grand opérande).

Parameters

lhs	Premier opérande.
rhs	Second opérande.
tolerance	Tolérance de base (défaut : core::EPSILON).

Returns: true si les deux valeurs sont égales à la tolérance près.

◆ armorCategoryName()

std::string_view core::armorCategoryName ( ArmorCategory category )

nodiscard

Nom textuel d'une catégorie d'armure, tel que la donnée l'écrit.

◆ armorClassFor()

int core::armorClassFor	(	const CharacterSheet &	sheet,
		const CharacterCreationRules &	rules,
		const Armor *	armor,
		const Armor *	shield )

nodiscard

La classe d'armure d'un personnage, armure et bouclier compris.

Les trois formes de la table du livre disent trois règles différentes, et les réduire à leur premier nombre est la faute qui ne se voit pas :

11 + Mod.Dex — le modificateur de Dextérité s'ajoute sans plafond (armures légères) ;
14 + Mod.Dex (max +2) — il s'ajoute plafonné à 2 (armures intermédiaires) ;
18 — il ne s'ajoute pas du tout (armures lourdes).

Appliquer la Dextérité au harnois rendrait le personnage plus résistant, jamais moins : le défaut ne provoque aucune erreur et passe pour de l'équilibrage.

Sans armure, la base vient de la donnée (rules/character-creation.json, LOT-13) et non d'un 10 écrit ici (EX-VIS-007).

Parameters

sheet	La fiche, pour son modificateur de Dextérité.
rules	Les constantes de création, pour la base sans armure.
armor	L'armure portée, ou nullptr.
shield	Le bouclier porté, ou nullptr.

◆ assetMarker()

MarkerImage core::assetMarker	(	std::string_view	key,
		int	width,
		int	height )

nodiscard

Peint le marqueur d'une clé d'asset.

Pourquoi un marqueur plutôt qu'une image manquante

EX-CNT-041 : le jeu doit tourner complet avant qu'aucune illustration ne soit produite. Sans marqueur, trois cents entrées s'afficheraient comme des trous, la production graphique deviendrait un préalable bloquant, et rien ne pourrait être joué ni relu avant elle. Avec, elle devient un remplacement progressif : on remplace un marqueur par une image, une à la fois, et le jeu ne cesse jamais d'être jouable.

Déterministe, et c'est le point

La même clé donne toujours le même marqueur — même teinte, même figure. Un marqueur tiré au hasard changerait à chaque lancement : le loup ne serait plus reconnaissable d'une partie à l'autre, deux captures d'écran du même combat différeraient, et un test ne pourrait rien en dire. La teinte est donc dérivée de la clé elle-même, par un hachage stable écrit ici plutôt qu'emprunté à std::hash, dont la valeur n'est pas garantie d'une plateforme ou d'une version de bibliothèque à l'autre.

Le marqueur reste manifestement un marqueur : deux diagonales barrent la vignette, de sorte qu'on ne le prenne jamais pour une illustration définitive livrée un peu vite.

Parameters

key	La clé, famille/identifiant. Une clé malformée rend une image vide.
width	Largeur voulue, celle que la famille attend.
height	Hauteur voulue.

◆ beginEncounter()

EncounterRun core::beginEncounter	(	const Encounter &	encounter,
		const ExplorationSnapshot &	exploration,
		GridPosition	trigger,
		std::string	defeatFlagKey )

nodiscard

Engage encounter au point trigger, en mettant exploration de côté.

Parameters

encounter	La rencontre, telle que la donnée la décrit.
exploration	L'état d'exploration à retrouver ensuite.
trigger	La case du déclencheur : les combattants s'y placent relativement.
defeatFlagKey	Le drapeau qu'une victoire acquerra, ou une chaîne vide.

◆ buildCharacterSheet()

CharacterSheet core::buildCharacterSheet	(	std::string	name,
		const std::array< int, 6 > &	baseAbilities,
		const Species *	species,
		const PlayableClass *	playableClass,
		const Background *	background,
		const CharacterCreationRules &	rules,
		const ExperienceTable &	table )

nodiscard

Construit une fiche depuis une espèce, une classe et un historique.

Les trois catalogues du LOT-36 deviennent ici une fiche jouable : les augmentations de l'espèce s'appliquent aux valeurs de base, la classe donne le dé de vie et les jets de sauvegarde, l'historique les compétences maîtrisées.

Parameters

name	Le nom du personnage, tel qu'il s'affichera.
baseAbilities	Les six valeurs avant augmentation d'espèce, dans l'ordre de core::Ability.
species	Peut être nullptr — une créature sans espèce est légitime.
playableClass	Peut être nullptr, auquel cause la fiche n'a ni dé de vie ni sauvegardes.
background	Peut être nullptr.
rules	Les constantes de création, lues dans la donnée.
table	La table d'expérience, pour le seuil du niveau de départ.

◆ buildLevelScene()

void core::buildLevelScene	(	World &	world,
		const Level &	level,
		const std::function< AtlasRegion(TileType)> &	regionForTile,
		const std::function< void(Entity, LayerKind, TileType, int, int)> &	onTileEntity = {} )

Peuple un World d'une entité par tuile non vide du niveau.

Chaque tuile non Empty devient une entité portant un Transform (position = colonne, ligne en unités monde) et un Sprite (couche 0, région fournie par regionForTile). Logique pure, indépendante du rendu (EX-ARCH-011) : la correspondance type de tuile → région d'atlas est injectée, ce qui rend la projection testable sans GPU (une fausse correspondance suffit).

Parameters

world	Monde à peupler.
level	Niveau source.
regionForTile	Correspondance type de tuile → région d'atlas (dépendance de rendu injectée).
onTileEntity	Rappel invoqué après la création de chaque entité tuile, avec le rôle de sa couche, son type et sa case. Permet à la couche de présentation d'y attacher ses propres composants (hmi::TileSkinTag, LOT-42, et depuis le LOT-07 le calque de dessin d'une tuile de décor) sans que Core connaisse ni l'habillage ni les calques (EX-NFR-011) — même principe d'injection que `regionForTile`. Vide par défaut.

Le rôle est passé plutôt que l'indice de couche : ce qui décide de la présentation d'une tuile, c'est ce qu'elle est (un sol, un décor), pas son rang dans une liste que l'auteur de la carte peut réordonner.

Ne peuple que les tuiles. Les plans picturaux (EX-DEC-040, LOT-69) qui ont remplacé les décors-sprites ne sont pas des entités : ce sont des données d'habillage du niveau, composées directement par HMI sans passer par l'ECS.

◆ cameraFramingModeName()

std::string_view core::cameraFramingModeName ( CameraFramingMode mode )

nodiscardnoexcept

Nom JSON du mode (symétrique à parseCameraFramingMode), pour la sérialisation.

◆ carriedWeightGrams()

int core::carriedWeightGrams	(	const Inventory &	inventory,
		const ItemLookup &	lookup )

nodiscard

Le poids total porté, sac et équipement compris, en grammes.

◆ casterProgressionName()

std::string_view core::casterProgressionName ( CasterProgression progression )

nodiscard

Nom textuel d'une progression, tel que multiclassing.json l'écrit.

◆ conditionName()

std::string core::conditionName ( Condition condition )

nodiscard

◆ creatureSizeName()

std::string core::creatureSizeName ( CreatureSize size )

nodiscard

◆ currentTimestamp()

std::string core::currentTimestamp ( )

nodiscard

Horodatage courant local, au format "HH:MM:SS".

Returns: La chaîne d'horodatage.

◆ damageTypeName()

std::string core::damageTypeName ( DamageType type )

nodiscard

◆ defaultAssetKeyFor()

std::string core::defaultAssetKeyFor	(	std::string_view	family,
		std::string_view	id )

nodiscard

La clé par défaut d'une entrée : famille/identifiant.

Une donnée n'a pas à écrire sa clé quand celle-ci se déduit : trois cents entrées porteraient alors trois cents lignes recopiées, et la première faute de frappe donnerait une créature sans image sans que rien ne l'explique. Le champ asset d'une donnée sert donc à déroger — deux entrées qui partagent une illustration —, pas à répéter.

Returns: La clé, ou une chaîne vide si family ou id ne respecte pas la syntaxe.

◆ defaultLogger()

Logger & core::defaultLogger ( )

nodiscard

Journaliseur global de l'application (utilisé par les macros de log).

Returns: Référence vers l'instance unique.

◆ derivedStatsFor()

DerivedStats core::derivedStatsFor	(	const CharacterSheet &	sheet,
		const Inventory &	inventory,
		const ItemLookup &	lookup,
		const CharacterCreationRules &	creation,
		const EncumbranceRules &	carrying )

nodiscard

Calcule tout ce que l'équipement porté produit, depuis la fiche et les catalogues.

Parameters

sheet	La fiche, pour ses caractéristiques et sa vitesse de base.
inventory	Ce qui est porté.
lookup	Les catalogues.
creation	Les constantes de création, pour la CA sans armure.
carrying	Les bornes de charge. Non chargées, la charge reste Unencumbered et la capacité vaut zéro : la fiche ne prétend pas connaître une règle qui manque.

◆ deriveSeed()

std::uint64_t core::deriveSeed	(	std::uint64_t	baseSeed,
		std::uint64_t	step,
		std::uint64_t	entityId )

nodiscardconstexprnoexcept

Combine une graine de base, un numéro de pas et un identifiant reproductible en une graine unique, propre à ce triplet (LOT-53 TACHE-01).

Reproductible quel que soit l'ordre ou le nombre d'appels : deux tirages faits pour le même triplet (graine, pas, identifiant) produisent toujours la même graine dérivée, jamais dépendante d'un compteur mutable partagé entre appels.

Parameters

baseSeed	Graine de base, explicite.
step	Numéro de pas de simulation courant.
entityId	Identifiant reproductible (core::Entity::index, par exemple).

Returns: Une graine dérivée, propre à ce triplet.

◆ encounterAlreadyCleared()

bool core::encounterAlreadyCleared	(	const WorldFlags &	flags,
		std::string_view	defeatFlagKey )

nodiscard

Vrai si cette rencontre a déjà été gagnée, et ne doit donc pas se redéclencher.

Une clé vide n'est jamais acquise : c'est le cas d'une zone de rencontre, qui se redéclenche par construction. Répondre « déjà nettoyée » pour une clé vide désactiverait toutes les zones du jeu dès le premier combat gagné.

◆ encounterTriggerFor()

std::optional< EncounterTrigger > core::encounterTriggerFor	(	const MapEntity &	entity,
		std::string_view	mapName )

nodiscard

Lit entity comme un déclencheur de rencontre, s'il en est un.

Deux natures de déclencheur, distinguées par la donnée et non par le type d'entité :

un ennemi posé sur la carte — il se combat une fois, et sa clé de drapeau le fait disparaître pour de bon (core::keyForEntity) ;
une zone de rencontre (respawns: true) — elle se redéclenche, et n'a donc pas de clé.

Confondre les deux se paierait dans les deux sens : un ennemi sans clé réapparaîtrait à chaque passage, et une zone avec clé s'éteindrait au premier combat gagné.

Parameters

entity	L'entité de la couche objects.
mapName	Le nom de la carte, qui ouvre la clé de drapeau — deux cartes ne se marchent jamais dessus.

Returns: Le déclencheur, ou std::nullopt si cette entité n'en est pas un.

◆ endEncounter()

ExplorationSnapshot core::endEncounter	(	const EncounterRun &	run,
		CombatOutcome	outcome,
		WorldFlags &	flags )

nodiscard

Termine run, et rend l'état d'exploration à restituer.

Seule une victoire acquiert le drapeau. Une fuite ramène à l'exploration sans marquer l'ennemi vaincu — sans quoi fuir suffirait à nettoyer une carte —, et une défaite non plus : le groupe est tombé, l'ennemi est toujours là.

Parameters

run	La rencontre engagée.
outcome	Comment elle s'est terminée.
flags	Les drapeaux de monde, où une victoire écrit.

Returns: L'état d'exploration à restituer, tel qu'il avait été relevé.

◆ equip()

std::string core::equip	(	Inventory &	inventory,
		EquipmentSlot	slot,
		std::string	itemId )

Équipe itemId à slot, et rend ce que l'emplacement portait.

Aucune règle de compatibilité n'est appliquée ici : ranger une armure à l'emplacement de tête est une question de donnée et d'interface, pas de cette fonction. Ce qu'elle garantit est plus étroit et plus utile : l'emplacement ne porte jamais deux choses, et ce qui en sort est rendu à l'appelant plutôt que perdu.

Returns: L'identifiant précédemment porté, ou une chaîne vide.

◆ equipmentSlotName()

std::string_view core::equipmentSlotName ( EquipmentSlot slot )

nodiscard

Nom textuel d'un emplacement, tel que la donnée et les clés de traduction l'écrivent.

◆ evaluateOutcome()

LevelOutcome core::evaluateOutcome	(	const Aabb &	playerBox,
		const Level &	level,
		const std::vector< Aabb > &	extraDangerBoxes = {} )

nodiscard

Détermine l'issue du niveau à partir de la boîte du personnage.

Fonction pure d'observation (ne modifie rien) : elle classe l'état courant, sans déclencher de transition (le retour au menu ou le redémarrage relèvent de l'intégration). Priorité déterministe en cas de recouvrement simultané : l'échec l'emporte sur le succès.

Les dangers statiques (Danger, DangerUp/DangerDown/DangerLeft/DangerRight, EX-GP-050) sont résolus directement depuis la grille du niveau (via core::dangerHitbox) : ce module (Core/Levels) n'a pas de dépendance vers Core/Gameplay, donc pas de connaissance des contrôleurs qui font vivre les dangers à état (mobile, commuté, temporisé — EX-GP-051/ 052/053). Leurs boîtes actuellement mortelles, calculées par l'appelant (core::DangerController, core::MechanismController) qui possède déjà cet état, sont passées via extraDangerBoxes plutôt que dupliquées ici.

Parameters

playerBox	Boîte englobante du personnage, en unités monde.
level	Niveau courant (sortie, tuiles de danger statique, limites de la grille).
extraDangerBoxes	Boîtes mortelles supplémentaires, hors grille statique (dangers mobile/ commuté/temporisé actuellement actifs) ; vide par défaut (niveaux sans danger à état, ou appelants qui ignorent ces variantes).

Returns: Lost si contact avec un danger (statique ou extraDangerBoxes) ou sortie par le bas ; sinon Won si la sortie est recouverte ; sinon Playing.

◆ expectedAssetKeys()

std::vector< ExpectedAssetKey > core::expectedAssetKeys	(	const std::filesystem::path &	rpgDir,
		const AssetFamilyTable &	families,
		std::vector< std::string > &	errors )

nodiscard

Énumère les clés qu'attendent les catalogues de rpgDir, selon families.

Le manifeste est dérivé, jamais tenu à la main : un fichier de manifeste commité divergerait du catalogue au premier ajout de créature, et c'est la copie oubliée qu'on lit six mois plus tard. Le dériver à chaque appel coûte un balayage de dossier et ne peut pas mentir.

Parameters

rpgDir	Racine des catalogues (Source/Elements/Rpg).
families	La table des familles.
errors	Reçoit les clés orphelines : une dérogation malformée, ou qui nomme une famille inconnue. C'est le seul cas qui doit faire échouer une vérification — une clé sans image, elle, est un état d'avancement (EX-CNT-041).

◆ fileName()

std::string_view core::fileName ( std::string_view path )

nodiscard

Réduit un chemin source à son seul nom de fichier.

Parameters

path	Chemin complet (tel que fourni par __FILE__).

Returns: La portion après le dernier séparateur, ou le chemin entier s'il n'y en a pas.

◆ findInteractionTarget()

InteractionTarget core::findInteractionTarget	(	GridPosition	from,
		Vector2	facing,
		const TileMap &	map,
		const std::vector< InteractionCandidate > &	candidates,
		const WorldFlags &	flags )

nodiscard

Désigne la cible d'interaction d'un personnage.

Trois règles, et chacune répond à un critère d'acceptation du lot :

La cible est sur la case visée, celle devant l'orientation.
L'interaction ne traverse pas un mur : si la case visée est de la matière pleine (core::isSolid), il n'y a pas de cible. Un coffre derrière un mur se voit et ne s'ouvre pas — sans cette règle, un joueur ouvrirait à travers une cloison, ce qui se joue et ne se diagnostique pas.
À plusieurs candidats, le choix est déterministe : la plus proche du centre de la case visée, et à distance égale le plus petit indice. Sans départage, deux coffres empilés donneraient tantôt l'un tantôt l'autre selon l'ordre de parcours de l'ECS, qui n'est pas stable.

Une cible dont le drapeau de consommation est déjà levé n'est pas retenue : un coffre vidé n'est plus une cible, et continuer à l'afficher comme telle promettrait au joueur quelque chose qui n'arrivera pas.

Parameters

from	Case du personnage.
facing	Orientation du personnage.
map	La carte, pour la règle du mur.
candidates	Les entités interactives de la carte.
flags	Les drapeaux de monde, pour écarter ce qui est déjà consommé.

◆ formatDice()

std::string core::formatDice ( const Dice & dice )

nodiscard

Réécrit une expression en notation canonique (2d6+3, 1d8, 4).

◆ formatLogLine()

std::string core::formatLogLine	(	std::string_view	timestamp,
		LogLevel	level,
		std::string_view	category,
		std::string_view	file,
		int	line,
		std::string_view	message )

nodiscard

Compose une ligne de journalisation.

Parameters

timestamp	Horodatage déjà formaté (injecté, pour rester testable).
level	Niveau du message.
category	Catégorie / sous-système émetteur (ex. "HMI").
file	Fichier source (le nom seul est conservé dans la ligne).
line	Ligne source à l'origine du message.
message	Texte du message.

Returns: Ligne de la forme "[timestamp][NIVEAU][catégorie][fichier:ligne] message".

◆ gainExperience()

LevelUpResult core::gainExperience	(	CharacterSheet &	sheet,
		const ExperienceTable &	table,
		int	hitDie,
		int	amount )

Ajoute des points d'expérience et applique la montée de niveau qui en découle.

Reproductible : aucune part de hasard, et le résultat ne dépend que de la fiche, de la table et du montant. Le franchissement de plusieurs seuils d'un coup est traité comme le livre le décrit — le personnage atteint le niveau que son total lui donne, pas le suivant.

Parameters

sheet	La fiche, modifiée sur place.
table	La table d'expérience.
hitDie	Le dé de vie de la classe, pour recalculer les points de vie.
amount	Les points gagnés. Un montant négatif est ignoré : perdre de l'expérience n'est pas une règle de ce jeu, et l'accepter en silence ferait descendre un personnage de niveau sans que rien ne l'annonce.

Returns: Ce que la montée a produit, niveau par niveau.

◆ handleAssertionFailure()

void core::handleAssertionFailure	(	const char *	condition,
		const char *	message,
		const char *	file,
		int	line )

Invoque le gestionnaire d'échec d'assertion courant.

Parameters

condition	Texte de la condition ayant échoué.
message	Message explicatif.
file	Fichier source.
line	Ligne source.

◆ interact()

InteractionOutcome core::interact	(	const InteractionTarget &	target,
		WorldFlags &	flags )

Résout une interaction sur une cible désignée, en levant son drapeau s'il y a lieu.

C'est ici que « deux fois ne donne qu'une fois » se joue. Le drapeau est levé et sa valeur de retour dit s'il était neuf ; l'appelant n'a pas à demander d'abord puis à écrire ensuite, séquence dans laquelle un second appel pourrait se glisser.

◆ isSolid()

bool core::isSolid ( TileType type )

nodiscardconstexprnoexcept

Indique si un type de tuile bloque le déplacement de manière statique.

Note: La solidité d'une porte dépend de son état (ouverte/fermée) et la position d'un bloc poussable évolue en jeu : les deux sont résolues par la simulation, jamais par ce test statique.; DeepWater bloque : ce n'est pas de la matière, mais rien ne permet encore de la franchir. Le jour où une règle de nage existera, elle sortira d'ici — et ce sera le seul endroit à changer, ce qui est précisément l'intérêt de l'y mettre plutôt que de parsemer le code de tests « sauf si c'est de l'eau ».

Parameters

type	Type de tuile.

Returns: true pour la matière pleine (Solid, Block, Wall, Cliff) et pour l'eau profonde.

◆ isValidAssetKey()

bool core::isValidAssetKey ( std::string_view key )

nodiscard

Vrai si key respecte la syntaxe d'une clé d'asset.

famille/identifiant, en minuscules, chiffres et tirets simples — la même expression que celle du schéma JSON (common.schema.json, $defs/assetKey), pour que la donnée refusée à la validation soit exactement celle que le moteur refuse.

Ce n'est jamais un chemin de fichier (EX-CNT-040) : un chemin dans une donnée de règle lie le catalogue à l'arborescence du disque, et tout déplacement de dossier casse alors des créatures. La clé, elle, survit à n'importe quel rangement.

◆ isValidPlaneDensity()

bool core::isValidPlaneDensity ( int pixelsPerUnit )

nodiscardconstexprnoexcept

Densité acceptée pour un plan (EX-DEC-041).

pixelsPerUnit est un entier et non une énumération : il sert directement au calcul des dimensions attendues (width * pixelsPerUnit), et une énumération imposerait une table de conversion à chaque site d'appel. La contrainte est donc validée au chargement, pas portée par le type.

Parameters

pixelsPerUnit Densité à vérifier.

Returns: true si la densité vaut 4, 8 ou 16.

◆ keyForEntity()

std::string core::keyForEntity	(	std::string_view	mapName,
		std::string_view	entityType,
		int	column,
		int	row )

nodiscard

La clé de drapeau d'une entité de carte : "<carte>/<type>@<colonne>,<ligne>".

Fabriquée, jamais écrite à la main. Deux coffres d'une même carte se distinguent par leur case ; deux cartes différentes ne se marchent pas dessus parce que le nom de carte ouvre la clé. Laisser l'auteur de la carte nommer le drapeau produirait tôt ou tard deux coffres partageant la même clé — et le second serait vide dès sa première ouverture, sans que rien ne l'explique.

La position sert d'identité parce que c'est la seule chose qu'une entité de carte possède en propre et qui ne bouge pas. Corollaire assumé : déplacer un coffre dans l'éditeur le remet à neuf pour une partie déjà commencée. C'est le bon compromis — l'inverse demanderait un identifiant stable écrit dans le fichier de carte, que le LOT-11 devrait générer et maintenir unique.

◆ knownInteractableKinds()

const std::vector< InteractableKind > & core::knownInteractableKinds ( )

nodiscard

Les familles connues de ce lot. Le LOT-15 et le LOT-09 en ajouteront.

◆ layerKindName()

const char * core::layerKindName ( LayerKind kind )

nodiscardconstexprnoexcept

Nom JSON d'un rôle de couche.

Déclaré ici, et non dans le chargeur ou l'écrivain, parce que les deux en ont besoin et qu'un rôle nommé différemment de part et d'autre casserait l'aller-retour sans qu'aucun test unitaire de l'un ou de l'autre pris isolément ne le voie. Le switch est exhaustif et sans default : un rôle ajouté sans nom ne compile pas, plutôt que de retomber silencieusement sur une valeur arbitraire.

◆ loadAssetFamilies()

AssetFamilyTable core::loadAssetFamilies ( const std::filesystem::path & familiesFile )

nodiscard

Charge la table des familles depuis Assets/Entities/families.json.

◆ loadAtlas()

Atlas core::loadAtlas ( const std::filesystem::path & directory )

nodiscard

Charge l'atlas — regions/ et locations/ sous le dossier donné.

Les deux dossiers sont balayés, jamais énumérés dans le code : le LOT-80 ajoutera des lieux, et une liste écrite ici les rendrait invisibles.

Note: Les clés d'espèce sont en anglais et ne pointent pas vers le catalogue d'espèces du LOT-36, qui est en français et n'en couvre que la moitié — ni géant, ni gobelinoïde, ni kemet, ni merfolk, ni orc, ni soulborn n'y existent. La correspondance est le travail du LOT-39 ; la fabriquer à moitié ici donnerait un champ vrai une fois sur deux, ce qui est pire qu'un champ dont on sait qu'il ne pointe nulle part.

Parameters

directory Dossier de l'atlas (Source/Elements/World).

Returns: L'atlas et la liste des échecs. Ne lève jamais (EX-NFR-040). Un dossier absent produit une erreur, pas un atlas vide : un monde vide se confondrait avec un monde non installé.

◆ loadBestiary()

Bestiary core::loadBestiary ( const std::filesystem::path & directory )

nodiscard

Charge toutes les créatures d'un dossier — un fichier JSON par créature.

Le dossier est balayé, jamais énuméré dans le code : une liste de quatre-vingt-quatorze noms écrite en C++ serait une seconde source de vérité, et la première créature ajoutée par le LOT-46 en sortirait invisible.

Note: Une seule clause de dégâts est typée par action. Une morsure qui inflige « 7 (1d10 + 2) dégâts perforants + 5 (1d10) dégâts de poison » en porte deux ; CreatureAction::damage ne rend que la première, et text reste ce qui fait foi jusqu'à ce que le LOT-21 sache composer plusieurs clauses. Le champ n'est pas faux, il est partiel, et c'est écrit ici parce que rien dans la donnée ne le dit.

Parameters

directory Dossier des créatures (Source/Elements/Rpg/creatures).

Returns: Le catalogue et la liste des échecs. Ne lève jamais (EX-NFR-040). Un dossier absent produit une erreur, pas un catalogue vide : un bestiaire vide se confondrait avec un bestiaire non installé.

◆ loadCharacterCreationRules()

CharacterCreationRules core::loadCharacterCreationRules ( const std::filesystem::path & path )

nodiscard

Charge les constantes depuis Source/Elements/Rpg/rules/character-creation.json.

◆ loadCharacterOptions()

CharacterOptions core::loadCharacterOptions	(	const std::filesystem::path &	speciesDir,
		const std::filesystem::path &	backgroundsDir,
		const std::filesystem::path &	classesDir )

nodiscard

Charge les trois catalogues depuis leurs dossiers.

Chaque dossier est balayé, jamais énuméré dans le code : une liste de noms écrite en C++ serait une seconde source de vérité, et la première espèce ajoutée par un lot suivant en sortirait invisible.

Parameters

speciesDir	Dossier des espèces (Source/Elements/Rpg/species).
backgroundsDir	Dossier des historiques.
classesDir	Dossier des classes.

Returns: Les catalogues et la liste des échecs. Ne lève jamais (EX-NFR-040). Un dossier absent produit une erreur, pas un catalogue vide : les deux se ressemblent à l'exécution, et les confondre fait chercher le défaut du mauvais côté.

◆ loadCharacterSheet()

LoadedCharacterSheet core::loadCharacterSheet	(	const std::filesystem::path &	path,
		const CharacterOptions &	options,
		const CharacterCreationRules &	rules,
		const ExperienceTable &	table )

nodiscard

Charge un personnage depuis son fichier JSON (Source/Elements/Rpg/characters/, schéma character.schema.json) et construit sa fiche.

Le fichier ne porte que des choix — espèce, classe, historique, valeurs de caractéristique avant augmentation, niveau visé. Tout le reste est dérivé ici par buildCharacterSheet et par la montée en expérience : points de vie, classe d'armure, valeurs finales, bonus de maîtrise. Écrire ces valeurs dans le fichier en ferait une seconde source, qui différerait de la première au premier ajustement de règle — et personne ne saurait laquelle croit.

Le niveau s'atteint par gain d'expérience, le même chemin qu'une partie empruntera : donc les mêmes points de vie qu'un personnage monté en jouant, et non une variante propre au chargement.

Ne lève jamais (EX-NFR-040) : un fichier absent, mal formé ou référençant un identifiant inconnu rend une fiche partielle et une erreur nommée (EX-CNT-010).

◆ loadEncounters()

EncounterCatalog core::loadEncounters ( const std::filesystem::path & encountersDir )

nodiscard

Charge les rencontres depuis leur dossier (Rpg/encounters/).

◆ loadEncumbranceRules()

EncumbranceRules core::loadEncumbranceRules ( const std::filesystem::path & rulesFile )

nodiscard

Charge les bornes de charge depuis rules/encumbrance.json.

Returns: Les bornes, ou une règle non chargée (isLoaded() faux) si le fichier manque.

◆ loadEquipment()

EquipmentCatalog core::loadEquipment	(	const std::filesystem::path &	weaponsDir,
		const std::filesystem::path &	armorsDir )

nodiscard

Charge les armes et les armures depuis leurs dossiers.

◆ loadExperienceTable()

ExperienceTable core::loadExperienceTable ( const std::filesystem::path & path )

nodiscard

Charge la table d'expérience depuis Source/Elements/Rpg/rules/experience.json.

◆ loadItems()

ItemCatalog core::loadItems ( const std::filesystem::path & itemsDir )

nodiscard

Charge les objets depuis leur dossier (Rpg/items/).

◆ loadSkills()

SkillCatalog core::loadSkills ( const std::filesystem::path & directory )

nodiscard

Charge le catalogue des compétences depuis son dossier.

Parameters

directory Source/Elements/Rpg/skills.

Returns: Le catalogue et la liste des échecs. Ne lève jamais (EX-NFR-040).

◆ magicSchoolName()

std::string core::magicSchoolName ( MagicSchool school )

nodiscard

◆ maximumHitPointsFor()

int core::maximumHitPointsFor	(	int	hitDie,
		int	level,
		int	constitutionModifier )

nodiscard

Les points de vie d'un niveau, selon la règle du livre.

« Vous pouvez aussi choisir d'utiliser la valeur fixe indiquée dans la description de votre classe, qui se trouve être la valeur moyenne (arrondie au supérieur) du dé » — Basic Rules p. 11. C'est la voie déterministe, et c'est celle que le moteur emploie : des points de vie tirés au dé rendraient une partie irrejouable, ce qu'EX-NFR-002 interdit.

Le niveau 1 reçoit le maximum du dé ; chaque niveau suivant sa moyenne arrondie au supérieur. Le modificateur de Constitution s'ajoute à chaque niveau, et le gain d'un niveau vaut au minimum 1 : un personnage à la Constitution désastreuse gagne peu de points de vie, il n'en perd pas.

Parameters

hitDie	Le dé de vie de la classe, lu dans sa donnée (hitDie du catalogue).
level	Le niveau atteint, à partir de 1.
constitutionModifier	Le modificateur de Constitution.

◆ metersFromTiles()

float core::metersFromTiles ( float tiles )

nodiscardconstexprnoexcept

Convertit un nombre de cases en mètres, pour l'affichage et les infobulles.

◆ multiclassCasterLevel()

int core::multiclassCasterLevel ( std::span< const ClassLevel > classes )

nodiscard

Niveau de lanceur cumulé d'un personnage multiclassé.

La règle qu'il est le plus facile d'implémenter de travers (EX-RPG-041), pour deux raisons qui se cumulent :

L'arrondi se fait par classe, jamais sur le total. Un paladin 3/rôdeur 3 donne 1 + 1 = 2, et non ⌊6/2⌋ = 3. Sommer d'abord et diviser ensuite donne un emplacement de trop, à un niveau où c'en est un tiers de plus.
La magie de pacte est exclue. Le sorcier (occultiste) obtient ses emplacements par une voie distincte — peu nombreux, toujours au niveau maximal, récupérés au repos court. Les additionner double la puissance du personnage sans que rien ne le signale.

Un lanceur multiclassé mal calculé reste jouable, simplement faux : c'est pourquoi cette fonction est vérifiée contre l'exemple travaillé du livre lui-même — un rôdeur 4/magicien 3 est « considéré comme un personnage de niveau 5 ».

Parameters

classes Les niveaux pris dans chaque classe. Une classe absente n'apporte rien.

Returns: Le niveau de lanceur, dans [0, 20]. 0 signifie qu'aucun emplacement n'est accordé par cette voie — ce qui n'interdit pas la magie de pacte, comptée à part.

◆ operator!=() [1/2]

bool core::operator!=	(	const Vector2 &	lhs,
		const Vector2 &	rhs )

nodiscard

◆ operator!=() [2/2]

bool core::operator!=	(	GridPosition	left,
		GridPosition	right )

nodiscardconstexprnoexcept

Returns: true si les deux positions désignent des cases différentes.

◆ operator*() [1/2]

Vector2 core::operator*	(	const Vector2 &	vector,
		float	scalar )

nodiscard

◆ operator*() [2/2]

Vector2 core::operator*	(	float	scalar,
		const Vector2 &	vector )

nodiscard

◆ operator+()

Vector2 core::operator+	(	const Vector2 &	lhs,
		const Vector2 &	rhs )

nodiscard

◆ operator-() [1/2]

Vector2 core::operator-	(	const Vector2 &	lhs,
		const Vector2 &	rhs )

nodiscard

◆ operator-() [2/2]

Vector2 core::operator- ( const Vector2 & vector )

nodiscard

◆ operator/()

Vector2 core::operator/	(	const Vector2 &	vector,
		float	scalar )

nodiscard

◆ operator==() [1/2]

bool core::operator==	(	const Vector2 &	lhs,
		const Vector2 &	rhs )

nodiscard

Égalité approchée entre deux vecteurs (comparaison par tolérance).

Parameters

lhs	Premier opérande.
rhs	Second opérande.

Returns: true si les composantes coïncident à la tolérance près.

◆ operator==() [2/2]

bool core::operator==	(	GridPosition	left,
		GridPosition	right )

nodiscardconstexprnoexcept

Returns: true si les deux positions désignent la même case.

◆ parseAbility()

std::optional< Ability > core::parseAbility ( std::string_view name )

nodiscardnoexcept

Inverse d'abilityName. std::nullopt si le nom est inconnu — jamais deviné.

◆ parseArmorCategory()

std::optional< ArmorCategory > core::parseArmorCategory ( std::string_view name )

nodiscard

Inverse d'armorCategoryName. std::nullopt si le nom est inconnu — jamais deviné.

◆ parseAssetKey()

std::optional< AssetKey > core::parseAssetKey ( std::string_view key )

nodiscard

Décompose key. std::nullopt si elle est malformée — jamais devinée.

◆ parseCameraFramingMode()

std::optional< CameraFramingMode > core::parseCameraFramingMode ( std::string_view name )

nodiscardnoexcept

Reconnaît le nom JSON d'un mode ; std::nullopt si non reconnu (mode inconnu, EX-LVL-004).

◆ parseCasterProgression()

std::optional< CasterProgression > core::parseCasterProgression ( std::string_view name )

nodiscard

Convertit le nom d'une progression, tel que la donnée l'écrit, en valeur.

Inverse de casterProgressionName. Un nom inconnu renvoie std::nullopt : c'est une donnée invalide à signaler, jamais une progression devinée — deviner None ferait taire un lanceur.

◆ parseCondition()

std::optional< Condition > core::parseCondition ( std::string_view name )

nodiscard

◆ parseCreatureSize()

std::optional< CreatureSize > core::parseCreatureSize ( std::string_view name )

nodiscard

◆ parseDamageType()

std::optional< DamageType > core::parseDamageType ( std::string_view name )

nodiscard

◆ parseDice()

std::optional< Dice > core::parseDice ( std::string_view notation )

nodiscard

Analyse une notation NdF, NdF+M, NdF-M ou une valeur fixe.

Parameters

notation La notation, sans espace. La casse du d est indifférente.

Returns: L'expression, ou std::nullopt si la notation est mal formée — jamais une expression devinée : une notation illisible est une donnée invalide à signaler.

◆ parseEquipmentSlot()

std::optional< EquipmentSlot > core::parseEquipmentSlot ( std::string_view name )

nodiscard

Inverse d'equipmentSlotName. std::nullopt si le nom est inconnu — jamais deviné.

◆ parseLogLevel()

std::optional< LogLevel > core::parseLogLevel ( std::string_view text )

inlinenodiscard

Convertit une chaîne en niveau de log (insensible à la casse).

Parameters

text	Nom du niveau : « trace », « info », « warning » (ou « warn »), « error ».

Returns: Le niveau correspondant, ou std::nullopt si la chaîne n'est pas reconnue.

◆ parseMagicSchool()

std::optional< MagicSchool > core::parseMagicSchool ( std::string_view name )

nodiscard

◆ parseTileType()

std::optional< TileType > core::parseTileType ( std::string_view name )

nodiscard

Convertit un nom textuel en type de tuile.

Inverse exact de core::tileTypeName : tout nom qu'il produit est accepté ici, et réciproquement (propriété vérifiée par test sur les trente types).

Parameters

name	Nom textuel, tel qu'écrit dans un fichier.

Returns: Le type correspondant, ou std::nullopt si le nom est inconnu — un nom inconnu est une donnée invalide à signaler, jamais un type deviné.

◆ placeCombatants()

std::vector< CombatantPlacement > core::placeCombatants	(	const Encounter &	encounter,
		GridPosition	trigger )

nodiscard

Place les combattants d'une rencontre autour de trigger.

Fonction pure : aucune carte, aucun monde ECS, aucune collision. Ce qu'elle produit est une liste de cases voulues — c'est au montage de la rencontre de refuser celles qui tombent dans un mur, et il ne peut le faire que s'il les reçoit toutes.

◆ playerClipSet()

std::shared_ptr< const ClipSet > core::playerClipSet ( )

nodiscard

Jeu de clips du personnage, migré tel quel depuis l'ancien dispositif figé (LOT-18), étendu aux états aériens/dash livrés par LOT-10/LOT-11 (LOT-48 TACHE-02).

Sept clips nommés : « idle », « run », « jump » (mêmes durées/nombres d'images qu'avant LOT-46, LOT-46 TACHE-04), plus « fall », « land », « wallslide », « dash » (LOT-48). Ces quatre nouveaux clips n'ont pas de pose procédurale dédiée (hmi::PlayerClipKind reste limité à trois poses) : c'est HMI (hmi::resolveDeclaredPlayerClip) qui les fait retomber sur le clip le plus proche déclaré, aussi bien pour l'atlas procédural que pour une spritesheet externe partielle — Core n'a pas à le savoir (EX-ARCH-012).

Instance partagée (même shared_ptr renvoyé à chaque appel) : tous les personnages d'une session utilisent le même jeu de clips, immuable.

Returns: Le jeu de clips du personnage.

◆ playerSize()

Vector2 core::playerSize ( )

inlinenodiscard

Returns: Les dimensions (largeur, hauteur) du personnage, pour le Collider et le rendu.

◆ playerSpawnPosition()

Vector2 core::playerSpawnPosition	(	int	column,
		int	row )

inlinenodiscard

Coin haut-gauche du personnage centré dans la tuile (column, row).

Marges symétriques : la boîte 0,4 × 0,8 est centrée dans la tuile 1×1 (repère haut-gauche, y vers le bas). Évite de faire apparaître le personnage collé à un bord de la tuile.

◆ positionOf()

TextPosition core::positionOf	(	std::string_view	text,
		std::size_t	byteOffset )

nodiscard

Convertit un décalage en octets en ligne et colonne.

Parameters

text	Le texte d'origine.
byteOffset	Décalage, tel que rapporté par nlohmann::json::parse_error::byte.

Returns: La position, ou {0, 0} si le décalage sort du texte.

◆ proficiencyBonus()

int core::proficiencyBonus	(	const CharacterSheet &	sheet,
		const ExperienceTable &	table )

nodiscard

Le bonus de maîtrise de la fiche, lu dans la table au niveau courant.

◆ readJsonObject()

JsonDocument core::readJsonObject	(	std::string_view	json,
		int	supportedVersion,
		std::string_view	origin = {},
		std::string_view	versionField = "version" )

nodiscard

Lit l'enveloppe commune d'un catalogue : JSON bien formé, racine objet, garde de version.

C'est la routine que les six lecteurs du dépôt réimplémentaient à l'identique. Le champ de version absent vaut 1 — un catalogue écrit avant que le format ne se versionne reste lisible ; une version supérieure à supportedVersion est refusée explicitement, jamais lue au mieux : un fichier plus récent que le jeu contient par définition ce que le jeu ne sait pas interpréter.

Parameters

json	Contenu JSON.
supportedVersion	Version la plus élevée que le lecteur sait lire. 0 désactive la garde : l'appelant porte alors sa propre catégorie d'échec de version, ce qui est le cas du chargeur de niveaux (core::LevelValidationError::UnsupportedFormatVersion).
origin	Nom à faire figurer dans les messages (« sounds.json »). Facultatif.
versionField	Nom du champ de version. Vaut "version" par défaut.

Returns: Le document, ou l'échec décrit. Ne lève jamais.

◆ readJsonObjectFromFile()

JsonDocument core::readJsonObjectFromFile	(	const std::filesystem::path &	path,
		int	supportedVersion,
		std::string_view	versionField = "version" )

nodiscard

Comme readJsonObject, en lisant d'abord le fichier.

Un fichier absent produit FileNotFound plutôt qu'un document vide : c'est à l'appelant de décider qu'un catalogue absent est un état de départ légitime, et cette décision ne peut pas être prise ici.

Parameters

path	Chemin du fichier.
supportedVersion	Version la plus élevée que le lecteur sait lire.
versionField	Nom du champ de version.

Returns: Le document, ou l'échec décrit. Ne lève jamais.

◆ regionAxisName()

std::string_view core::regionAxisName ( RegionAxis axis )

nodiscard

Le nom d'un axe, tel que le schéma l'écrit (citizenFreedom, …).

◆ regionGradeFromName()

std::optional< RegionGrade > core::regionGradeFromName ( std::string_view name )

nodiscard

La note portant ce nom de schéma, ou std::nullopt.

◆ regionGradeName()

std::string_view core::regionGradeName ( RegionGrade grade )

nodiscard

Le nom d'une note, tel que le schéma l'écrit (veryLow, normal, …).

◆ removeFromBackpack()

int core::removeFromBackpack	(	Inventory &	inventory,
		const std::string &	itemId,
		int	quantity = 1 )

Retire quantity exemplaires de itemId.

Returns: Ce qui a réellement été retiré.

◆ resolveCameraFraming()

CameraFramingConfig core::resolveCameraFraming	(	const std::optional< CameraFramingConfig > &	declared,
		int	levelWidth,
		int	levelHeight )

nodiscardnoexcept

Résout le cadrage effectif d'un niveau à partir du champ déclaré (peut être absent).

Unique endroit incarnant la règle de repli (EX-LVL-006) : un niveau sans mode déclaré est cadré sur le niveau entier s'il tient dans une salle de taille par défaut, et par salle sinon. Un mode déclaré explicitement est retourné tel quel, sans substitution.

Parameters

declared	Cadrage déclaré dans le fichier, ou std::nullopt si le champ est absent.
levelWidth	Largeur du niveau, en cases (> 0).
levelHeight	Hauteur du niveau, en cases (> 0).

Returns: Le cadrage effectif à appliquer.

◆ rollCheck()

CheckResult core::rollCheck	(	int	target,
		std::span< const Modifier >	modifiers,
		RollStance	stance,
		DeterministicRandom &	random )

nodiscard

Lance un d20 contre un seuil.

Parameters

target	Seuil visé : un degré de difficulté (Source/Elements/Rpg/rules/difficulty.json) ou une classe d'armure. Jamais un littéral dans le code appelant (EX-DND-021) : un nombre nu dans un if ne dit pas ce qu'il représente, et régler l'équilibre du jeu ne doit pas demander de recompiler.
modifiers	Les modificateurs, avec leur origine.
stance	Avantage, désavantage, ou ni l'un ni l'autre — voir rollStance.
random	Générateur déterministe (EX-NFR-002).

Returns: Le résultat complet, restituable.

◆ rollDice()

DiceRoll core::rollDice	(	const Dice &	dice,
		DeterministicRandom &	random )

nodiscard

Lance une expression avec un générateur déterministe.

Le déterminisme n'est pas un confort : sans lui, aucun test de combat n'est écrivable (EX-NFR-002). Le générateur est passé par référence et jamais créé ici, pour que l'appelant reste maître de la graine et de la position dans la suite.

◆ rollStance()

RollStance core::rollStance	(	int	advantageSources,
		int	disadvantageSources )

nodiscardconstexprnoexcept

Détermine la posture depuis le nombre de sources de chaque type (EX-DND-002).

Deux avantages et un désavantage donnent Normal, pas Advantage : la règle annule, elle ne compte pas. C'est contre-intuitif la première fois, et c'est précisément pour cela que la décision vit ici, à un seul endroit.

◆ rollStanceName()

std::string_view core::rollStanceName ( RollStance stance )

nodiscardnoexcept

Nom textuel d'une posture, pour les journaux et la restitution.

◆ savingThrowModifier()

int core::savingThrowModifier	(	const CharacterSheet &	sheet,
		const ExperienceTable &	table,
		Ability	which )

nodiscard

Le modificateur d'un jet de sauvegarde : caractéristique, plus la maîtrise si elle s'applique.

◆ setAssertionHandler()

void core::setAssertionHandler ( AssertionHandler handler )

Remplace le gestionnaire d'échec d'assertion (utile pour les tests).

Parameters

handler Nouveau gestionnaire ; un gestionnaire nul rend l'échec silencieux.

◆ skillModifier()

SkillCheckModifier core::skillModifier	(	const CharacterSheet &	sheet,
		const ExperienceTable &	table,
		const SkillCatalog &	catalog,
		std::string_view	skillId )

nodiscard

◆ spawnMapEntities()

std::size_t core::spawnMapEntities	(	World &	world,
		const Level &	level,
		std::string_view	mapName,
		const std::function< void(Entity, const MapEntity &)> &	onEntity = {} )

Peuple un World d'une entité par objet de la couche objects.

Chaque core::MapEntity devient une entité portant un Transform (sa case, en unités monde) et, si son type est connu, un Interactable. Un type inconnu produit tout de même une entité : c'est une erreur de conception tolérée, pas une carte invalide (EX-NFR-040), et la refuser ferait disparaître un objet de la carte sans que l'auteur comprenne pourquoi.

Le nom de carte entre dans la clé de drapeau de chaque entité consommable : deux cartes peuvent porter un coffre à la même case sans se marcher dessus.

Parameters

world	Monde à peupler.
level	Niveau source.
mapName	Nom de la carte, pour les clés de drapeau.
onEntity	Rappel invoqué après chaque création, avec l'entité et l'objet dont elle vient. Permet à la présentation d'y attacher ses propres composants sans que Core connaisse l'habillage (EX-NFR-011) — même principe d'injection que buildLevelScene.

Returns: Le nombre d'entités créées.

◆ splitMix64()

std::uint64_t core::splitMix64 ( std::uint64_t value )

nodiscardconstexprnoexcept

Mélange (SplitMix64) un entier 64 bits en une valeur bien distribuée.

Fonction pure et sans état : sert à combiner plusieurs valeurs reproductibles (graine de base, numéro de pas, identifiant d'entité) en une graine unique par tirage, sans jamais lire l'horloge système ni un générateur par défaut (EX-NFR-002).

Parameters

value Valeur à mélanger.

Returns: La valeur mélangée.

◆ stableAssetHash()

std::uint32_t core::stableAssetHash ( std::string_view key )

nodiscard

Le hachage stable dont assetMarker tire sa teinte.

Exposé pour être testé : c'est lui qui garantit qu'une clé donne toujours le même marqueur.

◆ sweepAabb()

SweepResult core::sweepAabb	(	const Aabb &	box,
		const Vector2 &	delta,
		const TileMap &	tiles )

nodiscard

Déplace box de delta en s'arrêtant au premier contact avec une tuile solide, puis en glissant le long de la surface pour le déplacement résiduel.

Collision continue (EX-GP-014) : quelle que soit la vitesse, la boîte ne traverse jamais une tuile solide sur un pas. Méthode : balayage par axe (X puis Y), chaque axe parcourant toutes les cellules entre la position courante et la cible (donc aucun tunneling), puis calant la position sur la coordonnée exacte du mur (clamp direct, sans dérive flottante). La passe Y part de la position X déjà résolue, ce qui produit le glissement le long des murs. Ordre X→Y conventionnel et déterministe (EX-NFR-002). Fonction pure : aucun état, aucun aléatoire.

Précondition : box ne chevauche aucune tuile solide au départ (état non pénétrant) — la physique appelante garantit cet invariant pas après pas.

Parameters

box	Boîte mobile avant déplacement (coin haut-gauche = position de l'entité).
delta	Déplacement voulu sur le pas, en unités monde (velocity * dt).
tiles	Grille de collision : tiles.isSolid(colonne, ligne) désigne les tuiles bloquantes.

Returns: La position finale, l'indicateur de blocage par axe et l'occurrence d'un contact.

◆ sweepAabbVsAabb()

SweepResult core::sweepAabbVsAabb	(	const Aabb &	box,
		const Vector2 &	delta,
		const Aabb &	obstacle )

nodiscardnoexcept

Déplace box de delta en s'arrêtant au premier contact avec obstacle, une boîte fixe unique (pas une grille), puis en glissant le long de sa surface pour le déplacement résiduel.

Complément de core::sweepAabb (SweptCollision.h), pas une extension : sweepAabb résout la collision sur la grille (murs, sols, blocs pleins — solide/vide par case entière) ; sweepAabbVsAabb résout la collision contre un obstacle dont la boîte réelle est plus petite qu'une case (les blocs réduits TileType::BlockHalf/BlockQuarter, core::BlockController) et ne peut donc pas être représentée sur la grille sans bloquer à tort l'espace vide qui l'entoure. Un appelant qui doit composer les deux (hmi::GameSession) applique sweepAabb puis, sur le déplacement réellement obtenu, sweepAabbVsAabb pour chaque bloc réduit concerné — la restriction la plus stricte des deux l'emporte, par construction (chaque passe ne peut que réduire encore le déplacement, jamais l'étendre).

Même méthode que sweepX/sweepY : résolution par axe, et clamp direct sur la coordonnée de contact plutôt qu'une interpolation position + delta * t — une position résolue est donc une coordonnée exacte, jamais un résultat d'interpolation, et aucune dérive flottante ne peut s'y accumuler (voir Physique du personnage). L'axe X est résolu en premier à partir de la position de départ, puis l'axe Y à partir de la position déjà résolue en X — ce qui produit le même glissement le long de l'obstacle qu'un mur classique.

Précondition : box ne chevauche pas obstacle au départ (état non pénétrant), comme pour sweepAabb.

Parameters

box	Boîte mobile avant déplacement (coin haut-gauche = position de l'entité).
delta	Déplacement voulu sur le pas, en unités monde.
obstacle	Boîte fixe contre laquelle résoudre la collision (déjà réduite/centrée si pertinent — cette fonction ne connaît ni les tuiles ni les blocs, une boîte quelconque suffit).

Returns: La position finale, l'indicateur de blocage par axe et l'occurrence d'un contact — même structure core::SweepResult que sweepAabb, pour une composition directe côté appelant.

◆ tilesFromMeters()

float core::tilesFromMeters ( float meters )

nodiscardconstexprnoexcept

Convertit une distance en mètres — telle que le corpus l'écrit — en nombre de cases.

◆ tileTypeName()

std::string core::tileTypeName ( TileType type )

nodiscard

Convertit un type de tuile en son nom textuel.

Point unique de vérité de la correspondance type ↔ nom, partagé par le format de niveau (core::LevelWriter, core::LevelLoader) et par les configurations de présentation qui désignent des types de tuiles (hmi::SkinCatalog, EX-EDIT-042). Deux tables distinctes divergeraient au premier type ajouté : un niveau écrit avec un nom qu'un autre lecteur ne reconnaîtrait pas.

Le switch est exhaustif et sans default : ajouter une valeur à core::TileType sans lui donner de nom devient une erreur de compilation (/W4 /WX), et non un nom silencieusement faux.

Parameters

type	Type de tuile.

Returns: Le nom textuel du type ("solid", "slopeUpRight"…).

◆ toString()

const char * core::toString ( LogLevel level )

nodiscardconstexpr

Convertit un niveau en libellé lisible.

Parameters

level Niveau à convertir.

Returns: Libellé constant ("TRACE", "INFO", "WARNING", "ERROR").

◆ totalWeightGrams()

int core::totalWeightGrams ( const std::vector< InventoryEntry > & entries )

nodiscard

Le poids total d'un inventaire, en grammes.

Une seule unité, et c'est la raison d'être de cette fonction : le livre écrit des kilogrammes et des grammes dans la même table — « 6,5 kg », « 500 g » —, et mélanger les deux dans un total donnerait un sac de cinq cents kilos pour une poignée de fléchettes. La conversion est faite à l'extraction ; ici tout est déjà en grammes.

◆ unequip()

std::string core::unequip	(	Inventory &	inventory,
		EquipmentSlot	slot )

Retire ce que slot porte.

Returns: L'identifiant retiré, ou une chaîne vide.

◆ unknownIds()

std::vector< std::string > core::unknownIds	(	const Inventory &	inventory,
		const ItemLookup &	lookup )

nodiscard

Les identifiants que les catalogues ne portent pas — un sac qui en contient ne pèse pas ce qu'il devrait, et le dire vaut mieux que de peser faux en silence.

◆ updateTopDownMovement()

void core::updateTopDownMovement	(	World &	world,
		Entity	actor,
		const PlayerInput &	input,
		const TileMap &	collision,
		const TopDownConfig &	config,
		float	fixedDelta )

Avance un acteur d'un pas fixe : intention → vitesse → balayage → position.

Referme la parenthèse ouverte par le LOT-01, où la physique de plateforme a été retirée sans remplaçant. Sans gravité : aucun axe n'est privilégié, x et y sont traités exactement de la même façon — c'est toute la différence avec le contrôleur qu'il remplace.

L'entité doit porter Transform, Velocity, Collider et Actor ; les autres sont ignorées. Le déplacement passe par core::sweepAabb, balayage continu contre la grille : quelle que soit la vitesse, la boîte ne traverse jamais une tuile solide, et le résidu d'un axe bloqué glisse le long du mur (EX-EXP-002, EX-EXP-003).

Note: La diagonale n'est pas plus rapide. L'intention est normalisée avant d'être mise à l'échelle : sans cela, aller en diagonale donnerait √2 ≈ 1,41 fois la vitesse cardinale — le défaut le plus courant du genre, et le plus visible en jeu (EX-EXP-001).

Fonction pure au sens du déterminisme (EX-NFR-002) : mêmes entrées, mêmes positions, sans aléatoire ni horloge. Testable sans fenêtre ni GPU (EX-ARCH-001).

Parameters

world	Monde ECS contenant l'acteur.
actor	Entité à déplacer.
input	Intention de ce pas (moveX/moveY, chacun dans [-1, 1]).
collision	Grille de collision de la carte (Level::tileMap, EX-LVL-016).
config	Réglages de vitesse, d'accélération et de friction.
fixedDelta	Durée du pas fixe, en secondes.

◆ validateCameraFramingConfig()

std::optional< std::string > core::validateCameraFramingConfig	(	const CameraFramingConfig &	config,
		int	levelWidth,
		int	levelHeight )

nodiscard

Valide un cadrage déclaré (EX-LVL-004) : taille de vue nulle/négative ou supérieure au niveau, zone hors bornes ou de taille nulle, ou paramètre étranger au mode retenu (roomWidthTiles/roomHeightTiles hors PerRoom/Follow, zones hors PerRoom).

Parameters

config	Cadrage déclaré à valider.
levelWidth	Largeur du niveau, en cases.
levelHeight	Hauteur du niveau, en cases.

Returns: Un message d'erreur exploitable nommant le champ fautif, ou std::nullopt si valide.

Variable Documentation

◆ COLLISION_SKIN

float core::COLLISION_SKIN = 1e-4F

inlineconstexpr

Tolérance géométrique des routines de balayage, en unités monde.

Empêche qu'un simple effleurement de frontière — un bord exactement posé sur une limite de case — compte comme un chevauchement. Partagée par sweepX/sweepY (SweptCollision) et par la résolution AABB/AABB : les deux doivent s'accorder sur ce qu'est un contact, sans quoi une même position serait bloquante pour l'une et libre pour l'autre. Ce n'est pas un réglage de ressenti, d'où sa place ici et non dans PhysicsConfig : la modifier ne change pas le jeu, elle change la définition du contact.

◆ D20_FACES

int core::D20_FACES = 20

inlineconstexpr

Nombre de faces du dé de résolution. Le d20 est la mécanique centrale du jeu.

◆ DEFAULT_PARTICLE_SEED

std::uint64_t core::DEFAULT_PARTICLE_SEED = 0x504152544943454CULL

inlineconstexpr

Graine par défaut de core::ParticleSystem – fixe et documentée, jamais l'horloge système (EX-NFR-002) : deux sessions démarrées avec cette graine et soumises à la même séquence d'entrées produisent exactement les mêmes particules.

◆ DEFAULT_ROOM_HEIGHT_TILES

int core::DEFAULT_ROOM_HEIGHT_TILES = 14

inlineconstexpr

◆ DEFAULT_ROOM_WIDTH_TILES

int core::DEFAULT_ROOM_WIDTH_TILES = 24

inlineconstexpr

Taille de salle par défaut du mode par salle, en cases.

Mêmes valeurs historiques que hmi::RoomGrid (LOT-32), désormais une valeur par défaut plutôt que la seule vérité (tache-01) : un niveau peut la personnaliser. Dupliquées ici plutôt que lues depuis hmi::RoomGrid : Core ne dépend jamais de HMI (EX-ARCH-011).

◆ DEVELOPER_BUILD

bool core::DEVELOPER_BUILD = true

inlineconstexpr

Vrai dans les builds de développement (Debug), faux en Release.

S'appuie sur NDEBUG (défini par le compilateur en Release). Sert à n'inclure que dans les builds de développement des éléments d'outillage (par exemple des boutons de débogage de l'interface), à utiliser de préférence avec if constexpr pour éliminer le code en Release.

◆ ENCOUNTER_ENTITY_TYPE

std::string_view core::ENCOUNTER_ENTITY_TYPE = "encounter"

inlineconstexpr

Type de la couche objects qui déclenche une rencontre.

◆ EPSILON

float core::EPSILON = 1e-5f

inlineconstexpr

Tolérance par défaut pour les comparaisons de flottants issus de calculs.

◆ EQUIPMENT_SLOT_COUNT

std::size_t core::EQUIPMENT_SLOT_COUNT = 16

inlineconstexpr

Nombre d'emplacements, pour dimensionner les tableaux qui les indexent.

◆ INVALID_ENTITY

Entity core::INVALID_ENTITY {Entity::INVALID_INDEX, 0}

inlineconstexpr

Entité invalide conventionnelle : ne désigne jamais une entité vivante.

◆ kRegionAxisCount

std::size_t core::kRegionAxisCount = 7

inlineconstexpr

Nombre d'axes.

◆ kRegionGradeCount

std::size_t core::kRegionGradeCount = 5

inlineconstexpr

Nombre de notes — pour les parcours exhaustifs et les contrôles de couverture.

◆ LANDING_DUST_MAX_COUNT

int core::LANDING_DUST_MAX_COUNT = 10

inlineconstexpr

Nombre de particules de poussière au plafond LANDING_MAX_IMPACT_SPEED (intensité maximale).

◆ LANDING_DUST_MIN_COUNT

int core::LANDING_DUST_MIN_COUNT = 3

inlineconstexpr

Nombre de particules de poussière au seuil LANDING_MIN_IMPACT_SPEED (intensité minimale).

◆ LANDING_MAX_IMPACT_SPEED

float core::LANDING_MAX_IMPACT_SPEED = 14.0f

inlineconstexpr

Vitesse d'impact au-delà de laquelle l'intensité de la poussière plafonne (LANDING_DUST_MAX_ COUNT) : une chute extrême ne produit pas un nuage toujours plus dense.

◆ LANDING_MIN_IMPACT_SPEED

float core::LANDING_MIN_IMPACT_SPEED = 4.0f

inlineconstexpr

Vitesse d'impact (LOT-53 TACHE-02) en-dessous de laquelle un atterrissage ne produit aucune poussière – sans ce seuil, chaque petit pas en émettrait.

◆ LAYER_KIND_COUNT

int core::LAYER_KIND_COUNT = static_cast<int>(LayerKind::Legacy) + 1

inlineconstexpr

Nombre de valeurs de core::LayerKind — même convention que core::TILE_TYPE_COUNT : toute valeur ajoutée doit l'être avant le dernier énumérateur.

◆ LEVEL_FORMAT_VERSION

int core::LEVEL_FORMAT_VERSION = 3

inlineconstexpr

Version courante du format de niveau JSON (EX-LVL-005).

Écrite par LevelWriter dans le champ racine "version". Un fichier sans ce champ est lu comme la version initiale (0), sans erreur ni avertissement — rétrocompatibilité des niveaux antérieurs à ce champ (LOT-44). Une version supérieure à celle-ci est une erreur exploitable (LevelValidationError::UnsupportedFormatVersion), pas une lecture au mieux.

Version 2 (LOT-64) : ajout du champ optionnel "cameraFraming" (EX-LVL-006). Un fichier de version antérieure, sans ce champ, se charge sans erreur – la règle de repli (core::resolveCameraFraming) reproduit exactement le comportement historique.

Version 3 (LOT-04) : couches de tuiles ("layers", core::TileLayer) et entités ("entities", core::MapEntity), les deux optionnels. "layers" ne porte que les couches visibles (sol, décor) : la grille de collision d'une carte est son tableau racine "tiles", celui qui porte déjà l'entrée, la sortie et les mécanismes — une couche "collision" déclarée est refusée (EX-LVL-016). Cette grille racine est promue en couche de tête, de rôle LayerKind::Collision, ou LayerKind::Legacy quand la carte ne déclare aucune couche : aucun fichier existant n'a besoin d'être touché, et rien de son comportement ne change.

Toute clé non reconnue dans une couche ou une entité est rangée dans ses propriétés libres (core::PropertyMap) et réémise à l'écriture : un fichier produit par une version ultérieure de l'éditeur traverse une version antérieure sans rien perdre.

◆ MAX_PARTICLES

int core::MAX_PARTICLES = 256

inlineconstexpr

Nombre maximal de particules simultanément vivantes (EX-NFR-005) : au-delà, spawn() recycle les plus anciennes plutôt que d'allouer sans borne.

◆ MAX_PLANE_TEXTURE_EXTENT

int core::MAX_PLANE_TEXTURE_EXTENT = 16384

inlineconstexpr

Dimension maximale, en pixels, d'une texture de plan sur un axe (EX-DEC-044) — limite de Direct3D 11 au feature level 11.

◆ MAX_PLANES_PER_LEVEL

std::size_t core::MAX_PLANES_PER_LEVEL = 16

inlineconstexpr

Nombre maximal de plans par niveau (EX-DEC-044) : borne le coût dans le format, plutôt que de le laisser à l'usage.

◆ METERS_PER_TILE

float core::METERS_PER_TILE = 1.5f

inlineconstexpr

Côté d'une case de la grille tactique, en mètres.

Décision de cadrage, figée ici et nulle part ailleurs. Toutes les portées et vitesses du corpus sont exprimées en mètres — « allonge 1,50 m », « vitesse 9 m », « portée 6 m/18 m » — et la grille tactique du LOT-19 compte en cases. La conversion se fait donc quelque part, et le seul choix ouvert est : à un endroit, ou à trente.

À trente endroits, il suffit qu'un seul emploie 1,5 quand un autre emploie 1,52 (les cinq pieds d'origine) pour qu'une portée de six cases devienne cinq à un endroit du jeu et six ailleurs — et c'est le genre d'écart qu'on ne diagnostique qu'après l'avoir cherché longtemps.

Consommée par les LOT-19 (déplacement) et LOT-22 (portée, ligne de vue, zones d'effet).

◆ PLANE_NATIVE_PIXELS_PER_UNIT

int core::PLANE_NATIVE_PIXELS_PER_UNIT = 16

inlineconstexpr

Densité native d'un plan, en pixels par unité monde — même valeur que l'échelle de rendu (hmi::Camera2D::PIXELS_PER_UNIT), que Core ne peut pas inclure (EX-NFR-011).

◆ PLAYER_CLIP_DASH

int core::PLAYER_CLIP_DASH = 6

constexpr

Index du clip « dash » dans core::playerClipSet() (voir PLAYER_CLIP_IDLE).

◆ PLAYER_CLIP_FALL

int core::PLAYER_CLIP_FALL = 3

constexpr

Index du clip « fall » (chute, distincte du saut, LOT-48) dans core::playerClipSet().

◆ PLAYER_CLIP_IDLE

int core::PLAYER_CLIP_IDLE = 0

constexpr

Index du clip « idle » dans core::playerClipSet() — ordre stable, seule source de vérité partagée avec hmi::TextureAtlas::playerFrameRegion (traduction en région d'atlas, LOT-46 TACHE-04) : ne pas réordonner sans mettre à jour HMI en conséquence.

◆ PLAYER_CLIP_JUMP

int core::PLAYER_CLIP_JUMP = 2

constexpr

Index du clip « jump » dans core::playerClipSet() (voir PLAYER_CLIP_IDLE).

◆ PLAYER_CLIP_LAND

int core::PLAYER_CLIP_LAND = 4

constexpr

Index du clip « land » (atterrissage, transition jouée une fois, LOT-48) dans core::playerClipSet().

◆ PLAYER_CLIP_RUN

int core::PLAYER_CLIP_RUN = 1

constexpr

Index du clip « run » dans core::playerClipSet() (voir PLAYER_CLIP_IDLE).

◆ PLAYER_CLIP_WALLSLIDE

int core::PLAYER_CLIP_WALLSLIDE = 5

constexpr

Index du clip « wallslide » (glissade murale, LOT-48) dans core::playerClipSet().

◆ PLAYER_HEIGHT

float core::PLAYER_HEIGHT = 0.8f

inlineconstexpr

Hauteur du personnage, en unités monde.

◆ PLAYER_WIDTH

float core::PLAYER_WIDTH = 0.4f

inlineconstexpr

Largeur du personnage, en unités monde (une tuile = 1 unité).

◆ TILE_TYPE_COUNT

int core::TILE_TYPE_COUNT = static_cast<int>(TileType::Stairs) + 1

inlineconstexpr

Nombre de valeurs de core::TileType — seule source de vérité de la fin de l'énumération (LOT-74 TACHE-02).

Ajouter un type ne demande rien d'autre que de l'ajouter ci-dessus, avant le dernier énumérateur : cette constante suit, et ses consommateurs avec elle. L'ajouter en fin de liste, comme l'a fait le LOT-08, demande en plus de re-pointer cette seule ligne — c'est le prix d'un vocabulaire qui se lit dans son ordre d'apparition plutôt qu'en désordre.

Volontairement une constante libre plutôt qu'un énumérateur Count : les switch sur TileType du projet sont exhaustifs et sans default (c'est ce qui fait que le compilateur désigne lui-même les points à mettre à jour), et un énumérateur sentinelle les obligerait tous à traiter un cas qui ne décrit aucune tuile.

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ AssertionHandler

◆ PropertyMap

◆ PropertyValue

Enumeration Type Documentation

◆ Ability

◆ ArmorCategory

◆ CameraFramingMode

◆ CasterProgression

◆ ClipEndMode

◆ CombatOutcome

◆ Condition

◆ CreatureSize

◆ DamageType

◆ EncumbranceLevel

◆ EquipmentSlot

◆ JsonReadError

◆ LayerKind

◆ LevelOutcome

◆ LevelValidationError

◆ LogLevel

◆ MagicSchool

◆ ParticleKind

◆ PlaneDepth

◆ RegionAxis

◆ RegionGrade

◆ RollStance

◆ TileType

Function Documentation

◆ abilityModifier()

◆ abilityName()

◆ abilityScoreWith()

◆ addToBackpack()

◆ advanceAnimation()

◆ aimedCell()

◆ allAbilities()

◆ allConditions()

◆ allCreatureSizes()

◆ allDamageTypes()

◆ allMagicSchools()

◆ approximatelyEqual()

◆ armorCategoryName()

◆ armorClassFor()

◆ assetMarker()

Pourquoi un marqueur plutôt qu'une image manquante

Déterministe, et c'est le point

◆ beginEncounter()

◆ buildCharacterSheet()

◆ buildLevelScene()

◆ cameraFramingModeName()

◆ carriedWeightGrams()

◆ casterProgressionName()

◆ conditionName()

◆ creatureSizeName()

◆ currentTimestamp()

◆ damageTypeName()

◆ defaultAssetKeyFor()

◆ defaultLogger()

◆ derivedStatsFor()

◆ deriveSeed()

◆ encounterAlreadyCleared()

◆ encounterTriggerFor()

◆ endEncounter()

◆ equip()

◆ equipmentSlotName()

◆ evaluateOutcome()

◆ expectedAssetKeys()

◆ fileName()

◆ findInteractionTarget()

◆ formatDice()

◆ formatLogLine()

◆ gainExperience()

◆ handleAssertionFailure()

◆ interact()