Blueprints & Scènes

Structure du blueprint

Un BlueprintExport est le fichier JSON exporté de l'éditeur LSDE. Il contient toutes les données dont le engine a besoin.

TypeScript

interface BlueprintExport {
  version: string;
  exportDate: string;
  projectName?: string;
  primaryLanguage?: string;
  locales: string[];
  dictionaries?: Dictionary[];
  signatures?: ActionSignature[];
  scenes: BlueprintScene[];
}

C#

public class BlueprintExport {
    public string Version { get; set; }
    public string ExportDate { get; set; }
    public string? ProjectName { get; set; }
    public string? PrimaryLanguage { get; set; }
    public List<string> Locales { get; set; }
    public List<Dictionary>? Dictionaries { get; set; }
    public List<ActionSignature>? Signatures { get; set; }
    public List<BlueprintScene> Scenes { get; set; }
}

C++

struct BlueprintExport {
    std::string version;
    std::string exportDate;
    std::optional<std::string> projectName;
    std::optional<std::string> primaryLanguage;
    std::vector<std::string> locales;
    std::vector<LsdeDictionary> dictionaries;
    std::vector<ActionSignature> signatures;
    std::vector<BlueprintScene> scenes;
};

GDScript

# Dictionary with keys:
# "version": String
# "exportDate": String
# "projectName": String (optional)
# "primaryLanguage": String (optional)
# "locales": Array[String]
# "dictionaries": Array[Dictionary] (optional)
# "signatures": Array[Dictionary] (optional)
# "scenes": Array[Dictionary]

Scenes

Une scene est une séquence de dialogue autonome — une conversation, une cinématique, un tutoriel, une interaction de shop. Dans un jeu, les scenes sont généralement déclenchées par des événements scriptés : le joueur parle à un NPC, entre dans une zone, ou ramasse un objet.

Chaque scene a son propre block d'entrée, son propre flow et son propre état. Plusieurs scenes peuvent tourner en parallèle (ex: un dialogue principal et un overlay de tutoriel). Les scenes sont définies par l'interface BlueprintScene :

TypeScript

interface BlueprintScene {
  uuid: string;
  label: string;
  note?: string;
  entryBlockId?: string;
  date: string;
  blocks: BlueprintBlock[];
  connections: BlueprintConnection[];
}

C#

public class BlueprintScene {
    public string Uuid { get; set; }
    public string Label { get; set; }
    public string? Note { get; set; }
    public string? EntryBlockId { get; set; }
    public string Date { get; set; }
    public List<BlueprintBlock> Blocks { get; set; }
    public List<BlueprintConnection> Connections { get; set; }
}

C++

struct BlueprintScene {
    std::string uuid;
    std::string label;
    std::optional<std::string> note;
    std::optional<std::string> entryBlockId;
    std::string date;
    std::vector<BlueprintBlock> blocks;
    std::vector<BlueprintConnection> connections;
};

GDScript

# Dictionary with keys:
# "uuid": String
# "label": String
# "note": String (optional)
# "entryBlockId": String (optional)
# "date": String
# "blocks": Array[Dictionary]
# "connections": Array[Dictionary]

Connections

Les connections sont les fils entre les blocks — elles définissent quel block mène à quel autre. Dans l'éditeur, on les dessine visuellement; dans l'export, elles deviennent une liste plate de liens source → cible définis par l'interface BlueprintConnection :

TypeScript

interface BlueprintConnection {
  id: string;
  fromId: string;
  toId: string;
  fromPort: string;
  toPort: string;
  fromPortIndex?: number;
}

C#

public class BlueprintConnection {
    public string Id { get; set; }
    public string FromId { get; set; }
    public string ToId { get; set; }
    public string FromPort { get; set; }
    public string ToPort { get; set; }
    public int? FromPortIndex { get; set; }
}

C++

struct BlueprintConnection {
    std::string id;
    std::string fromId;
    std::string toId;
    std::string fromPort;
    std::string toPort;
    std::optional<int> fromPortIndex;
};

GDScript

# Dictionary with keys:
# "id": String
# "fromId": String
# "toId": String
# "fromPort": String
# "toPort": String
# "fromPortIndex": int (optional)

Vous n'aurez normalement pas besoin d'inspecter les connections directement — le engine gère le routing en interne. Elles sont toutefois accessibles via onValidateNextBlock si nécessaire.

Dictionaries

Les dictionaries décrivent les registres de votre jeu — switches, variables, inventaire. Le développeur les déclare dans LSDE pour exposer au narrative designer les variables disponibles dans le moteur. Au runtime, le développeur mappe chaque dictionnaire vers le système correspondant de son jeu. Les conditions et onResolveCondition utilisent ces clés pour évaluer l'état du jeu. Définis par Dictionary :

TypeScript

interface Dictionary {
  uuid: string;
  id: string;
  rows: DictionaryRow[];
}

interface DictionaryRow {
  key: string;
}

C#

public class LsdeDictionary {
    public string Uuid { get; set; }
    public string Id { get; set; }
    public List<DictionaryRow> Rows { get; set; }
}

public class DictionaryRow {
    public string Key { get; set; }
}

C++

struct LsdeDictionary {
    std::string uuid;
    std::string id;
    std::vector<DictionaryRow> rows;
};

struct DictionaryRow {
    std::string key;
};

GDScript

# Dictionary with keys:
# "uuid": String
# "id": String
# "rows": Array[{"key": String}]

Action Signatures

Les signatures décrivent les types d'actions disponibles dans votre jeu — set_flag, play_sound, give_item. Le développeur les déclare dans LSDE pour que le narrative designer compose des séquences d'actions avec des paramètres typés. Au runtime, le id de la signature est ce que le développeur mappe vers ses propres systèmes. Définis par ActionSignature :

TypeScript

interface ActionSignature {
  uuid: string;
  id: string;
  params: SignatureParam[];
}

interface SignatureParam {
  label?: string;
  type: 'boolean' | 'string' | 'number' | 'enum' | 'dictionary';
  dictionaryGroupUuid?: string;
  enumOptions?: { id: string; label?: string }[];
}

C#

public class ActionSignature {
    public string Uuid { get; set; }
    public string Id { get; set; }
    public List<SignatureParam> Params { get; set; }
}

public class SignatureParam {
    public string? Label { get; set; }
    public string Type { get; set; }
    public string? DictionaryGroupUuid { get; set; }
    public List<EnumOption>? EnumOptions { get; set; }
}

C++

struct ActionSignature {
    std::string uuid;
    std::string id;
    std::vector<SignatureParam> params;
};

struct SignatureParam {
    std::optional<std::string> label;
    std::string type;
    std::optional<std::string> dictionaryGroupUuid;
    std::vector<EnumOption> enumOptions;
};

GDScript

# ActionSignature Dictionary:
# "uuid": String
# "id": String
# "params": Array[SignatureParam]
#
# SignatureParam Dictionary:
# "label": String (optional)
# "type": "boolean" | "string" | "number" | "enum" | "dictionary"
# "dictionaryGroupUuid": String (optional)
# "enumOptions": Array[{"id": String, "label": String?}] (optional)