2023-01-04 21:24:56 +01:00
/* -------------------------------------------- */
2023-01-04 22:09:09 +01:00
import { WarheroUtility } from "./warhero-utility.js" ;
import { WarheroRollDialog } from "./warhero-roll-dialog.js" ;
2023-01-04 21:24:56 +01:00
/* -------------------------------------------- */
const coverBonusTable = { "nocover" : 0 , "lightcover" : 2 , "heavycover" : 4 , "entrenchedcover" : 6 } ;
const statThreatLevel = [ "agi" , "str" , "phy" , "com" , "def" , "per" ]
const _ _subkey2title = {
"melee-dmg" : "Melee Damage" , "melee-atk" : "Melee Attack" , "ranged-atk" : "Ranged Attack" ,
"ranged-dmg" : "Ranged Damage" , "dmg-res" : "Damare Resistance"
}
/* -------------------------------------------- */
/* -------------------------------------------- */
/ * *
* Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system .
* @ extends { Actor }
* /
2023-01-04 22:09:09 +01:00
export class WarheroActor extends Actor {
2023-01-04 21:24:56 +01:00
/* -------------------------------------------- */
/ * *
* 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 ( data . items ) {
let actor = super . create ( data , options ) ;
return actor ;
}
if ( data . type == 'character' ) {
2023-01-04 22:09:09 +01:00
const skills = await WarheroUtility . loadCompendium ( "fvtt-warhero.skills" ) ;
2023-01-04 21:24:56 +01:00
data . items = skills . map ( i => i . toObject ( ) )
}
if ( data . type == 'npc' ) {
}
return super . create ( data , options ) ;
}
/* -------------------------------------------- */
prepareBaseData ( ) {
}
/* -------------------------------------------- */
async prepareData ( ) {
super . prepareData ( ) ;
}
/* -------------------------------------------- */
computeHitPoints ( ) {
if ( this . type == "character" ) {
}
}
/* -------------------------------------------- */
prepareDerivedData ( ) {
if ( this . type == 'character' || game . user . isGM ) {
this . computeHitPoints ( )
}
super . prepareDerivedData ( ) ;
}
/* -------------------------------------------- */
_preUpdate ( changed , options , user ) {
super . _preUpdate ( changed , options , user ) ;
}
/* -------------------------------------------- */
getEncumbranceCapacity ( ) {
return 1 ;
}
/* -------------------------------------------- */
getMoneys ( ) {
let comp = this . items . filter ( item => item . type == 'money' ) ;
2023-01-04 22:09:09 +01:00
WarheroUtility . sortArrayObjectsByName ( comp )
2023-01-04 21:24:56 +01:00
return comp ;
}
/* -------------------------------------------- */
getFeats ( ) {
let comp = duplicate ( this . items . filter ( item => item . type == 'feat' ) || [ ] ) ;
2023-01-04 22:09:09 +01:00
WarheroUtility . sortArrayObjectsByName ( comp )
2023-01-04 21:24:56 +01:00
return comp ;
}
/* -------------------------------------------- */
getFeatsWithDie ( ) {
let comp = duplicate ( this . items . filter ( item => item . type == 'feat' && item . system . isfeatdie ) || [ ] ) ;
2023-01-04 22:09:09 +01:00
WarheroUtility . sortArrayObjectsByName ( comp )
2023-01-04 21:24:56 +01:00
return comp ;
}
getFeatsWithSL ( ) {
let comp = duplicate ( this . items . filter ( item => item . type == 'feat' && item . system . issl ) || [ ] ) ;
2023-01-04 22:09:09 +01:00
WarheroUtility . sortArrayObjectsByName ( comp )
2023-01-04 21:24:56 +01:00
return comp ;
}
/* -------------------------------------------- */
getLore ( ) {
let comp = duplicate ( this . items . filter ( item => item . type == 'spell' ) || [ ] ) ;
2023-01-04 22:09:09 +01:00
WarheroUtility . sortArrayObjectsByName ( comp )
2023-01-04 21:24:56 +01:00
return comp ;
}
getEquippedWeapons ( ) {
let comp = duplicate ( this . items . filter ( item => item . type == 'weapon' && item . system . equipped ) || [ ] ) ;
2023-01-04 22:09:09 +01:00
WarheroUtility . sortArrayObjectsByName ( comp )
2023-01-04 21:24:56 +01:00
return comp ;
}
/* -------------------------------------------- */
getArmors ( ) {
let comp = duplicate ( this . items . filter ( item => item . type == 'armor' ) || [ ] ) ;
2023-01-04 22:09:09 +01:00
WarheroUtility . sortArrayObjectsByName ( comp )
2023-01-04 21:24:56 +01:00
return comp ;
}
2023-01-29 16:56:09 +01:00
getPowers ( ) {
let comp = duplicate ( this . items . filter ( item => item . type == 'power' ) || [ ] ) ;
WarheroUtility . sortArrayObjectsByName ( comp )
return comp ;
2023-01-04 21:24:56 +01:00
}
/* -------------------------------------------- */
getShields ( ) {
let comp = duplicate ( this . items . filter ( item => item . type == 'shield' ) || [ ] ) ;
2023-01-04 22:09:09 +01:00
WarheroUtility . sortArrayObjectsByName ( comp )
2023-01-04 21:24:56 +01:00
return comp ;
}
/* -------------------------------------------- */
getRace ( ) {
let race = this . items . filter ( item => item . type == 'race' )
return race [ 0 ] ? ? [ ] ;
}
/* -------------------------------------------- */
2023-01-29 16:56:09 +01:00
getClass ( ) {
let classWH = this . items . filter ( item => item . type == 'class' )
return classWH [ 0 ] ? ? [ ] ;
}
/* -------------------------------------------- */
2023-01-04 21:24:56 +01:00
checkAndPrepareEquipment ( item ) {
}
/* -------------------------------------------- */
checkAndPrepareEquipments ( listItem ) {
for ( let item of listItem ) {
this . checkAndPrepareEquipment ( item )
}
return listItem
}
2023-01-29 16:56:09 +01:00
/* -------------------------------------------- */
buildEquipmentsSlot ( ) {
let containers = { }
for ( let slotName in game . system . warhero . config . slotNames ) {
let slotDef = game . system . warhero . config . slotNames [ slotName ]
containers [ slotName ] = duplicate ( slotDef )
containers [ slotName ] . content = this . items . filter ( it => ( it . type == 'weapon' || it . type == 'armor' || it . type == 'shield' || it . type == 'equipment' )
&& it . system . slotlocation == slotName )
let slotUsed = 0
for ( let item of containers [ slotName ] . content ) {
slotUsed += item . system . slotused
}
containers [ slotName ] . slotUsed = slotUsed
}
return containers
}
2023-01-04 21:24:56 +01:00
/* -------------------------------------------- */
getConditions ( ) {
let comp = duplicate ( this . items . filter ( item => item . type == 'condition' ) || [ ] ) ;
2023-01-04 22:09:09 +01:00
WarheroUtility . sortArrayObjectsByName ( comp )
2023-01-04 21:24:56 +01:00
return comp ;
}
/* -------------------------------------------- */
getWeapons ( ) {
let comp = duplicate ( this . items . filter ( item => item . type == 'weapon' ) || [ ] ) ;
2023-01-04 22:09:09 +01:00
WarheroUtility . sortArrayObjectsByName ( comp )
2023-01-04 21:24:56 +01:00
return comp ;
}
/* -------------------------------------------- */
getItemById ( id ) {
let item = this . items . find ( item => item . id == id ) ;
if ( item ) {
item = duplicate ( item )
}
return item ;
}
/* -------------------------------------------- */
getSkills ( ) {
let comp = duplicate ( this . items . filter ( item => item . type == 'skill' ) || [ ] )
for ( let skill of comp ) {
2023-01-04 22:09:09 +01:00
WarheroUtility . updateSkill ( skill )
2023-01-04 21:24:56 +01:00
}
2023-01-04 22:09:09 +01:00
WarheroUtility . sortArrayObjectsByName ( comp )
2023-01-04 21:24:56 +01:00
return comp
}
/* -------------------------------------------- */
getRelevantAbility ( statKey ) {
let comp = duplicate ( this . items . filter ( item => item . type == 'skill' && item . system . ability == ability ) || [ ] ) ;
return comp ;
}
/* -------------------------------------------- */
async equipItem ( itemId ) {
let item = this . items . find ( item => item . id == itemId )
if ( item && item . system ) {
if ( item . type == "armor" ) {
let armor = this . items . find ( item => item . id != itemId && item . type == "armor" && item . system . equipped )
if ( armor ) {
ui . notifications . warn ( "You already have an armor equipped!" )
return
}
}
if ( item . type == "shield" ) {
let shield = this . items . find ( item => item . id != itemId && item . type == "shield" && item . system . equipped )
if ( shield ) {
ui . notifications . warn ( "You already have a shield equipped!" )
return
}
}
let update = { _id : item . id , "system.equipped" : ! item . system . equipped } ;
await this . updateEmbeddedDocuments ( 'Item' , [ update ] ) ; // Updates one EmbeddedEntity
}
}
/* -------------------------------------------- */
compareName ( a , b ) {
if ( a . name < b . name ) {
return - 1 ;
}
if ( a . name > b . name ) {
return 1 ;
}
return 0 ;
}
/* ------------------------------------------- */
getEquipments ( ) {
return this . items . filter ( item => item . type == 'shield' || item . type == 'armor' || item . type == "weapon" || item . type == "equipment" ) ;
}
/* ------------------------------------------- */
getEquipmentsOnly ( ) {
return duplicate ( this . items . filter ( item => item . type == "equipment" ) || [ ] )
}
/* ------------------------------------------- */
getSaveRoll ( ) {
return {
reflex : {
"label" : "Reflex Save" ,
2023-01-04 22:09:09 +01:00
"img" : "systems/fvtt-warhero/images/icons/saves/reflex_save.webp" ,
2023-01-04 21:24:56 +01:00
"value" : this . system . abilities . agi . value + this . system . abilities . wit . value
} ,
fortitude : {
"label" : "Fortitude Save" ,
2023-01-04 22:09:09 +01:00
"img" : "systems/fvtt-warhero/images/icons/saves/fortitude_save.webp" ,
2023-01-04 21:24:56 +01:00
"value" : this . system . abilities . str . value + this . system . abilities . con . value
} ,
willpower : {
"label" : "Willpower Save" ,
2023-01-04 22:09:09 +01:00
"img" : "systems/fvtt-warhero/images/icons/saves/will_save.webp" ,
2023-01-04 21:24:56 +01:00
"value" : this . system . abilities . int . value + this . system . abilities . cha . value
}
}
}
/* ------------------------------------------- */
async buildContainerTree ( ) {
let equipments = duplicate ( this . items . filter ( item => item . type == "equipment" ) || [ ] )
for ( let equip1 of equipments ) {
if ( equip1 . system . iscontainer ) {
equip1 . system . contents = [ ]
equip1 . system . contentsEnc = 0
for ( let equip2 of equipments ) {
if ( equip1 . _id != equip2 . id && equip2 . system . containerid == equip1 . id ) {
equip1 . system . contents . push ( equip2 )
let q = equip2 . system . quantity ? ? 1
equip1 . system . contentsEnc += q * equip2 . system . weight
}
}
}
}
// Compute whole enc
let enc = 0
for ( let item of equipments ) {
2023-01-04 22:09:09 +01:00
//item.data.idrDice = WarheroUtility.getDiceFromLevel(Number(item.data.idr))
2023-01-04 21:24:56 +01:00
if ( item . system . equipped ) {
if ( item . system . iscontainer ) {
enc += item . system . contentsEnc
} else if ( item . system . containerid == "" ) {
let q = item . system . quantity ? ? 1
enc += q * item . system . weight
}
}
}
for ( let item of this . items ) { // Process items/shields/armors
if ( ( item . type == "weapon" || item . type == "shield" || item . type == "armor" ) && item . system . equipped ) {
let q = item . system . quantity ? ? 1
enc += q * item . system . weight
}
}
// Store local values
this . encCurrent = enc
this . containersTree = equipments . filter ( item => item . system . containerid == "" ) // Returns the root of equipements without container
}
/* -------------------------------------------- */
async rollArmor ( rollData ) {
let armor = this . getEquippedArmor ( )
if ( armor ) {
}
return { armor : "none" }
}
/* -------------------------------------------- */
async incDecHP ( formula ) {
2023-01-04 22:09:09 +01:00
let dmgRoll = new Roll ( formula + "[warhero-orange]" ) . roll ( { async : false } )
await WarheroUtility . showDiceSoNice ( dmgRoll , game . settings . get ( "core" , "rollMode" ) )
2023-01-04 21:24:56 +01:00
let hp = duplicate ( this . system . secondary . hp )
hp . value = Number ( hp . value ) + Number ( dmgRoll . total )
this . update ( { 'system.secondary.hp' : hp } )
return Number ( dmgRoll . total )
}
/* -------------------------------------------- */
getAbility ( abilKey ) {
return this . system . abilities [ abilKey ] ;
}
/* -------------------------------------------- */
async addObjectToContainer ( itemId , containerId ) {
let container = this . items . find ( item => item . id == containerId && item . system . iscontainer )
let object = this . items . find ( item => item . id == itemId )
if ( container ) {
if ( object . system . iscontainer ) {
ui . notifications . warn ( "Only 1 level of container allowed" )
return
}
let alreadyInside = this . items . filter ( item => item . system . containerid && item . system . containerid == containerId ) ;
if ( alreadyInside . length >= container . system . containercapacity ) {
ui . notifications . warn ( "Container is already full !" )
return
} else {
await this . updateEmbeddedDocuments ( "Item" , [ { _id : object . id , 'system.containerid' : containerId } ] )
}
} else if ( object && object . system . containerid ) { // remove from container
console . log ( "Removeing: " , object )
await this . updateEmbeddedDocuments ( "Item" , [ { _id : object . id , 'system.containerid' : "" } ] ) ;
}
}
/* -------------------------------------------- */
async preprocessItem ( event , item , onDrop = false ) {
let dropID = $ ( event . target ) . parents ( ".item" ) . attr ( "data-item-id" ) // Only relevant if container drop
let objectID = item . id || item . _id
this . addObjectToContainer ( objectID , dropID )
return true
}
/* -------------------------------------------- */
async equipGear ( equipmentId ) {
let item = this . items . find ( item => item . id == equipmentId ) ;
if ( item && item . system ) {
let update = { _id : item . id , "system.equipped" : ! item . system . equipped } ;
await this . updateEmbeddedDocuments ( 'Item' , [ update ] ) ; // Updates one EmbeddedEntity
}
}
/* -------------------------------------------- */
getInitiativeScore ( combatId , combatantId ) {
if ( this . type == 'character' ) {
this . rollMR ( true , combatId , combatantId )
}
console . log ( "Init required !!!!" )
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 ( { 'system.subactors' : subActors } ) ;
}
/* -------------------------------------------- */
async delSubActor ( subActorId ) {
let newArray = [ ] ;
for ( let id of this . system . subactors ) {
if ( id != subActorId ) {
newArray . push ( id ) ;
}
}
await this . update ( { 'system.subactors' : newArray } ) ;
}
/* -------------------------------------------- */
syncRoll ( rollData ) {
this . lastRollId = rollData . rollId ;
2023-01-04 22:09:09 +01:00
WarheroUtility . saveRollData ( rollData ) ;
2023-01-04 21:24:56 +01:00
}
/* -------------------------------------------- */
getOneSkill ( skillId ) {
let skill = this . items . find ( item => item . type == 'skill' && item . id == skillId )
if ( skill ) {
skill = duplicate ( skill ) ;
}
return skill ;
}
/* -------------------------------------------- */
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 incrementSkillExp ( skillId , inc ) {
let skill = this . items . get ( skillId )
if ( skill ) {
await this . updateEmbeddedDocuments ( 'Item' , [ { _id : skill . id , 'system.exp' : skill . system . exp + inc } ] )
let chatData = {
user : game . user . id ,
rollMode : game . settings . get ( "core" , "rollMode" ) ,
whisper : [ game . user . id ] . concat ( ChatMessage . getWhisperRecipients ( 'GM' ) ) ,
content : ` <div> ${ this . name } has gained 1 exp in the skill ${ skill . name } (exp = ${ skill . system . exp } )</div `
}
ChatMessage . create ( chatData )
if ( skill . system . exp >= 25 ) {
await this . updateEmbeddedDocuments ( 'Item' , [ { _id : skill . id , 'system.exp' : 0 , 'system.explevel' : skill . system . explevel + 1 } ] )
let chatData = {
user : game . user . id ,
rollMode : game . settings . get ( "core" , "rollMode" ) ,
whisper : [ game . user . id ] . concat ( ChatMessage . getWhisperRecipients ( 'GM' ) ) ,
content : ` <div> ${ this . name } has gained 1 exp SL in the skill ${ skill . name } (new exp SL : ${ skill . system . explevel } ) !</div `
}
ChatMessage . create ( chatData )
}
}
}
/* -------------------------------------------- */
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 , 'system.quantity' : newQ } ] ) // pdates one EmbeddedEntity
}
}
}
/* -------------------------------------------- */
async incDecAmmo ( objetId , incDec = 0 ) {
let objetQ = this . items . get ( objetId )
if ( objetQ ) {
let newQ = objetQ . system . ammocurrent + incDec ;
if ( newQ >= 0 && newQ <= objetQ . system . ammomax ) {
const updated = await this . updateEmbeddedDocuments ( 'Item' , [ { _id : objetQ . id , 'system.ammocurrent' : newQ } ] ) ; // pdates one EmbeddedEntity
}
}
}
/* -------------------------------------------- */
isForcedAdvantage ( ) {
return this . items . find ( cond => cond . type == "condition" && cond . system . advantage )
}
isForcedDisadvantage ( ) {
return this . items . find ( cond => cond . type == "condition" && cond . system . disadvantage )
}
isForcedRollAdvantage ( ) {
return this . items . find ( cond => cond . type == "condition" && cond . system . rolladvantage )
}
isForcedRollDisadvantage ( ) {
return this . items . find ( cond => cond . type == "condition" && cond . system . rolldisadvantage )
}
isNoAdvantage ( ) {
return this . items . find ( cond => cond . type == "condition" && cond . system . noadvantage )
}
isNoAction ( ) {
return this . items . find ( cond => cond . type == "condition" && cond . system . noaction )
}
isAttackDisadvantage ( ) {
return this . items . find ( cond => cond . type == "condition" && cond . system . attackdisadvantage )
}
isDefenseDisadvantage ( ) {
return this . items . find ( cond => cond . type == "condition" && cond . system . defensedisadvantage )
}
isAttackerAdvantage ( ) {
return this . items . find ( cond => cond . type == "condition" && cond . system . targetadvantage )
}
/* -------------------------------------------- */
2023-01-29 16:56:09 +01:00
getCommonRollData ( ) {
2023-01-04 22:09:09 +01:00
let rollData = WarheroUtility . getBasicRollData ( )
2023-01-04 21:24:56 +01:00
rollData . alias = this . name
rollData . actorImg = this . img
rollData . actorId = this . id
rollData . img = this . img
console . log ( "ROLLDATA" , rollData )
return rollData
}
/* -------------------------------------------- */
2023-01-29 16:56:09 +01:00
rollFromType ( rollType , rollKey ) {
let stat = duplicate ( this . system [ rollType ] [ rollKey ] )
let rollData = this . getCommonRollData ( )
rollData . mode = rollType
rollData . stat = stat
this . startRoll ( rollData )
2023-01-04 21:24:56 +01:00
}
/* -------------------------------------------- */
rollWeapon ( weaponId ) {
let weapon = this . items . get ( weaponId )
if ( weapon ) {
weapon = duplicate ( weapon )
let skill = this . items . find ( item => item . name . toLowerCase ( ) == weapon . system . skill . toLowerCase ( ) )
if ( skill ) {
skill = duplicate ( skill )
2023-01-04 22:09:09 +01:00
WarheroUtility . updateSkill ( skill )
2023-01-04 21:24:56 +01:00
let abilityKey = skill . system . ability
let rollData = this . getCommonRollData ( abilityKey )
rollData . mode = "weapon"
rollData . skill = skill
rollData . weapon = weapon
rollData . img = weapon . img
if ( ! rollData . forceDisadvantage ) { // This is an attack, check if disadvantaged
rollData . forceDisadvantage = this . isAttackDisadvantage ( )
}
2023-01-04 22:09:09 +01:00
/ * i f ( r o l l D a t a . w e a p o n . s y s t e m . i s r a n g e d & & r o l l D a t a . t o k e n s D i s t a n c e > W a r h e r o U t i l i t y . g e t W e a p o n M a x R a n g e ( r o l l D a t a . w e a p o n ) ) {
ui . notifications . warn ( ` Your target is out of range of your weapon (max: ${ WarheroUtility . getWeaponMaxRange ( rollData . weapon ) } - current : ${ rollData . tokensDistance } ) ` )
2023-01-04 21:24:56 +01:00
return
} * /
this . startRoll ( rollData )
} else {
ui . notifications . warn ( "Unable to find the relevant skill for weapon " + weapon . name )
}
}
}
/* -------------------------------------------- */
async startRoll ( rollData ) {
this . syncRoll ( rollData )
2023-01-04 22:09:09 +01:00
let rollDialog = await WarheroRollDialog . create ( this , rollData )
2023-01-04 21:24:56 +01:00
rollDialog . render ( true )
}
}