2022-11-27 08:58:19 +01:00
/* -------------------------------------------- */
import { DarkStarsUtility } from "./dark-stars-utility.js" ;
import { DarkStarsRollDialog } from "./dark-stars-roll-dialog.js" ;
/* -------------------------------------------- */
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 }
* /
export class DarkStarsActor 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 ( data . items ) {
let actor = super . create ( data , options ) ;
return actor ;
}
if ( data . type == 'character' ) {
const skills = await DarkStarsUtility . loadCompendium ( "fvtt-dark-stars.skills" ) ;
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" ) {
}
}
2022-12-30 22:27:38 +01:00
2022-11-27 08:58:19 +01:00
/* -------------------------------------------- */
2022-12-30 22:27:38 +01:00
computeDerivated ( ) {
let attr = this . system . attributes
let deriv = this . system . derivated
let secondary = this . system . secondary
deriv . csb . value = Math . round ( ( attr . dex . value + attr . sel . value ) / 2 ) + deriv . csb . bonus
deriv . asb . value = Math . round ( ( attr . int . value + attr . edu . value ) / 2 ) + deriv . asb . bonus
deriv . ssb . value = Math . round ( ( attr . cha . value + attr . emp . value + attr . att . value ) / 3 ) + deriv . ssb . bonus
deriv . msb . value = Math . round ( ( attr . con . value + attr . str . value ) / 2 ) + deriv . msb . bonus
deriv . psb . value = Math . round ( ( attr . str . value + attr . dex . value + attr . con . value ) / 3 ) + deriv . psb . bonus
deriv . ego . value = attr . str . value + attr . cha . value + attr . sel . value + attr . emp . value + deriv . ego . bonus
deriv . hup . value = ( attr . emp . value * 10 ) + deriv . hup . bonus
deriv . ss . value = ( attr . edu . value * 10 ) + ( attr . int . value * 10 ) + 250 + deriv . ss . bonus
deriv . mcdb . value = Math . round ( ( attr . str . value + attr . siz . value ) / 4 ) + deriv . mcdb . bonus
deriv . si . value = Math . round ( ( ( attr . dex . value + attr . sel . value ) / 5 ) + 0.5 ) + deriv . si . bonus
secondary . hp . max = ( ( attr . con . value + attr . siz . value ) * 2 ) + secondary . hp . bonus
secondary . fp . max = 10 + attr . str . value + attr . con . value + secondary . fp . bonus
2022-11-27 08:58:19 +01:00
}
/* -------------------------------------------- */
prepareDerivedData ( ) {
if ( this . type == 'character' || game . user . isGM ) {
this . system . encCapacity = this . getEncumbranceCapacity ( )
2022-12-30 22:27:38 +01:00
this . computeDerivated ( )
2022-11-27 08:58:19 +01:00
this . buildContainerTree ( )
this . computeHitPoints ( )
this . computeEffortPoints ( )
}
super . prepareDerivedData ( ) ;
}
/* -------------------------------------------- */
_preUpdate ( changed , options , user ) {
super . _preUpdate ( changed , options , user ) ;
}
/* -------------------------------------------- */
getEncumbranceCapacity ( ) {
return 1 ;
}
getEquippedWeapons ( ) {
let comp = duplicate ( this . items . filter ( item => item . type == 'weapon' && item . system . equipped ) || [ ] ) ;
DarkStarsUtility . sortArrayObjectsByName ( comp )
return comp ;
}
/* -------------------------------------------- */
getArmors ( ) {
let comp = duplicate ( this . items . filter ( item => item . type == 'armor' ) || [ ] ) ;
DarkStarsUtility . sortArrayObjectsByName ( comp )
return comp ;
}
getEquippedArmor ( ) {
let comp = this . items . find ( item => item . type == 'armor' && item . system . equipped )
if ( comp ) {
return duplicate ( comp )
}
return undefined
}
/* -------------------------------------------- */
getShields ( ) {
let comp = duplicate ( this . items . filter ( item => item . type == 'shield' ) || [ ] ) ;
DarkStarsUtility . sortArrayObjectsByName ( comp )
return comp ;
}
getEquippedShield ( ) {
let comp = this . items . find ( item => item . type == 'shield' && item . system . equipped )
if ( comp ) {
return duplicate ( comp )
}
return undefined
}
/* -------------------------------------------- */
checkAndPrepareEquipment ( item ) {
}
/* -------------------------------------------- */
checkAndPrepareEquipments ( listItem ) {
for ( let item of listItem ) {
this . checkAndPrepareEquipment ( item )
}
return listItem
}
/* -------------------------------------------- */
getConditions ( ) {
let comp = duplicate ( this . items . filter ( item => item . type == 'condition' ) || [ ] ) ;
DarkStarsUtility . sortArrayObjectsByName ( comp )
return comp ;
}
/* -------------------------------------------- */
getWeapons ( ) {
let comp = duplicate ( this . items . filter ( item => item . type == 'weapon' ) || [ ] ) ;
DarkStarsUtility . sortArrayObjectsByName ( comp )
return comp ;
}
/* -------------------------------------------- */
getItemById ( id ) {
let item = this . items . find ( item => item . id == id ) ;
if ( item ) {
item = duplicate ( item )
}
return item ;
}
2022-12-30 22:27:38 +01:00
/* -------------------------------------------- */
updateSkill ( skill ) {
skill . derivated = duplicate ( this . system . derivated [ skill . system . base ] )
skill . total = skill . derivated . value + skill . system . bonus
}
2022-11-27 08:58:19 +01:00
/* -------------------------------------------- */
getSkills ( ) {
2022-12-30 22:27:38 +01:00
this . computeDerivated ( )
2022-11-27 08:58:19 +01:00
let comp = duplicate ( this . items . filter ( item => item . type == 'skill' ) || [ ] )
for ( let skill of comp ) {
2022-12-30 22:27:38 +01:00
this . updateSkill ( skill )
2022-11-27 08:58:19 +01:00
}
DarkStarsUtility . sortArrayObjectsByName ( comp )
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" ,
"img" : "systems/fvtt-dark-stars/images/icons/saves/reflex_save.webp" ,
"value" : this . system . abilities . agi . value + this . system . abilities . wit . value
} ,
fortitude : {
"label" : "Fortitude Save" ,
"img" : "systems/fvtt-dark-stars/images/icons/saves/fortitude_save.webp" ,
"value" : this . system . abilities . str . value + this . system . abilities . con . value
} ,
willpower : {
"label" : "Willpower Save" ,
"img" : "systems/fvtt-dark-stars/images/icons/saves/will_save.webp" ,
"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 ) {
//item.data.idrDice = DarkStarsUtility.getDiceFromLevel(Number(item.data.idr))
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 ) {
2022-12-30 22:27:38 +01:00
let dmgRoll = new Roll ( formula + "[dark-starsorange]" ) . roll ( { async : false } )
2022-11-27 08:58:19 +01:00
await DarkStarsUtility . showDiceSoNice ( dmgRoll , game . settings . get ( "core" , "rollMode" ) )
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 } ) ;
}
/* -------------------------------------------- */
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 )
}
/* -------------------------------------------- */
getCommonRollData ( abilityKey = undefined ) {
let noAction = this . isNoAction ( )
if ( noAction ) {
ui . notifications . warn ( "You can't do any actions du to the condition : " + noAction . name )
return
}
let rollData = DarkStarsUtility . getBasicRollData ( )
rollData . alias = this . name
rollData . actorImg = this . img
rollData . actorId = this . id
rollData . img = this . img
rollData . armors = this . getArmors ( )
rollData . conditions = this . getConditions ( )
if ( rollData . defenderTokenId ) {
let defenderToken = game . canvas . tokens . get ( rollData . defenderTokenId )
let defender = defenderToken . actor
// Distance management
let token = this . token
if ( ! token ) {
let tokens = this . getActiveTokens ( )
token = tokens [ 0 ]
}
if ( token ) {
const ray = new Ray ( token . object ? . center || token . center , defenderToken . center )
rollData . tokensDistance = canvas . grid . measureDistances ( [ { ray } ] , { gridSpaces : false } ) [ 0 ] / canvas . grid . grid . options . dimensions . distance
} else {
ui . notifications . info ( "No token connected to this actor, unable to compute distance." )
return
}
if ( defender ) {
rollData . forceAdvantage = defender . isAttackerAdvantage ( )
rollData . advantageFromTarget = true
}
}
if ( abilityKey ) {
rollData . ability = this . getAbility ( abilityKey )
rollData . selectedKill = undefined
}
console . log ( "ROLLDATA" , rollData )
return rollData
}
/* -------------------------------------------- */
rollAbility ( abilityKey ) {
let rollData = this . getCommonRollData ( abilityKey )
rollData . mode = "ability"
if ( rollData . target ) {
ui . notifications . warn ( "You are targetting a token with a skill : please use a Weapon instead." )
return
}
DarkStarsUtility . rollDarkStars ( rollData )
}
/* -------------------------------------------- */
rollSkill ( skillId ) {
let skill = this . items . get ( skillId )
if ( skill ) {
if ( skill . system . islore && skill . system . level == 0 ) {
ui . notifications . warn ( "You can't use Lore Skills with a SL of 0." )
return
}
skill = duplicate ( skill )
2022-12-30 22:27:38 +01:00
this . updateSkill ( skill )
let rollData = this . getCommonRollData ( )
2022-11-27 08:58:19 +01:00
rollData . mode = "skill"
2022-12-30 22:27:38 +01:00
rollData . title = "Skill " + skill . name
2022-11-27 08:58:19 +01:00
rollData . skill = skill
rollData . img = skill . img
if ( rollData . target ) {
ui . notifications . warn ( "You are targetting a token with a skill : please use a Weapon instead." )
return
}
this . startRoll ( rollData )
}
}
/* -------------------------------------------- */
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 )
DarkStarsUtility . updateSkill ( skill )
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 ( )
}
/ * 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 > D a r k S t a r s 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: ${ DarkStarsUtility . getWeaponMaxRange ( rollData . weapon ) } - current : ${ rollData . tokensDistance } ) ` )
return
} * /
this . startRoll ( rollData )
} else {
ui . notifications . warn ( "Unable to find the relevant skill for weapon " + weapon . name )
}
}
}
/* -------------------------------------------- */
async startRoll ( rollData ) {
let rollDialog = await DarkStarsRollDialog . create ( this , rollData )
rollDialog . render ( true )
}
}