mirror of
https://github.com/Nighthawk42/roll20-character-sheets.git
synced 2026-08-30 11:42:29 +00:00
uriele
f0119aa6df
- update version to correctly read weapons - convert npc of previous sheet to npc of new one importing named skills - fixed space between words
3531 lines
126 KiB
HTML
3531 lines
126 KiB
HTML
|
||
|
||
// check initialization so it updates only once per game at most
|
||
var _isInitialized = false;
|
||
// === ATTRIBUTE ARRAYS
|
||
|
||
const arrays = {
|
||
_stats: ['strength', 'constitution', 'dexterity', 'intelligence', 'power', 'charisma'],
|
||
_derived_stats: ['hit_points', 'sanity_points', 'willpower_points', 'breaking_point'],
|
||
_derived_stats_max: ['sanity_points_max','hit_points_max', 'willpower_points_max', 'breaking_point_max'],
|
||
_hit_points: ['strength_score', 'constitution_score'],
|
||
_willpower_points: ['power_score'],
|
||
_toggles: ['settings'],
|
||
_sanity_loss: ['sanity_loss_success', 'sanity_loss_failure'],
|
||
_skills:['accounting', 'alertness', 'anthropology', 'archeology', 'art_1', 'art_2', 'artillery', 'athletics', 'bureaucracy', 'computer_science', 'craft_1', 'craft_2', 'criminology', 'demolitions', 'disguise', 'dodge', 'drive', 'firearms','first_aid', 'forensics', 'heavy_machinery', 'heavy_weapons', 'history', 'humint', 'law', 'medicine', 'melee_weapons', 'military_science_1', 'military_science_2', 'navigate', 'occult', 'persuade', 'pharmacy', 'pilot_1','pilot_2', 'psychotherapy','ride', 'science_1','science_2', 'search' , 'sigint' , 'stealth' , 'surgery' , 'survival', 'swim', 'unarmed_combat'],
|
||
_colored_derivative:['willpower','hit'],
|
||
_derived_rolls:['sanity_points','luck'],
|
||
_disorder_related:['sanity_points','breaking_point'],
|
||
_derived_modifiers:['willpower_points','low_willpower','zero_willpower'],
|
||
_settings_wp:[`mod_willpower_check`],
|
||
_adaptation:['violence','helplessness'],
|
||
_editable_skills:['art_1','art_2','craft_1','craft_2','military_science_1','military_science_2','pilot_1','pilot_2','science_1','science_2'],
|
||
_weapon :["name", "skill_percent", "base_range", "damage", "armor_piercing", "lethality_percent", "ammo"],
|
||
_rituals : ['name','skill_span','unnatural_gain','study_time','sanity_loss_for_learning','activation_time','description','complexity'],
|
||
_personal_data : [
|
||
'profession',
|
||
'employer',
|
||
'occupation',
|
||
'nationality_and_residence',
|
||
'sex',
|
||
'age',
|
||
'education',
|
||
'personal_details_and_notes',
|
||
'developments_which_affect_home_and_family',
|
||
'description',
|
||
'physical_description',
|
||
'npc_sources',
|
||
'npc_remarks'],
|
||
_advanced_weapons_featurs : [`shotgun`,`blast_radius`,`hasDoubleBarrel`,`selfire`,'accessories'],
|
||
_weapon_hidden_buttons : ['damage','lethality_percent','double_barrel','selective_fire'],
|
||
_ritual_hidden_buttons : ['pay_cost','force_connection','accept_failure','attack','heal','power'],
|
||
|
||
};
|
||
|
||
|
||
|
||
const _skill_percent = [
|
||
{section:'skills', field:'rank'},
|
||
{section:'special', field:'skill_or_stat_used'},
|
||
{section:'weapons' , field:'skill_percent'},
|
||
{section:'rituals', field:'skill_percent'}
|
||
];
|
||
|
||
const _initial_skills={'accounting': 10, 'alertness': 20, 'anthropology': 0, 'archeology': 0, 'art_1': 0,
|
||
'art_2': '0', 'artillery': 0, 'athletics': 30, 'bureaucracy': 10, 'computer_science': 0,
|
||
'craft_1': 0, 'craft_2': 0, 'criminology': 10, 'demolitions': 0, 'disguise': 10, 'dodge': 30,
|
||
'drive': 20, 'firearms': 20, 'first_aid': 10, 'forensics': 0, 'heavy_machinery': 10, 'heavy_weapons': 0,
|
||
'history': 10, 'humint': 10, 'law': 0, 'medicine': 0, 'melee_weapons': 30, 'military_science_1': 0,
|
||
'military_science_2': 0, 'navigate': 10, 'occult': 10, 'persuade': 20, 'pharmacy': 0, 'pilot_1': 0,
|
||
'pilot_2': 0, 'psychotherapy': 10, 'ride': 10, 'science_1': 0, 'science_2': 0, 'search': 20, 'sigint': 0,
|
||
'stealth': '10', 'surgery': 0, 'survival': 10, 'swim': 20, 'unarmed_combat': 40,'unnatural': 0};
|
||
|
||
|
||
const _repeating_sections={
|
||
'skill':'skills',
|
||
'bond':'bonds',
|
||
'special':'special',
|
||
'weapons':'weapons',
|
||
'ritual':'rituals'
|
||
};
|
||
|
||
const _score_info = [
|
||
`willpower_points_max`,
|
||
`character_creation_bonds`,
|
||
`repeating_bonds_setScore`,
|
||
`repeating_bonds_score`,
|
||
`repeating_bonds_score_old`,
|
||
`repeating_bonds_color`
|
||
];
|
||
|
||
const _bond_attributes = [
|
||
`name`,
|
||
`test`,
|
||
`score`,
|
||
`hurt`,
|
||
];
|
||
|
||
const _repeating_damages = [
|
||
'damage',
|
||
'damage_critical',
|
||
'lethality_percent',
|
||
'lethality_percent_critical',
|
||
'double_barrel',
|
||
'double_barrel_critical',
|
||
'selective_fire',
|
||
'selective_fire_critical',
|
||
]
|
||
|
||
const _repeating_ammo = [
|
||
'hasammo',
|
||
'ammo',
|
||
'ammo_total'
|
||
]
|
||
|
||
const _rd100 = `[[1d100]]`;
|
||
const _rd4 = `[[1d4]]`;
|
||
const _rd6 = `[[1d6]]`;
|
||
const _rd8 = `[[1d8]]`;
|
||
const _rd10 = `[[1d10]]`;
|
||
const _rd12 = `[[1d12]]`;
|
||
const _rd20 = `[[1d20]]`;
|
||
const _INHUMAN_STAT_ = 100;
|
||
const _criticals=[1,11,22,33,44,55,66,77,88,99,100];
|
||
const _queryModifier = `?{Modifier|0|+20%,20|+40%,40|-20%,-20|-40%,-40|custom (%),?{custom (%)}}`;
|
||
const prefix_skill_roll = `@{gm_toggle} &{template:fancy-rolls} {{name=@{character_name}}} {{dice=[[${_rd100}]]}}`;
|
||
const prefix_sanity_roll = `@{gm_toggle} &{template:fancy-sanloss} `;
|
||
// roll to use in rituals
|
||
// isHealing -> -1 for attack, 1 for heal, 0 for normal damages
|
||
const prefix_attack_roll = `@{gm_toggle} &{template:fancy-damages} {{name=@{character_name}}} {{isHealing=[[-1]]}} {{trackbullets=[[0]]}} {{header=^{attack}}}`;
|
||
const prefix_health_roll = `@{gm_toggle} &{template:fancy-damages} {{name=@{character_name}}} {{isHealing=[[1]]}} {{trackbullets=[[0]]}} {{header=^{heal} }}`;
|
||
// roll to use in weapons
|
||
const prefix_damage_roll = `@{gm_toggle} &{template:fancy-damages} {{name=@{character_name}}} {{isHealing=[[0]]}} {{usAiming=[[0]]}}`;
|
||
const prefix_bond_roll = `@{gm_toggle} &{template:fancy-bonds} {{character_id=@{character_id}}}{{name=@{character_name}}} {{dice=[[${_rd4}]]}}`;
|
||
const prefix_ritual_roll = `@{gm_toggle} &{template:fancy-rituals} {{name=@{character_name}}} {{dice=[[${_rd100}]]}}`;
|
||
const prefix_ritualloss_roll = `@{gm_toggle} &{template:fancy-ritualloss} {{name=@{character_name}}} {{header=^{ritual cost}}}`;
|
||
|
||
|
||
const _shotgun_or_blast_radius =[`shotgun`,`blast_radius`];
|
||
const _alldamages=['damage','damage_critical','double_barrel','double_barrel_critical',
|
||
'lethality_percent','lethality_percent_critical','selective_fire','selective_fire_critical'
|
||
];
|
||
|
||
const _ritual_damages=['attack','heal','power'];
|
||
const _type_damages=['damage','lethality_percent'];
|
||
const _ritual_losses=['pay_cost','force_connection','accept_failure'];
|
||
const _allrolls=arrays['_derived_rolls'].concat(arrays[`_stats`],arrays[`_skills`],['unnatural','sanity_loss']);
|
||
|
||
const RitualCosts = ['sanity_loss_success','sanity_loss_failure',
|
||
'willpower_points_cost','power_score_cost','hit_points_cost',
|
||
'strength_score_cost','constitution_score_cost',
|
||
'dexterity_score_cost','intelligence_score_cost',
|
||
'charisma_score_cost'];
|
||
|
||
const CurrentValues = ['sanity_points',
|
||
'willpower_points','power_score','hit_points',
|
||
'strength_score','constitution_score',
|
||
'dexterity_score','intelligence_score',
|
||
'charisma_score'];
|
||
|
||
const RitualRolls = ['name','skill_span','unnatural_gain',
|
||
'study_time','sanity_loss_for_learning','activation_time',
|
||
'description','complexity','flawed_ritual','power_reaction'];
|
||
|
||
const RitualDamages = ['attack_target_stat','attack_damage_amount','attack_lethality_percent_amount','attack_isLethal'];
|
||
const RitualHeals = ['heal_target_stat','heal_damage_amount','heal_lethality_percent_amount','heal_isLethal'];
|
||
|
||
const _ritualInfo=[
|
||
'complexity',
|
||
'activation_time',
|
||
'activation_time_unit',
|
||
'study_time',
|
||
'study_time_unit',
|
||
'unnatural_gain',
|
||
'sanity_loss_for_learning',
|
||
'willpower_points_cost',
|
||
'power_score_cost',
|
||
'hit_points_cost',
|
||
'strength_score_cost',
|
||
'constitution_score_cost',
|
||
'dexterity_score_cost',
|
||
'intelligence_score_cost',
|
||
'charisma_score_cost',
|
||
'sanity_loss_success',
|
||
'sanity_loss_failure'
|
||
]
|
||
|
||
const selector='button.roll';
|
||
const sanity_selector='button.sanroll';
|
||
|
||
let _globalModifier = 0;
|
||
|
||
|
||
const _number_or_roll= [
|
||
{section:'weapons', fields:['damage','double_barrel']},
|
||
{section:'rituals',fields:['sanity_loss_low','sanity_loss_high','attr_sanity_loss_for_learning','attr_unnatural_gain','heal_damage_amount','attack_damage_amount','willpower_points_cost','healpoints_cost','strength_score_cost','constitution_score_cost','dexterity_score_cost','intelligence_score_cost','charisma_score_cost','power_score_cost']}
|
||
];
|
||
const _only_number=[
|
||
{section:'weapons', fields:['lethality_percent','selfire_lethality_percent','accessory_modifier']},
|
||
{section:'rituals',fields:['attack_lethality_percent_amount','heallethality_percent_amount']}
|
||
];
|
||
const setWeaponOptions = ({isFlawed=0, isAiming=0 ,modifier=0,wp_mod={low_willpower:0,zero_willpower:0},hasLethality=0,
|
||
hasDamage=0,damage='',rating=0,lethality_percent=0,hasAdvancedWeapons=0,isShotgun=0,hasDoubleBarrel=0,hasSelectiveFire=0,
|
||
hasAccessories=0,hasBlastRadius=0, trackAmmo=0,current_ammo=0,double_barrel='',selfire_lethality_percent=0,selfire_type='',
|
||
accessory_modifier=0,accessory_name='',isSkill=1}) => {
|
||
const _hasAdvancedWeapons=hasAdvancedWeapons;
|
||
const _hasLethality= hasLethality;
|
||
const _hasDamage=hasDamage;
|
||
const _trackAmmo=trackAmmo;
|
||
const _rating=rating;
|
||
const _isSkill=isSkill;
|
||
const _modifier=modifier;
|
||
const _wp_mod=wp_mod;
|
||
const _isFlawed=isFlawed;
|
||
const _isAiming=isAiming;
|
||
var _isShotgun=0;
|
||
var _hasDoubleBarrel=0;
|
||
var _hasSelectiveFire=0;
|
||
var _hasAccessories=0;
|
||
var _hasBlastRadius=0;
|
||
var _double_barrel=double_barrel;
|
||
var _selfire_lethality_percent=selfire_lethality_percent;
|
||
var _selfire_type=selfire_type;
|
||
var _selfire_ammo=0;
|
||
var _current_ammo=current_ammo;
|
||
const _has_ammo=(_current_ammo>0) ? 1 : 0;
|
||
var _accessory_modifier=accessory_modifier;
|
||
var _accessory_name=(accessory_name==='') ? '^{accessory}' : accessory_name;
|
||
|
||
var _damage='';
|
||
var _lethality_percent=0;
|
||
var _low_willpower=0;
|
||
var _zero_willpower=0;
|
||
if (_wp_mod.hasOwnProperty('low_willpower')) { _low_willpower=_wp_mod.low_willpower; }
|
||
if (_wp_mod.hasOwnProperty('zero_willpower')) { _zero_willpower=_wp_mod.zero_willpower; }
|
||
if (_hasDamage==1) { _damage=damage; }
|
||
if (_hasLethality==1) { _lethality_percent=lethality_percent; }
|
||
|
||
if (_hasAdvancedWeapons==1) {
|
||
_isShotgun=isShotgun;
|
||
_hasDoubleBarrel=hasDoubleBarrel;
|
||
_hasSelectiveFire=hasSelectiveFire;
|
||
_hasAccessories=hasAccessories;
|
||
_hasBlastRadius=hasBlastRadius;
|
||
}
|
||
|
||
if (hasDoubleBarrel==1) { _double_barrel=double_barrel; }
|
||
if (hasSelectiveFire==1) {
|
||
_selfire_lethality_percent=selfire_lethality_percent;
|
||
_selfire_type=selfire_type;
|
||
_selfire_ammo=getRollDamage(selfire_type);
|
||
}
|
||
|
||
return { hasLethality: _hasLethality,lethality_percent: _lethality_percent, isSkill: _isSkill, rating: _rating,
|
||
hasDamage: _hasDamage,damage: _damage,
|
||
isShotgun: _isShotgun,hasDoubleBarrel: _hasDoubleBarrel,
|
||
hasSelectiveFire: _hasSelectiveFire,hasAccessories: _hasAccessories,hasBlastRadius: _hasBlastRadius,
|
||
trackAmmo: _trackAmmo,current_ammo: _current_ammo, double_barrel: _double_barrel,
|
||
selfire_lethality_percent: _selfire_lethality_percent, selfire_type: _selfire_type, selfire_ammo: _selfire_ammo,
|
||
accessory_modifier: _accessory_modifier,
|
||
accessory_name: _accessory_name,hasAdvancedWeapons: _hasAdvancedWeapons,
|
||
zero_willpower: _zero_willpower, low_willpower: _low_willpower, modifier: _modifier,
|
||
isFlawed: _isFlawed, isAiming: _isAiming};
|
||
};
|
||
|
||
const getInitializationFlags = (statInfo,values) => {
|
||
// note: flags are INITIALLY set to 1, it was a mistake but now it's better to keep it that way
|
||
const statName=statInfo['name'];
|
||
const _stat_used={
|
||
strength:'initial_str',
|
||
constitution:'initial_con',
|
||
};
|
||
const InitializationFlags={
|
||
'initial_hp':1,
|
||
'initial_str':1,
|
||
'initial_con':1,
|
||
'initial_san':1
|
||
};
|
||
Object.keys(InitializationFlags).forEach((key)=>{
|
||
if (values.hasOwnProperty(key) && values[key] == 0){ InitializationFlags[key]=0;}
|
||
});
|
||
if (_stat_used.hasOwnProperty(statName)) { InitializationFlags[_stat_used[statName]]=0;}
|
||
|
||
console.info('InitializationFlags:',InitializationFlags);
|
||
return InitializationFlags;
|
||
};
|
||
|
||
const setInitialHp = (update,values,statInfo,InitializationFlags) => {
|
||
if (statInfo['name'] !== 'strength' && statInfo['name'] !== 'constitution') { return; } // check if the stat is strength or constitution
|
||
if (statInfo['name'] == 'strength') {InitializationFlags[`initial_str`]=0;} // set the initial strength to 0
|
||
if (statInfo['name'] == 'constitution') {InitializationFlags[`initial_con`]=0;} // set the initial constitution to 0
|
||
if (InitializationFlags['initial_str']==1 || InitializationFlags['initial_con']==1) { return; } // if either flag is set, I cannot set the initial hp
|
||
///////// Set Hp regardless of the initial hp
|
||
const _strength_score=Math.max(0,parseInt(values['strength_score'],10)||0);
|
||
const _constitution_score=Math.max(0,parseInt(values['constitution_score'],10)||0);
|
||
const initial_hit_points= Math.ceil((_strength_score+_constitution_score)/2); // update max hp regardless of the initial hp
|
||
update['hit_points_max']=initial_hit_points;
|
||
//////// If the initial hp is not set yet, set it
|
||
if (InitializationFlags['initial_hp']==0) { return; } // check if initial hp is already set
|
||
|
||
update['hit_points']=initial_hit_points;
|
||
update['hit_points_old']=initial_hit_points;
|
||
InitializationFlags['initial_hp']=0;
|
||
};
|
||
|
||
|
||
const setInitialPower = (update,values,statInfo,InitializationFlags) => {
|
||
if (statInfo['name'] !== 'power') { return; } // only power can change the sanity points
|
||
const sanmax=setSanMax(values[`unnatural`]);
|
||
const InitialWillPower = statInfo.score;
|
||
update[`willpower_points_max`]=InitialWillPower;
|
||
// only updates if the flag is set
|
||
update['sanity_points_max']=sanmax;
|
||
if (InitializationFlags['initial_san']==0) { return; }
|
||
const InitialSanity = statInfo.stat;
|
||
const InitialBreakingPoint = statInfo.score*4;
|
||
//update['initial_san']=0;
|
||
update['sanity_points']= InitialSanity;
|
||
update['sanity_points_old']= InitialSanity;
|
||
update['breaking_point']= InitialBreakingPoint;
|
||
update['breaking_point_max']= InitialBreakingPoint;
|
||
update['willpower_points']=InitialWillPower;
|
||
InitializationFlags['initial_san']=0;
|
||
};
|
||
|
||
const setStatScore=(score,statName) =>{
|
||
const validNames=['strength','constitution','dexterity','power','intelligence','charisma'];
|
||
if (!validNames.includes(statName)) { return false; }
|
||
const _score = Math.max(0,parseInt(score));
|
||
return {name: statName, stat: _score*5, score: _score};
|
||
};
|
||
|
||
const setSanMax = (unnatural) => {
|
||
// Input:
|
||
// unnatural is the unnatural value
|
||
// Output:
|
||
// the maximum value for sanity points
|
||
return 99-setMinMax(unnatural,0,99);
|
||
};
|
||
|
||
const setDiceSection = (character_id,repsecid,use_=true) => {
|
||
// Input:
|
||
// charid is the character id
|
||
// repsecid is the repeating section id
|
||
// Output:
|
||
// ](~<charid>|<repsecid>_
|
||
return '](~'+ character_id +'|'+repsecid+ ((use_) ? '_' : '');
|
||
}
|
||
|
||
const setAdvancedWeaponsString = (options,character_id,repsecid) => {
|
||
var advancedWeaponsString='';
|
||
const dice_section = setDiceSection(character_id,repsecid);
|
||
const nothing_section = setDiceSection(character_id,'nothing)}}',false);
|
||
const rollEnding='-action)}}';
|
||
if (options.hasAdvancedWeapons===1) {
|
||
if (options.isShotgun===1) {advancedWeaponsString += '{{shotgun=[[1]]}}';}
|
||
if (options.hasDoubleBarrel===1) {
|
||
if (options.double_barrel != '') {
|
||
advancedWeaponsString += '{{double_barrel=['+options.double_barrel+dice_section+'double_barrel'+rollEnding;
|
||
advancedWeaponsString += '{{voiddouble_barrel=['+options.double_barrel+nothing_section;
|
||
advancedWeaponsString += '{{double_barrel_critical=[('+options.double_barrel+')×2'+dice_section+'double_barrel_critical'+rollEnding;
|
||
advancedWeaponsString += '{{voiddouble_barrel_critical=[('+options.double_barrel+')×2'+nothing_section;
|
||
}
|
||
}
|
||
if (options.hasSelectiveFire===1) {
|
||
if (options.selfire_lethality_percent>0) {
|
||
const critical_selfire_lethality_percent=options.selfire_lethality_percent*2;
|
||
|
||
advancedWeaponsString += '{{selective_fire=[' + options.selfire_type;
|
||
advancedWeaponsString += '('+options.selfire_lethality_percent + '%)'+dice_section+'selective_fire'+rollEnding;
|
||
|
||
advancedWeaponsString += '{{voidselective_fire=[' + options.selfire_type;
|
||
advancedWeaponsString += '(' + options.selfire_lethality_percent + '%)'+nothing_section;
|
||
|
||
advancedWeaponsString += '{{selective_fire_critical=[' + options.selfire_type;
|
||
advancedWeaponsString += '(' + critical_selfire_lethality_percent + '%)'+dice_section+'selective_fire_critical'+rollEnding;
|
||
advancedWeaponsString += '{{voidselective_fire_critical=[' + options.selfire_type;
|
||
advancedWeaponsString += '(' + critical_selfire_lethality_percent + '%)'+nothing_section;
|
||
}
|
||
|
||
if (options.selfire_ammo>=options.current_ammo && options.trackAmmo==1) {
|
||
advancedWeaponsString += '{{selfire_noammo=1}}';
|
||
}else{
|
||
advancedWeaponsString += '{{selfire_wammo=0}}';
|
||
}
|
||
}
|
||
if (options.hasAccessories===1) {
|
||
advancedWeaponsString += '{{accessories=[[1]]}}';
|
||
|
||
advancedWeaponsString += '{{accessory_name=' + options.accessory_name + '}}';
|
||
advancedWeaponsString += '{{accessory_modifier=[[' + options.accessory_modifier + ']]}}';
|
||
}
|
||
if (options.hasBlastRadius===1) {
|
||
advancedWeaponsString += '{{blast_radius=[[1]]}}';
|
||
}
|
||
}
|
||
|
||
if (options.trackAmmo) {
|
||
advancedWeaponsString += '{{trackbullets=1}}';
|
||
advancedWeaponsString += '{{current_ammo=[[' + options.current_ammo + ']]}}';
|
||
if (options.current_ammo==0) {
|
||
advancedWeaponsString += '{{noammo=1}}';
|
||
}else{
|
||
advancedWeaponsString += '{{wammo=0}}';
|
||
}
|
||
} else {
|
||
advancedWeaponsString += '{{wammo=0}}';
|
||
}
|
||
|
||
if (options.hasDamage==1) {
|
||
|
||
advancedWeaponsString += '{{damage= ['+options.damage+dice_section+'damage'+rollEnding;
|
||
advancedWeaponsString += '{{voiddamage= ['+options.damage+nothing_section;
|
||
|
||
advancedWeaponsString += '{{damage_critical= [('+options.damage+')×2'+dice_section+'damage_critical'+rollEnding;
|
||
advancedWeaponsString += '{{voiddamage_critical= [('+options.damage+')×2'+nothing_section;
|
||
}
|
||
if (options.hasLethality==1) {
|
||
const label_lethality = `^{Lethality}`;
|
||
advancedWeaponsString += '{{lethality_percent= [';
|
||
advancedWeaponsString += label_lethality+' ('+options.lethality_percent+'%)';
|
||
advancedWeaponsString += dice_section+'lethality_percent'+rollEnding;
|
||
advancedWeaponsString += '{{voidlethality_percent= [';
|
||
advancedWeaponsString += label_lethality+' ('+options.lethality_percent+'%)'+nothing_section;
|
||
|
||
advancedWeaponsString += '{{lethality_percent_critical= [';
|
||
advancedWeaponsString += label_lethality+' (2×'+options.lethality_percent+'%)';
|
||
advancedWeaponsString += dice_section+'lethality_percent_critical'+rollEnding;
|
||
advancedWeaponsString += '{{voidlethality_percent_critical= [';
|
||
advancedWeaponsString += label_lethality+' (2×'+options.lethality_percent+'%)'+ nothing_section;
|
||
}
|
||
|
||
return advancedWeaponsString;
|
||
}
|
||
|
||
const check_for_wp_modifiers = (values,roll) => {
|
||
|
||
const _willpower_points = parseInt(values[`willpower_points`]) || 0;
|
||
var flag_for_zero_willpower = values[`zero_willpower`]== 1;
|
||
flag_for_zero_willpower = flag_for_zero_willpower && _willpower_points== 0 && roll !== 'luck';
|
||
|
||
const _zero_willpower = (flag_for_zero_willpower) ? 1 : 0;
|
||
|
||
var flag_for_low_willpower = values[`low_willpower`]== 1;
|
||
flag_for_low_willpower = flag_for_low_willpower && _willpower_points <= 2;
|
||
flag_for_low_willpower = flag_for_low_willpower && roll !== 'luck' && roll !== 'sanity_points';
|
||
/// important it is either one or the other
|
||
flag_for_low_willpower = flag_for_low_willpower && flag_for_zero_willpower==false;
|
||
const _low_willpower = (flag_for_low_willpower) ? 1 : 0;
|
||
return {zero_willpower: _zero_willpower, low_willpower: _low_willpower};
|
||
};
|
||
|
||
const check_success= (dice,rating,isSkill=1) => {
|
||
// Input:
|
||
// dice is the result of the roll
|
||
// rollName is the name of the skill or stat
|
||
// rollFail used only for stats to check for failure
|
||
// rating is the rating of the skill or stat
|
||
// isSkill is the flag to check if it's a skill or a stat [0,1]
|
||
|
||
var isSuccess=0;
|
||
var isCritical=0;
|
||
|
||
if (dice==100){ // 100 is always a fumble
|
||
isCritical=1;
|
||
isSuccess=0;
|
||
} else { // check for criticals normally
|
||
isSuccess = dice<=rating ? 1 : 0;
|
||
isCritical = _criticals.includes(dice) ? 1 : 0;
|
||
}
|
||
|
||
const isInhuman=(isSkill==0 && rating>=_INHUMAN_STAT_);
|
||
const isNormalSuccess=(isSuccess==1 && isCritical==0);
|
||
|
||
if (isInhuman && isNormalSuccess){ // special case for stats to evaluate criticals
|
||
const score=Math.round(rating/5);
|
||
isCritical = (dice<=score) ? 1 : 0;
|
||
}
|
||
|
||
return {isSuccess:isSuccess,isCritical:isCritical};
|
||
|
||
};
|
||
|
||
const check_weapon_modifiers = (options) => {
|
||
const advanced_weapons = options.hasAdvancedWeapons;
|
||
var modifier = options.modifier;
|
||
const low_willpower = options.low_willpower;
|
||
if (advanced_weapons==0) { return correct_modifier(modifier,low_willpower) ;}
|
||
|
||
if (options.isShotgun==1 || options.hasBlastRadius==1){ modifier+=20;}
|
||
if (options.hasAccessories==1){modifier+=options.accessory_modifier;}
|
||
if (options.isFlawed==1){modifier-=20;}
|
||
if (options.isAiming==1){modifier+=20;}
|
||
return correct_modifier(modifier,low_willpower);
|
||
}
|
||
|
||
const correct_modifier = (modifier,low_willpower,limit_to_40=1) => {
|
||
// Input:
|
||
// modifier is the base modifier provided by the used
|
||
// low_willpowe is the low willpower flag [0,1]
|
||
// limit_to_40 is the flag to limit the upper bound modifier to 40% (not used but for future and debugging) [0,1]
|
||
// Output:
|
||
// the corrected modifier
|
||
var corrected_modifier=modifier - (20*low_willpower);
|
||
return limit_to_40==1 ? Math.min(40,corrected_modifier) : corrected_modifier;
|
||
}
|
||
const correct_rating = (rating,modifier,limit_to_99=1) => {
|
||
// Input:
|
||
// rating is the base rating of the skill
|
||
// modifier is the corrected modifier
|
||
// limit_to_99 is the flag to limit the upper bound rating to 99% (0 for inhuman stats) [0,1]
|
||
// Output:
|
||
// the corrected rating
|
||
var corrected_rating=rating+modifier;
|
||
return limit_to_99==1 ? Math.min(99,corrected_rating) : corrected_rating;
|
||
}
|
||
|
||
const check_sanloss = (sanloss,attrName) => {
|
||
if (attrName==='sanity_loss_success'){
|
||
|
||
return sanloss=='' ? 0 : sanloss;
|
||
} else if(attrName==='sanity_loss_failure'){
|
||
|
||
return sanloss=='' ? 1 : sanloss;
|
||
}
|
||
};
|
||
|
||
const check_track_ammo=(rollString,trackAmmo,currentAmmo,used_ammo=1) => {
|
||
if (trackAmmo==1) {
|
||
rollString = `${rollString} {{trackbullets=[[1]]}} {{used_ammo=[[${used_ammo}]]}}`;
|
||
rollString = `${rollString} {{current_ammo=[[${currentAmmo}]]}}`;
|
||
} else {
|
||
rollString = `${rollString} {{trackbullets=[[0]]}}`;
|
||
}
|
||
return rollString;
|
||
};
|
||
|
||
const getUsedAmmo=(selfire_type='') => {
|
||
if (selfire_type==='short burst'){return 3} ;
|
||
if (selfire_type==='long burst'){return 5} ;
|
||
if (selfire_type==='short spray'){return 10} ;
|
||
if (selfire_type==='long spray'){return 20} ;
|
||
return 1;
|
||
}
|
||
|
||
const need_to_track_ammo = (_values,_names)=>{
|
||
const track_bullets=_values[_names['track_bullets']]==='active' ? 1 : 0;
|
||
const hasammo=_values[_names['hasammo']]==='active' ? 1 : 0;
|
||
return (track_bullets==1 && hasammo==1) ? 1 : 0;
|
||
}
|
||
|
||
|
||
const setAttributes = (update, silent) => {
|
||
(silent === true) ? setAttrs(update, {silent:true}) : setAttrs(update);
|
||
};
|
||
|
||
// check skill value for weapons and special training
|
||
const isSkillNumber = (str) => {
|
||
let num=Number(str);
|
||
return !isNaN(num) && num>=0 && num<=99
|
||
};
|
||
|
||
const isSkillName= (rollName) => {return arrays[`_skills`].includes(rollName) ? 1 : 0;};
|
||
|
||
|
||
// check if linking skill in in linking form
|
||
const isStringInForm=(str)=> {
|
||
var regex = /^@\{[\w\s]+\}$/;
|
||
return regex.test(str);
|
||
};
|
||
|
||
// used for linking skills
|
||
const cleanedSkill= (str) =>{return String(str).toLowerCase().replace(' ','_').replace('@{','').replace('}','')};
|
||
|
||
// When the trigger comes from another call
|
||
const isMinorityReport = (eventInfo) => !(eventInfo.hasOwnProperty('newValue'));
|
||
|
||
// check if the format is the one of a linking skill
|
||
const isValidSkill=(str)=> {
|
||
|
||
const compar=cleanedSkill(String(str));
|
||
|
||
return arrays['_skills'].concat(arrays['_stats']).concat(['unnatural','ritual_skill']).includes(compar);
|
||
};
|
||
|
||
const isEmpty = (obj) => Object.keys(obj).length === 0 && obj.constructor === Object;
|
||
|
||
const getSections = function(sectionDetails,callback){
|
||
let queueClone = _.clone(sectionDetails);
|
||
const worker = (queue,repeatAttrs=[],sections={})=>{
|
||
let detail = queue.shift();
|
||
|
||
getSectionIDs(detail.section,(IDs)=>{
|
||
sections[detail.section] = IDs;
|
||
IDs.forEach((id)=>{
|
||
detail.fields.forEach((f)=>{
|
||
repeatAttrs.push(`${detail.section}_${id}_${f}`);
|
||
});
|
||
});
|
||
repeatAttrs.push(`_reporder_${detail.section}`);
|
||
if(queue.length){
|
||
worker(queue,repeatAttrs,sections);
|
||
}else{
|
||
callback(repeatAttrs,sections);
|
||
}
|
||
});
|
||
};
|
||
if(!queueClone[0]){
|
||
callback([],{});
|
||
}else{
|
||
worker(queueClone);
|
||
}
|
||
};
|
||
|
||
const get_header_skills = (values,property) => {
|
||
var _header = ``;
|
||
if (values.hasOwnProperty(property['editable_name'])) {
|
||
_header = '{{header=^{'+property['editable_type']+'}';
|
||
_header = _header +' ('+values[property['editable_name']]+')}}';
|
||
}else {
|
||
_header = '{{header=^{'+property['name']+'} }}';
|
||
}
|
||
return _header;
|
||
}
|
||
|
||
const check_for_failed_skill = (rollName,isSuccess=0,isSkill=1) => {
|
||
// Input:
|
||
// rollName is the name of the skill if it's a skill, if it's a repeating section, it's the name of the section
|
||
// outcome is the result of the roll [0,1]
|
||
// isSkill is the flag to check if it's a skill [0,1]
|
||
|
||
var failure={};
|
||
if (isSkill==false) {return failure;}; // if it's not a skill, return empty object
|
||
if (isSuccess==1) {return failure;}; // if it's a success, return empty object
|
||
|
||
failure[`${rollName}_fail`]='on';
|
||
|
||
return failure;
|
||
}
|
||
|
||
const setMinMax = (skill, min=0, max=99) => {
|
||
const IntegerSkill=parseInt(skill)||0;
|
||
if (min>max) {return IntegerSkill}
|
||
return Math.min(Math.max(IntegerSkill,min),max);
|
||
};
|
||
|
||
const isValidLinkInput = (newValue) => {return (isStringInForm(newValue) && isValidSkill(newValue));};
|
||
|
||
const parseRoll = (roll) => {
|
||
const regex_int = /^(\s*[\+\-]?\d{1,100}\s*)$/;
|
||
const regex_roll = /^((\s*[\+\-\(\)]\s*){0,4}?\d{0,10}[dD]?\d{1,10}((\s*[\+\-\*\/\(\)]\s*){0,4}?\d{0,10}[dD]?\d{1,10})*(\s*[\)]\s*){0,4}?)+$/
|
||
if (regex_int.test(roll)) {return parseInt(roll);}
|
||
if (regex_roll.test(roll)) {return roll.replace(/\s/g, '').toUpperCase();}
|
||
return 0;
|
||
}
|
||
|
||
const maxRoll = (roll) => {
|
||
if (isNaN(Number(roll))==false) {return roll;}
|
||
return parseRoll(roll).replace(/[dD]/g, '*')
|
||
}
|
||
|
||
const minRoll = (roll) => {
|
||
if (isNaN(Number(roll))==false) {return roll;}
|
||
return parseRoll(roll).replace(/[dD]\d{1,100}/g,'')
|
||
}
|
||
const addTargetStat=(values,names,attrName) => {
|
||
var target_stat='';
|
||
if (attrName==='attack' || attrName==='heal'){
|
||
target_stat+=`{{target_unit=${name_to_shorthand(values[names['target_stat']])}}}`;
|
||
target_stat+=`{{target_stat=${values[names['target_stat']].replace(/_/g,' ')}}}`;
|
||
}
|
||
return target_stat;
|
||
};
|
||
const updatebondscore = (values,update,manualscore=true) => {
|
||
|
||
const character_creation_bonds = values[`character_creation_bonds`] === 'active' ? true : false;
|
||
const willpower_points_max = parseInt(values.willpower_points_max) || 0;
|
||
const initial_willpower = (character_creation_bonds) ? willpower_points_max : Math.floor(willpower_points_max/2);
|
||
const flag = (manualscore) ? 1 : parseInt(values[`repeating_bonds_setScore`]) || 0;
|
||
const bond_score_old = parseInt(values[`repeating_bonds_score_old`]) || 0;
|
||
var bond_score = 0;
|
||
|
||
if (flag === 0) {
|
||
bond_score = initial_willpower;
|
||
} else {
|
||
bond_score = parseInt(values[`repeating_bonds_score`]) || 0;
|
||
if (bond_score > willpower_points_max) {
|
||
if (willpower_points_max > bond_score_old) {
|
||
bond_score = willpower_points_max;
|
||
}
|
||
}
|
||
}
|
||
update[`repeating_bonds_score`] = bond_score;
|
||
update[`repeating_bonds_score_old`] = bond_score_old;
|
||
update[`repeating_bonds_setScore`] = 1;
|
||
update[`repeating_bonds_color`] = BondButtonColor(bond_score);
|
||
}
|
||
const DeltaGreenLethalityFail=(roll) => {
|
||
const quotient=Math.floor(roll/10)== 0 ? 10 : Math.round(roll/10);
|
||
const remainder= (roll%10 ==0) ? 10 : Math.round(roll%10);
|
||
return quotient+ remainder;
|
||
};
|
||
|
||
// Update span on change
|
||
const updateSkillSpanOnChange=(skill,value,update,isWhat) =>{
|
||
|
||
const sectionDetails = [{section:'repeating_special', fields:['skill_or_stat_used']},
|
||
{section:'repeating_weapons',fields:['skill_percent']},
|
||
{section:'repeating_rituals',fields:['skill_percent']}];
|
||
|
||
getSections(sectionDetails,(attr)=>{
|
||
|
||
const allskills1=attr.filter(el => el.startsWith(sectionDetails[0][`section`]) && el.endsWith(sectionDetails[0][`fields`][0]));
|
||
const allskills2=attr.filter(el => el.startsWith(sectionDetails[1][`section`]) && el.endsWith(sectionDetails[1][`fields`][0]));
|
||
const allskills3=attr.filter(el => el.startsWith(sectionDetails[2][`section`]) && el.endsWith(sectionDetails[2][`fields`][0]));
|
||
|
||
const allids1= allskills1.map(el => el.replace(`_${sectionDetails[0][`fields`][0]}`,''));
|
||
const allids2= allskills2.map(el => el.replace(`_${sectionDetails[1][`fields`][0]}`,''));
|
||
const allids3= allskills3.map(el => el.replace(`_${sectionDetails[2][`fields`][0]}`,''));
|
||
const len1=allids1.length;
|
||
const len2=allids2.length;
|
||
const len3=allids3.length;
|
||
getAttrs(allskills1.concat(allskills2).concat(allskills3),(v)=>{
|
||
|
||
for (i=0;i<len1; i++){
|
||
if (cleanedSkill(v[allskills1[i]])===skill){
|
||
update[`${allids1[i]}_skill_span`]=value;
|
||
}
|
||
|
||
}
|
||
|
||
for (i=0;i<len2; i++){
|
||
if (cleanedSkill(v[allskills2[i]])===skill){
|
||
update[`${allids2[i]}_skill_span`]=value;
|
||
}
|
||
}
|
||
|
||
for (i=0;i<len3; i++){
|
||
if (cleanedSkill(v[allskills3[i]])===skill){
|
||
update[`${allids3[i]}_skill_span`]=value;
|
||
}
|
||
}
|
||
setAttrs(update,{silent:true},()=>{
|
||
console.log(`Skill span updated for ${skill}`);
|
||
console.info(update);
|
||
|
||
});
|
||
});
|
||
|
||
});
|
||
|
||
}
|
||
const saneffects=(snew,sold,smax,bnew,bmax,bold,pow,trackbp) => {
|
||
const san = value_current(snew,sold,smax);
|
||
const diffsan=san-sold;
|
||
|
||
const flag_2san = (diffsan>=2) ? 1 : 0;
|
||
const flag_temp = (diffsan>=5) ? 1 : 0;
|
||
const flag_bp = (san<=bnew && trackbp==1) ? 1 : 0;
|
||
return {san2:flag_2san,temp:flag_temp,bp:flag_bp};
|
||
};
|
||
|
||
const definesanroll=(san,sold,bnew,bold,sanflags,character_name,San2_disorder={},Temp_disorder={}) => {
|
||
const diffsan=san-sold;
|
||
const flag_2san=(sanflags.san2 && !(isEmpty(San2_disorder)));
|
||
const flag_temp=sanflags.temp;
|
||
const flag_bp=sanflags.bp;
|
||
|
||
var rollString=`&{template:fancy-rolls} {{name=${character_name}}} {{header=^{sanity_loss}}} `;
|
||
rollString= `${rollString} {{sanity_loss=[[${diffsan}]]}} {{sanity_new=[[${san}]]}}`;
|
||
rollString= `${rollString} {{sanity_old=[[${sold}]]}} {{bp_old=[[${bold}]]}} {{bp_new=[[${bnew}]]}}`;
|
||
|
||
if (flag_bp == 1){
|
||
rollString= `${rollString} {{flag_bp=1}} `;
|
||
}
|
||
if (flag_temp==1){
|
||
rollString=`${rollString} {{flag_temp=1}}`;
|
||
if (!(isEmpty(Temp_disorder))){
|
||
Object.entries(Temp_disorder).forEach(([key,val],index)=>{
|
||
rollString= `${rollString} {{tdis_name${index}=${key}}} {{tdis_desc${index}=${val}}} `;
|
||
});
|
||
}
|
||
}
|
||
|
||
if (flag_2san==1){
|
||
rollString=`${rollString} {{flag_2san=1}}`;
|
||
if (!(isEmpty(Temp_disorder))){
|
||
Object.entries(Temp_disorder).forEach(([key,val],index)=>{
|
||
rollString= `${rollString} {{tdis_name${index}=${key}}} {{tdis_desc${index}=${val}}} `;
|
||
});
|
||
}
|
||
}
|
||
|
||
var update={};
|
||
update['sanity_points']=san;
|
||
update['sanity_points_old']=sold;
|
||
if (flag_bp==='on'){
|
||
update['breaking_point']=Math.max(0,san-pow);
|
||
update['breaking_point_max']=bold;
|
||
update['breaking_point_old']==Math.max(0,san-pow);
|
||
}
|
||
|
||
setAttrs(update, {silent:true},()=>{
|
||
|
||
});
|
||
|
||
startRoll(`${rollValue} {{isSkill=[[${_isSkill}]]}}`, (results)=> {
|
||
const sanity_old=results.results.sanity_old.result;
|
||
const sanity_new=results.results.sanity_new.result;
|
||
const sanity_loss=results.results.sanity_loss.result;
|
||
const bp_old=results.results.bp_old.result;
|
||
const bp_new=results.results.bp_new.result;
|
||
finishRoll(results.rollId,{});
|
||
|
||
});
|
||
|
||
}
|
||
|
||
const value_current = (current,old,max) => {
|
||
|
||
if (current>=max) {
|
||
return (current<=old) ? current : old;
|
||
}
|
||
return Math.max(current,0);
|
||
}
|
||
|
||
const setBondsLocalVariables = () => {
|
||
getAttrs(["willpower_points","sanity_points"],function(value){
|
||
let update={};
|
||
getSectionIDs(`bonds`,function(idarray){
|
||
idarray.forEach(id=>{
|
||
update["repeating_bonds_"+id+"_wp_points"]=value["willpower_points"];
|
||
update["repeating_bonds_"+id+"_sanity_points"]=value["sanity_points"];
|
||
});
|
||
console.log('inside repeating section');
|
||
|
||
setAttrs(update,{silent:true},()=>{
|
||
console.log('Bonds updated on open');
|
||
});
|
||
});
|
||
});
|
||
};
|
||
// === debug note: need to change repeating_special_training and repeating_weapons for visulization purposes
|
||
// === Update stats on change
|
||
|
||
const skill_in_bounds = (skill) => {
|
||
const skill_value = parseInt(skill) || 0;
|
||
return Math.min(99, Math.max(0, skill_value));
|
||
};
|
||
|
||
const updateadvancedweapons = () => {
|
||
getAttrs(['advanced_weapons'],(v)=>{
|
||
const advanced_weapons=v['advanced_weapons'];
|
||
getSectionIDs('repeating_weapons',(ids)=>{
|
||
|
||
const update={};
|
||
|
||
const prefix='repeating_weapons_';
|
||
ids.forEach((id)=>{
|
||
update[prefix+id+'_hasAdvancedWeapons']=advanced_weapons;
|
||
arrays['_advanced_weapons_featurs'].forEach((feat)=>{
|
||
update[prefix+id+'_'+feat]=0;
|
||
});
|
||
});
|
||
setAttrs(update,{silent:true});
|
||
});
|
||
});
|
||
};
|
||
/* visuar option: removes the "advanced weapons" button from the weapons section
|
||
*/"use strict";
|
||
|
||
on('clicked:reset_all', () =>{
|
||
const update = {};
|
||
resetStats(update,false);
|
||
resetBonds(update);
|
||
resetAdaptations(update);
|
||
resetEquipment(update);
|
||
resetSkills(update);
|
||
resetHistory(update);
|
||
// write all the reset functions here
|
||
|
||
|
||
setAttrs(update, {silent: true}, () => {
|
||
console.log('reset all');
|
||
console.info(update);
|
||
|
||
});
|
||
});
|
||
on('clicked:reset_stats', () =>{
|
||
const update = {};
|
||
resetStats(update);
|
||
|
||
setAttrs(update, {silent: true}, () => {
|
||
console.log('reset stats');
|
||
console.info(update);
|
||
|
||
});
|
||
});
|
||
on('clicked:reset_skills', () =>{
|
||
const update = {};
|
||
resetSkills(update);
|
||
|
||
setAttrs(update, {silent: true}, () => {
|
||
console.log('reset skills');
|
||
console.info(update);
|
||
|
||
});
|
||
});
|
||
on('clicked:reset_equipment', () =>{
|
||
const update = {};
|
||
resetEquipment(update);
|
||
|
||
setAttrs(update, {silent: true}, () => {
|
||
console.log('reset equipment');
|
||
console.info(update);
|
||
|
||
});
|
||
});
|
||
on('clicked:reset_breaking_point', () =>{
|
||
const update = {};
|
||
resetBreakingPoints(update);
|
||
console.info(update);
|
||
|
||
});
|
||
|
||
|
||
|
||
const resetBreakingPoints = (update) => {
|
||
getAttrs(['breaking_point_max', 'breaking_point', 'breaking_point_reset'], function (values) {
|
||
console.log('breaking_point_reset:',values);
|
||
var breaking_point_reset = parseInt(values.breaking_point_reset,10) || 0;
|
||
|
||
update['breaking_point_max']= breaking_point_reset;
|
||
update['breaking_point']= breaking_point_reset;
|
||
update['breaking_point_reset']= breaking_point_reset;
|
||
|
||
setAttrs(update, {silent: true}, () => {
|
||
console.log('reset breaking points');
|
||
console.info(update);
|
||
|
||
});
|
||
});
|
||
};
|
||
|
||
|
||
const resetStats = (update,reset_bonds=true) => {
|
||
var array_to_reset = arrays['_stats'];
|
||
const stat_score=arrays['_stats'].map(stat => stat+'_score');
|
||
array_to_reset=array_to_reset.concat(stat_score);
|
||
array_to_reset=array_to_reset.concat(arrays['_derived_stats'])
|
||
array_to_reset=array_to_reset.concat(arrays['_derived_stats_max'])
|
||
|
||
|
||
array_to_reset = array_to_reset;
|
||
array_to_reset.forEach(stat => {
|
||
update[stat] = '';
|
||
});
|
||
|
||
const old_values = [
|
||
'sanity_points_old',
|
||
'breaking_point_old',
|
||
];
|
||
|
||
old_values.forEach(stat => {
|
||
update[stat] = '';
|
||
});
|
||
|
||
|
||
const initial_flags=[
|
||
'initial_san',
|
||
'initial_con',
|
||
'initial_str',
|
||
'initial_hp',
|
||
];
|
||
|
||
initial_flags.forEach(flag => {
|
||
update[flag] = '1';
|
||
});
|
||
if (reset_bonds){
|
||
getSectionIDs('repeating_bonds',(ids) => {
|
||
|
||
ids.forEach(id => {
|
||
update[`repeating_bonds_${id}_test`] = 'editable';
|
||
update[`repeating_bonds_${id}_score`] = '';
|
||
});
|
||
});
|
||
}
|
||
};
|
||
|
||
const resetSkills = (update) => {
|
||
Object.entries(_initial_skills).forEach(([skill, value]) => {
|
||
update[skill] = value;
|
||
update[`${skill}_fail`] = value;
|
||
});
|
||
arrays['_editable_skills'].forEach(skill => {
|
||
update[`${skill}_name`] = '';
|
||
update[`${skill}_test`] = 0;
|
||
});
|
||
resetAllRepeatingSkills(update);
|
||
resetAllSpecialAbilities(update);
|
||
|
||
};
|
||
|
||
|
||
const resetBonds= (update) => {
|
||
getSectionIDs('repeating_bonds',(ids) => {
|
||
ids.forEach(id => {
|
||
removeRepeatingRow('repeating_bonds_'+id);
|
||
console.log('removing repeating_bonds_'+id);
|
||
});
|
||
});
|
||
};
|
||
|
||
const resetAdaptations= (update) => {
|
||
update['motivations'] = '';
|
||
console.log(arrays['_adaptation']);
|
||
arrays['_adaptation'].forEach(adaptation => {
|
||
update[adaptation] = -1;
|
||
update[`${adaptation}_adapted`] = 0;
|
||
});
|
||
};
|
||
|
||
const resetAllWeapons= (update) => {
|
||
getSectionIDs('repeating_weapons',(ids) => {
|
||
ids.forEach(id => {
|
||
removeRepeatingRow('repeating_weapons_'+id);
|
||
console.log('removing repeating_weapons_'+id);
|
||
|
||
});
|
||
});
|
||
}
|
||
|
||
const resetAllRituals= (update) => {
|
||
getSectionIDs('repeating_rituals',(ids) => {
|
||
ids.forEach(id => {
|
||
removeRepeatingRow('repeating_rituals_'+id);
|
||
console.log('removing repeating_rituals_'+id);
|
||
});
|
||
});
|
||
}
|
||
|
||
|
||
const resetEquipment= (update) => {
|
||
resetAllWeapons(update);
|
||
resetAllRituals(update);
|
||
update['armor_and_gear'] = '';
|
||
};
|
||
|
||
|
||
const resetAllRepeatingSkills= (update) => {
|
||
getSectionIDs('repeating_skills',(ids) => {
|
||
ids.forEach(id => {
|
||
removeRepeatingRow('repeating_skills_'+id);
|
||
console.log('removing repeating_skills_'+id);
|
||
});
|
||
});
|
||
}
|
||
|
||
const resetAllSpecialAbilities= (update) => {
|
||
getSectionIDs('repeating_special',(ids) => {
|
||
console.log('special:'+ids);
|
||
ids.forEach(id => {
|
||
removeRepeatingRow('repeating_special_'+id);
|
||
console.log('removing repeating_special_'+id);
|
||
});
|
||
});
|
||
}
|
||
const resetHistory = (update) => {
|
||
console.log(arrays['_personal_data']);
|
||
arrays['_personal_data'].forEach(data => {
|
||
update[data] = '';
|
||
});
|
||
resetInjuries(update);
|
||
}
|
||
|
||
const resetInjuries = (update) => {
|
||
update['injuries'] = '';
|
||
update['injuries_first_aid'] = 0;
|
||
}
|
||
|
||
const updatesanitypoints = (tmp_sanity_points,sanity_points_old,sanity_points_max,update) => {
|
||
const sanity_points = value_current(tmp_sanity_points, sanity_points_old, sanity_points_max);
|
||
update['sanity_points_old'] = sanity_points;
|
||
update['sanity_points'] = sanity_points;
|
||
update['ritual_skill'] = Math.max(99-sanity_points);
|
||
return {sanity_points:sanity_points,ritual_skill:Math.max(99-sanity_points)};
|
||
};
|
||
|
||
const updatebreakingpoints = () => {
|
||
getAttrs(['power_score','breaking_point','sanity_points','breaking_point_reset','sanity_points_max','sanity_points_old','track_breaking_points'], (values)=> {
|
||
const update = {};
|
||
const flag=values.track_breaking_points==='active' ? true : false;
|
||
const power_score = parseInt(values.power_score, 10) || 0;
|
||
const breaking_point = parseInt(values.breaking_point, 10) || 0;
|
||
const sanity_points_old = parseInt(values.sanity_points_old, 10) || 0;
|
||
const sanity_points_max = parseInt(values.sanity_points_max, 10) || 0;
|
||
const tmp_sanity_points = parseInt(values.sanity_points, 10) || 0;
|
||
update_bp_san_ritual(tmp_sanity_points,sanity_points_old,sanity_points_max,power_score,breaking_point,update,flag);
|
||
|
||
});
|
||
}
|
||
|
||
const update_bp_san_ritual = (tmp_sanity_points,sanity_points_old,sanity_points_max,power_score, breaking_point,update,flag) => {
|
||
const updated_values=updatesanitypoints(tmp_sanity_points,sanity_points_old,sanity_points_max,update);
|
||
var update_breaking_point = breaking_point;
|
||
if(flag && (updated_values.sanity_points<breaking_point)){
|
||
update_breaking_point = Math.max(0,updated_values.sanity_points-power_score);
|
||
}
|
||
update['breaking_point_reset'] = update_breaking_point;
|
||
update['breaking_point']=update_breaking_point;
|
||
updateSkillSpanOnChange('ritual_skill',updated_values.ritual_skill,update,'Rituals');
|
||
}
|
||
|
||
const setResetBreakingPointsOnOpen = () => {
|
||
getAttrs(['breaking_point','sanity_points','sanity_points_max','power_score','track_breaking_points'], (values)=> {
|
||
const breaking_point = Math.max(0,parseInt(values.breaking_point, 10) || 0);
|
||
const flag=values.track_breaking_points==='active' ? true : false;
|
||
const power_score = parseInt(values.power_score, 10) || 0;
|
||
|
||
const update = {};
|
||
const open_sanity_points = parseInt(values.sanity_points, 10) || 0;
|
||
const sanity_points_max = parseInt(values.sanity_points_max, 10) || 0;
|
||
update_bp_san_ritual(open_sanity_points,open_sanity_points,sanity_points_max,power_score,breaking_point,update,flag);
|
||
});
|
||
};const versioning = (version) => {
|
||
console.log(`%c Versioning, ${version}`, 'color: green; font-weight:bold');
|
||
if (version < 1.05) {
|
||
version_0_105();
|
||
}
|
||
if (version <1.5) {
|
||
version_105_150();
|
||
}
|
||
if (version<1.7) {
|
||
version_150_170();
|
||
}
|
||
if (version<2.0) {
|
||
version_170_200();
|
||
}
|
||
if (version<2.01) {
|
||
version_200_201();
|
||
}
|
||
};
|
||
|
||
// UPDATE TO VERSION 1.05
|
||
const version_0_105= () => {
|
||
getAttrs(['version'], function(v) {
|
||
let codeversion=1.05;
|
||
let update={version: codeversion,
|
||
initial_san: 0,
|
||
initial_hp: 0,
|
||
initial_str: 0,
|
||
initial_con: 0
|
||
};
|
||
setAttrs(update, //Update attributes
|
||
{silent:true}, // will not trigger sheet workers
|
||
versioning(codeversion)); // call versioning again
|
||
});
|
||
};
|
||
// UPDATE TO VERSION 1.5
|
||
const version_105_150 = () => {
|
||
|
||
let codeversion=1.5;
|
||
let update={};
|
||
|
||
getSectionIDs(`weapons`,function(idarray){
|
||
console.log(`%c idarray`, 'color: green; font-weight:bold');
|
||
console.info(idarray);
|
||
let fieldnames=['sheet_type','version'];
|
||
console.log(`%c did I found weapons?`, 'color: green; font-weight:bold');
|
||
idarray.forEach(id => {
|
||
console.log(`%c ${id}`, 'color: green; font-weight:bold');
|
||
fieldnames.push(`repeating_weapons_${id}_damage`,`repeating_weapons_${id}_lethality_percent`,`repeating_weapons_${id}_attack`);
|
||
});
|
||
getAttrs(fieldnames,function(v) {
|
||
console.log(`%c v`, 'color: green; font-weight:bold');
|
||
console.info(v);
|
||
update['version']=codeversion;
|
||
|
||
idarray.forEach(id=>{
|
||
console.log(`%c ${id}`, 'color: green; font-weight:bold');
|
||
if (v[`repeating_weapons_${id}_damage`]===""){
|
||
update["repeating_weapons_"+id+"_hasDamage"]="0";
|
||
|
||
} else{
|
||
update["repeating_weapons_"+id+"_hasDamage"]="1";
|
||
|
||
}
|
||
|
||
if (v[`repeating_weapons_${id}_lethality_percent`]>0){
|
||
update["repeating_weapons_"+id+"_hasLethality"]="1";
|
||
|
||
} else {
|
||
update["repeating_weapons_"+id+"_hasLethality"]="0";
|
||
|
||
}
|
||
if (v['sheet_type']==='npc'){
|
||
update["repeating_weapons_"+id+"_weapons"]=v[`repeating_weapons_${id}_attack`];
|
||
}
|
||
});
|
||
|
||
console.log(`%c update`, 'color: green; font-weight:bold');
|
||
|
||
setAttrs(update, //Update attributes
|
||
{silent:true}, // will not trigger sheet workers
|
||
versioning(codeversion)); // call versioning again
|
||
|
||
});
|
||
});
|
||
};
|
||
|
||
// UPDATE TO VERSION 1.7
|
||
const version_150_170 = () => {
|
||
let codeversion=1.7;
|
||
let update={};
|
||
update['version']=codeversion;
|
||
update['luck']=50;
|
||
update['luck_max']=50;
|
||
console.log(`%c update`, 'color: green; font-weight:bold');
|
||
|
||
setAttrs(update, //Update attributes
|
||
{silent:true}, // will not trigger sheet workers
|
||
versioning(codeversion)); // call versioning again
|
||
};
|
||
|
||
// UPDATE TO VERSION 2.0
|
||
const version_170_200 = () => {
|
||
let codeversion=2.0;
|
||
let update={};
|
||
update['version']=codeversion;
|
||
getAttrs(["motivations","character_name","name","sanity_points","violence_3","helplessness_3","violence_2","helplessness_2",
|
||
"sanity_points_old","sanity_points","breaking_point_old","breaking_point_old"],function(v){
|
||
let motivations=v["motivations"];
|
||
if (v["name"]!==""){
|
||
_name=v["name"];
|
||
}else{
|
||
_name=v["character_name"];
|
||
}
|
||
update["character_name"]=_name;
|
||
update["old_motivations"]=motivations.replace(/<br>/g,"\n");
|
||
const _violence_adapted = v["violence_2"]==='on';
|
||
const _helplessness_adapted = v["helplessness_2"]==='on';
|
||
if (v["violence_2"]==='on'){
|
||
update["violence_1"]='on';
|
||
}
|
||
if (v["helplessness_2"]==='on'){
|
||
update["helplessness_1"]='on';
|
||
}
|
||
|
||
if (_violence_adapted){
|
||
update["violence_adapted"]=1;
|
||
update["violence_2"]='on';
|
||
update["violence_1"]='on';
|
||
}
|
||
if (_helplessness_adapted){
|
||
update["helplessness_adapted"]=1;
|
||
update["helplessness_2"]='on';
|
||
update["helplessness_1"]='on';
|
||
}
|
||
|
||
update['sanity_points_old']=v['sanity_points'];
|
||
update['breaking_point_old']=v['breaking_point'];
|
||
|
||
console.log(`%c update`, 'color: green; font-weight:bold');
|
||
|
||
setAttrs(update, //Update attributes
|
||
{silent:true}, // will not trigger sheet workers
|
||
versioning(codeversion)); // call versioning again
|
||
});
|
||
|
||
};
|
||
// UPDATE TO VERSION 2.0
|
||
const version_200_201 = () => {
|
||
let codeversion=2.01;
|
||
let update1={};
|
||
console.log('verion:',codeversion);
|
||
update1['version']=codeversion;
|
||
|
||
// UPDATE NAMES FOR SPECIAL TRAINING AND WEAPONS AND TRIGGER TEST
|
||
const _sectionDetails = [
|
||
{section:'repeating_special', fields: ['name','special_training','skill_or_stat_used','skill_span',]},
|
||
{section:'repeating_weapons', fields: ['name','weapons','skill_percent','skill_span','ammo','hasammo','ammo_total','lethality_percent']},
|
||
{section:'repeating_bonds', fields: ['flag','setScore','score','score_old']}];
|
||
_sectionDetails.forEach(_group => {
|
||
const section = _group.section;
|
||
const fields = _group.fields;
|
||
getSectionIDs(section, (ids)=>{
|
||
console.log('in getSectionIDs section',section);
|
||
console.log('in getSectionIDs ids',ids);
|
||
const repfields=[];
|
||
ids.forEach(id => {
|
||
fields.forEach(field => {
|
||
repfields.push(`repeating_special_${id}_${field}`);
|
||
});
|
||
});
|
||
getAttrs(repfields,(values) => {
|
||
console.info('fullarray',values);
|
||
var update = {};
|
||
|
||
ids.forEach(id => {
|
||
const repsecid= `repeating_${section}_${id}_`;
|
||
|
||
/// bond update
|
||
if (values.hasOwnProperty(`${repsecid}flag`)){
|
||
update[`${repsecid}setScore`]=1;
|
||
}
|
||
if (values[`${repsecid}score`]!==''){
|
||
update[`${repsecid}score_old`]=values[`${repsecid}score`];
|
||
}
|
||
|
||
if (values.hasOwnProperty(`${repsecid}lethality_percent`)){
|
||
if (values[`${repsecid}lethality_percent`]===''){
|
||
const number=setMinMax(values[`${repsecid}lethality_percent`]);
|
||
update[`${repsecid}lethality_percent`]=number;
|
||
update[`${repsecid}lethality_percent`]='';
|
||
console.log(`%c update name ${repsecid}lethality_percent to empty`, 'color: green; font-weight:bold');
|
||
}
|
||
}
|
||
|
||
if (values.hasOwnProperty(`${repsecid}special_training`)){
|
||
if (values[`${repsecid}special_training`]!==''){
|
||
update[`${repsecid}name`]=values[`${repsecid}special_training`];
|
||
update[`${repsecid}special_training`]='';
|
||
console.log(`%c update name ${repsecid}special_training to ${repsecid}name`, 'color: green; font-weight:bold');
|
||
|
||
}
|
||
};
|
||
if (values.hasOwnProperty(`${repsecid}weapons`)){
|
||
if (values[`${repsecid}weapons`]!==''){
|
||
update[`${repsecid}name`]=values[`${repsecid}weapons`];
|
||
update[`${repsecid}weapons`]='';
|
||
console.log(`%c update name ${repsecid}weapons to ${repsecid}name`, 'color: green; font-weight:bold');
|
||
}
|
||
};
|
||
if (values.hasOwnProperty(`${repsecid}skill_or_stat_used`)){
|
||
const value_stat=setMinMax(values[`${repsecid}skill_or_stat_used`]) ;
|
||
update[`${repsecid}skill_span`]=value_stat;
|
||
update[`${repsecid}skill_or_stat_used`]=value_stat;
|
||
console.log(`%c update skill_span for ${repsecid}`, 'color: green; font-weight:bold');
|
||
};
|
||
|
||
if (values.hasOwnProperty(`${repsecid}skill_percent`)){
|
||
const value_skill = setMinMax(values[`${repsecid}skill_percent`]);
|
||
update[`${repsecid}skill_span`]=value_skill;
|
||
update[`${repsecid}skill_percent`]=value_skill;
|
||
console.log(`%c update skill_span for ${repsecid}`, 'color: green; font-weight:bold');
|
||
};
|
||
|
||
if (values.hasOwnProperty(`${repsecid}ammo`)){
|
||
const value_ammo = Math.max(parseInt(values[`${repsecid}ammo`],10) || 0,0) ;
|
||
if (value_ammo>0){
|
||
update[`${repsecid}ammo_total`]=value_ammo;
|
||
update[`${repsecid}hasammo`]=1;
|
||
update[`${repsecid}ammo`]=value_ammo;
|
||
} else {
|
||
update[`${repsecid}hasammo`]=0;
|
||
update[`${repsecid}ammo_total`]='';
|
||
update[`${repsecid}ammo`]='';
|
||
}
|
||
console.log(`%c update ammo for ${repsecid}: ammo_total=${update[`${repsecid}ammo_total`]} hasammo=${update[`${repsecid}hasammo`]}`, 'color: green; font-weight:bold');
|
||
}
|
||
|
||
});
|
||
|
||
|
||
console.log(`%c update`, 'color: green; font-weight:bold');
|
||
console.info('versioning',update1);
|
||
setAttrs(update1, //Update attributes
|
||
{silent:true}, // will not trigger sheet workers
|
||
versioning(codeversion)); // call versioning again
|
||
|
||
});
|
||
|
||
});
|
||
});
|
||
};
|
||
|
||
|
||
|
||
const BondButtonColor= (bondvalue) => {
|
||
const score = parseInt(bondvalue)||0;
|
||
const color = (score > 0) ? 'on' : 'off';
|
||
return color;
|
||
};
|
||
|
||
const changeBondButtonColorOnOpen = () => {
|
||
getSectionIDs(`repeating_bonds`, (idarray) => {
|
||
const allbonds=idarray.map(id =>`repeating_bonds_${id}_score`);
|
||
getAttrs(allbonds, (value) => {
|
||
const update={};
|
||
Object.entries(value).forEach(([key, value]) => {
|
||
const id = key.split('_')[2];
|
||
const score = parseInt(value)||0;
|
||
update['repeating_bonds_'+id+'_color'] = BondButtonColor(score);
|
||
});
|
||
setAttrs(update, {silent:true}, () => {
|
||
console.log('Bond color updated');
|
||
|
||
});
|
||
});
|
||
});
|
||
};
|
||
|
||
// update the rollDamage dice for the hidden buttons in the repeating sections
|
||
// it should only be used at creation of the field on in versioning
|
||
// since characterID and repeatingSectionID does not change
|
||
// if it does, using transmogrifer, I might have to add a reset button to reset the rolls
|
||
|
||
const updateRepeatingDamageRolls = (update,character_id,attrPrefix,nameRoll,hasCritical=false) => {
|
||
const fullAttrPrefix = (attrPrefix==='') ? nameRoll : `${attrPrefix}_${nameRoll}`;
|
||
|
||
const dicePrefix=`%{${character_id}|${fullAttrPrefix}`;
|
||
|
||
|
||
update[`${fullAttrPrefix}_action`] = `${dicePrefix}-action}`;
|
||
if (hasCritical) {
|
||
update[`${fullAttrPrefix}_critical_action`] = `${dicePrefix}_critical-action}`;
|
||
}
|
||
};
|
||
|
||
const updateRepeatingRolls = (section, attrName, id, character_id) => {
|
||
const update = {};
|
||
const attrPrefix = `repeating_${section}_${id}`;
|
||
const rep_attrName = `${attrPrefix}_${attrName}`;
|
||
const dicePrefix = `%{${character_id}|${rep_attrName}`;
|
||
update[`${rep_attrName}_action`] = `${dicePrefix}-action}`;
|
||
update[`${rep_attrName}_r`] = id;
|
||
|
||
update[`${rep_attrName}_initialized`] = `1`;
|
||
|
||
if (section === 'weapons') {
|
||
arrays['_weapon_hidden_buttons'].forEach((buttonName) => {
|
||
updateRepeatingDamageRolls(update,character_id,attrPrefix,buttonName,true);
|
||
});
|
||
}
|
||
if (section === 'rituals') {
|
||
arrays['_ritual_hidden_buttons'].forEach((buttonName) => {
|
||
updateRepeatingDamageRolls(update,character_id,attrPrefix,buttonName);
|
||
});
|
||
}
|
||
return update;
|
||
};
|
||
|
||
const updateAllRollsOnOpen = () => {
|
||
const update = {};
|
||
getAttrs(['character_id'], (values) => {
|
||
const character_id = values.character_id;
|
||
updateRollsOnOpen(update,character_id);
|
||
updateRepeatingRollsonOpen(update,character_id);
|
||
});
|
||
};
|
||
|
||
const updateRollsOnOpen= (update, character_id) => {
|
||
console.log('===update rolls===');
|
||
const fullrolls = _allrolls;
|
||
fullrolls.forEach(roll => {
|
||
const dicePrefix = `%{${character_id}|${roll}`;
|
||
update[`${roll}_action`] = `${dicePrefix}-action}`;
|
||
|
||
if (roll.includes('sanity_loss')) {
|
||
updateRepeatingDamageRolls(update,character_id,'',roll+'_success');
|
||
updateRepeatingDamageRolls(update,character_id,'',roll+'_failure');
|
||
|
||
}
|
||
});
|
||
};
|
||
|
||
const updateRepeatingRollsonOpen = (update,character_id) => {
|
||
Object.entries(_repeating_sections).forEach(([attrName,section])=> {
|
||
getSectionIDs(section, function(idarray) {
|
||
idarray.forEach(id => {
|
||
Object.assign(update, updateRepeatingRolls(section, attrName, id, character_id));
|
||
});
|
||
setAttrs(update, {silent:true}, () => {
|
||
console.log('Repeating and Normal Rolls updated');
|
||
|
||
});
|
||
});
|
||
});
|
||
};
|
||
|
||
|
||
|
||
|
||
const changeRepeatingRolls = (section,attrName,id) => {
|
||
getAttrs(['character_id',`repeating_${section}_${id}_initialized`], (values) => {
|
||
const character_id = values.character_id;
|
||
const isInitialized = parseInt(values[`repeating_${section}_${id}_initialized`],10) || 0;
|
||
const update = {};
|
||
|
||
if (isInitialized===0) {
|
||
console.log('===update rolls===');
|
||
Object.assign(update, updateRepeatingRolls(section, attrName, id, character_id));
|
||
} else {
|
||
console.log('===no need to update===');
|
||
}
|
||
|
||
setAttrs(update, {silent:true}, () => {
|
||
|
||
});
|
||
});
|
||
};
|
||
|
||
|
||
const rollwithmodifiers = (rollString,rollName,queryModifier,additionalParameters) => {
|
||
const attr_to_get=arrays['_derived_modifiers']
|
||
if (additionalParameters.hasOwnProperty('editable_name')) {
|
||
attr_to_get.push(additionalParameters['editable_name']);
|
||
}
|
||
getAttrs(attr_to_get, (values) => {
|
||
|
||
const wp_mod=check_for_wp_modifiers(values,rollName);
|
||
|
||
rollString += `{{rating=[[@{${rollName}}]]}}`;
|
||
rollString += `{{zero_willpower=[[${wp_mod.zero_willpower}]]}}`;
|
||
rollString += `{{low_willpower=[[${wp_mod.low_willpower}]]}}} `;
|
||
rollString += `{{modifier=[[${queryModifier}]]}}`;
|
||
rollString += `{{isCritical=[[0]]}} {{isSuccess=[[0]]}}`;
|
||
|
||
rollString += get_header_skills(values,additionalParameters);
|
||
|
||
rollFail=`${rollName}_fail`;
|
||
rollSkillAndStats(rollString,rollName,isSkillName(rollName));
|
||
|
||
});
|
||
|
||
};
|
||
|
||
const rollAttacks = (rollValue,options) => {
|
||
startRoll(rollValue, (results) => {
|
||
const dice=results.results.dice.result;
|
||
options.modifier=results.results.modifier.result;
|
||
const modifier=check_weapon_modifiers(options);
|
||
const rating=correct_rating(options.rating,modifier);
|
||
|
||
const outcome=check_success(dice,rating,options.isSkill);
|
||
|
||
newroll={
|
||
rating: rating,
|
||
modifier: modifier,
|
||
isSuccess: outcome.isSuccess,
|
||
isCritical: outcome.isCritical,
|
||
zero_willpower: options.zero_willpower,
|
||
low_willpower: options.low_willpower,
|
||
advanced_weapons: options.hasAdvancedWeapons
|
||
};
|
||
|
||
finishRoll(results.rollId,newroll);
|
||
});
|
||
};
|
||
|
||
|
||
const rollSkillAndStats=(rollValue,rollName,isSkill) => {
|
||
// Input:
|
||
// rollValue is the string to roll the dice
|
||
// rollName is the name of the skill or stat
|
||
// rollFail used only for stats to check for failure
|
||
// limit_to_99 is the flag to limit the upper bound rating to 99% (0 for inhuman stats) [0,1]
|
||
startRoll(rollValue, (results)=> {
|
||
// low and zero willpower flags only used if the setting is on
|
||
const zero_willpower=results.results.zero_willpower.result;
|
||
const low_willpower=results.results.low_willpower.result;
|
||
|
||
const _modifier= correct_modifier(results.results.modifier.result,low_willpower);
|
||
const _rating = correct_rating(results.results.rating.result,_modifier,isSkill);
|
||
const dice=results.results.dice.result;
|
||
|
||
var newroll={};
|
||
const outcome=check_success(dice,_rating,isSkill);
|
||
newroll={
|
||
rating: _rating,
|
||
modifier: _modifier,
|
||
isSuccess: outcome.isSuccess,
|
||
isCritical: outcome.isCritical,
|
||
zero_willpower: zero_willpower,
|
||
low_willpower: low_willpower
|
||
};
|
||
finishRoll(results.rollId,newroll);
|
||
|
||
update=check_for_failed_skill(rollName,outcome.isSuccess,isSkill);
|
||
setAttrs(update,{silent:false}, () => {
|
||
|
||
});
|
||
|
||
});
|
||
};
|
||
|
||
const rollBonds=(rollValue,_value,_names,_parameters) => {
|
||
|
||
startRoll(`${rollValue}`, (results)=> {
|
||
|
||
|
||
const dice=results.results.dice.result;
|
||
const local_wp=Math.max(0,parseInt(results.results.local_wp.result)-dice);
|
||
var score=Math.max(0,parseInt(results.results.score.result)-dice);
|
||
const original_wp=parseInt(results.results.local_wp.result) || 0;
|
||
|
||
const zerowp=local_wp==0 ? 1 : 0;
|
||
|
||
var update={};
|
||
|
||
update[_names['local_wp_points']]=local_wp;
|
||
update[`willpower_points`]=local_wp;
|
||
if (parseInt(results.results.local_wp.result)||0 !=0){
|
||
update[_names[`score`]]=score;
|
||
}else{
|
||
score=parseInt(results.results.score.result) || 0;
|
||
}
|
||
update[_names[`color`]]=BondButtonColor(score);
|
||
|
||
newroll={
|
||
dice: Math.min(dice,original_wp),
|
||
local_wp: local_wp,
|
||
score: score,
|
||
zerowp: zerowp
|
||
};
|
||
|
||
finishRoll(results.rollId,newroll);
|
||
setAttrs(update,{silent:false}, () => {
|
||
|
||
});
|
||
});
|
||
};
|
||
|
||
const clicked_repeating_rituals_cost = (parameters,names) => {
|
||
getAttrs(parameters, (values) => {
|
||
const ritual_type = names['ritual_type'];
|
||
// cost of the ritual
|
||
const other_costs={};
|
||
getOtherCosts(other_costs,values,names,RitualCosts);
|
||
getOtherCosts(other_costs,values,names,CurrentValues);
|
||
|
||
|
||
if(ritual_type==='pay_cost'){
|
||
paythecost(other_costs['sanity_loss_failure'],other_costs);
|
||
}
|
||
|
||
if(ritual_type==='force_connection'){
|
||
forceconnection(other_costs['sanity_loss_failure'],other_costs);
|
||
}
|
||
|
||
if(ritual_type==='accept_failure'){
|
||
acceptfailure(other_costs['sanity_loss_success'],other_costs);
|
||
}
|
||
|
||
});
|
||
};
|
||
|
||
const setDamageParametersAndInputNames=(id,attrName, _parameters, _input_names) => {
|
||
_input_names[`name`] = `repeating_weapons_${id}_name`;
|
||
_input_names[`repsecid`] = `repeating_weapons_${id}`;
|
||
_parameters.push(_input_names[`name`]);
|
||
|
||
_input_names[`hasammo`] = `repeating_weapons_${id}_hasammo`;
|
||
_parameters.push(_input_names[`hasammo`]);
|
||
var flagCritical=false;
|
||
flagCritical= flagCritical || (attrName==='damage_critical');
|
||
flagCritical= flagCritical || (attrName==='double_barrel_critical');
|
||
flagCritical= flagCritical || (attrName==='lethality_percent_critical');
|
||
flagCritical= flagCritical || (attrName==='selective_fire_critical');
|
||
|
||
_input_names[`isCritical`] = (flagCritical==true) ? 1 : 0;
|
||
const isCritical=_input_names[`isCritical`];
|
||
|
||
if (attrName==='damage' || attrName==='damage_critical') {
|
||
|
||
if (isCritical==1){
|
||
_input_names[`header`] = `damage (×2)`;
|
||
}else{
|
||
_input_names[`header`] = `damage`;
|
||
}
|
||
_input_names[`damage`] = `repeating_weapons_${id}_damage`;
|
||
_parameters.push(_input_names[`damage`]);
|
||
_input_names[`damage_type`]='damage';
|
||
}else if (attrName==='double_barrel' || attrName==='double_barrel_critical') {
|
||
|
||
_input_names[`damage_type`]='damage';
|
||
|
||
if (isCritical==1){
|
||
_input_names[`header`] = `damage (×2)`;
|
||
}else{
|
||
_input_names[`header`] = `damage`;
|
||
}
|
||
|
||
_input_names[`damage`] = `repeating_weapons_${id}_double_barrel`;
|
||
_parameters.push(_input_names[`damage`]);
|
||
}else if (attrName==='lethality_percent' || attrName==='lethality_percent_critical') {
|
||
|
||
_input_names[`damage_type`]='lethality_percent';
|
||
if (isCritical==1){
|
||
_input_names[`header`] = `lethality (×2)`;
|
||
}else{
|
||
_input_names[`header`] = `lethality`;
|
||
}
|
||
_input_names[`damage`] = `repeating_weapons_${id}_lethality_percent`;
|
||
_parameters.push(_input_names[`damage`]);
|
||
}else if (attrName==='selective_fire' || attrName==='selective_fire_critical') {
|
||
|
||
if (isCritical==1){
|
||
_input_names[`header`] = `_tmp_header_ (×2)`;
|
||
}else{
|
||
_input_names[`header`] = `_tmp_header_`;
|
||
}
|
||
|
||
_input_names[`damage_type`]='lethality_percent';
|
||
_input_names[`damage`] = `repeating_weapons_${id}_selfire_lethality_percent`;
|
||
_parameters.push(_input_names[`damage`]);
|
||
_input_names[`selfire_type`] = `repeating_weapons_${id}_selfire_type`;
|
||
_parameters.push(_input_names[`selfire_type`]);
|
||
}
|
||
|
||
_input_names[`ammo`] = `repeating_weapons_${id}_ammo`;
|
||
_parameters.push(_input_names[`ammo`]);
|
||
_input_names[`track_bullets`] = `track_bullets`;
|
||
_parameters.push(_input_names[`track_bullets`]);
|
||
};
|
||
const addAttackHeader=(values,names) => {
|
||
if (names.hasOwnProperty('header')){
|
||
return `{{header=^{${realDmgHeader(values,names)}}}}`;
|
||
}
|
||
return '';
|
||
};
|
||
|
||
const realDmgHeader=(values,names) => {
|
||
if (names.hasOwnProperty)
|
||
var header=names['header'];
|
||
if (header.includes('_tmp_header_')){ // I can use it for other things
|
||
//if (names['rollName']==='selective_fire'){
|
||
return header.replace('_tmp_header_',values[names[`selfire_type`]]);
|
||
//}
|
||
}
|
||
return header;
|
||
};
|
||
|
||
const prefixDamageRoll = (type_prefix) => {
|
||
if (type_prefix==='damage'){ return prefix_damage_roll;}
|
||
if (type_prefix==='heal'){ return prefix_health_roll;}
|
||
if (type_prefix==='attack'){ return prefix_attack_roll;}
|
||
};
|
||
|
||
const clicked_repeating_damages = (parameters,names,type_prefix='damage') => {
|
||
getAttrs(parameters, (values) => {
|
||
const isCritical=names['isCritical'];
|
||
const track_bullets=values[names['track_bullets']]==='active' ? 1 : 0;
|
||
const hasammo=values[names['hasammo']]==='active' ? 1 : 0;
|
||
const trackAmmo=track_bullets==1 && hasammo==1 ? 1 : 0;
|
||
const currentAmmo=Math.max(0,parseInt(values[names['ammo']]) || 0);
|
||
const selfire_type=(values[names['selfire_type']]) || '';
|
||
const used_ammo=getUsedAmmo(selfire_type);
|
||
|
||
const damage_type=names['damage_type'];
|
||
var damage=values[names['damage']];
|
||
|
||
var rollString=``;
|
||
|
||
rollString += prefixDamageRoll(type_prefix);
|
||
rollString += addAttackHeader(values,names)
|
||
|
||
|
||
rollString += addTargetStat(values,names,type_prefix);
|
||
|
||
|
||
|
||
var damageString='';
|
||
|
||
if (damage_type === 'damage') {
|
||
if (isCritical==1){
|
||
damageString=`{{damage=[[2*${damage}]]}}`;
|
||
}else{
|
||
damageString=`{{damage=[[${damage}]]}}`;
|
||
}
|
||
|
||
rollString = `${rollString} ${damageString}`;
|
||
|
||
rollString = check_track_ammo(rollString,trackAmmo,currentAmmo,used_ammo)
|
||
}else if (damage_type === 'lethality_percent') {
|
||
if (isCritical==1){
|
||
damage=2*damage;
|
||
}
|
||
damageString=`{{lethality_percent=[[${damage}]]}}`;
|
||
|
||
rollString = `${rollString} ${damageString}`;
|
||
rollString = `${rollString} {{roll=[[1d100]]}}`;
|
||
|
||
rollString = check_track_ammo(rollString,trackAmmo,currentAmmo,used_ammo)
|
||
}
|
||
rollString = `${rollString} {{isCritical=[[${isCritical}]]}}`;
|
||
|
||
startRoll(rollString, (results) => {
|
||
|
||
const newroll = getRollDamage(results,trackAmmo,damage_type,isCritical);
|
||
|
||
newroll['isCritical']=isCritical;
|
||
newroll['trackbullets']=trackAmmo;
|
||
finishRoll(results.rollId,newroll);
|
||
if (trackAmmo==1){
|
||
const update={};
|
||
update[names['ammo']]=newroll['current_ammo'];
|
||
setAttrs(update, () => {
|
||
|
||
});
|
||
}
|
||
});
|
||
});
|
||
};
|
||
|
||
|
||
const setDamageRitualParametersAndInputNames=(id, _parameters, _input_names) => {
|
||
_input_names[`name`] = `repeating_rituals_${id}_name`;
|
||
_input_names[`isCritical`]=0;
|
||
|
||
const damage_type=_input_names[`damage_type`];
|
||
const attack_or_heal = _input_names[`attack_or_heal`];
|
||
const repsecid=_input_names[`repsecid`]; //
|
||
|
||
_parameters.push(_input_names[`name`]);
|
||
|
||
var prefix_names=`${repsecid}_${attack_or_heal}`;
|
||
|
||
_input_names[`repsecid`] = prefix_names;
|
||
|
||
_input_names[`damage`]=`${prefix_names}_${damage_type}_amount`;
|
||
|
||
_parameters.push(_input_names[`damage`]);
|
||
|
||
_input_names[`target_stat`] = `${prefix_names}_target_stat`;
|
||
_parameters.push(_input_names[`target_stat`]);
|
||
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
const getRollDamage= (results,trackammo,damage_type,critical) =>{
|
||
const newroll={};
|
||
if (trackammo==1){
|
||
const trackbullets=[[1]];
|
||
newroll['trackbullets']=trackbullets;
|
||
const used_ammo=results.results.used_ammo.result;
|
||
const current_ammo=results.results.current_ammo.result;
|
||
const expended_ammo= current_ammo - used_ammo;
|
||
|
||
newroll['current_ammo']= expended_ammo;
|
||
}
|
||
if (damage_type==='damage'){
|
||
const damage=results.results.damage.result;
|
||
newroll['damage']=damage;
|
||
}
|
||
if (damage_type==='lethality_percent'){
|
||
const lethality_percent=results.results.lethality_percent.result;
|
||
const roll=results.results.roll.result;
|
||
var computed_lethality_percent=lethality_percent;
|
||
var computed_roll=DeltaGreenLethalityFail(roll);
|
||
|
||
|
||
|
||
if (critical==1) {
|
||
computed_lethality_percent=lethality_percent*2;
|
||
computed_roll= computed_roll*2;
|
||
}
|
||
|
||
newroll['roll']=computed_roll;
|
||
newroll['lethality_percent']=computed_lethality_percent;
|
||
}
|
||
return newroll;
|
||
};
|
||
|
||
const clicked_repeating_weapons= (parameters,names,queryModifier) => {
|
||
getAttrs(parameters, (values) => {
|
||
// used to set the roll string
|
||
const character_id=values['character_id'];
|
||
const repsecid= names['repsecid'];
|
||
|
||
const skillname=values[names['name']];
|
||
const skillrank=setMinMax(values[names['rank']]);
|
||
const trackAmmo= need_to_track_ammo(values,names);
|
||
const current_ammo=Math.max(0,parseInt(values[names['ammo']]) || 0);
|
||
|
||
const hasAdvancedWeapons=values[names['advanced_weapons']] === 'active' ? 1 : 0;
|
||
const isShotgun = values[names['shotgun']] === 'active' ? 1 : 0;
|
||
const hasDoubleBarrel = values[names['hasDoubleBarrel']] === 'active' ? 1 : 0;
|
||
const hasSelectiveFire = values[names['selfire']] === 'active' ? 1 : 0;
|
||
const hasAccessories = values[names['accessories']] === 'active' ? 1 : 0;
|
||
const hasBlastRadius = values[names['blast_radius']] === 'active' ? 1 : 0;
|
||
const isAiming = values[names['aiming']] === 'active' ? 1 : 0;
|
||
|
||
const lethality_percent=setMinMax(values[names['lethality_percent']]);
|
||
const damage= parseRoll(values[names['damage']]);
|
||
const armor_piercing=Math.min(parseInt(values[names['armor_piercing']],10)||0,0);
|
||
const base_range=values[names['range']];
|
||
const kill_radius=values[names['kill_radius']];
|
||
|
||
|
||
var _options={};
|
||
_options['rating']=skillrank;
|
||
_options['hasLethality']= lethality_percent>0 ? 1 : 0;
|
||
_options['hasDamage']= damage !=0 ? 1 : 0;
|
||
_options['isAiming']= isAiming;
|
||
if (_options['hasDamage']===1) {_options['damage']=damage;}
|
||
if (_options['hasLethality']===1) {_options['lethality_percent']=lethality_percent;}
|
||
if (trackAmmo==1) {_options['trackAmmo']=1;_options['current_ammo']=current_ammo;}
|
||
if (hasAdvancedWeapons===1) {_options['hasAdvancedWeapons']=1;}
|
||
if (isShotgun===1) {_options['isShotgun']=1;}
|
||
if (hasDoubleBarrel===1) {_options['hasDoubleBarrel']=1;_options['double_barrel']=parseRoll(values[names['double_barrel']]);}
|
||
if (hasSelectiveFire===1) {
|
||
_options['hasSelectiveFire']=1;
|
||
_options['selfire_lethality_percent']=setMinMax(values[names['selfire_lethality_percent']]);
|
||
_options['selfire_type']=values[names['selfire_type']];}
|
||
if (hasAccessories===1) {
|
||
_options['hasAccessories']=1;
|
||
_options['accessory_modifier']=values[names['accessory_modifier']];
|
||
_options['accessory_name']=values[names['accessory_name']];
|
||
}
|
||
if (hasBlastRadius===1) {_options['hasBlastRadius']=1;}
|
||
|
||
const wp_mod=check_for_wp_modifiers(values);
|
||
_options['wp_mod']=wp_mod
|
||
const rollString=`${prefix_skill_roll} {{header=${skillname}}} {{subheader=${skillrank}}}`;
|
||
|
||
var rollValue = `${rollString} {{rating=[[${skillrank}]]}} {{modifier=[[${queryModifier}]]}} `;
|
||
rollValue += ` {{low_willpower=[[${wp_mod.low_willpower}]]}} {{zero_willpower=[[${wp_mod.zero_willpower}]]}}`;
|
||
rollValue += ` {{isCritical=[[0]]}} {{isSuccess=[[0]]}}`;
|
||
rollValue += ` {{advanced_weapons=[[${hasAdvancedWeapons}]]}}`;
|
||
|
||
if (base_range != "") {rollValue += '{{base_range=' + base_range + '}}';}
|
||
if (armor_piercing !=0) {rollValue += '{{armor_piercing=' + armor_piercing + '}}';}
|
||
if (kill_radius != "") {rollValue += '{{kill_radius=' + kill_radius + '}}';}
|
||
|
||
const options = setWeaponOptions(_options)
|
||
rollValue += setAdvancedWeaponsString(options,character_id,repsecid);
|
||
//********************************************
|
||
rollAttacks(rollValue,options);
|
||
|
||
});
|
||
};
|
||
|
||
const clicked_repeating_actions = (section,parameters,names,queryModifier) => {
|
||
|
||
initializeRolls(); // Initialize the rolls if flag is not set
|
||
if (section==='weapons'){
|
||
clicked_repeating_weapons(parameters,names,queryModifier);
|
||
}
|
||
if (section==='bonds'){
|
||
clicked_repeating_bonds(parameters,names,queryModifier);
|
||
}
|
||
if (section==='special'){
|
||
clicked_repeating_skills(parameters,names,queryModifier,0);
|
||
}
|
||
if (section==='skills'){
|
||
clicked_repeating_skills(parameters,names,queryModifier,1);
|
||
}
|
||
if (section==='rituals'){
|
||
clicked_repeating_rituals(parameters,names,queryModifier);
|
||
}
|
||
}
|
||
|
||
const clicked_repeating_skills = (parameters,names,queryModifier,isRepSkill) => {
|
||
getAttrs(parameters, (values) => {
|
||
const skillname=values[names['name']];
|
||
const skillrank=parseInt(values[names['rank']]) || 0;
|
||
|
||
const rollString=`${prefix_skill_roll} {{header=${skillname}}} {{subheader=${skillrank}}} `;
|
||
|
||
const wp_modifiers=check_for_wp_modifiers(values);
|
||
|
||
const _zero_willpower = wp_modifiers.zero_willpower;
|
||
const _low_willpower = wp_modifiers.low_willpower;
|
||
const rating=parseInt(values[parameters[names['rank']]]) || 0;
|
||
var rollValue = `${rollString} {{rating=[[${skillrank}]]}} {{zero_willpower=[[${_zero_willpower}]]}} {{low_willpower=[[${_low_willpower}]]}}} {{modifier=[[${queryModifier}]]}} {{isCritical=[[0]]}} {{isSuccess=[[0]]}}`;
|
||
|
||
if(_zero_willpower!='[[1]]') {
|
||
rollValue = `${rollValue}`;
|
||
}
|
||
|
||
attrName=names['repsecid'];
|
||
rollSkillAndStats(rollValue,attrName,isRepSkill);
|
||
|
||
});
|
||
|
||
};
|
||
|
||
|
||
const clicked_repeating_bonds = (parameters,names) => {
|
||
getAttrs(parameters, (values) => {
|
||
const bondname=values[names['name']];
|
||
const bondscore=parseInt(values[names['score']]) || 0;
|
||
const local_wp_points=parseInt(values[names['local_wp_points']]) || 0;
|
||
const local_sanity_points=parseInt(values[names['local_sanity_points']]) || 0;
|
||
const character_id=values['character_id'];
|
||
|
||
|
||
if (bondscore<=0) {return;} // No need to roll if the bond is already broken
|
||
|
||
|
||
const rollString=`${prefix_bond_roll} {{header=${bondname}}} {{subheader=${bondscore}}} `;
|
||
|
||
|
||
var rollValue = `${rollString} {{zerowp=[[0]]}} {{score=[[${bondscore}]]}} {{local_wp=[[${local_wp_points}]]}} {{local_sanity=[[${local_sanity_points}}]]}} {{repress= [^{repress}](~${character_id}|sanity_points)}}`;
|
||
rollValue=`${rollValue} {{projection=1}} {{repression=1}}`;
|
||
|
||
rollBonds(rollValue,values,names,parameters);
|
||
|
||
});
|
||
|
||
};
|
||
|
||
|
||
// Important functions
|
||
|
||
|
||
const setCommonParametersAndInputNames=(repsecid, _parameters, _input_names) => {
|
||
_input_names[`name`] = `${repsecid}_name`;
|
||
_input_names[`repsecid`] = `${repsecid}`;
|
||
_parameters.push(_input_names[`name`]);
|
||
_input_names[`willpower_points`] = `willpower_points`;
|
||
_parameters.push(`willpower_points`);
|
||
_input_names[`sanity_points`] = `sanity_points`;
|
||
_parameters.push(`sanity_points`);
|
||
_input_names[`low_willpower`] = `low_willpower`;
|
||
_parameters.push(`low_willpower`);
|
||
_input_names[`zero_willpower`] = `zero_willpower`;
|
||
_parameters.push(`zero_willpower`);
|
||
_input_names[`character_id`] = `character_id`;
|
||
_parameters.push(`character_id`);
|
||
|
||
}
|
||
|
||
const setSkillsParametersAndInputNames=(repsecid, _parameters, _input_names) => {
|
||
_input_names[`rank`] = `${repsecid}_rank`;
|
||
_input_names[`fail`] = `${repsecid}_fail`;
|
||
_parameters.push(_input_names[`rank`]);
|
||
_parameters.push(_input_names[`fail`]);
|
||
}
|
||
|
||
const setBondsParametersAndInputNames=(repsecid, _parameters, _input_names) => {
|
||
_input_names[`local_wp_points`] = `willpower_points`;
|
||
_input_names[`local_sanity_points`] = `sanity_points`;
|
||
|
||
_input_names[`score`] = `${repsecid}_score`;
|
||
_input_names[`color`] = `${repsecid}_color`;
|
||
_parameters.push(_input_names[`local_wp_points`]);
|
||
_parameters.push(_input_names[`local_sanity_points`]);
|
||
_parameters.push(_input_names[`score`]);
|
||
_parameters.push(_input_names[`color`]);
|
||
};
|
||
|
||
const setSpecialParametersAndInputNames=(repsecid, _parameters, _input_names) => {
|
||
_input_names[`rank`] = `${repsecid}_skill_span`;
|
||
_parameters.push(_input_names[`rank`]);
|
||
};
|
||
|
||
const setGeneralWeaponParametersAndInputNames=(repsecid, _parameters, _input_names)=>{
|
||
_input_names[`rank`] = `${repsecid}_skill_span`;
|
||
_parameters.push(_input_names[`rank`]);
|
||
_input_names[`range`] = `${repsecid}_base_range`;
|
||
_parameters.push(_input_names[`range`]);
|
||
_input_names[`damage`] = `${repsecid}_damage`;
|
||
// write the push in function of the input name
|
||
_parameters.push(_input_names[`damage`]);
|
||
_input_names[`armor_piercing`] = `${repsecid}_armor_piercing`;
|
||
_parameters.push(_input_names[`armor_piercing`]);
|
||
_input_names[`ammo`] = `${repsecid}_ammo`;
|
||
_parameters.push(_input_names[`ammo`]);
|
||
_input_names[`hasammo`] = `${repsecid}_hasammo`;
|
||
_parameters.push(_input_names[`hasammo`]);
|
||
|
||
_input_names[`lethality_percent`]=`${repsecid}_lethality_percent`;
|
||
_parameters.push(_input_names[`lethality_percent`]);
|
||
_input_names[`kill_radius`]=`${repsecid}_kill_radius`;
|
||
_parameters.push(_input_names[`kill_radius`]);
|
||
};
|
||
|
||
const setShotgunParametersAndInputNames=(repsecid, _parameters, _input_names) => {
|
||
_input_names[`shotgun`] = `${repsecid}_shotgun`;
|
||
_parameters.push(_input_names[`shotgun`]);
|
||
_input_names[`hasDoubleBarrel`] = `${repsecid}_hasDoubleBarrel`;
|
||
_parameters.push(_input_names[`hasDoubleBarrel`]);
|
||
_input_names[`double_barrel`] = `${repsecid}_double_barrel`;
|
||
_parameters.push(_input_names[`double_barrel`]);
|
||
};
|
||
|
||
const setAccessoriesParametersAndInputNames=(repsecid, _parameters, _input_names) => {
|
||
_input_names[`accessories`]=`${repsecid}_hasAccessories`;
|
||
_parameters.push(_input_names[`accessories`]);
|
||
_input_names[`accessory_name`]=`${repsecid}_accessory_name`;
|
||
_parameters.push(_input_names[`accessory_name`]);
|
||
_input_names[`accessory_modifier`]=`${repsecid}_accessory_modifier`;
|
||
_parameters.push(_input_names[`accessory_modifier`]);
|
||
};
|
||
|
||
const setBlastRadiusParametersAndInputNames=(repsecid, _parameters, _input_names) => {
|
||
_input_names[`blast_radius`]=`${repsecid}_blast_radius`;
|
||
_parameters.push(_input_names[`blast_radius`]);
|
||
};
|
||
|
||
const setSelectiveFireParametersAndInputNames=(repsecid, _parameters, _input_names) => {
|
||
_input_names[`selfire`]=`${repsecid}_selfire`;
|
||
_parameters.push(_input_names[`selfire`]);
|
||
_input_names[`selfire_lethality_percent`]=`${repsecid}_selfire_lethality_percent`;
|
||
_parameters.push(_input_names[`selfire_lethality_percent`]);
|
||
_input_names[`selfire_type`]=`${repsecid}_selfire_type`;
|
||
_parameters.push(_input_names[`selfire_type`]);
|
||
};
|
||
|
||
const setAdvancedWeaponParametersAndInputNames=(repsecid, _parameters, _input_names) => {
|
||
|
||
_input_names[`advanced_weapons`]=`advanced_weapons`;
|
||
_parameters.push(_input_names[`advanced_weapons`]);
|
||
|
||
setShotgunParametersAndInputNames(repsecid, _parameters, _input_names);
|
||
setAccessoriesParametersAndInputNames(repsecid, _parameters, _input_names);
|
||
setBlastRadiusParametersAndInputNames(repsecid, _parameters, _input_names);
|
||
setSelectiveFireParametersAndInputNames(repsecid, _parameters, _input_names);
|
||
|
||
}
|
||
|
||
const setRepeatingParametersAndInputNames=(section, id, _parameters, _input_names) => {
|
||
const repsecid = `repeating_${section}_${id}`;
|
||
_input_names[`section`] = section;
|
||
_input_names[`id`] = id;
|
||
setCommonParametersAndInputNames(repsecid, _parameters, _input_names);
|
||
if (section === 'skills') {
|
||
setSkillsParametersAndInputNames(repsecid, _parameters, _input_names);
|
||
} else if (section === 'bonds') {
|
||
setBondsParametersAndInputNames(repsecid, _parameters, _input_names);
|
||
} else if (section === 'special') {
|
||
setSpecialParametersAndInputNames(repsecid, _parameters, _input_names);
|
||
} else if (section==='rituals') {
|
||
setRitualParametersAndInputNames(repsecid, _parameters, _input_names);
|
||
} else if (section==='weapons') {
|
||
|
||
setGeneralWeaponParametersAndInputNames(repsecid, _parameters, _input_names);
|
||
|
||
setAdvancedWeaponParametersAndInputNames(repsecid, _parameters, _input_names);
|
||
|
||
_input_names[`track_bullets`]=`track_bullets`;
|
||
_parameters.push(_input_names[`track_bullets`]);
|
||
|
||
} else {
|
||
console.error(`Section ${section} not found`);
|
||
}
|
||
}
|
||
|
||
//levelup character
|
||
|
||
const initializeRolls = () => {
|
||
if (!_isInitialized) {
|
||
// Perform the necessary setup for rolls
|
||
|
||
// Example setup code
|
||
updateAllRollsOnOpen();
|
||
|
||
setResetBreakingPointsOnOpen();
|
||
updateRitualInfoOnOpen();
|
||
updateadvancedweapons();
|
||
// Set the flag to true after initialization
|
||
_isInitialized = true;
|
||
|
||
}
|
||
};
|
||
|
||
const rollSanityDamages = (sanloss) => {
|
||
const standard =`{{trackbullets=[[0]]}} {{isCritical=[[0]]}}`;
|
||
|
||
var rollString= `${prefix_damage_roll} {{header=^{sanity loss}}}`
|
||
rollString+=`{{subheader=${sanloss}}} {{damage=[[${sanloss}]]}} ${standard}`;
|
||
|
||
startRoll(rollString, (results) => {
|
||
const newroll = getRollDamage(results,0,'damage',0);
|
||
newroll['isCritical']=0;
|
||
newroll['trackbullets']=0;
|
||
|
||
finishRoll(results.rollId,newroll);
|
||
|
||
});
|
||
};
|
||
|
||
|
||
const paythecost=(sanity_loss,other_costs,fraction=1) => {
|
||
// lower sanity loss (not half)
|
||
|
||
rollSan= `${prefix_ritualloss_roll}`;
|
||
//used for before the roll
|
||
var hasCosts = {};
|
||
CurrentValues.forEach((attrName) => {
|
||
const current=parseInt(other_costs[attrName]) || 0;
|
||
var price= other_costs[attrName+'_cost'];
|
||
if (attrName !== 'sanity_points') {
|
||
rollSan += ` {{${attrName}_cost=[[floor(${price}/${fraction})]]}}`
|
||
rollSan += ` {{${attrName}=${current}}}`
|
||
if (price !== 0 && price !== '0') {
|
||
rollSan += ` {{has_${attrName}=1}}`
|
||
hasCosts[attrName] = 1;
|
||
} else {
|
||
|
||
};
|
||
}
|
||
});
|
||
|
||
rollSan += ` {{sanity_points_cost=[[${sanity_loss}]]}}`;
|
||
rollSan += ` {{sanity_points=${other_costs.sanity_points}}}`;
|
||
rollSan += ` {{has_sanity_points=1}}`;
|
||
|
||
hasCosts['sanity_points'] = 1;
|
||
|
||
startRoll(rollSan, (results) => {
|
||
const newroll = {};
|
||
const update = {};
|
||
|
||
CurrentValues.forEach((attrName) => {
|
||
const attrCost=attrName+'_cost';
|
||
const old_value=parseInt(other_costs[attrName]) || 0;
|
||
const cost = parseInt(results.results[attrCost].result) || 0;
|
||
|
||
const new_value = Math.max(0,old_value - cost);
|
||
newroll[attrCost] = new_value;
|
||
if (hasCosts.hasOwnProperty(attrName)) {
|
||
update[attrName] = new_value;
|
||
}
|
||
});
|
||
|
||
finishRoll(results.rollId,newroll);
|
||
|
||
setAttrs(update, {silent:true}, () => {
|
||
updatebreakingpoints() // I need to update the breaking points in the callback
|
||
|
||
});
|
||
});
|
||
|
||
};
|
||
|
||
const acceptfailure=(sanity_loss_success,other_costs) => {
|
||
paythecost(sanity_loss_success,other_costs,2);
|
||
};
|
||
|
||
const forceconnection=(sanity_loss_failure,other_costs) => {
|
||
other_costs['power_score'] = other_costs['power_score']+1 ;
|
||
paythecost(sanity_loss_failure,other_costs,1);
|
||
};
|
||
|
||
const name_and_param=(repsecid,attrName, _parameters, _input_names) => {
|
||
_input_names[attrName] = `${repsecid}_${attrName}`;
|
||
|
||
_parameters.push(_input_names[attrName]);
|
||
|
||
};
|
||
|
||
const setRitualCostParametersAndInputNames = (repsecid, _parameters, _input_names) => {
|
||
|
||
RitualCosts.forEach((attrName) => {
|
||
name_and_param(repsecid,attrName, _parameters, _input_names);
|
||
|
||
});
|
||
};
|
||
|
||
const setRitualDamageParametersAndInputNames = (repsecid, _parameters, _input_names) => {
|
||
|
||
RitualDamages.forEach((attrName) => {
|
||
name_and_param(repsecid,attrName, _parameters, _input_names);
|
||
});
|
||
|
||
RitualHeals.forEach((attrName) => {
|
||
name_and_param(repsecid,attrName, _parameters, _input_names);
|
||
});
|
||
};
|
||
|
||
const setRitualParametersAndInputNames = (repsecid, _parameters, _input_names) => {
|
||
|
||
// general informations
|
||
|
||
RitualRolls.forEach((attrName) => {
|
||
name_and_param(repsecid,attrName, _parameters, _input_names);
|
||
});
|
||
|
||
setRitualCostParametersAndInputNames(repsecid, _parameters, _input_names);
|
||
|
||
setRitualDamageParametersAndInputNames(repsecid, _parameters, _input_names);
|
||
|
||
};
|
||
|
||
const getOtherCosts = (other_costs,values,names,array) => {
|
||
array.forEach((attrName) => {
|
||
other_costs[attrName]=(values[names[attrName]] != '') ? values[names[attrName]] : 0;;
|
||
});
|
||
};
|
||
|
||
const name_to_shorthand = (name) => {
|
||
if (name === 'willpower_points') {return 'WP';}
|
||
if (name === 'hit_points') {return 'HP';}
|
||
if (name === 'strength_score') {return 'STR';}
|
||
if (name === 'constitution_score') {return 'CON';}
|
||
if (name === 'dexterity_score') {return 'DEX';}
|
||
if (name === 'intelligence_score') {return 'INT';}
|
||
if (name === 'charisma_score') {return 'CHA';}
|
||
if (name === 'power_score') {return 'POW';}
|
||
};
|
||
|
||
const ritual_power_action = (character_id,repsecid,other_costs) => {
|
||
const const_button_part = '](~'+character_id+'|';
|
||
const prefix_power_reaction='{{power_button=[';
|
||
const suffix_power_reaction = const_button_part+'power)}}';
|
||
return prefix_power_reaction+'^{power}'+suffix_power_reaction;
|
||
}
|
||
/*
|
||
|
||
const ritual_attack_or_heal_action = (character_id,repsecid,other_costs,heal_or_attack='attack') => {
|
||
const value_target=heal_or_attack.replace('_damage','').replace('_lethality_percent','');
|
||
const value = real_damage(other_costs,value_target);
|
||
if (value === '') {return '';}
|
||
const const_button_part = '](~'+character_id+'|'+repsecid+'_';
|
||
const target_stat=name_to_shorthand(other_costs[`${value_target}_target_stat`]);
|
||
|
||
const prefix_button = `{{${heal_or_attack}_button=[`;
|
||
const suffix_button = target_stat+const_button_part+heal_or_attack+'-action)}}';
|
||
return prefix_button+value+suffix_button;
|
||
};
|
||
|
||
|
||
const ritual_attack_action = (character_id,repsecid,other_costs) => {
|
||
var ritual_rolls='';
|
||
ritual_rolls+= ritual_attack_or_heal_action(character_id,repsecid,other_costs,'attack_damage');
|
||
ritual_rolls+= ritual_attack_or_heal_action(character_id,repsecid,other_costs,'attack_lethality_percent');
|
||
return ritual_rolls;
|
||
};
|
||
const ritual_heal_action = (character_id,repsecid,other_costs) => {
|
||
var ritual_rolls='';
|
||
ritual_rolls+= ritual_attack_or_heal_action(character_id,repsecid,other_costs,'heal_damage');
|
||
ritual_rolls+= ritual_attack_or_heal_action(character_id,repsecid,other_costs,'heal_lethality_percent');
|
||
return ritual_rolls;
|
||
};
|
||
*/
|
||
|
||
|
||
const real_damage = (other_costs,heal_or_damage,damage_type) => {
|
||
if (damage_type === 'lethality_percent') {
|
||
return `${setMinMax(other_costs[`${heal_or_damage}_${damage_type}_amount`])}% `;
|
||
} else if (damage_type === 'damage') {
|
||
return parseRoll(other_costs[`${heal_or_damage}_${damage_type}_amount`]);
|
||
}
|
||
return '';
|
||
};
|
||
|
||
const ritual_attack_or_heal_action = (character_id,repsecid,other_costs,heal_or_attack,damage_type) => {
|
||
const value = real_damage(other_costs,heal_or_attack,damage_type);
|
||
if (value === '') {return '';}
|
||
const const_button_part = '](~'+character_id+'|'+repsecid+'_';
|
||
const target_stat=name_to_shorthand(other_costs[`${heal_or_attack}_target_stat`]);
|
||
|
||
const prefix_button = `{{${heal_or_attack}_button=[`;
|
||
const suffix_button = ` ${target_stat}${const_button_part}${heal_or_attack}_${damage_type}-action)}}`;
|
||
return prefix_button+value+suffix_button;
|
||
};
|
||
|
||
|
||
const ritual_attack_action = (character_id,repsecid,other_costs,damage_type) => {
|
||
return ritual_attack_or_heal_action(character_id,repsecid,other_costs,'attack',damage_type);
|
||
};
|
||
const ritual_heal_action = (character_id,repsecid,other_costs,damage_type) => {
|
||
return ritual_attack_or_heal_action(character_id,repsecid,other_costs,'heal',damage_type);
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
const prepare_ritual_rolls = (other_costs,values,names) => {
|
||
var localString='';
|
||
const attack_type = other_costs['attack_isLethal']
|
||
const heal_type = other_costs['heal_isLethal']
|
||
localString += ritual_attack_action(values[names['character_id']],names['repsecid'],other_costs,attack_type);
|
||
localString += ritual_heal_action(values[names['character_id']],names['repsecid'],other_costs,heal_type);
|
||
|
||
if (values[names['power_reaction']] === 'active') {
|
||
localString += ritual_power_action(values[names['character_id']],names['repsecid']);
|
||
}
|
||
|
||
return localString;
|
||
};
|
||
|
||
const clicked_repeating_rituals = (parameters,names,queryModifier) => {
|
||
getAttrs(parameters, (values) => {
|
||
// cost of the ritual
|
||
const other_costs={};
|
||
getOtherCosts(other_costs,values,names,RitualCosts);
|
||
getOtherCosts(other_costs,values,names,RitualDamages);
|
||
getOtherCosts(other_costs,values,names,RitualHeals);
|
||
|
||
//----------------------------------------------------------------------------------------------
|
||
//---------Not used for the roll, they are always zero. Ask Shane if he wants it----------------
|
||
//const wp_mod=check_for_wp_modifiers(values,rollName);
|
||
const low_willpower = 0 //wp_mod.low_willpower;
|
||
const zero_willpower = 0 //wp_mod.zero_willpower;
|
||
//----------------------------------------------------------------------------------------------
|
||
//----------------------------------------------------------------------------------------------
|
||
// what is needed to roll
|
||
const rating = values[names['skill_span']];
|
||
const sanity_loss_success = other_costs['sanity_loss_success'];
|
||
const sanity_loss_failure = other_costs['sanity_loss_failure'];
|
||
|
||
// info ritual
|
||
const ritual_name = values[names['name']];
|
||
const description = values[names['description']];
|
||
|
||
var rollString=`${prefix_ritual_roll} {{header=${ritual_name}}}`;
|
||
rollString +=` {{subheader=${rating}}}`;
|
||
rollString +=` {{rating=[[${rating}]]}}`;
|
||
rollString +=` {{queryModifier=${queryModifier}}}`;
|
||
|
||
if (description !=='') {rollString += `{{description=${description}}}`;}
|
||
|
||
rollString += `{{sanity_loss_success=${sanity_loss_success}}}`;
|
||
rollString += `{{sanity_loss_failure=${sanity_loss_failure}}}`;
|
||
|
||
rollString += `{{zero_willpower=[[${zero_willpower}]]}}`;
|
||
rollString += `{{low_willpower=[[${low_willpower}]]}}`;
|
||
|
||
var hasOtherCosts = false;
|
||
var costString = '';
|
||
Object.entries(other_costs).forEach(([key, value]) => {
|
||
if (value != '' && value!= '0') {costString += `{{${key}=${value}}}`; hasOtherCosts = true;}
|
||
});
|
||
|
||
rollString += costString;
|
||
|
||
rollString += `{{hasCost=[[0]]}}`;
|
||
rollString += prepare_ritual_rolls(other_costs,values,names);
|
||
|
||
const flawed_ritual = values[names['flawed_ritual']] === 'active' ? 1 : 0;
|
||
if (flawed_ritual === 1) {rollString += `{{flawed_ritual=${flawed_ritual}}}`;}
|
||
|
||
rollString += `{{modifier=[[${queryModifier}]]}}`;
|
||
|
||
const character_id=values['character_id'];
|
||
const repsecid=names['repsecid']; // ritualid is the repeating section id, not a parameter
|
||
|
||
rollString += `{{pay_cost=[^{pay the cost}](~${character_id}|${repsecid}_pay_cost)}}`;
|
||
rollString += `{{accept_failure=[^{accept}](~${character_id}|${repsecid}_accept_failure)}}`;
|
||
rollString += `{{reject_failure=[^{reject}](~${character_id}|${repsecid}_force_connection)}}`;
|
||
/// This are the only quantities than I need to manupulate
|
||
rollString += `{{isSuccess=[[0]]}}`;
|
||
|
||
startRoll(rollString, (results) => {
|
||
const activation_rating = parseInt(results.results.rating.result) || 0;
|
||
const dice = parseInt(results.results.dice.result) || 0;
|
||
const _flawed_ritual = (flawed_ritual ===1) ? -20 : 0;
|
||
const _modifier = correct_modifier((parseInt(results.results.modifier.result) || 0)+flawed_ritual,low_willpower);
|
||
const _rating = correct_rating(activation_rating,_modifier);
|
||
const hasCost = hasOtherCosts ? 1 : 0;
|
||
const outcome=check_success(dice,_rating);
|
||
|
||
newroll = {
|
||
isSuccess: outcome.isSuccess,
|
||
IsCritical: outcome.IsCritical,
|
||
dice: dice,
|
||
modifier: _modifier,
|
||
hasCost: hasCost,
|
||
flawed_ritual: _flawed_ritual,
|
||
low_willpower: low_willpower,
|
||
zero_willpower: zero_willpower,
|
||
};
|
||
|
||
finishRoll(results.rollId,newroll);
|
||
});
|
||
});
|
||
};
|
||
|
||
const empty_to_zero=(value) => {
|
||
return (value !== '' || value !=='0') ? value : 0;
|
||
}
|
||
|
||
const updateRitualInfoOnOpen = () => {
|
||
getSectionIDs('repeating_rituals', (ids) => {
|
||
ids.forEach((id) => {
|
||
ritual_rolls_info(`repeating_rituals_${id}`);
|
||
});
|
||
});
|
||
};
|
||
|
||
const ritual_rolls_info = (repsecid) => {
|
||
const update = {};
|
||
const _names={};
|
||
const _parameters=[];
|
||
|
||
_ritualInfo.forEach((ritual_name) => {
|
||
_names[ritual_name] = `${repsecid}_${ritual_name}`;
|
||
_parameters.push(_names[ritual_name]);
|
||
});
|
||
|
||
getAttrs(_parameters, (values) => {
|
||
|
||
const complexity = values[_names['complexity']];
|
||
const sanity_loss_success = empty_to_zero(values[_names['sanity_loss_success']]);
|
||
const sanity_loss_failure = empty_to_zero(values[_names['sanity_loss_failure']]);
|
||
const activation_time = empty_to_zero(values[_names['activation_time']])==0 ? '' : empty_to_zero(values[_names['activation_time']]);
|
||
const activation_time_unit = values[_names['activation_time_unit']];
|
||
const study_time = empty_to_zero(values[_names['study_time']])==0 ? '' : empty_to_zero(values[_names['study_time']]);
|
||
const study_time_unit = values[_names['study_time_unit']];
|
||
const unnatural_gain = empty_to_zero(values[_names['unnatural_gain']]);
|
||
const sanity_loss_for_learning = empty_to_zero(values[_names['sanity_loss_for_learning']]);
|
||
const willpower_points_cost = empty_to_zero(values[_names['willpower_points_cost']]);
|
||
const power_score_cost = empty_to_zero(values[_names['power_score_cost']]);
|
||
const hit_points_cost = empty_to_zero(values[_names['hit_points_cost']]);
|
||
const strength_score_cost = empty_to_zero(values[_names['strength_score_cost']]);
|
||
const constitution_score_cost = empty_to_zero(values[_names['constitution_score_cost']]);
|
||
const dexterity_score_cost = empty_to_zero(values[_names['dexterity_score_cost']]);
|
||
const intelligence_score_cost = empty_to_zero(values[_names['intelligence_score_cost']]);
|
||
const charisma_score_cost = empty_to_zero(values[_names['charisma_score_cost']]);
|
||
|
||
// complexity text
|
||
update[`${repsecid}_complexity_text`] = `${complexity} ritual`;
|
||
|
||
// study time text
|
||
var study_time_text = '';
|
||
if (study_time != '') {
|
||
study_time_text = `${study_time} ${study_time_unit}`;
|
||
} else {
|
||
study_time_text = study_time_unit;
|
||
}
|
||
update[`${repsecid}_study_time_text`] = `${study_time_text}`;
|
||
// learning text
|
||
var learning_cost_text = `${String(sanity_loss_for_learning).toUpperCase()}SAN`;
|
||
if (unnatural_gain != 0) {learning_cost_text += `; ${unnatural_gain} Unnatural`;}
|
||
|
||
update[`${repsecid}_study_cost_text`] = `${learning_cost_text}`;
|
||
// activation time text
|
||
var activation_time_text = '';
|
||
if (activation_time != '') {
|
||
activation_time_text = `${activation_time} ${activation_time_unit}`;
|
||
} else {
|
||
activation_time_text = activation_time_unit;
|
||
}
|
||
update[`${repsecid}_activation_time_text`] = `${String(activation_time_text).toUpperCase()}`;
|
||
// costs text
|
||
var costs_text = '';
|
||
if (willpower_points_cost != 0) {costs_text += `${willpower_points_cost}WP, `;}
|
||
if (hit_points_cost != 0) {costs_text += `${hit_points_cost}HP, `;}
|
||
if (power_score_cost != 0) {costs_text += `${power_score_cost}POW, `;}
|
||
if (strength_score_cost != 0) {costs_text += `${strength_score_cost}STR, `;}
|
||
if (constitution_score_cost != 0) {costs_text += `${constitution_score_cost}CON, `;}
|
||
if (dexterity_score_cost != 0) {costs_text += `${dexterity_score_cost}DEX, `;}
|
||
if (intelligence_score_cost != 0) {costs_text += `${intelligence_score_cost}INT, `;}
|
||
if (charisma_score_cost != 0) {costs_text += `${charisma_score_cost}CHA, `;}
|
||
if (sanity_loss_success != 0) {costs_text += `${sanity_loss_success}SAN/`;}
|
||
costs_text += `${sanity_loss_failure}SAN`;
|
||
|
||
update[`${repsecid}_cost_text`] = `${String(costs_text).toUpperCase()}`;
|
||
|
||
setAttrs(update, {silent:true}, () => {
|
||
|
||
});
|
||
});
|
||
};
|
||
|
||
|
||
|
||
|
||
usedModifier = (e,callback) => {
|
||
var queryModifier = 0;
|
||
getAttrs(['useKey','global_modifier_number'], (values) => {
|
||
const useKey = values['useKey'];
|
||
|
||
const globalModifier = parseInt(values['global_modifier_number']) || 0;
|
||
if (useKey === 'global') {
|
||
queryModifier = globalModifier;
|
||
}
|
||
if (e.altKey && useKey === 'alt') {queryModifier=_queryModifier;}
|
||
if (e.ctrlKey && useKey === 'ctrl') {queryModifier=_queryModifier;}
|
||
if (e.metaKey && useKey === 'meta') {queryModifier=_queryModifier;}
|
||
if (e.shiftKey && useKey === 'shift') {queryModifier=_queryModifier;}
|
||
if (useKey === 'none') {queryModifier=_queryModifier;}
|
||
console.log(`queryModifier: ${queryModifier}`);
|
||
callback(queryModifier);
|
||
});
|
||
}
|
||
|
||
|
||
on(`clicked:reset_global_modifier`, () => {
|
||
const update={'global_modifier_number':''};
|
||
setAttrs(update, {silent:true}, () => {
|
||
|
||
});
|
||
});
|
||
|
||
$20(selector).on(`click`, e => {
|
||
|
||
const roll = e.htmlAttributes.name.match(/^attr_(.*)_r$/)[1];
|
||
const _roll = (roll === 'sanity_points') ? 'sanity' : roll;
|
||
usedModifier(e,(queryModifier) =>{
|
||
console.log(`queryModifier: ${queryModifier}`);
|
||
|
||
|
||
const additionalParameters={}
|
||
if (arrays[`_editable_skills`].includes(_roll)){
|
||
const prefix_skill=_roll.slice(0,-2);
|
||
additionalParameters['editable_name']=`${_roll}_name`;
|
||
additionalParameters['editable_type']=prefix_skill.replace('_',' ');
|
||
}else{
|
||
const caps = (_roll === 'humint' || _roll === 'sigint') ? _roll.toUpperCase() : _roll.replace('_',' ')
|
||
additionalParameters['name']=caps.replace('_',' ');
|
||
}
|
||
|
||
const rollString=`${prefix_skill_roll} {{subheader=@{${roll}}}} `;
|
||
|
||
rollwithmodifiers(rollString,roll,queryModifier,additionalParameters);
|
||
});
|
||
});
|
||
|
||
$20(sanity_selector).on(`click`, e => {
|
||
|
||
const _input_name={};
|
||
var _parameters = [];
|
||
|
||
_input_name['success'] = 'sanity_loss_success';
|
||
_parameters.push(_input_name['success']);
|
||
_input_name['failure'] = 'sanity_loss_failure';
|
||
_parameters.push(_input_name['failure']);
|
||
|
||
getAttrs(['character_id','sanity_loss_success','sanity_loss_failure',
|
||
'sanity_type','violence_adapted','helplessness_adapted'], (values) => {
|
||
const charid=values['character_id'];
|
||
const sanity_loss_success=values['sanity_loss_success'] !== '' ? values['sanity_loss_success'] : 0;
|
||
const sanity_loss_failure=values['sanity_loss_failure'] !== '' ? values['sanity_loss_failure'] : 1;
|
||
const sanity_loss_type=values['sanity_type'];
|
||
console.log(sanity_loss_type);
|
||
var rollString = `${prefix_sanity_roll} {{header=@{character_name}}}`;
|
||
rollString += ` {{sanity_type=^{@{sanity_type}}}}`;
|
||
rollString += ` {{description=@{npc_description}}}`;
|
||
rollString += ` {{success_roll=[${sanity_loss_success}](~${charid}|sanity_loss_success)}}`;
|
||
rollString += ` {{failure_roll=[${sanity_loss_failure}](~${charid}|sanity_loss_failure)}}`;
|
||
|
||
|
||
console.info(sanity_loss_success);
|
||
console.info(sanity_loss_failure);
|
||
console.info('min roll:',minRoll(sanity_loss_success));
|
||
console.info('max roll:',maxRoll(sanity_loss_failure));
|
||
startRoll(rollString,results =>{
|
||
finishRoll(results.rollId)
|
||
});
|
||
});
|
||
});
|
||
|
||
$20('button.repeating_roll').on(`click`, e => {
|
||
|
||
const id = e.htmlAttributes.value;
|
||
const section = _repeating_sections[e.htmlAttributes.name.split('_')[1]];
|
||
|
||
|
||
usedModifier(e,(queryModifier) => {
|
||
var _input_names = {};
|
||
var _parameters = [];
|
||
setRepeatingParametersAndInputNames(section, id, _parameters, _input_names)
|
||
clicked_repeating_actions(section, _parameters, _input_names, queryModifier);
|
||
});
|
||
});
|
||
|
||
arrays['_sanity_loss'].forEach((attrName) => {
|
||
on(`clicked:${attrName}-action`, (eventInfo) => {
|
||
|
||
getAttrs([attrName],(values) => {
|
||
const sanloss=check_sanloss(values[attrName],attrName);
|
||
rollSanityDamages(sanloss,attrName);
|
||
});
|
||
});
|
||
});
|
||
|
||
|
||
_allrolls.forEach(roll => {
|
||
const _roll = (roll === 'sanity_points') ? 'sanity' : roll;
|
||
on(`clicked:${roll}-action`, (eventInfo) => {
|
||
const additionalParameters={}
|
||
if (arrays[`_editable_skills`].includes(_roll)){
|
||
const prefix_skill=_roll.slice(0,-2);
|
||
additionalParameters['editable_name']=`${_roll}_name`;
|
||
additionalParameters['editable_type']=prefix_skill.replace('_',' ');
|
||
}else{
|
||
const caps = (_roll === 'humint' || _roll === 'sigint') ? _roll.toUpperCase() : _roll.replace('_',' ')
|
||
additionalParameters['name']=caps.replace('_',' ');
|
||
}
|
||
|
||
const rollString=`${prefix_skill_roll} {{subheader=@{${roll}}}} `;
|
||
|
||
rollwithmodifiers(rollString,roll,_queryModifier,additionalParameters);
|
||
});
|
||
});
|
||
|
||
Object.entries(_repeating_sections).forEach(([attrName,section]) => {
|
||
on(`clicked:repeating_${section}:${attrName}-action`, (eventInfo) => {
|
||
const id = eventInfo.sourceAttribute.split('_')[2];
|
||
const queryModifier=_queryModifier;
|
||
var _input_names = {};
|
||
var _parameters =[];
|
||
setRepeatingParametersAndInputNames(section, id, _parameters, _input_names)
|
||
|
||
clicked_repeating_actions(section, _parameters, _input_names, queryModifier);
|
||
|
||
});
|
||
});
|
||
|
||
_ritual_damages.forEach((attrName) => {
|
||
_type_damages.forEach((type) => {
|
||
on(`clicked:repeating_rituals:${attrName}_${type}-action`, (eventInfo) => {
|
||
|
||
const id = eventInfo.sourceAttribute.split('_')[2];
|
||
const input_names = {};
|
||
var parameters =[];
|
||
input_names[`ritual_type`]=attrName;
|
||
parameters.push(`repeating_rituals_${id}_ritual_type`);
|
||
|
||
|
||
const repsecid = `repeating_rituals_${id}`;
|
||
input_names[`repsecid`]=repsecid;
|
||
input_names[`name`]=`${repsecid}_name`;
|
||
input_names[`damage_type`]=`${type}`;
|
||
input_names[`attack_or_heal`]=`${attrName}`;
|
||
parameters.push(input_names[`name`]);
|
||
|
||
|
||
setDamageRitualParametersAndInputNames(id, parameters, input_names);
|
||
clicked_repeating_damages(parameters,input_names,attrName);
|
||
});
|
||
});
|
||
});
|
||
|
||
|
||
_ritual_losses.forEach((attrName) => {
|
||
on(`clicked:repeating_rituals:${attrName}-action`, (eventInfo) => {
|
||
|
||
const id = eventInfo.sourceAttribute.split('_')[2];
|
||
const input_names = {};
|
||
var parameters =[];
|
||
input_names[`ritual_type`]=attrName;
|
||
parameters.push(`repeating_rituals_${id}_ritual_type`);
|
||
|
||
|
||
const repsecid = `repeating_rituals_${id}`;
|
||
input_names[`repsecid`]=repsecid;
|
||
input_names[`name`]=`${repsecid}_name`;
|
||
parameters.push(input_names[`name`]);
|
||
|
||
|
||
setRitualCostParametersAndInputNames(repsecid, parameters, input_names);
|
||
CurrentValues.forEach((attrName) => {
|
||
input_names[attrName]=`${attrName}`;
|
||
parameters.push(attrName);
|
||
});
|
||
|
||
clicked_repeating_rituals_cost(parameters,input_names);
|
||
});
|
||
});
|
||
|
||
_alldamages.forEach((attrName) => {
|
||
on(`clicked:repeating_weapons:${attrName}-action`, (eventInfo) => {
|
||
|
||
const id = eventInfo.sourceAttribute.split('_')[2];
|
||
var _input_names = {};
|
||
var _parameters =[];
|
||
setDamageParametersAndInputNames(id,attrName, _parameters, _input_names)
|
||
_input_names['rollName']=attrName;
|
||
clicked_repeating_damages(_parameters,_input_names);
|
||
});
|
||
});
|
||
|
||
|
||
|
||
// levelup character
|
||
on("clicked:levelup", () =>{
|
||
const copyarray=arrays['_skills']; // copy of the array containing all skills ranks
|
||
|
||
console.dir(copyarray);
|
||
getSectionIDs(`repeating_summary`, function(idarray) {
|
||
for(var i=0; i < idarray.length; i++) {
|
||
removeRepeatingRow("repeating_summary_" + idarray[i]);
|
||
}
|
||
});
|
||
|
||
|
||
const summary={}; // object to store the summary of the changes
|
||
const update={}; // object to update the attributes
|
||
const newrowattrs={}; // object to create a new row in the repeating_summary section
|
||
const named_skills = copyarray.map((sk) => `${sk}_name`);
|
||
const failed_skills = copyarray.map((sk) => `${sk}_fail`);
|
||
getAttrs(copyarray.concat(named_skills,failed_skills),(val)=>{
|
||
var newrowid;
|
||
var oldval=0;
|
||
var newval=0;
|
||
var name;
|
||
var var_rnd=0; // random variable of 1d4
|
||
|
||
copyarray.forEach( (sk) => {
|
||
if (val[`${sk}_fail`]=='on'){ //if the checkbox is checked
|
||
var_rnd=Math.ceil(Math.random() * 4); // generate a random number for each checked value (less number generated)
|
||
|
||
oldval=(parseInt(val[`${sk}`])||0);
|
||
newval=oldval+var_rnd;
|
||
name=val[`${sk}_name`];
|
||
summary[`${sk}`]=var_rnd; // how much the skill has changed 0-3
|
||
update[`${sk}`]=newval; // new value of the skill
|
||
update[`${sk}_fail`]='off'; // uncheck checkbox
|
||
|
||
newrowid = generateRowID();
|
||
newrowattrs['repeating_summary_' + newrowid + '_skillname'] = name;
|
||
newrowattrs['repeating_summary_' + newrowid + '_oldval'] = oldval;
|
||
newrowattrs['repeating_summary_' + newrowid + '_newval'] = newval;
|
||
}
|
||
});
|
||
|
||
});
|
||
getSectionIDs(`repeating_skills`, function(idarray) {
|
||
var rep_array=[];
|
||
var rep_rank=[];
|
||
var rep_name=[];
|
||
var rep_fail=[];
|
||
|
||
idarray.forEach((id) => {
|
||
rep_array.push(`repeating_skills_${id}`);
|
||
});
|
||
rep_rank=rep_array.map((sk) => `${sk}_rank`);
|
||
rep_name=rep_array.map((sk) => `${sk}_name`);
|
||
rep_fail=rep_array.map((sk) => `${sk}_fail`);
|
||
getAttrs(rep_rank.concat(rep_name,rep_fail),(val)=>{
|
||
var newrowid;
|
||
var oldval=0;
|
||
var newval=0;
|
||
var name;
|
||
var var_rnd=0; // random variable of 1d4
|
||
|
||
rep_array.forEach( (sk) => {
|
||
if (val[`${sk}_fail`]=='on'){ //if the checkbox is checked
|
||
var_rnd=Math.ceil(Math.random() * 4); // generate a random number for each checked value (less number generated)
|
||
|
||
oldval=(parseInt(val[`${sk}_rank`])||0);
|
||
newval=oldval+var_rnd;
|
||
name=val[`${sk}_name`];
|
||
summary[`${sk}`]=var_rnd; // how much the skill has changed 0-3
|
||
update[`${sk}_rank`]=newval; // new value of the skill
|
||
update[`${sk}_fail`]='off'; // uncheck checkbox
|
||
|
||
newrowid = generateRowID();
|
||
newrowattrs['repeating_summary_' + newrowid + '_skillname'] = name;
|
||
newrowattrs['repeating_summary_' + newrowid + '_oldval'] = oldval;
|
||
newrowattrs['repeating_summary_' + newrowid + '_newval'] = newval;
|
||
}
|
||
});
|
||
setAttrs(Object.assign(update,newrowattrs),{silent:true},()=>{
|
||
console.log('inside repeating section');
|
||
console.info(newrowattrs);
|
||
console.info(update);
|
||
});
|
||
});
|
||
});
|
||
});
|
||
|
||
arrays['_colored_derivative'].forEach(vitality => {
|
||
on(`change:${vitality}_points`, (eventInfo) => {
|
||
|
||
var value = parseInt(eventInfo.newValue) || 0;
|
||
value = (value < 0) ? 0 : value;
|
||
const maxval=`${vitality}_points_max`;
|
||
getAttrs([maxval], function(v) {
|
||
|
||
const max_val = parseInt(v[maxval]) || 0;
|
||
const low_val=2;
|
||
var update={};
|
||
|
||
update[`color_${vitality}`]='normal';
|
||
update[`${vitality}_modifier`]=0;
|
||
|
||
if (value > max_val) {
|
||
update[`color_${vitality}`]='extra';
|
||
}
|
||
if (value <= low_val) {
|
||
update[`color_${vitality}`]='low';
|
||
update[`${vitality}_modifier`]=1;
|
||
}
|
||
if (value == 0) {
|
||
update[`color_${vitality}`]='zero';
|
||
update[`${vitality}_modifier`]=2;
|
||
}
|
||
update[`${vitality}_points`]=value;
|
||
|
||
setAttrs(update, {silent:false}, ()=>{
|
||
|
||
});
|
||
});
|
||
});
|
||
});
|
||
|
||
_skill_percent.forEach(_skill_sec_percent => {
|
||
const section=_skill_sec_percent.section;
|
||
const field=_skill_sec_percent.field;
|
||
const input=`repeating_${section}_${field}`;
|
||
const skillspan=`repeating_${section}_skill_span`;
|
||
on(`change:repeating_${section}:${field}`, () => {
|
||
getAttrs([input], (value) => {
|
||
const SkillPercent = value[`repeating_${section}_${field}`];
|
||
const isInLinkingForm=isValidLinkInput(SkillPercent);
|
||
const isInNumericalForm=isSkillNumber(SkillPercent);
|
||
const update={};
|
||
var skillname='';
|
||
|
||
if (isInLinkingForm===false && isInNumericalForm===false) {
|
||
update[input]=0;
|
||
if (section !=='skills') {update[skillspan]=update[input];}
|
||
setAttrs(update,{silent:true},()=>{
|
||
|
||
});
|
||
}
|
||
|
||
if (isInNumericalForm){
|
||
const number= setMinMax(SkillPercent);
|
||
update[input]=number;
|
||
if (section !=='skills') {update[skillspan]=update[input];}
|
||
setAttrs(update,{silent:true},()=>{
|
||
|
||
});
|
||
}
|
||
|
||
if (isInLinkingForm) {
|
||
const skill=cleanedSkill(SkillPercent);
|
||
skillname=skill;
|
||
getAttrs([`${skillname}`], (values) => {
|
||
const number= setMinMax(values[skillname]);
|
||
if (section !=='skills') {update[skillspan]=number;}
|
||
setAttrs(update,{silent:true},()=>{
|
||
|
||
});
|
||
});
|
||
};
|
||
});
|
||
});
|
||
});
|
||
|
||
_only_number.forEach(_sect_object => {
|
||
const section=_sect_object.section;
|
||
const fields=_sect_object.fields;
|
||
if (Array.isArray(fields)) {
|
||
fields.forEach(field => {
|
||
const input=`repeating_${section}_${field}`;
|
||
on(`change:repeating_${section}:${field}`, () => {
|
||
getAttrs([input], (value) => {
|
||
const update={};
|
||
const number=setMinMax(value[input]);
|
||
update[input]=number;
|
||
setAttrs(update,{silent:true},()=>{
|
||
});
|
||
});
|
||
});
|
||
});
|
||
};
|
||
});
|
||
|
||
|
||
|
||
_number_or_roll.forEach(_sect_object => {
|
||
const section=_sect_object.section;
|
||
const fields=_sect_object.fields;
|
||
|
||
if (Array.isArray(fields)) {
|
||
fields.forEach(field => {
|
||
const input=`repeating_${section}_${field}`;
|
||
on(`change:repeating_${section}:${field}`, () => {
|
||
getAttrs([input], (value) => {
|
||
const update={};
|
||
const number=parseRoll(value[input]);
|
||
update[input]=number;
|
||
setAttrs(update,{silent:true},()=>{
|
||
});
|
||
});
|
||
});
|
||
});
|
||
};
|
||
});
|
||
|
||
arrays['_sanity_loss'].forEach(sanity => {
|
||
on(`change:${sanity}`, () => {
|
||
getAttrs([`${sanity}`], (v) => {
|
||
const value= parseRoll(v[sanity]);
|
||
const update={};
|
||
update[sanity]=value;
|
||
setAttrs(update, {silent:true}, () => {
|
||
console.info(`Sanity points updated`);
|
||
});
|
||
});
|
||
});
|
||
});
|
||
|
||
_shotgun_or_blast_radius.forEach(main => {
|
||
other= _shotgun_or_blast_radius.filter(el => el == main);
|
||
on(`change:repeating_weapons:${main}`, (eventInfo) => {
|
||
id = eventInfo.sourceAttribute.split('_')[2];
|
||
const main_name=`repeating_weapons_${id}_${main}`;
|
||
const other_name=`repeating_weapons_${id}_${other}`;
|
||
const double_barrel_name=`repeating_weapons_${id}_hasDoubleBarrel`;
|
||
|
||
getAttrs([main_name,other_name], (values) => {
|
||
|
||
console.info(values);
|
||
const main_value=values[main_name]==='active' ? 1 : 0;
|
||
const update={};
|
||
|
||
if (main_value===1 ){
|
||
if (main==='shotgun'){
|
||
update[`repeating_weapons_${id}_blast_radius`]=0;
|
||
update[double_barrel_name]='active';
|
||
}else{
|
||
update[double_barrel_name]=0;
|
||
update[`repeating_weapons_${id}_shotgun`]=0;
|
||
}
|
||
}
|
||
if (main_value===0){
|
||
update[double_barrel_name]=0;
|
||
}
|
||
|
||
setAttrs(update,{silent:true},()=>{
|
||
console.log('Shotgun or Blast Radius updated');
|
||
|
||
});
|
||
});
|
||
});
|
||
});
|
||
|
||
arrays['_settings_wp'].forEach(wp_setting => {
|
||
on(`change:${wp_setting}`, (eventInfo) => {
|
||
console.log('wp_setting changed:'+eventInfo.triggerName);
|
||
getAttrs(arrays['_settings_wp'].concat(arrays['_derived_modifiers']), (values) => {
|
||
var update = {};
|
||
if (values['mod_willpower_check'] === 'none'){
|
||
update[`low_willpower`] = 0;
|
||
update[`zero_willpower`] = 0;
|
||
}
|
||
if (values['mod_willpower_check'] === 'lowonly'){
|
||
update[`zero_willpower`] = 0;
|
||
update[`low_willpower`] = 1;
|
||
}
|
||
if (values['mod_willpower_check'] === 'all'){
|
||
update[`low_willpower`] = 1;
|
||
update[`zero_willpower`] = 1;
|
||
}
|
||
|
||
setAttrs(update, {silent:true}, () => {
|
||
console.log('Willpower Settings updated');
|
||
});
|
||
});
|
||
});
|
||
});
|
||
|
||
on(`change:repeating_skills:rank`, (eventInfo) => {
|
||
const newValue = setMinMax(parseInt(eventInfo.newValue) || 0, 0, 99);
|
||
update={};
|
||
update[eventInfo.sourceAttribute]=newValue;
|
||
|
||
setAttrs(update,{silent:true},()=>{
|
||
console.log('Repeating Skills updated on change');
|
||
});
|
||
});
|
||
|
||
Object.entries(_repeating_sections).forEach(([attrName,section]) => {
|
||
on(`change:repeating_${section}`, (eventInfo) => {
|
||
const id = eventInfo.sourceAttribute.split('_')[2];
|
||
changeRepeatingRolls(section,attrName,id);
|
||
});
|
||
});
|
||
|
||
|
||
|
||
// new function to compute san point max
|
||
on(`change:unnatural`, function(eventInfo) {
|
||
const newvalue = setMinMax(parseInt(eventInfo.newValue) || 0,0,99);
|
||
update={sanity_points_max: 99-newvalue, unnatural: newvalue};
|
||
|
||
setAttrs(update,{silent:true},()=>{
|
||
console.log('Sanity points updated');
|
||
});
|
||
});
|
||
|
||
arrays['_stats'].forEach(stat => {
|
||
const stat_score = `${stat}_score`;
|
||
|
||
const _sanity_array=['sanity_points', 'breaking_point','initial_san'];
|
||
const _initial_hp=['initial_str','initial_con','initial_hp'];
|
||
on(`change:${stat_score}`, () => {
|
||
var update = {};
|
||
getAttrs(arrays['_stats'].concat(_sanity_array,_initial_hp,['unnatural'],arrays['_stats'].map(el=> `${el}_score`)), function(values) {
|
||
const stat_score_value=parseInt(values[stat_score],10) || 0;
|
||
statInfo=setStatScore(stat_score_value,stat);
|
||
InitializationFlags=getInitializationFlags(statInfo,values)
|
||
|
||
setInitialPower(update,values,statInfo,InitializationFlags);
|
||
setInitialHp(update,values,statInfo,InitializationFlags)
|
||
update[stat]=statInfo[`stat`];
|
||
update[stat_score]=statInfo[`score`];
|
||
Object.assign(update,InitializationFlags);
|
||
updateSkillSpanOnChange(statInfo[`name`],statInfo[`score`],update,'Stats')
|
||
});
|
||
});
|
||
});
|
||
|
||
on(`change:ritual_skill`, (eventInfo) => {
|
||
const value = skill_in_bounds(eventInfo.newValue);
|
||
var update = {};
|
||
console.log('ritual_skill:',value);
|
||
update['ritual_skill'] = value;
|
||
updateSkillSpanOnChange('ritual_skill',value,update,'Rituals');
|
||
});
|
||
// === Update skills on change
|
||
arrays['_skills'].forEach(skill => {
|
||
on(`change:${skill}`, (eventInfo) => {
|
||
const value= skill_in_bounds(eventInfo.newValue);
|
||
var update={};
|
||
update[skill]=value;
|
||
updateSkillSpanOnChange(skill,value,update,'Skills')
|
||
});
|
||
});
|
||
|
||
on(`change:sanity_points`, () => {
|
||
updatebreakingpoints();
|
||
});
|
||
|
||
on(`change:breaking_point`, () => {
|
||
getAttrs(['breaking_point'], (values)=> {
|
||
const breaking_point = Math.max(0,parseInt(values.breaking_point, 10) || 0);
|
||
const update = {};
|
||
update['breaking_point_reset'] = breaking_point;
|
||
update['breaking_point']=breaking_point;
|
||
setAttrs(update, {silent:true}, () => {
|
||
});
|
||
});
|
||
});
|
||
|
||
on(`change:breaking_point_reset`,(eventInfo)=>{
|
||
const breaking_point_reset = parseInt(eventInfo.newValue, 10) || 0;
|
||
getAttrs(['breaking_point_reset'], (values)=> {
|
||
const breaking_point_reset = parseInt(values.breaking_point_reset, 10) || 0;
|
||
|
||
const update = {};
|
||
update['breaking_point_reset'] = Math.min(Math.max(0,breaking_point_reset),99);
|
||
setAttrs(update, {silent:true}, () => {
|
||
|
||
});
|
||
});
|
||
});
|
||
|
||
on(`clicked:breaking_point_resets`, () => {
|
||
resetBreakingPoints();
|
||
});
|
||
|
||
on(`change:global_modifier_number`, () => {
|
||
getAttrs(['global_modifier_number'], (values) => {
|
||
const modifier = parseInt(values['global_modifier_number']) || 0;
|
||
const update = {global_modifier_number:modifier};
|
||
setAttrs(update, {silent:true}, () => {
|
||
|
||
});
|
||
});
|
||
});
|
||
|
||
on(`change:repeating_skills remove:repeating_skills`, () => {
|
||
update_additionalskills();
|
||
});
|
||
|
||
on(`change:repeating_weapons:armor_piercing`, () => {
|
||
getAttrs(['repeating_weapons_armor_piercing'], (values) => {
|
||
const update = {};
|
||
update_armor_piercing(values.repeating_weapons_armor_piercing,update);
|
||
setAttrs(update, {silent:true}, () => {
|
||
});
|
||
});
|
||
});
|
||
on(`change:repeating_weapons:ammo_total remove:repeating_weapons`, (values) => {
|
||
const ammo_total = Math.max(0,parseInt(values.newValue)||0);
|
||
const update = {};
|
||
update[`repeating_weapons_ammo_total`] = ammo_total;
|
||
update[`repeating_weapons_ammo`] = ammo_total;
|
||
update[`repeating_weapons_hasammo`] = ammo_total > 0 ? 'active' : '0';
|
||
|
||
setAttrs(update, {silent:true}, () => {
|
||
});
|
||
});
|
||
|
||
on(`change:repeating_weapons:ammo`, (values) => {
|
||
const ammo = Math.max(0,parseInt(values.newValue)||0);
|
||
const update = {};
|
||
update[`repeating_weapons_ammo`] = ammo;
|
||
setAttrs(update, {silent:true}, () => {
|
||
});
|
||
});
|
||
|
||
|
||
_bond_attributes.forEach(attrName => {
|
||
on(`change:repeating_bonds:${attrName}`, (eventInfo) => {
|
||
const update={};
|
||
getAttrs(_score_info, (values) => {
|
||
updatebondscore(values,update,attrName==='score');
|
||
setAttrs(update, {silent:true}, () => {
|
||
console.log('Bond color updated');
|
||
console.info(update);
|
||
});
|
||
});
|
||
});
|
||
});
|
||
|
||
on(`change:repeating_rituals`, (eventinfo) => {
|
||
const id = eventinfo.sourceAttribute.split('_')[2];
|
||
ritual_rolls_info(`repeating_rituals_${id}`);
|
||
});
|
||
|
||
arrays['_adaptation'].forEach(adaptation => {
|
||
on(`change:${adaptation}`, () => {
|
||
getAttrs([adaptation], (values) => {
|
||
console.log('values:',values);
|
||
const value=parseInt(values[adaptation]) || 0;
|
||
console.log('adaptation changed:'+value);
|
||
const update={};
|
||
update[`${adaptation}_adapted`]= value===2 ? 1 : 0;
|
||
setAttrs(update, {silent:true}, () => {
|
||
update[`${adaptation}_adapted`] == 1 ? console.log(`${adaptation} adapted`) : console.log(`${adaptation} not adapted`);
|
||
});
|
||
});
|
||
});
|
||
});
|
||
|
||
on(`change:advanced_weapons`,()=>{
|
||
updateadvancedweapons()
|
||
});
|
||
|
||
on(`change:useKey`, () => {
|
||
getAttrs(['useKey'], (values) => {
|
||
const val = values['useKey'];
|
||
const update = {use_global_modifier:'inactive'};
|
||
if (val === 'global') {update['use_global_modifier']='active'};
|
||
console.log(`useKey: ${val}`);
|
||
|
||
|
||
setAttrs(update, {silent:true}, () => {
|
||
|
||
});
|
||
});
|
||
});
|
||
// === Update repeating skills on change
|
||
on(`change:repeating_skills:rank`, function(eventInfo) {
|
||
const value = parseInt(eventInfo.newValue) || 0;
|
||
if (value < 0) {
|
||
setAttributes({[eventInfo.sourceAttribute]: 0}, false);
|
||
}
|
||
if (value > 99) {
|
||
setAttributes({[eventInfo.sourceAttribute]: 99}, false);
|
||
}
|
||
});
|
||
|
||
const update_armor_piercing = (value,update) => {
|
||
const armor_piercing_text = value;
|
||
const armor_piercing_number = parseInt(armor_piercing_text) || 0;
|
||
|
||
if (armor_piercing_text !== '') { update[`repeating_weapons_armor_piercing`] = armor_piercing_number; }
|
||
|
||
};
|
||
//= force the stats to be positive and the skills to be between 0 and 99
|
||
on(`sheet:opened`, () => {
|
||
|
||
// === Versioning
|
||
getAttrs(['version'], values => { versioning(parseFloat(values.version) || 1); });
|
||
changeBondButtonColorOnOpen();
|
||
initializeRolls();
|
||
|
||
});
|
||
|
||
|
||
const isJSONString = (string) => {
|
||
let json= {};
|
||
try {
|
||
json = JSON.parse(string);
|
||
} catch (e) {
|
||
console.info('it is not a JSON');
|
||
return false;
|
||
}
|
||
console.info(`string`,json)
|
||
return json;
|
||
}
|
||
const arrays_drop={
|
||
fields : [
|
||
"employer","profession",
|
||
"accounting","alertness","anthropology","archeology","art_1","art_1_name","art_2","art_2_name","artillery","athletics","bureaucracy",
|
||
"computer_science","craft_1","craft_1_name","craft_2","craft_2_name","criminology","demolitions","disguise","dodge","drive","firearms",
|
||
"first_aid","forensics","heavy_machinery","heavy_weapons","history","humint","law","medicine","melee_weapons","military_science_1",
|
||
"military_science_1_name","military_science_2","military_science_2_name","navigate","occult","persuade","pharmacy","pilot_1","pilot_1_name",
|
||
"pilot_2","pilot_","psychotherapy","ride","science_1","science_1_name","science_1","science_2_name","search","sigint", "stealth","surgery",
|
||
"survival", "swim","unarmed_combat","unnatural",
|
||
"armor_and_gear","personal_details_and_notes","motivations","bond_number"],
|
||
visible: ["accounting","alertness","anthropology","archeology","art_1","art_1_name","art_2","art_2_name","artillery","athletics","bureaucracy",
|
||
"computer_science","craft_1","craft_1_name","craft_2","craft_2_name","criminology","demolitions","disguise","dodge","drive","firearms",
|
||
"first_aid","forensics","heavy_machinery","heavy_weapons","history","humint","law","medicine","melee_weapons","military_science_1",
|
||
"military_science_1_name","military_science_2","military_science_2_name","navigate","occult","persuade","pharmacy","pilot_1","pilot_1_name",
|
||
"pilot_2","pilot_","psychotherapy","ride","science_1","science_1_name","science_1","science_2_name","search","sigint", "stealth","surgery",
|
||
"survival", "swim","unarmed_combat","unnatural"],
|
||
bond: ["name","bond_score"],
|
||
skill: ["name","rank"],
|
||
special_training:["name","skill_or_stat_used"],
|
||
weapon :["name", "skill_percent", "base_range", "damage", "armor_piercing", "lethality_percent", "ammo"],
|
||
rep: {bond: "repeating_bonds_",special: "repeating_special_",skill:"repeating_skills_",ritual:"repeating_rituals_",weapon:"repeating_weapons_"},
|
||
}
|
||
|
||
|
||
const dropAgent = (data) => {
|
||
const updateAttrs = {};
|
||
updateAttrs[`sheet_type`] = "pc";
|
||
// First of all reset skills and repeating sections for skills and abilities
|
||
resetBonds(updateAttrs);
|
||
resetSkills(updateAttrs);
|
||
resetAllRepeatingSkills(updateAttrs);
|
||
resetAllSpecialAbilities(updateAttrs);
|
||
console.log(`Agent Reset:`,updateAttrs);
|
||
|
||
// bonds
|
||
const special_trainings = isJSONString(data.repeated_special_trainings);
|
||
const rituals= isJSONString(data.repeating_rituals);
|
||
const weapons= isJSONString(data.repeating_weapons);
|
||
const repSkills= isJSONString(data.repeating_skills);
|
||
const dropfields= arrays_drop[`fields`];
|
||
const visible=arrays_drop['visible'];
|
||
console.log(`special_trainings: ${special_trainings}`);
|
||
console.log(`rituals: ${rituals}`);
|
||
console.log(`weapons: ${weapons}`);
|
||
console.log(`repSkills: ${repSkills}`);
|
||
|
||
if (repSkills){
|
||
for (const skill of repSkills){
|
||
let dRepSkills=dropRepSkills(skill);
|
||
Object.keys(dRepSkills).forEach(key => updateAttrs[key] = dRepSkills[key]);
|
||
}
|
||
}
|
||
|
||
if (special_trainings){
|
||
for (const special_training of special_trainings){
|
||
let dSpecialTraining=dropSpecialTraining(special_training);
|
||
Object.keys(dSpecialTraining).forEach(key => updateAttrs[key] = dSpecialTraining[key]);
|
||
}
|
||
}
|
||
/*
|
||
if (rituals){
|
||
for (const ritual of rituals){
|
||
let dRitual=dropRitual(ritual);
|
||
Object.keys(dRitual).forEach(key => updateAttrs[key] = dRitual[key]);
|
||
}
|
||
}
|
||
*/
|
||
if (weapons){
|
||
for (const weapon of weapons){
|
||
let dWeapons=dropWeapon(weapon);
|
||
Object.keys(dWeapons).forEach(key => updateAttrs[key] = dWeapons[key]);
|
||
}
|
||
}
|
||
|
||
console.info('drop fields:',dropfields);
|
||
for (const field of dropfields){
|
||
console.log(field);
|
||
console.log(data[field]);
|
||
if (data[field]){
|
||
if (field === "bond_number") {
|
||
for (i=0; i<data[field]; i++){
|
||
let UIDD = generateRowID();
|
||
let prefix=`${arrays_drop[`rep`][`bond`]}${UIDD}`;
|
||
updateAttrs[`${prefix}_name`] = `bond_${i}`;
|
||
updateAttrs[`${prefix}_test`] = `editable`;
|
||
}
|
||
}else if (data[field]==="name"){
|
||
updateAttrs[`profession`] = data[field];
|
||
}else{
|
||
updateAttrs[field] = data[field];
|
||
}
|
||
if (visible.includes(field)){
|
||
updateAttrs[`${field}_visible`]=`visible`;
|
||
}
|
||
}
|
||
}
|
||
|
||
console.info(`Agent:`,updateAttrs);
|
||
return updateAttrs;
|
||
}
|
||
|
||
const dropRepSkills = (data) => {
|
||
const updateAttrs = {};
|
||
let UIDD = generateRowID();
|
||
let prefix=`${arrays_drop[`rep`][`skill`]}${UIDD}`;
|
||
const dropskillfields=arrays_drop[`skill`];
|
||
dropskillfields.forEach(field =>{
|
||
updateAttrs[`${prefix}_${field}`] = data[field];
|
||
});
|
||
updateAttrs[`${prefix}_test`] = `editable`;
|
||
console.info(`repeating skills:`,updateAttrs);
|
||
return updateAttrs;
|
||
}
|
||
|
||
const dropSpecialTraining = (data) => {
|
||
const updateAttrs = {};
|
||
let UIDD = generateRowID();
|
||
var prefix=`${arrays_drop[`rep`][`special`]}${UIDD}`;
|
||
const dropspecialtrainingfields=arrays_drop[`special_training`];
|
||
dropspecialtrainingfields.forEach(field =>{
|
||
if (data[field]){
|
||
if (field === "skill_or_stat_used"){
|
||
let skillname=data[`skill_or_stat_used`].toLowerCase().replace(/ /g, "_");
|
||
updateAttrs[`${prefix}_skill_or_stat_used`] = `@{${skillname}}`;
|
||
}else{
|
||
updateAttrs[`${prefix}_${field}`] = data[field];
|
||
}
|
||
}
|
||
});
|
||
updateAttrs[`${prefix}_test`] = `editable`;
|
||
console.info(`special training:`, updateAttrs);
|
||
return updateAttrs;
|
||
}
|
||
|
||
/*
|
||
const dropRitual = (data) => {
|
||
const updateAttrs = {};
|
||
const UIDD = generateRowID();
|
||
const prefix=`repeating_rituals_${UIDD}`;
|
||
// to be updated when the format is decided
|
||
|
||
console.log(updateAttrs);
|
||
return updateAttrs;
|
||
}
|
||
|
||
const dropMonster = (data) => {
|
||
const updateAttrs = {};
|
||
updateAttrs[`sheet_type`] = "npc";
|
||
// to be updated when the format is decided
|
||
console.log(updateAttrs);
|
||
return updateAttrs;
|
||
}
|
||
*/
|
||
const dropWeapon = (data) => {
|
||
const updateAttrs = {};
|
||
let UIDD = generateRowID();
|
||
var prefix=`${arrays_drop[`rep`][`weapon`]}${UIDD}`;
|
||
|
||
const weaponfields=arrays_drop[`weapon`];
|
||
if (data.hasOwnProperty(weaponfields[2])==false){
|
||
console.warn(`weapon uses the repeating field format`);
|
||
data=isJSONString(data.repeating_weapons);
|
||
console.log(data);
|
||
}
|
||
|
||
updateAttrs[`${prefix}_test`] = 'editable';
|
||
for (const field of weaponfields){
|
||
if (data[field]){
|
||
if (field === "skill_percent"){
|
||
let skillname=cleanedSkill(data[field]);
|
||
console.info(skillname);
|
||
if (isSkillNumber(skillname)){
|
||
updateAttrs[`${prefix}_skill_percent`] = skillname;
|
||
}else if (isValidSkill(skillname)){
|
||
updateAttrs[`${prefix}_skill_percent`] = `@{${skillname}}`;
|
||
}else{
|
||
console.error(`skill not found: ${skillname}`);
|
||
}
|
||
}else{
|
||
updateAttrs[`${prefix}_${field}`] = data[field];
|
||
}
|
||
}
|
||
}
|
||
console.log(`weapon:`, updateAttrs);
|
||
return updateAttrs;
|
||
}
|
||
|
||
|
||
|
||
const getDropType = data => data.Category || false;
|
||
|
||
const handleDragandDrop = () => {
|
||
getAttrs(["drop_name","drop_data"], (v) => {
|
||
const {drop_name, drop_data} = v;
|
||
if (drop_name==="" || drop_data===""){return;}
|
||
const dropDataParsed =JSON.parse(drop_data);
|
||
const dropType = getDropType(dropDataParsed);
|
||
console.info(`drop type:`, dropType);
|
||
console.info('data:',dropDataParsed);
|
||
|
||
var updateAttrs = false;
|
||
if (dropType === "Agents"){
|
||
console.log("It's an Agent");
|
||
updateAttrs= dropAgent(dropDataParsed);
|
||
}
|
||
|
||
if (dropType === "Bonds"){
|
||
console.log("It's a Bond");
|
||
updateAttrs= dropBond(dropDataParsed);
|
||
}
|
||
if (dropType === "SpecialTrainings"){
|
||
console.log("It's an Special Training");
|
||
updateAttrs= dropSpecialTraining(dropDataParsed);
|
||
}
|
||
if (dropType === "Weapons"){
|
||
console.log("It's a Weapon");
|
||
|
||
updateAttrs= dropWeapon(dropDataParsed);
|
||
}
|
||
if (updateAttrs === false) {
|
||
updateAttrs = {...{drop_name:"", drop_data:"",drop_category:""}};
|
||
setAttrs(updateAttrs);
|
||
return console.warn("Drag and drop could not identify the type of drop");
|
||
}
|
||
if (typeof updateAttrs !== "object") {
|
||
updateAttrs = {...{drop_name:"", drop_data:"",drop_category:""}};
|
||
setAttrs(updateAttrs);
|
||
return console.warn("Drag and drop returned broken value");
|
||
}
|
||
const updateAttrsTot = {...updateAttrs, ...{drop_name:"", drop_data:"",drop_category:""}};
|
||
console.log(updateAttrsTot);
|
||
setAttrs(updateAttrsTot);
|
||
|
||
});
|
||
}
|
||
|
||
on("change:drop_data", (eventInfo) => {
|
||
const jsonData = JSON.parse(eventInfo.newValue);
|
||
console.log(jsonData);
|
||
handleDragandDrop();
|
||
// do something with data
|
||
});
|
||
on(`change:repeating_agents:name change:repeating_agents:test`, (eventInfo)=> {
|
||
const id = eventInfo.sourceAttribute.split(`_`)[2];
|
||
const repsecid = `repeating_agents_${id}`;
|
||
getAttrs([`${repsecid}_name`],(values)=> {
|
||
const update = {};
|
||
const info_to_get=['hit_points', 'willpower_points', 'sanity_points', 'strength_score', 'constitution_score']
|
||
const character_name = values[`repeating_agents_${`id`}_name`];
|
||
var string = ``;
|
||
info_to_get.forEach((field)=>{
|
||
string += `{{${field}=[[@{${character_name}|${field}]]}} `;
|
||
});
|
||
startRoll(string,results=>{
|
||
info_to_get.forEach((field)=>{
|
||
update[`${repsecid}_${field}`] = results.results[field].result;
|
||
});
|
||
|
||
setAttrs(update);
|
||
})
|
||
});
|
||
});
|