294 lines
8.7 KiB
JavaScript
294 lines
8.7 KiB
JavaScript
/* -------------------------------------------- */
|
|
import { Imperium5Utility } from "./imperium5-utility.js";
|
|
import { Imperium5RollDialog } from "./imperium5-roll-dialog.js";
|
|
|
|
/* -------------------------------------------- */
|
|
/**
|
|
* Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
|
|
* @extends {Actor}
|
|
*/
|
|
export class Imperium5Actor extends Actor {
|
|
|
|
/* -------------------------------------------- */
|
|
/**
|
|
* Override the create() function to provide additional SoS functionality.
|
|
*
|
|
* This overrided create() function adds initial items
|
|
* Namely: Basic skills, money,
|
|
*
|
|
* @param {Object} data Barebones actor data which this function adds onto.
|
|
* @param {Object} options (Unused) Additional options which customize the creation workflow.
|
|
*
|
|
*/
|
|
|
|
static async create(data, options) {
|
|
|
|
// Case of compendium global import
|
|
if (data instanceof Array) {
|
|
return super.create(data, options);
|
|
}
|
|
// If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
|
|
if (items) {
|
|
let actor = super.create(data, options);
|
|
return actor;
|
|
}
|
|
|
|
if (data.type == 'character') {
|
|
|
|
}
|
|
|
|
return super.create(data, options);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
prepareBaseData() {
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async prepareData() {
|
|
super.prepareData();
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
prepareDerivedData() {
|
|
|
|
if (this.type == 'character') {
|
|
//this.system.encCapacity = this.getEncumbranceCapacity()
|
|
//this.buildContainerTree()
|
|
}
|
|
console.log("Acteur : ", this)
|
|
super.prepareDerivedData();
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
_preUpdate(changed, options, user) {
|
|
|
|
super._preUpdate(changed, options, user);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getArchetype() {
|
|
let item = duplicate( this.items.find( it => it.type == "archetype") || [])
|
|
return item
|
|
}
|
|
getSpecialites() {
|
|
let item = duplicate(this.items.filter( it => it.type == "specialite") || [] )
|
|
return item
|
|
}
|
|
getFamiliarites() {
|
|
let item = duplicate(this.items.filter( it => it.type == "familiarite") || [] )
|
|
return item
|
|
}
|
|
getNatureProfonde() {
|
|
let item = duplicate( this.items.find( it => it.type == "nature") || [])
|
|
return item
|
|
}
|
|
getTraits() {
|
|
let item = duplicate(this.items.filter( it => it.type == "trait") || [] )
|
|
return item
|
|
}
|
|
getSymbioses() {
|
|
let item = duplicate(this.items.filter( it => it.type == "symbiose") || [] )
|
|
return item
|
|
}
|
|
getEquipements() {
|
|
let item = duplicate(this.items.filter( it => it.type == "equipement") || [] )
|
|
return item
|
|
}
|
|
getCapacites() {
|
|
let item = duplicate(this.items.filter( it => it.type == "capacite") || [] )
|
|
return item
|
|
}
|
|
getUnusedCapacites(){
|
|
let item = this.items.filter( it => it.type == "capacite") || []
|
|
return item
|
|
}
|
|
getSingularites(){
|
|
let item = duplicate(this.items.filter( it => it.type == "singularite") || [] )
|
|
return item
|
|
}
|
|
getContacts(){
|
|
let item = duplicate(this.items.filter( it => it.type == "contact") || [] )
|
|
return item
|
|
}
|
|
getUnusedParadigmes() {
|
|
let paraList = []
|
|
for(let k in this.system.paradigmes) {
|
|
let para = this.system.paradigmes[k]
|
|
if (!para.used) {
|
|
para.key = k
|
|
paraList.push(duplicate(para))
|
|
}
|
|
}
|
|
return paraList
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
transferToSource( nbSuccess) {
|
|
let karma = duplicate(this.system.karma)
|
|
karma.source += Number(nbSuccess)
|
|
let nbKarma = Math.floor(karma.source / 3)
|
|
karma.value += nbKarma
|
|
karma.source -= nbKarma*3
|
|
this.update( { 'system.karma': karma})
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
decOneKarma( ) {
|
|
let karma = duplicate(this.system.karma)
|
|
karma.value--
|
|
karma.value = Math.max(karma.value, 0)
|
|
karma.xp++
|
|
this.update( { 'system.karma': karma})
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getItemById(id) {
|
|
let item = this.items.find(item => item.id == id)
|
|
if (item) {
|
|
item = duplicate(item)
|
|
}
|
|
return item;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
compareName(a, b) {
|
|
if (a.name < b.name) {
|
|
return -1;
|
|
}
|
|
if (a.name > b.name) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getActiveEffects(matching = it => true) {
|
|
let array = Array.from(this.getEmbeddedCollection("ActiveEffect").values());
|
|
return Array.from(this.getEmbeddedCollection("ActiveEffect").values()).filter(it => matching(it));
|
|
}
|
|
/* -------------------------------------------- */
|
|
getEffectByLabel(label) {
|
|
return this.getActiveEffects().find(it => it.label == label);
|
|
}
|
|
/* -------------------------------------------- */
|
|
getEffectById(id) {
|
|
return this.getActiveEffects().find(it => it.id == id);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getInitiativeScore(combatId, combatantId) {
|
|
return -1;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getSubActors() {
|
|
let subActors = [];
|
|
for (let id of this.system.subactors) {
|
|
subActors.push(duplicate(game.actors.get(id)))
|
|
}
|
|
return subActors;
|
|
}
|
|
/* -------------------------------------------- */
|
|
async addSubActor(subActorId) {
|
|
let subActors = duplicate(this.system.subactors);
|
|
subActors.push(subActorId);
|
|
await this.update({ 'data.subactors': subActors });
|
|
}
|
|
/* -------------------------------------------- */
|
|
async delSubActor(subActorId) {
|
|
let newArray = [];
|
|
for (let id of this.system.subactors) {
|
|
if (id != subActorId) {
|
|
newArray.push(id);
|
|
}
|
|
}
|
|
await this.update({ 'data.subactors': newArray });
|
|
}
|
|
|
|
|
|
/* -------------------------------------------- */
|
|
async deleteAllItemsByType(itemType) {
|
|
let items = this.items.filter(item => item.type == itemType);
|
|
await this.deleteEmbeddedDocuments('Item', items);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async addItemWithoutDuplicate(newItem) {
|
|
let item = this.items.find(item => item.type == newItem.type && item.name.toLowerCase() == newItem.name.toLowerCase())
|
|
if (!item) {
|
|
await this.createEmbeddedDocuments('Item', [newItem]);
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async incDecQuantity(objetId, incDec = 0) {
|
|
let objetQ = this.items.get(objetId)
|
|
if (objetQ) {
|
|
let newQ = objetQ.system.quantity + incDec
|
|
if (newQ >= 0) {
|
|
const updated = await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'data.quantity': newQ }]) // pdates one EmbeddedEntity
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
setParadigmeUsed(paraKey) {
|
|
let para = duplicate(this.system.paradigmes)
|
|
para[paraKey].used = true
|
|
this.update( {'system.paradigmes': para} )
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
/* ROLL SECTION
|
|
/* -------------------------------------------- */
|
|
|
|
/* -------------------------------------------- */
|
|
addEffects(rollData) {
|
|
let effects = this.items.filter(item => item.type == 'effect')
|
|
for (let effect of effects) {
|
|
effect = duplicate(effect)
|
|
if (!effect.system.hindrance
|
|
&& (effect.system.stataffected != "notapplicable" || effect.system.specaffected.length > 0)
|
|
&& effect.system.stataffected != "special") {
|
|
if (effect.system.effectstatlevel) {
|
|
effect.system.effectlevel = this.system.statistics[effect.system.effectstat].value
|
|
}
|
|
rollData.effectsList.push({ label: effect.name, type: "effect", applied: false, effect: effect, value: effect.system.effectlevel })
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
rollAme( ameKey) {
|
|
let rollData = this.getCommonRollData()
|
|
rollData.ame = duplicate(this.system.ames[ameKey])
|
|
rollData.ameMalus = this.system.amestype[rollData.ame.type].malus
|
|
this.startRoll(rollData)
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getCommonRollData() {
|
|
let rollData = Imperium5Utility.getBasicRollData()
|
|
rollData.alias = this.name
|
|
rollData.actorImg = this.img
|
|
rollData.actorId = this.id
|
|
rollData.img = this.img
|
|
rollData.capacites = this.getUnusedCapacites()
|
|
rollData.paradigmes = this.getUnusedParadigmes()
|
|
rollData.selectedParadigme = "none"
|
|
rollData.karma = this.system.karma.value
|
|
|
|
return rollData
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async startRoll(rollData) {
|
|
let rollDialog = await Imperium5RollDialog.create(this, rollData)
|
|
console.log(rollDialog)
|
|
rollDialog.render(true)
|
|
}
|
|
|
|
|
|
}
|