fvtt-pegasus-rpg/modules/pegasus-create-char.js

334 lines
12 KiB
JavaScript
Raw Normal View History

2022-01-06 18:22:05 +01:00
import { PegasusUtility } from "./pegasus-utility.js";
import { PegasusActor } from "./pegasus-actor.js";
import { PegasusActorSheet } from "./pegasus-actor-sheet.js";
export class PegasusActorCreate {
/* -------------------------------------------- */
async start() {
this.actor = await Actor.create({
name: "New Actor",
type: "character"
});
this.actor.sheet.render(true);
const racesPack = await PegasusUtility.loadCompendium("fvtt-pegasus-rpg.race");
this.races = racesPack.map(i => i.toObject());
const rolesPack = await PegasusUtility.loadCompendium("fvtt-pegasus-rpg.role");
this.roles = rolesPack.map(i => i.toObject());
2022-01-12 16:25:55 +01:00
const perksPack = await PegasusUtility.loadCompendium("fvtt-pegasus-rpg.perk");
this.perks = perksPack.map(i => i.toObject());
2022-01-06 18:22:05 +01:00
this.showRaces()
}
/* -------------------------------------------- */
createFormData(step) {
let formData = {
name: this.actor.name,
img: this.actor.img,
step: step,
races: this.races,
2022-01-07 20:40:40 +01:00
roles: this.roles,
nboptionnal: this.raceOptionnalAbilities?.nboptionnal?? 0,
optionnalabilities: this.raceOptionnalAbilities?.optionnalabilities?? [],
}
if ( this.raceSelectableStats ) {
formData.numberstats = this.raceSelectableStats.numberstats;
formData.statsonlyonce = this.raceSelectableStats.statsonlyonce;
formData.stats = this.raceSelectableStats.stats;
2022-01-06 18:22:05 +01:00
}
return formData;
}
/* -------------------------------------------- */
processChatEvent( event ) {
const step = $(event.currentTarget).data("step-name");
const itemId = $(event.currentTarget).data("item-id");
2022-01-08 18:28:01 +01:00
2022-01-06 18:22:05 +01:00
if ( step == "select-race") {
let race = this.races.find( item => item._id == itemId);
2022-01-08 18:28:01 +01:00
this.currentRace = race;
2022-01-07 20:40:40 +01:00
this.actor.applyRace( race);
PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
if ( race.data.nboptionnal > 0 && race.data.optionnalabilities.length > 0) {
this.manageOptionnalAbilities(race);
} else {
if ( race.data.selectablestats ) {
this.manageSelectableStats(race);
2022-01-08 18:28:01 +01:00
} else if ( race.data.perksgained) {
2022-01-12 16:25:55 +01:00
this.manageRacePerks(race);
2022-01-07 20:40:40 +01:00
} else {
this.showRoles()
}
}
}
if ( step == 'select-race-optionnal') {
let ability = this.raceOptionnalAbilities.optionnalabilities.find( item => item._id == itemId);
2022-01-11 23:35:23 +01:00
let update = []
this.actor.applyAbility( ability, update );
this.actor.update( update )
2022-01-07 20:40:40 +01:00
this.actor.createEmbeddedDocuments( 'Item', [ability]);
PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
this.raceOptionnalAbilities.optionnalabilities = this.raceOptionnalAbilities.optionnalabilities.filter( item => item._id != itemId);
this.raceOptionnalAbilities.nboptionnal -= 1;
this.processOptionnalAbilitiesStep();
}
if (step == 'select-race-stats') {
let statKey = $(event.currentTarget).data("stat-key");
this.actor.modStat( statKey, 1);
this.raceSelectableStats.stats[statKey].used = true;
this.raceSelectableStats.numberstats -=1;
PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
this.processSelectableStats();
}
2022-01-12 16:25:55 +01:00
if (step == 'select-race-perks') {
2022-01-08 18:28:01 +01:00
PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
let perk = this.racePerks.find( item => item._id == itemId);
this.actor.createEmbeddedDocuments( 'Item', [perk]);
this.racePerks = this.racePerks.filter( item => item._id != itemId);
2022-01-12 16:25:55 +01:00
this.nbRacePerks -= 1;
if ( this.nbRacePerks == 0 || this.racePerks.length == 0) {
2022-01-08 18:28:01 +01:00
this.showRoles()
2022-01-12 16:25:55 +01:00
} else {
this.manageRacePerks()
2022-01-08 18:28:01 +01:00
}
}
2022-01-07 20:40:40 +01:00
if ( step == 'select-role') {
let role = this.roles.find( item => item._id == itemId);
2022-01-08 10:49:08 +01:00
PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
2022-01-07 20:40:40 +01:00
this.actor.applyRole( role );
2022-01-08 10:49:08 +01:00
this.currentRole = role;
this.nbRoleStat = 2;
this.roleStats = duplicate(role.data.statincreasechoice)
2022-01-10 08:00:27 +01:00
this.showRoleStartSpec( );
}
if ( step == 'select-role-start-spec') {
PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
let spec = this.roleSpecStart.find( item => item._id == itemId);
this.actor.addIncSpec(spec, 1);
this.nbRoleSpecStart--;
this.roleSpecStart = this.roleSpecStart.filter( item => item._id != itemId);//Remove selected spec
if( this.nbRoleSpecStart == 0) {
this.showRoleStat( );
} else {
this.showRoleStartSpec( );
}
2022-01-08 10:49:08 +01:00
}
if ( step == 'select-role-stat') {
PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
let statKey = $(event.currentTarget).data("stat-key");
this.actor.valueStat( statKey, 1);
for (let stat of this.roleStats ) {
if ( stat.name.toLowerCase() == statKey.toLowerCase()) {
stat.flag = false
}
}
this.nbRoleStat--;
if ( this.nbRoleStat == 0 || this.roleStats.length == 0) {
this.roleSpec = duplicate(this.currentRole.data.specincrease)
this.nbDT2 = 1;
this.nbDT1 = 2;
this.showRoleSpecialisations()
} else{
this.showRoleStat( );
}
}
if (step == 'select-role-spec') {
PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
let spec = this.roleSpec.find( item => item._id == itemId);
if (this.nbDT2 > 0) {
this.actor.addIncSpec(spec, 2)
this.nbDT2--;
} else {
this.actor.addIncSpec(spec, 1)
this.nbDT1--;
}
this.roleSpec = this.roleSpec.filter( item => item._id != itemId);//Remove selected spec
if ( this.nbDT1 == 0 || this.roleSpec.length == 0) {
this.rolePerks = duplicate(this.currentRole.data.perks)
this.nbPerks = 2;
this.showRolePerks()
} else {
this.showRoleSpecialisations()
}
}
if (step == 'select-role-perk') {
PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
let perk = this.rolePerks.find( item => item._id == itemId);
this.actor.addItemWithoutDuplicate(perk)
this.nbPerks--;
this.rolePerks = this.rolePerks.filter( item => item._id != itemId);//Remove selected perk
if (this.nbPerks == 0 || this.rolePerks.length == 0) {
this.showCharacterEnd()
} else {
this.showRolePerks()
}
2022-01-06 18:22:05 +01:00
}
}
2022-01-07 20:40:40 +01:00
/* -------------------------------------------- */
manageSelectableStats( race ) {
this.raceSelectableStats = {
"race": race,
"statsonlyonce": race.data.statsonlyonce,
"numberstats": race.data.numberstats,
"stats": duplicate(this.actor.data.data.statistics)
}
this.processSelectableStats()
}
2022-01-08 18:28:01 +01:00
/* -------------------------------------------- */
async renderChatMessage( formData) {
let chatData = {
user: game.user.id,
alias : this.actor.name,
rollMode: game.settings.get("core", "rollMode"),
whisper: [game.user.id].concat( ChatMessage.getWhisperRecipients('GM') ),
content: await renderTemplate('systems/fvtt-pegasus-rpg/templates/chat-create-actor.html', formData)
};
//console.log("Apply damage chat", chatData );
await ChatMessage.create( chatData );
}
/* --------------- -------------------- --------- */
manageRacePerks(race) {
2022-01-12 16:25:55 +01:00
console.log("MANAG RACE PERKsS", this.currentRace)
if ( !this.currentRace.data.perksgained ) {
this.showRoles()
return;
2022-01-08 18:28:01 +01:00
}
2022-01-12 16:25:55 +01:00
console.log("MANAG RACE PERKsS 2", this.currentRace)
if ( !this.racePerks) { // First init
if ( this.currentRace.data.perksall) {
this.racePerks = duplicate(this.perks)
} else {
this.racePerks = duplicate(this.currentRace.data.perks)
}
this.nbRacePerks = this.currentRace.data.perksnumber;
2022-01-08 18:28:01 +01:00
}
2022-01-12 16:25:55 +01:00
let formData = this.createFormData("select-race-perks")
formData.raceperks = this.racePerks;
formData.nbraceperks = this.nbRacePerks;
2022-01-08 18:28:01 +01:00
this.renderChatMessage(formData)
}
/* --------------- -------------------- --------- */
2022-01-07 20:40:40 +01:00
async processSelectableStats() {
// End of race options choice
if ( this.raceSelectableStats.numberstats == 0) {
2022-01-12 16:25:55 +01:00
this.manageRacePerks();
2022-01-07 20:40:40 +01:00
return;
}
let formData = this.createFormData("select-race-stats")
let chatData = {
user: game.user.id,
alias : this.actor.name,
rollMode: game.settings.get("core", "rollMode"),
whisper: [game.user.id].concat( ChatMessage.getWhisperRecipients('GM') ),
content: await renderTemplate('systems/fvtt-pegasus-rpg/templates/chat-create-actor.html', formData)
};
//console.log("Apply damage chat", chatData );
await ChatMessage.create( chatData );
}
/* --------------- ----------------------------- */
manageOptionnalAbilities( race) {
this.raceOptionnalAbilities = {
"nboptionnal": race.data.nboptionnal,
"optionnalabilities": duplicate(race.data.optionnalabilities),
}
this.processOptionnalAbilitiesStep()
}
/* -------------------------------------------- */
async processOptionnalAbilitiesStep() {
// End of race options choice
if ( this.raceOptionnalAbilities.nboptionnal == 0) {
if ( this.raceSelectableStats ) {
2022-01-08 18:28:01 +01:00
this.manageSelectableStats(this.currentrace);
} else if ( this.currentRace.data.perksgained) {
this.manageRacePerks(this.currentRace);
2022-01-07 20:40:40 +01:00
} else {
this.showRoles()
}
2022-01-08 18:28:01 +01:00
} else {
let formData = this.createFormData("select-race-optionnal")
this.renderChatMessage( formData)
2022-01-07 20:40:40 +01:00
}
}
2022-01-06 18:22:05 +01:00
/* -------------------------------------------- */
async showRaces() {
let formData = this.createFormData("select-race")
2022-01-08 18:28:01 +01:00
this.renderChatMessage( formData)
2022-01-06 18:22:05 +01:00
}
/* -------------------------------------------- */
async showRoles() {
2022-01-07 20:40:40 +01:00
let formData = this.createFormData("select-role")
2022-01-08 18:28:01 +01:00
this.renderChatMessage( formData)
2022-01-06 18:22:05 +01:00
}
2022-01-08 10:49:08 +01:00
2022-01-10 08:00:27 +01:00
/* ------------------------------- ------------- */
async showRoleStartSpec() {
if ( !this.roleSpecStart) {
this.roleSpecStart = duplicate(this.currentRole.data.specialisationsplus1)
this.nbRoleSpecStart = 2;
}
let formData = this.createFormData("select-role-start-spec")
formData.rolestartspec = this.roleSpecStart
formData.nbrolespecstart = this.nbRoleSpecStart;
this.renderChatMessage( formData)
}
/* ------------------------------- ------------- */
2022-01-08 10:49:08 +01:00
async showRoleStat( ) {
let formData = this.createFormData("select-role-stat")
formData.rolestats = []
for(let stat of this.roleStats) {
if (stat.flag) {
formData.rolestats.push( duplicate(this.actor.data.data.statistics[stat.name.toLowerCase()]) )
}
}
console.log("STAT", this.roleStats, formData)
2022-01-08 18:28:01 +01:00
this.renderChatMessage( formData)
2022-01-08 10:49:08 +01:00
}
/* -------------------------------------------- */
async showRoleSpecialisations() {
let formData = this.createFormData("select-role-spec")
formData.rolespec = duplicate(this.roleSpec)
formData.dt = 1
if (this.nbDT2 > 0 ) {
formData.dt = 2
}
2022-01-08 18:28:01 +01:00
this.renderChatMessage( formData)
2022-01-08 10:49:08 +01:00
}
/* -------------------------------------------- */
async showRolePerks() {
let formData = this.createFormData("select-role-perk")
formData.roleperks = duplicate(this.rolePerks)
formData.nbperks = this.nbPerks
2022-01-08 18:28:01 +01:00
this.renderChatMessage( formData)
2022-01-08 10:49:08 +01:00
}
/* -------------------------------------------- */
async showCharacterEnd() {
this.actor.computeNRGHealth()
let formData = this.createFormData("character-end")
2022-01-08 18:28:01 +01:00
this.renderChatMessage( formData)
2022-01-08 10:49:08 +01:00
}
2022-01-06 18:22:05 +01:00
}