From 52807890ecff2adde50ee04f6379463235d4ba4d Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Wed, 8 Feb 2023 20:42:54 +0100
Subject: [PATCH 01/27] feat: ajout tableau dynamiques

---
 src/components/tableaux/DynTable.vue | 224 +++++++++++++++++++++++++++
 1 file changed, 224 insertions(+)
 create mode 100644 src/components/tableaux/DynTable.vue

diff --git a/src/components/tableaux/DynTable.vue b/src/components/tableaux/DynTable.vue
new file mode 100644
index 0000000..0791328
--- /dev/null
+++ b/src/components/tableaux/DynTable.vue
@@ -0,0 +1,224 @@
+<script lang="ts" setup>
+import { computed, ref, onMounted } from "vue";
+import type { PropType } from "vue";
+import axios from "axios";
+
+interface TableField {
+  key: string;
+  label: string;
+  canBeFiltered?: boolean;
+}
+
+interface Filters {
+  [key: string]: boolean;
+}
+
+interface FilterList {
+  [key: string]: { title: string; filters: Filters };
+}
+
+interface TableItem {
+  [key: string]: unknown;
+}
+
+const props = defineProps({
+  fields: {
+    type: Array as PropType<TableField[]>,
+    default: () => [],
+  },
+  files: {
+    type: Array as PropType<string[]>,
+    default: () => [],
+  },
+});
+
+const items = ref([] as TableItem[]);
+const filters = ref({} as FilterList);
+const pageNumber = ref(0);
+const elemByPage = ref(10);
+
+const displayedFieldKeys = computed(() => {
+  return Object.entries(props.fields).map(([key, value]) => value.key);
+});
+
+function haveFilter(filterName: string) {
+  for (const val in filters.value[filterName].filters) {
+    if (
+      Object.prototype.hasOwnProperty.call(
+        filters.value[filterName].filters,
+        val
+      )
+    ) {
+      if (filters.value[filterName].filters[val]) {
+        console.log(filterName, true);
+        return true;
+      }
+    }
+  }
+  console.log(filterName, false);
+  return false;
+}
+
+const filteredItems = computed(() => {
+  var filteredItem = items.value as TableItem[];
+
+  for (const filter in filters.value) {
+    if (haveFilter(filter)) {
+      filteredItem = filteredItem.filter((value) => {
+        return filters.value[filter].filters[value[filter] as string];
+      });
+    }
+  }
+
+  return filteredItem;
+});
+
+const paginatedList = computed(() => {
+  var filteredItem = filteredItems.value as TableItem[];
+
+  filteredItem = filteredItem.filter((value, index) => {
+    const pageBegin = pageNumber.value * elemByPage.value;
+    return index >= pageBegin && index < pageBegin + elemByPage.value;
+  });
+
+  return filteredItem;
+});
+
+onMounted(() => {
+  for (const field of props.fields) {
+    if (field.canBeFiltered) {
+      filters.value[field.key] = {
+        title: field.label,
+        filters: {} as Filters,
+      };
+    }
+  }
+
+  for (const file of props.files) {
+    const listItems = `/jdr/objets/${file}.json`;
+    axios.get(listItems).then((response) => {
+      items.value = items.value.concat(response.data);
+      response.data.forEach((element: TableItem) => {
+        for (const key in element) {
+          if (Object.prototype.hasOwnProperty.call(element, key)) {
+            if (filters.value[key]) {
+              filters.value[key].filters[element[key] as string] = false;
+            }
+          }
+        }
+      });
+    });
+  }
+});
+
+function switchFilter(filterSet: string | number, filterName: string | number) {
+  if (filters.value[filterSet]?.filters[filterName] !== undefined) {
+    filters.value[filterSet].filters[filterName] =
+      !filters.value[filterSet].filters[filterName];
+  }
+  setPage(0);
+}
+
+function removeFilter(filterSet: string | number) {
+  for (const val in filters.value[filterSet].filters) {
+    if (
+      Object.prototype.hasOwnProperty.call(
+        filters.value[filterSet].filters,
+        val
+      )
+    ) {
+      filters.value[filterSet].filters[val] = false;
+    }
+  }
+  setPage(0);
+}
+
+const getTotalPage = computed(() => {
+  return Math.floor((filteredItems.value.length - 1) / elemByPage.value);
+});
+
+function setPage(page: number) {
+  pageNumber.value = page;
+}
+
+function canGo(rel: number) {
+  return (
+    pageNumber.value + rel >= 0 && pageNumber.value + rel <= getTotalPage.value
+  );
+}
+
+function go(rel: number) {
+  if (canGo(rel)) {
+    setPage(pageNumber.value + rel);
+  }
+}
+</script>
+
+<template>
+  <div class="small-text" v-for="(filter, key) in filters" :key="key">
+    <strong>{{ filter.title }} : </strong>
+    <button
+      v-for="(isTrue, filterName) in filter.filters"
+      :key="filterName"
+      class="btn-small mb-0"
+      :class="{ 'btn-grey': !isTrue, 'btn-primary': isTrue }"
+      @click="switchFilter(key, filterName)"
+    >
+      {{ filterName }}
+    </button>
+    <button class="btn-small btn-secondary mb-0" @click="removeFilter(key)">
+      Vider filtres
+    </button>
+  </div>
+  <table class="pb-0 table-auto">
+    <thead>
+      <tr>
+        <th v-for="field in fields" :key="field.key">
+          {{ field.label }}
+        </th>
+      </tr>
+    </thead>
+    <tbody>
+      <tr v-for="(item, index) of paginatedList" :key="index">
+        <td v-for="(key, index2) in displayedFieldKeys" :key="index2">
+          {{ item[key] }}
+        </td>
+      </tr>
+    </tbody>
+  </table>
+  <div class="d-flex f-between f-middle nextprevious small-text">
+    <div>
+      <strong class="btn m-0 pages pl-0">
+        Page {{ pageNumber + 1 }} / {{ getTotalPage + 1 }}
+      </strong>
+    </div>
+
+    <div>
+      <button
+        class="btn btn-grey m-0 mr-1"
+        :class="{ 'bg-grey': !canGo(-1), 'btn-secondary': canGo(-1) }"
+        @click="go(-1)"
+      >
+        Page précédante
+      </button>
+      <button
+        class="btn btn-grey m-0"
+        :class="{ 'bg-grey': !canGo(1), 'btn-secondary': canGo(1) }"
+        @click="go(1)"
+      >
+        Page suivante
+      </button>
+    </div>
+  </div>
+</template>
+
+<style lang="scss" scoped>
+.small-text {
+  font-size: 0.8rem;
+  padding-bottom: 0.5rem;
+}
+
+.pages {
+  font-weight: 600;
+}
+</style>

From 592c80b8949454db0c68dde32fe3166433c8b112 Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Wed, 8 Feb 2023 20:44:47 +0100
Subject: [PATCH 02/27] feat: tableau dynamique pour les objets

---
 public/jdr/core.json               |  3 +-
 public/jdr/erratum.json            |  5 +-
 public/jdr/objets/base.json        | 10 ++++
 public/jdr/objets/elements.json    |  6 ++
 public/jdr/objets/magique.json     |  4 ++
 public/jdr/objets/potions.json     | 32 ++++++++++
 public/pelican.json                |  3 +-
 public/rules/inventaire/objets.md  | 29 ++-------
 public/rules/inventaire/potions.md | 95 ------------------------------
 src/data/fields.ts                 |  9 +++
 src/router/index.ts                |  5 ++
 11 files changed, 76 insertions(+), 125 deletions(-)
 create mode 100644 public/jdr/objets/base.json
 create mode 100644 public/jdr/objets/elements.json
 create mode 100644 public/jdr/objets/magique.json
 create mode 100644 public/jdr/objets/potions.json
 delete mode 100644 public/rules/inventaire/potions.md
 create mode 100644 src/data/fields.ts

diff --git a/public/jdr/core.json b/public/jdr/core.json
index e657e64..d46cd64 100644
--- a/public/jdr/core.json
+++ b/public/jdr/core.json
@@ -4,5 +4,6 @@
     {"name":"determination01","value":"Effet dépendant du JDR"},
     {"name":"determination19","value":"Effet dépendant du JDR"},
     {"name":"determination20","value":"Effet dépendant du JDR"}
-  ]
+  ],
+  "objects":["base"]
 }
\ No newline at end of file
diff --git a/public/jdr/erratum.json b/public/jdr/erratum.json
index 21230c4..523fb4f 100644
--- a/public/jdr/erratum.json
+++ b/public/jdr/erratum.json
@@ -1,5 +1,5 @@
 {
-  "name": "Règles de bases",
+  "name": "Erratum",
   "sidebar": [
     {
       "id": 50,
@@ -24,5 +24,6 @@
     {"name":"determination01","value":"Le personnage fait un jet d'apothéose (D100). Si réussite critique: apothéose, si échec critique, jet d'anomie, sinon +1 karma"},
     {"name":"determination19","value":"Le personnage fait un jet d'anomie"},
     {"name":"determination20","value":"Le personnage devient anomique"}
-  ]
+  ],
+  "objects":["base"]
 }
\ No newline at end of file
diff --git a/public/jdr/objets/base.json b/public/jdr/objets/base.json
new file mode 100644
index 0000000..6263e3d
--- /dev/null
+++ b/public/jdr/objets/base.json
@@ -0,0 +1,10 @@
+[
+  {"nom":"Repas complet de base","type":"Nourriture","rarete":"Commun","effet":"Des vivres pour une journée. Durent une partie.","cout":10},
+  {"nom":"Repas de qualité","type":"Nourriture","rarete":"Commun","effet":"Des vivres pour une journée. Durent une partie. +5% à toute les stats","cout":25},
+  {"nom":"Alcool néfaste","type":"Nourriture","rarete":"Semi-rare","effet":"Provoque un jet de pestilence et de bénédiction à la fois","cout":500},
+  {"nom":"Pain d'ascedie","type":"Nourriture","rarete":"Semi-rare","effet":"Ne périme pas, fait un repas complet - mais la sensation de faim reste et il est dégoutant.","cout":80},
+  {"nom":"Explosif","type":"Attaque","rarete":"Commun","effet":"Provoque une explosion de 12 dégâts (sur trois ennemis proches).","cout":100},
+  {"nom":"Bille de statistiques","type":"Boost","rarete":"Semi-rare","effet":"Ajoute +5% à la statistique trois tours. Cumulatif","cout":250},
+  {"nom":"Dés pipés","type":"Boost","rarete":"Rare","effet":"Annule un échec critique, mais la réussite critique suivante sera un échec critique","cout":1500},
+  {"nom":"Liste d'Attente de la mort","type":"Boost","rarete":"Rare","effet":"Réussite automatique au prochain jet de survie, le suivant à chance/2","cout":1500}
+]
\ No newline at end of file
diff --git a/public/jdr/objets/elements.json b/public/jdr/objets/elements.json
new file mode 100644
index 0000000..1a7c664
--- /dev/null
+++ b/public/jdr/objets/elements.json
@@ -0,0 +1,6 @@
+[
+  {"nom":"Graine élémentaire","type":"Attaque","rarete":"Commun","effet":"Produit l'effet de l'élément.","cout":50},
+  {"nom":"Prisme d'élément","type":"Attaque","rarete":"Semi-rare","effet":"Quand brisé, produit un terrain élémentaire","cout":500},
+  {"nom":"Bombes élémentaires","type":"Attaque","rarete":"Commun","effet":"Provoque une explosion de 12 dégâts (sur trois ennemis proches) avec effet élémentaire.","cout":150},
+  {"nom":"Voile élémentaire","type":"Boost","rarete":"Semi-rare","effet":"Produit une résistance à l'élément sur toute l'équipe trois tours","cout":550}
+]
\ No newline at end of file
diff --git a/public/jdr/objets/magique.json b/public/jdr/objets/magique.json
new file mode 100644
index 0000000..619af27
--- /dev/null
+++ b/public/jdr/objets/magique.json
@@ -0,0 +1,4 @@
+[
+  {"nom":"Essence d'espèce","type":"Boost","rarete":"Rare","effet":"Change l'espèce d'un personnage trois tours.","cout":1000},
+  {"nom":"Cristal de téléportation","type":"Utilitaire","rarete":"Semi-rare","effet":"Ramène au début d'un donjon où d'un endroit","cout":400}
+]
\ No newline at end of file
diff --git a/public/jdr/objets/potions.json b/public/jdr/objets/potions.json
new file mode 100644
index 0000000..de3554d
--- /dev/null
+++ b/public/jdr/objets/potions.json
@@ -0,0 +1,32 @@
+[
+  {"nom":"Ingrédients Communs","type":"Ingrédient","rarete":"Rare","effet":"Permet de créer des potions communes.","cout":5},
+  {"nom":"Ingrédients Semi-rares","type":"Ingrédient","rarete":"Semi-rare","effet":"Permet de créer des potions semi-rares.","cout":40},
+  {"nom":"Ingrédients Rares","type":"Ingrédient","rarete":"Semi-rare","effet":"Permet de créer des potions rares.","cout":125},
+  {"nom":"Ingrédients Exceptionnels","type":"Ingrédient","rarete":"Exceptionnel","effet":"Permet de créer des potions exceptionnelles.","cout":500},
+  {"nom":"Herbes démoniaques","type":"Ingrédient","rarete":"Rare","effet":"Transforme une potion à effet positif en potion satanique : augmente ses effets, mais provoque un jet de panique","cout":200},
+  {"nom":"Potion de soin","type":"Potion","rarete":"Commun","effet":"Permet de regagner 12PV","cout":20},
+  {"nom":"Potion de moral","type":"Potion","rarete":"Commun","effet":"Permet de regagner 12PM","cout":20},
+  {"nom":"Antidote","type":"Potion","rarete":"Commun","effet":"Soigne une affliction physique","cout":20},
+  {"nom":"Extrait de douleur","type":"Potion","rarete":"Commun","effet":"Inflige 3 dégâts esprit et 3 dégâts de corps","cout":20},
+  {"nom":"Potion de vigueur","type":"Potion","rarete":"Commun","effet":"Augmente de 10 % les statistiques physique pendant trois tour","cout":20},
+  {"nom":"Potion explosive légère","type":"Potion","rarete":"Commun","effet":"Provoque une explosion d'une puissance de 8 dégâts bruts, pas d'esquive. (dégat doublé si bue)","cout":20},
+  {"nom":"Potion d'aveuglement","type":"Potion","rarete":"Commun","effet":"Produit un malus de 15 % en PER à tout personnage touché par la potion.","cout":20},
+  {"nom":"Potion de flamme","type":"Potion","rarete":"Commun","effet":"Donne des dégâts de feu aux attaques","cout":20},
+  {"nom":"Potion de satiété","type":"Potion","rarete":"Commun","effet":"Protège de la faim pendant trois parties","cout":20},
+  {"nom":"Potion de soin avancée","type":"Potion","rarete":"Semi-rare","effet":"Permet de regagner 24PV","cout":85},
+  {"nom":"Potion de moral avancée","type":"Potion","rarete":"Semi-rare","effet":"Permet de regagner 24PM","cout":85},
+  {"nom":"Essence de célérité","type":"Potion","rarete":"Semi-rare","effet":"Toujours premier pour prochain combat","cout":85},
+  {"nom":"Potion de pestilence","type":"Potion","rarete":"Semi-rare","effet":"Fait faire un jet de pestilence à l’ennemi quand il est touché","cout":85},
+  {"nom":"Concentré de Dopage","type":"Potion","rarete":"Semi-rare","effet":"Permet de faire rejouer","cout":85},
+  {"nom":"Potion de rage","type":"Potion","rarete":"Semi-rare","effet":"Booste l’attaque de 20 % mais lui donne 1 chance sur 4 d’attaquer un allié (la chance sur 4 est cumulable)","cout":85},
+  {"nom":"Potion explosive avancée","type":"Potion","rarete":"Semi-rare","effet":"Provoque une explosion d'une puissance de 14 dégâts, pas d'esquive. (dégat doublé si bue)","cout":85},
+  {"nom":"Potion de soin royale","type":"Potion","rarete":"Rare","effet":"Permet de regagner 54PV","cout":250},
+  {"nom":"Potion de moral royale","type":"Potion","rarete":"Rare","effet":"Permet de regagner 54PV","cout":250},
+  {"nom":"Potion 'Debout les Morts'","type":"Potion","rarete":"Rare","effet":"Soigne de tout les PV un perso non-mort, mais rend fortement confus 5 tours.","cout":250},
+  {"nom":"Potion d’intangibilité","type":"Potion","rarete":"Rare","effet":"Donne une immunité aux dégâts physiques.","cout":250},
+  {"nom":"Filtre d’amour","type":"Potion","rarete":"Rare","effet":"Peut séduire en combat un allié et lui donner +50 % à tout ses jets. Il obéira à tout ses ordres, et ne prendra d’action sans son autorisation.","cout":250},
+  {"nom":"Potion d'éclat","type":"Potion","rarete":"Rare","effet":"Permet de regagner 2 point d'éclat","cout":250},
+  {"nom":"Potion de Résurrection","type":"Potion","rarete":"Exceptionnel","effet":"Ramène un perso mort à la vie, si la mort date de moins d'une partie","cout":1000},
+  {"nom":"Potion de Bonheur","type":"Potion","rarete":"Exceptionnel","effet":"Immunise temporairement aux effets de la perte de moral","cout":1000},
+  {"nom":"Potion secrète","type":"Potion","rarete":"Exceptionnel","effet":"La personne l’ayant bu peut annuler un critique au choix","cout":1000}
+]
\ No newline at end of file
diff --git a/public/pelican.json b/public/pelican.json
index 049381e..98cbf4f 100644
--- a/public/pelican.json
+++ b/public/pelican.json
@@ -55,9 +55,8 @@
       "id": 40,
       "title": "Inventaire",
       "links": [
-        {"title": "Objets et aliments", "path": "rules/inventaire/objets"},
+        {"title": "Objets et consommables", "path": "inventaire/objets"},
         {"title": "Équipement et outils", "path": "rules/inventaire/equipements"},
-        {"title": "Potions et crafting", "path": "rules/inventaire/potions"},
         {"title": "Véhicules", "path": "rules/inventaire/vehicules"}
       ]
     },
diff --git a/public/rules/inventaire/objets.md b/public/rules/inventaire/objets.md
index 7770adf..616d179 100644
--- a/public/rules/inventaire/objets.md
+++ b/public/rules/inventaire/objets.md
@@ -1,30 +1,9 @@
 # Objets et consommables
 
-<div class="table-auto">
+Dans votre aventure, vous trouverez de nombreux objets consommables, qui pourront vous permettre d'avoir des pouvoirs plus ou moins positifs. Ces différents objects peuvent être trouvés, acheté, construit. Cette page à pour objectif de présenter ces différents objets.
 
-## Nourritures
+## Créer un objet
 
-| Objet | Effet | Prix |
-|:----------:|:------|:----:|
-| Repas complet de base | Des vivres pour une journée. Durent une partie. | 10 |
-| Repas de qualité | Des vivres pour une journée + ajoute un niveau de boost dans toute les statistiques. Durent une partie. | 25 |
-| Alcool néfaste | Provoque un jet de pestilence et de bénédiction à la fois | 500 |
-| Pain d'ascedie | Ne périme pas, fait un repas complet - mais la sensation de faim reste et il est dégoutant. | 85 |
+Une confection de consommables prend un tour, et peut se faire à tout moment si les ingrédient sont présent (ils sont consommés). Si un joueur peut faire plusieurs doses d'un même consommable, alors il lui faudra consommer plus d'ingrédients proportionnellement au nombre de dose voulue (et dans la limite laissée par le JDR), cependant cela ne prendra pas plus d'action.
 
-## Objets magiques
-
-| Objet | Effet | Prix |
-|:----------:|:------|:----:|
-| Pierre d'intégrité | Restaure entièrement tout effet métaphysique | 1000 |
-| Graine élémentaire | Produit l'effet de l'élément | 50 |
-| Voile élémentaire | Produit une résistance à l'élément sur toute l'équipe | 550 |
-| Prisme d'élément | Quand brisé, produit un terrain élémentaire | 350 |
-| Bille de statistiques | Ajoute +5% à la statistique trois tours. Cumulatif | 250 |
-| Essence d'espèce | Change l'espèce d'un personnage trois tours | Introuvable sur le marché |
-| Bombes élémentaires | Provoque une explosion de 12 dégâts (sur trois ennemis proches) avec effet élémentaire | 250 |
-| Cristal de téléportation | Ramène au début d'un donjon où d'un endroit | 400 |
-| Carnet de la mort | Réussite automatique au prochain jet de survie, le suivant cependant échouera | 1500 |
-| Dés pipés | Annule un échec critique, mais la réussite critique suivante sera un échec critique | 1500 |
-| Herbes démoniaques | Transforme une potion à effet positif en potion satanique : augmente ses effets, mais provoque un jet de panique | 200 |
-
-</div>
+## Liste des objets
\ No newline at end of file
diff --git a/public/rules/inventaire/potions.md b/public/rules/inventaire/potions.md
deleted file mode 100644
index 169bbd9..0000000
--- a/public/rules/inventaire/potions.md
+++ /dev/null
@@ -1,95 +0,0 @@
-# Potions et crafting
-
-Il est possible dans les jdr d'avoir des personnages dont les gimmick sont de construire des objets ou des outils. Parmi les exemples à cela il peut y avoir cuisinier (pour créer des vivres), la création d'arme (ou il faudra cependant placer quelques limites, puisque cela créer des objets permanents) et la création de potion.
-
-Créer des objets nécessites des classes dédiées à cela, et utilise les mécanismes suivants
-
-## Confectionner un objet
-
-La confection d'objet dépend du type d'objet souhaité. Elle utilisera toujours un double jet : INT pour déterminer la capacité à voir ce qu'il faut faire, et HAB pour réussir à faire ce que l'on veut.
-
-### Objet consommable
-
-Une confection de consommables prend un tour, et peut se faire à tout moment si les ingrédient sont présent (ils sont consommés). Si un joueur peut faire plusieurs doses d'un même consommable, alors il lui faudra consommer plus d'ingrédients proportionnellement au nombre de dose voulue (et dans la limite laissée par le JDR), cependant cela ne prendra pas plus d'action.
-
-### Objet permanent
-
-Une confection d'objet permanent (équipement, par exemple) prend plus de temps, pouvant durer sur une partie de partie, voir sur un inter-partie, et ne peut se faire au combat. Il est possible cependant de laisser une élispe se faire dans le JDR pour permettre à la créer autour d'une partie. Cependant, elle ne peut se faire en un tour comme un objet consommable. Elle va demander aussi des matériaux, soit qui seront fourni in-RP, soit via un système de matériaux propre au JDR.
-
-Cette confection peut aussi faire faire un jet par "spécificité" que l'objet final doit avoir ( par exemple une épée améliorée pourra avoir besoin d'un jet pour créer une épée, un jet pour créer l'aspect "amélioré" ).
-
-## Potions
-
-### Ingrédients
-
-Il peut y avoir 4 types d'ingrédients pour les potions
-
-- Ingrédients Communs (5)
-- Ingrédients Semi-rare
-- Ingrédients Rare ()
-- Ingrédients Exceptionnel (80)
-
-Il est à noter qu'il est possible ou non d'utiliser les ingrédients pour d'autres éléments (comme de la cuisine). Ces ingré Les JDR peuvent aussi avoir des ingrédients annexes ayant un effet sur la création des potions.
-
-### Liste des potions
-
-#### Faciles
-
-Coût : 10
-
-Les potions faciles contiennent des ingrédients *communs*.
-
-| Potion | Effet |
-|:------:|:-----:|
-| Potion de soin | Permet de regagner 12PV |
-| Potion de moral | Permet de regagner 12PM |
-| Antidote | Soigne une affliction physique |
-| Extrait de douleur | Inflige 3 dégâts esprit et 3 dégâts de corps |
-| Potion de vigueur | Augmente de 10 % les statistiques physique pendant trois tour |
-| Potion explosive légère | Provoque une explosion d'une puissance de 8 dégâts, pas d'esquive. (dégat doublé & brut si bue) |
-| Potion d'aveuglement | Produit un malus de 15 % en PER à tout personnage touché par la potion. |
-| Potion de flamme | Donne des dégâts de feu aux attaques |
-| Potion de satiété | Protège de la fin pendant trois parties |
-
-#### Avancées
-
-Coût : 20
-
-Les potions faciles contiennent des ingrédients *semi-rares*.
-
-| Potion | Effet |
-|:------:|:-----:|
-| Potion de soin avancée | Permet de regagner 24PV |
-| Potion de moral avancée | Permet de regagner 24PM |
-| Essence de célérité | Toujours premier pour prochain combat |
-| Potion de pestilence | Fait faire un jet de pestilence à l’ennemi quand il la boit |
-| Concentré de Dopage | Permet de faire rejouer |
-| Potion de rage | Booste l’attaque de 20 % mais lui donne 1 chance sur 4 d’attaquer un allié (la chance sur 4 est cumulable) |
-| Potion explosive avancée | Provoque une explosion d'une puissance de 14 dégâts, pas d'esquive. (dégat doublé & brut si bue) |
-
-#### Difficiles
-
-Coût : 40
-
-Les potions faciles contiennent des ingrédients *rares*.
-
-| Potion | Effet |
-|:------:|:-----:|
-| Potion de soin royale | Permet de regagner 54PV |
-| Potion de moral royale | Permet de regagner 54PV |
-| Potion "debout les morts" | Soigne de tout les PV un perso non-mort, mais rend fortement confus 5 tours. |
-| Potion d’intangibilité | Donne une immunité aux dégâts physiques. |
-| Filtre d’amour | Peut séduire en combat un allié et lui donner +50 % à tout ses jets. Il obéira à tout ses ordres, et ne prendra d’action sans son autorisation. |
-| Potion d'éclat | Permet de regagner 2 point d'éclat |
-
-#### Légendaires
-
-Coût : 100
-
-Les potions légendaires contiennent des ingrédients *exceptionnels*
-
-| Potion | Effet |
-|:------:|:-----:|
-| Potion de Résurrection | Ramène un perso mort à la vie, si la mort date de moins d'une partie |
-| Potion de Bonheur | Immunise temporairement aux effets de la perte de moral |
-| Potion secrète | La personne l’ayant bu peut annuler un critique au choix |
diff --git a/src/data/fields.ts b/src/data/fields.ts
new file mode 100644
index 0000000..f654b09
--- /dev/null
+++ b/src/data/fields.ts
@@ -0,0 +1,9 @@
+const objectFields = [
+  { key: "nom", label: "Nom" },
+  { key: "type", label: "Type", canBeFiltered: true },
+  { key: "rarete", label: "Rareté", canBeFiltered: true },
+  { key: "effet", label: "Effet" },
+  { key: "cout", label: "Cout" },
+];
+
+export { objectFields };
diff --git a/src/router/index.ts b/src/router/index.ts
index 0293477..f2ccd2c 100644
--- a/src/router/index.ts
+++ b/src/router/index.ts
@@ -3,6 +3,7 @@ import HomeView from "../views/HomeView.vue";
 import RuleView from "../views/RuleView.vue";
 import JdrView from "../views/JdrView.vue";
 import FichesView from "../views/FichesView.vue";
+import ObjetsView from "../views/ObjetsView.vue";
 
 const router = createRouter({
   history: createWebHashHistory(import.meta.env.BASE_URL),
@@ -32,6 +33,10 @@ const router = createRouter({
       // which is lazy-loaded when the route is visited.
       component: () => import("../views/AboutView.vue"),
     },
+    {
+      path: "/jdr/:jdr/inventaire/objets/",
+      component: ObjetsView,
+    },
   ],
   scrollBehavior(to, from, savedPosition) {
     if (to.hash) {

From c53b73cb160c104096af3b955e9d68d18e7a0e40 Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Wed, 8 Feb 2023 20:45:19 +0100
Subject: [PATCH 03/27] fix: config typescript

---
 tsconfig.json | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/tsconfig.json b/tsconfig.json
index 8d23599..a973799 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -5,12 +5,13 @@
     "baseUrl": ".",
     "paths": {
       "@/*": ["./src/*"]
-    }
+    },
+    "lib": ["es2018", "dom", "esnext"],
   },
 
   "references": [
     {
       "path": "./tsconfig.config.json"
     }
-  ]
+  ],
 }

From 60e29fbdc06a5437ce8f54851c9e17a6f910d3d2 Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Wed, 8 Feb 2023 20:45:45 +0100
Subject: [PATCH 04/27] fix: meilleurs vue article

---
 src/styles/custom/_article.scss | 8 ++------
 src/styles/custom/_global.scss  | 6 +++---
 2 files changed, 5 insertions(+), 9 deletions(-)

diff --git a/src/styles/custom/_article.scss b/src/styles/custom/_article.scss
index 95955cf..75ca8db 100644
--- a/src/styles/custom/_article.scss
+++ b/src/styles/custom/_article.scss
@@ -1,12 +1,8 @@
-.markdown:not(:last-child) {
-    padding-bottom: 1.5rem;
-}
-
-article {
+article:last-child {
     padding-bottom:1.5rem;
 }
 
-article .table-auto table {
+article .table-auto table, table.table-auto {
     display: table;
     width: 100%;
     table-layout: auto;
diff --git a/src/styles/custom/_global.scss b/src/styles/custom/_global.scss
index 7e7fa93..504cdfc 100644
--- a/src/styles/custom/_global.scss
+++ b/src/styles/custom/_global.scss
@@ -14,7 +14,7 @@
 #sidebar {
   padding-top:1rem;
   padding-left:0.75rem;
-  width:18rem;
+  width:17rem;
   position: fixed;
   height: calc(100vh - 3rem);
   overflow: scroll;
@@ -38,7 +38,7 @@
   position: fixed;
   top: 4rem;
   right: 1rem;
-  width: 17rem;
+  width: 16rem;
   .menu {
     padding-left:0.5rem;
     padding-right:0.5rem;
@@ -46,6 +46,6 @@
 }
 
 #content {
-  max-width:800px;
+  max-width:1000px;
   margin:auto;
 }
\ No newline at end of file

From f8b9a3d272cf9fc2b6dc6b614fb71efcb29def11 Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Wed, 8 Feb 2023 20:45:55 +0100
Subject: [PATCH 05/27] fix: ajout ObjetsView oublie

---
 src/views/ObjetsView.vue | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 src/views/ObjetsView.vue

diff --git a/src/views/ObjetsView.vue b/src/views/ObjetsView.vue
new file mode 100644
index 0000000..50ee43c
--- /dev/null
+++ b/src/views/ObjetsView.vue
@@ -0,0 +1,24 @@
+<script setup lang="ts">
+import DynTable from "@/components/tableaux/DynTable.vue";
+import { useConfigStore } from "@/stores/config";
+import { onMounted } from "vue";
+import { useRoute } from "vue-router";
+import MarkdownFile from "../components/MarkdownFile.vue";
+import { objectFields } from "@/data/fields";
+
+const store = useConfigStore();
+const route = useRoute();
+const objectTest = ["base", "potions"];
+
+onMounted(() => {
+  store.loadJdr(`${route.params.jdr}`);
+});
+</script>
+
+<template>
+  <main>
+    <MarkdownFile :path="`rules/inventaire/objets`">
+      <DynTable :fields="objectFields" :files="objectTest" />
+    </MarkdownFile>
+  </main>
+</template>

From 787146ec6d8cb198b8cfb5e5d8a07cede4dafd30 Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Wed, 8 Feb 2023 20:46:04 +0100
Subject: [PATCH 06/27] feat: ajout cartomancia et sonata

---
 public/jdr/cartomancia.json |  9 +++++++++
 public/jdr/sonata.json      | 19 +++++++++++++++++++
 2 files changed, 28 insertions(+)
 create mode 100644 public/jdr/cartomancia.json
 create mode 100644 public/jdr/sonata.json

diff --git a/public/jdr/cartomancia.json b/public/jdr/cartomancia.json
new file mode 100644
index 0000000..81ff2ce
--- /dev/null
+++ b/public/jdr/cartomancia.json
@@ -0,0 +1,9 @@
+{
+  "name":"Cartomancia",
+  "vars":[
+    {"name":"determination01","value":"TODO"},
+    {"name":"determination19","value":"TODO"},
+    {"name":"determination20","value":"TODO"}
+  ],
+  "objets":["base", "elements", "magique", "potion"]
+}
\ No newline at end of file
diff --git a/public/jdr/sonata.json b/public/jdr/sonata.json
new file mode 100644
index 0000000..35cf3d4
--- /dev/null
+++ b/public/jdr/sonata.json
@@ -0,0 +1,19 @@
+{
+  "name": "Meteor Sonata",
+  "sidebar": [
+    {
+      "id": 50,
+      "title": "Magie et surnaturel",
+      "links": [
+        {"title": "Métaphysique", "path": "rules/magie/eclat"},
+        {"title": "Anomie", "path": "rules/magie/anomie"}
+      ]
+    }
+  ],
+  "vars":[
+    {"name":"determination01","value":"TODO"},
+    {"name":"determination19","value":"Le personnage fait un jet d'anomie"},
+    {"name":"determination20","value":"Le personnage devient anomique"}
+  ],
+  "objects":["base"]
+}
\ No newline at end of file

From 07e8986ed6bdafcb3c07fd4b96c516e12f88fba2 Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Sat, 11 Feb 2023 19:46:58 +0100
Subject: [PATCH 07/27] chore: split DynTable into classes

---
 src/components/tableaux/DynTable.vue       | 136 ++++-----------------
 src/utils/tables/FilteredHtmlTable.ts      |  89 ++++++++++++++
 src/utils/tables/PaginatedFilteredTable.ts |  58 +++++++++
 src/utils/tables/SimpleHtmlTable.ts        |  18 +++
 src/utils/tables/tableUtils.ts             |  17 +++
 src/utils/tables/types.ts                  |  24 ++++
 6 files changed, 231 insertions(+), 111 deletions(-)
 create mode 100644 src/utils/tables/FilteredHtmlTable.ts
 create mode 100644 src/utils/tables/PaginatedFilteredTable.ts
 create mode 100644 src/utils/tables/SimpleHtmlTable.ts
 create mode 100644 src/utils/tables/tableUtils.ts
 create mode 100644 src/utils/tables/types.ts

diff --git a/src/components/tableaux/DynTable.vue b/src/components/tableaux/DynTable.vue
index 0791328..dbb5efe 100644
--- a/src/components/tableaux/DynTable.vue
+++ b/src/components/tableaux/DynTable.vue
@@ -1,26 +1,10 @@
 <script lang="ts" setup>
-import { computed, ref, onMounted } from "vue";
+import { computed, reactive, onMounted } from "vue";
+import PaginatedFilteredTable from "@/utils/tables/PaginatedFilteredTable";
+import type { TableField } from "@/utils/tables/types";
 import type { PropType } from "vue";
 import axios from "axios";
 
-interface TableField {
-  key: string;
-  label: string;
-  canBeFiltered?: boolean;
-}
-
-interface Filters {
-  [key: string]: boolean;
-}
-
-interface FilterList {
-  [key: string]: { title: string; filters: Filters };
-}
-
-interface TableItem {
-  [key: string]: unknown;
-}
-
 const props = defineProps({
   fields: {
     type: Array as PropType<TableField[]>,
@@ -32,130 +16,60 @@ const props = defineProps({
   },
 });
 
-const items = ref([] as TableItem[]);
-const filters = ref({} as FilterList);
-const pageNumber = ref(0);
-const elemByPage = ref(10);
+const DEFAULT_MAX_ITEM_BY_PAGE = 10;
 
-const displayedFieldKeys = computed(() => {
-  return Object.entries(props.fields).map(([key, value]) => value.key);
+const table = reactive(new PaginatedFilteredTable(DEFAULT_MAX_ITEM_BY_PAGE));
+
+const filtersFieldMap = computed(() => {
+  return table?.filteredTable?.filtersFieldMap;
 });
 
-function haveFilter(filterName: string) {
-  for (const val in filters.value[filterName].filters) {
-    if (
-      Object.prototype.hasOwnProperty.call(
-        filters.value[filterName].filters,
-        val
-      )
-    ) {
-      if (filters.value[filterName].filters[val]) {
-        console.log(filterName, true);
-        return true;
-      }
-    }
-  }
-  console.log(filterName, false);
-  return false;
-}
-
-const filteredItems = computed(() => {
-  var filteredItem = items.value as TableItem[];
-
-  for (const filter in filters.value) {
-    if (haveFilter(filter)) {
-      filteredItem = filteredItem.filter((value) => {
-        return filters.value[filter].filters[value[filter] as string];
-      });
-    }
-  }
-
-  return filteredItem;
+const displayedFieldKeys = computed(() => {
+  return table?.filteredTable?.table.displayedFieldKeys;
 });
 
 const paginatedList = computed(() => {
-  var filteredItem = filteredItems.value as TableItem[];
-
-  filteredItem = filteredItem.filter((value, index) => {
-    const pageBegin = pageNumber.value * elemByPage.value;
-    return index >= pageBegin && index < pageBegin + elemByPage.value;
-  });
-
-  return filteredItem;
+  return table?.items;
 });
 
 onMounted(() => {
-  for (const field of props.fields) {
-    if (field.canBeFiltered) {
-      filters.value[field.key] = {
-        title: field.label,
-        filters: {} as Filters,
-      };
-    }
-  }
-
+  table.fields = props.fields;
   for (const file of props.files) {
     const listItems = `/jdr/objets/${file}.json`;
     axios.get(listItems).then((response) => {
-      items.value = items.value.concat(response.data);
-      response.data.forEach((element: TableItem) => {
-        for (const key in element) {
-          if (Object.prototype.hasOwnProperty.call(element, key)) {
-            if (filters.value[key]) {
-              filters.value[key].filters[element[key] as string] = false;
-            }
-          }
-        }
-      });
+      table.addItems(response.data);
+      table.currentPage = 0;
     });
   }
 });
 
 function switchFilter(filterSet: string | number, filterName: string | number) {
-  if (filters.value[filterSet]?.filters[filterName] !== undefined) {
-    filters.value[filterSet].filters[filterName] =
-      !filters.value[filterSet].filters[filterName];
-  }
-  setPage(0);
+  table.switchFilter(filterSet as string, filterName as string);
 }
 
 function removeFilter(filterSet: string | number) {
-  for (const val in filters.value[filterSet].filters) {
-    if (
-      Object.prototype.hasOwnProperty.call(
-        filters.value[filterSet].filters,
-        val
-      )
-    ) {
-      filters.value[filterSet].filters[val] = false;
-    }
-  }
-  setPage(0);
+  table.removeAllFilters(filterSet as string);
 }
 
-const getTotalPage = computed(() => {
-  return Math.floor((filteredItems.value.length - 1) / elemByPage.value);
+const currentPage = computed(() => {
+  return table?.currentPage;
 });
 
-function setPage(page: number) {
-  pageNumber.value = page;
-}
+const getTotalPage = computed(() => {
+  return table?.pageNumber;
+});
 
 function canGo(rel: number) {
-  return (
-    pageNumber.value + rel >= 0 && pageNumber.value + rel <= getTotalPage.value
-  );
+  return table?.canGo(rel);
 }
 
 function go(rel: number) {
-  if (canGo(rel)) {
-    setPage(pageNumber.value + rel);
-  }
+  table?.go(rel);
 }
 </script>
 
 <template>
-  <div class="small-text" v-for="(filter, key) in filters" :key="key">
+  <div class="small-text" v-for="(filter, key) in filtersFieldMap" :key="key">
     <strong>{{ filter.title }} : </strong>
     <button
       v-for="(isTrue, filterName) in filter.filters"
@@ -189,7 +103,7 @@ function go(rel: number) {
   <div class="d-flex f-between f-middle nextprevious small-text">
     <div>
       <strong class="btn m-0 pages pl-0">
-        Page {{ pageNumber + 1 }} / {{ getTotalPage + 1 }}
+        Page {{ currentPage + 1 }} / {{ getTotalPage + 1 }}
       </strong>
     </div>
 
diff --git a/src/utils/tables/FilteredHtmlTable.ts b/src/utils/tables/FilteredHtmlTable.ts
new file mode 100644
index 0000000..c427919
--- /dev/null
+++ b/src/utils/tables/FilteredHtmlTable.ts
@@ -0,0 +1,89 @@
+import SimpleHtmlTable from "./SimpleHtmlTable";
+import { forEachCols, getColumn } from "./tableUtils";
+import type { FilterFieldsMap, Filters, TableField, TableItem } from "./types";
+
+export default class FilteredHtmlTable {
+  table: SimpleHtmlTable;
+  filtersFieldMap: FilterFieldsMap = {};
+
+  constructor() {
+    this.table = new SimpleHtmlTable();
+  }
+
+  private initFilters() {
+    this.filtersFieldMap = {};
+    for (const field of this.table.fields) {
+      if (field.canBeFiltered) {
+        // Create a filter for the field, that'll contain every
+        // filters possible for the field
+        this.filtersFieldMap[field.key] = {
+          title: field.label,
+          filters: {} as Filters,
+        };
+      }
+    }
+  }
+
+  set fields(fields: TableField[]) {
+    this.table.fields = fields;
+    this.initFilters();
+  }
+
+  addItems(rows: TableItem[]) {
+    this.table.addItems(rows);
+    forEachCols(rows, (colName: string, col: string) => {
+      this.setFilterableValue(colName, col);
+    });
+  }
+
+  get items() {
+    let filteredItem = this.table.items as TableItem[];
+
+    for (const fieldKey in this.filtersFieldMap) {
+      if (this.haveFilter(fieldKey)) {
+        filteredItem = filteredItem.filter((row) => {
+          const filters = this.getFiltersForField(fieldKey);
+          return !filters || filters[getColumn(row, fieldKey) as string];
+        });
+      }
+    }
+
+    return filteredItem;
+  }
+
+  private setFilterableValue(fieldKey: string, filterableValue: string) {
+    const filters = this.getFiltersForField(fieldKey);
+    if (filters) {
+      filters[filterableValue] = false;
+    }
+  }
+
+  private getFiltersForField(fieldKey: string) {
+    if (this.filtersFieldMap[fieldKey]) {
+      return this.filtersFieldMap[fieldKey].filters;
+    }
+  }
+
+  private haveFilter(fieldKey: string) {
+    for (const val in this.getFiltersForField(fieldKey)) {
+      if (this.filtersFieldMap[fieldKey].filters[val]) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  public switchFilter(fieldKey: string, filterValue: string) {
+    const filters = this.getFiltersForField(fieldKey);
+    if (filters && filters[filterValue] !== undefined) {
+      filters[filterValue] = !filters[filterValue];
+    }
+  }
+
+  public removeAllFilters(fieldKey: string) {
+    const filters = this.getFiltersForField(fieldKey);
+    for (const filterValue in filters) {
+      filters[filterValue] = false;
+    }
+  }
+}
diff --git a/src/utils/tables/PaginatedFilteredTable.ts b/src/utils/tables/PaginatedFilteredTable.ts
new file mode 100644
index 0000000..d83a0cf
--- /dev/null
+++ b/src/utils/tables/PaginatedFilteredTable.ts
@@ -0,0 +1,58 @@
+import FilteredHtmlTable from "./FilteredHtmlTable";
+import type { TableField, TableItem } from "./types";
+
+export default class PaginatedFilteredTable {
+  filteredTable: FilteredHtmlTable;
+  pageLenght: number;
+  currentPage = 0;
+
+  constructor(pageLenght: number) {
+    this.filteredTable = new FilteredHtmlTable();
+    this.pageLenght = pageLenght;
+  }
+
+  get pageNumber() {
+    return Math.floor((this.filteredTable.items.length - 1) / this.pageLenght);
+  }
+
+  get items() {
+    let items = this.filteredTable.items as TableItem[];
+
+    items = items.filter((value, index) => {
+      const pageBegin = this.currentPage * this.pageLenght;
+      return index >= pageBegin && index < pageBegin + this.pageLenght;
+    });
+
+    return items;
+  }
+
+  set fields(fields: TableField[]) {
+    this.filteredTable.fields = fields;
+  }
+
+  public addItems(items: TableItem[]) {
+    this.filteredTable.addItems(items);
+  }
+
+  public canGo(rel: number) {
+    return (
+      this.currentPage + rel >= 0 && this.currentPage + rel <= this.pageNumber
+    );
+  }
+
+  public go(rel: number) {
+    if (this.canGo(rel)) {
+      this.currentPage = this.currentPage + rel;
+    }
+  }
+
+  public switchFilter(fieldKey: string, filterValue: string) {
+    this.filteredTable.switchFilter(fieldKey, filterValue);
+    this.currentPage = 0;
+  }
+
+  public removeAllFilters(fieldKey: string) {
+    this.filteredTable.removeAllFilters(fieldKey);
+    this.currentPage = 0;
+  }
+}
diff --git a/src/utils/tables/SimpleHtmlTable.ts b/src/utils/tables/SimpleHtmlTable.ts
new file mode 100644
index 0000000..13d6f3a
--- /dev/null
+++ b/src/utils/tables/SimpleHtmlTable.ts
@@ -0,0 +1,18 @@
+import type { TableField, TableItem } from "./types";
+
+export default class SimpleHtmlTable {
+  fields = [] as TableField[];
+  items = [] as TableItem[];
+
+  setFields(fields: TableField[]) {
+    this.fields = fields;
+  }
+
+  addItems(items: TableItem[]) {
+    this.items = this.items.concat(items);
+  }
+
+  get displayedFieldKeys() {
+    return Object.entries(this.fields).map(([, value]) => value.key);
+  }
+}
diff --git a/src/utils/tables/tableUtils.ts b/src/utils/tables/tableUtils.ts
new file mode 100644
index 0000000..20d2d96
--- /dev/null
+++ b/src/utils/tables/tableUtils.ts
@@ -0,0 +1,17 @@
+import type { TableItem } from "./types";
+
+export function getColumn(row: TableItem, colName: string) {
+  return row[colName];
+}
+
+export function forEachCols(rows: TableItem[], func: Function) {
+  rows.forEach((row: TableItem) => {
+    for (const colName in row) {
+      if (Object.prototype.hasOwnProperty.call(row, colName)) {
+        if (getColumn(row, colName)) {
+          func(colName, getColumn(row, colName));
+        }
+      }
+    }
+  });
+}
diff --git a/src/utils/tables/types.ts b/src/utils/tables/types.ts
new file mode 100644
index 0000000..3781956
--- /dev/null
+++ b/src/utils/tables/types.ts
@@ -0,0 +1,24 @@
+interface Table {
+  fields: TableField[];
+  items: TableItem[];
+}
+
+interface TableField {
+  key: string;
+  label: string;
+  canBeFiltered?: boolean;
+}
+
+interface Filters {
+  [key: string]: boolean;
+}
+
+interface FilterFieldsMap {
+  [key: string]: { title: string; filters: Filters };
+}
+
+interface TableItem {
+  [key: string]: unknown;
+}
+
+export type { Table, TableField, Filters, FilterFieldsMap, TableItem };

From de0845da114bcb020c86682d87d8c76eaf21613c Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Sun, 12 Feb 2023 11:25:05 +0100
Subject: [PATCH 08/27] feat: use categories of current jdr

---
 src/components/tableaux/DynTable.vue | 14 ++++++++++++--
 src/types/JdrConfig.ts               |  1 +
 src/views/ObjetsView.vue             |  9 ++++++---
 3 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/src/components/tableaux/DynTable.vue b/src/components/tableaux/DynTable.vue
index dbb5efe..d7a45b1 100644
--- a/src/components/tableaux/DynTable.vue
+++ b/src/components/tableaux/DynTable.vue
@@ -14,6 +14,10 @@ const props = defineProps({
     type: Array as PropType<string[]>,
     default: () => [],
   },
+  category: {
+    type: String,
+    default: "",
+  },
 });
 
 const DEFAULT_MAX_ITEM_BY_PAGE = 10;
@@ -33,15 +37,21 @@ const paginatedList = computed(() => {
 });
 
 onMounted(() => {
+  setTimeout(() => {
+    refresh();
+  }, 100);
+});
+
+function refresh() {
   table.fields = props.fields;
   for (const file of props.files) {
-    const listItems = `/jdr/objets/${file}.json`;
+    const listItems = `/jdr/${props.category}/${file}.json`;
     axios.get(listItems).then((response) => {
       table.addItems(response.data);
       table.currentPage = 0;
     });
   }
-});
+}
 
 function switchFilter(filterSet: string | number, filterName: string | number) {
   table.switchFilter(filterSet as string, filterName as string);
diff --git a/src/types/JdrConfig.ts b/src/types/JdrConfig.ts
index 8d67365..55722b3 100644
--- a/src/types/JdrConfig.ts
+++ b/src/types/JdrConfig.ts
@@ -6,4 +6,5 @@ export default interface JdrConfig {
   sidebar: LinkList[];
   hideLinks: HideLink[];
   vars: { name: string; value: string }[];
+  objects: string[];
 }
diff --git a/src/views/ObjetsView.vue b/src/views/ObjetsView.vue
index 50ee43c..870fc50 100644
--- a/src/views/ObjetsView.vue
+++ b/src/views/ObjetsView.vue
@@ -1,24 +1,27 @@
 <script setup lang="ts">
 import DynTable from "@/components/tableaux/DynTable.vue";
 import { useConfigStore } from "@/stores/config";
-import { onMounted } from "vue";
+import { onMounted, computed } from "vue";
 import { useRoute } from "vue-router";
 import MarkdownFile from "../components/MarkdownFile.vue";
 import { objectFields } from "@/data/fields";
 
 const store = useConfigStore();
 const route = useRoute();
-const objectTest = ["base", "potions"];
 
 onMounted(() => {
   store.loadJdr(`${route.params.jdr}`);
 });
+
+const objects = computed(() => {
+  return store.jdrConfig?.objects ?? [];
+});
 </script>
 
 <template>
   <main>
     <MarkdownFile :path="`rules/inventaire/objets`">
-      <DynTable :fields="objectFields" :files="objectTest" />
+      <DynTable :fields="objectFields" :files="objects" category="objets" />
     </MarkdownFile>
   </main>
 </template>

From 39f5e65e483f75410aa83f0f83cb86ba032b7e8b Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Sun, 12 Feb 2023 20:41:23 +0100
Subject: [PATCH 09/27] feat: outils en tant que liste

---
 public/jdr/cartomancia.json             |  4 ++-
 public/jdr/core.json                    |  4 ++-
 public/jdr/effets-mains/base.json       |  9 ++++++
 public/jdr/effets-mains/magique.json    |  8 +++++
 public/jdr/effets-mains/tech.json       |  6 ++++
 public/jdr/erratum.json                 |  3 +-
 public/jdr/mains/arcs.json              |  6 ++++
 public/jdr/mains/baguette.json          |  9 ++++++
 public/jdr/mains/base.json              | 17 ++++++++++
 public/jdr/mains/medieval-cac.json      | 11 +++++++
 public/jdr/mains/medieval-feu.json      |  3 ++
 public/jdr/mains/moderne.json           |  8 +++++
 public/jdr/mains/outil-moderne.json     |  3 ++
 public/jdr/sonata.json                  |  4 ++-
 public/pelican.json                     |  2 +-
 public/rules/inventaire/mains-effets.md |  3 ++
 public/rules/inventaire/mains.md        | 19 +++++++++++
 src/data/fields.ts                      | 17 +++++++++-
 src/router/index.ts                     |  5 +++
 src/types/JdrConfig.ts                  |  2 ++
 src/views/EquipView.vue                 | 42 +++++++++++++++++++++++++
 21 files changed, 179 insertions(+), 6 deletions(-)
 create mode 100644 public/jdr/effets-mains/base.json
 create mode 100644 public/jdr/effets-mains/magique.json
 create mode 100644 public/jdr/effets-mains/tech.json
 create mode 100644 public/jdr/mains/arcs.json
 create mode 100644 public/jdr/mains/baguette.json
 create mode 100644 public/jdr/mains/base.json
 create mode 100644 public/jdr/mains/medieval-cac.json
 create mode 100644 public/jdr/mains/medieval-feu.json
 create mode 100644 public/jdr/mains/moderne.json
 create mode 100644 public/jdr/mains/outil-moderne.json
 create mode 100644 public/rules/inventaire/mains-effets.md
 create mode 100644 public/rules/inventaire/mains.md
 create mode 100644 src/views/EquipView.vue

diff --git a/public/jdr/cartomancia.json b/public/jdr/cartomancia.json
index 81ff2ce..b28399e 100644
--- a/public/jdr/cartomancia.json
+++ b/public/jdr/cartomancia.json
@@ -5,5 +5,7 @@
     {"name":"determination19","value":"TODO"},
     {"name":"determination20","value":"TODO"}
   ],
-  "objets":["base", "elements", "magique", "potion"]
+  "objets":["base", "elements", "magique", "potion"],
+  "equipMains":["base", "arcs", "medieval-cac", "medieval-feu", "baguette"],
+  "effetsMains":["base", "magique"]
 }
\ No newline at end of file
diff --git a/public/jdr/core.json b/public/jdr/core.json
index d46cd64..f3a3a83 100644
--- a/public/jdr/core.json
+++ b/public/jdr/core.json
@@ -5,5 +5,7 @@
     {"name":"determination19","value":"Effet dépendant du JDR"},
     {"name":"determination20","value":"Effet dépendant du JDR"}
   ],
-  "objects":["base"]
+  "objects":["base"],
+  "equipMains":["base", "arcs"],
+  "effetsMains":["base"]
 }
\ No newline at end of file
diff --git a/public/jdr/effets-mains/base.json b/public/jdr/effets-mains/base.json
new file mode 100644
index 0000000..9829b62
--- /dev/null
+++ b/public/jdr/effets-mains/base.json
@@ -0,0 +1,9 @@
+[
+  {"nom":"Améliorée","effet":"x1.5 force","surcout":"+50%"},
+  {"nom":"Supérieur","effet":"x2 force","surcout":"+100%"},
+  {"nom":"Ultime","effet":"x3 force","surcout":"+200%"},
+  {"nom":"Non-léthal","effet":"Tout coup avec ne fera pas tomber en dessous de 0 PV","surcout":"+10%"},
+  {"nom":"Léthal","effet":"Double les chances de critique","surcout":"+50%"},
+  {"nom":"de verre","effet":"Double la force, mais ne peut être utilisé que deux fois","surcout":"+10%"},
+  {"nom":"À accroche","effet":"À besoin d'une main de moins","surcout":"+10%"}
+]
\ No newline at end of file
diff --git a/public/jdr/effets-mains/magique.json b/public/jdr/effets-mains/magique.json
new file mode 100644
index 0000000..007d61c
--- /dev/null
+++ b/public/jdr/effets-mains/magique.json
@@ -0,0 +1,8 @@
+[
+  {"nom":"Élémentaire","effet":"Produit l'effet de l'élément lié","surcout":"+25%"},
+  {"nom":"des Âmes","effet":"Chaque mort fait avec lui confère un dégât d'1PM qui sera aussi appliqué au héros","surcout":"+25%"},
+  {"nom":"Funeste","effet":"Provoque un jet de panique si réussite critique","surcout":"+100%"},
+  {"nom":"De sang","effet":"Provoque un jet d'affliction physique si réussite critique","surcout":"+100%"},
+  {"nom":"Des Héros","effet":"+50% force sur les créatures démoniaques","surcout":"+100%"},
+  {"nom":"Des Ombres","effet":"Fait 3 dégâts bruts (même si a échoué)","surcout":"+100%"}
+]
\ No newline at end of file
diff --git a/public/jdr/effets-mains/tech.json b/public/jdr/effets-mains/tech.json
new file mode 100644
index 0000000..6e13d05
--- /dev/null
+++ b/public/jdr/effets-mains/tech.json
@@ -0,0 +1,6 @@
+[
+  {"nom":"Biotechnologie","effet":"Ajoute un effet de vampirisme physique (regen force/2 en PV)","surcout":"+50%"},
+  {"nom":"Nanotechnologie","effet":"Tout effet de brise armure ou brise-arme s'estomp à la fin de la partie","surcout":"+100%"},
+  {"nom":"Crystalline","effet":"Brise armure/arme: tous les 6 points de dégâts effectué ou reçu, ajoute un malus en armure/arme à l'opposant","surcout":"+25%"},
+  {"nom":"Laser","effet":"Semi perce-armure (si déjà semi perce-armure, full perce-armure)","surcout":"+100%"}
+]
\ No newline at end of file
diff --git a/public/jdr/erratum.json b/public/jdr/erratum.json
index 523fb4f..53f5b30 100644
--- a/public/jdr/erratum.json
+++ b/public/jdr/erratum.json
@@ -25,5 +25,6 @@
     {"name":"determination19","value":"Le personnage fait un jet d'anomie"},
     {"name":"determination20","value":"Le personnage devient anomique"}
   ],
-  "objects":["base"]
+  "objects":["base"],
+  "equipMains":["base", "arcs", "medieval-cac", "medieval-feu", "moderne"]
 }
\ No newline at end of file
diff --git a/public/jdr/mains/arcs.json b/public/jdr/mains/arcs.json
new file mode 100644
index 0000000..3f86ad1
--- /dev/null
+++ b/public/jdr/mains/arcs.json
@@ -0,0 +1,6 @@
+[
+  {"nom":"Arc court","type":"Arme distance","mains":2,"force":4,"effet":"Perce-armure sur les hélicoptères","competence":" Arc","cout":350},
+  {"nom":"Arc long","type":"Arme distance","mains":2,"force":6,"effet":"PER -20; Perce-armure sur les hélicoptères","competence":" Arc","cout":400},
+  {"nom":"Arbalète à une main","type":"Arme distance","mains":1,"force":6,"effet":"PER -20; Semi perce-armure ; Peut s'enrayer","competence":" Arc","cout":500},
+  {"nom":"Arbalète","type":"Arme distance","mains":2,"force":8,"effet":"PER -20; Semi perce-armure ; Peut s'enrayer","competence":" Arc","cout":600}
+]
\ No newline at end of file
diff --git a/public/jdr/mains/baguette.json b/public/jdr/mains/baguette.json
new file mode 100644
index 0000000..f99ffaa
--- /dev/null
+++ b/public/jdr/mains/baguette.json
@@ -0,0 +1,9 @@
+[
+  {"nom":"Baguette de soin","type":"Baguette","mains":1,"force":4,"effet":"Utilise VOL ou INT; Les dégats sont fait en tant que soin","competence":"Baguette","cout":350},
+  {"nom":"Baguette de guérison","type":"Baguette","mains":1,"force":2,"effet":"Utilise VOL ou INT; Les dégats sont fait en tant que soin; Soigne + 50 % de chance de soigner une altération","competence":"Baguette","cout":550},
+  {"nom":"Baguette de combat","type":"Baguette","mains":1,"force":3,"effet":"Utilise VOL ou INT; Fait des dégâts à la cible; Perce-Armure","competence":"Baguette","cout":350},
+  {"nom":"Baguette maléfique","type":"Baguette","mains":1,"force":3,"effet":"Utilise VOL ou INT; Fait des dégâts sur les PM (dé de mental)","competence":"Baguette","cout":550},
+  {"nom":"Sceptre de soin","type":"Baguette","mains":2,"force":8,"effet":"Utilise VOL ou INT; Les dégats sont fait en tant que soin","competence":"Baguette","cout":500},
+  {"nom":"Sceptre de combat","type":"Baguette","mains":2,"force":5,"effet":"Utilise VOL ou INT; Fait des dégâts à la cible; Perce-Armure","competence":"Baguette","cout":500},
+  {"nom":"Sceptre maléfique","type":"Baguette","mains":2,"force":5,"effet":"Utilise VOL ou INT; Fait des dégâts sur les PM (dé de mental)","competence":"Baguette","cout":800}
+]
\ No newline at end of file
diff --git a/public/jdr/mains/base.json b/public/jdr/mains/base.json
new file mode 100644
index 0000000..84dea2b
--- /dev/null
+++ b/public/jdr/mains/base.json
@@ -0,0 +1,17 @@
+[
+  {"nom":"Mains","type":"Arme au CaC","mains":2,"force":0,"effet":"Comptent comme main nue. Non-Lethal","competence":"N/A","cout":0},
+  {"nom":"Poings","type":"Arme au CaC","mains":2,"force":2,"effet":"Comptent comme main nue. Non-Lethal","competence":"N/A","cout":80},
+  {"nom":"Griffe","type":"Arme au CaC","mains":2,"force":3,"effet":"Comptent comme main nue. Saignement si critique","competence":" N/A ","cout":150},
+  {"nom":"Batons","type":"Arme au CaC","mains":2,"force":2,"effet":"Non-Lethal","competence":"N/A","cout":80},
+  {"nom":"Fouet","type":"Arme au CaC","mains":1,"force":3,"effet":"Peut toucher à distance","competence":"Fouet","cout":150},
+  {"nom":"Couteau","type":"Arme au CaC","mains":1,"force":3,"effet":"Peuvent être lancée. Saignement si critique","competence":"N/A","cout":150},
+  {"nom":"Projectile","type":"Arme distance","mains":1,"force":0,"effet":"Lance un projectile (pierre, etc)","competence":"N/A","cout":0},
+  {"nom":"Lance-Pierre","type":"Arme distance","mains":1,"force":1,"effet":"Peuvent être utilisée pour jeter des projectiles spécifiques","competence":"N/A","cout":150},
+  {"nom":"Fronde","type":"Arme distance","mains":1,"force":2,"effet":"Peuvent être utilisée pour jeter des projectiles spécifiques","competence":"N/A","cout":200},
+  {"nom":"Boumerang","type":"Arme distance","mains":1,"force":3,"effet":"Nécessite deux jet d'HAB réussi pour être esquivé","competence":"Boumerang","cout":200},
+  {"nom":"Bouclier simple","type":"Bouclier","mains":1,"force":1,"effet":" ","competence":"Bouclier","cout":100},
+  {"nom":"Bouclier lourd","type":"Bouclier","mains":1,"force":4,"effet":"-10% pour encaisser et esquiver","competence":"Bouclier","cout":400},
+  {"nom":"Pelle","type":"Outil","mains":2,"force":1,"effet":"Peut être utilisé pour creuser","competence":"N/A ","cout":100},
+  {"nom":"Fourchette","type":"Outil","mains":2,"force":1,"effet":"Manger rapporte +1 PM","competence":"N/A","cout":30},
+  {"nom":"Torche","type":"Outil","mains":1,"force":2,"effet":"Dure une partie; Éclaires; Dégats de feu","competence":"N/A","cout":150}
+]
\ No newline at end of file
diff --git a/public/jdr/mains/medieval-cac.json b/public/jdr/mains/medieval-cac.json
new file mode 100644
index 0000000..052826d
--- /dev/null
+++ b/public/jdr/mains/medieval-cac.json
@@ -0,0 +1,11 @@
+[
+{"nom":"Épée","type":"Arme au CaC","mains":1,"force":5,"effet":"","competence":"Épée","cout":400},
+{"nom":"Épée à deux mains","type":"Arme au CaC","mains":2,"force":8,"effet":"","competence":" Épée","cout":550},
+{"nom":"Hachette","type":"Arme au CaC","mains":2,"force":4,"effet":"FOR-20; Peut être lancé; Saignement si critique","competence":" Hache","cout":550},
+{"nom":"Haches","type":"Arme au CaC","mains":2,"force":10,"effet":"FOR -40; Saignement si critique","competence":" Hache","cout":600},
+{"nom":"Lance","type":"Arme au CaC","mains":2,"force":5,"effet":"Peut être lancé ; Touche des ennemis plus éloigné ; +50% dégat si sur/contre monture","competence":" Lance","cout":550},
+{"nom":"Hallebarde","type":"Arme au CaC","mains":2,"force":10,"effet":"FOR -40; Peut être lancé ; Touche des ennemis plus éloigné ; +50% dégat si sur/contre monture","competence":" Lance","cout":600},
+{"nom":"Marteau","type":"Arme au CaC","mains":1,"force":4,"effet":"Effet de brise-armure","competence":"Masse","cout":400},
+{"nom":"Masses","type":"Arme au CaC","mains":2,"force":8,"effet":"FOR -20; Effet de brise-armure","competence":"Masse","cout":600},
+{"nom":"Pavois","type":"Bouclier","mains":2,"force":6,"effet":"-20% pour encaisser et esquiver","competence":"Bouclier","cout":550}
+]
\ No newline at end of file
diff --git a/public/jdr/mains/medieval-feu.json b/public/jdr/mains/medieval-feu.json
new file mode 100644
index 0000000..dc14d0b
--- /dev/null
+++ b/public/jdr/mains/medieval-feu.json
@@ -0,0 +1,3 @@
+[
+  {"nom":" Escopette/Arquebuse","type":"Arme distance","mains":1,"force":8,"effet":"Doit être rechargé tout les tir ; Semi perce-défense","competence":" Arme à feu","cout":400}
+]
\ No newline at end of file
diff --git a/public/jdr/mains/moderne.json b/public/jdr/mains/moderne.json
new file mode 100644
index 0000000..37587ea
--- /dev/null
+++ b/public/jdr/mains/moderne.json
@@ -0,0 +1,8 @@
+[
+  {"nom":" Revolver","type":"Arme distance","mains":1,"force":8,"effet":"Doit être rechargé tout les deux tir ; Semi perce-défense","competence":" Pistolet","cout":550},
+{"nom":" Fusil","type":"Arme distance","mains":2,"force":12,"effet":"PER -20; Doit être rechargé tout les deux tir ; Semi perce-défense","competence":" Fusil","cout":600},
+{"nom":" Tromblon","type":"Arme distance","mains":2,"force":8,"effet":"PER -20; Doit être rechargé tout les deux tir ; Touche une zone; Semi perce-défense","competence":" Fusil","cout":600},
+{"nom":" Pistolet automatique","type":"Arme distance","mains":1,"force":8,"effet":"PER - 20 ; Semi perce-défense","competence":" Arme à feu","cout":900},
+{"nom":" Fusil automatique","type":"Arme distance","mains":2,"force":12,"effet":"PER -40; Semi perce-défense","competence":" Fusil","cout":1200},
+{"nom":" Fusil à double canon","type":"Arme distance","mains":2,"force":15,"effet":"PER -40; Doit être rechargé tout les deux tir ; Semi perce-défense","competence":" Fusil","cout":1200}
+]
\ No newline at end of file
diff --git a/public/jdr/mains/outil-moderne.json b/public/jdr/mains/outil-moderne.json
new file mode 100644
index 0000000..7fed81f
--- /dev/null
+++ b/public/jdr/mains/outil-moderne.json
@@ -0,0 +1,3 @@
+[
+  {"nom":" Tronçonneuse","type":"Outil","mains":2,"force":15,"effet":"FOR -50; Doit être rechargé tout les deux attaque; Saignement si critique; Semi perce-défense","competence":"Tronçonneuse","cout":1200}
+]
\ No newline at end of file
diff --git a/public/jdr/sonata.json b/public/jdr/sonata.json
index 35cf3d4..9d95ff9 100644
--- a/public/jdr/sonata.json
+++ b/public/jdr/sonata.json
@@ -15,5 +15,7 @@
     {"name":"determination19","value":"Le personnage fait un jet d'anomie"},
     {"name":"determination20","value":"Le personnage devient anomique"}
   ],
-  "objects":["base"]
+  "objects":["base"],
+  "equipMains":["base", "arcs", "medieval-cac", "moderne"],
+  "effetsMains":["base", "tech"]
 }
\ No newline at end of file
diff --git a/public/pelican.json b/public/pelican.json
index 98cbf4f..85af39d 100644
--- a/public/pelican.json
+++ b/public/pelican.json
@@ -56,7 +56,7 @@
       "title": "Inventaire",
       "links": [
         {"title": "Objets et consommables", "path": "inventaire/objets"},
-        {"title": "Équipement et outils", "path": "rules/inventaire/equipements"},
+        {"title": "Équipement et outils", "path": "inventaire/equipements"},
         {"title": "Véhicules", "path": "rules/inventaire/vehicules"}
       ]
     },
diff --git a/public/rules/inventaire/mains-effets.md b/public/rules/inventaire/mains-effets.md
new file mode 100644
index 0000000..dd25fdd
--- /dev/null
+++ b/public/rules/inventaire/mains-effets.md
@@ -0,0 +1,3 @@
+## Effets d'outils
+
+Plusieurs effets peuvent être appliqués sur les outils, affectant les degats qu'ils peuvent faire en tant qu'arme, etc.
diff --git a/public/rules/inventaire/mains.md b/public/rules/inventaire/mains.md
new file mode 100644
index 0000000..77698b3
--- /dev/null
+++ b/public/rules/inventaire/mains.md
@@ -0,0 +1,19 @@
+# Equipements
+
+Lors d'un combat, vous pouvez utiliser toutes sortes d'armes ou d'objets pour agir, attaquer et/ou vous défendre. Voici un petit panel de ce qui est possible d'avoir dans un JDR de type Pélican. Il est a noter que les équipements peuvent avoir des effets, qui peuvent se combiner. Leurs effets ET leur surcout (des plus faibles aux plus grands) se combinent alors pour donner le prix final de l'équipement.
+
+## Les outils
+
+Le premier type d'équipements sont les outils, ce sont les outils que votre personnage porte sur lui pour agir. Lorsqu'ils sont équipés, ils prennent une ou deux mains de votre personnage. Parmis ces outils, pour attaquer ou vous défendre, vos personnages peuvent porter une arme ou un bouclier, mais la plupars des outils peuvent être utilisé pour le combat.
+
+### Types d'armes et boucliers
+
+Les armes et boucliers sont les types d'outils spécialisé pour le combat.
+
+- Les armes au corps-à-corps utilise la **force** pour attaquer, et ne peuvent généralement toucher que les ennemis proches. Le dé utilisé pour attaquer est généralement le dé de vigueur.
+
+- Les armes à distance utilise la **perception** pour attaquer, et peuvent toucher n'importe lequel des ennemis présents, tant qu'il n'est pas caché. Le dé utilisé pour attaquer est généralement le dé de jet.
+
+-  Les boucliers permettent de diminuer les dégâts si un jet d'encaissement est réussi, et s'ajoutent au dessus de l'armure, qu'elle soit physique ou spéciale - avec parfois quelque subtilité.
+
+### Liste des outils
\ No newline at end of file
diff --git a/src/data/fields.ts b/src/data/fields.ts
index f654b09..dd3194b 100644
--- a/src/data/fields.ts
+++ b/src/data/fields.ts
@@ -6,4 +6,19 @@ const objectFields = [
   { key: "cout", label: "Cout" },
 ];
 
-export { objectFields };
+const equipMainsFields = [
+  { key: "nom", label: "Nom" },
+  { key: "type", label: "Type", canBeFiltered: true },
+  { key: "mains", label: "Mains", canBeFiltered: true },
+  { key: "effet", label: "Effet" },
+  { key: "force", label: "Force" },
+  { key: "cout", label: "Cout" },
+];
+
+const effetsFields = [
+  { key: "nom", label: "Nom" },
+  { key: "effet", label: "Effet" },
+  { key: "surcout", label: "Surcout" },
+];
+
+export { objectFields, equipMainsFields, effetsFields };
diff --git a/src/router/index.ts b/src/router/index.ts
index f2ccd2c..56238bb 100644
--- a/src/router/index.ts
+++ b/src/router/index.ts
@@ -4,6 +4,7 @@ import RuleView from "../views/RuleView.vue";
 import JdrView from "../views/JdrView.vue";
 import FichesView from "../views/FichesView.vue";
 import ObjetsView from "../views/ObjetsView.vue";
+import EquipView from "../views/EquipView.vue";
 
 const router = createRouter({
   history: createWebHashHistory(import.meta.env.BASE_URL),
@@ -37,6 +38,10 @@ const router = createRouter({
       path: "/jdr/:jdr/inventaire/objets/",
       component: ObjetsView,
     },
+    {
+      path: "/jdr/:jdr/inventaire/equipements/",
+      component: EquipView,
+    },
   ],
   scrollBehavior(to, from, savedPosition) {
     if (to.hash) {
diff --git a/src/types/JdrConfig.ts b/src/types/JdrConfig.ts
index 55722b3..61c023e 100644
--- a/src/types/JdrConfig.ts
+++ b/src/types/JdrConfig.ts
@@ -7,4 +7,6 @@ export default interface JdrConfig {
   hideLinks: HideLink[];
   vars: { name: string; value: string }[];
   objects: string[];
+  equipMains: string[];
+  effetsMains: string[];
 }
diff --git a/src/views/EquipView.vue b/src/views/EquipView.vue
new file mode 100644
index 0000000..c4c771d
--- /dev/null
+++ b/src/views/EquipView.vue
@@ -0,0 +1,42 @@
+<script setup lang="ts">
+import DynTable from "@/components/tableaux/DynTable.vue";
+import { useConfigStore } from "@/stores/config";
+import { onMounted, computed } from "vue";
+import { useRoute } from "vue-router";
+import MarkdownFile from "../components/MarkdownFile.vue";
+import { equipMainsFields, effetsFields } from "@/data/fields";
+
+const store = useConfigStore();
+const route = useRoute();
+
+onMounted(() => {
+  store.loadJdr(`${route.params.jdr}`);
+});
+
+const equipMains = computed(() => {
+  return store.jdrConfig?.equipMains ?? [];
+});
+
+const effetsMains = computed(() => {
+  return store.jdrConfig?.effetsMains ?? [];
+});
+</script>
+
+<template>
+  <main>
+    <MarkdownFile :path="`rules/inventaire/mains`">
+      <DynTable
+        :fields="equipMainsFields"
+        :files="equipMains"
+        category="mains"
+      />
+    </MarkdownFile>
+    <MarkdownFile :path="`rules/inventaire/mains-effets`">
+      <DynTable
+        :fields="effetsFields"
+        :files="effetsMains"
+        category="effets-mains"
+      />
+    </MarkdownFile>
+  </main>
+</template>

From bab292f357a97c69f98a3e4c11f06255ac75ea30 Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Sun, 12 Feb 2023 20:49:05 +0100
Subject: [PATCH 10/27] chore: refonte perce-armure

---
 CHANGELOG.md                           |   2 +
 public/rules/combats/attacc.md         |   6 +-
 public/rules/inventaire/equipements.md | 190 +------------------------
 public/rules/magie/elements.md         |   2 +-
 public/rules/personnages/vitalite.md   |   8 +-
 5 files changed, 16 insertions(+), 192 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5d73f53..efa6a86 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -42,6 +42,8 @@ Refonte global du site en vueJS
 
 - [site] Unification de l'interface
 - [site] Feuilles de styles simplifiées
+- [core] Refonte perce-armure qui touche toute l'attaque, ou divise par deux l'armure. Idem Perce-Defense.
+- [core] Refonte armure spéciale, qui devient une armure ignorant le perce-armure, le brise armure, etc.
 
 ### Supprimés
 
diff --git a/public/rules/combats/attacc.md b/public/rules/combats/attacc.md
index 7c5f862..34a2480 100644
--- a/public/rules/combats/attacc.md
+++ b/public/rules/combats/attacc.md
@@ -58,11 +58,11 @@ Tableau récapitulatif :
 
 Différents effets peuvent s'appliquer aux attaques et affecter les personnages différemment :
 
-- Les dégâts **perce-armure** sont des dégâts qui vont traverser l'armure, et ne pourront être protéger par elle.
+- L'effets **perce-armure** font que les dégâts vont traverser l'armure, et ne pourront être protéger par elle. Une attaque est *semi perce-armure* si elle divise par deux l'armure.
 
-- Les dégâts **perce-défense** sont des dégâts qui vont traverser la défense, et ne pourront être protéger par le jet de vigueur, ni l'esquive.
+- Les dégâts **perce-défense** font que les dégâts vont traverser la défense, et ne pourront être protéger par le jet de vigueur et le bouclier. Une attaque est *semi perce-défense* si elle divise par deux le jet de vigueur et bouclier.
 
-- Les dégâts **brise-armure** font perdre un points d'armure tout les six dégâts (en priorité sur le bouclier s'il est utilisé). Les points d'armure venant de pouvoirs (hors armure naturelle) ne peuvent être touché.
+- Les dégâts **brise-armure** font perdre un points d'armure tout les six dégâts (en priorité sur le bouclier s'il est utilisé). Les points d'armure spéciale ne sont pas touché.
 
 - Les dégats de **chute** sont à 1D12, lancé le nombre de fois correspondant au nombre d'étage de la chute. Ils sont brises-armures.
 
diff --git a/public/rules/inventaire/equipements.md b/public/rules/inventaire/equipements.md
index cb8d2a7..8a5a81e 100644
--- a/public/rules/inventaire/equipements.md
+++ b/public/rules/inventaire/equipements.md
@@ -1,155 +1,3 @@
-# Equipements
-
-Lors d'un combat, vous pouvez utiliser toutes sortes d'armes ou d'objets pour agir, attaquer et/ou vous défendre. Voici un petit panel de ce qui est possible d'avoir dans un JDR de type Pélican.
-
-Il est a noter que les équipements peuvent avoir des effets, qui peuvent se combiner. Leurs effets ET leur surcout (des plus faibles aux plus grands) se combinent alors pour donner le prix final de l'équipement.
-
-<div class="table-auto">
-
-## Armes
-
-### Liste des armes
-
-#### Armes au Corps à Corps
-
-Les armes au corps-à-corps utilise la **force** pour attaquer, et ne peuvent généralement toucher que les ennemis proches. Le dé utilisé pour attaquer est généralement le dé de vigueur.
-
-| Arme (mains) | dégâts | Effet | Critiques | Compétence | Prix |
-|:------------:|:------:|:------|:-----------:|:----:|:----:|
-| Mains (2) | 0 | Comptent comme « main nue ». Non-Lethal |  | N/A | 0 |
-| Poings (2) | 2 | Comptent comme « main nue ». Non-Lethal |  | N/A | 100 |
-| Griffe (2) | 2 | Comptent comme « main nue ». | Provoque saignement. |  N/A | 150 |
-| Batons (2) | 1 | | Non-Lethal | N/A | 100 |
-| Fouet (1) | 2 | Peut toucher à distance. |   | Fouet | 150 |
-| Marteau (1) | 4 | Effet de brise-armure. | Double brise-armure | Masse | 400 |
-| Masses (2) | 8 | FOR -20; Effet de brise-armure | Double brise-armure. | Masse | 600 |
-
-#### Armes blanches
-
-Les armes au corps-à-corps utilise la **force** pour attaquer, et ne peuvent généralement toucher que les ennemis proches. Le dé utilisé pour attaquer est généralement le dé de vigueur.
-
-| Arme (mains) | dégâts | Effet | Critiques | Compétence | Prix |
-|:------------:|:------:|:------|:-----------:|:----:|:----:|
-| Couteau / Dague (1) | 3 | Peuvent être lancée. | Provoque saignement, incapacitation perçante | N/A | 150 |
-| Épée (1) | 5 | | Incapacitation perçante | Épée | 400 |
-| Épée à deux mains (2) | 8 | | Incapacitation perçante | Épée | 550 |
-| Hachette (2) | 4 | FOR-20; Peut être lancé | Incapacitation tranchante. | Hache | 550 |
-| Haches (2) | 10 | FOR -40 | Incapacitation tranchante | Hache | 600 |
-| Lance (2) | 5 | Peut être lancé ; Touche des ennemis plus éloigné ; +50% dégat si sur/contre monture | Incapacitation perçante | Lance | 550 |
-| Hallebarde (2) | 10 | FOR -40; Peut être lancé ; Touche des ennemis plus éloigné ; +50% dégat si sur/contre monture | Incapacitation perçante | Lance | 600 |
-
-#### Armes de jet
-
-Les armes à distance utilise la **perception** pour attaquer, et peuvent toucher n'importe lequel des ennemis présents, tant qu'il n'est pas caché. Le dé utilisé pour attaquer est généralement le dé de jet.
-
-Un des défauts des arbalète est le risque d'enrayement. À chaque tir, un dés (D20->D3) de plus en plus petits est fait d'enrayement, ce qui empèche l'attaque, et demande de prendre un tour pour désenrayer l'arbalète.
-
-| Arme (mains) | dégâts | Effet | Critiques | Compétence | Prix |
-|:------------:|:------:|:------|:-----------:|:----:|:----:|
-| Projectile (1) | 0 | Lance un projectile (pierre, etc). | N/A | N/A  | 0 |
-| Lance-Pierre (1) | 2 | Peuvent être utilisée pour jeter des projectiles spécifiques. | N/A | N/A | 150 |
-| Fronde (1) | 3 | Peuvent être utilisée pour jeter des projectiles spécifiques. | N/A | N/A | 200 |
-| Arc court (2) | 4 | Perce-armure sur les hélicoptères. | Incapacitation perçante | Arc | 350 |
-| Arc long (2) | 6 | PER -20; Perce-armure sur les hélicoptères. | Incapacitation perçante | Arc | 400 |
-| Arbalète à une main (1) | 6 | PER -20; La moitié des dégâts sont perce-armure ; Peut s'enrayer | Incapacitation perçante | Arc | 500 |
-| Arbalète (2) | 8 | PER -20; La moitié des dégâts sont perce-armure ; Peut s'enrayer | Incapacitation perçante | Arc | 600 |
-| Escopette/Arquebuse (1) | 8 | Doit être rechargé tout les tir ; La moitié des dégâts sont perce-défense | Incapacitation perçante | Arme à feu | 400 |
-
-#### Armes à feu
-
-Des armes à distance redoutables, dont la moitié des dégâts sont généralement perces-défenses.
-
-| Arme (mains) | dégâts | Effet | Critiques | Compétence | Prix |
-|:------------:|:------:|:------|:-----------:|:----:|:----:|
-| Revolver (1) | 8 | Doit être rechargé tout les deux tir ; La moitié des dégâts sont perce-défense | Incapacitation perçante | Pistolet | 550 |
-| Fusil (2) | 12 | PER -10; Doit être rechargé tout les deux tir ; La moitié des dégâts sont perce-défense. | Incapacitation (les deux types) | Fusil | 600 |
-| Tromblon (2) | 8 | PER -10; Doit être rechargé tout les deux tir ; Touche une zone; La moitié des dégâts sont perce-défense. | Incapacitation (les deux types) | Fusil | 600 |
-| Pistolet automatique (1) | 8 | PER - 15 ; La moitié des dégâts sont perce-défense | Incapacitation perçante | Arme à feu | 900 |
-| Fusil automatique (2) | 12 | PER -30; La moitié des dégâts sont perce-défense. | Incapacitation (les deux types) | Fusil | 1200 |
-| Fusil à double canon (2) | 15 | PER -30; Doit être rechargé tout les deux tir ; La moitié des dégâts sont perce-défense. | Incapacitation (les deux types) | Fusil | 1200 |
-
-### Effets des armes
-
-#### Effets de base
-
-| Nom de l'effet | Effet | Amplification du prix |
-|:-------------:|:----|:-----:|
-| Non-léthal | Si ennemi ≥ 1 PV, alors le coup ne fera pas tomber en dessous de 0 PV | +10% |
-| Léthal | Double les chances de réussite critique | +50% |
-| de verre | Double les dégâts, mais ne peut être utilisé que deux fois | +10% |
-| Améliorée | Fait 50% de dégats de base en plus | +50% |
-| Supérieur | Fait 100% de dégats de base en plus | +100% |
-| Ultime | Fait 150% de dégats de base en plus | +150% |
-
-#### Effes magiques
-
-| Nom de l'effet | Effet | Amplification du prix |
-|:-------------:|:----|:-----:|
-| Élémentaire | Produit l'effet de l'élément lié | +25% |
-| des Âmes | Chaque mort fait avec cette arme lui confère un dégât d'1PM qui sera aussi appliqué au héros | +25% |
-| Funeste | Provoque un jet de panique si réussite critique | +100% |
-| De sang | Provoque un jet d'affliction physique si réussite critique | +100% |
-| Des Héros | +50% dégats sur les créatures démoniaques | +100% |
-| Des Ombres | Fait 3 dégâts bruts même si l'attaque est esquivée | +100% |
-
-#### Effets technologiques
-
-Dans le cas d'une arme élémentaire, elle prendra un nom plus "scientifique" (tel que calorique, frigorifique, éléctrique, etc).
-
-| Nom de l'effet | Effet | Amplification du prix |
-|:-------------:|:----|:-----:|
-| Élémentaire* | Produit l'effet de l'élément lié | +25% |
-| Biotechnologie | Ajoute un effet de vampirisme physique (50 % des dégâts effectués régénéré en tant que PV) à l’attaque. | +50% |
-| Nanotechnologie | 50% des dégats sont perce-armure | + 50% |
-| Crystalline | Brise armure : tous les 6 points de dégâts effectué, ajoute un malus en armure jusqu’à réparation | + 25% |
-| Laser | Attaque sur armure speciale | +10% |
-
-## Boucliers
-
-Les boucliers permettent de diminuer les dégâts si un jet d'encaissement est réussi, et s'ajoutent au dessus de l'armure, qu'elle soit physique ou spéciale - avec parfois quelque subtilité.
-
-### Liste des boucliers
-
-| Bouclier (mains) | Protection | Effet | Prix |
-|:------------:|:----:|:------|:---:|
-| Bouclier simple (1) | 1 |  | 100 |
-| Bouclier lourd (1) | 4 | -10% pour encaisser et esquiver | 400 |
-| Pavois (2) | 6 | -20% pour encaisser et esquiver | 550 |
-
-### Effets des boucliers
-
-#### Effets de base
-
-| Nom de l'effet | Effet | Amplification du prix |
-|:-------------:|:----|:-----:|
-| Boomerang | Peut être jeté pour faire la moitié de l'armure en dégâts | +10% |
-| À accroche | Le bouclier à besoin d'une main de moins | +10% |
-| À pique | 50% de l'armure en tant que dégat de riposte quand attaqué |  +10% |
-| Consolidé | Effet du brise-armure divisé par 2 | +25% |
-| d'Exception | Double les chances de réussite critique à l'encaissement | +50% |
-| Miroir | Renvoie la moitié des dégâts spéciaux infligés | +50% |
-| Améliorée | Fait 50% de défense de base en plus | +50% |
-| Supérieur | Fait 100% de défense de base en plus | +100% |
-| Ultime | Fait 150% de défense de base en plus | +150% |
-
-#### Effets magiques
-
-| Nom de l'effet | Effet | Amplification du prix |
-|:-------------:|:----|:-----:|
-| Elémentaire | Rajoute une résistance à l'élément lié | +25% |
-| Magique | +25% face aux attaques spéciales | +25% |
-| Scellé | Ne peut être retiré que par le porteur | +10% |
-| D'Âme | Peut être utilisé pour faire face aux attaques morale | +50% |
-
-#### Effets technologiques
-
-| Nom de l'effet | Effet | Amplification du prix |
-|:-------------:|:----|:-----:|
-| Elémentaire* | Peut provoquer un effet d'élément pour une attaque parée | +25% |
-| Biotechnologie | Vole 50% de l'armure en tant que PV si l'attaque est parée. | +50% |
-| Nanotechnologie | S'auto-répare de 1/partie | + 50% |
-| Crystalline | Brise-Arme: 1/4 de faire perdre 1 points de dégat à une arme l'attaquant sur le physique | + 25% |
-
 ## Tenues
 
 Les tenues sont un équipement offrant protection et effets divers à votre personnage. Les personnages ne peuvent porter qu'une tenues à la fois, il peut être donc intéressant d'adapter sa tenue aux circonstances.
@@ -168,11 +16,11 @@ Les tenues sont un équipement offrant protection et effets divers à votre pers
 | Armure intégrale | 5 | 1 | -25 % DIS et HAB ; x0.5 chance de toucher point faible | 850 |
 | Armure Lourde | 7 | 0 | -25 % DIS et HAB | 850 |
 
-### Effets des tenues
+## Effets des tenues
 
 Différents types d'effets peuvent exister sur les tenues. Il est à noter que les vêtements, les tenues de base, ne présentent pas vraiment de puissance, mais peuvent avoir des pouvoirs unique, tels que des effets sociaux, pour compenser leur manque de compréhension. Les armures ont des effets plus proche de ceux des armes et bouclier.
 
-#### Effets vetements
+### Effets vetements
 
 | Nom de l'effet | Effet | Effet négatif |
 |:-------------:|:----|:-----:|
@@ -189,7 +37,7 @@ Différents types d'effets peuvent exister sur les tenues. Il est à noter que l
 | Tenue de voyage | +20 pour les exploration de grand espace | -20% SOC en société |
 | Tenue moulante sombre | +20 en DIS dans un lieu sombre | -20 en DIS autrement |
 
-#### Effets de base (armures)
+### Effets de base (armures)
 
 | Nom de l'effet | Effet | Amplification du prix |
 |:-------------:|:----|:-----:|
@@ -200,7 +48,7 @@ Différents types d'effets peuvent exister sur les tenues. Il est à noter que l
 | Supérieur | Fait 100% de défense de base en plus | +100% |
 | Ultime | Fait 150% de défense de base en plus | +150% |
 
-#### Effets magiques (armures)
+### Effets magiques (armures)
 
 | Nom de l'effet | Effet | Amplification du prix |
 |:-------------:|:----|:-----:|
@@ -215,7 +63,7 @@ Différents types d'effets peuvent exister sur les tenues. Il est à noter que l
 | Des Ombres | -25% PM et PV ; 1D6, si 1, un encaissement réussi devient une esquive | +100% |
 | Des Héros | -n×10 DIS ; +20% dans toutes les stats face aux êtres démoniaques. | +100% |
 
-#### Effets technologique (armures)
+### Effets technologique (armures)
 
 | Nom de l'effet | Effet | Amplification du prix |
 |:-------------:|:----|:-----:|
@@ -226,32 +74,6 @@ Différents types d'effets peuvent exister sur les tenues. Il est à noter que l
 | Pare-balle | Anti-perce défense face aux armes à feux | +25% |
 | Anti-explosion | Encaisse les explosions | +25% |
 
-## Baguettes
-
-Des baguettes sont des accessoires magiques servant à faire des actions spécifiques. Elles utilisent la compétence baguette, le dés de mental, et les stats de INT ou VOL.
-
-### Liste des baguettes
-
-| Type | Effet | Prix |
-|:----:|:----:|:-----:|
-| Baguette de soin | Sert à soigner | 350 |
-| Baguette de guérison | Soigne + 50 % de chance de soigner une altération. | 550 |
-| Baguette élémentaire | Sert à lancer un sort élémentaire de base | 550, 750 si métaphysique |
-| Baguette de combat | Fait des dégâts non-élémentaire à la cible | 350 |
-| Baguette maléfique | Fait des dégâts sur les PM (dé de mental) | 550 |
-
-### Effets des baguettes
-
-| Nom de l'effet | Effet | Amplification du prix |
-|:-------------:|:----|:-----:|
-| Non-léthal | Si ennemi ≥ 1 PV, alors le coup ne fera pas tomber en dessous de 0 PV | +10% |
-| d'Exception | Double les chances de réussite critique | +50% |
-| de verre | Double les dégats/soins, mais ne peut être utilisé que deux fois | +10% |
-| Sceptre | Fait +2 de dégats/soins en plus, mais prend deux mains | +25% |
-| Améliorée | Fait +2 de dégats/soins de base en plus | +50% |
-| Supérieur | Fait +4 de dégats/soins de base en plus | +100% |
-| Ultime | Fait +8 de dégats/soins de base en plus | +150% |
-
 ## Accessoires
 
 Les accessoires sont des équipements aux effets divers, qui sont limités à deux par personnages.
@@ -274,5 +96,3 @@ Les accessoires sont des équipements aux effets divers, qui sont limités à de
 | Lunettes Optic Grosbill | Protège de tout malus en perception | 750 |
 | Masque de terreur | En cas de jet de panique, 1D4. Si 4, un allié fait aussi un jet de panique. Sinon, un ennemi le fait | 1500 |
 | Slip divin | +20 aux jets de survies | 2550 |
-
-</div>
diff --git a/public/rules/magie/elements.md b/public/rules/magie/elements.md
index 6187450..fed67d9 100644
--- a/public/rules/magie/elements.md
+++ b/public/rules/magie/elements.md
@@ -76,7 +76,7 @@ Ils peuvent avoir les effets suivants en combat :
 | **Air** | La moitié des dégâts de l'attaque ont 50% d'agir même si l'attaque à été esquivée. |
 | **Foudre** | 50 % de chance de provoquer un effet de « stunt » sur l’ennemi. |
 | **Feu** | 60 % de chance de produire un effet « blessure/brûlure ». Si critique, blessure/brûlure grave.
-| **Metal** | 50 % des dégâts sont perce-armure (en plus de ceux potentiellement déjà p-a) |
+| **Metal** | Semi perce-armure (100% perce-armure si déjà semi perce-armure) |
 
 </div>
 
diff --git a/public/rules/personnages/vitalite.md b/public/rules/personnages/vitalite.md
index b016b2e..e9debde 100644
--- a/public/rules/personnages/vitalite.md
+++ b/public/rules/personnages/vitalite.md
@@ -71,9 +71,11 @@ Le jet d'irrationnalité (ou jet de panique) peut être vu dans la page afflicti
 
 Sur les fiches de personnages, vous pouvez remarquer trois types d'armures. Chacune permet de protéger dans les conditions suivantes :
 
-| Armure physique | Armure spéciale | Armure morale |
-|:---------------:|:---------------:|:-------------:|
-| Protège des attaques faites sur les PV, par les attaques physiques. | Protège à la fois les PV et les PM, mais des attaques produites par les attaques non-directement physique. | Protège des attaques faites sur les PM, par les attaques morales ou psychique.
+| Armure physique | Armure morale |
+|:---------------:|:---------------:|
+| Protège des attaques faites sur les PV, par les attaques physiques. | Protège des attaques faites sur les PM, par les attaques morales ou psychique. |
+
+En plus de l'armure physique, le personnage peut avoir des points d'armures *spéciales* qui ne sont pas affecté par le perce-armure et le brise armure.
 
 ## Status
 

From 6d360e1026b9d8e837e5374314730ca5b07591be Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Mon, 13 Feb 2023 18:34:02 +0100
Subject: [PATCH 11/27] feat: ajout des jdr de test

---
 public/jdr/cartomancia.json     |  2 +-
 public/pages/jdr/cartomancia.md |  7 +++++++
 public/pages/jdr/sonata.md      |  7 +++++++
 public/pelican.json             | 14 ++++++++++++++
 4 files changed, 29 insertions(+), 1 deletion(-)
 create mode 100644 public/pages/jdr/cartomancia.md
 create mode 100644 public/pages/jdr/sonata.md

diff --git a/public/jdr/cartomancia.json b/public/jdr/cartomancia.json
index b28399e..523afc8 100644
--- a/public/jdr/cartomancia.json
+++ b/public/jdr/cartomancia.json
@@ -5,7 +5,7 @@
     {"name":"determination19","value":"TODO"},
     {"name":"determination20","value":"TODO"}
   ],
-  "objets":["base", "elements", "magique", "potion"],
+  "objects":["base", "elements", "magique", "potions"],
   "equipMains":["base", "arcs", "medieval-cac", "medieval-feu", "baguette"],
   "effetsMains":["base", "magique"]
 }
\ No newline at end of file
diff --git a/public/pages/jdr/cartomancia.md b/public/pages/jdr/cartomancia.md
new file mode 100644
index 0000000..3804f70
--- /dev/null
+++ b/public/pages/jdr/cartomancia.md
@@ -0,0 +1,7 @@
+# Cartomancia
+
+Cartomancia est un JDR orienté fantasy "sans univers", visant à reproduire à ce pourquoi beaucoup utilisent les règles d'univers à la D&D ou PF : Plutôt que de représenter un univers avec ses propres aspects et un lore très défini, cartomancia propose des bases, une série d'espèce, de concept de gameplay à partir duquel vous pouvez broder votre univers et vos concepts.
+
+Cartomancia propose de ce fait un gameplay de JDR Héroïc Fantasy avec nains, elfes et gobelins, tout en ayant des inspirations des jeux traditionnels (Échecs, carte à jouer, tarot) pour construire ses classes et pouvoirs. Il peut être cependant adapter à tout type de setting (surtout combiné avec d'autres règles, tels que des armes venant d'autres sets présent ici, etc), et peut être joué en fantasy urbaine, transposé à d'autre époque, et certains de ses éléments peuvent être pris en isolation (sa liste d'espèce, ses classes et les atouts, etc). Si les différentes espèces ont différentes capacité, Cartomancia ne présume pas de leurs organisation sociale ni de leur système politique, qui sont laissé à la liberté de ceux voulant faire des univers utilisant ce JDR.
+
+Ce sytème utilise septs classe, inspiré des pièces d'échecs et des cartes à jouer (pions, chevalier, bouffon, prêtre (pour reprendre le nom anglais du bouffon), chevalier, tour, dame/seigneur et roi/reine), disposé en quatre enseigne (pique, coeur, carreau et trèfle) influençant leur pouvoir. À cela s'ajouter 22 pouvoirs indépendant, basé sur les atouts du jeu de société.
diff --git a/public/pages/jdr/sonata.md b/public/pages/jdr/sonata.md
new file mode 100644
index 0000000..7f09496
--- /dev/null
+++ b/public/pages/jdr/sonata.md
@@ -0,0 +1,7 @@
+# Meteor Sonata
+
+Meteor Sonata est un JDR orienté space-opera "sans univers", visant à reproduire à ce pourquoi beaucoup utilisent les règles d'univers à la D&D ou PF : Plutôt que de représenter un univers avec ses propres aspects et un lore très défini, cartomancia propose des bases, une série d'espèce, de concept de gameplay à partir duquel vous pouvez broder votre univers et vos concepts.
+
+Meteor Sonata propose de ce fait un gameplay de JDR Space Opera avec différentes races aliens, tout en ayant des inspirations d'éléments cyberpunk (possibilité de transformer technologiquement ou autre ses personnages) pour construire ses classes et pouvoirs. Si les différentes espèces ont différentes capacité, Meteor Sonata ne présume pas de leurs organisation sociale ni de leur système politique, qui sont laissé à la liberté de ceux voulant faire des univers utilisant ce JDR.
+
+Ce sytème utilise quatorze classe, inspiré des rôles traditionnels dans les commandement de vaisseau de space opera, combiné à quelques autres inspirations de séries de SF connues. À cela s'ajoute les différentes modifications que vous pouvez faire à votre personnage.
diff --git a/public/pelican.json b/public/pelican.json
index 85af39d..450bb68 100644
--- a/public/pelican.json
+++ b/public/pelican.json
@@ -7,6 +7,20 @@
       "links": [
         {"title": "Règles de bases", "path": "core"}
       ]
+    },
+    {
+      "id": 0,
+      "title": "Systèmes sans univers",
+      "links": [
+        {
+          "title": "Cartomancia",
+          "path": "cartomancia"
+        },
+        {
+          "title": "Meteor Sonata",
+          "path": "sonata"
+        }
+      ]
     }
   ],
   "sidebar": [

From d0f284dc36a1111f91efed8d7fe21b3a21dcd784 Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Mon, 13 Feb 2023 21:26:47 +0100
Subject: [PATCH 12/27] improvement: separate md loader & renderer

---
 src/components/MarkdownFile.vue            |  99 ++----------------
 src/components/markdown/MarkdownRender.vue | 111 +++++++++++++++++++++
 2 files changed, 122 insertions(+), 88 deletions(-)
 create mode 100644 src/components/markdown/MarkdownRender.vue

diff --git a/src/components/MarkdownFile.vue b/src/components/MarkdownFile.vue
index 3568dd9..c6b4582 100644
--- a/src/components/MarkdownFile.vue
+++ b/src/components/MarkdownFile.vue
@@ -1,93 +1,16 @@
 <script setup lang="ts">
 import { ref, onMounted, onBeforeUpdate } from "vue";
-import { marked } from "marked";
-import { useTocStore } from "../stores/toc";
 
 import axios from "axios";
-import { useRoute } from "vue-router";
-import { useConfigStore } from "@/stores/config";
+import MarkdownRender from "./markdown/MarkdownRender.vue";
 
 const props = defineProps<{
   path: string;
   order?: number;
 }>();
 
-const htmlContent = ref("");
 const loadedPage = ref("");
-
-var specialQuote: Map<string, { class: string; text: string }> = new Map();
-specialQuote.set("NOTE", { class: "info", text: "Information :" });
-specialQuote.set("SUCCESS", { class: "success", text: "Success :" });
-specialQuote.set("WARNING", { class: "warning", text: "Warning :" });
-specialQuote.set("DANGER", { class: "danger", text: "Danger :" });
-
-var renderer = new marked.Renderer();
-
-const toc = useTocStore();
-const config = useConfigStore();
-const route = useRoute();
-var tocNbr = 1;
-
-renderer.heading = function (text, level, raw) {
-  var anchor = "#" + raw.toLowerCase().replace(/[^\w]+/g, "-");
-  if (level === 2) {
-    toc.addTocLine(route.path, {
-      anchor: anchor,
-      order: (props.order ?? 1) * 100 + tocNbr,
-      text: text,
-    });
-    tocNbr++;
-  }
-  return `<h${level} id="${anchor}">${text}</h${level}>\n`;
-};
-
-renderer.blockquote = function (quote) {
-  var bqClass = "";
-  var newQuote = quote;
-  for (const [key, quoteData] of specialQuote) {
-    if (quote.includes(`[!${key}]`)) {
-      bqClass = `bg-${quoteData?.class}`;
-      newQuote = newQuote.replace(
-        `[!${key}]`,
-        `<strong>${quoteData?.text}</strong>`
-      );
-    }
-  }
-  newQuote = newQuote.replace("\n", "<br />");
-  return `<blockquote class="${bqClass}">${newQuote}</blockquote>`;
-};
-
-const variable = {
-  name: "variable",
-  level: "inline", // Is this a block-level or inline-level tokenizer?
-  start(src: string) {
-    return src.match(/{{/)?.index;
-  }, // Hint to Marked.js to stop and check for a match
-  tokenizer(
-    src: string
-  ): { type: string; raw: string; [index: string]: any } | undefined {
-    const rule = /\{\{([A-Za-z0-9_]+)\}\}/; // Regex for the complete token, anchor to string start
-    const match = rule.exec(src);
-    if (match) {
-      return {
-        // Token to generate
-        type: "variable", // Should match "name" above
-        raw: match[0], // Text to consume from the source
-        ["varName"]: match[1],
-      };
-    }
-  },
-  renderer(token: { type: string; raw: string; [index: string]: any }): string {
-    const varName = token["varName"] as string | null;
-    const value = `${config.getVar(varName ?? "")}`;
-    return value;
-  },
-};
-
-marked.setOptions({
-  renderer: renderer,
-});
-marked.use({ extensions: [variable] });
+const markdown = ref("");
 
 function refresh() {
   const markdownFileUrl = `/${props.path}.md`;
@@ -99,21 +22,17 @@ function refresh() {
   axios
     .get(markdownFileUrl)
     .then((response) => {
-      tocNbr = 1;
-      htmlContent.value = marked.parse(response.data);
+      markdown.value = response.data;
     })
     .catch(
       () =>
-        (htmlContent.value = marked.parse(
-          "# 404 Not Found \n \n La page recherchée n'a pas pu être trouvée"
-        ))
+        (markdown.value =
+          "# 404 Not Found \n \n La page recherchée n'a pas pu être trouvée")
     );
 }
 
 onMounted(() => {
-  setTimeout(() => {
-    refresh();
-  }, 100);
+  refresh();
 });
 
 onBeforeUpdate(() => {
@@ -123,7 +42,11 @@ onBeforeUpdate(() => {
 
 <template>
   <article>
-    <div v-html="htmlContent" class="markdown"></div>
+    <MarkdownRender
+      :markdown="markdown"
+      :order="order"
+      v-if="markdown !== ''"
+    ></MarkdownRender>
     <slot></slot>
   </article>
 </template>
diff --git a/src/components/markdown/MarkdownRender.vue b/src/components/markdown/MarkdownRender.vue
new file mode 100644
index 0000000..67a6247
--- /dev/null
+++ b/src/components/markdown/MarkdownRender.vue
@@ -0,0 +1,111 @@
+<script setup lang="ts">
+import { ref, onMounted, onBeforeUpdate } from "vue";
+import { marked } from "marked";
+import { useTocStore } from "../../stores/toc";
+
+import { useRoute } from "vue-router";
+import { useConfigStore } from "@/stores/config";
+
+const props = defineProps<{
+  markdown: string;
+  order?: number;
+}>();
+
+const htmlContent = ref("");
+
+var specialQuote: Map<string, { class: string; text: string }> = new Map();
+specialQuote.set("NOTE", { class: "info", text: "Information :" });
+specialQuote.set("SUCCESS", { class: "success", text: "Success :" });
+specialQuote.set("WARNING", { class: "warning", text: "Warning :" });
+specialQuote.set("DANGER", { class: "danger", text: "Danger :" });
+
+var renderer = new marked.Renderer();
+
+const toc = useTocStore();
+const config = useConfigStore();
+const route = useRoute();
+var tocNbr = 1;
+
+renderer.heading = function (text, level, raw) {
+  var anchor = "#" + raw.toLowerCase().replace(/[^\w]+/g, "-");
+  if (level === 2) {
+    toc.addTocLine(route.path, {
+      anchor: anchor,
+      order: (props.order ?? 1) * 100 + tocNbr,
+      text: text,
+    });
+    tocNbr++;
+  }
+  return `<h${level} id="${anchor}">${text}</h${level}>\n`;
+};
+
+renderer.blockquote = function (quote) {
+  var bqClass = "";
+  var newQuote = quote;
+  for (const [key, quoteData] of specialQuote) {
+    if (quote.includes(`[!${key}]`)) {
+      bqClass = `bg-${quoteData?.class}`;
+      newQuote = newQuote.replace(
+        `[!${key}]`,
+        `<strong>${quoteData?.text}</strong>`
+      );
+    }
+  }
+  newQuote = newQuote.replace("\n", "<br />");
+  return `<blockquote class="${bqClass}">${newQuote}</blockquote>`;
+};
+
+const variable = {
+  name: "variable",
+  level: "inline", // Is this a block-level or inline-level tokenizer?
+  start(src: string) {
+    return src.match(/{{/)?.index;
+  }, // Hint to Marked.js to stop and check for a match
+  tokenizer(
+    src: string
+  ): { type: string; raw: string; [index: string]: any } | undefined {
+    const rule = /\{\{([A-Za-z0-9_]+)\}\}/; // Regex for the complete token, anchor to string start
+    const match = rule.exec(src);
+    if (match) {
+      return {
+        // Token to generate
+        type: "variable", // Should match "name" above
+        raw: match[0], // Text to consume from the source
+        ["varName"]: match[1],
+      };
+    }
+  },
+  renderer(token: { type: string; raw: string; [index: string]: any }): string {
+    const varName = token["varName"] as string | null;
+    const value = `${config.getVar(varName ?? "")}`;
+    return value;
+  },
+};
+
+marked.setOptions({
+  renderer: renderer,
+});
+marked.use({ extensions: [variable] });
+
+function render() {
+  tocNbr = 1;
+  if (htmlContent.value === "") {
+    htmlContent.value = marked.parse(props.markdown);
+  }
+}
+
+onMounted(() => {
+  render();
+});
+
+onBeforeUpdate(() => {
+  render();
+});
+</script>
+
+<template>
+  <article>
+    <div v-html="htmlContent" class="markdown"></div>
+    <slot></slot>
+  </article>
+</template>

From f6fcf218d38cba6c316f82d56a9fa3e92640a448 Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Mon, 13 Feb 2023 21:31:45 +0100
Subject: [PATCH 13/27] feat: ajout des tenues

---
 public/jdr/cartomancia.json              |  4 +++-
 public/jdr/core.json                     |  4 +++-
 public/jdr/effets-tenues/base.json       |  8 ++++++++
 public/jdr/effets-tenues/magique.json    | 12 ++++++++++++
 public/jdr/effets-tenues/tech.json       |  8 ++++++++
 public/jdr/sonata.json                   |  4 +++-
 public/jdr/tenues/armures.json           |  6 ++++++
 public/jdr/tenues/base.json              | 15 +++++++++++++++
 public/rules/inventaire/tenues-effets.md |  3 +++
 public/rules/inventaire/tenues.md        |  5 +++++
 src/App.vue                              | 10 +++++++---
 src/data/fields.ts                       |  9 ++++++++-
 src/types/JdrConfig.ts                   |  2 ++
 src/views/EquipView.vue                  | 24 +++++++++++++++++++++---
 14 files changed, 104 insertions(+), 10 deletions(-)
 create mode 100644 public/jdr/effets-tenues/base.json
 create mode 100644 public/jdr/effets-tenues/magique.json
 create mode 100644 public/jdr/effets-tenues/tech.json
 create mode 100644 public/jdr/tenues/armures.json
 create mode 100644 public/jdr/tenues/base.json
 create mode 100644 public/rules/inventaire/tenues-effets.md
 create mode 100644 public/rules/inventaire/tenues.md

diff --git a/public/jdr/cartomancia.json b/public/jdr/cartomancia.json
index 523afc8..c5f5c4b 100644
--- a/public/jdr/cartomancia.json
+++ b/public/jdr/cartomancia.json
@@ -7,5 +7,7 @@
   ],
   "objects":["base", "elements", "magique", "potions"],
   "equipMains":["base", "arcs", "medieval-cac", "medieval-feu", "baguette"],
-  "effetsMains":["base", "magique"]
+  "effetsMains":["base", "magique"],
+  "tenues":["base","armures"],
+  "effetsTenues":["base", "magique"]
 }
\ No newline at end of file
diff --git a/public/jdr/core.json b/public/jdr/core.json
index f3a3a83..21f6902 100644
--- a/public/jdr/core.json
+++ b/public/jdr/core.json
@@ -7,5 +7,7 @@
   ],
   "objects":["base"],
   "equipMains":["base", "arcs"],
-  "effetsMains":["base"]
+  "effetsMains":["base"],
+  "tenues":["base","armures"],
+  "effetsTenues":["base"]
 }
\ No newline at end of file
diff --git a/public/jdr/effets-tenues/base.json b/public/jdr/effets-tenues/base.json
new file mode 100644
index 0000000..a0a3a35
--- /dev/null
+++ b/public/jdr/effets-tenues/base.json
@@ -0,0 +1,8 @@
+[
+  {"nom":"Ultime","effet":"Fait 200% de défense de base en plus","surcout":"+200%"},
+  {"nom":"Intégrale","effet":"Masque les points faibles","surcout":"+25%"},
+  {"nom":"Consolidée","effet":"Effet du brise-armure divisé par 2","surcout":"+25%"},
+  {"nom":"Miroitante","effet":"Renvoie la moitié des dégâts spéciaux infligés","surcout":"+50%"},
+  {"nom":"Améliorée","effet":"Fait 50% de défense de base en plus","surcout":"+50%"},
+  {"nom":"Supérieur","effet":"Fait 100% de défense de base en plus","surcout":"+100%"}
+]
\ No newline at end of file
diff --git a/public/jdr/effets-tenues/magique.json b/public/jdr/effets-tenues/magique.json
new file mode 100644
index 0000000..83000a1
--- /dev/null
+++ b/public/jdr/effets-tenues/magique.json
@@ -0,0 +1,12 @@
+[
+  {"nom":"Élémentaire","effet":"Evite l'effet secondaire de l'élément lié","surcout":"+25%"},
+  {"nom":"Scellée","effet":"Ne peut être retirée que par le porteur","surcout":"+10%"},
+  {"nom":"Magique","effet":"+2 armure spéciale","surcout":"+50%"},
+  {"nom":"D'Âme","effet":"+2 armure morale","surcout":"+50%"},
+  {"nom":"De sang","effet":"-25% PV ; 1D6, si 1, l'ennemi fait un jet d'affliction physique","surcout":"+100%"},
+  {"nom":"Radiante","effet":"+2 éclat ; Rajoute faiblesse à tout les éléments métaphysique ","surcout":"+100%"},
+  {"nom":"Funeste","effet":"-25% PM ; Double les dégats mentaux ; 1D6, si 1, l'ennemi fait un jet d'affliction morale","surcout":"+100%"},
+  {"nom":"Célèste","effet":" -2 éclat ; Protège de l'éclat et si devrait devenir anomique 1D4 chance d'en être protégé","surcout":"+100%"},
+  {"nom":"Des Ombres","effet":"-25% PM et PV ; 1D6, si 1, un encaissement réussi devient une esquive","surcout":"+100%"},
+  {"nom":"Des Héros","effet":"-n×10 DIS ; +20% dans toutes les stats face aux êtres démoniaques.","surcout":"+100%"}
+]
\ No newline at end of file
diff --git a/public/jdr/effets-tenues/tech.json b/public/jdr/effets-tenues/tech.json
new file mode 100644
index 0000000..7c6b0f0
--- /dev/null
+++ b/public/jdr/effets-tenues/tech.json
@@ -0,0 +1,8 @@
+[
+  {"nom":"Biotechnologie","effet":"Ramène 1 PV/tour.","surcout":"+50%"},
+  {"nom":"Nanotechnologie","effet":"S'auto-répare de 1/partie","surcout":"+ 50%"},
+  {"nom":"Crystalline","effet":"Brise-Arme: 1/4 de faire perdre 1 points de dégat à une arme l'attaquant sur le physique","surcout":"+ 25%"},
+  {"nom":"Champs d'énergie","effet":"Les attaques perce-armure font moitié dégats","surcout":"+100%"},
+  {"nom":"Pare-balle","effet":"Anti-perce défense face aux armes à feux","surcout":"+25%"},
+  {"nom":"Anti-explosion","effet":"Encaisse les explosions","surcout":"+25%"}
+]
\ No newline at end of file
diff --git a/public/jdr/sonata.json b/public/jdr/sonata.json
index 9d95ff9..d585082 100644
--- a/public/jdr/sonata.json
+++ b/public/jdr/sonata.json
@@ -17,5 +17,7 @@
   ],
   "objects":["base"],
   "equipMains":["base", "arcs", "medieval-cac", "moderne"],
-  "effetsMains":["base", "tech"]
+  "effetsMains":["base", "tech"],
+  "tenues":["base","armures"],
+  "effetsTenues":["base", "tech"]
 }
\ No newline at end of file
diff --git a/public/jdr/tenues/armures.json b/public/jdr/tenues/armures.json
new file mode 100644
index 0000000..b199d5e
--- /dev/null
+++ b/public/jdr/tenues/armures.json
@@ -0,0 +1,6 @@
+[
+  {"nom":"Côte de maille","armure":4,"effet":"-10 % HAB","cout":750},
+  {"nom":"Armure d'apparat","armure":4,"effet":"-25 % DIS et HAB ; +20% dans les statistiques sociales en milieu riche","cout":1050},
+  {"nom":"Armure","armure":5,"effet":"-25 % DIS et HAB","cout":950},
+  {"nom":"Armure Lourde","armure":7,"effet":"-40 % DIS et HAB","cout":1200}
+]
\ No newline at end of file
diff --git a/public/jdr/tenues/base.json b/public/jdr/tenues/base.json
new file mode 100644
index 0000000..82ff4a9
--- /dev/null
+++ b/public/jdr/tenues/base.json
@@ -0,0 +1,15 @@
+[
+  {"nom":"Vêtements communs","armure":1,"effet":"","cout":200},
+  {"nom":"Vêtements confortables","armure":1,"effet":"+1 armure mentale","cout":300},
+  {"nom":"Tenue terrifiante","armure":1,"effet":"L'ennemi à +2% en échec critique","cout":300},
+  {"nom":"Tenue polaire","armure":1,"effet":"+20% pour résister au froid ; -20% pour résister au chaud","cout":300},
+  {"nom":"Tenue légère","armure":1,"effet":"+20% pour résister au chaud ; -20% pour résister au froid","cout":300},
+  {"nom":"Séduisante","armure":1,"effet":"+20% pour charmer","cout":300},
+  {"nom":"Tenue discrète","armure":1,"effet":"+20% en DIS dans un lieu sombre","cout":400},
+  {"nom":"Uniforme de faction","armure":1,"effet":"Permet de donner l'impression d'être un membre de cette faction si l'on est pas trop connu","cout":400},
+  {"nom":"Costard","armure":1,"effet":"+20% sur les reventes ; +20% risque de se faire attaquer dans les rencontre aléatoire","cout":800},
+  {"nom":"Tenue majestueuse","armure":1,"effet":"+20% dans les statistiques sociales en milieu riche","cout":600},
+  {"nom":"Tenue du Héros","armure":2,"effet":"+20% CHA","cout":600},
+  {"nom":"Tenue de voyage","armure":2,"effet":"+20% pour les exploration de grand espace","cout":600},
+  {"nom":"Tenue renforcée","armure":2,"effet":"","cout":400}
+]
\ No newline at end of file
diff --git a/public/rules/inventaire/tenues-effets.md b/public/rules/inventaire/tenues-effets.md
new file mode 100644
index 0000000..aa2b902
--- /dev/null
+++ b/public/rules/inventaire/tenues-effets.md
@@ -0,0 +1,3 @@
+## Effets de tenue
+
+Plusieurs effets peuvent être appliqués sur les tenues, affectant leur défense, etc.
diff --git a/public/rules/inventaire/tenues.md b/public/rules/inventaire/tenues.md
new file mode 100644
index 0000000..a54eb90
--- /dev/null
+++ b/public/rules/inventaire/tenues.md
@@ -0,0 +1,5 @@
+## Tenues
+
+Les tenues sont un équipement offrant protection et effets divers à votre personnage. Les personnages ne peuvent porter qu'une tenues à la fois, il peut être donc intéressant d'adapter sa tenue aux circonstances.
+
+### Liste des tenues
diff --git a/src/App.vue b/src/App.vue
index 6277a96..68d303a 100644
--- a/src/App.vue
+++ b/src/App.vue
@@ -4,13 +4,17 @@ import TopBar from "./components/layout/TopBar.vue";
 import SideBar from "./components/layout/SideBar.vue";
 import TableOfContent from "./components/layout/TableOfContent.vue";
 import { useConfigStore } from "./stores/config";
-import { onMounted } from "vue";
+import { onMounted, ref } from "vue";
 import axios from "axios";
 
 const store = useConfigStore();
+const loaded = ref(false);
 
 onMounted(() => {
-  axios.get(`/pelican.json`).then((response) => store.setConfig(response.data));
+  axios.get(`/pelican.json`).then((response) => {
+    store.setConfig(response.data);
+    loaded.value = true;
+  });
 });
 </script>
 
@@ -20,7 +24,7 @@ onMounted(() => {
     <SideBar />
     <div id="page">
       <div id="content" class="pt-1">
-        <RouterView />
+        <RouterView v-if="loaded" />
       </div>
     </div>
     <TableOfContent />
diff --git a/src/data/fields.ts b/src/data/fields.ts
index dd3194b..d69be9e 100644
--- a/src/data/fields.ts
+++ b/src/data/fields.ts
@@ -15,10 +15,17 @@ const equipMainsFields = [
   { key: "cout", label: "Cout" },
 ];
 
+const tenuesFields = [
+  { key: "nom", label: "Nom" },
+  { key: "effet", label: "Effet" },
+  { key: "armure", label: "Armure" },
+  { key: "cout", label: "cout" },
+];
+
 const effetsFields = [
   { key: "nom", label: "Nom" },
   { key: "effet", label: "Effet" },
   { key: "surcout", label: "Surcout" },
 ];
 
-export { objectFields, equipMainsFields, effetsFields };
+export { objectFields, equipMainsFields, tenuesFields, effetsFields };
diff --git a/src/types/JdrConfig.ts b/src/types/JdrConfig.ts
index 61c023e..758b5df 100644
--- a/src/types/JdrConfig.ts
+++ b/src/types/JdrConfig.ts
@@ -9,4 +9,6 @@ export default interface JdrConfig {
   objects: string[];
   equipMains: string[];
   effetsMains: string[];
+  tenues: string[];
+  effetsTenues: string[];
 }
diff --git a/src/views/EquipView.vue b/src/views/EquipView.vue
index c4c771d..e45494b 100644
--- a/src/views/EquipView.vue
+++ b/src/views/EquipView.vue
@@ -4,7 +4,7 @@ import { useConfigStore } from "@/stores/config";
 import { onMounted, computed } from "vue";
 import { useRoute } from "vue-router";
 import MarkdownFile from "../components/MarkdownFile.vue";
-import { equipMainsFields, effetsFields } from "@/data/fields";
+import { equipMainsFields, effetsFields, tenuesFields } from "@/data/fields";
 
 const store = useConfigStore();
 const route = useRoute();
@@ -20,23 +20,41 @@ const equipMains = computed(() => {
 const effetsMains = computed(() => {
   return store.jdrConfig?.effetsMains ?? [];
 });
+
+const tenues = computed(() => {
+  return store.jdrConfig?.tenues ?? [];
+});
+
+const effetsTenues = computed(() => {
+  return store.jdrConfig?.effetsTenues ?? [];
+});
 </script>
 
 <template>
   <main>
-    <MarkdownFile :path="`rules/inventaire/mains`">
+    <MarkdownFile :path="`rules/inventaire/mains`" :order="1">
       <DynTable
         :fields="equipMainsFields"
         :files="equipMains"
         category="mains"
       />
     </MarkdownFile>
-    <MarkdownFile :path="`rules/inventaire/mains-effets`">
+    <MarkdownFile :path="`rules/inventaire/mains-effets`" :order="2">
       <DynTable
         :fields="effetsFields"
         :files="effetsMains"
         category="effets-mains"
       />
     </MarkdownFile>
+    <MarkdownFile :path="`rules/inventaire/tenues`" :order="3">
+      <DynTable :fields="tenuesFields" :files="tenues" category="tenues" />
+    </MarkdownFile>
+    <MarkdownFile :path="`rules/inventaire/tenues-effets`" :order="4">
+      <DynTable
+        :fields="effetsFields"
+        :files="effetsTenues"
+        category="effets-tenues"
+      />
+    </MarkdownFile>
   </main>
 </template>

From d62bbceef9b5786eee2c5bb7b829c1456dd08398 Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Mon, 13 Feb 2023 21:47:02 +0100
Subject: [PATCH 14/27] improvement: separate Table and Renderer

---
 src/components/tableaux/DynTable.vue      | 124 +++-----------------
 src/components/tableaux/TableRenderer.vue | 132 ++++++++++++++++++++++
 2 files changed, 145 insertions(+), 111 deletions(-)
 create mode 100644 src/components/tableaux/TableRenderer.vue

diff --git a/src/components/tableaux/DynTable.vue b/src/components/tableaux/DynTable.vue
index d7a45b1..4fdc15d 100644
--- a/src/components/tableaux/DynTable.vue
+++ b/src/components/tableaux/DynTable.vue
@@ -1,9 +1,9 @@
 <script lang="ts" setup>
-import { computed, reactive, onMounted } from "vue";
-import PaginatedFilteredTable from "@/utils/tables/PaginatedFilteredTable";
-import type { TableField } from "@/utils/tables/types";
+import { ref, onMounted } from "vue";
+import type { TableField, TableItem } from "@/utils/tables/types";
 import type { PropType } from "vue";
 import axios from "axios";
+import TableRenderer from "./TableRenderer.vue";
 
 const props = defineProps({
   fields: {
@@ -20,21 +20,8 @@ const props = defineProps({
   },
 });
 
-const DEFAULT_MAX_ITEM_BY_PAGE = 10;
-
-const table = reactive(new PaginatedFilteredTable(DEFAULT_MAX_ITEM_BY_PAGE));
-
-const filtersFieldMap = computed(() => {
-  return table?.filteredTable?.filtersFieldMap;
-});
-
-const displayedFieldKeys = computed(() => {
-  return table?.filteredTable?.table.displayedFieldKeys;
-});
-
-const paginatedList = computed(() => {
-  return table?.items;
-});
+const toLoad = ref(1);
+const items = ref([] as TableItem[]);
 
 onMounted(() => {
   setTimeout(() => {
@@ -43,106 +30,21 @@ onMounted(() => {
 });
 
 function refresh() {
-  table.fields = props.fields;
+  toLoad.value = props.files.length;
   for (const file of props.files) {
     const listItems = `/jdr/${props.category}/${file}.json`;
     axios.get(listItems).then((response) => {
-      table.addItems(response.data);
-      table.currentPage = 0;
+      toLoad.value = toLoad.value - 1;
+      items.value = items.value.concat(response.data);
     });
   }
 }
-
-function switchFilter(filterSet: string | number, filterName: string | number) {
-  table.switchFilter(filterSet as string, filterName as string);
-}
-
-function removeFilter(filterSet: string | number) {
-  table.removeAllFilters(filterSet as string);
-}
-
-const currentPage = computed(() => {
-  return table?.currentPage;
-});
-
-const getTotalPage = computed(() => {
-  return table?.pageNumber;
-});
-
-function canGo(rel: number) {
-  return table?.canGo(rel);
-}
-
-function go(rel: number) {
-  table?.go(rel);
-}
 </script>
 
 <template>
-  <div class="small-text" v-for="(filter, key) in filtersFieldMap" :key="key">
-    <strong>{{ filter.title }} : </strong>
-    <button
-      v-for="(isTrue, filterName) in filter.filters"
-      :key="filterName"
-      class="btn-small mb-0"
-      :class="{ 'btn-grey': !isTrue, 'btn-primary': isTrue }"
-      @click="switchFilter(key, filterName)"
-    >
-      {{ filterName }}
-    </button>
-    <button class="btn-small btn-secondary mb-0" @click="removeFilter(key)">
-      Vider filtres
-    </button>
-  </div>
-  <table class="pb-0 table-auto">
-    <thead>
-      <tr>
-        <th v-for="field in fields" :key="field.key">
-          {{ field.label }}
-        </th>
-      </tr>
-    </thead>
-    <tbody>
-      <tr v-for="(item, index) of paginatedList" :key="index">
-        <td v-for="(key, index2) in displayedFieldKeys" :key="index2">
-          {{ item[key] }}
-        </td>
-      </tr>
-    </tbody>
-  </table>
-  <div class="d-flex f-between f-middle nextprevious small-text">
-    <div>
-      <strong class="btn m-0 pages pl-0">
-        Page {{ currentPage + 1 }} / {{ getTotalPage + 1 }}
-      </strong>
-    </div>
-
-    <div>
-      <button
-        class="btn btn-grey m-0 mr-1"
-        :class="{ 'bg-grey': !canGo(-1), 'btn-secondary': canGo(-1) }"
-        @click="go(-1)"
-      >
-        Page précédante
-      </button>
-      <button
-        class="btn btn-grey m-0"
-        :class="{ 'bg-grey': !canGo(1), 'btn-secondary': canGo(1) }"
-        @click="go(1)"
-      >
-        Page suivante
-      </button>
-    </div>
-  </div>
+  <TableRenderer
+    :fields="fields"
+    :items="items"
+    v-if="toLoad === 0"
+  ></TableRenderer>
 </template>
-
-<style lang="scss" scoped>
-.small-text {
-  font-size: 0.8rem;
-  padding-bottom: 0.5rem;
-}
-
-.pages {
-  font-weight: 600;
-}
-</style>
diff --git a/src/components/tableaux/TableRenderer.vue b/src/components/tableaux/TableRenderer.vue
new file mode 100644
index 0000000..7dc2839
--- /dev/null
+++ b/src/components/tableaux/TableRenderer.vue
@@ -0,0 +1,132 @@
+<script lang="ts" setup>
+import { computed, reactive, onMounted } from "vue";
+import PaginatedFilteredTable from "@/utils/tables/PaginatedFilteredTable";
+import type { TableField, TableItem } from "@/utils/tables/types";
+import type { PropType } from "vue";
+
+const props = defineProps({
+  fields: {
+    type: Array as PropType<TableField[]>,
+    default: () => [],
+  },
+  items: {
+    type: Array as PropType<TableItem[]>,
+    default: () => [],
+  },
+});
+
+const DEFAULT_MAX_ITEM_BY_PAGE = 10;
+
+const table = reactive(new PaginatedFilteredTable(DEFAULT_MAX_ITEM_BY_PAGE));
+
+const filtersFieldMap = computed(() => {
+  return table?.filteredTable?.filtersFieldMap;
+});
+
+const displayedFieldKeys = computed(() => {
+  return table?.filteredTable?.table.displayedFieldKeys;
+});
+
+const paginatedList = computed(() => {
+  return table?.items;
+});
+
+onMounted(() => {
+  table.fields = props.fields;
+  table.addItems(props.items);
+  table.currentPage = 0;
+});
+
+function switchFilter(filterSet: string | number, filterName: string | number) {
+  table.switchFilter(filterSet as string, filterName as string);
+}
+
+function removeFilter(filterSet: string | number) {
+  table.removeAllFilters(filterSet as string);
+}
+
+const currentPage = computed(() => {
+  return table?.currentPage;
+});
+
+const getTotalPage = computed(() => {
+  return table?.pageNumber;
+});
+
+function canGo(rel: number) {
+  return table?.canGo(rel);
+}
+
+function go(rel: number) {
+  table?.go(rel);
+}
+</script>
+
+<template>
+  <div class="small-text" v-for="(filter, key) in filtersFieldMap" :key="key">
+    <strong>{{ filter.title }} : </strong>
+    <button
+      v-for="(isTrue, filterName) in filter.filters"
+      :key="filterName"
+      class="btn-small mb-0"
+      :class="{ 'btn-grey': !isTrue, 'btn-primary': isTrue }"
+      @click="switchFilter(key, filterName)"
+    >
+      {{ filterName }}
+    </button>
+    <button class="btn-small btn-secondary mb-0" @click="removeFilter(key)">
+      Vider filtres
+    </button>
+  </div>
+  <table class="pb-0 table-auto">
+    <thead>
+      <tr>
+        <th v-for="field in fields" :key="field.key">
+          {{ field.label }}
+        </th>
+      </tr>
+    </thead>
+    <tbody>
+      <tr v-for="(item, index) of paginatedList" :key="index">
+        <td v-for="(key, index2) in displayedFieldKeys" :key="index2">
+          {{ item[key] }}
+        </td>
+      </tr>
+    </tbody>
+  </table>
+  <div class="d-flex f-between f-middle nextprevious small-text">
+    <div>
+      <strong class="btn m-0 pages pl-0">
+        Page {{ currentPage + 1 }} / {{ getTotalPage + 1 }}
+      </strong>
+    </div>
+
+    <div>
+      <button
+        class="btn btn-grey m-0 mr-1"
+        :class="{ 'bg-grey': !canGo(-1), 'btn-secondary': canGo(-1) }"
+        @click="go(-1)"
+      >
+        Page précédante
+      </button>
+      <button
+        class="btn btn-grey m-0"
+        :class="{ 'bg-grey': !canGo(1), 'btn-secondary': canGo(1) }"
+        @click="go(1)"
+      >
+        Page suivante
+      </button>
+    </div>
+  </div>
+</template>
+
+<style lang="scss" scoped>
+.small-text {
+  font-size: 0.8rem;
+  padding-bottom: 0.5rem;
+}
+
+.pages {
+  font-weight: 600;
+}
+</style>

From e99da55f134843a65a299f2d850487e67bd0efe2 Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Mon, 13 Feb 2023 21:50:11 +0100
Subject: [PATCH 15/27] fix: smaller text in table

---
 src/components/tableaux/TableRenderer.vue | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/components/tableaux/TableRenderer.vue b/src/components/tableaux/TableRenderer.vue
index 7dc2839..592b8c7 100644
--- a/src/components/tableaux/TableRenderer.vue
+++ b/src/components/tableaux/TableRenderer.vue
@@ -103,14 +103,14 @@ function go(rel: number) {
 
     <div>
       <button
-        class="btn btn-grey m-0 mr-1"
+        class="btn-grey btn-small m-0 mr-1"
         :class="{ 'bg-grey': !canGo(-1), 'btn-secondary': canGo(-1) }"
         @click="go(-1)"
       >
         Page précédante
       </button>
       <button
-        class="btn btn-grey m-0"
+        class="btn-grey btn-small m-0"
         :class="{ 'bg-grey': !canGo(1), 'btn-secondary': canGo(1) }"
         @click="go(1)"
       >
@@ -126,6 +126,10 @@ function go(rel: number) {
   padding-bottom: 0.5rem;
 }
 
+table {
+  font-size: 0.8rem;
+}
+
 .pages {
   font-weight: 600;
 }

From f066f064f4d80e92fb43d63e70a2790717ee8941 Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Tue, 14 Feb 2023 20:33:30 +0100
Subject: [PATCH 16/27] fix: better pagination

---
 src/components/tableaux/TableRenderer.vue     |  38 ++---
 .../tableaux/pagination/ElipsisPageButton.vue |   0
 .../tableaux/pagination/PageButton.vue        |  22 +++
 .../tableaux/pagination/PageList.vue          | 149 ++++++++++++++++++
 src/styles/mixins/_btns.scss                  |   3 -
 5 files changed, 180 insertions(+), 32 deletions(-)
 create mode 100644 src/components/tableaux/pagination/ElipsisPageButton.vue
 create mode 100644 src/components/tableaux/pagination/PageButton.vue
 create mode 100644 src/components/tableaux/pagination/PageList.vue

diff --git a/src/components/tableaux/TableRenderer.vue b/src/components/tableaux/TableRenderer.vue
index 592b8c7..31100cf 100644
--- a/src/components/tableaux/TableRenderer.vue
+++ b/src/components/tableaux/TableRenderer.vue
@@ -3,6 +3,7 @@ import { computed, reactive, onMounted } from "vue";
 import PaginatedFilteredTable from "@/utils/tables/PaginatedFilteredTable";
 import type { TableField, TableItem } from "@/utils/tables/types";
 import type { PropType } from "vue";
+import PageList from "./pagination/PageList.vue";
 
 const props = defineProps({
   fields: {
@@ -53,12 +54,8 @@ const getTotalPage = computed(() => {
   return table?.pageNumber;
 });
 
-function canGo(rel: number) {
-  return table?.canGo(rel);
-}
-
-function go(rel: number) {
-  table?.go(rel);
+function goTo(page: number) {
+  table.currentPage = page - 1;
 }
 </script>
 
@@ -94,29 +91,12 @@ function go(rel: number) {
       </tr>
     </tbody>
   </table>
-  <div class="d-flex f-between f-middle nextprevious small-text">
-    <div>
-      <strong class="btn m-0 pages pl-0">
-        Page {{ currentPage + 1 }} / {{ getTotalPage + 1 }}
-      </strong>
-    </div>
-
-    <div>
-      <button
-        class="btn-grey btn-small m-0 mr-1"
-        :class="{ 'bg-grey': !canGo(-1), 'btn-secondary': canGo(-1) }"
-        @click="go(-1)"
-      >
-        Page précédante
-      </button>
-      <button
-        class="btn-grey btn-small m-0"
-        :class="{ 'bg-grey': !canGo(1), 'btn-secondary': canGo(1) }"
-        @click="go(1)"
-      >
-        Page suivante
-      </button>
-    </div>
+  <div class="d-flex f-end">
+    <PageList
+      :current-page="currentPage + 1"
+      :page-nbr="getTotalPage + 1"
+      @set-page="goTo"
+    ></PageList>
   </div>
 </template>
 
diff --git a/src/components/tableaux/pagination/ElipsisPageButton.vue b/src/components/tableaux/pagination/ElipsisPageButton.vue
new file mode 100644
index 0000000..e69de29
diff --git a/src/components/tableaux/pagination/PageButton.vue b/src/components/tableaux/pagination/PageButton.vue
new file mode 100644
index 0000000..77d0b0d
--- /dev/null
+++ b/src/components/tableaux/pagination/PageButton.vue
@@ -0,0 +1,22 @@
+<script setup lang="ts">
+import { computed } from "vue";
+
+const props = defineProps<{
+  page: number;
+  currentPage: number;
+}>();
+
+const isPage = computed(() => {
+  return props.page === props.currentPage;
+});
+</script>
+
+<template>
+  <button
+    class="btn-small"
+    :class="{ 'btn-secondary': !isPage, 'bg-primary': isPage }"
+    :disabled="isPage"
+  >
+    {{ page }}
+  </button>
+</template>
diff --git a/src/components/tableaux/pagination/PageList.vue b/src/components/tableaux/pagination/PageList.vue
new file mode 100644
index 0000000..7439855
--- /dev/null
+++ b/src/components/tableaux/pagination/PageList.vue
@@ -0,0 +1,149 @@
+<script setup lang="ts">
+import { computed } from "vue";
+import PageButton from "./PageButton.vue";
+
+const PAGE_NUMBER = 7;
+
+const props = defineProps<{
+  pageNbr: number;
+  currentPage: number;
+}>();
+
+const emit = defineEmits(["setPage"]);
+
+const pageToDraw = computed(() => {
+  return Math.min(props.pageNbr, PAGE_NUMBER);
+});
+
+const isAtStart = computed(() => {
+  return props.currentPage < 4;
+});
+
+const isAtEnd = computed(() => {
+  return props.currentPage > props.pageNbr - 2;
+});
+
+function setPage(page: number) {
+  emit("setPage", page);
+}
+</script>
+
+<template>
+  <div>
+    <button
+      class="btn-small"
+      :disabled="currentPage <= 1"
+      :class="{ 'btn-secondary': currentPage > 1, 'bg-grey': currentPage <= 1 }"
+      @click="setPage(currentPage - 1)"
+    >
+      ←
+    </button>
+    <span v-if="pageNbr <= PAGE_NUMBER">
+      <v-for v-for="index in pageToDraw" :key="index">
+        <PageButton
+          @click="setPage(index)"
+          :current-page="currentPage"
+          :page="index"
+        ></PageButton>
+      </v-for>
+    </span>
+    <span v-else-if="isAtStart">
+      <PageButton
+        :current-page="currentPage"
+        :page="1"
+        @click="setPage(1)"
+      ></PageButton>
+      <PageButton
+        :current-page="currentPage"
+        :page="2"
+        @click="setPage(2)"
+      ></PageButton>
+      <PageButton
+        :current-page="currentPage"
+        :page="3"
+        @click="setPage(3)"
+      ></PageButton>
+      <PageButton
+        :current-page="currentPage"
+        :page="4"
+        @click="setPage(4)"
+      ></PageButton>
+      <PageButton
+        :current-page="currentPage"
+        :page="5"
+        @click="setPage(5)"
+      ></PageButton>
+      <button disabled class="btn-small bg-grey disabled">…</button>
+      <PageButton :current-page="currentPage" :page="pageNbr"></PageButton>
+    </span>
+    <span v-else-if="isAtEnd">
+      <PageButton
+        :current-page="currentPage"
+        :page="1"
+        @click="setPage(1)"
+      ></PageButton>
+      <button disabled class="btn-small bg-grey disabled">…</button>
+      <PageButton
+        :current-page="currentPage"
+        :page="pageNbr - 4"
+        @click="setPage(pageNbr - 4)"
+      ></PageButton>
+      <PageButton
+        :current-page="currentPage"
+        :page="pageNbr - 3"
+        @click="setPage(pageNbr - 3)"
+      ></PageButton>
+      <PageButton
+        :current-page="currentPage"
+        :page="pageNbr - 2"
+        @click="setPage(pageNbr - 2)"
+      ></PageButton>
+      <PageButton
+        :current-page="currentPage"
+        :page="pageNbr - 1"
+        @click="setPage(pageNbr - 1)"
+      ></PageButton>
+      <PageButton
+        :current-page="currentPage"
+        :page="pageNbr"
+        @click="setPage(pageNbr)"
+      ></PageButton>
+    </span>
+    <span v-else>
+      <PageButton
+        :current-page="currentPage"
+        :page="1"
+        @click="setPage(1)"
+      ></PageButton>
+      <button disabled class="btn-small bg-grey disabled">…</button>
+      <PageButton
+        :current-page="currentPage"
+        :page="currentPage - 1"
+        @click="setPage(currentPage - 1)"
+      ></PageButton>
+      <PageButton :current-page="currentPage" :page="currentPage"></PageButton>
+      <PageButton
+        :current-page="currentPage"
+        :page="currentPage + 1"
+        @click="setPage(currentPage + 1)"
+      ></PageButton>
+      <button disabled class="btn-small bg-grey disabled">…</button>
+      <PageButton
+        :current-page="currentPage"
+        :page="pageNbr"
+        @click="setPage(pageNbr)"
+      ></PageButton>
+    </span>
+    <button
+      class="btn-small"
+      :disabled="currentPage >= pageNbr"
+      :class="{
+        'btn-secondary': currentPage < pageNbr,
+        'bg-grey': currentPage >= pageNbr,
+      }"
+      @click="setPage(currentPage + 1)"
+    >
+      →
+    </button>
+  </div>
+</template>
diff --git a/src/styles/mixins/_btns.scss b/src/styles/mixins/_btns.scss
index 46e25e2..715491f 100644
--- a/src/styles/mixins/_btns.scss
+++ b/src/styles/mixins/_btns.scss
@@ -19,9 +19,6 @@
 
 @mixin button-hover() {
   transition: background-color .2s, border .2s, box-shadow .2s, color .2s;
-  &:hover, &:active, &:focus {
-      background-color:transparent;
-  }
 
   &:focus {
     outline: none;

From 64d93b9ef7c72d6d2f3d5f4e3436fd9f05a7fdc2 Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Thu, 16 Feb 2023 07:27:21 +0100
Subject: [PATCH 17/27] fix: use a button to handle tags

---
 src/components/tableaux/TableRenderer.vue |  24 ++---
 src/components/tableaux/TagList.vue       | 112 ++++++++++++++++++++++
 2 files changed, 122 insertions(+), 14 deletions(-)
 create mode 100644 src/components/tableaux/TagList.vue

diff --git a/src/components/tableaux/TableRenderer.vue b/src/components/tableaux/TableRenderer.vue
index 31100cf..ed14dc6 100644
--- a/src/components/tableaux/TableRenderer.vue
+++ b/src/components/tableaux/TableRenderer.vue
@@ -4,6 +4,7 @@ import PaginatedFilteredTable from "@/utils/tables/PaginatedFilteredTable";
 import type { TableField, TableItem } from "@/utils/tables/types";
 import type { PropType } from "vue";
 import PageList from "./pagination/PageList.vue";
+import TagList from "./TagList.vue";
 
 const props = defineProps({
   fields: {
@@ -60,20 +61,15 @@ function goTo(page: number) {
 </script>
 
 <template>
-  <div class="small-text" v-for="(filter, key) in filtersFieldMap" :key="key">
-    <strong>{{ filter.title }} : </strong>
-    <button
-      v-for="(isTrue, filterName) in filter.filters"
-      :key="filterName"
-      class="btn-small mb-0"
-      :class="{ 'btn-grey': !isTrue, 'btn-primary': isTrue }"
-      @click="switchFilter(key, filterName)"
-    >
-      {{ filterName }}
-    </button>
-    <button class="btn-small btn-secondary mb-0" @click="removeFilter(key)">
-      Vider filtres
-    </button>
+  <div class="d-flex f-between">
+    <div></div>
+    <div class="d-flex f-end">
+      <TagList
+        :filtersFieldMap="filtersFieldMap"
+        @remove-filter="removeFilter"
+        @switch-filter="switchFilter"
+      ></TagList>
+    </div>
   </div>
   <table class="pb-0 table-auto">
     <thead>
diff --git a/src/components/tableaux/TagList.vue b/src/components/tableaux/TagList.vue
new file mode 100644
index 0000000..5053b37
--- /dev/null
+++ b/src/components/tableaux/TagList.vue
@@ -0,0 +1,112 @@
+<script lang="ts" setup>
+import type { FilterFieldsMap } from "@/utils/tables/types";
+import { ref, defineProps, computed } from "vue";
+
+const props = defineProps<{
+  filtersFieldMap: FilterFieldsMap;
+}>();
+
+const emit = defineEmits(["switchFilter", "removeFilter"]);
+
+const computedFieldMap = computed(() => {
+  return props.filtersFieldMap ?? [];
+});
+
+const haveElement = computed(() => {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  for (const _key in props.filtersFieldMap) {
+    return true;
+  }
+  return false;
+});
+
+const tagNumber = computed(() => {
+  var i = 0;
+  for (const key in props.filtersFieldMap) {
+    const filters = props.filtersFieldMap[key].filters;
+    for (const key2 in filters) {
+      if (filters[key2] === true) {
+        i++;
+      }
+    }
+  }
+  return i;
+});
+
+const showPopover = ref(false);
+
+function switchFilter(filterSet: string | number, filterName: string | number) {
+  emit("switchFilter", filterSet as string, filterName as string);
+}
+
+function removeFilter(filterSet: string | number) {
+  emit("removeFilter", filterSet as string);
+}
+</script>
+
+<template>
+  <div class="taglist" v-if="haveElement">
+    <button class="btn-small btn-outline" @click="showPopover = !showPopover">
+      <strong>Tags</strong>
+      <span
+        class="badge pills"
+        :class="{ 'bg-grey': tagNumber <= 0, 'bg-secondary': tagNumber > 0 }"
+        >{{ tagNumber }} tag(s)</span
+      >
+    </button>
+    <div class="card menu fg-dark" v-if="showPopover">
+      <div
+        class="small-text"
+        v-for="(filter, key) in computedFieldMap"
+        :key="key"
+      >
+        <p class="m-0 p-0">
+          <strong>{{ filter.title }} : </strong>
+        </p>
+        <div>
+          <button
+            v-for="(isTrue, filterName) in filter.filters"
+            :key="filterName"
+            class="btn-small mb-0"
+            :class="{ 'btn-grey': !isTrue, 'btn-primary': isTrue }"
+            @click="switchFilter(key, filterName)"
+          >
+            {{ filterName }}
+          </button>
+          <button class="btn-small btn-danger mb-0" @click="removeFilter(key)">
+            Vider filtres
+          </button>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style lang="scss" scoped>
+.taglist {
+  position: relative;
+}
+
+.card {
+  position: absolute;
+  width: 480px;
+  box-shadow: 0px 1px 1px 1px rgba(0, 0, 0, 0.3);
+  background-color: white;
+  right: 0;
+}
+
+.btn-outline {
+  border: 1px solid rgba(0, 0, 0, 0.2);
+  &:hover {
+    background-color: rgba(0, 0, 0, 0.05);
+  }
+  margin-bottom: 0.5rem;
+  margin-left: 0;
+  margin-right: 0;
+}
+
+.badge {
+  font-size: 0.8em;
+  border-radius: 999px;
+}
+</style>

From f559e7cd5a750cf7f47eff6a24921c39009c331d Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Thu, 16 Feb 2023 07:46:47 +0100
Subject: [PATCH 18/27] fix: fix table style

---
 src/components/tableaux/TableRenderer.vue     |  5 ++-
 .../tableaux/pagination/PageButton.vue        |  2 +-
 .../tableaux/pagination/PageList.vue          |  8 ++--
 src/styles/components/_tables.scss            | 40 ++++++++++++++-----
 src/styles/custom/_article.scss               | 18 ++++++++-
 5 files changed, 55 insertions(+), 18 deletions(-)

diff --git a/src/components/tableaux/TableRenderer.vue b/src/components/tableaux/TableRenderer.vue
index ed14dc6..c6b061f 100644
--- a/src/components/tableaux/TableRenderer.vue
+++ b/src/components/tableaux/TableRenderer.vue
@@ -71,7 +71,7 @@ function goTo(page: number) {
       ></TagList>
     </div>
   </div>
-  <table class="pb-0 table-auto">
+  <table class="mb-0 table-auto">
     <thead>
       <tr>
         <th v-for="field in fields" :key="field.key">
@@ -102,8 +102,9 @@ function goTo(page: number) {
   padding-bottom: 0.5rem;
 }
 
-table {
+table:not(:last-child) {
   font-size: 0.8rem;
+  margin-bottom: 0.5rem;
 }
 
 .pages {
diff --git a/src/components/tableaux/pagination/PageButton.vue b/src/components/tableaux/pagination/PageButton.vue
index 77d0b0d..a5bd287 100644
--- a/src/components/tableaux/pagination/PageButton.vue
+++ b/src/components/tableaux/pagination/PageButton.vue
@@ -13,7 +13,7 @@ const isPage = computed(() => {
 
 <template>
   <button
-    class="btn-small"
+    class="btn-small btn-pagination"
     :class="{ 'btn-secondary': !isPage, 'bg-primary': isPage }"
     :disabled="isPage"
   >
diff --git a/src/components/tableaux/pagination/PageList.vue b/src/components/tableaux/pagination/PageList.vue
index 7439855..4c476d9 100644
--- a/src/components/tableaux/pagination/PageList.vue
+++ b/src/components/tableaux/pagination/PageList.vue
@@ -31,7 +31,7 @@ function setPage(page: number) {
 <template>
   <div>
     <button
-      class="btn-small"
+      class="btn-small btn-navig"
       :disabled="currentPage <= 1"
       :class="{ 'btn-secondary': currentPage > 1, 'bg-grey': currentPage <= 1 }"
       @click="setPage(currentPage - 1)"
@@ -39,13 +39,13 @@ function setPage(page: number) {
       ←
     </button>
     <span v-if="pageNbr <= PAGE_NUMBER">
-      <v-for v-for="index in pageToDraw" :key="index">
+      <span v-for="index in pageToDraw" :key="index">
         <PageButton
           @click="setPage(index)"
           :current-page="currentPage"
           :page="index"
         ></PageButton>
-      </v-for>
+      </span>
     </span>
     <span v-else-if="isAtStart">
       <PageButton
@@ -135,7 +135,7 @@ function setPage(page: number) {
       ></PageButton>
     </span>
     <button
-      class="btn-small"
+      class="btn-small btn-navig"
       :disabled="currentPage >= pageNbr"
       :class="{
         'btn-secondary': currentPage < pageNbr,
diff --git a/src/styles/components/_tables.scss b/src/styles/components/_tables.scss
index 0e6e341..0edb789 100644
--- a/src/styles/components/_tables.scss
+++ b/src/styles/components/_tables.scss
@@ -4,26 +4,46 @@
 
 table {
   border-collapse: collapse;
+  border-spacing: 0;
   &:not(:last-child) {
     margin-bottom: 1.5rem;
   }
 }
 
 th, td {
-  border:1px solid rgba(0,0,0,0.2);
-  padding:0;
+  padding: 0.325rem;
+  border:0;
   margin:0;
 }
 
 th {
   vertical-align: center;
-  text-align: center;
-}
-
-th, td {
-  padding: 0.325em;
-}
-
-th  {
   font-weight: $fontweight_hyper;
+  background-color:$color-primary;
+  color:white;
 }
+
+td {
+  background-color:$color-background-alt;
+  tr:nth-child(even) & {
+    background-color: darken($color-background-alt, 7.5%);
+  }
+}
+
+thead {
+  th:first-child {
+    border-top-left-radius: 10px;
+  }
+
+  th:last-child {
+    border-top-right-radius: 10px;
+  }
+}
+
+tr:last-child td:first-child {
+  border-bottom-left-radius: 10px;
+}
+
+tr:last-child td:last-child {
+  border-bottom-right-radius: 10px;
+}
\ No newline at end of file
diff --git a/src/styles/custom/_article.scss b/src/styles/custom/_article.scss
index 75ca8db..0b5cd05 100644
--- a/src/styles/custom/_article.scss
+++ b/src/styles/custom/_article.scss
@@ -8,12 +8,28 @@ article .table-auto table, table.table-auto {
     table-layout: auto;
 }
 
-article table {
+table {
     display: table;
     width: 100%;
     table-layout: fixed;
 }
 
+.btn-pagination, .btn-navig {
+    margin:0;
+    border-radius: 0;
+    width: 2rem;
+}
+
+.btn-navig:first-child {
+    border-top-left-radius: $btn-radius;
+    border-bottom-left-radius: $btn-radius;
+}
+
+.btn-navig:last-child {
+    border-top-right-radius: $btn-radius;
+    border-bottom-right-radius: $btn-radius;
+}
+
 article th {
     height: 34px;
 }

From 2ff9638f49f2f4c082fb2b1c37ff562d20260042 Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Thu, 16 Feb 2023 07:49:56 +0100
Subject: [PATCH 19/27] fix: fix the dice table

---
 src/styles/components/_tables.scss | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/styles/components/_tables.scss b/src/styles/components/_tables.scss
index 0edb789..c431fc9 100644
--- a/src/styles/components/_tables.scss
+++ b/src/styles/components/_tables.scss
@@ -38,6 +38,20 @@ thead {
   th:last-child {
     border-top-right-radius: 10px;
   }
+
+  &:last-child {
+    th {
+      text-align: center;
+      &:first-child {
+        border-bottom-left-radius: 10px;
+      }
+    
+      &:last-child {
+        border-bottom-right-radius: 10px;
+      }
+
+    }
+  }
 }
 
 tr:last-child td:first-child {

From dafd9fe325ff41bb9d897d1e9893f43349ecaf9a Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Thu, 16 Feb 2023 07:59:39 +0100
Subject: [PATCH 20/27] fix: correction d'une regression sur le render

---
 src/components/markdown/MarkdownRender.vue | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/components/markdown/MarkdownRender.vue b/src/components/markdown/MarkdownRender.vue
index 67a6247..8502364 100644
--- a/src/components/markdown/MarkdownRender.vue
+++ b/src/components/markdown/MarkdownRender.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { ref, onMounted, onBeforeUpdate } from "vue";
+import { ref, onMounted, onBeforeUpdate, watch } from "vue";
 import { marked } from "marked";
 import { useTocStore } from "../../stores/toc";
 
@@ -94,6 +94,10 @@ function render() {
   }
 }
 
+function forceRender(markdown: string) {
+  htmlContent.value = marked.parse(markdown);
+}
+
 onMounted(() => {
   render();
 });
@@ -101,6 +105,13 @@ onMounted(() => {
 onBeforeUpdate(() => {
   render();
 });
+
+watch(
+  () => props.markdown,
+  (newMd) => {
+    forceRender(newMd);
+  }
+);
 </script>
 
 <template>

From 0095fb9224cb253c2363ca1ff179c3b01b89b533 Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Sat, 18 Feb 2023 11:17:53 +0100
Subject: [PATCH 21/27] feat: accessoire en tableau

---
 public/jdr/accessoires/base.json         | 18 ++++++++++++++++
 public/jdr/accessoires/cristaleclat.json |  7 ++++++
 public/jdr/accessoires/eclat.json        |  7 ++++++
 public/jdr/cartomancia.json              |  3 ++-
 public/jdr/core.json                     |  3 ++-
 public/jdr/sonata.json                   |  3 ++-
 public/rules/inventaire/accessoires.md   |  3 +++
 public/rules/magie/eclat.md              | 27 ------------------------
 src/data/fields.ts                       | 14 +++++++++++-
 src/types/JdrConfig.ts                   |  1 +
 src/views/EquipView.vue                  | 18 +++++++++++++++-
 11 files changed, 72 insertions(+), 32 deletions(-)
 create mode 100644 public/jdr/accessoires/base.json
 create mode 100644 public/jdr/accessoires/cristaleclat.json
 create mode 100644 public/jdr/accessoires/eclat.json
 create mode 100644 public/rules/inventaire/accessoires.md

diff --git a/public/jdr/accessoires/base.json b/public/jdr/accessoires/base.json
new file mode 100644
index 0000000..381230c
--- /dev/null
+++ b/public/jdr/accessoires/base.json
@@ -0,0 +1,18 @@
+[
+  {"nom":"Faux mouscle", "effet":"+15 en FOR", "cout":650},
+  {"nom":"Bracelet de santé", "effet":"+15 en CON", "cout":650},
+  {"nom":"Chaussures de courses", "effet":"+15 en HAB", "cout":650},
+  {"nom":"Blouse intellectuelle", "effet":"+15 en INT", "cout":650},
+  {"nom":"Medaillon de philosophe", "effet":"+15 en SAG", "cout":650},
+  {"nom":"Porte-clef en peluche anti-stress", "effet":"+15 en VOL", "cout":650},
+  {"nom":"Cape de héros", "effet":"+15 en CHA", "cout":650},
+  {"nom":"Masque de voleur", "effet":"+15 en DIS", "cout":650},
+  {"nom":"Collier mignon", "effet":"+15 en REL", "cout":650},
+  {"nom":"Monocle ultime", "effet":"+15 en PER", "cout":650},
+  {"nom":"Débardeur d'acier", "effet":"+3 armure physique", "cout":850},
+  {"nom":"Joli clochette", "effet":"+1 armure spéciale", "cout":1050},
+  {"nom":"Accessoire stylé", "effet":"+1 armure morale", "cout":850},
+  {"nom":"Lunettes Blindées", "effet":"Protège de tout malus en perception", "cout":1050},
+  {"nom":"Masque de terreur", "effet":"En cas de jet de panique, 1D4. Si 4, un allié fait aussi un jet de panique. Sinon, un ennemi le fait", "cout":1500},
+  {"nom":"Slip divin", "effet":"+20 aux jets de survies", "cout":2550}
+]
\ No newline at end of file
diff --git a/public/jdr/accessoires/cristaleclat.json b/public/jdr/accessoires/cristaleclat.json
new file mode 100644
index 0000000..d0954fe
--- /dev/null
+++ b/public/jdr/accessoires/cristaleclat.json
@@ -0,0 +1,7 @@
+[
+  {"nom":"Mini-cristal à éclat", "effet":"Réserve de 5 éclat. Peut être rechargé pour un cout de 10.", "cout":100},
+  {"nom":"Petit cristal à éclat", "effet":"Réserve de 10 éclat. Peut être rechargé pour un cout de 20.", "cout":200},
+  {"nom":"Cristal à éclat", "effet":"Réserve de 20 éclat. Peut être rechargé pour un cout de 50.", "cout":500},
+  {"nom":"Grand cristal à éclat", "effet":"Réserve de 35 éclat. Peut être rechargé pour un cout de 100.", "cout":1000},
+  {"nom":"Cristal à éclat géante", "effet":"Réserve de 50 éclat. Peut être rechargé pour un cout de 250.", "cout":2500}
+]
\ No newline at end of file
diff --git a/public/jdr/accessoires/eclat.json b/public/jdr/accessoires/eclat.json
new file mode 100644
index 0000000..def44e7
--- /dev/null
+++ b/public/jdr/accessoires/eclat.json
@@ -0,0 +1,7 @@
+[
+  {"nom":"Mini-batterie à éclat", "effet":"Réserve de 5 éclat. Peut être rechargé pour un cout de 10.", "cout":100},
+  {"nom":"Petite batterie à éclat", "effet":"Réserve de 10 éclat. Peut être rechargé pour un cout de 20.", "cout":200},
+  {"nom":"Batterie à éclat", "effet":"Réserve de 20 éclat. Peut être rechargé pour un cout de 50.", "cout":500},
+  {"nom":"Grande batterie à éclat", "effet":"Réserve de 35 éclat. Peut être rechargé pour un cout de 100.", "cout":1000},
+  {"nom":"Batterie à éclat géante", "effet":"Réserve de 50 éclat. Peut être rechargé pour un cout de 250.", "cout":2500}
+]
\ No newline at end of file
diff --git a/public/jdr/cartomancia.json b/public/jdr/cartomancia.json
index c5f5c4b..6de88e1 100644
--- a/public/jdr/cartomancia.json
+++ b/public/jdr/cartomancia.json
@@ -9,5 +9,6 @@
   "equipMains":["base", "arcs", "medieval-cac", "medieval-feu", "baguette"],
   "effetsMains":["base", "magique"],
   "tenues":["base","armures"],
-  "effetsTenues":["base", "magique"]
+  "effetsTenues":["base", "magique"],
+  "accessoires":["base", "cristaleclat"]
 }
\ No newline at end of file
diff --git a/public/jdr/core.json b/public/jdr/core.json
index 21f6902..87e156e 100644
--- a/public/jdr/core.json
+++ b/public/jdr/core.json
@@ -9,5 +9,6 @@
   "equipMains":["base", "arcs"],
   "effetsMains":["base"],
   "tenues":["base","armures"],
-  "effetsTenues":["base"]
+  "effetsTenues":["base"],
+  "accessoires":["base", "eclat"]
 }
\ No newline at end of file
diff --git a/public/jdr/sonata.json b/public/jdr/sonata.json
index d585082..641484f 100644
--- a/public/jdr/sonata.json
+++ b/public/jdr/sonata.json
@@ -19,5 +19,6 @@
   "equipMains":["base", "arcs", "medieval-cac", "moderne"],
   "effetsMains":["base", "tech"],
   "tenues":["base","armures"],
-  "effetsTenues":["base", "tech"]
+  "effetsTenues":["base", "tech"],
+  "accessoires":["base"]
 }
\ No newline at end of file
diff --git a/public/rules/inventaire/accessoires.md b/public/rules/inventaire/accessoires.md
new file mode 100644
index 0000000..3d9bfec
--- /dev/null
+++ b/public/rules/inventaire/accessoires.md
@@ -0,0 +1,3 @@
+## Accessoires
+
+Les accessoires sont des équipements aux effets divers, qui sont limités à deux par personnages.
\ No newline at end of file
diff --git a/public/rules/magie/eclat.md b/public/rules/magie/eclat.md
index 9ea7c28..d0fb5b7 100644
--- a/public/rules/magie/eclat.md
+++ b/public/rules/magie/eclat.md
@@ -9,30 +9,3 @@ Il est à noter que l'éclat est grandement facultatif dans Pélican. Il existe
 - Limitation du nombre d'utilisation par partie/combat
 - Système de "charges" de sortilege
 - Système de cooldown
-
-
-## Batteries à éclat
-
-Si l'éclat est limité à 10 points (hors exception) par personnage, il est possible d'obtenir plus d'éclat à l'aide d'objet spécifique, ce qui est notamment utile pour effectuer les attaques les plus puissantes.
-
-Ces apports d'éclat supplémentaire ne sont pas cumulables, et ne se régénère pas naturellement.
-
-### Les différents niveaux de réserve d'éclat
-
-| Niveau | Contenance | Prix achat | Prix recharge |
-|:------:|:----------:|:----------:|:-------------:|
-| 1 | 5 | 100 | 10 |
-| 2 | 10 | 200 | 20 |
-| 3 | 20 | 500 | 50 |
-| 4 | 35 | 1000 | 100 |
-| 5 | 50 | 2500 | 250 |
-
-### Recharger sa réserve d'éclat
-
-Le rechargement de sa réserve d'éclat peut se faire de plusieurs manière.
-
-- L'achat où la récupération de *recharge d'éclat*, tel que les perles blanches.
-
-- Le remplissage (payant) de la recharge. Il n'est pas possible de remplir partiellement la réserve d'éclat, seulement entièrement. Le prix est le même que votre batterie soit vide ou à moitié remplie.
-
-- Certains lieu dans les JDR peuvent aussi permettre de la remplir d'autres moyens
diff --git a/src/data/fields.ts b/src/data/fields.ts
index d69be9e..9f11412 100644
--- a/src/data/fields.ts
+++ b/src/data/fields.ts
@@ -28,4 +28,16 @@ const effetsFields = [
   { key: "surcout", label: "Surcout" },
 ];
 
-export { objectFields, equipMainsFields, tenuesFields, effetsFields };
+const accessoiresFields = [
+  { key: "nom", label: "Nom" },
+  { key: "effet", label: "Effet" },
+  { key: "cout", label: "Cout" },
+];
+
+export {
+  objectFields,
+  equipMainsFields,
+  tenuesFields,
+  effetsFields,
+  accessoiresFields,
+};
diff --git a/src/types/JdrConfig.ts b/src/types/JdrConfig.ts
index 758b5df..dcfd755 100644
--- a/src/types/JdrConfig.ts
+++ b/src/types/JdrConfig.ts
@@ -11,4 +11,5 @@ export default interface JdrConfig {
   effetsMains: string[];
   tenues: string[];
   effetsTenues: string[];
+  accessoires: string[];
 }
diff --git a/src/views/EquipView.vue b/src/views/EquipView.vue
index e45494b..146eb3b 100644
--- a/src/views/EquipView.vue
+++ b/src/views/EquipView.vue
@@ -4,7 +4,12 @@ import { useConfigStore } from "@/stores/config";
 import { onMounted, computed } from "vue";
 import { useRoute } from "vue-router";
 import MarkdownFile from "../components/MarkdownFile.vue";
-import { equipMainsFields, effetsFields, tenuesFields } from "@/data/fields";
+import {
+  equipMainsFields,
+  effetsFields,
+  tenuesFields,
+  accessoiresFields,
+} from "@/data/fields";
 
 const store = useConfigStore();
 const route = useRoute();
@@ -28,6 +33,10 @@ const tenues = computed(() => {
 const effetsTenues = computed(() => {
   return store.jdrConfig?.effetsTenues ?? [];
 });
+
+const accessoires = computed(() => {
+  return store.jdrConfig?.accessoires ?? [];
+});
 </script>
 
 <template>
@@ -56,5 +65,12 @@ const effetsTenues = computed(() => {
         category="effets-tenues"
       />
     </MarkdownFile>
+    <MarkdownFile :path="`rules/inventaire/accessoires`" :order="5">
+      <DynTable
+        :fields="accessoiresFields"
+        :files="accessoires"
+        category="accessoires"
+      />
+    </MarkdownFile>
   </main>
 </template>

From c68ae3d8ce43b9f59d01e67056c2edef9b95693a Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Sat, 18 Feb 2023 11:22:40 +0100
Subject: [PATCH 22/27] =?UTF-8?q?chore:=20suppression=20tableau=20r=C3=A9s?=
 =?UTF-8?q?istence?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 public/rules/magie/elements.md | 46 ++--------------------------------
 1 file changed, 2 insertions(+), 44 deletions(-)

diff --git a/public/rules/magie/elements.md b/public/rules/magie/elements.md
index fed67d9..36bf91b 100644
--- a/public/rules/magie/elements.md
+++ b/public/rules/magie/elements.md
@@ -8,51 +8,9 @@ En règle général, les éléments n’aiment pas les effets de terrains de l
 
 Certains personnages ou créatures peuvent avoir des **faiblesses** ou des **résistances** élémentaires.
 
-Pour chaque résistance, un personnage ne se prendra que x0.5 dégâts par une attaque de l'élément en question, tandis que pour chaque faiblesse, le personnage se prendra x2 dégâts.
+Pour chaque résistance, un personnage ne se prendra que la moitié des dégâts par une attaque de l'élément en question, tandis que pour chaque faiblesse, le personnage se prendra deux fois les dégâts. 
 
-### Groupe de créatures et éléments
-
-#### Créature biologiques
-
-| Créatures | Spécificités | Faiblesses | Résistances | Immunité |
-|:---------:|:------------:|:----------:|:-----------:|:--------:|
-| Humanoïdes | Peut manier des armes |  |  | |
-| Bêtes | Des griffes et des crocs | Metal, Chaos, Glace | Air | |
-| Reptiles |  | Glace, Ombre | Feu, Lumière | |
-| Aquatique | Peuvent respirer sous l'eau | Foudre, Végétal | Eau, Feu | |
-| Végétaux | C dé salad lol | Feu, Metal, Poison | Eau, Végétal | |
-| Insectes | | Terre, Feu, Glace | Ordre | |
-| Aerien | | Air, Glace | Terre, Espace | |
-
-#### Créature non-biologique
-
-| Créatures | Spécificités | Faiblesses | Résistances | Immunité |
-|:---------:|:------------:|:----------:|:-----------:|:--------:|
-| Machines | Ne sont pas soumis aux besoins vitaux normaux | Eau, Foudre, Chaos | Métal, Végétal, Énergie | Poison |
-| Minéraloïdes | Armure naturelle élevée | Eau, Temps | Foudre, Feu, Air | Poison |
-| Créature de glace | | Feu, Lumière, Énergie | Glace | |
-| Volutes | Créatures gazeuses | Végétal, Air, Foudre | Terre, Métal, Temps | Poison |
-| Gelatineux | Créatures liquides et semi-liquide | Métal, Végétal, Son | Force, Poison, Eau | |
-| Feufolets | Créatures de feu | Eau, Terre | Glace | Feu |
-
-#### Créature magique
-
-| Créatures | Spécificités | Faiblesses | Résistances | Immunité |
-|:---------:|:------------:|:----------:|:-----------:|:--------:|
-| Démons | Liés au chaos | Ordre, Lumière | Chaos, Ombre | |
-| Mort-vivant | Des corps maintenu par la magie | Lumière | Ombre | |
-| Parasite | Peuvent parasiter d'autres créatures | Feu, Ordre | Végétal | Chaos |
-| Calorique | Créatures d'énergie pure | | | Poison |
-| Psychiques | Créatures avec une forte puissance mentales | Ombre, Force, Son | Esprit | |
-| Âmes | Des êtres d'esprit, sans corps | Tout ce qui est métaphysique, Éclat | Son, Esprit | Tout ce qui est physique, Force, Poison |
-
-#### Créature paradoxales
-
-| Créatures | Spécificités | Faiblesses | Résistances | Immunité |
-|:---------:|:------------:|:----------:|:-----------:|:--------:|
-| Titans | Peuvent être lié élémentairement | *Divers* + Éclat | *Divers* | *Divers* |
-| Effacés | Liés au néant | Énergie, Éclat | Chaos, Ombre | Néant |
-| Céleste | Lié à l'ordre | Ombre, Chaos | Lumière, Énergie, Ordre | |
+Généralement, une créature à entre zero et deux faiblesses/résistences.
 
 ## Éléments physiques
 

From c1c98180aaf9cb66f5e300dede0e7bf36cb40ccf Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Sat, 18 Feb 2023 16:32:48 +0100
Subject: [PATCH 23/27] feat: portage elements vers tableaux

---
 public/jdr/cartomancia.json           |   3 +-
 public/jdr/core.json                  |   3 +-
 public/jdr/elements/base.json         |  10 ++
 public/jdr/elements/metaphysique.json |  10 ++
 public/jdr/elements/paradoxe.json     |   5 +
 public/jdr/elements/pseudo.json       |   6 +
 public/jdr/sonata.json                |   3 +-
 public/pelican.json                   |   4 +-
 public/rules/magie/elements.md        | 158 ++------------------------
 public/rules/magie/terrains.md        |   1 +
 src/data/fields.ts                    |  17 +++
 src/router/index.ts                   |   5 +
 src/types/JdrConfig.ts                |   1 +
 src/views/ElementsView.vue            |  38 +++++++
 14 files changed, 108 insertions(+), 156 deletions(-)
 create mode 100644 public/jdr/elements/base.json
 create mode 100644 public/jdr/elements/metaphysique.json
 create mode 100644 public/jdr/elements/paradoxe.json
 create mode 100644 public/jdr/elements/pseudo.json
 create mode 100644 public/rules/magie/terrains.md
 create mode 100644 src/views/ElementsView.vue

diff --git a/public/jdr/cartomancia.json b/public/jdr/cartomancia.json
index 6de88e1..34f8870 100644
--- a/public/jdr/cartomancia.json
+++ b/public/jdr/cartomancia.json
@@ -10,5 +10,6 @@
   "effetsMains":["base", "magique"],
   "tenues":["base","armures"],
   "effetsTenues":["base", "magique"],
-  "accessoires":["base", "cristaleclat"]
+  "accessoires":["base", "cristaleclat"],
+  "elements":["base", "metaphysique", "pseudo"]
 }
\ No newline at end of file
diff --git a/public/jdr/core.json b/public/jdr/core.json
index 87e156e..54ef9d1 100644
--- a/public/jdr/core.json
+++ b/public/jdr/core.json
@@ -10,5 +10,6 @@
   "effetsMains":["base"],
   "tenues":["base","armures"],
   "effetsTenues":["base"],
-  "accessoires":["base", "eclat"]
+  "accessoires":["base", "eclat"],
+  "elements":["base"]
 }
\ No newline at end of file
diff --git a/public/jdr/elements/base.json b/public/jdr/elements/base.json
new file mode 100644
index 0000000..74efbd6
--- /dev/null
+++ b/public/jdr/elements/base.json
@@ -0,0 +1,10 @@
+[
+  {"nom":"Terre","type":"Physique","effet":"Brise armure : tous les 6 points de dégâts effectué, ajoute un malus en armure jusqu’à réparation.","nomTerrain":"Tempête de sable","effetTerrain":"1D4 dégâts chaque tour.","oppose":"Air"},
+  {"nom":"Végétal","type":"Physique","effet":"Ajoute un effet de vampirisme physique (50 % des dégâts effectués régénéré en tant que PV) à l’attaque","nomTerrain":"Phytoradiation","effetTerrain":"Les personnages regagnent tous 1D4 PV par tour.","oppose":"Metal"},
+  {"nom":"Eau","type":"Physique","effet":"1/6 chance de provoquer l'effet épuisement.","nomTerrain":"Brume","effetTerrain":"Les personnages non-aveugle ont 1D4 chance d’échouer leur jet d’action.","oppose":"Feu"},
+  {"nom":"Glace","type":"Physique","effet":"1/3 de chance de provoquer la paralysie (personnage doit faire un jet de CON pour attaquer)","nomTerrain":"Verglas","effetTerrain":"Sur chaque déplacement, le personnage fait un jet d’HAB pour pas tomber.","oppose":"Foudre"},
+  {"nom":"Air","type":"Physique","effet":"L'attaque fera forcément au moins 2 dégats.","nomTerrain":"Tempête","effetTerrain":"Stat divisée par 2 pour toute attaque à distance","oppose":"Terre"},
+  {"nom":"Foudre","type":"Physique","effet":"1/2 de chance de provoquer un effet de « stunt » sur l’ennemi.","nomTerrain":"Orage","effetTerrain":"Chaque tour, un personnage présent sur le terrain au hasard se prend 1D10 dégât.","oppose":"Glace"},
+  {"nom":"Feu","type":"Physique","effet":"2/3 chance de produire un effet « blessure/brûlure ». Si critique, blessure/brûlure grave.","nomTerrain":"Sol ardent","effetTerrain":"Chaque personnage sur le sol jette 1D4, si échoue, effet brûlure/blessure immédiat.","oppose":"Eau"},
+  {"nom":"Metal","type":"Physique","effet":"Semi perce-armure (100% perce-armure si déjà semi perce-armure)","nomTerrain":"Picots","effetTerrain":"À chaque déplacement au sol ou arrivé sur le terrain, 1D8 dégât.","oppose":"Végétal"}
+]
\ No newline at end of file
diff --git a/public/jdr/elements/metaphysique.json b/public/jdr/elements/metaphysique.json
new file mode 100644
index 0000000..42904db
--- /dev/null
+++ b/public/jdr/elements/metaphysique.json
@@ -0,0 +1,10 @@
+[
+  {"nom":"Énergie","type":"Métaphysique","effet":"Le personnage à 1/8 chance de se régénérer d’un éclat en faisant l’attaque.","nomTerrain":"Apogée cosmique","effetTerrain":"Retire à tout les personnages présent 1 dégats mental par tour.","oppose":"Néant"},
+  {"nom":"Lumière","type":"Métaphysique","effet":"1/3 chance de provoquer l'affliction Aveuglement (grave si critique).","nomTerrain":"Zénith grandiose","effetTerrain":"Rajoute 2 d'armure mentale à tout les personnages","oppose":"Ombre"},
+  {"nom":"Ordre","type":"Métaphysique","effet":"1/8 chance de diviser par deux les réussite critique pour trois tours","nomTerrain":"Égalisation ultime","effetTerrain":"Les critiques, réussite comme échec, ne peuvent pas se produire.","oppose":"Chaos"},
+  {"nom":"Espace","type":"Métaphysique","effet":"1/4 chance de déplacer à une autre position sur le terrain l’ennemi touché, au choix du joueur.","nomTerrain":"Distorsion spatiale","effetTerrain":"Les êtres « proches » sont traités comme loin, les êtres « loin » sont traités comme proche.","oppose":"Temps"},
+  {"nom":"Néant","type":"Métaphysique","effet":"1/6 chance de provoquer l'affliction Terreur (grave si critique).","nomTerrain":"Vide cosmique","effetTerrain":"Provoque à tout les personnages présent 1 dégats mental par tour.","oppose":"Énergie"},
+  {"nom":"Ombre","type":"Métaphysique","effet":"Ajoute un effet de vampirisme moral (50 % des dégâts effectués régénéré en tant que PM) à l’attaque","nomTerrain":"Éclipse grandiose","effetTerrain":"Retire 2 d'armure mentale à tout les personnages","oppose":"Lumière"},
+  {"nom":"Chaos","type":"Métaphysique","effet":"50 % des dégâts physique sont aussi des dégâts d’esprit, et vice-versa.","nomTerrain":"Désordre ultime","effetTerrain":"Les critiques, réussite comme échec, sont doublé.","oppose":"Ordre"},
+  {"nom":"Temps","type":"Métaphysique","effet":"Si l’attaque échoue : jette 1D4. Si 1, peut relancer l’attaque.","nomTerrain":"Distorsion temporelle","effetTerrain":"Inverse l’ordre de passage de tout les personnages.","oppose":"Espace"}
+]
\ No newline at end of file
diff --git a/public/jdr/elements/paradoxe.json b/public/jdr/elements/paradoxe.json
new file mode 100644
index 0000000..81d9ee4
--- /dev/null
+++ b/public/jdr/elements/paradoxe.json
@@ -0,0 +1,5 @@
+[
+  {"nom":"Éclat","type":"Paradoxal","effet":"Aucun effet particulier hors résistance élémentaire.","nomTerrain":"Cieux radiants","effetTerrain":"Toute la magie n'utilise que l'éclat environnant. Cependant, perte de 25% de PV et PM par tour.","oppose":"Anomie"},
+  {"nom":"Paradoxe","type":"Paradoxal","effet":"Le jet à deux effets secondaires d'élément parmi tout ceux disponible sur cette page hors éclat (1D20).","nomTerrain":"Cieux paradoxaux","effetTerrain":"Les effets de deux autres terrains présent sur cette page hors éclat se produisent au hasard.","oppose":"Anomie"},
+  {"nom":"Anomie","type":"Paradoxal","effet":"10% de chance de rendre anomique la cible","nomTerrain":"Cieux corrompus","effetTerrain":"Tout jet de magie double sa puissance, mais à 1/3 chance d'être anomique","oppose":"Éclat, Paradoxe"}
+]
\ No newline at end of file
diff --git a/public/jdr/elements/pseudo.json b/public/jdr/elements/pseudo.json
new file mode 100644
index 0000000..d9449a4
--- /dev/null
+++ b/public/jdr/elements/pseudo.json
@@ -0,0 +1,6 @@
+[
+  {"nom":"Toxine","type":"Physique","effet":"Provoque un poison progressif (augmentant de 1 dégât par tour à partir de 1) qui ne s'arrêtera qu'après le combat ou si soin d’altération physique.","nomTerrain":"Brume miasmatique","effetTerrain":"Tout les personnages voient leurs statistiques physique baissée de 30%","oppose":"N/A"},
+  {"nom":"Son","type":"Physique","effet":"1/4 chance de provoquer silence.","nomTerrain":"Déconcentration absolue","effetTerrain":"Empêche l'utilisation de magie sur le terrain","oppose":"N/A"},
+  {"nom":"Force","type":"Physique","effet":"Provoque un dégât supplémentaire par tranche de 5.","nomTerrain":"Zone de guerre","effetTerrain":"Provoque rage sur tout les personnages présents en combat.","oppose":"N/A"},
+  {"nom":"Esprit","type":"Physique","effet":"1/4 chance de rendre confus l'ennemi.","nomTerrain":"Terres astrales","effetTerrain":"Inversions attaques/soins physiques et morales.","oppose":"N/A"}
+]
\ No newline at end of file
diff --git a/public/jdr/sonata.json b/public/jdr/sonata.json
index 641484f..3aacc89 100644
--- a/public/jdr/sonata.json
+++ b/public/jdr/sonata.json
@@ -20,5 +20,6 @@
   "effetsMains":["base", "tech"],
   "tenues":["base","armures"],
   "effetsTenues":["base", "tech"],
-  "accessoires":["base"]
+  "accessoires":["base"],
+  "elements":["metaphysique", "paradoxe"]
 }
\ No newline at end of file
diff --git a/public/pelican.json b/public/pelican.json
index 450bb68..3f4c17b 100644
--- a/public/pelican.json
+++ b/public/pelican.json
@@ -78,8 +78,7 @@
       "id": 50,
       "title": "Magie et surnaturel",
       "links": [
-        {"title": "Éclat", "path": "rules/magie/eclat"},
-        {"title": "Éléments", "path": "rules/magie/eclat"}
+        {"title": "Éclat", "path": "rules/magie/eclat"}
       ]
     },
     {
@@ -93,6 +92,7 @@
       "id": 70,
       "title": "",
       "links": [
+        {"title": "Éléments", "path": "elements"},
         {"title": "Jeu de plateau", "path": "rules/bases/plateau"}
       ]
     }
diff --git a/public/rules/magie/elements.md b/public/rules/magie/elements.md
index 36bf91b..fee9940 100644
--- a/public/rules/magie/elements.md
+++ b/public/rules/magie/elements.md
@@ -1,8 +1,12 @@
 # Les éléments et leurs effets
 
-Il peut être également intéressant d’ajouter des effets élémentaires aux différentes capacités. Pélican propose un système de huit éléments « physiques » qui plus qu’un système de défense/résistance offrent un système « d’effet spéciaux ». Ces effets peuvent également se lier aux effets de terrains pour créer des faiblesses et résistances.
+Un élément est une représentation d'une force de la nature, qui peut être physique, métaphysique, etc. Elle peut représenter un matériel, un état, une forme de magie qui seront appliqué à une attaque, une armure, etc. Les éléments ne sont pas forcément lié à quelque chose de magique, et le nombre est différent suivant les JDRs.
 
-En règle général, les éléments n’aiment pas les effets de terrains de l’élément opposé.
+Les éléments peuvent :
+- Affecter quel sera la puissance d'une attaque sur un type d'ennemi
+- Ajouter un effet à une attaque, un objet, une action
+- Ajouter un effet à l'environnement autour des personnages.
+- Atténuer ou amplifier l'effet d'un autre élément
 
 ## Faiblesses et résistances
 
@@ -12,153 +16,5 @@ Pour chaque résistance, un personnage ne se prendra que la moitié des dégâts
 
 Généralement, une créature à entre zero et deux faiblesses/résistences.
 
-## Éléments physiques
+## Liste des éléments
 
-Les éléments physiques représentes les éléments les plus classiques et courants, présents partout de manière "normale" dans un monde.
-
-| **Végétal** | **Eau** | **Glace** |
-|:-----------:|:-------:|:---------:|
-| **Terre**   |         | **Air**   |
-| **Métal**   | **Feu** | **Foudre**|
-
-Ils peuvent avoir les effets suivants en combat :
-
-<div class="table-auto">
-
-| Élément | Effet |
-|:-------:|:------|
-| **Terre** | Brise armure : tous les 6 points de dégâts effectué, ajoute un malus en armure jusqu’à réparation. |
-| **Végétal** | Ajoute un effet de vampirisme physique (50 % des dégâts effectués régénéré en tant que PV) à l’attaque |
-| **Eau** | 25% de chance de provoquer l'effet épuisement. |
-| **Glace** | 30 % de chance de provoquer la paralysie (personnage doit faire un jet de CON pour attaquer) |
-| **Air** | La moitié des dégâts de l'attaque ont 50% d'agir même si l'attaque à été esquivée. |
-| **Foudre** | 50 % de chance de provoquer un effet de « stunt » sur l’ennemi. |
-| **Feu** | 60 % de chance de produire un effet « blessure/brûlure ». Si critique, blessure/brûlure grave.
-| **Metal** | Semi perce-armure (100% perce-armure si déjà semi perce-armure) |
-
-</div>
-
-### Terrains élémentaires
-
-<div class="table-auto">
-
-| Élément | Terrain | Effet |
-|:-------:|:-------:|:------|
-| **Terre** | *Tempête de sable* | 1D4 dégâts chaque tour. |
-| **Végétal** | *Phytoradiation* | Les personnages regagnent tous 1D4 PV par tour. |
-| **Eau** | *Brume* | Les personnages non-aveugle ont 1D4 chance d’échouer leur jet d’action. |
-| **Glace** | *Verglas* | Sur chaque déplacement, le personnage fait un jet d’HAB pour pas tomber. |
-| **Air** | *Tornade* | Chaque attaque à distance devient difficile (-50 %) |
-| **Foudre** | *Orage* | Chaque tour, un personnage présent sur le terrain au hasard se prend 1D10 dégât. |
-| **Feu** | *Sol ardent (floor is lava)* | Chaque personnage sur le sol jette 1D4, si échoue, effet brûlure/blessure immédiat. |
-| **Métal** | *Picots* | À chaque déplacement au sol ou arrivé sur le terrain, 1D8 dégât. |
-
-</div>
-
-## Éléments métaphysique
-
-Les éléments métaphysiques représentent plus des structures de la réalité, des éléments fondamentaux qui la composent. Ils sont en cela souvent plus rare et plus puissants.
-
-| **Lumière** | **Ordre** | **Espace** |
-|:-----------:|:---------:|:----------:|
-| **Énergie** | *(Éclat)* | **Néant**  |
-| **Temps**   | **Chaos** | **Ombre**  |
-
-Ils peuvent avoir les effets suivants en combat :
-
-<div class="table-auto">
-
-| Élément | Effet |
-|:-------:|:------|
-| **Énergie** | Le personnage à 15 % de chance de se régénérer d’un éclat en faisant l’attaque. |
-| **Lumière** | 30 % d'aveugler la cible (si critique, cécité). |
-| **Ordre** | Si attaque sur l’armure la plus forte de l’ennemi, attaquera sur la deuxième plus forte. |
-| **Espace** | 30 % de déplacer à une autre position sur le terrain l’ennemi touché, au choix du joueur. |
-| **Néant** | L’ennemi touché à 30 % de chance de devoir faire un jet de panique s’il n’est pas déjà en panique. |
-| **Ombre** | Ajoute un effet de vampirisme moral (50 % des dégâts effectués régénéré en tant que PM) à l’attaque |
-| **Chaos** | 50 % des dégâts physique sont aussi des dégâts d’esprit, et vice-versa. |
-| **Temps** | Si l’attaque échoue : jette 1D4. Si 1, peut relancer l’attaque. |
-
-</div>
-
-### Terrains élémentaires
-
-<div class="table-auto">
-
-| Élément | Terrain | Effet |
-|:-------:|:-------:|:------|
-| **Énergie** | *Apogée cosmique* | À chaque jet de panique, le personnage jette 1D4, si 1 ou 3 : le jet de panique ne se produit pas. |
-| **Lumière** | *Zénith divin* | Les attaques de lumière, plante et feu ont une amélioration au dé supérieur. Les attaques d’ombre, glace et eau passent aux dés inférieurs. Les êtres d’ombres ont un désavantage. |
-| **Ordre** | *Égalisation ultime* | Les critiques, réussite comme échec, ne peuvent pas se produire. |
-| **Espace** | *Distorsion spatiale* | Les êtres « proches » sont traités comme loin, les êtres « loin » sont traités comme proche. |
-| **Néant** | *Vide cosmique* | Tous les tours, 1D4, si 2 ou 4 : un personnage au hasard fait un jet de panique. |
-| **Ombre** | *Éclipse divine* | Les attaques d’ombre, glace et eau ont une amélioration au dé supérieur. Les attaques de lumière, plante et feu passent aux dés inférieurs. Les êtres de lumière ont un désavantage. |
-| **Chaos** | *Désordre ultime* | Les critiques, réussite comme échec, sont doublé. |
-| **Temps** | *Distorsion temporelle* | Inverse l’ordre de passage de tout les personnages. |
-
-</div>
-
-## Elements paradoxaux
-
-> [!NOTE]
-> Dans certains univers, une troisième forme du paradoxe peut exister, l'anomie. Cependant, l'anomie étant un peu plus complexe qu'un élément, elle a le droit à sa page à part.
-
-Les éléments paradoxaux sont les éléments existant à une échelle supérieure à celle des mondes. C'est le nom donné aux deux formes du paradoxe, la force née des contradictions même de l'univers qui rend les magiques et la métaphysique possible, l'éclat et le paradoxe pur.
-
-| Éclat | Paradoxe |
-|:-----:|:------:|
-| La forme énergique du paradoxe. Une énergie volatile mais puissante, qui peut changer la réalité même. Il porte des noms différents dans de multiple univers, et n'existe à plus ou moins grande dose suivant l'imperfection de l'univers | La forme la plus pur du paradoxe. Plus qu'une énergie ou une entité, il s'agit d'un état de réalité, se produisant quand deux états contradictoire du monde existent. |
-
-<div class="table-auto">
-
-| Élément | Effet |
-|:-------:|:------|
-| **Éclat** | Aucun effet particulier hors résistance élémentaire. |
-| **Paradoxe** | Le jet à deux effets secondaires d'élément parmi tout ceux disponible sur cette page hors éclat (1D20). |
-
-</div>
-
-### Terrains élémentaires
-
-<div class="table-auto">
-
-| Élément | Terrain | Effet |
-|:-------:|:-------:|:------|
-| **Éclat** | *Cieux radiants* | Toute la magie n'utilise que l'éclat environnant. Cependant, perte de 25% de PV et PM par tour. |
-| **Paradoxe** | *Cieux paradoxaux* | Les effets de deux autres terrains présent sur cette page hors éclat (1D20) se produisent au hasard. |
-
-</div>
-
-## Pseudo-éléments
-
-Les pseudo-éléments sont un ensemble de quatre entités qui ont des propriétés proches d'un élément, sans en être véritablement.
-
-| Toxine | Son | Force | Esprit |
-|:-------|:----|:------|:-------|
-| Tous les poisons et entités qui affaiblissent le corps et l'esprit. | Des ondes qui peuvent être détectée et utilisée comme information par la plupart des créatures. | L'énergie née de la combativité et de la force physique du corps | L'énergie formée par l'activité cérébrale, lorsque celle-ci réussi à s'échapper de son enveloppe charnelle |
-
-Ils peuvent avoir les effets suivants
-
-<div class="table-auto">
-
-| P-Élément | Effet |
-|:---------:|:------|
-| Toxine    | Provoque un poison progressif (augmentant de 1 dégât par tour à partir de 1) qui ne s'arrêtera qu'après le combat ou si soin d’altération physique. |
-| Son       | 30% de chance de provoquer une hypoactivité. |
-| Force     | Provoque un dégât supplémentaire par tranche de 5. |
-| Esprit    | 30% de chance de rendre confus l'ennemi. |
-
-</div>
-
-### Terrains élémentaires
-
-<div class="table-auto">
-
-| P-Élément | Terrain | Effet |
-|:---------:|:-------:|:------|
-| Toxine    | *Brume miasmatique* | Tout les personnages voient leurs statistiques physique baissée de 30% |
-| Son       | *Déconcentration absolue* | Empêche l'utilisation de magie sur le terrain |
-| Force     | *Zone de guerre* | Provoque rage sur tout les personnages présents en combat. |
-| Esprit    | *Terres astrales* | Inversions attaques/soins physiques et morales. |
-
-</div>
diff --git a/public/rules/magie/terrains.md b/public/rules/magie/terrains.md
new file mode 100644
index 0000000..4b4848b
--- /dev/null
+++ b/public/rules/magie/terrains.md
@@ -0,0 +1 @@
+## Terrains élémentaires
diff --git a/src/data/fields.ts b/src/data/fields.ts
index 9f11412..e5ce71a 100644
--- a/src/data/fields.ts
+++ b/src/data/fields.ts
@@ -34,10 +34,27 @@ const accessoiresFields = [
   { key: "cout", label: "Cout" },
 ];
 
+const elementsFields = [
+  { key: "nom", label: "Nom" },
+  { key: "type", label: "Type", canBeFiltered: true },
+  { key: "effet", label: "Effet" },
+  { key: "oppose", label: "Opposé" },
+];
+
+const terrainsFields = [
+  { key: "nom", label: "Nom" },
+  { key: "type", label: "Type", canBeFiltered: true },
+  { key: "nomTerrain", label: "Nom du Terrain" },
+  { key: "effetTerrain", label: "Effet" },
+  { key: "oppose", label: "Affaibli" },
+];
+
 export {
   objectFields,
   equipMainsFields,
   tenuesFields,
   effetsFields,
   accessoiresFields,
+  elementsFields,
+  terrainsFields,
 };
diff --git a/src/router/index.ts b/src/router/index.ts
index 56238bb..086e1f0 100644
--- a/src/router/index.ts
+++ b/src/router/index.ts
@@ -5,6 +5,7 @@ import JdrView from "../views/JdrView.vue";
 import FichesView from "../views/FichesView.vue";
 import ObjetsView from "../views/ObjetsView.vue";
 import EquipView from "../views/EquipView.vue";
+import ElementsView from "../views/ElementsView.vue";
 
 const router = createRouter({
   history: createWebHashHistory(import.meta.env.BASE_URL),
@@ -42,6 +43,10 @@ const router = createRouter({
       path: "/jdr/:jdr/inventaire/equipements/",
       component: EquipView,
     },
+    {
+      path: "/jdr/:jdr/elements/",
+      component: ElementsView,
+    },
   ],
   scrollBehavior(to, from, savedPosition) {
     if (to.hash) {
diff --git a/src/types/JdrConfig.ts b/src/types/JdrConfig.ts
index dcfd755..c6d7cee 100644
--- a/src/types/JdrConfig.ts
+++ b/src/types/JdrConfig.ts
@@ -12,4 +12,5 @@ export default interface JdrConfig {
   tenues: string[];
   effetsTenues: string[];
   accessoires: string[];
+  elements: string[];
 }
diff --git a/src/views/ElementsView.vue b/src/views/ElementsView.vue
new file mode 100644
index 0000000..eaf617b
--- /dev/null
+++ b/src/views/ElementsView.vue
@@ -0,0 +1,38 @@
+<script setup lang="ts">
+import DynTable from "@/components/tableaux/DynTable.vue";
+import { useConfigStore } from "@/stores/config";
+import { onMounted, computed } from "vue";
+import { useRoute } from "vue-router";
+import MarkdownFile from "../components/MarkdownFile.vue";
+import { elementsFields, terrainsFields } from "@/data/fields";
+
+const store = useConfigStore();
+const route = useRoute();
+
+onMounted(() => {
+  store.loadJdr(`${route.params.jdr}`);
+});
+
+const elements = computed(() => {
+  return store.jdrConfig?.elements ?? [];
+});
+</script>
+
+<template>
+  <main>
+    <MarkdownFile :path="`rules/magie/elements`" :order="1">
+      <DynTable
+        :fields="elementsFields"
+        :files="elements"
+        category="elements"
+      />
+    </MarkdownFile>
+    <MarkdownFile :path="`rules/magie/terrains`" :order="2">
+      <DynTable
+        :fields="terrainsFields"
+        :files="elements"
+        category="elements"
+      />
+    </MarkdownFile>
+  </main>
+</template>

From cb1904cdad6e9bb9232674e497b0fee32f008d46 Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Sat, 18 Feb 2023 16:39:51 +0100
Subject: [PATCH 24/27] feat: ajout elementaire tech

---
 public/jdr/effets-mains/tech.json | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/public/jdr/effets-mains/tech.json b/public/jdr/effets-mains/tech.json
index 6e13d05..86a6947 100644
--- a/public/jdr/effets-mains/tech.json
+++ b/public/jdr/effets-mains/tech.json
@@ -1,6 +1,11 @@
 [
-  {"nom":"Biotechnologie","effet":"Ajoute un effet de vampirisme physique (regen force/2 en PV)","surcout":"+50%"},
-  {"nom":"Nanotechnologie","effet":"Tout effet de brise armure ou brise-arme s'estomp à la fin de la partie","surcout":"+100%"},
-  {"nom":"Crystalline","effet":"Brise armure/arme: tous les 6 points de dégâts effectué ou reçu, ajoute un malus en armure/arme à l'opposant","surcout":"+25%"},
-  {"nom":"Laser","effet":"Semi perce-armure (si déjà semi perce-armure, full perce-armure)","surcout":"+100%"}
+  {"nom":"Crystallisé","effet":"Brise armure : tous les 6 points de dégâts effectué, ajoute un malus en armure jusqu’à réparation.","surcout":"+100%"},
+  {"nom":"Mésophase","effet":"25% de chance de provoquer l'effet épuisement.","surcout":"+100%"},
+  {"nom":"Frigorifique","effet":"30 % de chance de provoquer la paralysie (personnage doit faire un jet de CON pour attaquer)","surcout":"+100%"},
+  {"nom":"Gaz Magnétisé","effet":"La moitié des dégâts de l'attaque ont 50% d'agir même si l'attaque à été esquivée.","surcout":"+100%"},
+  {"nom":"Éléctrique","effet":"50 % de chance de provoquer un effet de « stunt » sur l’ennemi.","surcout":"+100%"},
+  {"nom":"Biotechnologie","effet":"Ajoute un effet de vampirisme physique (50 % des dégâts effectués régénéré en tant que PV) à l’attaque.","surcout":"+100%"},
+  {"nom":"Pyrolithique","effet":"60 % de chance de produire un effet « blessure/brûlure ». Si critique, blessure/brûlure grave.","surcout":"+100%"},
+  {"nom":"Laser","effet":"Semi perce-armure (si déjà semi perce-armure, full perce-armure)","surcout":"+100%"},
+  {"nom":"Nanotechnologie","effet":"Tout effet de brise armure ou brise-arme s'estomp à la fin de la partie","surcout":"+100%"}
 ]
\ No newline at end of file

From af5f2983d3cd0afd93c594e8103777ac4c0b25db Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Sat, 18 Feb 2023 16:59:35 +0100
Subject: [PATCH 25/27] feat: make table searchable

---
 src/components/tableaux/TableRenderer.vue  | 21 ++++++++++++---
 src/data/fields.ts                         | 30 +++++++++++-----------
 src/utils/tables/FilteredHtmlTable.ts      | 13 ++++++++++
 src/utils/tables/PaginatedFilteredTable.ts |  4 +++
 src/utils/tables/types.ts                  |  1 +
 5 files changed, 51 insertions(+), 18 deletions(-)

diff --git a/src/components/tableaux/TableRenderer.vue b/src/components/tableaux/TableRenderer.vue
index c6b061f..39f05fb 100644
--- a/src/components/tableaux/TableRenderer.vue
+++ b/src/components/tableaux/TableRenderer.vue
@@ -1,5 +1,5 @@
 <script lang="ts" setup>
-import { computed, reactive, onMounted } from "vue";
+import { computed, reactive, onMounted, ref } from "vue";
 import PaginatedFilteredTable from "@/utils/tables/PaginatedFilteredTable";
 import type { TableField, TableItem } from "@/utils/tables/types";
 import type { PropType } from "vue";
@@ -21,6 +21,8 @@ const DEFAULT_MAX_ITEM_BY_PAGE = 10;
 
 const table = reactive(new PaginatedFilteredTable(DEFAULT_MAX_ITEM_BY_PAGE));
 
+const textSearch = ref("");
+
 const filtersFieldMap = computed(() => {
   return table?.filteredTable?.filtersFieldMap;
 });
@@ -30,7 +32,11 @@ const displayedFieldKeys = computed(() => {
 });
 
 const paginatedList = computed(() => {
-  return table?.items;
+  if (textSearch.value !== "") {
+    return table?.search(textSearch.value);
+  } else {
+    return table?.items;
+  }
 });
 
 onMounted(() => {
@@ -62,7 +68,9 @@ function goTo(page: number) {
 
 <template>
   <div class="d-flex f-between">
-    <div></div>
+    <div>
+      <input v-model="textSearch" class="btn-small" placeholder="Rechercher" />
+    </div>
     <div class="d-flex f-end">
       <TagList
         :filtersFieldMap="filtersFieldMap"
@@ -110,4 +118,11 @@ table:not(:last-child) {
 .pages {
   font-weight: 600;
 }
+
+input {
+  border: 1px solid rgba(0, 0, 0, 0.2);
+  margin-bottom: 0.5rem;
+  margin-left: 0;
+  margin-right: 0;
+}
 </style>
diff --git a/src/data/fields.ts b/src/data/fields.ts
index e5ce71a..1d10c67 100644
--- a/src/data/fields.ts
+++ b/src/data/fields.ts
@@ -1,51 +1,51 @@
 const objectFields = [
-  { key: "nom", label: "Nom" },
+  { key: "nom", label: "Nom", canBeSearched: true },
   { key: "type", label: "Type", canBeFiltered: true },
   { key: "rarete", label: "Rareté", canBeFiltered: true },
-  { key: "effet", label: "Effet" },
+  { key: "effet", label: "Effet", canBeSearched: true },
   { key: "cout", label: "Cout" },
 ];
 
 const equipMainsFields = [
-  { key: "nom", label: "Nom" },
+  { key: "nom", label: "Nom", canBeSearched: true },
   { key: "type", label: "Type", canBeFiltered: true },
   { key: "mains", label: "Mains", canBeFiltered: true },
-  { key: "effet", label: "Effet" },
+  { key: "effet", label: "Effet", canBeSearched: true },
   { key: "force", label: "Force" },
   { key: "cout", label: "Cout" },
 ];
 
 const tenuesFields = [
-  { key: "nom", label: "Nom" },
-  { key: "effet", label: "Effet" },
+  { key: "nom", label: "Nom", canBeSearched: true },
+  { key: "effet", label: "Effet", canBeSearched: true },
   { key: "armure", label: "Armure" },
   { key: "cout", label: "cout" },
 ];
 
 const effetsFields = [
-  { key: "nom", label: "Nom" },
-  { key: "effet", label: "Effet" },
+  { key: "nom", label: "Nom", canBeSearched: true },
+  { key: "effet", label: "Effet", canBeSearched: true },
   { key: "surcout", label: "Surcout" },
 ];
 
 const accessoiresFields = [
-  { key: "nom", label: "Nom" },
-  { key: "effet", label: "Effet" },
+  { key: "nom", label: "Nom", canBeSearched: true },
+  { key: "effet", label: "Effet", canBeSearched: true },
   { key: "cout", label: "Cout" },
 ];
 
 const elementsFields = [
-  { key: "nom", label: "Nom" },
+  { key: "nom", label: "Nom", canBeSearched: true },
   { key: "type", label: "Type", canBeFiltered: true },
-  { key: "effet", label: "Effet" },
+  { key: "effet", label: "Effet", canBeSearched: true },
   { key: "oppose", label: "Opposé" },
 ];
 
 const terrainsFields = [
-  { key: "nom", label: "Nom" },
+  { key: "nom", label: "Nom", canBeSearched: true },
   { key: "type", label: "Type", canBeFiltered: true },
-  { key: "nomTerrain", label: "Nom du Terrain" },
-  { key: "effetTerrain", label: "Effet" },
+  { key: "nomTerrain", label: "Nom du Terrain", canBeSearched: true },
+  { key: "effetTerrain", label: "Effet", canBeSearched: true },
   { key: "oppose", label: "Affaibli" },
 ];
 
diff --git a/src/utils/tables/FilteredHtmlTable.ts b/src/utils/tables/FilteredHtmlTable.ts
index c427919..5c8c56d 100644
--- a/src/utils/tables/FilteredHtmlTable.ts
+++ b/src/utils/tables/FilteredHtmlTable.ts
@@ -51,6 +51,19 @@ export default class FilteredHtmlTable {
     return filteredItem;
   }
 
+  search(query: string) {
+    return this.items.filter((row) => {
+      for (const field of this.table.fields) {
+        if (field.canBeSearched) {
+          if ((row[field.key] as string).includes(query)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    });
+  }
+
   private setFilterableValue(fieldKey: string, filterableValue: string) {
     const filters = this.getFiltersForField(fieldKey);
     if (filters) {
diff --git a/src/utils/tables/PaginatedFilteredTable.ts b/src/utils/tables/PaginatedFilteredTable.ts
index d83a0cf..28eea1c 100644
--- a/src/utils/tables/PaginatedFilteredTable.ts
+++ b/src/utils/tables/PaginatedFilteredTable.ts
@@ -34,6 +34,10 @@ export default class PaginatedFilteredTable {
     this.filteredTable.addItems(items);
   }
 
+  public search(query: string) {
+    return this.filteredTable.search(query);
+  }
+
   public canGo(rel: number) {
     return (
       this.currentPage + rel >= 0 && this.currentPage + rel <= this.pageNumber
diff --git a/src/utils/tables/types.ts b/src/utils/tables/types.ts
index 3781956..ce10766 100644
--- a/src/utils/tables/types.ts
+++ b/src/utils/tables/types.ts
@@ -7,6 +7,7 @@ interface TableField {
   key: string;
   label: string;
   canBeFiltered?: boolean;
+  canBeSearched?: boolean;
 }
 
 interface Filters {

From 9e8349bb7adf68fa563a028c63f654eb92020180 Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Sat, 18 Feb 2023 19:03:59 +0100
Subject: [PATCH 26/27] feat: ajout element par page configurable

---
 src/components/tableaux/TableRenderer.vue | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/src/components/tableaux/TableRenderer.vue b/src/components/tableaux/TableRenderer.vue
index 39f05fb..1760f14 100644
--- a/src/components/tableaux/TableRenderer.vue
+++ b/src/components/tableaux/TableRenderer.vue
@@ -95,7 +95,17 @@ function goTo(page: number) {
       </tr>
     </tbody>
   </table>
-  <div class="d-flex f-end">
+  <div class="d-flex f-between">
+    <div>
+      <span>Lignes par page </span>
+      <select class="btn-small btn-outline" v-model="table.pageLenght">
+        <option>5</option>
+        <option>10</option>
+        <option>15</option>
+        <option>25</option>
+        <option>50</option>
+      </select>
+    </div>
     <PageList
       :current-page="currentPage + 1"
       :page-nbr="getTotalPage + 1"
@@ -119,7 +129,8 @@ table:not(:last-child) {
   font-weight: 600;
 }
 
-input {
+input,
+.btn-outline {
   border: 1px solid rgba(0, 0, 0, 0.2);
   margin-bottom: 0.5rem;
   margin-left: 0;

From 5a210a042594f125bc6a1788acf1fd4799592eb5 Mon Sep 17 00:00:00 2001
From: Kazhnuz <kazhnuz@kobold.cafe>
Date: Sat, 18 Feb 2023 19:05:16 +0100
Subject: [PATCH 27/27] meta: changelog

---
 CHANGELOG.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index efa6a86..29c98f8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -37,6 +37,7 @@ Refonte global du site en vueJS
 
 - [site] Page À propos
 - [site] Chargement dynamique d'infos sur les pages
+- [core] Ajout des outils
 
 ### Modifiés
 
@@ -44,10 +45,12 @@ Refonte global du site en vueJS
 - [site] Feuilles de styles simplifiées
 - [core] Refonte perce-armure qui touche toute l'attaque, ou divise par deux l'armure. Idem Perce-Defense.
 - [core] Refonte armure spéciale, qui devient une armure ignorant le perce-armure, le brise armure, etc.
+- [core] Mise en commun armes, outil et boucliers et leurs effets
 
 ### Supprimés
 
 - [site] Suppression des systèmes d'onglets
+- [core] Suppression du tableau des faiblesses/resistences (sera réimplémenté dans le bestiaire)
 
 ## Pélican 0.1.0 (alpha 1)