Nighthawk/roll20-character-sheets
1
0
Fork 0
mirror of https://github.com/Nighthawk42/roll20-character-sheets.git synced 2026-08-31 04:02:29 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
32a3859da5fb141ffe2d414595f968226d01faef
roll20-character-sheets/Genefunk 2090/genefunk2090.js
T

1867 lines
56 KiB
JavaScript
Raw Blame History

var genefunk2090 = genefunk2090 || (function() {
const version = 1.20;
const displayControllers = ['sheet_view','advantage_state','character_type','whisper_state'],
importControls = ['import','import_cancel'],
abilityScores = {str:'strength',dex:'dexterity',con:'constitution',int:'intelligence',wis:'wisdom',cha:'charisma'},
skillNames = ['athletics','acrobatics','drive','sleight_of_hand','stealth','bureaucracy','computers','investigation','life_science','mechanics','physical_science','social_science','streetwise','insight','perception','survival','deception','intimidation','performance','persuasion'],
skillList = {athletics:'strength',acrobatics:'dexterity',drive:'dexterity',sleight_of_hand:'dexterity',stealth:'dexterity',bureaucracy:'intelligence',computers:'intelligence',investigation:'intelligence',life_science:'intelligence',mechanics:'intelligence',physical_science:'intelligence',social_science:'intelligence',streetwise:'intelligence',insight:'wisdom',perception:'wisdom',survival:'wisdom',deception:'charisma',intimidation:'charisma',performance:'charisma',persuasion:'charisma'},
hackLevels = ['1st','2nd','3rd','4th','5th'],
repeating_section_details = [
{
section:'repeating_equipment',
fields:['name','quantity','weight','cost','mods','description','id']
},
{
section:'repeating_hack',
fields:['name','level','launch_time','duration','hack_type','source','action_proficiency','attack_enable_item','save_enable_item','damage_1_enable_item','damage_2_enable_item','attack_ability','attack_bonus','save_ability','save_type','dc_bonus','damage_1','critical_damage_1','damage_ability_1','damage_type_1','damage_2','critical_damage_2','damage_ability_2','damage_type_2','range','properties','description','id']
},
{
section:'repeating_action',
fields:['name','action_proficiency','attack_enable_item','save_enable_item','damage_1_enable_item','damage_2_enable_item','attack_ability','attack_bonus','save_ability','save_type','dc_bonus','damage_1','critical_damage_1','damage_ability_1','damage_type_1','damage_2','critical_damage_2','damage_ability_2','damage_type_2','range','properties','description','id']
},
{
section:'repeating_trait',
fields:['name','source','mods','description','id']
}
],
cascades = {
pc:{
class_level:{
name:'class_level',
defaultValue:'',
type:'text',
affects:['level']
},
level:{
name:'level',
defaultValue:'',
type:'number',
calculation:'custom',
affects:['proficiency']
},
proficiency:{
name:'proficiency',
defaultValue:'',
type:'number',
calculation:'2+floor((@{level}-1)/4)',
affects:['variable']
},
ac_formula:{
name:'ac_formula',
defaultValue:'10+@{dexterity_mod}',
type:'text',
calculation:'custom',
affects:['ac']
},
ac:{
name:'ac',
defaultValue:'10',
type:'number',
calculation:'@{ac_formula}',
affects:[]
},
base_strength:{
name:'base_strength',
defaultValue:10,
type:'number',
affects:['strength']
},
base_dexterity:{
name:'base_dexterity',
defaultValue:10,
type:'number',
affects:['dexterity']
},
base_constitution:{
name:'base_constitution',
defaultValue:10,
type:'number',
affects:['constitution']
},
base_intelligence:{
name:'base_intelligence',
defaultValue:10,
type:'number',
affects:['intelligence']
},
base_wisdom:{
name:'base_wisdom',
defaultValue:10,
type:'number',
affects:['wisdom']
},
base_charisma:{
name:'base_charisma',
defaultValue:10,
type:'number',
affects:['charisma']
},
strength:{
name:'strength',
defaultValue:10,
type:'number',
calculation:'@{base_strength} @{strength_modded}',
affects:['strength_mod']
},
dexterity:{
name:'dexterity',
defaultValue:10,
type:'number',
calculation:'@{base_dexterity} @{dexterity_modded}',
affects:['dexterity_mod']
},
constitution:{
name:'constitution',
defaultValue:10,
type:'number',
calculation:'@{base_constitution} @{constitution_modded}',
affects:['constitution_mod']
},
intelligence:{
name:'intelligence',
defaultValue:10,
type:'number',
calculation:'@{base_intelligence} @{intelligence_modded}',
affects:['intelligence_mod']
},
wisdom:{
name:'wisdom',
defaultValue:10,
type:'number',
calculation:'@{base_wisdom} @{wisdom_modded}',
affects:['wisdom_mod']
},
charisma:{
name:'charisma',
defaultValue:10,
type:'number',
calculation:'@{base_charisma} @{charisma_modded}',
affects:['charisma_mod']
},
strength_mod:{
name:'strength_mod',
defaultValue:0,
type:'number',
calculation:'floor((@{strength}-10)/2)',
affects:['athletics','strength_save','variable']
},
strength_save_proficiency:{
name:'strength_save_proficiency',
defaultValue:0,
type:'text',
affects:['strength_save']
},
strength_save:{
name:'strength_save',
defaultValue:0,
type:'number',
calculation:'@{strength_mod} + @{strength_save_proficiency}@{strength_save_modded}',
affects:[]
},
dexterity_mod:{
name:'dexterity_mod',
defaultValue:0,
type:'number',
calculation:'floor((@{dexterity}-10)/2)',
affects:['acrobatics','drive','sleight_of_hand','stealth','dexterity_save','initiative','variable']
},
dexterity_save_proficiency:{
name:'dexterity_save_proficiency',
defaultValue:0,
type:'text',
affects:['dexterity_save']
},
dexterity_save:{
name:'dexterity_save',
defaultValue:0,
type:'number',
calculation:'@{dexterity_mod} + @{dexterity_save_proficiency}@{dexterity_save_modded}',
affects:[]
},
constitution_mod:{
name:'constitution_mod',
defaultValue:0,
type:'number',
calculation:'floor((@{constitution}-10)/2)',
affects:['constitution_save','variable']
},
constitution_save_proficiency:{
name:'constitution_save_proficiency',
defaultValue:0,
type:'text',
affects:['constitution_save']
},
constitution_save:{
name:'constitution_save',
defaultValue:0,
type:'number',
calculation:'@{constitution_mod} + @{constitution_save_proficiency}@{constitution_save_modded}',
affects:[]
},
intelligence_mod:{
name:'intelligence_mod',
defaultValue:0,
type:'number',
calculation:'floor((@{intelligence}-10)/2)',
affects:['bureaucracy','computers','investigation','life_science','mechanics','physical_science','social_science','streetwise','intelligence_save','variable']
},
intelligence_save_proficiency:{
name:'intelligence_save_proficiency',
defaultValue:0,
type:'text',
affects:['intelligence_save']
},
intelligence_save:{
name:'intelligence_save',
defaultValue:0,
type:'number',
calculation:'@{intelligence_mod} + @{intelligence_save_proficiency}@{intelligence_save_modded}',
affects:[]
},
wisdom_mod:{
name:'wisdom_mod',
defaultValue:0,
type:'number',
calculation:'floor((@{wisdom}-10)/2)',
affects:['insight','perception','survival','wisdom_save','variable']
},
wisdom_save_proficiency:{
name:'wisdom_save_proficiency',
defaultValue:0,
type:'text',
affects:['wisdom_save']
},
wisdom_save:{
name:'wisdom_save',
defaultValue:0,
type:'number',
calculation:'@{wisdom_mod} + @{wisdom_save_proficiency}@{wisdom_save_modded}',
affects:[]
},
charisma_mod:{
name:'charisma_mod',
defaultValue:0,
type:'number',
calculation:'floor((@{charisma}-10)/2)',
affects:['deception','intimidation','performance','persuasion','charisma_save','variable']
},
charisma_save_proficiency:{
name:'charisma_save_proficiency',
defaultValue:0,
type:'text',
affects:['charisma_save']
},
charisma_save:{
name:'charisma_save',
defaultValue:0,
type:'number',
calculation:'@{charisma_mod} + @{charisma_save_proficiency}@{charisma_save_modded}',
affects:[]
},
initiative:{
name:'initiative',
defaultValue:0,
type:'number',
calculation:'@{dexterity_mod}@{initiative_modded}',
affects:[]
},
initiative_modded:{
name:'initiative_modded',
defaultValue:'',
type:'text',
affects:['initiative']
},
athletics_proficiency:{
name:'athletics_proficiency',
defaultValue:0,
type:'text',
affects:['athletics']
},
athletics:{
name:'athletics',
defaultValue:0,
type:'number',
calculation:'@{strength_mod} + @{athletics_proficiency}@{athletics_modded}',
affects:[]
},
acrobatics_proficiency:{
name:'acrobatics_proficiency',
defaultValue:0,
type:'text',
affects:['acrobatics']
},
acrobatics:{
name:'acrobatics',
defaultValue:0,
type:'number',
calculation:'@{dexterity_mod} + @{acrobatics_proficiency}@{acrobatics_modded}',
affects:[]
},
drive_proficiency:{
name:'drive_proficiency',
defaultValue:0,
type:'text',
affects:['drive']
},
drive:{
name:'drive',
defaultValue:0,
type:'number',
calculation:'@{dexterity_mod} + @{drive_proficiency}@{drive_modded}',
affects:[]
},
sleight_of_hand_proficiency:{
name:'sleight_of_hand_proficiency',
defaultValue:0,
type:'text',
affects:['sleight_of_hand']
},
sleight_of_hand:{
name:'sleight_of_hand',
defaultValue:0,
type:'number',
calculation:'@{dexterity_mod} + @{sleight_of_hand_proficiency}@{sleight_of_hand_modded}',
affects:[]
},
stealth_proficiency:{
name:'stealth_proficiency',
defaultValue:0,
type:'text',
affects:['stealth']
},
stealth:{
name:'stealth',
defaultValue:0,
type:'number',
calculation:'@{dexterity_mod} + @{stealth_proficiency}@{stealth_modded}',
affects:[]
},
bureaucracy_proficiency:{
name:'bureaucracy_proficiency',
defaultValue:0,
type:'text',
affects:['bureaucracy']
},
bureaucracy:{
name:'bureaucracy',
defaultValue:0,
type:'number',
calculation:'@{intelligence_mod} + @{bureaucracy_proficiency}@{bureaucracy_modded}',
affects:[]
},
computers_proficiency:{
name:'computers_proficiency',
defaultValue:0,
type:'text',
affects:['computers']
},
computers:{
name:'computers',
defaultValue:0,
type:'number',
calculation:'@{intelligence_mod} + @{computers_proficiency}@{computers_modded}',
affects:[]
},
investigation_proficiency:{
name:'investigation_proficiency',
defaultValue:0,
type:'text',
affects:['investigation']
},
investigation:{
name:'investigation',
defaultValue:0,
type:'number',
calculation:'@{intelligence_mod} + @{investigation_proficiency}@{investigation_modded}',
affects:[]
},
life_science_proficiency:{
name:'life_science_proficiency',
defaultValue:0,
type:'text',
affects:['life_science']
},
life_science:{
name:'life_science',
defaultValue:0,
type:'number',
calculation:'@{intelligence_mod} + @{life_science_proficiency}@{life_science_modded}',
affects:[]
},
mechanics_proficiency:{
name:'mechanics_proficiency',
defaultValue:0,
type:'text',
affects:['mechanics']
},
mechanics:{
name:'mechanics',
defaultValue:0,
type:'number',
calculation:'@{intelligence_mod} + @{mechanics_proficiency}@{mechanics_modded}',
affects:[]
},
physical_science_proficiency:{
name:'physical_science_proficiency',
defaultValue:0,
type:'text',
affects:['physical_science']
},
physical_science:{
name:'physical_science',
defaultValue:0,
type:'number',
calculation:'@{intelligence_mod} + @{physical_science_proficiency}@{physical_science_modded}',
affects:[]
},
social_science_proficiency:{
name:'social_science_proficiency',
defaultValue:0,
type:'text',
affects:['social_science']
},
social_science:{
name:'social_science',
defaultValue:0,
type:'number',
calculation:'@{intelligence_mod} + @{social_science_proficiency}@{social_science_modded}',
affects:[]
},
streetwise_proficiency:{
name:'streetwise_proficiency',
defaultValue:0,
type:'text',
affects:['streetwise']
},
streetwise:{
name:'streetwise',
defaultValue:0,
type:'number',
calculation:'@{intelligence_mod} + @{streetwise_proficiency}@{streetwise_modded}',
affects:[]
},
insight_proficiency:{
name:'insight_proficiency',
defaultValue:0,
type:'text',
affects:['insight']
},
insight:{
name:'insight',
defaultValue:0,
type:'number',
calculation:'@{wisdom_mod} + @{insight_proficiency}@{insight_modded}',
affects:['passive_insight']
},
passive_insight:{
name:'passive_insight',
defaultValue:10,
type:'number',
calculation:'10 +@{insight}@{passive_insight_modded}',
affects:[]
},
passive_insight_modded:{
name:'passive_insight_modded',
defaultValue:'',
type:'text',
affects:['passive_insight']
},
perception_proficiency:{
name:'perception_proficiency',
defaultValue:0,
type:'text',
affects:['perception']
},
perception:{
name:'perception',
defaultValue:0,
type:'number',
calculation:'@{wisdom_mod} + @{perception_proficiency}@{perception_modded}',
affects:['passive_perception']
},
passive_perception:{
name:'passive_perception',
defaultValue:10,
type:'number',
calculation:'10 + @{perception}@{passive_perception_modded}',
affects:[]
},
passive_perception_modded:{
name:'passive_perception_modded',
defaultValue:'',
type:'text',
affects:['passive_perception']
},
survival_proficiency:{
name:'survival_proficiency',
defaultValue:0,
type:'text',
affects:['survival']
},
survival:{
name:'survival',
defaultValue:0,
type:'number',
calculation:'@{wisdom_mod} + @{survival_proficiency}@{survival_modded}',
affects:[]
},
deception_proficiency:{
name:'deception_proficiency',
defaultValue:0,
type:'text',
affects:['deception']
},
deception:{
name:'deception',
defaultValue:0,
type:'number',
calculation:'@{charisma_mod} + @{deception_proficiency}@{deception_modded}',
affects:[]
},
intimidation_proficiency:{
name:'intimidation_proficiency',
defaultValue:0,
type:'text',
affects:['intimidation']
},
intimidation:{
name:'intimidation',
defaultValue:0,
type:'number',
calculation:'@{charisma_mod} + @{intimidation_proficiency}@{intimidation_modded}',
affects:[]
},
performance_proficiency:{
name:'performance_proficiency',
defaultValue:0,
type:'text',
affects:['performance']
},
performance:{
name:'performance',
defaultValue:0,
type:'number',
calculation:'@{charisma_mod} + @{performance_proficiency}@{performance_modded}',
affects:[]
},
persuasion_proficiency:{
name:'persuasion_proficiency',
defaultValue:0,
type:'text',
affects:['persuasion']
},
persuasion:{
name:'persuasion',
defaultValue:0,
type:'number',
calculation:'@{charisma_mod} + @{persuasion_proficiency}@{persuasion_modded}',
affects:[]
},
repeating_action_$X_bonus:{
name:'repeating_action_$X_bonus',
defaultValue:0,
type:'number',
calculation:'@{repeating_action_$X_attack_ability} + @{repeating_action_$X_attack_bonus} + @{repeating_action_$X_action_proficiency}@{repeating_action_$X_attack_modded}',
affects:[]
},
repeating_action_$X_action_proficiency:{
name:'repeating_action_$X_action_proficiency',
defaultValue:'0',
type:'text',
affects:['repeating_action_$X_bonus']
},
repeating_action_$X_attack_ability:{
name:'repeating_action_$X_attack_ability',
defaultValue:'0',
type:'text',
affects:['repeating_action_$X_bonus']
},
repeating_action_$X_attack_bonus:{
name:'repeating_action_$X_attack_bonus',
defaultValue:'',
type:'text',
affects:['repeating_action_$X_bonus']
}
},
npc:{
/*character_name:{
name:'character_name',
defaultValue:'',
affects:[]
},*/
size:{
name:'size',
defaultValue:'',
affects:[]
},
genome:{
name:'genome',
defaultValue:'',
affects:[]
},
modification:{
name:'modification',
defaultValue:'',
affects:[]
},
ac:{
name:'ac' ,
defaultValue:'',
affects:[]
},
damage_reduction:{
name:'damage_reduction',
defaultValue:'',
affects:[]
},
hp:{
name:'hp',
defaultValue:'',
affects:[]
},
hp_max:{
name:'hp_max',
defaultValue:'',
affects:[]
},
hit_dice:{
name:'hit_dice',
defaultValue:'',
affects:[]
},
speed:{
name:'speed',
defaultValue:'',
affects:[]
},
strength:{
name:'strength',
type:'text',
defaultValue:10,
affects:['strength_mod']
},
strength_save_base:{
name:'strength_save_base',
type:'number',
defaultValue:'',
affects:['strength_save']
},
dexterity:{
name:'dexterity',
type:'text',
defaultValue:10,
affects:['dexterity_mod']
},
dexterity_save_base:{
name:'dexterity_save_base',
type:'number',
defaultValue:'',
affects:['dexterity_save']
},
constitution:{
name:'constitution',
type:'text',
defaultValue:10,
affects:['constitution_mod']
},
constitution_save_base:{
name:'constitution_save_base',
type:'number',
defaultValue:'',
affects:['constitution_save']
},
intelligence:{
name:'intelligence',
type:'text',
defaultValue:10,
affects:['intelligence_mod']
},
intelligence_save_base:{
name:'intelligence_save_base',
type:'number',
defaultValue:'',
affects:['intelligence_save']
},
wisdom:{
name:'wisdom',
type:'text',
defaultValue:10,
affects:['wisdom_mod']
},
wisdom_save_base:{
name:'wisdom_save_base',
type:'number',
defaultValue:'',
affects:['wisdom_save']
},
charisma:{
name:'charisma',
type:'text',
defaultValue:10,
affects:['charisma_mod']
},
charisma_save_base:{
name:'charisma_save_base',
type:'number',
defaultValue:'',
affects:['charisma_save']
},
strength_mod:{
name:'strength_mod',
defaultValue:0,
type:'number',
calculation:'floor((@{strength}-10)/2)',
affects:['strength_save']
},
dexterity_mod:{
name:'dexterity_mod',
defaultValue:0,
type:'number',
calculation:'floor((@{dexterity}-10)/2)',
affects:['dexterity_save']
},
constitution_mod:{
name:'constitution_mod',
defaultValue:0,
type:'number',
calculation:'floor((@{constitution}-10)/2)',
affects:['constitution_save']
},
intelligence_mod:{
name:'intelligence_mod',
defaultValue:0,
type:'number',
calculation:'floor((@{intelligence}-10)/2)',
affects:['intelligence_save']
},
wisdom_mod:{
name:'wisdom_mod',
defaultValue:0,
type:'number',
calculation:'floor((@{wisdom}-10)/2)',
affects:['wisdom_save']
},
charisma_mod:{
name:'charisma_mod',
defaultValue:0,
type:'number',
calculation:'floor((@{charisma}-10)/2)',
affects:['charisma_save']
},
strength_save:{
name:'strength_save',
defaultValue:0,
type:'number',
calculation:'custom',
affects:[]
},
dexterity_save:{
name:'dexterity_save',
defaultValue:0,
type:'number',
calculation:'custom',
affects:[]
},
constitution_save:{
name:'constitution_save',
defaultValue:0,
type:'number',
calculation:'custom',
affects:[]
},
intelligence_save:{
name:'intelligence_save',
defaultValue:0,
type:'number',
calculation:'custom',
affects:[]
},
wisdom_save:{
name:'wisdom_save',
defaultValue:0,
type:'number',
calculation:'custom',
affects:[]
},
charisma_save:{
name:'charisma_save',
defaultValue:0,
type:'number',
calculation:'custom',
affects:[]
},
condition_immunities:{
name:'condition_immunities',
defaultValue:'',
affects:[]
},
damage_immunities:{
name:'damage_immunities',
defaultValue:'',
affects:[]
},
damage_resistances:{
name:'damage_resistances',
defaultValue:'',
affects:[]
},
damage_vulnerability:{
name:'damage_vulnerability',
defaultValue:'',
affects:[]
},
athletics:{
name:'athletics',
defaultValue:'',
affects:[]
},
acrobatics:{
name:'acrobatics',
defaultValue:'',
affects:[]
},
drive:{
name:'drive',
defaultValue:'',
affects:[]
},
sleight_of_hand:{
name:'sleight_of_hand',
defaultValue:'',
affects:[]
},
stealth:{
name:'stealth',
defaultValue:'',
affects:[]
},
bureaucracy:{
name:'bureaucracy',
defaultValue:'',
affects:[]
},
computers:{
name:'computers',
defaultValue:'',
affects:[]
},
investigation:{
name:'investigation',
defaultValue:'',
affects:[]
},
life_science:{
name:'life_science',
defaultValue:'',
affects:[]
},
mechanics:{
name:'mechanics',
defaultValue:'',
affects:[]
},
physical_science:{
name:'physical_science',
defaultValue:'',
affects:[]
},
social_science:{
name:'social_science',
defaultValue:'',
affects:[]
},
streetwise:{
name:'streetwise',
defaultValue:'',
affects:[]
},
insight:{
name:'insight',
defaultValue:'',
affects:[]
},
perception:{
name:'perception',
defaultValue:'',
affects:[]
},
survival:{
name:'survival',
defaultValue:'',
affects:[]
},
deception:{
name:'deception',
defaultValue:'',
affects:[]
},
intimidation:{
name:'intimidation',
defaultValue:'',
affects:[]
},
performance:{
name:'performance',
defaultValue:'',
affects:[]
},
persuasion:{
name:'persuasion',
defaultValue:'',
affects:[]
},
skill_notes:{
name:'skill_notes',
defaultValue:'',
affects:[]
},
senses:{
name:'senses',
defaultValue:'',
affects:[]
},
passive_perception:{
name:'passive_perception',
defaultValue:'',
affects:[]
},
languages:{
name:'languages',
defaultValue:'',
affects:[]
},
challenge:{
name:'challenge',
defaultValue:'',
affects:[]
},
experience_points:{
name:'experience_points',
defaultValue:'',
affects:[]
},
hacker_level:{
name:'hacker_level',
defaultValue:'',
affects:[]
},
hacking_ability:{
name:'hacking_ability',
defaultValue:'',
affects:[]
},
hack_dc:{
name:'hack_dc',
defaultValue:'',
affects:[]
},
hack_attack:{
name:'hack_attack',
defaultValue:'',
affects:[]
},
'1st_level_slots':{
name:'1st_level_slots',
defaultValue:'',
affects:[]
},
'1st_level_slots':{
name:'1st_level_slots',
defaultValue:'',
affects:[]
},
'2nd_level_slots':{
name:'2nd_level_slots',
defaultValue:'',
affects:[]
},
'3rd_level_slots':{
name:'3rd_level_slots',
defaultValue:'',
affects:[]
},
'4th_level_slots':{
name:'4th_level_slots',
defaultValue:'',
affects:[]
},
'5th_level_slots':{
name:'5th_level_slots',
defaultValue:'',
affects:[]
},
}
},
dropDowns = ['repeating_action_$X_attack_ability'],
hitDice = ['d8_hd','d10_hd','d12_hd'],
toMonitor = ['strength','dexterity','constitution','intelligence','wisdom','charisma','base_strength','base_dexterity','base_constitution','base_intelligence','base_wisdom','base_charisma','strength_save_proficiency','dexterity_save_proficiency','constitution_save_proficiency','intelligence_save_proficiency','wisdom_save_proficiency','charisma_save_proficiency','class_level','level','athletics_proficiency','acrobatics_proficiency','drive_proficiency','sleight_of_hand_proficiency','stealth_proficiency','bureaucracy_proficiency','computers_proficiency','investigation_proficiency','life_science_proficiency','mechanics_proficiency','physical_science_proficiency','social_science_proficiency','streetwise_proficiency','insight_proficiency','perception_proficiency','survival_proficiency','deception_proficiency','intimidation_proficiency','performance_proficiency','persuasion_proficiency','athletics_proficiency','acrobatics_proficiency','drive_proficiency','sleight_of_hand_proficiency','stealth_proficiency','bureaucracy_proficiency','computers_proficiency','investigation_proficiency','life_science_proficiency','mechanics_proficiency','physical_science_proficiency','social_science_proficiency','streetwise_proficiency','insight_proficiency','perception_proficiency','survival_proficiency','deception_proficiency','intimidation_proficiency','performance_proficiency','persuasion_proficiency','strength_save_base','dexterity_save_base','constitution_save_base','intelligence_save_base','wisdom_save_base','charisma_save_base'],
repeatingSections = ['repeating_action','repeating_hack','repeating_trait','repeating_equipment'],
baseGet = [...toMonitor,'proficiency','character_type','strength_mod','dexterity_mod','constitution_mod','intelligence_mod','wisdom_mod','charisma_mod','strength_save','dexterity_save','constitution_save','intelligence_save','wisdom_save','charisma_save','athletics','acrobatics','drive','sleight_of_hand','stealth','bureaucracy','computers','investigation','life_science','mechanics','physical_science','social_science','streetwise','insight','perception','survival','deception','intimidation','performance','persuasion'],
challengeToXP = {
'0':10,'1/8':25,'1/4':50,'1/2':100,'1':200,'2':450,'3':700,'4':1100,'5':1800,'6':2300,'7':2900,'8':3900,'9':5000,
'10':5900,'11':7200,'12':8400,'13':10000,'14':11500,'15':13000,'16':15000,'17':18000,'18':20000,'19':22000,'20':25000,
'21':33000,'22':41000,'23':50000,'24':62000,'25':75000,'26':90000,'27':105000,'28':120000,'29':135000,'30':155000
};
var registerEventHandlers = function(){
on('sheet:opened',openSheet);
['repeating_action:attack_enable_item','repeating_hack:attack_enable_item','repeating_action:damage_1_enable_item','repeating_hack:damage_1_enable_item','repeating_action:damage_2_enable_item','repeating_hack:damage_2_enable_item'].forEach((name)=>{
on(`change:${name}`,updateActionMacro);
});
displayControllers.forEach((attr)=>{
on(`change:${attr}`,importReact);
});
importControls.forEach((attr)=>{
on(`change:${attr}`,importReact);
});
hackLevels.forEach((attr)=>{
on(`clicked:add_${attr}_hack`,createHack);
});
on('change:character_type',changeCharacter);
on('change:challenge',convertChallenge);
on('change:hit_dice',averageHP);
hitDice.forEach((attr)=>{
on(`change:${attr}`,updateHDmacro);
});
[...toMonitor,...repeatingSections].forEach((attr)=>{
on(`change:${attr}${/repeating/.test(attr) ? ` remove:${attr}` :''}`,(event)=>{
let triggers = [event.sourceAttribute];
if(/_mods$/.test(event.sourceAttribute)){
triggers = extractModTrigger(`${event.newValue},${event.previousValue}`,triggers);
}else if(event.removedInfo && _.contains(_.keys(event.removedInfo),`${triggers[0]}_mods`)){
triggers = extractModTrigger(event.removedInfo[`${event.sourceAttribute}_mods`],[]);
}else if(event.removedInfo){
return;
}
getSections(accessSheet,baseGet,triggers);
});
});
},
extractModTrigger = function(string,triggers){
string.replace(/([+\-=].+?)\s+([^\s,]+)(?:,|$)/ig,(match,value,target)=>{
target = target.toLowerCase();
if(/=/.test(value) && target ==='ac'){
target = 'ac_formula';
}
if(!_.contains(triggers,target)){
triggers.push(target);
}
});
return triggers;
},
accessSheet = function(getArray,sections,triggers){
const setObj = {};
getAttrs(getArray,(attributes)=>{
const buffs = parseBuffs(attributes,sections,triggers);
if(attributes.character_type === 'pc' && !buffs.ac_formula){
buffs.ac_formula = [{value:cascades.pc.ac_formula.defaultValue,label:'AC'}];
}
triggers = parseTrigger(triggers,attributes.character_type,attributes,buffs,sections);
triggers = sortTrigger(triggers);
reactToTrigger(triggers,attributes,setObj,buffs);
});
},
parseBuffs = function(attributes,sections,triggers){ //parses all of the buffs contained in the repeating_trait, and repeating_equipment items
// creates an object indexed by attribute to be buffed containing objects that have all of the buffs for that attribute
// indexed by buff type
const modRegex = /([+\-=].+?)\s+([^\s,]+)(?:,|$)/ig;//mod expression +X target,+X target,...
//mod expression can use attribute calls, queries, roll expressions, etc.
return _.chain(_.keys(attributes))
.filter((attr_name)=>{
return /_mods$/.test(attr_name);
})
.reject((attr_name)=>{
return attributes[attr_name] === '' || !attributes[attr_name];
})
.reduce((memo,attr_name)=>{
attributes[attr_name].toLowerCase().replace(modRegex,(match,value,target)=>{
if(/=/.test(value) && target === 'ac'){
target = 'ac_formula';
triggers.push('ac_formula');
}
if(/repeating_[^_]+_\$/i.test(target)){
target.replace(/(repeating_[^_]+_)[^_]+(.+)/,(match,section,field)=>{
_.each(sections[section],(id)=>{
memo[`${section}${id}${field}`] = memo[`${section}${id}${field}`] || [];
let targObj = {
value:value,
label:attributes[attr_name.replace('mods','name')]
};
memo[`${section}${id}${field}`].push(targObj);
});
});
}else{
memo[target] = memo[target] || [];
let targObj = {
value:value,
label:attributes[attr_name.replace('mods','name')]
};
memo[target].push(targObj);
}
});
return memo;
},{})
.tap(log)
.value();
},
expandRepeating = function(cascade,sections){
let tempCasc = trueCopy(cascade);
tempCasc = _.keys(tempCasc).reduce((memo,key)=>{
if(/^repeating/.test(key)){
key.replace(/(repeating_[^_]+)_[^_]+_(.+)/,(match,section,field)=>{
_.each(sections[section].id,(id)=>{
memo[`${section}_${id}_${field}`]=trueCopy(tempCasc[key]);
memo[`${section}_${id}_${field}`].affects = memo[`${section}_${id}_${field}`].affects.map((affected)=>{
return affected.replace(/(repeating_[^_]+_)[^_]+(.+)/,`$1${id}$2`);
});
});
});
}else{
memo[key] = trueCopy(tempCasc[key]);
}
return memo;
},{});
return tempCasc;
},
updateActionMacro = function(event){
if(event.sourceAttribute === 'attack_enable_item'){
return;
}
getAttrs(['character_type'],(attributes)=>{
const setObj = {};
adjustActionMacro(event,attributes,setObj);
set(setObj);
});
},
adjustActionMacro = function(event,attributes,setObj = {}){
let macroAttr = event.sourceAttribute.replace(/enable_item/,'macro');
if(event.newValue*1){
setObj[macroAttr] = `{{d20=[[@{advantage_state} ${attributes.character_type === 'pc' ? '+ @{attack_ability} + @{action_proficiency}' : ''} + 0@{attack_bonus}]]}}`;
}else if(/{{damage_type_\d=@{damage_type_\d}}} @{damage_\d_macro}/.test(event.newValue)){
event.sourceAttribute.replace(/_(\d)_/,(match,num)=>{
setObj[macroAttr] = `{{damage_${num}=[[0@{damage_${num}}${attributes.character_type === 'pc' ? `+ @{damage_ability_${num}}` : ''}]]}} {{regular_critical_${num}=[[0@{damage_${num}}]]}} {{is_custom_crit_${num}=@{critical_damage_${num}}}} {{custom_critical_${num}=[[0@{critical_damage_${num}}]]}}`;
});
}else{
setObj[macroAttr] = ' ';
}
set(setObj);
},
trueCopy = function(obj){
return JSON.parse(JSON.stringify(obj));
},
applyBuffsToCascades = function(cascade,buffs,sections){
let tempCasc = expandRepeating(cascade,sections);
_.keys(buffs).forEach((key)=>{
buffs[key].forEach((buff)=>{
buff.value.replace(/@{(.+?)}/g,(match,attr)=>{
if(/repeating_[^_]+_\$[X\d]+/i.test(attr)){
attr.replace(/(repeating_[^_]+)_[^_]+_(.+)/,(match,section,field)=>{
sections[section].id.forEach((id)=>{
if(!_.contains(tempCasc[`${section}_${id}_${field}`].affects)){
tempCasc[`${section}_${id}_${field}`].affects.push(key);
}
});
});
}else{
if(!_.contains(tempCasc[attr].affects)){
tempCasc[attr].affects.push(key);
}
}
});
});
});
return tempCasc;
},
parseTrigger = function(triggers,character_type,attributes,buffs,sections){
let cascadeCopy = character_type==='pc' ? applyBuffsToCascades(cascades[character_type],buffs,sections) : expandRepeating(cascades[character_type],sections),
trigQueue,
trigWorker = (queue,arr) =>{
arr = arr || [];
let item = queue.shift(),
rowID,
itemLookup = item.replace(/(repeating_[^_]+_)([^_]+)/,(match,section,id)=>{
rowID = /\$/.test(id) ? undefined : id;
return `${section}$X`;
});
if(cascadeCopy[itemLookup]){
let parsedItem = {};
_.keys(cascadeCopy[itemLookup]).forEach((key)=>{
if(key === 'affects'){
parsedItem[key] = [];
let affectArray = cascadeCopy[itemLookup][key];
_.keys(buffs).forEach((key)=>{
if(new RegExp(`@{${itemLookup}}`).test(buffs[key].value)){
affectArray.push(key);
}
});
affectArray = _.unique(affectArray);
_.each(affectArray,(affected)=>{
if(/^repeating_/.test(affected)){
affected.replace(/(repeating_[^_]+_)[^_]+(.+)/,(match,section,field)=>{
if(rowID){
parsedItem[key].push(`${section}${rowID}${field}`);
if(_.every(arr,(item)=>{
return item.name !== `${section}${rowID}${field}`;
}) && !_.contains(queue,`${section}${rowID}${field}`)){
queue.push(`${section}${rowID}${field}`);
}
}else{
_.each(sections[section],(id)=>{
parsedItem[key].push(`${section}${id}${field}`);
if(_.every(arr,(item)=>{
return item.name !== `${section}${id}${field}`;
}) && !_.contains(queue,`${section}${id}${field}`)){
queue.push(`${section}${id}${field}`);
}
});
}
});
}else if(/^variable$/.test(affected)){
dropDowns.forEach((dropDown)=>{
dropDown.replace(/(?:(repeating_[^_]+)_[^_]+_)?(.+)/,(match,section,field)=>{
sections[section].forEach((id)=>{
if(attributes[`${section}_${id}_${field}`]===`@{${key}}`){
parsedItem[key].push(`${section}_${id}_${field}`);
queue.push(`${section}_${id}_${field}`);
}
});
});
});
}else{
parsedItem[key].push(affected);
if(_.every(arr,(item)=>{
return item.name !== affected;
}) && !_.contains(queue,affected)){
queue.push(affected);
}
}
});
}else{
parsedItem[key] = `${cascadeCopy[itemLookup][key]}`.replace(/(repeating_[^_]+_)[^_]+/,`$1${rowID||''}`);
}
});
if((cascadeCopy[itemLookup].calculation || itemLookup === 'ac_formula') && _.every(arr,(item)=>{
return item.name !== parsedItem.name;
})){
arr.push(parsedItem);
}
}
if(_.isEmpty(queue)){
return arr;
}else{
return trigWorker(queue,arr);
}
};
return trigWorker(triggers);
},
sortTrigger = function(triggers){
_.each(triggers,(trigger)=>{
trigger.order = triggers.reduce((memo,trig,index)=>{
if(_.contains(trig.affects,trigger.name)){
memo = trig.order + 1 || index;
}
return memo;
},0);
});
return _.sortBy(triggers,(obj)=>{return obj.order});
},
reactToTrigger = function(triggers,attributes,setObj,buffs){
_.each(triggers,(obj)=>{
let calc;
if(obj.calculation === 'custom'){
calc = customCalcs[obj.name](attributes,triggers,setObj,buffs,obj);
}else{
calc = sheetCalc(obj.name,obj.calculation,attributes,setObj,buffs);
}
if(!calc && calc !== 0){
calc = obj.defaultValue;
}
attributes[obj.name] = calc;
setObj[obj.name] = calc;
});
set(setObj);
},
calcLevel = function(attributes){
let level = 0;
attributes.class_level.replace(/\d+/g,(classLevel)=>{
level += classLevel*1;
});
return level;
},
calcAC = function(attributes,triggers,setObj,buffs){
return buffs.ac_formula.reduce((memo,buffObj)=>{
let calc = sheetCalc('ac_formula',buffObj.value,attributes,setObj,buffs);
if(calc >= memo.value){
memo = {value:calc,formula:buffObj.value};
}
return memo;
},{value:0}).formula || triggers.ac_formula.defaultValue;
},
npcSaveCalc = function(attributes,triggers,setObj,buffs,trigger){
let attr = trigger.name.replace(/_save.*/,'');
return (attributes[`${attr}_save_base`]*1||attributes[`${attr}_save_base`]!=='') ? attributes[`${attr}_save_base`] : attributes[`${attr}_mod`];
},
customCalcs = {
level:calcLevel,
ac_formula:calcAC,
strength_save:npcSaveCalc,
dexterity_save:npcSaveCalc,
constitution_save:npcSaveCalc,
intelligence_save:npcSaveCalc,
wisdom_save:npcSaveCalc,
charisma_save:npcSaveCalc
},
sheetCalc = function(name,calculation,attributes,setObj,buffs){
let parsedCalc = calculation;
while(/@{([^}]+)}/.test(parsedCalc)){
parsedCalc.replace(/@{(([^}]+)_modded)}/,(match,store,target)=>{
attributes[store] = (buffs[target]||[]).map((buffObj)=>{
return `+ [[${buffObj.value}]][${buffObj.label}]`;
}).join(' ');
setObj[store]=attributes[store];
});
parsedCalc = attributeParse(parsedCalc,attributes);
}
parsedCalc = parsedCalc.replace(/floor|ceil|round|abs/g,'Math.$&').replace(/\[\[|\]\]|\[.*?\]|=/g,'');
let finalCalc;
try{
finalCalc = eval(parsedCalc);
}catch(err){
finalCalc = undefined;
}
return finalCalc;
},
attributeParse = function(string,attributes){
return string.replace(/@{([^}]+)}/g,(match,name)=>{
return attributes[name.toLowerCase()];
});
},
updateHDmacro = function(event){
const setObj = {};
getAttrs(hitDice,(attributes)=>{
let hdAccumulator = [];
hitDice.forEach((hd)=>{
if(attributes[hd] && (attributes[hd]*1!==0 && attributes[hd]!=='')){
hdAccumulator.push(hd.replace(/_hd/,''));
}
});
hdAccumulator = hdAccumulator.join('|');
if(/\|/.test(hdAccumulator)){
hdAccumulator = `?{Die Size|${hdAccumulator}}`;
}
setObj.hit_dice_macro = `{{d20=[[?{Number of dice|1}${hdAccumulator} + [[?{Number of dice}*@{constitution_mod}]]]]}}`;
set(setObj);
});
},
convertChallenge = function(event){
set({experience_points:challengeToXP[event.newValue]||10});
},
averageHP = function(event){
const setObj = {};
let numDie,die,bonus;
event.newValue.replace(/(\d+)\s*d\s*(\d+)(?:\s*([+\-]\s*\d+))?/,(match,n,d,b)=>{
numDie = n*1||1;
die = d*1||6;
bonus = (b+'').replace(/\s*\+\s*/,'')*1||0;
});
setObj.hp = bonus + Math.floor(numDie*(die/2+0.5));
setObj.hp_max = setObj.hp;
set(setObj);
},
changeDisplay = function(){
getAttrs([...displayControllers,...importControls],(attributes)=>{
const setObj = processDisplayChange(attributes);
set(setObj);
});
},
processDisplayChange = function(attributes){
const setObj = {};
setObj.master_display_controller = displayControllers.map((attr)=>{
return `${attr}:${attributes[attr]}`
}).join(' | ');
setObj.master_display_controller = `${setObj.master_display_controller} | import:${attributes.import}`;
return setObj;
},
importReact = function(event){
const attrToGet = [...displayControllers,...importControls],
setObj = {};
let processImport = false;
if(event.newValue === '0' && event.sourceAttribute === 'import'){
attrToGet.push('importer');
processImport = true;
}else if(event.sourceAttribute === 'import_cancel'){
setObj.import = '0';
setObj.import_cancel = '0';
}
if(!processImport){
displayImportChange(attrToGet,setObj);
}else{
getSections(beginImport,[...baseGet,...attrToGet]);
}
},
displayImportChange = function(toGet,setObj){
getAttrs(toGet,(attributes)=>{
_.extend(attributes,setObj);
_.extend(setObj,processDisplayChange(attributes));
set(setObj);
});
},
beginImport = function(toGet,sections){
let setObj = {};
wipeSheet(sections,setObj);
getAttrs(toGet,(attributes)=>{
if(attributes.importer.trim() === ''){
setObj.import = 'import';
}else{
setObj = {...setObj,...parseStatblock(attributes.importer)};
setObj.sheet_view = 'in-play';
attributes = {...attributes,...setObj};
setObj = {...setObj,...processDisplayChange(attributes)};
}
set(setObj);
});
},
wipeSheet = function(sections){
const setObj = {};
Object.keys(cascades.npc).forEach((k)=>setObj[k]=cascades.npc[k].defaultValue);
setObj.import = 'import-process';
_.each(sections,(idArray,section)=>{
resetRepeatingSection(section,idArray);
});
},
resetRepeatingSection = function(section,idArray){
idArray.forEach((id)=>{
removeRepeatingRow(`${section}_${id}`);
});
},
parseStatblock = function(statblock){
if(statblock.trim() === ''){
return {};
}
let parser = headerParser,
section = 'header',
lines = statblock.replace(/\s+\n/g,'\n').replace(/[\-–—―−]/g,'-').split(/\n+/),
setObj = {};
const Parsers = {//regex as strings for matching against each line to determine if we continue with the current recursive parse, or move onto a new section
'^\\s*str\\s+dex\\s+con\\s+int\\s+wis\\s+cha':abilityScoreParser,
'^\\s*(?:saves|skills|senses|languages|challenge|damage resistance)\\s+':detailParser,
'^\\s*hacking\\.\\s+':hackParser,
'^\\s*traits$':traitParser,
'^\\s*actions\\s*$':actionParser
},
setParser = (lines) => {//Tests the line and changes the parser if necessary
return !!Object.keys(Parsers).find( (regexp) => {
if(new RegExp(regexp,"i").test(lines[0])){
section = regexp;
parser = Parsers[regexp];
if(/actions|^\s*str\s+dex\s+con\s+int\s+wis\s+cha/i.test(lines[0])){//if the section is one of these, then jump to the next line (shift it out of the array)
lines.shift();
}
return true;
}
return false;
});
};
setObj.character_name = lines.shift();
while(lines.length){//while there are lines
setParser(lines);//check the line and see if the parser needs to be changed
[setObj,lines] = parser(setObj,lines);//call the parser in question, and modify setObj and lines to be what the parser returns
};
return setObj;
},
processRegex = function(setObj,currLine,regexs){
_.keys(regexs).find((r)=>{
if(new RegExp(r,'i').test(currLine)){
let objMatch = currLine.match(new RegExp(r,'i'));
_.each(_.range(regexs[r].length),(l)=>{
_.each(regexs[r][l],(o)=>{
setObj[o]=objMatch[l + 1]||'';
});
});
return true;
}
return false;
});
},
headerParser = function(setObj,lines){
const regexs = {//regexs as strings for matching against lines. the properties are arrays of what attributes (in a sub array) receive the value from each matching group
'^\\s*(medium|tiny|large|huge)\\s+(.+?)(?:\\s+\\(\\s*(.+?)\\s*\\)|$)':[['size'],['genome'],['modification']],//size and type,
'^\\s*armor\\s+class\\s+(\\d+)':[['ac']],
'^\\s*damage\\s+reduction\\s+(\\d+)':[['damage_reduction']],
'^\\s*hit\\s+points\\s+(\\d+)\\s*\\((.+?)\\)':[['hp','hp_max'],['hit_dice']],
'^\\s*speed\\s+(.+)':[['speed']]
};
processRegex(setObj,lines.shift(),regexs);
return [setObj,lines];
},
abilityScoreParser = function(setObj,lines){
const regexs = {//regexs as strings for matching against lines. the properties are arrays of what attributes (in a sub array) receive the value from each matching group
'^\\s*(\\d+)\\s*\\(\\+?(\\-?\\d+)\\)\\s*(\\d+)\\s*\\(\\+?(\\-?\\d+)\\)\\s*(\\d+)\\s*\\(\\+?(\\-?\\d+)\\)\\s*(\\d+)\\s*\\(\\+?(\\-?\\d+)\\)\\s*(\\d+)\\s*\\(\\+?(\\-?\\d+)\\)\\s*(\\d+)\\s*\\(\\+?(\\-?\\d+)\\)':[['strength'],['strength_mod'],['dexterity'],['dexterity_mod'],['constitution'],['constitution_mod'],['intelligence'],['intelligence_mod'],['wisdom'],['wisdom_mod'],['charisma'],['charisma_mod']]
};
processRegex(setObj,lines.shift(),regexs);
return [setObj,lines];
},
detailParser = function(setObj,lines){
const regexs = {//regexs as strings for matching against lines. the properties are arrays of what attributes (in a sub array) receive the value from each matching group
'^\\s*senses\\s+passive perception (\\d+)(?:,\\s*(.+?))?$':[['passive_perception'],['senses']],
'^\\s*damage\\s+resistance\s+(.+)':[['damage_resistance']],
'^\\s*languages\\s+(.+)':[['languages']],
'^\\s*challenge\\s+([\\d\\/]+)\\s*\\(([\\d,]+)\\s*xp\\)':[['challenge'],['experience_points']]
};
let line = assembleDetailLine(lines);
if(/^\s*skills\s+/i.test(line)){
parseSkills(setObj,line);
}else if(/^\s*senses\s+/i.test(line)){
parseSenses(setObj,line);
}else{
processRegex(setObj,line,regexs);
}
if(/^\s*challenge/i.test(line) && !/^\s*(hacking\.|actions)/i.test(lines[0])){
lines.unshift('trait');
}
return [setObj,lines];
},
assembleDetailLine = function(lines,line){
line = line ? `${line} ${lines.shift()}` : lines.shift();
return /^\s*(?:saves|skills|senses|languages|challenge|damage resistance|hacking|actions)/i.test(lines[0]) ? line : assembleDetailLine(lines,line);
},
parseSkills = function(setObj,line){
line.replace(/(?:,\s*|skills\s+)(.+?)\s+\+?(\-?\d+)/ig,(match,skill,bonus)=>{
setObj[skill.replace(/\s+/,'_').toLowerCase()]=bonus;
});
},
parseSenses = function(setObj,line){
line.replace(/senses\s*(?:(.+?),\s*)?passive \s*perception\s*(\d+)(?:,\s*(.+?))?$/i,(match,senses,pp='',senses2)=>{
setObj.passive_perception = pp;
setObj.senses = [senses,senses2].filter(a=>a).join(', ');
});
},
hackParser = function(setObj,lines){
let line = assembleHackerDetails(lines);
line.replace(/.+?(\d+)(?:st|th|rd).+?ability is (strength|dexterity|constitution|intelligence|wisdom|charisma).+?DC\s*(\d+).+?(\-?\d+) to hit/,(match,level,ability,dc,attack)=>{
setObj.hacker_level = level;
setObj.hacking_ability = ability;
setObj.hack_dc = dc;
setObj.hack_attack = attack;
});
processHacks(setObj,lines);
if(/.+\./.test(lines[0])){
lines.unshift('traits')
}
return [setObj,lines];
},
assembleHackerDetails = function(lines){
let line = lines.shift();
while(!/:/.test(line) && lines.length){
line = `${line} ${lines.shift()}`;
}
return line.toLowerCase();
},
processHacks = function(setObj,lines){
while(lines.length && !/.+\.|actions/i.test(lines[0])){
let line = assembleHackLevel(lines);
line.replace(/(\d+)(st|rd|th)\s+level\s*\((\d+)\s+slots\):(.+)/,(match,level,ordinal,slots,hacks)=>{
setObj[`${level}${ordinal}_level_slots`] = slots;
hacks = hacks.trim().split(/\s*,\s*/);
hacks.forEach((hack)=>{
importHack(setObj,hack,level);
});
});
}
},
assembleHackLevel = function(lines){
let line = lines.shift();
while(lines.length && !/.+(?:\.|:)|actions/i.test(lines[0])){
line = `${line} ${lines.shift()}`;
}
return line;
},
importHack = function(setObj,hack,level){
const rowID = generateRowID();
setObj[`repeating_hack_${rowID}_level`] = level;
setObj[`repeating_hack_${rowID}_hack_type`] = 'injection';
setObj[`repeating_hack_${rowID}_id`] = rowID;
setObj[`repeating_hack_${rowID}_name`] = hack;
},
traitParser = function(setObj,lines){
if(/^\s*traits$/.test(lines[0])){
lines.shift();
}
let regex = /(?:.+\.|actions)\s*$/i;
do{
let line = assembleTraitDetails(lines);
importTrait(setObj,line);
}while(lines.length && !regex.test(lines[0]))
return [setObj,lines];
},
importTrait = function(setObj,line){
const rowID = generateRowID();
line.replace(/^(.+?)\.\s*(.+)/,(match,name,description)=>{
setObj[`repeating_trait_${rowID}_description`] = description;
setObj[`repeating_trait_${rowID}_id`] = rowID;
setObj[`repeating_trait_${rowID}_name`] = name;
setObj[`repeating_trait_${rowID}_expand_item`] = 0;
});
},
//collects lines to create the entire paragraph of a trait. If action is truthy, then it will parse for an action's details
assembleTraitDetails = function(lines,action){
let line = lines.shift();
while(lines.length && !/\.\s*$/.test(line)){
line = `${line} ${lines.shift()}`;
}
return line;
},
actionParser = function(setObj,lines){
do{
let line = assembleTraitDetails(lines,true);
importAction(setObj,line);
}while(lines.length && /^(?:.+\.).+/.test(lines[0]))
return [setObj,lines];
},
importAction = function(setObj,line){
const rowID = generateRowID();
line.replace(/^(.+?)\.\s+((?:ranged|melee)\s+weapon\s+attack:.+?(\-?\d+).+?(?:range|reach)\s+(.+?),\s*(.+?)\..+?\((.+?)\)\s*(.*?)\.\s*(.+)?|.+)/i,(match,name,details,attack,range,target,damageRoll,damageType,description)=>{
setObj[`repeating_action_${rowID}_id`] = rowID;
setObj[`repeating_action_${rowID}_name`] = name;
if(attack){
setObj[`repeating_action_${rowID}_attack_bonus`] = attack;
setObj[`repeating_action_${rowID}_bonus`] = attack;
setObj[`repeating_action_${rowID}_attack_enable_item`] = 1;
setObj[`repeating_action_${rowID}_attack_macro`] = '{{d20=[[@{advantage_state} + 0@{attack_bonus}]]}}';
}
if(damageRoll){
setObj[`repeating_action_${rowID}_damage_1`] = damageRoll;
setObj[`repeating_action_${rowID}_damage_type_1`] = damageType||'';
setObj[`repeating_action_${rowID}_damage_1_enable_item`] = '{{damage_type_1=@{damage_type_1}}} @{damage_1_macro}';
setObj[`repeating_action_${rowID}_damage_1_macro`] = `{{damage_${num}=[[0@{damage_${num}}]]}} {{regular_critical_${num}=[[0@{damage_${num}}]]}} {{is_custom_crit_${num}=@{critical_damage_${num}}}} {{custom_critical_${num}=[[0@{critical_damage_${num}}]]}}`;
}
if(description){
setObj[`repeating_action_${rowID}_description`] = description||'';
}else if(!attack&&!range&&!target&&!damageRoll&&!damageType){
setObj[`repeating_action_${rowID}_description`] = details;
}
setObj[`repeating_action_${rowID}_range`] = range||'';
setObj[`repeating_action_${rowID}_expand_item`] = 0;
});
},
createHack = function(event){
const setObj = {},
rowID = generateRowID(),
[hackLevel] = event.triggerName.match(/\d+/);
setObj[`repeating_hack_${rowID}_level`] = hackLevel;
setObj[`repeating_hack_${rowID}_hack_type`] = 'injection';
setObj[`repeating_hack_${rowID}_id`] = rowID;
set(setObj);
},
changeCharacter = function(event){
const switcher = {
npc:NPC,
pc:PC
};
getSections(switcher[event.newValue]);
},
PC = function(getArray,sections){
const setObj = {
whisper_state:''
};
_.keys(skillList).forEach((skill)=>{
setObj[`${skill}_macro`]=`{{d20=[[@{advantage_state} + @{${skill}_proficiency}[Proficiency] + @{${skillList[skill]}_mod}[${skillList[skill].toUpperCase()}] @{${skill}_bonus}]]}}`
});
_.keys(abilityScores).forEach((abbreviation)=>{
setObj[`${abilityScores[abbreviation]}_check_macro`]=`{{d20=[[@{advantage_state} + @{${abilityScores[abbreviation]}_mod}[${abbreviation.toUpperCase()}] @{${abilityScores[abbreviation]}_bonus}]]}}`;
setObj[`${abilityScores[abbreviation]}_save_macro`]=`{{d20=[[@{advantage_state} + @{${abilityScores[abbreviation]}_mod}[${abbreviation.toUpperCase()}] + @{${abilityScores[abbreviation]}_save_proficiency}[Proficiency] @{${abilityScores[abbreviation]}_save_bonus}]]}}`;
});
sections.repeating_trait.forEach((id)=>{
setObj[`repeating_trait_${id}_macro`]='{{source=@{source}}}';
});
['repeating_hack','repeating_action'].forEach((section)=>{
sections[section].forEach((id)=>{
setObj[`repeating_hack_${id}_attack_macro`]='{{d20=[[@{advantage_state} + @{attack_ability} + @{action_proficiency} + 0@{attack_bonus}]]}}';
setObj[`repeating_hack_${id}_save_macro`]='{{dc=[[8 + @{save_ability} + @{action_proficiency} + 0@{dc_bonus}]]}}';
[1,2].forEach((num)=>{
setObj[`${section}_${id}_damage_${num}_macro`]=`{{damage_${num}=[[0@{damage_${num}} + @{damage_ability_${num}}]]}} {{regular_critical_${num}=[[0@{damage_${num}}]]}} {{is_custom_crit_${num}=@{critical_damage_${num}}}} {{custom_critical_${num}=[[0@{critical_damage_${num}}]]}}`;
});
});
});
set(setObj,changeDisplay);
},
NPC = function(getArray,sections){
const setObj = {
whisper_state:'/w gm'
};
_.keys(skillList).forEach((skill)=>{
setObj[`${skill}_macro`]=`{{d20=[[@{advantage_state} + @{${skill}} @{${skill}_bonus}]]}}`
});
_.keys(abilityScores).forEach((abbreviation)=>{
setObj[`${abilityScores[abbreviation]}_check_macro`]=`{{d20=[[@{advantage_state} + @{${abilityScores[abbreviation]}_mod}[${abbreviation.toUpperCase()}] @{${abilityScores[abbreviation]}_bonus}]]}}`;
setObj[`${abilityScores[abbreviation]}_save_macro`]=`{{d20=[[@{advantage_state} + @{${abilityScores[abbreviation]}_save}[${abbreviation.toUpperCase()}] @{${abilityScores[abbreviation]}_save_bonus}]]}}`;
});
sections.repeating_trait.forEach((id)=>{
setObj[`repeating_trait_${id}_macro`]='';
});
['repeating_hack','repeating_action'].forEach((section)=>{
sections[section].forEach((id)=>{
setObj[`${section}_${id}_attack_macro`]='{{d20=[[@{advantage_state} + 0@{attack_bonus}]]}}';
setObj[`${section}_${id}_save_macro`]='{{dc=[[0@{dc_bonus}]]}}';
[1,2].forEach((num)=>{
setObj[`${section}_${id}_damage_${num}_macro`]=`{{damage_${num}=[[0@{damage_${num}}]]}} {{regular_critical_${num}=[[0@{damage_${num}}]]}} {{is_custom_crit_${num}=@{critical_damage_${num}}}} {{custom_critical_${num}=[[0@{critical_damage_${num}}]]}}`;
});
});
});
set(setObj,changeDisplay);
},
getSections = function(callback,getArray,trigger,sections,queue){
queue = queue || JSON.parse(JSON.stringify(repeating_section_details));
getArray = getArray || [];
sections = sections || {};
let section = queue.shift();
getSectionIDs(section.section,(idArray)=>{
sections[section.section]=[];
idArray.forEach((id)=>{
sections[section.section].push(id);
section.fields.forEach((field)=>{
getArray.push(`${section.section}_${id}_${field}`);
});
});
if(_.isEmpty(queue)){
callback(getArray,sections,trigger);
}else{
getSections(callback,getArray,trigger,sections,queue);
}
});
},
log = function(msg){
const sheetName = 'Genefunk2090';
if(typeof msg === 'string'){
console.log(`%c${sheetName} log| ${msg}`,"background-color:#159ccf");
}else if(typeof msg === 'object'){
Object.keys(msg).forEach((m)=>{
if(typeof msg[m] === 'string'){
console.log(`%c${sheetName} log| ${m}: ${msg[m]}`,"background-color:#159ccf");
}else{
console.log(`%c${sheetName} log| ${typeof msg[m]} ${m}`,"background-color:#159ccf");
console.table(msg[m]);
}
});
}
},
openSheet = function(){
getSections(updateSheet,baseGet);
},
updateSheet = function(getArray,sections){
const setObj = {};
getAttrs([...getArray,'sheet_version'],(attr)=>{
if(!attr.sheet_version){
attr.sheet_version = 0;
}
if(attr.sheet_version*1 < 1.1) updateTo1_1(attr,setObj);//First update applied
if(attr.sheet_version*1 < 1.12) updateTo1_12(attr,setObj);//update 1.12; npc hp attribute change
if(attr.sheet_version*1 < 1.20) updateTo1_20(attr,setObj);
set(setObj);
});
},
updateTo1_20 = function(attr,setObj){
const damageEnablers = Object.keys(attr).filter(k => /(?:attack|damage_\d)_enable_item/.test(k));
damageEnablers.forEach(d => adjustActionMacro({sourceAttribute:d,triggerName:d,newValue:attr[d]},attr,setObj));
if(attr.character_type === 'npc'){
setObj.hit_points = attr.hp
setObj.hit_points_max = attr.hp_max;
}
attr = {...attr,...setObj};
setObj.sheet_version = 1.20;
},
updateTo1_12 = function(attr,setObj){
if(attr.character_type === 'npc'){
setObj.hp = attr.hit_points;
setObj.hp_max = attr.hit_points_max;
}
attr = {...attr,...setObj};
setObj.sheet_version = 1.12;
},
updateTo1_1 = function(attr,setObj){
let enableItems = Object.keys(attr).filter((a)=>/attack_enable_item/.test(a));
enableItems.forEach((check)=>{
let macroName = check.replace(/attack_enable_item/,'attack_macro');
if(/@/.test(attr[check])){
setObj[check] = 1;
setObj[macroName] = `{{d20=[[@{advantage_state} ${attr.character_type === 'pc' ? '+ @{attack_ability} + @{action_proficiency}' : ''} + 0@{attack_bonus}]]}}`;
}else if(!attr[check]*1){
setObj[macroName] = ' ';
setObj[check] = 0;
}
});
setObj.sheet_version = 1.1;
attr = {...attr,...setObj};
},
bootUp = function(){
log(`Sheet Starting up`);
},
set = function(obj,callback){
setAttrs(obj,{silent:true},callback)
};
return {
BootUp: bootUp,
RegisterEventHandlers: registerEventHandlers
};
}());
genefunk2090.BootUp();
genefunk2090.RegisterEventHandlers();
Reference in New Issue View Git Blame Copy Permalink