490 lines
28 KiB
JavaScript
490 lines
28 KiB
JavaScript
import { Grammar } from "./grammar.js";
|
||
import { Misc } from "./misc.js";
|
||
import { RdDDice } from "./rdd-dice.js";
|
||
import { TMRUtility } from "./tmr-utility.js";
|
||
import { TMRType } from "./tmr-utility.js";
|
||
|
||
/* -------------------------------------------- */
|
||
const typeRencontres = {
|
||
|
||
messager: {
|
||
msgSucces: (rencData) => `Le ${rencData.rencontre.name} vous propose d'emmener le message de votre un sort à ${rencData.rencontre.force} cases ${rencData.tmr.label}.`,
|
||
msgEchec: (rencData) => `Le ${rencData.rencontre.name} est pressé et continue son chemin d'une traite sans vous accorder un regard.`,
|
||
postSucces: (tmrDialog, rencData) => {
|
||
tmrDialog.setStateRencontre(rencData.rencontre.type);
|
||
tmrDialog.choisirCasePortee(rencData.tmr.coord, rencData.rencontre.force);
|
||
},
|
||
poesieSucces: {
|
||
reference: "La chevelure, Charles Baudelaire",
|
||
extrait: `J'irai là-bas où l'arbre et l'homme, pleins de sève,
|
||
<br>Se pâment longuement sous l'ardeur des climats ;
|
||
<br>Fortes tresses, soyez la houle qui m'enlève !`
|
||
},
|
||
poesieEchec: {
|
||
reference: "Rêve de Dragon, Denis Gerfaud",
|
||
extrait: `En réalité, tous les éléments du rêve des Dragons expriment
|
||
le Draconic : chaque pierre, chaque fleur, chaque goutte d'eau,
|
||
chaque nuage est porteur d'un message dans la langue des Dragons`}
|
||
},
|
||
|
||
passeur: {
|
||
msgSucces: (rencData) => `Le ${rencData.rencontre.name} vous propose de vous transporter à ${rencData.rencontre.force} cases des ${rencData.tmr.label}.`,
|
||
msgEchec: (rencData) => `Le prix que demande le ${rencData.rencontre.name} est trop élevé, vous êtes réduit à poursuivre votre chemin par vos propres moyens.`,
|
||
postSucces: (tmrDialog, rencData) => {
|
||
tmrDialog.setStateRencontre(rencData.rencontre.type);
|
||
tmrDialog.choisirCasePortee(rencData.tmr.coord, rencData.rencontre.force);
|
||
},
|
||
poesieSucces: {
|
||
reference: "Femmes damnées (2), Charles Baudelaire",
|
||
extrait: `Comme je descendais des Fleuves impassibles,
|
||
<br>Je ne me sentis plus guidé par les haleurs :
|
||
<br>Des Peaux-Rouges criards les avaient pris pour cibles,
|
||
<br>Les ayant cloués nus aux poteaux de couleurs.`},
|
||
poesieEchec: {
|
||
reference: "Le bateau ivre, Arthur Rimbaud",
|
||
extrait: `Loin des peuples vivants, errantes, condamnées,
|
||
<br>A travers les déserts courez comme les loups ;
|
||
<br>Faites votre destin, âmes désordonnées,
|
||
<br>Et fuyez l'infini que vous portez en vous !`}
|
||
},
|
||
|
||
fleur: {
|
||
msgSucces: (rencData) => `Vous cueillez la ${rencData.rencontre.name}, son parfum vous apporte ${rencData.rencontre.force} points de Rêve.`,
|
||
msgEchec: (rencData) => `La ${rencData.rencontre.name} se fâne et disparaît entre vos doigts.`,
|
||
postSucces: (tmrDialog, rencData) => tmrDialog.actor.reveActuelIncDec(rencData.rencontre.force),
|
||
poesieSucces: {
|
||
reference: "L'Ennemi, Charles Baudelaire",
|
||
extrait: `Et qui sait si les fleurs nouvelles que je rêve
|
||
<br>Trouveront dans ce sol lavé comme une grève
|
||
<br>Le mystique aliment qui ferait leur vigueur ?`},
|
||
poesieEchec: {
|
||
reference: "Une charogne, Charles Baudelaire",
|
||
extrait: `Et le ciel regardait la carcasse superbe
|
||
<br>Comme une fleur s'épanouir.
|
||
<br>La puanteur était si forte, que sur l'herbe
|
||
<br>Vous crûtes vous évanouir.`},
|
||
},
|
||
|
||
mangeur: {
|
||
msgSucces: (rencData) => `Le ${rencData.rencontre.name} claque de sa machoire dans le vide avant de fuir.`,
|
||
msgEchec: (rencData) => `Le ${rencData.rencontre.name} croque votre Rêve ! Il emporte ${rencData.rencontre.force} de vos points de rêve actuels`,
|
||
postEchec: (tmrDialog, rencData) => tmrDialog.actor.reveActuelIncDec(-rencData.rencontre.force),
|
||
poesieSucces: {
|
||
reference: "Conseil, Victor Hugo",
|
||
extrait: `Rois ! la bure est souvent jalouse du velours.
|
||
<br>Le peuple a froid l'hiver, le peuple a faim toujours.
|
||
<br>Rendez-lui son sort plus facile.
|
||
<br>Le peuple souvent porte un bien rude collier.
|
||
<br>Ouvrez l'école aux fils, aux pères l'atelier,
|
||
<br>À tous vos bras, auguste asile !`},
|
||
poesieEchec: {
|
||
reference: "El Desdichado, Gérard de Nerval",
|
||
extrait: `Suis-je Amour ou Phébus ?... Lusignan ou Biron ?
|
||
<br>Mon front est rouge encor du baiser de la Reine ;
|
||
<br>J'ai rêvé dans la Grotte où nage la sirène...`}
|
||
},
|
||
|
||
changeur: {
|
||
msgSucces: (rencData) => `Le ${rencData.rencontre.name} vaincu accepte de vous déplacer sur une autre ${TMRType[rencData.tmr.type].name} de votre choix en échange de sa liberté.`,
|
||
msgEchec: (rencData) => {
|
||
rencData.newTMR = TMRUtility.getTMRAleatoire(it => it.type = rencData.tmr.type);
|
||
return `Le ${rencData.rencontre.name} vous embobine avec des promesses, et vous transporte en ${rencData.newTMR.label} sans attendre votre avis.`;
|
||
},
|
||
postSucces: (tmrDialog, rencData) => {
|
||
tmrDialog.setStateRencontre(rencData.rencontre.type);
|
||
tmrDialog.choisirCaseType(rencData.tmr.type);
|
||
},
|
||
postEchec: (tmrDialog, rencData) => tmrDialog.forceDemiRevePosition(rencData.newTMR.coord),
|
||
poesieSucces: {
|
||
reference: "Caligula - IIIème chant, Gérard de Nerval",
|
||
extrait: `Allez, que le caprice emporte
|
||
<br>Chaque âme selon son désir,
|
||
<br>Et que, close après vous, la porte
|
||
<br>Ne se rouvre plus qu'au plaisir.`},
|
||
poesieEchec: {
|
||
reference: "Rêve de Dragon, Denis Gerfaud",
|
||
extrait: `Les sages ont encore coutume de dire :
|
||
<br>« Mais comment les Dragons peuvent-ils
|
||
être influencés par une créature qui, tout
|
||
bien considéré, n'existe pas vraiment pour eux,
|
||
qui n'est que le fantasme de leur activité nocturne ? »`}
|
||
},
|
||
|
||
briseur: {
|
||
msgSucces: (rencData) => `Le ${rencData.rencontre.name} tente vainement de vous déconcentrer, avant de fuir sans demander son reste.`,
|
||
msgEchec: (rencData) => `Le ${rencData.rencontre.name} vous déconcentre au point de briser votre demi-rêve.`,
|
||
postEchec: (tmrDialog, rencData) => tmrDialog.close(),
|
||
poesieSucces: {
|
||
reference: "Rêve de Dragon, Denis Gerfaud",
|
||
extrait: `La légende affirme que ce sont les Gnomes qui furent
|
||
les premiers haut-rêvants. En observant les pierres précieuses,
|
||
les gemmes qui sont les larmes de joie des Dragons, ils parvinrent à
|
||
en comprendre la langue. Et l'ayant comprise, ils purent s'en servir
|
||
pour influencer le cours du rêve`},
|
||
poesieEchec: {
|
||
reference: "Quand le rêve se brise, Cypora Sebagh",
|
||
extrait: `Quand le rêve se brise,
|
||
<br>Dans la plainte du jour,
|
||
<br>Ma mémoire devient grise
|
||
<br>Et sombre, tour à tour,
|
||
<br>Dans le puits du silence
|
||
<br>Et de la solitude ;
|
||
<br>Elle reprend son errance
|
||
<br>Parmi la multitude.`}
|
||
},
|
||
|
||
reflet: {
|
||
msgSucces: (rencData) => `Le ${rencData.rencontre.name} s'estompe dans l'oubli.`,
|
||
msgEchec: (rencData) => `Vous êtes submergé par un ${rencData.rencontre.name}, les souvenirs vous retiennent tant qu'il ne sera pas vaincu!`,
|
||
poesieSucces: {
|
||
reference: "Une charogne, Charles Baudelaire",
|
||
extrait: `Les formes s'effaçaient et n'étaient plus qu'un rêve,
|
||
<br>Une ébauche lente à venir
|
||
<br>Sur la toile oubliée, et que l'artiste achève
|
||
<br>Seulement par le souvenir.`},
|
||
poesieEchec: {
|
||
reference: "La chevelure, Charles Baudelaire",
|
||
extrait: `Longtemps ! toujours ! ma main dans ta crinière lourde
|
||
<br>Sèmera le rubis, la perle et le saphir,
|
||
<br>Afin qu'à mon désir tu ne sois jamais sourde !
|
||
<br>N'es-tu pas l'oasis où je rêve, et la gourde
|
||
<br>Où je hume à longs traits le vin du souvenir`}
|
||
},
|
||
|
||
passeurfou: {
|
||
msgSucces: (rencData) => `Le ${rencData.rencontre.name} tente vainement de découvrir où vous avez caché vos réserves. Vous le chassez, et en déroute il part harceler un autre voyageur du rêve.`,
|
||
msgEchec: (rencData) => TMRRencontres.msgEchecPasseurFou(rencData),
|
||
postEchec: (tmrDialog, rencData) => TMRRencontres.postEchecPasseurFou(tmrDialog, rencData),
|
||
poesieSucces: {
|
||
reference: "Un Fou et un Sage, Jean de La Fontaine",
|
||
extrait: `Certain Fou poursuivait à coups de pierre un Sage.
|
||
<br>Le Sage se retourne et lui dit : Mon ami,
|
||
<br>C'est fort bien fait à toi ; reçois cet écu-ci :
|
||
<br>Tu fatigues assez pour gagner davantage.`},
|
||
poesieEchec: {
|
||
reference: "Guitare, Victor Hugo",
|
||
extrait: `Je la voyais passer de ma demeure,
|
||
<br>Et c'était tout.
|
||
<br>Mais à présent je m'ennuie à toute heure,
|
||
<br>Plein de dégoût,
|
||
<br>Rêveur oisif, l'âme dans la campagne,
|
||
<br>La dague au clou ... –
|
||
<br>Le vent qui vient à travers la montagne
|
||
<br>M'a rendu fou !`}
|
||
},
|
||
|
||
tbblanc: {
|
||
msgSucces: (rencData) => `Le ${rencData.rencontre.name} souleve une poussière blanche, vous tenez bon, et il tourbillonne en s'éloignant.`,
|
||
msgEchec: (rencData) => `Le souffle du ${rencData.rencontre.name} vous déstabilise et vous emmène dans un nuage de poussière.`,
|
||
postEchec: (tmrDialog, rencData) => TMRRencontres.onPostEchecTourbillon(tmrDialog, rencData, 1),
|
||
poesieSucces: {
|
||
reference: "Rêve de Dragon, Denis Gerfaud",
|
||
extrait: `Le Premier Âge fut appelé l'Âge des Dragons. Ce fut le commencement
|
||
des temps, le commencement des rêves. Durant cette période plus mythique
|
||
que réellement historique, les Dragons aimaient à se rêver eux-mêmes.`},
|
||
poesieEchec: {
|
||
reference: "Les Djinns, Victor Hugo",
|
||
extrait: `C'est l'essaim des Djinns qui passe,
|
||
<br>Et tourbillonne en sifflant !
|
||
<br>Les ifs, que leur vol fracasse,
|
||
<br>Craquent comme un pin brûlant.`},
|
||
},
|
||
|
||
tbnoir: {
|
||
msgSucces: (rencData) => `Le ${rencData.rencontre.name} orageux vous enveloppe de fureur et d'éclairs, vous tenez bon face à la tempête qui s'éloigne sans vous éloigner de votre chemin.`,
|
||
msgEchec: (rencData) => `Le ${rencData.rencontre.name} furieux vous secoue tel un fichu de paille malmené par les vents, et vous emporte dans la tourmente.`,
|
||
postEchec: (tmrDialog, rencData) => TMRRencontres.onPostEchecTourbillon(tmrDialog, rencData, 2),
|
||
poesieSucces: {
|
||
reference: "Rêve de Dragon, Denis Gerfaud",
|
||
extrait: `Car le Second Âge fut bel et bien celui des Magiciens. Durant cette période, les
|
||
Gnomes s'enfoncèrent profondément sous les montagnes et la magie passa aux
|
||
mains des Humains qui en usèrent et abusèrent, se croyant devenus les maîtres du monde`},
|
||
poesieEchec: {
|
||
reference: "Lily, Pierre Perret",
|
||
extrait: `Elle aurait pas cru sans le voir
|
||
<br>Que la couleur du désespoir
|
||
<br>Là-bas aussi ce fût le noir.`},
|
||
},
|
||
|
||
tbrouge: {
|
||
msgSucces: (rencData) => `Le ${rencData.rencontre.name} s'abat avec violence mais vous êtes plus rapide et parvenez à lui échapper.`,
|
||
msgEchec: (rencData) => `Le ${rencData.rencontre.name} vous frappe de milliers de morsure et vous malmène à travers les terres médianes.`,
|
||
postEchec: (tmrDialog, rencData) => TMRRencontres.onPostEchecTourbillonRouge(tmrDialog, rencData),
|
||
poesieSucces: {
|
||
reference: "Qu'est-ce de votre vie ? une bouteille molle, Jean-Baptiste Chassignet",
|
||
extrait: `Qu'est-ce de votre vie ? un tourbillon rouant
|
||
<br>De fumière à flot gris, parmi l'air se jouant,
|
||
<br>Qui passe plus soudain que foudre meurtrière.`},
|
||
poesieEchec: {
|
||
reference: "Les Djinns, poème Victor Hugo",
|
||
extrait: `Cris de l'enfer! voix qui hurle et qui pleure !
|
||
<br>L'horrible essaim, poussé par l'aquilon,
|
||
<br>Sans doute, ô ciel ! s'abat sur ma demeure.
|
||
<br>Le mur fléchit sous le noir bataillon.
|
||
<br>La maison crie et chancelle penchée,
|
||
<br>Et l'on dirait que, du sol arrachée,
|
||
<br>Ainsi qu'il chasse une feuille séchée,
|
||
<br>Le vent la roule avec leur tourbillon !`},
|
||
},
|
||
|
||
rdd: {
|
||
msgSucces: (rencData) => `A tout seigneur, tout honneur, vous faites face à un ${rencData.rencontre.name}. Vous le maîtrisez et récupérez ses rêves. Vous gagnez ses ${rencData.rencontre.force} points de rêve`,
|
||
msgEchec: (rencData) => `A tout seigneur, tout honneur, vous faites face à un ${rencData.rencontre.name}. La rencontre tourne au cauchemar, dans la lutte épique, vous subissez ${rencData.rolled.isETotal ? 'deux queues' : 'une queue'} de dragon!`,
|
||
postSucces: (tmrDialog, rencData) => TMRRencontres.onPostSuccessReveDeDragon(tmrDialog, rencData),
|
||
postEchec: (tmrDialog, rencData) => TMRRencontres.onPostEchecReveDeDragon(tmrDialog, rencData),
|
||
poesieSucces: {
|
||
reference: "Rêve de Dragon, Denis Gerfaud",
|
||
extrait: `Le monde est Rêve de Dragons, mais nous ne savons
|
||
<br>ni leur apparence ni qui sont les dragons.
|
||
<br>En dépit de l'iconographie qui les clame
|
||
<br>immenses créatures ailées crachant des flammes`},
|
||
poesieEchec: {
|
||
reference: "El Desdichado, Gérard de Nerval",
|
||
extrait: `Je suis le Ténébreux, – le Veuf, – l'Inconsolé,
|
||
<br>Le Prince d'Aquitaine à la Tour abolie :
|
||
<br>Ma seule Etoile est morte, – et mon luth constellé
|
||
<br>Porte le Soleil noir de la Mélancolie.`}
|
||
},
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
const mauvaisesRencontres = [
|
||
{ code: "mangeur", name: "Mangeur de Rêve", type: "mangeur", genre: "m", force: "1d6", refoulement: 2, isMauvaise: true },
|
||
{ code: "mangeur2d6", name: "Mangeur de Rêve", type: "mangeur", genre: "m", force: "2d6", refoulement: 2, isMauvaise: true },
|
||
{ code: "reflet+4", name: "Reflet d'ancien Rêve", type: "reflet", genre: "m", force: "2d6+4", refoulement: 2, isPersistant: true, isMauvaise: true },
|
||
{ code: "tbblanc+4", name: "Tourbillon blanc", type: "tbblanc", genre: "m", force: "2d6+4", refoulement: 2, isPersistant: true, isMauvaise: true },
|
||
{ code: "tbnoir+4", name: "Tourbillon noir", type: "tbnoir", genre: "m", force: "2d8+4", refoulement: 2, isPersistant: true, isMauvaise: true },
|
||
{ code: "passfou", name: "Passeur fou", type: "passeurfou", genre: "m", force: "2d8", refoulement: 2, isMauvaise: true },
|
||
{ code: "tbrouge", name: "Tourbillon rouge", type: "tbrouge", genre: "m", force: "2d8", refoulement: 3, isPersistant: true, isMauvaise: true }
|
||
]
|
||
|
||
/* -------------------------------------------- */
|
||
const rencontresStandard = [
|
||
{ code: "messager", name: "Messager des Rêves", type: "messager", genre: "m", force: "2d4", ignorer: true },
|
||
{ code: "passeur", name: "Passeur des Rêves", type: "passeur", genre: "m", force: "2d4", ignorer: true },
|
||
{ code: "fleur", name: "Fleur des Rêves", type: "fleur", genre: "f", force: "1d6", ignorer: true },
|
||
{ code: "mangeur", name: "Mangeur de Rêve", type: "mangeur", genre: "m", force: "1d6" },
|
||
{ code: "changeur", name: "Changeur de Rêve", type: "changeur", genre: "m", force: "2d6" },
|
||
{ code: "briseur", name: "Briseur de Rêve", type: "briseur", genre: "m", force: "2d6", quitterTMR: true },
|
||
{ code: "reflet", name: "Reflet d'ancien Rêve", type: "reflet", genre: "m", force: "2d6", isPersistant: true },
|
||
{ code: "tbblanc", name: "Tourbillon blanc", type: "tbblanc", genre: "m", force: "2d6", isPersistant: true },
|
||
{ code: "tbnoir", name: "Tourbillon noir", type: "tbnoir", genre: "m", force: "2d8", isPersistant: true },
|
||
{ code: "rdd", name: "Rêve de Dragon", type: "rdd", genre: "m", force: "1dr + 7", refoulement: 2, quitterTMR: true }
|
||
];
|
||
|
||
const rencontresPresentCite = [
|
||
{ code: "messager2d6", name: "Messager des Rêves", type: "messager", genre: "m", force: "2d6", ignorer: true },
|
||
{ code: "passeur2d6", name: "Passeur des Rêves", type: "passeur", genre: "m", force: "2d6", ignorer: true },
|
||
{ code: "fleur2d6", name: "Fleur des Rêves", type: "fleur", genre: "f", force: "2d6", ignorer: true }
|
||
]
|
||
const rencontresAll = [].concat(rencontresStandard).concat(mauvaisesRencontres).concat(rencontresPresentCite);
|
||
|
||
const tableRencontres = {
|
||
cite: [{ code: 'messager', range: [1, 25] }, { code: 'passeur', range: [26, 50] }, { code: 'fleur', range: [51, 65] }, { code: 'mangeur', range: [66, 70] }, { code: 'changeur', range: [71, 80] }, { code: 'briseur', range: [81, 85] }, { code: 'reflet', range: [86, 90] }, { code: 'tbblanc', range: [91, 94] }, { code: 'tbnoir', range: [95, 97] }, { code: 'rdd', range: [98, 100] }],
|
||
sanctuaire: [{ code: 'messager', range: [1, 25] }, { code: 'passeur', range: [26, 50] }, { code: 'fleur', range: [51, 65] }, { code: 'mangeur', range: [66, 70] }, { code: 'changeur', range: [71, 80] }, { code: 'briseur', range: [81, 85] }, { code: 'reflet', range: [86, 90] }, { code: 'tbblanc', range: [91, 94] }, { code: 'tbnoir', range: [95, 97] }, { code: 'rdd', range: [98, 100] }],
|
||
plaines: [{ code: 'messager', range: [1, 20] }, { code: 'passeur', range: [21, 40] }, { code: 'fleur', range: [41, 55] }, { code: 'mangeur', range: [56, 60] }, { code: 'changeur', range: [61, 75] }, { code: 'briseur', range: [76, 82] }, { code: 'reflet', range: [83, 88] }, { code: 'tbblanc', range: [89, 93] }, { code: 'tbnoir', range: [94, 97] }, { code: 'rdd', range: [98, 100] }],
|
||
pont: [{ code: 'messager', range: [1, 20] }, { code: 'passeur', range: [21, 40] }, { code: 'fleur', range: [41, 55] }, { code: 'mangeur', range: [56, 60] }, { code: 'changeur', range: [61, 75] }, { code: 'briseur', range: [76, 82] }, { code: 'reflet', range: [83, 88] }, { code: 'tbblanc', range: [89, 93] }, { code: 'tbnoir', range: [94, 97] }, { code: 'rdd', range: [98, 100] }],
|
||
collines: [{ code: 'messager', range: [1, 15] }, { code: 'passeur', range: [16, 30] }, { code: 'fleur', range: [31, 42] }, { code: 'mangeur', range: [43, 54] }, { code: 'changeur', range: [55, 69] }, { code: 'briseur', range: [70, 82] }, { code: 'reflet', range: [83, 88] }, { code: 'tbblanc', range: [89, 93] }, { code: 'tbnoir', range: [94, 97] }, { code: 'rdd', range: [98, 100] }],
|
||
foret: [{ code: 'messager', range: [1, 15] }, { code: 'passeur', range: [16, 30] }, { code: 'fleur', range: [31, 42] }, { code: 'mangeur', range: [43, 54] }, { code: 'changeur', range: [55, 69] }, { code: 'briseur', range: [70, 82] }, { code: 'reflet', range: [83, 88] }, { code: 'tbblanc', range: [89, 93] }, { code: 'tbnoir', range: [94, 97] }, { code: 'rdd', range: [98, 100] }],
|
||
monts: [{ code: 'messager', range: [1, 10] }, { code: 'passeur', range: [11, 20] }, { code: 'fleur', range: [21, 26] }, { code: 'mangeur', range: [27, 44] }, { code: 'changeur', range: [45, 59] }, { code: 'briseur', range: [60, 75] }, { code: 'reflet', range: [76, 85] }, { code: 'tbblanc', range: [86, 92] }, { code: 'tbnoir', range: [93, 97] }, { code: 'rdd', range: [98, 100] }],
|
||
desert: [{ code: 'messager', range: [1, 10] }, { code: 'passeur', range: [11, 20] }, { code: 'fleur', range: [21, 26] }, { code: 'mangeur', range: [27, 44] }, { code: 'changeur', range: [45, 59] }, { code: 'briseur', range: [60, 75] }, { code: 'reflet', range: [76, 85] }, { code: 'tbblanc', range: [86, 92] }, { code: 'tbnoir', range: [93, 97] }, { code: 'rdd', range: [98, 100] }],
|
||
fleuve: [{ code: 'messager', range: [1, 5] }, { code: 'passeur', range: [6, 10] }, { code: 'fleur', range: [11, 13] }, { code: 'mangeur', range: [14, 37] }, { code: 'changeur', range: [38, 49] }, { code: 'briseur', range: [50, 65] }, { code: 'reflet', range: [66, 79] }, { code: 'tbblanc', range: [80, 89] }, { code: 'tbnoir', range: [90, 97] }, { code: 'rdd', range: [98, 100] }],
|
||
lac: [{ code: 'messager', range: [1, 5] }, { code: 'passeur', range: [6, 10] }, { code: 'fleur', range: [11, 13] }, { code: 'mangeur', range: [14, 37] }, { code: 'changeur', range: [38, 49] }, { code: 'briseur', range: [50, 65] }, { code: 'reflet', range: [66, 79] }, { code: 'tbblanc', range: [80, 89] }, { code: 'tbnoir', range: [90, 97] }, { code: 'rdd', range: [98, 100] }],
|
||
marais: [{ code: 'messager', range: [1, 2] }, { code: 'passeur', range: [3, 4] }, { code: 'fleur', range: [5, 5] }, { code: 'mangeur', range: [6, 29] }, { code: 'changeur', range: [30, 39] }, { code: 'briseur', range: [40, 60] }, { code: 'reflet', range: [61, 75] }, { code: 'tbblanc', range: [76, 86] }, { code: 'tbnoir', range: [87, 97] }, { code: 'rdd', range: [98, 100] }],
|
||
gouffre: [{ code: 'messager', range: [1, 2] }, { code: 'passeur', range: [3, 4] }, { code: 'fleur', range: [5, 5] }, { code: 'mangeur', range: [6, 29] }, { code: 'changeur', range: [30, 39] }, { code: 'briseur', range: [40, 60] }, { code: 'reflet', range: [61, 75] }, { code: 'tbblanc', range: [76, 86] }, { code: 'tbnoir', range: [87, 97] }, { code: 'rdd', range: [98, 100] }],
|
||
necropole: [{ code: 'mangeur', range: [1, 20] }, { code: 'changeur', range: [21, 30] }, { code: 'briseur', range: [31, 50] }, { code: 'reflet', range: [51, 65] }, { code: 'tbblanc', range: [66, 80] }, { code: 'tbnoir', range: [81, 97] }, { code: 'rdd', range: [98, 100] }],
|
||
desolation: [{ code: 'mangeur', range: [1, 20] }, { code: 'changeur', range: [21, 30] }, { code: 'briseur', range: [31, 50] }, { code: 'reflet', range: [51, 65] }, { code: 'tbblanc', range: [66, 80] }, { code: 'tbnoir', range: [81, 97] }, { code: 'rdd', range: [98, 100] }]
|
||
}
|
||
|
||
|
||
/* -------------------------------------------- */
|
||
export class TMRRencontres {
|
||
static gestionRencontre = {}
|
||
|
||
/* -------------------------------------------- */
|
||
static init() {
|
||
for (let type in typeRencontres) {
|
||
TMRRencontres.register(type, typeRencontres[type]);
|
||
}
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
static register(type, rencontre) {
|
||
TMRRencontres.gestionRencontre[type] = rencontre;
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
/**
|
||
* Retourne une recontre en fonction de la case et du tirage
|
||
* @param {*} terrain
|
||
* @param {*} roll
|
||
*/
|
||
static async rollRencontre(terrain, roll = undefined) {
|
||
if (!terrain) {
|
||
ChatMessage.create({ content: "Un type de case doit être indiqué (par exemple sanctuaire, desert ou cité)" });
|
||
return false;
|
||
}
|
||
if (!roll || roll <= 0 || roll > 100) {
|
||
roll = await RdDDice.rollTotal("1d100");
|
||
}
|
||
let rencontre = await TMRRencontres.getRencontreAleatoire(terrain, roll);
|
||
ChatMessage.create({
|
||
user: game.user.id,
|
||
whisper: [game.user.id],
|
||
content: `Rencontre en ${terrain} (jet : ${roll}%)<br>Vous rencontrez un ${rencontre.name} de ${rencontre.force} Points de Rêve`
|
||
});
|
||
return false;
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
static getRencontre(index) {
|
||
let rencontre;
|
||
if (isNaN(index)) {
|
||
rencontre = rencontresAll.find(r => r.type == index) ?? rencontresAll.find(r => r.code == index)
|
||
}
|
||
else if (0 <= index && index < rencontresAll.length) {
|
||
rencontre = rencontresAll[index];
|
||
}
|
||
if (rencontre) {
|
||
return duplicate(rencontre);
|
||
}
|
||
else {
|
||
ui.notifications.info(`Pas de rencontre pour ${index}, seulement ${rencontresAll.length} rencontres sont connues.<br>Vous pouvez aussi essayer par type (ie: mangeur, fleur, fleur2d6, ...)`)
|
||
}
|
||
return undefined;
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
static async getRencontreAleatoire(terrain, roll = undefined) {
|
||
if (!roll || roll <= 0 || roll > 100) {
|
||
roll = await RdDDice.rollTotal("1d100");
|
||
}
|
||
terrain = Grammar.toLowerCaseNoAccent(terrain);
|
||
const code = tableRencontres[terrain].find(it => it.range[0] <= roll && roll <= it.range[1]).code;
|
||
const rencontre = duplicate(rencontresStandard.find(it => it.code == code));
|
||
rencontre.roll = roll;
|
||
await TMRRencontres.evaluerForceRencontre(rencontre);
|
||
return rencontre;
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
static async getMauvaiseRencontre(index = undefined) {
|
||
const rencontre = duplicate(
|
||
(index && index >= 0 && index < mauvaisesRencontres.length)
|
||
? mauvaisesRencontres[index]
|
||
: await RdDDice.rollOneOf(mauvaisesRencontres));
|
||
await TMRRencontres.evaluerForceRencontre(rencontre);
|
||
return rencontre;
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
static async evaluerForceRencontre(rencontre) {
|
||
const rollForce = new Roll(rencontre.force);
|
||
await rollForce.evaluate();
|
||
rencontre.force = rollForce.total;
|
||
return rencontre.force;
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
static isReveDeDragon(rencontre) {
|
||
return rencontre.type == "rdd";
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
static getGestionRencontre(name) {
|
||
let gestion = TMRRencontres.gestionRencontre[name];
|
||
if (!gestion) {
|
||
ui.notifications.error(`La rencontre ${name} est inconnue, pas de méthode de gestion associée`)
|
||
gestion = TMRRencontres.gestionRencontre['messager'];
|
||
}
|
||
return gestion;
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
static async gererRencontre(tmrDialog, rencData) {
|
||
let gestion = TMRRencontres.getGestionRencontre(rencData.rencontre.type);
|
||
if (rencData.rolled.isSuccess) {
|
||
rencData.message = gestion.msgSucces(rencData);
|
||
if (rencData.nbRounds > 1) {
|
||
rencData.message += ` Au total, vous avez passé ${rencData.nbRounds} rounds à vous battre!`;
|
||
}
|
||
rencData.poesie = gestion.poesieSucces;
|
||
return gestion.postSucces;
|
||
}
|
||
|
||
rencData.message = gestion.msgEchec(rencData);
|
||
if (rencData.nbRounds > 1) {
|
||
rencData.message += ` Vous avez passé ${rencData.nbRounds} rounds à lutter!`;
|
||
}
|
||
rencData.poesie = gestion.poesieEchec;
|
||
return gestion.postEchec;
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
static async msgEchecPasseurFou(tmrData) {
|
||
tmrData.sortReserve = Misc.templateData(tmrData.actor).reve.reserve.list[0];
|
||
if (tmrData.sortReserve) {
|
||
// Passeur fou positionne sur la case d'un ort en réserve // TODO : Choisir le sort le plus loin ou au hasard
|
||
tmrData.newTMR = TMRUtility.getTMR(tmrData.sortReserve.coord);
|
||
} else {
|
||
// Déplacement aléatoire de la force du Passeur Fou
|
||
const newCoord = await RdDDice.rollOneOf(TMRUtility.getTMRPortee(tmrData.tmr.coord, tmrData.rencontre.force));
|
||
tmrData.newTMR = TMRUtility.getTMR(newCoord);
|
||
}
|
||
if (tmrData.sortReserve) {
|
||
return `Le ${tmrData.rencontre.name} vous dérobe la clé de vos sorts. Vous vous saisissez de lui, mais dans un nuage violet, il vous emporte en ${tmrData.newTMR.label} déclencher votre sort en réserve de ${tmrData.sortReserve.name}.`;
|
||
}
|
||
else {
|
||
return `Le ${tmrData.rencontre.name} tente de vous dérober la clé de vos sorts. Ne la trouvant pas, il déclenche un nuage violet et vous emporte en ${tmrData.newTMR.label}`;
|
||
}
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
static async postEchecPasseurFou(tmrDialog, tmrData) {
|
||
if (tmrData.sortReserve) {
|
||
await tmrDialog.processSortReserve(tmrData.sortReserve);
|
||
}
|
||
await tmrDialog.forceDemiRevePosition(tmrData.newTMR.coord);
|
||
if (tmrData.sortReserve) {
|
||
tmrDialog.close();
|
||
}
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
static async onPostEchecTourbillon(tmrDialog, tmrData, cases) {
|
||
await tmrData.actor.reveActuelIncDec(-cases);
|
||
await TMRRencontres._toubillonner(tmrDialog, tmrData.actor, cases);
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
static async onPostEchecTourbillonRouge(tmrDialog, data) {
|
||
await data.actor.reveActuelIncDec(-2); // -2 pts de Reve a chaque itération
|
||
TMRRencontres._toubillonner(tmrDialog, data.actor, 4);
|
||
await data.actor.santeIncDec("vie", -1); // Et -1 PV
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
static async _toubillonner(tmrDialog, actor, cases) {
|
||
let coord = Misc.templateData(actor).reve.tmrpos.coord;
|
||
for (let i = 0; i < cases; i++) {
|
||
coord = await TMRUtility.deplaceTMRAleatoire(actor, coord).coord;
|
||
}
|
||
await tmrDialog.forceDemiRevePosition(coord)
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
static async onPostSuccessReveDeDragon(tmrDialog, tmrData) {
|
||
if (tmrData.rolled.isPart) {
|
||
await tmrData.actor.appliquerAjoutExperience(tmrData, true);
|
||
}
|
||
await tmrData.actor.resultCombatReveDeDragon(tmrData);
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
static async onPostEchecReveDeDragon(tmrDialog, tmrData) {
|
||
await tmrData.actor.resultCombatReveDeDragon(tmrData);
|
||
tmrDialog.close();
|
||
}
|
||
}
|
||
|