605 lines
21 KiB
JavaScript
605 lines
21 KiB
JavaScript
import { TeDeumUtility } from "../common/tedeum-utility.js";
|
|
import { TeDeumActor } from "../actors/tedeum-actor.js";
|
|
export class TeDeumCharacterCreator {
|
|
|
|
/*--------------------------------------------*/
|
|
async init() {
|
|
this.stages = {}
|
|
this.currentStage = "origineSociale"
|
|
this.sex = undefined
|
|
this.origineSociale = undefined
|
|
this.religion = undefined
|
|
this.caracBonus = {}
|
|
this.competenceBonus = {}
|
|
this.competences = TeDeumUtility.getCompetencesForDropDown()
|
|
|
|
for (let k in game.system.tedeum.config.caracteristiques) {
|
|
this.caracBonus[k] = { value: 0 }
|
|
}
|
|
|
|
for (let stage in game.system.tedeum.config.etapesEducation) {
|
|
this.stages[stage] = { selectedItem: null, items: [] }
|
|
}
|
|
|
|
const educations = await TeDeumUtility.loadCompendium("fvtt-te-deum.education")
|
|
for (let edu of educations) {
|
|
this.stages[edu.system.etape].items.push(edu)
|
|
}
|
|
|
|
this.processStage()
|
|
}
|
|
|
|
/*--------------------------------------------*/
|
|
increaseCompetence(compName) {
|
|
if (compName === "" || compName == undefined || compName == "undefined") { return }
|
|
compName = compName.toLowerCase()
|
|
if (!this.competenceBonus[compName]) {
|
|
this.competenceBonus[compName] = { value: 1 }
|
|
} else {
|
|
this.competenceBonus[compName].value += 1
|
|
}
|
|
}
|
|
|
|
/*--------------------------------------------*/
|
|
processReponses(question) {
|
|
let fullResponses = []
|
|
for (let key in question.reponses) {
|
|
let response = question.reponses[key]
|
|
fullResponses.push({ id: key, label: `${response.reponse} (${TeDeumUtility.upperFirst( response.compName)} +1)` })
|
|
}
|
|
return fullResponses
|
|
}
|
|
|
|
/*--------------------------------------------*/
|
|
processReponsesRadio(question) {
|
|
let fullResponses = {}
|
|
let selected = true
|
|
for (let key in question.reponses) {
|
|
let response = question.reponses[key]
|
|
if (response.toSelect) {
|
|
fullResponses[key] = { label: `${response.reponse}`, competences: response.compList, selected }
|
|
} else {
|
|
fullResponses[key] = { label: `${response.reponse} (${response.compName} +1)`, selected }
|
|
}
|
|
selected = false
|
|
}
|
|
return fullResponses
|
|
}
|
|
|
|
/*--------------------------------------------*/
|
|
async askStageName(context) {
|
|
const content = await renderTemplate("systems/fvtt-te-deum/templates/dialogs/character-creator-select-stage-name.hbs", context)
|
|
const choiceResult = await foundry.applications.api.DialogV2.wait({
|
|
window: { title: context.title },
|
|
classes: ["fvtt-te-deum"],
|
|
content,
|
|
buttons: [
|
|
{
|
|
label: context.label,
|
|
callback: (event, button, dialog) => {
|
|
const output = Array.from(button.form.elements).reduce((obj, input) => {
|
|
if (input.name) obj[input.name] = input.value
|
|
return obj
|
|
}, {})
|
|
return output
|
|
},
|
|
},
|
|
],
|
|
actions: {
|
|
},
|
|
rejectClose: false, // Click on Close button will not launch an error
|
|
render: (event, dialog) => {
|
|
$(".stage-selector").change(event => {
|
|
let stageId = event.target.value
|
|
let stage = context.choices.find(item => item.id === stageId)
|
|
let link = `<a class="content-link" draggable="true" data-link=""
|
|
data-uuid="Compendium.fvtt-te-deum.education.Item.${stageId}" data-id="${stageId}" data-type="Item"
|
|
data-pack="fvtt-te-deum.education" data-tooltip="Education Objet"><i class="fas fa-suitcase"></i>${stage.name}</a>`
|
|
$(".stage-main-details").html(`Voir le détail : ${link}`)
|
|
})
|
|
|
|
document.getElementById("stage-selector").dispatchEvent(new Event('change'))
|
|
|
|
}
|
|
})
|
|
return choiceResult
|
|
}
|
|
|
|
/*--------------------------------------------*/
|
|
processCompetences(compList) {
|
|
for (let compName in compList) {
|
|
this.increaseCompetence(compName)
|
|
}
|
|
}
|
|
|
|
/*--------------------------------------------*/
|
|
async askQuestionnaire(stage, context) {
|
|
context.subtitle = "Questionnaire"
|
|
|
|
for (let key in stage.system.questionnaire) {
|
|
let question = stage.system.questionnaire[key]
|
|
if (question.question === "") { break }
|
|
|
|
context.question = question.question
|
|
context.responses = this.processReponses(question)
|
|
context.responsesRadio = this.processReponsesRadio(question)
|
|
context.competences = {}
|
|
context.responseKey = "reponse1" // By default
|
|
|
|
const content = await renderTemplate("systems/fvtt-te-deum/templates/dialogs/character-creator-select-questions.hbs", context)
|
|
const choiceResult = await foundry.applications.api.DialogV2.wait({
|
|
window: { title: context.title },
|
|
classes: ["fvtt-te-deum"],
|
|
content,
|
|
buttons: [
|
|
{
|
|
label: context.label,
|
|
callback: (event, button, dialog) => {
|
|
const output = Array.from(button.form.elements).reduce((obj, input) => {
|
|
if (input.name) obj[input.name] = input.value
|
|
return obj
|
|
}, {})
|
|
return output
|
|
},
|
|
},
|
|
],
|
|
actions: {
|
|
},
|
|
rejectClose: false, // Click on Close button will not launch an error
|
|
render: (event, dialog) => {
|
|
$(".questionnaire-radio").click(event => {
|
|
let responseKey = $(event.target).data("response-key")
|
|
context.responseKey = responseKey
|
|
})
|
|
$(".questionnaire-select-competence").change(event => {
|
|
// Get the responseKey data
|
|
let responseKey = $(event.target).data("response-key")
|
|
let compName = event.target.value
|
|
console.log("Questionnaire Change", responseKey, compName)
|
|
context.competences[responseKey] = compName.toLowerCase()
|
|
})
|
|
}
|
|
})
|
|
if (choiceResult == null) {
|
|
this.currentStage = "cancelled"
|
|
return
|
|
}
|
|
|
|
let selectedResponse = question.reponses[context.responseKey]
|
|
let compName = context.competences[context.responseKey] || selectedResponse.compName
|
|
this.increaseCompetence(compName)
|
|
}
|
|
}
|
|
|
|
/*------------- -------------------------------*/
|
|
async askCompetences(stage, context) {
|
|
context.subtitle = "Choix des Compétences"
|
|
|
|
context.fixedCompetences = {}
|
|
context.selectCompetences = {}
|
|
for (let compKey in stage.system.competences) {
|
|
let comp = stage.system.competences[compKey]
|
|
if (comp.valid && comp.compName !== "") {
|
|
if (comp.toSelect) {
|
|
context.hasSelectCompetences = true
|
|
context.selectCompetences[comp.compName] = TeDeumUtility.upperFirst(comp.compName)
|
|
} else {
|
|
context.fixedCompetences[comp.compName] = TeDeumUtility.upperFirst(comp.compName)
|
|
}
|
|
}
|
|
}
|
|
|
|
const content = await renderTemplate("systems/fvtt-te-deum/templates/dialogs/character-creator-select-competences.hbs", context)
|
|
const choiceResult = await foundry.applications.api.DialogV2.wait({
|
|
window: { title: context.title },
|
|
classes: ["fvtt-te-deum"],
|
|
content,
|
|
buttons: [
|
|
{
|
|
label: context.label,
|
|
callback: (event, button, dialog) => {
|
|
const output = Array.from(button.form.elements).reduce((obj, input) => {
|
|
if (input.name) obj[input.name] = input.value
|
|
return obj
|
|
}, {})
|
|
return output
|
|
},
|
|
},
|
|
],
|
|
actions: {
|
|
},
|
|
rejectClose: false, // Click on Close button will not launch an error
|
|
render: (event, dialog) => {
|
|
}
|
|
})
|
|
if (choiceResult == null) {
|
|
this.currentStage = "cancelled"
|
|
return
|
|
}
|
|
context.fixedCompetences[choiceResult.selectedCompetence] = choiceResult.selectedCompetence
|
|
this.processCompetences(context.fixedCompetences)
|
|
|
|
// Handle specific case when multiple skills can be selected (ie compagnon case)
|
|
if ( stage.system.hasCompetencesOpt ) {
|
|
context.fixedCompetences = []
|
|
context.hasSelectCompetences = true
|
|
for (let i = 0; i < stage.system.competencesOptNumber; i++) {
|
|
context.competences = {}
|
|
context.selectCompetences = {}
|
|
for (let compKey in stage.system.competencesOpt) {
|
|
let comp = stage.system.competencesOpt[compKey]
|
|
if (comp.compName !== "") {
|
|
context.selectCompetences[comp.compName] = TeDeumUtility.upperFirst(comp.compName)
|
|
}
|
|
}
|
|
|
|
const content = await renderTemplate("systems/fvtt-te-deum/templates/dialogs/character-creator-select-competences.hbs", context)
|
|
const choiceResult = await foundry.applications.api.DialogV2.wait({
|
|
window: { title: context.title },
|
|
classes: ["fvtt-te-deum"],
|
|
content,
|
|
buttons: [
|
|
{
|
|
label: context.label,
|
|
callback: (event, button, dialog) => {
|
|
const output = Array.from(button.form.elements).reduce((obj, input) => {
|
|
if (input.name) obj[input.name] = input.value
|
|
return obj
|
|
}, {})
|
|
return output
|
|
},
|
|
},
|
|
],
|
|
actions: {
|
|
},
|
|
rejectClose: false, // Click on Close button will not launch an error
|
|
render: (event, dialog) => {
|
|
}
|
|
})
|
|
if (choiceResult == null) {
|
|
this.currentStage = "cancelled"
|
|
return
|
|
}
|
|
context.fixedCompetences[choiceResult.selectedCompetence] = choiceResult.selectedCompetence
|
|
this.processCompetences(context.fixedCompetences)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/*------------- -------------------------------*/
|
|
async askCarac(stage, context) {
|
|
context.subtitle = "Choix des Caractéristiques"
|
|
|
|
let selected = []
|
|
for (let i = 0; i < stage.system.nbChoixCarac; i++) {
|
|
context.caracList = []
|
|
for (let caracKey in stage.system.caracteristiques) {
|
|
let carac = stage.system.caracteristiques[caracKey]
|
|
if (selected.includes(carac.caracId)) { continue }
|
|
context.caracList.push(game.system.tedeum.config.caracteristiques[carac.caracId])
|
|
}
|
|
|
|
const content = await renderTemplate("systems/fvtt-te-deum/templates/dialogs/character-creator-select-carac.hbs", context)
|
|
const choiceResult = await foundry.applications.api.DialogV2.wait({
|
|
window: { title: context.title },
|
|
classes: ["fvtt-te-deum"],
|
|
content,
|
|
buttons: [
|
|
{
|
|
label: context.label,
|
|
callback: (event, button, dialog) => {
|
|
const output = Array.from(button.form.elements).reduce((obj, input) => {
|
|
if (input.name) obj[input.name] = input.value
|
|
return obj
|
|
}, {})
|
|
return output
|
|
},
|
|
},
|
|
],
|
|
actions: {
|
|
},
|
|
rejectClose: false, // Click on Close button will not launch an error
|
|
render: (event, dialog) => {
|
|
}
|
|
})
|
|
if (choiceResult == null) {
|
|
this.currentStage = "cancelled"
|
|
return
|
|
}
|
|
this.caracBonus[choiceResult.carac].value += 1
|
|
selected.push(choiceResult.carac)
|
|
}
|
|
}
|
|
|
|
/*--------------------------------------------*/
|
|
async renderOrigineSociale(stage) {
|
|
let context = {
|
|
title: "Création de personnage",
|
|
subtitle: "Origine Sociale",
|
|
sexeChoice: { "Homme": "Homme", "Femme": "Femme" },
|
|
religionChoice: { "catholique": "Catholique", "protestante": "Protestante" },
|
|
origineChoice: game.system.tedeum.config.origineSociale
|
|
}
|
|
|
|
const content = await renderTemplate("systems/fvtt-te-deum/templates/dialogs/character-creator-origine.hbs", context)
|
|
const label = "Valider le choix de l'Origine Sociale"
|
|
const choiceResult = await foundry.applications.api.DialogV2.wait({
|
|
window: { title: context.title },
|
|
classes: ["fvtt-te-deum"],
|
|
content,
|
|
buttons: [
|
|
{
|
|
label: label,
|
|
callback: (event, button, dialog) => {
|
|
const output = Array.from(button.form.elements).reduce((obj, input) => {
|
|
if (input.name) obj[input.name] = input.value
|
|
return obj
|
|
}, {})
|
|
return output
|
|
},
|
|
},
|
|
],
|
|
actions: {
|
|
},
|
|
rejectClose: false, // Click on Close button will not launch an error
|
|
render: (event, dialog) => { }
|
|
})
|
|
|
|
if (choiceResult == null) {
|
|
this.currentStage = "cancelled"
|
|
return
|
|
}
|
|
|
|
this.sexe = choiceResult.sexe
|
|
this.religion = choiceResult.religion
|
|
this.origineSociale = foundry.utils.duplicate(game.system.tedeum.config.origineSociale[choiceResult.origineSociale])
|
|
for (let key in this.origineSociale.caracteristiques) {
|
|
this.caracBonus[key].value += this.origineSociale.caracteristiques[key]
|
|
}
|
|
this.currentStage = "pouponniere"
|
|
|
|
}
|
|
|
|
/*--------------------------------------------*/
|
|
async renderPouponniere(stage) {
|
|
|
|
// Filter available pouponniere from origineSociale
|
|
let pouponniereItems = stage.items.filter(item => item.system.accessible[this.origineSociale.id].isaccessible)
|
|
|
|
let context = {
|
|
title: "Création de personnage - La Pouponnière",
|
|
subtitle: "Choix de la Pouponnière",
|
|
label: "Valider le choix de la Pouponnière",
|
|
choices: pouponniereItems,
|
|
caracBonus: this.caracBonus,
|
|
competenceBonus: this.competenceBonus
|
|
}
|
|
let choiceResult = await this.askStageName(context)
|
|
if (choiceResult == null) {
|
|
this.currentStage = "cancelled"
|
|
return
|
|
}
|
|
|
|
this.pouponniere = foundry.utils.duplicate(stage.items.find(item => item.id === choiceResult.selectedItem))
|
|
context.title = `La Pouponnière - ${this.pouponniere.name}`
|
|
TeDeumUtility.prepareEducationContent(this.pouponniere);
|
|
|
|
context.label = "Valider l'augmentation de caracteristique"
|
|
await this.askCarac(this.pouponniere, context)
|
|
|
|
context.label = "Valider l'augmentation de compétences"
|
|
await this.askCompetences(this.pouponniere, context)
|
|
|
|
context.label = "Valider cette réponse"
|
|
await this.askQuestionnaire(this.pouponniere, context)
|
|
|
|
this.currentStage = "petitsgrimauds"
|
|
}
|
|
|
|
/*--------------------------------------------*/
|
|
async renderPetitsGrimauds(stage) {
|
|
// Filter available pouponniere from origineSociale
|
|
let grimaudsItems = stage.items.filter(item => item.system.accessible[this.origineSociale.id].isaccessible)
|
|
|
|
let context = {
|
|
title: "Les Petits Grimauds",
|
|
label: "Valider le choix des Petits Grimauds",
|
|
choices: grimaudsItems,
|
|
caracBonus: this.caracBonus,
|
|
competenceBonus: this.competenceBonus
|
|
}
|
|
|
|
let choiceResult = await this.askStageName(context)
|
|
if (choiceResult == null) {
|
|
this.currentStage = "cancelled"
|
|
return
|
|
}
|
|
|
|
this.grimauds = foundry.utils.duplicate(stage.items.find(item => item.id === choiceResult.selectedItem))
|
|
context.title = `LesPetits Grimauds - ${this.grimauds.name}`
|
|
TeDeumUtility.prepareEducationContent(this.grimauds);
|
|
|
|
context.label = "Valider l'augmentation de caracteristique"
|
|
await this.askCarac(this.grimauds, context)
|
|
context.label = "Valider l'augmentation de compétences"
|
|
await this.askCompetences(this.grimauds, context)
|
|
|
|
context.label = "Valider cette réponse"
|
|
await this.askQuestionnaire(this.grimauds, context)
|
|
|
|
this.currentStage = "rosevie"
|
|
}
|
|
|
|
/*--------------------------------------------*/
|
|
async renderRosesDeLaVie(stage) {
|
|
// Filter available pouponniere from origineSociale
|
|
let rosesItems = stage.items.filter(item => item.system.accessible[this.origineSociale.id].isaccessible)
|
|
|
|
let context = {
|
|
title: "Création de personnage - Les Roses de la Vie",
|
|
label: "Valider le choix des Roses de la Vie",
|
|
choices: rosesItems,
|
|
caracBonus: this.caracBonus,
|
|
competenceBonus: this.competenceBonus
|
|
|
|
}
|
|
|
|
let choiceResult = await this.askStageName(context)
|
|
if (choiceResult == null) {
|
|
this.currentStage = "cancelled"
|
|
return
|
|
}
|
|
|
|
this.roses = foundry.utils.duplicate(stage.items.find(item => item.id === choiceResult.selectedItem))
|
|
context.title = `Les Roses de la Vie - ${this.roses.name}`
|
|
TeDeumUtility.prepareEducationContent(this.roses);
|
|
|
|
context.label = "Valider l'augmentation de caracteristique"
|
|
await this.askCarac(this.roses, context)
|
|
context.label = "Valider l'augmentation de compétences"
|
|
await this.askCompetences(this.roses, context)
|
|
|
|
context.label = "Valider cette réponse"
|
|
await this.askQuestionnaire(this.roses, context)
|
|
|
|
this.currentStage = "ageviril"
|
|
}
|
|
|
|
/*--------------------------------------------*/
|
|
async renderAgeViril(stage) {
|
|
let virilDebouche = this.roses.system.debouches
|
|
let ageVirilItems = []
|
|
for (let key in virilDebouche) {
|
|
let debouche = virilDebouche[key]
|
|
if (debouche.debouche === "") { continue }
|
|
let deboucheItem = stage.items.find(item => item.name.toLowerCase().includes(debouche.debouche.toLowerCase()))
|
|
if (deboucheItem) {
|
|
ageVirilItems.push(deboucheItem)
|
|
} else {
|
|
console.log(`Debouche ${debouche.debouche} not found !`)
|
|
}
|
|
}
|
|
|
|
let context = {
|
|
title: "Création de personnage - L'Age Viril",
|
|
label: "Valider le choix de l'Age Viril",
|
|
choices: ageVirilItems,
|
|
caracBonus: this.caracBonus,
|
|
competenceBonus: this.competenceBonus
|
|
}
|
|
|
|
let choiceResult = await this.askStageName(context)
|
|
if (choiceResult == null) {
|
|
this.currentStage = "cancelled"
|
|
return
|
|
}
|
|
|
|
this.ageViril = foundry.utils.duplicate(stage.items.find(item => item.id === choiceResult.selectedItem))
|
|
context.title = `L'Age Viril - ${this.ageViril.name}`
|
|
TeDeumUtility.prepareEducationContent(this.ageViril);
|
|
|
|
context.label = "Valider l'augmentation de caracteristique"
|
|
await this.askCarac(this.ageViril, context)
|
|
context.label = "Valider l'augmentation de compétences"
|
|
await this.askCompetences(this.ageViril, context)
|
|
|
|
this.currentStage = "finished"
|
|
}
|
|
|
|
/*--------------------------------------------*/
|
|
async processStage() {
|
|
while (this.currentStage !== "finished") {
|
|
let stage = this.stages[this.currentStage]
|
|
switch (this.currentStage) {
|
|
case "origineSociale":
|
|
await this.renderOrigineSociale(stage)
|
|
break
|
|
case "pouponniere":
|
|
await this.renderPouponniere(stage)
|
|
break
|
|
case "petitsgrimauds":
|
|
await this.renderPetitsGrimauds(stage)
|
|
break
|
|
case "rosevie":
|
|
await this.renderRosesDeLaVie(stage)
|
|
break
|
|
case "ageviril":
|
|
await this.renderAgeViril(stage)
|
|
break
|
|
case "cancelled":
|
|
return
|
|
break
|
|
}
|
|
}
|
|
|
|
console.log("Carac Bonus", this.caracBonus)
|
|
console.log("Competence Bonus", this.competenceBonus)
|
|
let actor = await TeDeumActor.create({name: "Nouveau personnage", type: "pj"})
|
|
let updates = {}
|
|
for (let key in this.caracBonus) {
|
|
updates[`system.caracteristiques.${key}.value`] = Number(this.caracBonus[key].value)+1
|
|
}
|
|
updates['system.genre'] = this.sexe
|
|
updates['system.religion'] = TeDeumUtility.upperFirst(this.religion)
|
|
updates['system.statutocial'] = this.origineSociale.label
|
|
updates['system.equipmentfree'] = this.ageViril.system.trousseau
|
|
actor.update( updates);
|
|
|
|
// Process competences : increase know skills
|
|
let updateComp = []
|
|
let toAdd = []
|
|
for (let compName in this.competenceBonus) {
|
|
let comp = actor.items.find( i => i.type == "competence" && i.name.toLowerCase() === compName.toLowerCase())
|
|
if (comp) {
|
|
updateComp.push({ _id: comp._id, "system.score": this.competenceBonus[compName].value })
|
|
} else {
|
|
toAdd.push( compName)
|
|
}
|
|
}
|
|
actor.updateEmbeddedDocuments("Item", updateComp)
|
|
|
|
// Process adding skills
|
|
let compendiumSkill = TeDeumUtility.getCompetences()
|
|
let compToAdd = [ this.pouponniere, this.grimauds, this.roses, this.ageViril ]
|
|
for (let compName of toAdd) {
|
|
let comp = compendiumSkill.find( i => i.name.toLowerCase() === compName.toLowerCase())
|
|
comp.system.score = this.competenceBonus[compName].value
|
|
compToAdd.push(comp)
|
|
}
|
|
await actor.createEmbeddedDocuments('Item', compToAdd)
|
|
|
|
let newArgent = this.origineSociale.cagnotte * this.ageViril.system.cagnotteMultiplier
|
|
newArgent /= this.ageViril.system.cagnotteDivider
|
|
await actor.update({ [`system.fortune.${this.origineSociale.cagnotteUnit}`]: newArgent})
|
|
|
|
actor.render(true)
|
|
|
|
const content = await renderTemplate("systems/fvtt-te-deum/templates/dialogs/character-creator-finished.hbs", context)
|
|
const label = "Terminer"
|
|
const choiceResult = await foundry.applications.api.DialogV2.wait({
|
|
window: { title: context.title },
|
|
classes: ["fvtt-te-deum"],
|
|
content,
|
|
buttons: [
|
|
{
|
|
label: label,
|
|
callback: (event, button, dialog) => {
|
|
const output = Array.from(button.form.elements).reduce((obj, input) => {
|
|
if (input.name) obj[input.name] = input.value
|
|
return obj
|
|
}, {})
|
|
return output
|
|
},
|
|
},
|
|
],
|
|
actions: {
|
|
},
|
|
rejectClose: false, // Click on Close button will not launch an error
|
|
render: (event, dialog) => { }
|
|
})
|
|
|
|
}
|
|
|
|
}
|