public/bol
1
0
Fork 1
Code Issues Pull Requests Actions Projects Releases 78 Wiki Activity

Foundry v10 version

Browse Source
This commit is contained in:
sladecraven
2022-07-01 15:48:54 +02:00
parent d27b78d1d2
commit cc1964093d
23 changed files with 320 additions and 330 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
module/actor/actor-sheet.js
View File

@ -66,10 +66,9 @@ export class BoLActorSheet extends ActorSheet {
const incr = parseInt(dataset.incr)
const min = parseInt(dataset.min)
const max = parseInt(dataset.max) || 10000
const itemData = item.data;
let value = eval("itemData." + target)
let value = eval("item." + target)
value = value || 0
console.log("IncDec", item, target, value, operator, min, max)
//console.log("IncDec", item, target, value, operator, min, max)
if (operator === "minus") {
if (value >= min + incr) value -= incr;
else value = min;
@ -109,12 +108,12 @@ export class BoLActorSheet extends ActorSheet {
/** @override */
getData(options) {
const data = super.getData(options);
const actorData = duplicate(data.data);
const data = super.getData(options)
const actorData = duplicate(data)
let formData = duplicate(data)
formData.config = game.bol.config
formData.data = actorData.data
formData.data = actorData
formData.details = this.actor.details
formData.attributes = this.actor.attributes
formData.aptitudes = this.actor.aptitudes

256
module/actor/actor.js
View File

@ -9,15 +9,14 @@ export class BoLActor extends Actor {
/** @override */
prepareData() {
const actorData = this.data;
if (actorData.type === 'character') {
actorData.type = 'player';
actorData.villainy = false;
if (this.type === 'character') {
this.chartype = 'player';
this.villainy = false;
}
if (actorData.type === 'encounter') {
actorData.type = 'tough';
actorData.villainy = true;
if (this.type === 'encounter') {
this.chartype = 'tough';
this.villainy = true;
}
super.prepareData();
}
@ -25,13 +24,13 @@ export class BoLActor extends Actor {
/* -------------------------------------------- */
updateResourcesData() {
if (this.type == 'character') {
let newVitality = 10 + this.data.data.attributes.vigor.value + this.data.data.resources.hp.bonus
if (this.data.data.resources.hp.max != newVitality) {
this.update({ 'data.resources.hp.max': newVitality })
let newVitality = 10 + this.system.attributes.vigor.value + this.system.resources.hp.bonus
if (this.system.resources.hp.max != newVitality) {
this.update({ 'system.resources.hp.max': newVitality })
}
let newPower = 10 + this.data.data.attributes.mind.value + this.data.data.resources.power.bonus
if (this.data.data.resources.power.max != newPower) {
this.update({ 'data.resources.power.max': newPower })
let newPower = 10 + this.system.attributes.mind.value + this.system.resources.power.bonus
if (this.system.resources.power.max != newPower) {
this.update({ 'system.resources.power.max': newPower })
}
}
}
@ -44,25 +43,22 @@ export class BoLActor extends Actor {
}
/* -------------------------------------------- */
get itemData() {
return Array.from(this.data.items.values()).map(i => i.data)
}
get details() {
return this.data.data.details
return this.system.details
}
get attributes() {
return Object.values(this.data.data.attributes)
return Object.values(this.system.attributes)
}
get aptitudes() {
return Object.values(this.data.data.aptitudes)
return Object.values(this.system.aptitudes)
}
/* -------------------------------------------- */
clearRoundModifiers() { // Process data/items that are finished at end of a round
let foList = this.fightoptions
for (let fo of foList) {
if (fo.data.properties.used) {
this.updateEmbeddedDocuments("Item", [{ _id: fo._id, 'data.properties.used': false }])
if (fo.system.properties.used) {
this.updateEmbeddedDocuments("Item", [{ _id: fo._id, 'system.properties.used': false }])
}
}
}
@ -71,28 +67,28 @@ export class BoLActor extends Actor {
get defenseValue() {
let defMod = 0
let fo = this.getActiveFightOption()
if (fo && fo.data.properties.fightoptiontype == "intrepid") {
if (fo && fo.system.properties.fightoptiontype == "intrepid") {
defMod += -2
}
if (fo && fo.data.properties.fightoptiontype == "fulldefense") {
if (fo && fo.system.properties.fightoptiontype == "fulldefense") {
defMod += 2
}
if (fo && fo.data.properties.fightoptiontype == "twoweaponsdef" && !fo.data.properties.used) {
if (fo && fo.system.properties.fightoptiontype == "twoweaponsdef" && !fo.system.properties.used) {
defMod += 1
this.updateEmbeddedDocuments("Item", [{ _id: fo._id, 'data.properties.used': true }])
this.updateEmbeddedDocuments("Item", [{ _id: fo._id, 'system.properties.used': true }])
}
if (fo && fo.data.properties.fightoptiontype == "defense") {
if (fo && fo.system.properties.fightoptiontype == "defense") {
defMod += 1
}
if (fo && fo.data.properties.fightoptiontype == "attack") {
if (fo && fo.system.properties.fightoptiontype == "attack") {
defMod += -1
}
return this.data.data.aptitudes.def.value + defMod
return this.system.aptitudes.def.value + defMod
}
/* -------------------------------------------- */
getActiveFightOption() {
let it = this.itemData.find(i => i.type === "feature" && i.data.subtype === "fightoption" && i.data.properties.activated)
let it = this.items.find(i => i.type === "feature" && i.system.subtype === "fightoption" && i.system.properties.activated)
if (it) {
return duplicate(it)
}
@ -101,14 +97,14 @@ export class BoLActor extends Actor {
/* -------------------------------------------- */
incAttributeXP(key) {
let attr = duplicate(this.data.data.attributes[key])
let attr = duplicate(this.system.attributes[key])
if (attr) {
let nextXP = (attr.value == -1) ? 2 : attr.value + (attr.value + 1)
let xp = duplicate(this.data.data.xp)
let xp = duplicate(this.system.xp)
if (xp.total - xp.spent >= nextXP) {
attr.value += 1
xp.spent += nextXP
this.update({ [`data.attributes.${key}`]: attr, [`data.xp`]: xp })
this.update({ [`system.attributes.${key}`]: attr, [`system.xp`]: xp })
} else {
ui.notifications.warn("Pas assez de points d'expérience !")
}
@ -117,14 +113,14 @@ export class BoLActor extends Actor {
/* -------------------------------------------- */
incAptitudeXP(key) {
let apt = duplicate(this.data.data.aptitudes[key])
let apt = duplicate(this.system.aptitudes[key])
if (apt) {
let nextXP = (apt.value == -1) ? 1 : apt.value + 2
let xp = duplicate(this.data.data.xp)
let xp = duplicate(this.system.xp)
if (xp.total - xp.spent >= nextXP) {
apt.value += 1
xp.spent += nextXP
this.update({ [`data.aptitudes.${key}`]: apt, [`data.xp`]: xp })
this.update({ [`system.aptitudes.${key}`]: apt, [`system.xp`]: xp })
} else {
ui.notifications.warn("Pas assez de points d'expérience !")
}
@ -132,15 +128,15 @@ export class BoLActor extends Actor {
}
/* -------------------------------------------- */
incCareerXP(itemId) {
let career = this.data.items.get(itemId)
let career = this.items.get(itemId)
if (career) {
career = duplicate(career)
let nextXP = career.data.rank + 1
let xp = duplicate(this.data.data.xp)
let nextXP = career.system.rank + 1
let xp = duplicate(this.system.xp)
if (xp.total - xp.spent >= nextXP) {
xp.spent += nextXP
this.update({ [`data.xp`]: xp })
this.updateEmbeddedDocuments('Item', [{ _id: career._id, 'data.rank': career.data.rank + 1 }])
this.update({ [`system.xp`]: xp })
this.updateEmbeddedDocuments('Item', [{ _id: career._id, 'system.rank': career.system.rank + 1 }])
} else {
ui.notifications.warn("Pas assez de points d'expérience !")
}
@ -149,18 +145,18 @@ export class BoLActor extends Actor {
/* -------------------------------------------- */
async toggleFightOption(itemId) {
let fightOption = this.data.items.get(itemId)
let fightOption = this.items.get(itemId)
let state
let updates = []
if (fightOption) {
fightOption = duplicate(fightOption)
if (fightOption.data.properties.activated) {
if (fightOption.system.properties.activated) {
state = false
} else {
state = true
}
updates.push({ _id: fightOption._id, 'data.properties.activated': state }) // Update the selected one
updates.push({ _id: fightOption._id, 'system.properties.activated': state }) // Update the selected one
await this.updateEmbeddedDocuments("Item", updates) // Apply all changes
// Then notify
ChatMessage.create({
@ -175,13 +171,13 @@ export class BoLActor extends Actor {
/*-------------------------------------------- */
get armorMalusValue() { // used for Fight Options
for (let armor of this.armors) {
if (armor.data.properties.armorQuality.includes("light")) {
if (armor.system.properties.armorQuality.includes("light")) {
return 1
}
if (armor.data.properties.armorQuality.includes("medium")) {
if (armor.system.properties.armorQuality.includes("medium")) {
return 2
}
if (armor.data.properties.armorQuality.includes("heavy")) {
if (armor.system.properties.armorQuality.includes("heavy")) {
return 3
}
}
@ -189,112 +185,112 @@ export class BoLActor extends Actor {
}
get resources() {
return Object.values(this.data.data.resources)
return Object.values(this.system.resources)
}
get boons() {
return this.itemData.filter(i => i.type === "feature" && i.data.subtype === "boon");
return this.items.filter(i => i.type === "feature" && i.system.subtype === "boon");
}
get flaws() {
return this.itemData.filter(i => i.type === "feature" && i.data.subtype === "flaw");
return this.items.filter(i => i.type === "feature" && i.system.subtype === "flaw");
}
get careers() {
return this.itemData.filter(i => i.type === "feature" && i.data.subtype === "career");
return duplicate( this.items.filter(i => i.type === "feature" && i.system.subtype === "career") || [])
}
get origins() {
return this.itemData.filter(i => i.type === "feature" && i.data.subtype === "origin");
return this.items.filter(i => i.type === "feature" && i.system.subtype === "origin");
}
get races() {
return this.itemData.filter(i => i.type === "feature" && i.data.subtype === "race");
return this.items.filter(i => i.type === "feature" && i.system.subtype === "race");
}
get languages() {
return this.itemData.filter(i => i.type === "feature" && i.data.subtype === "language")
return this.items.filter(i => i.type === "feature" && i.system.subtype === "language")
}
get fightoptions() {
return this.itemData.filter(i => i.type === "feature" && i.data.subtype === "fightoption")
return this.items.filter(i => i.type === "feature" && i.system.subtype === "fightoption")
}
get godsfaith() {
return this.itemData.filter(i => i.type === "feature" && i.data.subtype === "godsfaith")
return this.items.filter(i => i.type === "feature" && i.system.subtype === "godsfaith")
}
get features() {
return this.itemData.filter(i => i.type === "feature")
return this.items.filter(i => i.type === "feature")
}
get equipment() {
return this.itemData.filter(i => i.type === "item")
return this.items.filter(i => i.type === "item")
}
get equipmentCreature() {
return this.itemData.filter(i => i.type === "item" && i.data.category === "equipment" && (( i.data.subtype === "weapon" && i.data.properties.natural === true) || (i.data.subtype === "armor")) )
return this.items.filter(i => i.type === "item" && i.system.category === "equipment" && (( i.system.subtype === "weapon" && i.system.properties.natural === true) || (i.system.subtype === "armor")) )
}
get armors() {
return this.itemData.filter(i => i.type === "item" && i.data.category === "equipment" && i.data.subtype === "armor");
return this.items.filter(i => i.type === "item" && i.system.category === "equipment" && i.system.subtype === "armor");
}
get helms() {
return this.itemData.filter(i => i.type === "item" && i.data.category === "equipment" && i.data.subtype === "helm");
return this.items.filter(i => i.type === "item" && i.system.category === "equipment" && i.system.subtype === "helm");
}
get shields() {
return this.itemData.filter(i => i.type === "item" && i.data.category === "equipment" && i.data.subtype === "shield");
return this.items.filter(i => i.type === "item" && i.system.category === "equipment" && i.system.subtype === "shield");
}
get weapons() {
return this.itemData.filter(i => i.type === "item" && i.data.category === "equipment" && i.data.subtype === "weapon");
return this.items.filter(i => i.type === "item" && i.system.category === "equipment" && i.system.subtype === "weapon");
}
get protections() {
return this.armors.concat(this.helms).concat(this.shields)
}
get spells() {
return this.itemData.filter(i => i.type === "item" && i.data.category === "spell");
return this.items.filter(i => i.type === "item" && i.system.category === "spell");
}
get alchemy() {
return this.itemData.filter(i => i.type === "item" && i.data.category === "alchemy");
return this.items.filter(i => i.type === "item" && i.system.category === "alchemy");
}
get melee() {
return this.weapons.filter(i => i.data.properties.melee === true);
return this.weapons.filter(i => i.system.properties.melee === true);
}
get natural() {
return this.weapons.filter(i => i.data.properties.natural === true);
return this.weapons.filter(i => i.system.properties.natural === true);
}
get ranged() {
return this.weapons.filter(i => i.data.properties.ranged === true);
return this.weapons.filter(i => i.system.properties.ranged === true);
}
get containers() {
return this.itemData.filter(i => i.type === "item" && i.data.category === "equipment" && i.data.subtype === "container");
return this.items.filter(i => i.type === "item" && i.system.category === "equipment" && i.system.subtype === "container");
}
get treasure() {
return this.itemData.filter(i => i.type === "item" && i.data.category === "equipment" && i.data.subtype === "currency");
return this.items.filter(i => i.type === "item" && i.system.category === "equipment" && i.system.subtype === "currency");
}
get vehicles() {
return this.itemData.filter(i => i.type === "item" && i.data.category === "vehicle");
return this.items.filter(i => i.type === "item" && i.system.category === "vehicle");
}
get ammos() {
return this.itemData.filter(i => i.type === "item" && i.data.category === "equipment" && i.data.subtype === "ammunition");
return this.items.filter(i => i.type === "item" && i.system.category === "equipment" && i.system.subtype === "ammunition");
}
get misc() {
return this.itemData.filter(i => i.type === "item" && i.data.category === "equipment" && (i.data.subtype === "other" || i.data.subtype === "container" || i.data.subtype === "scroll" || i.data.subtype === "jewel"));
return this.items.filter(i => i.type === "item" && i.system.category === "equipment" && (i.system.subtype === "other" || i.system.subtype === "container" || i.system.subtype === "scroll" || i.system.subtype === "jewel"));
}
get bonusBoons() {
return this.itemData.filter(i => i.type === "feature" && i.data.subtype === "boon" && i.data.properties.isbonusdice);
return this.items.filter(i => i.type === "feature" && i.system.subtype === "boon" && i.system.properties.isbonusdice);
}
get malusFlaws() {
return this.itemData.filter(i => i.type === "feature" && i.data.subtype === "flaw" && i.data.properties.ismalusdice);
return this.items.filter(i => i.type === "feature" && i.system.subtype === "flaw" && i.system.properties.ismalusdice);
}
isSorcerer() {
if (this.careers.find(item => item.data.properties.sorcerer == true))
if (this.careers.find(item => item.system.properties.sorcerer == true))
return true
return false
}
isAlchemist() {
if (this.careers.find(item => item.data.properties.alchemist == true))
if (this.careers.find(item => item.system.properties.alchemist == true))
return true
return false
}
isPriest() {
if (this.careers.find(item => item.data.properties.priest == true))
if (this.careers.find(item => item.system.properties.priest == true))
return true
return false
}
@ -304,8 +300,8 @@ export class BoLActor extends Actor {
let armors = this.armors
let ppCostArmor = 0
for (let armor of armors) {
if (armor.data.worn) {
ppCostArmor += Number(armor.data.properties.modifiers.powercost) || 0
if (armor.system.worn) {
ppCostArmor += Number(armor.system.properties.modifiers.powercost) || 0
}
}
return ppCostArmor
@ -314,8 +310,8 @@ export class BoLActor extends Actor {
getArmorAgiMalus() {
let malusAgi = 0
for (let armor of this.protections) {
if (armor.data.worn) {
malusAgi += Number(armor.data.properties.modifiers.agility) || 0
if (armor.system.worn) {
malusAgi += Number(armor.system.properties.modifiers.agility) || 0
}
}
return malusAgi
@ -324,8 +320,8 @@ export class BoLActor extends Actor {
getArmorInitMalus() {
let malusInit = 0
for (let armor of this.protections) {
if (armor.data.worn) {
malusInit += Number(armor.data.properties.modifiers.init) || 0
if (armor.system.worn) {
malusInit += Number(armor.system.properties.modifiers.init) || 0
}
}
return malusInit
@ -333,7 +329,7 @@ export class BoLActor extends Actor {
/*-------------------------------------------- */
spendPowerPoint(ppCost) {
let newPP = this.data.data.resources.power.value - ppCost
let newPP = this.system.resources.power.value - ppCost
newPP = (newPP < 0) ? 0 : newPP
this.update({ 'data.resources.power.value': newPP })
return newPP
@ -341,7 +337,7 @@ export class BoLActor extends Actor {
/*-------------------------------------------- */
resetAlchemyStatus(alchemyId) {
let alchemy = this.data.items.get(alchemyId)
let alchemy = this.items.get(alchemyId)
if (alchemy) {
this.updateEmbeddedDocuments('Item', [{ _id: alchemy.id, 'data.properties.pccurrent': 0 }])
}
@ -349,14 +345,14 @@ export class BoLActor extends Actor {
/*-------------------------------------------- */
async spendAlchemyPoint(alchemyId, pcCost) {
let alchemy = this.data.items.get(alchemyId)
let alchemy = this.items.get(alchemyId)
if (alchemy) {
pcCost = Number(pcCost) ?? 0
if (this.data.data.resources.alchemypoints.value >= pcCost) {
let newPC = this.data.data.resources.alchemypoints.value - pcCost
if (this.system.resources.alchemypoints.value >= pcCost) {
let newPC = this.system.resources.alchemypoints.value - pcCost
newPC = (newPC < 0) ? 0 : newPC
this.update({ 'data.resources.alchemypoints.value': newPC })
newPC = alchemy.data.data.properties.pccurrent + pcCost
newPC = alchemy.system.properties.pccurrent + pcCost
await this.updateEmbeddedDocuments('Item', [{ _id: alchemy.id, 'data.properties.pccurrent': newPC }])
} else {
ui.notifications.warn("Plus assez de Points de Création !")
@ -366,17 +362,17 @@ export class BoLActor extends Actor {
/*-------------------------------------------- */
getAlchemistBonus() {
let sorcerer = this.careers.find(item => item.data.properties.alchemist == true)
let sorcerer = this.careers.find(item => item.system.properties.alchemist == true)
if (sorcerer) {
return sorcerer.data.rank
return sorcerer.system.rank
}
return 0;
}
/*-------------------------------------------- */
getSorcererBonus() {
let sorcerer = this.careers.find(item => item.data.properties.sorcerer == true)
let sorcerer = this.careers.find(item => item.system.properties.sorcerer == true)
if (sorcerer) {
return sorcerer.data.rank
return sorcerer.system.rank
}
return 0;
}
@ -384,10 +380,10 @@ export class BoLActor extends Actor {
/*-------------------------------------------- */
heroReroll() {
if (this.type == 'character') {
return this.data.data.resources.hero.value > 0;
return this.system.resources.hero.value > 0;
} else {
if (this.data.data.type == 'adversary') {
return this.data.data.resources.hero.value > 0;
if (this.system.type == 'adversary') {
return this.system.resources.hero.value > 0;
}
}
return false
@ -396,17 +392,17 @@ export class BoLActor extends Actor {
getResourcesFromType() {
let resources = {};
if (this.type == 'encounter') {
resources['hp'] = this.data.data.resources.hp;
if (this.data.data.type != 'base') {
resources['faith'] = this.data.data.resources.faith
resources['power'] = this.data.data.resources.power
resources['hp'] = this.system.resources.hp;
if (this.system.type != 'base') {
resources['faith'] = this.system.resources.faith
resources['power'] = this.system.resources.power
}
if (this.data.data.type == 'adversary') {
resources['hero'] = duplicate(this.data.data.resources.hero)
if (this.system.type == 'adversary') {
resources['hero'] = duplicate(this.system.resources.hero)
resources['hero'].label = "BOL.resources.villainy"
}
} else {
resources = this.data.data.resources;
resources = this.system.resources;
}
return resources
}
@ -532,13 +528,13 @@ export class BoLActor extends Actor {
/*-------------------------------------------- */
buildRollList() {
let rolls = []
for (let key in this.data.data.attributes) {
let attr = this.data.data.attributes[key]
for (let key in this.system.attributes) {
let attr = this.system.attributes[key]
rolls.push({ key: key, value: attr.value, name: attr.label, type: "attribute" })
}
for (let key in this.data.data.aptitudes) {
for (let key in this.system.aptitudes) {
if (key != "def") {
let apt = this.data.data.aptitudes[key]
let apt = this.system.aptitudes[key]
rolls.push({ key: key, value: apt.value, name: apt.label, type: "aptitude" })
}
}
@ -554,13 +550,13 @@ export class BoLActor extends Actor {
async manageHealthState() {
let hpID = "lastHP" + this.id
let lastHP = await this.getFlag("world", hpID)
if (lastHP != this.data.data.resources.hp.value && game.user.isGM ) { // Only GM sends this
await this.setFlag("world", hpID, this.data.data.resources.hp.value)
if (this.data.data.resources.hp.value <= 0) {
if (lastHP != this.system.resources.hp.value && game.user.isGM ) { // Only GM sends this
await this.setFlag("world", hpID, this.system.resources.hp.value)
if (this.system.resources.hp.value <= 0) {
ChatMessage.create({
alias: this.name,
whisper: BoLUtility.getWhisperRecipientsAndGMs(this.name),
content: await renderTemplate('systems/bol/templates/chat/chat-vitality-zero.hbs', { name: this.name, img: this.img, hp: this.data.data.resources.hp.value })
content: await renderTemplate('systems/bol/templates/chat/chat-vitality-zero.hbs', { name: this.name, img: this.img, hp: this.system.resources.hp.value })
})
}
}
@ -568,46 +564,46 @@ export class BoLActor extends Actor {
/*-------------------------------------------- */
registerInit(initScore, isCritical, isFumble) {
this.update({ 'data.combat.lastinit': initScore, 'data.combat.iscritical': isCritical, 'data.combat.isfumble': isFumble })
this.update({ 'system.combat.lastinit': initScore, 'system.combat.iscritical': isCritical, 'system.combat.isfumble': isFumble })
}
/*-------------------------------------------- */
getLastInitData() {
return this.data.data.combat
return this.system.combat
}
/*-------------------------------------------- */
async subHeroPoints(nb) {
let newHeroP = this.data.data.resources.hero.value - nb;
let newHeroP = this.system.resources.hero.value - nb;
newHeroP = (newHeroP < 0) ? 0 : newHeroP;
await this.update({ 'data.resources.hero.value': newHeroP });
await this.update({ 'system.resources.hero.value': newHeroP });
}
/*-------------------------------------------- */
async sufferDamage(damage) {
let newHP = this.data.data.resources.hp.value - damage
await this.update({ 'data.resources.hp.value': newHP })
let newHP = this.system.resources.hp.value - damage
await this.update({ 'system.resources.hp.value': newHP })
}
/* -------------------------------------------- */
getArmorFormula() {
let protectWorn = this.protections.filter(item => item.data.worn)
let protectWorn = this.protections.filter(item => item.system.worn)
let formula = ""
for (let protect of protectWorn) {
if (protect.data.subtype == 'helm') {
if (protect.system.subtype == 'helm') {
formula += "+1"
} else if (protect.data.subtype == 'armor') {
} else if (protect.system.subtype == 'armor') {
if (BoLUtility.getRollArmor()) {
if (!protect.data.properties.soak.formula || protect.data.properties.soak.formula == "") {
if (!protect.system.properties.soak.formula || protect.system.properties.soak.formula == "") {
ui.notifications.warn(`L'armure ${protect.name} n'a pas de formule pour la protection !`)
} else {
formula += "+" + " max(" + protect.data.properties.soak.formula +",0)"
formula += "+" + " max(" + protect.system.properties.soak.formula +",0)"
}
} else {
if (protect.data.properties.soak.value == undefined) {
if (protect.system.properties.soak.value == undefined) {
ui.notifications.warn(`L'armure ${protect.name} n'a pas de valeur fixe pour la protection !`)
} else {
formula += "+ " + protect.data.properties.soak.value
formula += "+ " + protect.system.properties.soak.value
}
}
}
@ -618,9 +614,9 @@ export class BoLActor extends Actor {
/* -------------------------------------------- */
rollProtection(itemId) {
let armor = duplicate(this.data.items.get(itemId))
let armor = duplicate(this.items.get(itemId))
if (armor) {
let armorFormula = "max("+armor.data.properties.soak.formula + ", 0)"
let armorFormula = "max("+armor.system.properties.soak.formula + ", 0)"
let rollArmor = new Roll(armorFormula)
rollArmor.roll({ async: false }).toMessage()
}
@ -628,7 +624,7 @@ export class BoLActor extends Actor {
/* -------------------------------------------- */
rollWeaponDamage(itemId) {
let weapon = duplicate(this.data.items.get(itemId))
let weapon = duplicate(this.system.items.get(itemId))
if (weapon) {
let r = new BoLDefaultRoll({ id: randomID(16), isSuccess: true, mode: "weapon", weapon: weapon, actorId: this.id, actor: this })
r.setSuccess(true)
@ -638,10 +634,10 @@ export class BoLActor extends Actor {
/* -------------------------------------------- */
toggleEquipItem(item) {
const equipable = item.data.data.properties.equipable;
const equipable = item.system.properties.equipable;
if (equipable) {
let itemData = duplicate(item.data);
itemData.data.worn = !itemData.data.worn;
let itemData = duplicate(item);
itemData.system.worn = !itemData.system.worn;
return item.update(itemData);
}
}

3
module/bol.js
View File

@ -79,6 +79,7 @@ function registerUsageCount( registerKey ) {
name: "Unique world key",
scope: "world",
config: false,
default: "",
type: String
});
@ -88,7 +89,7 @@ function registerUsageCount( registerKey ) {
game.settings.set(registerKey, "world-key", worldKey )
}
// Simple API counter
let regURL = `https://www.uberwald.me/fvtt_appcount/count.php?name="${registerKey}"&worldKey="${worldKey}"&version="${game.release.generation}.${game.release.build}"&system="${game.system.id}"&systemversion="${game.system.data.version}"`
let regURL = `https://www.uberwald.me/fvtt_appcount/count.php?name="${registerKey}"&worldKey="${worldKey}"&version="${game.release.generation}.${game.release.build}"&system="${game.system.id}"&systemversion="${game.system.version}"`
$.ajax(regURL)
}
}

64
module/controllers/bol-rolls.js
View File

@ -18,7 +18,7 @@ export class BoLRoll {
/* -------------------------------------------- */
static attributeCheck(actor, key) {
let attribute = eval(`actor.data.data.attributes.${key}`)
let attribute = eval(`actor.system.attributes.${key}`)
let label = (attribute.label) ? game.i18n.localize(attribute.label) : null
let description = game.i18n.localize('BOL.ui.attributeCheck') + " - " + game.i18n.localize(attribute.label)
@ -43,9 +43,9 @@ export class BoLRoll {
/* -------------------------------------------- */
static aptitudeCheck(actor, key) {
let aptitude = eval(`actor.data.data.aptitudes.${key}`)
let aptitude = eval(`actor.system.aptitudes.${key}`)
let attrKey = this.getDefaultAttribute(key)
let attribute = eval(`actor.data.data.attributes.${attrKey}`)
let attribute = eval(`actor.system.attributes.${attrKey}`)
let label = (aptitude.label) ? game.i18n.localize(aptitude.label) : null;
let description = game.i18n.localize('BOL.ui.aptitudeCheck') + " - " + game.i18n.localize(aptitude.label);
@ -72,13 +72,13 @@ export class BoLRoll {
let target = BoLUtility.getTarget()
let weaponData = weapon.data
let attribute = eval(`actor.data.data.attributes.${weaponData.properties.attackAttribute}`)
let aptitude = eval(`actor.data.data.aptitudes.${weaponData.properties.attackAptitude}`)
let weaponData = weapon.system
let attribute = eval(`actor.system.attributes.${weaponData.properties.attackAttribute}`)
let aptitude = eval(`actor.system.aptitudes.${weaponData.properties.attackAptitude}`)
// Manage specific case
let fightOption = actor.getActiveFightOption()
if (fightOption && fightOption.data.fightoptiontype == "fulldefense") {
if (fightOption && fightOption.system.fightoptiontype == "fulldefense") {
ui.notifications.warn(`{{actor.name}} est en Défense Totale ! Il ne peut pas attaquer ce round.`)
return
}
@ -138,8 +138,8 @@ export class BoLRoll {
actorId: actor.id,
img: actor.img,
alchemy: alchemy,
attribute: actor.data.data.attributes.mind,
attrValue: actor.data.data.attributes.mind.value,
attribute: actor.system.attributes.mind,
attrValue: actor.system.attributes.mind.value,
aptValue: 0,
careerBonus: actor.getAlchemistBonus(),
pcCost: Number(alchemyData.properties.pccost),
@ -161,14 +161,14 @@ export class BoLRoll {
actorId: actor.id,
img: actor.img,
spell: spell,
attribute: actor.data.data.attributes.mind,
attrValue: actor.data.data.attributes.mind.value,
attribute: actor.system.attributes.mind,
attrValue: actor.system.attributes.mind.value,
aptValue: 0,
ppCurrent: Number(actor.data.data.resources.power.value),
ppCurrent: Number(actor.system.resources.power.value),
careerBonus: actor.getSorcererBonus(),
ppCostArmor: actor.getPPCostArmor(),
ppCost: Number(spell.data.properties.ppcost),
mod: Number(spell.data.properties.difficulty),
ppCost: Number(spell.system.properties.ppcost),
mod: Number(spell.system.properties.difficulty),
armorAgiMalus: actor.getArmorAgiMalus(),
armorInitMalus: actor.getArmorInitMalus(),
label: spell.name,
@ -180,7 +180,7 @@ export class BoLRoll {
/* -------------------------------------------- */
static spellCheck(actor, event) {
if (actor.data.data.resources.power.value <= 0) {
if (actor.system.resources.power.value <= 0) {
ui.notifications.warn("Plus assez de points de Pouvoir !")
return
}
@ -209,7 +209,7 @@ export class BoLRoll {
$('#roll-nbdice').val("2 + " + String(Math.abs(this.rollData.bmDice)) + letter)
}
let rollbase = this.rollData.attrValue + "+" + this.rollData.aptValue
if ( this.rollData.weapon && this.rollData.weapon.data.properties.onlymodifier ) {
if ( this.rollData.weapon && this.rollData.weapon.system.properties.onlymodifier ) {
rollbase = ""
}
$('#roll-modifier').val(rollbase + "+" + this.rollData.careerBonus + "+" + this.rollData.mod + "+" +
@ -226,20 +226,20 @@ export class BoLRoll {
let fgItem = rollData.fightOption
if (fgItem) {
console.log(fgItem)
if (fgItem.data.properties.fightoptiontype == "armordefault") {
if (fgItem.system.properties.fightoptiontype == "armordefault") {
rollData.modArmorMalus = rollData.armorMalus // Activate the armor malus
rollData.damagesIgnoresArmor = true
}
if (fgItem.data.properties.fightoptiontype == "intrepid") {
if (fgItem.system.properties.fightoptiontype == "intrepid") {
rollData.attackModifier += 2
}
if (fgItem.data.properties.fightoptiontype == "defense") {
if (fgItem.system.properties.fightoptiontype == "defense") {
rollData.attackModifier += -1
}
if (fgItem.data.properties.fightoptiontype == "attack") {
if (fgItem.system.properties.fightoptiontype == "attack") {
rollData.attackModifier += 1
}
if (fgItem.data.properties.fightoptiontype == "twoweaponsdef" || fgItem.data.properties.fightoptiontype == "twoweaponsatt") {
if (fgItem.system.properties.fightoptiontype == "twoweaponsdef" || fgItem.system.properties.fightoptiontype == "twoweaponsatt") {
rollData.attackModifier += -1
}
}
@ -289,15 +289,15 @@ export class BoLRoll {
html.find('#attr').change((event) => {
let attrKey = event.currentTarget.value
let actor = game.actors.get( this.rollData.actorId)
this.rollData.attribute = duplicate(actor.data.data.attributes[attrKey])
this.rollData.attrValue = actor.data.data.attributes[attrKey].value
this.rollData.attribute = duplicate(actor.system.attributes[attrKey])
this.rollData.attrValue = actor.system.attributes[attrKey].value
this.updateTotalDice()
})
html.find('#apt').change((event) => {
let aptKey = event.currentTarget.value
let actor = game.actors.get( this.rollData.actorId)
this.rollData.aptitude = duplicate(actor.data.data.aptitudes[aptKey])
this.rollData.aptValue = actor.data.data.aptitudes[aptKey].value
this.rollData.aptitude = duplicate(actor.system.aptitudes[aptKey])
this.rollData.aptValue = actor.system.aptitudes[aptKey].value
this.updateTotalDice()
})
@ -339,16 +339,16 @@ export class BoLRoll {
/* -------------------------------------------- */
static preProcessWeapon(rollData, defender) {
if (rollData.mode == "weapon") {
rollData.weaponModifier = rollData.weapon.data.properties.attackModifiers ?? 0;
rollData.attackBonusDice = rollData.weapon.data.properties.attackBonusDice
rollData.weaponModifier = rollData.weapon.system.properties.attackModifiers ?? 0;
rollData.attackBonusDice = rollData.weapon.system.properties.attackBonusDice
if (defender) { // If target is selected
rollData.defence = defender.defenseValue
rollData.armorMalus = defender.armorMalusValue
rollData.shieldBlock = 'none'
let shields = defender.shields
for (let shield of shields) {
rollData.shieldBlock = (shield.data.properties.blocking.blockingAll) ? 'blockall' : 'blockone';
rollData.shieldAttackMalus = (shield.data.properties.blocking.malus) ? shield.data.properties.blocking.malus : 1;
rollData.shieldBlock = (shield.system.properties.blocking.blockingAll) ? 'blockall' : 'blockone';
rollData.shieldAttackMalus = (shield.system.properties.blocking.malus) ? shield.system.properties.blocking.malus : 1;
rollData.applyShieldMalus = false
}
}
@ -431,7 +431,7 @@ export class BoLRoll {
rollData.nbDice += (rollData.attackBonusDice) ? 1 : 0
let rollbase = rollData.attrValue + rollData.aptValue
if ( rollData.weapon && rollData.weapon.data.properties.onlymodifier ) {
if ( rollData.weapon && rollData.weapon.system.properties.onlymodifier ) {
rollbase = 0
}
const modifiers = rollbase + rollData.careerBonus + rollData.mod + rollData.weaponModifier - rollData.defence - rollData.modArmorMalus + rollData.shieldMalus + rollData.attackModifier + rollData.appliedArmorMalus
@ -597,8 +597,8 @@ export class BoLDefaultRoll {
if (this.rollData.damageMode == 'damage-plus-12') {
bonusDmg = 12
}
let attrDamageValue = this.getDamageAttributeValue(this.rollData.weapon.data.properties.damageAttribute)
let weaponFormula = BoLUtility.getDamageFormula(this.rollData.weapon.data, this.rollData.fightOption)
let attrDamageValue = this.getDamageAttributeValue(this.rollData.weapon.system.properties.damageAttribute)
let weaponFormula = BoLUtility.getDamageFormula(this.rollData.weapon.system, this.rollData.fightOption)
let damageFormula = weaponFormula + "+" + bonusDmg + "+" + attrDamageValue
console.log("DAMAGE !!!", damageFormula, attrDamageValue, this.rollData)

40
module/item/item-sheet.js
View File

@ -20,42 +20,40 @@ export class BoLItemSheet extends ItemSheet {
/* -------------------------------------------- */
/** @override */
getData(options) {
const data = super.getData(options);
const itemData = data.data;
data.config = game.bol.config;
data.item = itemData;
data.data = itemData.data;
data.category = itemData.category;
data.itemProperties = this.item.itemProperties;
const data = super.getData(options)
let itemData = duplicate(data.document)
data.config = game.bol.config
data.item = itemData
data.category = itemData.system.category
data.isGM = game.user.isGM;
// Dynamic default data fix/adapt
if (itemData.type == "item") {
if (!itemData.data.category) {
itemData.data.category = "equipment"
if (!itemData.system.category) {
itemData.system.category = "equipment"
}
if ( itemData.data.category == "equipment" && itemData.data.properties.equipable) {
if (!itemData.data.properties.slot) {
itemData.data.properties.slot = "-"
if ( itemData.system.category == "equipment" && itemData.system.properties.equipable) {
if (!itemData.system.properties.slot) {
itemData.system.properties.slot = "-"
}
}
if (itemData.data.category == 'spell') {
if(!itemData.data.properties.mandatoryconditions) {
itemData.data.properties.mandatoryconditions = []
if (itemData.system.category == 'spell') {
if(!itemData.system.properties.mandatoryconditions) {
itemData.system.properties.mandatoryconditions = []
}
if(!itemData.data.properties.optionnalconditions) {
itemData.data.properties.optionnalconditions = []
if(!itemData.system.properties.optionnalconditions) {
itemData.system.properties.optionnalconditions = []
}
for (let i = 0; i < 4; i++) {
itemData.data.properties.mandatoryconditions[i] = itemData.data.properties.mandatoryconditions[i] ?? ""
itemData.system.properties.mandatoryconditions[i] = itemData.system.properties.mandatoryconditions[i] ?? ""
}
for (let i = 0; i < 8; i++) {
itemData.data.properties.optionnalconditions[i] = itemData.data.properties.optionnalconditions[i] ?? ""
itemData.system.properties.optionnalconditions[i] = itemData.system.properties.optionnalconditions[i] ?? ""
}
}
} else {
if (!itemData.data.subtype) {
itemData.data.category = "origin"
if (!itemData.system.subtype) {
itemData.system.category = "origin"
}
}

24
module/item/item.js
View File

@ -7,21 +7,17 @@ export class BoLItem extends Item {
* Augment the basic Item data model with additional dynamic data.
*/
prepareData() {
super.prepareData();
// console.debug("Item prepareData");
// Get the Item's data
const itemData = this.data;
// console.log(itemData);
const actorData = this.actor ? this.actor.data : {};
const data = itemData.data;
}
super.prepareData()
get properties() {
return this.data.properties;
const actorData = this.actor ? this.actor.system : {}
}
/* -------------------------------------------- */
get properties() {
return this.system.properties
}
/* -------------------------------------------- */
/**
* Get the Array of item properties which are used in the small sidebar of the description tab
* @return {Array}
@ -29,11 +25,11 @@ export class BoLItem extends Item {
*/
get itemProperties() {
const props = [];
if ( this.data.type === "item" ) {
const entries = Object.entries(this.data.data.properties);
props.push(...entries.filter(e => e[1] === true).map(e => { return game.bol.config.itemProperties2[e[0]] }));
if ( this.type === "item" ) {
const entries = Object.entries(this.system.properties)
props.push(...entries.filter(e => e[1] === true).map(e => { return game.bol.config.itemProperties2[e[0]] }))
}
return props.filter(p => !!p);
return props.filter(p => !!p)
}