diff --git a/.gitignore b/.gitignore index a1292091..70f2d42e 100644 --- a/.gitignore +++ b/.gitignore @@ -194,3 +194,9 @@ pip-log.txt # Mac crap .DS_Store + + +############# +## PyCharm +############# +.idea \ No newline at end of file diff --git a/scripts/expertise/expertise_bh_absorbtion_1.py b/scripts/expertise/expertise_bh_absorbtion_1.py new file mode 100644 index 00000000..80b8479e --- /dev/null +++ b/scripts/expertise/expertise_bh_absorbtion_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_absorbtion_1') + + actor.addSkillMod('expertise_innate_protection_all', 125) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_absorbtion_1') + + actor.removeSkillMod('expertise_innate_protection_all', 125) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_absorbtion_2.py b/scripts/expertise/expertise_bh_absorbtion_2.py new file mode 100644 index 00000000..96a6ff72 --- /dev/null +++ b/scripts/expertise/expertise_bh_absorbtion_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_absorbtion_2') + + actor.addSkillMod('expertise_innate_protection_all', 125) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_absorbtion_2') + + actor.removeSkillMod('expertise_innate_protection_all', 125) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_absorbtion_3.py b/scripts/expertise/expertise_bh_absorbtion_3.py new file mode 100644 index 00000000..e46daa07 --- /dev/null +++ b/scripts/expertise/expertise_bh_absorbtion_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_absorbtion_3') + + actor.addSkillMod('expertise_innate_protection_all', 125) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_absorbtion_3') + + actor.removeSkillMod('expertise_innate_protection_all', 125) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_absorbtion_4.py b/scripts/expertise/expertise_bh_absorbtion_4.py new file mode 100644 index 00000000..f62d4493 --- /dev/null +++ b/scripts/expertise/expertise_bh_absorbtion_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_absorbtion_4') + + actor.addSkillMod('expertise_innate_protection_all', 125) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_absorbtion_4') + + actor.removeSkillMod('expertise_innate_protection_all', 125) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_agility_1.py b/scripts/expertise/expertise_bh_agility_1.py new file mode 100644 index 00000000..aab87823 --- /dev/null +++ b/scripts/expertise/expertise_bh_agility_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_agility_1') + + actor.addSkillMod('agility_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_agility_1') + + actor.removeSkillMod('agility_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_agility_2.py b/scripts/expertise/expertise_bh_agility_2.py new file mode 100644 index 00000000..2724b112 --- /dev/null +++ b/scripts/expertise/expertise_bh_agility_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_agility_2') + + actor.addSkillMod('agility_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_agility_2') + + actor.removeSkillMod('agility_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_agility_3.py b/scripts/expertise/expertise_bh_agility_3.py new file mode 100644 index 00000000..d869fbc4 --- /dev/null +++ b/scripts/expertise/expertise_bh_agility_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_agility_3') + + actor.addSkillMod('agility_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_agility_3') + + actor.removeSkillMod('agility_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_agility_4.py b/scripts/expertise/expertise_bh_agility_4.py new file mode 100644 index 00000000..6152ee4b --- /dev/null +++ b/scripts/expertise/expertise_bh_agility_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_agility_4') + + actor.addSkillMod('agility_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_agility_4') + + actor.removeSkillMod('agility_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_amb_act_1.py b/scripts/expertise/expertise_bh_amb_act_1.py new file mode 100644 index 00000000..7a0c4ee0 --- /dev/null +++ b/scripts/expertise/expertise_bh_amb_act_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_amb_act_1') + + actor.addSkillMod('expertise_action_line_dm_crit', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_amb_act_1') + + actor.removeSkillMod('expertise_action_line_dm_crit', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_amb_act_2.py b/scripts/expertise/expertise_bh_amb_act_2.py new file mode 100644 index 00000000..a19f7ba9 --- /dev/null +++ b/scripts/expertise/expertise_bh_amb_act_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_amb_act_2') + + actor.addSkillMod('expertise_action_line_dm_crit', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_amb_act_2') + + actor.removeSkillMod('expertise_action_line_dm_crit', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_amb_act_3.py b/scripts/expertise/expertise_bh_amb_act_3.py new file mode 100644 index 00000000..cb649c64 --- /dev/null +++ b/scripts/expertise/expertise_bh_amb_act_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_amb_act_3') + + actor.addSkillMod('expertise_action_line_dm_crit', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_amb_act_3') + + actor.removeSkillMod('expertise_action_line_dm_crit', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_amb_cool_1.py b/scripts/expertise/expertise_bh_amb_cool_1.py new file mode 100644 index 00000000..8749deaa --- /dev/null +++ b/scripts/expertise/expertise_bh_amb_cool_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_amb_cool_1') + + actor.addSkillMod('expertise_cooldown_line_dm_crit', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_amb_cool_1') + + actor.removeSkillMod('expertise_cooldown_line_dm_crit', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_amb_cool_2.py b/scripts/expertise/expertise_bh_amb_cool_2.py new file mode 100644 index 00000000..a7a26a52 --- /dev/null +++ b/scripts/expertise/expertise_bh_amb_cool_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_amb_cool_2') + + actor.addSkillMod('expertise_cooldown_line_dm_crit', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_amb_cool_2') + + actor.removeSkillMod('expertise_cooldown_line_dm_crit', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_amb_dam_1.py b/scripts/expertise/expertise_bh_amb_dam_1.py new file mode 100644 index 00000000..7d057532 --- /dev/null +++ b/scripts/expertise/expertise_bh_amb_dam_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_amb_dam_1') + + actor.addSkillMod('expertise_damage_line_dm_crit', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_amb_dam_1') + + actor.removeSkillMod('expertise_damage_line_dm_crit', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_amb_dam_2.py b/scripts/expertise/expertise_bh_amb_dam_2.py new file mode 100644 index 00000000..df566fbd --- /dev/null +++ b/scripts/expertise/expertise_bh_amb_dam_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_amb_dam_2') + + actor.addSkillMod('expertise_damage_line_dm_crit', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_amb_dam_2') + + actor.removeSkillMod('expertise_damage_line_dm_crit', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_amb_dam_3.py b/scripts/expertise/expertise_bh_amb_dam_3.py new file mode 100644 index 00000000..ba9a05e9 --- /dev/null +++ b/scripts/expertise/expertise_bh_amb_dam_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_amb_dam_3') + + actor.addSkillMod('expertise_damage_line_dm_crit', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_amb_dam_3') + + actor.removeSkillMod('expertise_damage_line_dm_crit', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_amb_dam_cool.py b/scripts/expertise/expertise_bh_amb_dam_cool.py new file mode 100644 index 00000000..1f9d3b03 --- /dev/null +++ b/scripts/expertise/expertise_bh_amb_dam_cool.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_amb_dam_cool') + + actor.addSkillMod('expertise_dm_crit_advanced', 1) + actor.addSkillMod('expertise_critical_line_dm_crit', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_amb_dam_cool') + + actor.removeSkillMod('expertise_dm_crit_advanced', 1) + actor.removeSkillMod('expertise_critical_line_dm_crit', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_armor_duelist_1.py b/scripts/expertise/expertise_bh_armor_duelist_1.py new file mode 100644 index 00000000..a8955362 --- /dev/null +++ b/scripts/expertise/expertise_bh_armor_duelist_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_armor_duelist_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_armor_duelist_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bh_armor_duelist_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bh_armor_duelist_1') + + return diff --git a/scripts/expertise/expertise_bh_armor_eng_1.py b/scripts/expertise/expertise_bh_armor_eng_1.py new file mode 100644 index 00000000..dfcf05f9 --- /dev/null +++ b/scripts/expertise/expertise_bh_armor_eng_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_armor_eng_1') + + actor.addSkillMod('expertise_innate_protection_energy', 500) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_armor_eng_1') + + actor.removeSkillMod('expertise_innate_protection_energy', 500) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_armor_eng_2.py b/scripts/expertise/expertise_bh_armor_eng_2.py new file mode 100644 index 00000000..c04179da --- /dev/null +++ b/scripts/expertise/expertise_bh_armor_eng_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_armor_eng_2') + + actor.addSkillMod('expertise_innate_protection_energy', 500) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_armor_eng_2') + + actor.removeSkillMod('expertise_innate_protection_energy', 500) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_armor_eng_3.py b/scripts/expertise/expertise_bh_armor_eng_3.py new file mode 100644 index 00000000..a175c1bc --- /dev/null +++ b/scripts/expertise/expertise_bh_armor_eng_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_armor_eng_3') + + actor.addSkillMod('expertise_innate_protection_energy', 500) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_armor_eng_3') + + actor.removeSkillMod('expertise_innate_protection_energy', 500) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_armor_eng_4.py b/scripts/expertise/expertise_bh_armor_eng_4.py new file mode 100644 index 00000000..5157fef5 --- /dev/null +++ b/scripts/expertise/expertise_bh_armor_eng_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_armor_eng_4') + + actor.addSkillMod('expertise_innate_protection_energy', 500) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_armor_eng_4') + + actor.removeSkillMod('expertise_innate_protection_energy', 500) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_armor_kin_1.py b/scripts/expertise/expertise_bh_armor_kin_1.py new file mode 100644 index 00000000..0f0fb7f5 --- /dev/null +++ b/scripts/expertise/expertise_bh_armor_kin_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_armor_kin_1') + + actor.addSkillMod('expertise_innate_protection_kinetic', 500) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_armor_kin_1') + + actor.removeSkillMod('expertise_innate_protection_kinetic', 500) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_armor_kin_2.py b/scripts/expertise/expertise_bh_armor_kin_2.py new file mode 100644 index 00000000..c4897930 --- /dev/null +++ b/scripts/expertise/expertise_bh_armor_kin_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_armor_kin_2') + + actor.addSkillMod('expertise_innate_protection_kinetic', 500) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_armor_kin_2') + + actor.removeSkillMod('expertise_innate_protection_kinetic', 500) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_armor_kin_3.py b/scripts/expertise/expertise_bh_armor_kin_3.py new file mode 100644 index 00000000..2eacb73d --- /dev/null +++ b/scripts/expertise/expertise_bh_armor_kin_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_armor_kin_3') + + actor.addSkillMod('expertise_innate_protection_kinetic', 500) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_armor_kin_3') + + actor.removeSkillMod('expertise_innate_protection_kinetic', 500) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_armor_kin_4.py b/scripts/expertise/expertise_bh_armor_kin_4.py new file mode 100644 index 00000000..7d0980cc --- /dev/null +++ b/scripts/expertise/expertise_bh_armor_kin_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_armor_kin_4') + + actor.addSkillMod('expertise_innate_protection_kinetic', 500) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_armor_kin_4') + + actor.removeSkillMod('expertise_innate_protection_kinetic', 500) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_armor_mgb_1.py b/scripts/expertise/expertise_bh_armor_mgb_1.py new file mode 100644 index 00000000..b96d73ae --- /dev/null +++ b/scripts/expertise/expertise_bh_armor_mgb_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_armor_mgb_1') + + actor.addSkillMod('expertise_dodge', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_armor_mgb_1') + + actor.removeSkillMod('expertise_dodge', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_armor_mgb_2.py b/scripts/expertise/expertise_bh_armor_mgb_2.py new file mode 100644 index 00000000..3712b6e1 --- /dev/null +++ b/scripts/expertise/expertise_bh_armor_mgb_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_armor_mgb_2') + + actor.addSkillMod('expertise_dodge', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_armor_mgb_2') + + actor.removeSkillMod('expertise_dodge', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_armor_mgb_3.py b/scripts/expertise/expertise_bh_armor_mgb_3.py new file mode 100644 index 00000000..10a05268 --- /dev/null +++ b/scripts/expertise/expertise_bh_armor_mgb_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_armor_mgb_3') + + actor.addSkillMod('expertise_dodge', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_armor_mgb_3') + + actor.removeSkillMod('expertise_dodge', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_armor_rgb_1.py b/scripts/expertise/expertise_bh_armor_rgb_1.py new file mode 100644 index 00000000..d529151c --- /dev/null +++ b/scripts/expertise/expertise_bh_armor_rgb_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_armor_rgb_1') + + actor.addSkillMod('expertise_critical_hit_reduction', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_armor_rgb_1') + + actor.removeSkillMod('expertise_critical_hit_reduction', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_armor_rgb_2.py b/scripts/expertise/expertise_bh_armor_rgb_2.py new file mode 100644 index 00000000..54da7d9e --- /dev/null +++ b/scripts/expertise/expertise_bh_armor_rgb_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_armor_rgb_2') + + actor.addSkillMod('expertise_critical_hit_reduction', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_armor_rgb_2') + + actor.removeSkillMod('expertise_critical_hit_reduction', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_armor_rgb_3.py b/scripts/expertise/expertise_bh_armor_rgb_3.py new file mode 100644 index 00000000..c94386c5 --- /dev/null +++ b/scripts/expertise/expertise_bh_armor_rgb_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_armor_rgb_3') + + actor.addSkillMod('expertise_critical_hit_reduction', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_armor_rgb_3') + + actor.removeSkillMod('expertise_critical_hit_reduction', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_armor_sprint_1.py b/scripts/expertise/expertise_bh_armor_sprint_1.py new file mode 100644 index 00000000..247c23e1 --- /dev/null +++ b/scripts/expertise/expertise_bh_armor_sprint_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_armor_sprint_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_armor_sprint_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bh_armor_sprint_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bh_armor_sprint_1') + + return diff --git a/scripts/expertise/expertise_bh_ass_act_1.py b/scripts/expertise/expertise_bh_ass_act_1.py new file mode 100644 index 00000000..4b60f445 --- /dev/null +++ b/scripts/expertise/expertise_bh_ass_act_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_ass_act_1') + + actor.addSkillMod('expertise_action_line_dm', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_ass_act_1') + + actor.removeSkillMod('expertise_action_line_dm', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_ass_act_2.py b/scripts/expertise/expertise_bh_ass_act_2.py new file mode 100644 index 00000000..07f25018 --- /dev/null +++ b/scripts/expertise/expertise_bh_ass_act_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_ass_act_2') + + actor.addSkillMod('expertise_action_line_dm', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_ass_act_2') + + actor.removeSkillMod('expertise_action_line_dm', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_ass_act_3.py b/scripts/expertise/expertise_bh_ass_act_3.py new file mode 100644 index 00000000..c24cbdd3 --- /dev/null +++ b/scripts/expertise/expertise_bh_ass_act_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_ass_act_3') + + actor.addSkillMod('expertise_action_line_dm', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_ass_act_3') + + actor.removeSkillMod('expertise_action_line_dm', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_ass_cool_1.py b/scripts/expertise/expertise_bh_ass_cool_1.py new file mode 100644 index 00000000..aaff3675 --- /dev/null +++ b/scripts/expertise/expertise_bh_ass_cool_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_ass_cool_1') + + actor.addSkillMod('expertise_cooldown_line_dm', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_ass_cool_1') + + actor.removeSkillMod('expertise_cooldown_line_dm', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_ass_cool_2.py b/scripts/expertise/expertise_bh_ass_cool_2.py new file mode 100644 index 00000000..af01e9aa --- /dev/null +++ b/scripts/expertise/expertise_bh_ass_cool_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_ass_cool_2') + + actor.addSkillMod('expertise_cooldown_line_dm', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_ass_cool_2') + + actor.removeSkillMod('expertise_cooldown_line_dm', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_ass_dam_1.py b/scripts/expertise/expertise_bh_ass_dam_1.py new file mode 100644 index 00000000..04fb74e7 --- /dev/null +++ b/scripts/expertise/expertise_bh_ass_dam_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_ass_dam_1') + + actor.addSkillMod('expertise_damage_line_dm', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_ass_dam_1') + + actor.removeSkillMod('expertise_damage_line_dm', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_ass_dam_2.py b/scripts/expertise/expertise_bh_ass_dam_2.py new file mode 100644 index 00000000..ea7ec873 --- /dev/null +++ b/scripts/expertise/expertise_bh_ass_dam_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_ass_dam_2') + + actor.addSkillMod('expertise_damage_line_dm', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_ass_dam_2') + + actor.removeSkillMod('expertise_damage_line_dm', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_ass_dam_3.py b/scripts/expertise/expertise_bh_ass_dam_3.py new file mode 100644 index 00000000..7fce7d94 --- /dev/null +++ b/scripts/expertise/expertise_bh_ass_dam_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_ass_dam_3') + + actor.addSkillMod('expertise_damage_line_dm', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_ass_dam_3') + + actor.removeSkillMod('expertise_damage_line_dm', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_carbine_act_1.py b/scripts/expertise/expertise_bh_carbine_act_1.py new file mode 100644 index 00000000..ce2dd758 --- /dev/null +++ b/scripts/expertise/expertise_bh_carbine_act_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_carbine_act_1') + + actor.addSkillMod('expertise_action_weapon_1', 3) + actor.addSkillMod('expertise_action_weapon_2', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_carbine_act_1') + + actor.removeSkillMod('expertise_action_weapon_1', 3) + actor.removeSkillMod('expertise_action_weapon_2', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_carbine_act_2.py b/scripts/expertise/expertise_bh_carbine_act_2.py new file mode 100644 index 00000000..bb494e3f --- /dev/null +++ b/scripts/expertise/expertise_bh_carbine_act_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_carbine_act_2') + + actor.addSkillMod('expertise_action_weapon_1', 3) + actor.addSkillMod('expertise_action_weapon_2', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_carbine_act_2') + + actor.removeSkillMod('expertise_action_weapon_1', 3) + actor.removeSkillMod('expertise_action_weapon_2', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_carbine_act_3.py b/scripts/expertise/expertise_bh_carbine_act_3.py new file mode 100644 index 00000000..6f07762a --- /dev/null +++ b/scripts/expertise/expertise_bh_carbine_act_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_carbine_act_3') + + actor.addSkillMod('expertise_action_weapon_1', 4) + actor.addSkillMod('expertise_action_weapon_2', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_carbine_act_3') + + actor.removeSkillMod('expertise_action_weapon_1', 4) + actor.removeSkillMod('expertise_action_weapon_2', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_carbine_act_4.py b/scripts/expertise/expertise_bh_carbine_act_4.py new file mode 100644 index 00000000..96142cc2 --- /dev/null +++ b/scripts/expertise/expertise_bh_carbine_act_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_carbine_act_4') + + actor.addSkillMod('expertise_action_weapon_1', 5) + actor.addSkillMod('expertise_action_weapon_2', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_carbine_act_4') + + actor.removeSkillMod('expertise_action_weapon_1', 5) + actor.removeSkillMod('expertise_action_weapon_2', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_carbine_crit_1.py b/scripts/expertise/expertise_bh_carbine_crit_1.py new file mode 100644 index 00000000..131db4c7 --- /dev/null +++ b/scripts/expertise/expertise_bh_carbine_crit_1.py @@ -0,0 +1,54 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_carbine_crit_1') + + actor.addSkillMod('expertise_range_bonus_carbine', 10) + actor.addSkillMod('expertise_undiminished_critical_carbine', 10) + actor.addSkillMod('expertise_undiminished_critical_pistol', 10) + actor.addSkillMod('expertise_range_bonus_pistol', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_carbine_crit_1') + + actor.removeSkillMod('expertise_range_bonus_carbine', 10) + actor.removeSkillMod('expertise_undiminished_critical_carbine', 10) + actor.removeSkillMod('expertise_undiminished_critical_pistol', 10) + actor.removeSkillMod('expertise_range_bonus_pistol', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_carbine_dam_1.py b/scripts/expertise/expertise_bh_carbine_dam_1.py new file mode 100644 index 00000000..4681ff5a --- /dev/null +++ b/scripts/expertise/expertise_bh_carbine_dam_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_carbine_dam_1') + + actor.addSkillMod('expertise_damage_weapon_1', 2) + actor.addSkillMod('expertise_damage_weapon_2', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_carbine_dam_1') + + actor.removeSkillMod('expertise_damage_weapon_1', 2) + actor.removeSkillMod('expertise_damage_weapon_2', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_carbine_dam_2.py b/scripts/expertise/expertise_bh_carbine_dam_2.py new file mode 100644 index 00000000..bca390dc --- /dev/null +++ b/scripts/expertise/expertise_bh_carbine_dam_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_carbine_dam_2') + + actor.addSkillMod('expertise_damage_weapon_1', 3) + actor.addSkillMod('expertise_damage_weapon_2', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_carbine_dam_2') + + actor.removeSkillMod('expertise_damage_weapon_1', 3) + actor.removeSkillMod('expertise_damage_weapon_2', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_constitution_1.py b/scripts/expertise/expertise_bh_constitution_1.py new file mode 100644 index 00000000..bf9c095e --- /dev/null +++ b/scripts/expertise/expertise_bh_constitution_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_constitution_1') + + actor.addSkillMod('constitution_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_constitution_1') + + actor.removeSkillMod('constitution_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_constitution_2.py b/scripts/expertise/expertise_bh_constitution_2.py new file mode 100644 index 00000000..a7a36229 --- /dev/null +++ b/scripts/expertise/expertise_bh_constitution_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_constitution_2') + + actor.addSkillMod('constitution_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_constitution_2') + + actor.removeSkillMod('constitution_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_constitution_3.py b/scripts/expertise/expertise_bh_constitution_3.py new file mode 100644 index 00000000..4259b57a --- /dev/null +++ b/scripts/expertise/expertise_bh_constitution_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_constitution_3') + + actor.addSkillMod('constitution_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_constitution_3') + + actor.removeSkillMod('constitution_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_constitution_4.py b/scripts/expertise/expertise_bh_constitution_4.py new file mode 100644 index 00000000..dd89792b --- /dev/null +++ b/scripts/expertise/expertise_bh_constitution_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_constitution_4') + + actor.addSkillMod('constitution_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_constitution_4') + + actor.removeSkillMod('constitution_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_cover_1.py b/scripts/expertise/expertise_bh_cover_1.py new file mode 100644 index 00000000..019850cd --- /dev/null +++ b/scripts/expertise/expertise_bh_cover_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_cover_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_cover_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bh_cover_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bh_cover_1') + + return diff --git a/scripts/expertise/expertise_bh_deflection_1.py b/scripts/expertise/expertise_bh_deflection_1.py new file mode 100644 index 00000000..ab02e0a6 --- /dev/null +++ b/scripts/expertise/expertise_bh_deflection_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_deflection_1') + + actor.addSkillMod('expertise_innate_protection_all', 250) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_deflection_1') + + actor.removeSkillMod('expertise_innate_protection_all', 250) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_deflection_2.py b/scripts/expertise/expertise_bh_deflection_2.py new file mode 100644 index 00000000..33b98bf0 --- /dev/null +++ b/scripts/expertise/expertise_bh_deflection_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_deflection_2') + + actor.addSkillMod('expertise_innate_protection_all', 250) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_deflection_2') + + actor.removeSkillMod('expertise_innate_protection_all', 250) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_deflection_3.py b/scripts/expertise/expertise_bh_deflection_3.py new file mode 100644 index 00000000..c408ca42 --- /dev/null +++ b/scripts/expertise/expertise_bh_deflection_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_deflection_3') + + actor.addSkillMod('expertise_innate_protection_all', 250) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_deflection_3') + + actor.removeSkillMod('expertise_innate_protection_all', 250) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_deflection_4.py b/scripts/expertise/expertise_bh_deflection_4.py new file mode 100644 index 00000000..b5e42e86 --- /dev/null +++ b/scripts/expertise/expertise_bh_deflection_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_deflection_4') + + actor.addSkillMod('expertise_innate_protection_all', 250) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_deflection_4') + + actor.removeSkillMod('expertise_innate_protection_all', 250) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_dread_strike_1.py b/scripts/expertise/expertise_bh_dread_strike_1.py new file mode 100644 index 00000000..f7598134 --- /dev/null +++ b/scripts/expertise/expertise_bh_dread_strike_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_dread_strike_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_dread_strike_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bh_dread_strike_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bh_dread_strike_1') + + return diff --git a/scripts/expertise/expertise_bh_fumble_1.py b/scripts/expertise/expertise_bh_fumble_1.py new file mode 100644 index 00000000..c3863158 --- /dev/null +++ b/scripts/expertise/expertise_bh_fumble_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_fumble_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_fumble_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bh_fumble_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bh_fumble_1') + + return diff --git a/scripts/expertise/expertise_bh_innate_1.py b/scripts/expertise/expertise_bh_innate_1.py new file mode 100644 index 00000000..1f013597 --- /dev/null +++ b/scripts/expertise/expertise_bh_innate_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_innate_1') + + actor.addSkillMod('expertise_assult_action_buff', 40) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_innate_1') + + actor.removeSkillMod('expertise_assult_action_buff', 40) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_intimidate_1.py b/scripts/expertise/expertise_bh_intimidate_1.py new file mode 100644 index 00000000..fa501d18 --- /dev/null +++ b/scripts/expertise/expertise_bh_intimidate_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_intimidate_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_intimidate_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bh_intimidate_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bh_intimidate_1') + + return diff --git a/scripts/expertise/expertise_bh_man_crit_1.py b/scripts/expertise/expertise_bh_man_crit_1.py new file mode 100644 index 00000000..834f9dec --- /dev/null +++ b/scripts/expertise/expertise_bh_man_crit_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_man_crit_1') + + actor.addSkillMod('expertise_strikethrough_chance', 2) + actor.addSkillMod('expertise_bh_detect_camo_chance', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_man_crit_1') + + actor.removeSkillMod('expertise_strikethrough_chance', 2) + actor.removeSkillMod('expertise_bh_detect_camo_chance', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_man_crit_2.py b/scripts/expertise/expertise_bh_man_crit_2.py new file mode 100644 index 00000000..b9650fe3 --- /dev/null +++ b/scripts/expertise/expertise_bh_man_crit_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_man_crit_2') + + actor.addSkillMod('expertise_strikethrough_chance', 2) + actor.addSkillMod('expertise_bh_detect_camo_chance', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_man_crit_2') + + actor.removeSkillMod('expertise_strikethrough_chance', 2) + actor.removeSkillMod('expertise_bh_detect_camo_chance', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_man_crit_3.py b/scripts/expertise/expertise_bh_man_crit_3.py new file mode 100644 index 00000000..da3e6f06 --- /dev/null +++ b/scripts/expertise/expertise_bh_man_crit_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_man_crit_3') + + actor.addSkillMod('expertise_strikethrough_chance', 2) + actor.addSkillMod('expertise_bh_detect_camo_chance', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_man_crit_3') + + actor.removeSkillMod('expertise_strikethrough_chance', 2) + actor.removeSkillMod('expertise_bh_detect_camo_chance', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_precision_1.py b/scripts/expertise/expertise_bh_precision_1.py new file mode 100644 index 00000000..7004f208 --- /dev/null +++ b/scripts/expertise/expertise_bh_precision_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_precision_1') + + actor.addSkillMod('precision_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_precision_1') + + actor.removeSkillMod('precision_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_precision_2.py b/scripts/expertise/expertise_bh_precision_2.py new file mode 100644 index 00000000..58cb5095 --- /dev/null +++ b/scripts/expertise/expertise_bh_precision_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_precision_2') + + actor.addSkillMod('precision_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_precision_2') + + actor.removeSkillMod('precision_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_precision_3.py b/scripts/expertise/expertise_bh_precision_3.py new file mode 100644 index 00000000..32fa6e4c --- /dev/null +++ b/scripts/expertise/expertise_bh_precision_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_precision_3') + + actor.addSkillMod('precision_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_precision_3') + + actor.removeSkillMod('precision_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_precision_4.py b/scripts/expertise/expertise_bh_precision_4.py new file mode 100644 index 00000000..9ff20b56 --- /dev/null +++ b/scripts/expertise/expertise_bh_precision_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_precision_4') + + actor.addSkillMod('precision_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_precision_4') + + actor.removeSkillMod('precision_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_prescience.py b/scripts/expertise/expertise_bh_prescience.py new file mode 100644 index 00000000..8211d2f6 --- /dev/null +++ b/scripts/expertise/expertise_bh_prescience.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_prescience') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_prescience') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bh_prescience') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bh_prescience') + + return diff --git a/scripts/expertise/expertise_bh_relentless_1.py b/scripts/expertise/expertise_bh_relentless_1.py new file mode 100644 index 00000000..16584560 --- /dev/null +++ b/scripts/expertise/expertise_bh_relentless_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_relentless_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_relentless_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bh_relentless_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bh_relentless_1') + + return diff --git a/scripts/expertise/expertise_bh_return_fire_1.py b/scripts/expertise/expertise_bh_return_fire_1.py new file mode 100644 index 00000000..27d39f22 --- /dev/null +++ b/scripts/expertise/expertise_bh_return_fire_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_return_fire_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_return_fire_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bh_return_fire_command_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bh_return_fire_command_1') + + return diff --git a/scripts/expertise/expertise_bh_rifle_act_1.py b/scripts/expertise/expertise_bh_rifle_act_1.py new file mode 100644 index 00000000..c64ab6fd --- /dev/null +++ b/scripts/expertise/expertise_bh_rifle_act_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_rifle_act_1') + + actor.addSkillMod('expertise_action_weapon_0', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_rifle_act_1') + + actor.removeSkillMod('expertise_action_weapon_0', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_rifle_act_2.py b/scripts/expertise/expertise_bh_rifle_act_2.py new file mode 100644 index 00000000..f1488c3f --- /dev/null +++ b/scripts/expertise/expertise_bh_rifle_act_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_rifle_act_2') + + actor.addSkillMod('expertise_action_weapon_0', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_rifle_act_2') + + actor.removeSkillMod('expertise_action_weapon_0', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_rifle_act_3.py b/scripts/expertise/expertise_bh_rifle_act_3.py new file mode 100644 index 00000000..709fdfec --- /dev/null +++ b/scripts/expertise/expertise_bh_rifle_act_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_rifle_act_3') + + actor.addSkillMod('expertise_action_weapon_0', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_rifle_act_3') + + actor.removeSkillMod('expertise_action_weapon_0', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_rifle_act_4.py b/scripts/expertise/expertise_bh_rifle_act_4.py new file mode 100644 index 00000000..fc0549fa --- /dev/null +++ b/scripts/expertise/expertise_bh_rifle_act_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_rifle_act_4') + + actor.addSkillMod('expertise_action_weapon_0', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_rifle_act_4') + + actor.removeSkillMod('expertise_action_weapon_0', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_rifle_dam_1.py b/scripts/expertise/expertise_bh_rifle_dam_1.py new file mode 100644 index 00000000..9c3114cc --- /dev/null +++ b/scripts/expertise/expertise_bh_rifle_dam_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_rifle_dam_1') + + actor.addSkillMod('expertise_damage_weapon_0', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_rifle_dam_1') + + actor.removeSkillMod('expertise_damage_weapon_0', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_rifle_dam_2.py b/scripts/expertise/expertise_bh_rifle_dam_2.py new file mode 100644 index 00000000..43fa09b4 --- /dev/null +++ b/scripts/expertise/expertise_bh_rifle_dam_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_rifle_dam_2') + + actor.addSkillMod('expertise_damage_weapon_0', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_rifle_dam_2') + + actor.removeSkillMod('expertise_damage_weapon_0', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_shields_1.py b/scripts/expertise/expertise_bh_shields_1.py new file mode 100644 index 00000000..cc0b0b50 --- /dev/null +++ b/scripts/expertise/expertise_bh_shields_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_shields_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_shields_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bh_shields_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bh_shields_1') + + return diff --git a/scripts/expertise/expertise_bh_sniper_1.py b/scripts/expertise/expertise_bh_sniper_1.py new file mode 100644 index 00000000..5d90b6af --- /dev/null +++ b/scripts/expertise/expertise_bh_sniper_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_sniper_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_sniper_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bh_sniper_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bh_sniper_1') + + return diff --git a/scripts/expertise/expertise_bh_stamina_1.py b/scripts/expertise/expertise_bh_stamina_1.py new file mode 100644 index 00000000..135dfb5a --- /dev/null +++ b/scripts/expertise/expertise_bh_stamina_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_stamina_1') + + actor.addSkillMod('stamina_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_stamina_1') + + actor.removeSkillMod('stamina_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_stamina_2.py b/scripts/expertise/expertise_bh_stamina_2.py new file mode 100644 index 00000000..82137a73 --- /dev/null +++ b/scripts/expertise/expertise_bh_stamina_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_stamina_2') + + actor.addSkillMod('stamina_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_stamina_2') + + actor.removeSkillMod('stamina_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_stamina_3.py b/scripts/expertise/expertise_bh_stamina_3.py new file mode 100644 index 00000000..4a9d9c79 --- /dev/null +++ b/scripts/expertise/expertise_bh_stamina_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_stamina_3') + + actor.addSkillMod('stamina_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_stamina_3') + + actor.removeSkillMod('stamina_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_stamina_4.py b/scripts/expertise/expertise_bh_stamina_4.py new file mode 100644 index 00000000..b4bec72c --- /dev/null +++ b/scripts/expertise/expertise_bh_stamina_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_stamina_4') + + actor.addSkillMod('stamina_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_stamina_4') + + actor.removeSkillMod('stamina_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_stun_1.py b/scripts/expertise/expertise_bh_stun_1.py new file mode 100644 index 00000000..63fbb815 --- /dev/null +++ b/scripts/expertise/expertise_bh_stun_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_stun_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_stun_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bh_stun_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bh_stun_1') + + return diff --git a/scripts/expertise/expertise_bh_surprise_1.py b/scripts/expertise/expertise_bh_surprise_1.py new file mode 100644 index 00000000..362f3be0 --- /dev/null +++ b/scripts/expertise/expertise_bh_surprise_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_surprise_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_surprise_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bh_dm_crit_3') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bh_dm_crit_3') + + return diff --git a/scripts/expertise/expertise_bh_survival_instinct_1.py b/scripts/expertise/expertise_bh_survival_instinct_1.py new file mode 100644 index 00000000..720ddfe0 --- /dev/null +++ b/scripts/expertise/expertise_bh_survival_instinct_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_survival_instinct_1') + + actor.addSkillMod('expertise_cooldown_line_sh', 20) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_survival_instinct_1') + + actor.removeSkillMod('expertise_cooldown_line_sh', 20) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_survival_instinct_2.py b/scripts/expertise/expertise_bh_survival_instinct_2.py new file mode 100644 index 00000000..9fbce1d0 --- /dev/null +++ b/scripts/expertise/expertise_bh_survival_instinct_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_survival_instinct_2') + + actor.addSkillMod('expertise_cooldown_line_sh', 20) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_survival_instinct_2') + + actor.removeSkillMod('expertise_cooldown_line_sh', 20) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_taunt_1.py b/scripts/expertise/expertise_bh_taunt_1.py new file mode 100644 index 00000000..9fa48b82 --- /dev/null +++ b/scripts/expertise/expertise_bh_taunt_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_taunt_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_taunt_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bh_taunt_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bh_taunt_1') + + return diff --git a/scripts/expertise/expertise_bh_trap_dam_1.py b/scripts/expertise/expertise_bh_trap_dam_1.py new file mode 100644 index 00000000..debbc5b2 --- /dev/null +++ b/scripts/expertise/expertise_bh_trap_dam_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_trap_dam_1') + + actor.addSkillMod('expertise_damage_line_dm_cc', 5) + actor.addSkillMod('expertise_action_line_dm_cc', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_trap_dam_1') + + actor.removeSkillMod('expertise_damage_line_dm_cc', 5) + actor.removeSkillMod('expertise_action_line_dm_cc', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_trap_dam_2.py b/scripts/expertise/expertise_bh_trap_dam_2.py new file mode 100644 index 00000000..34f1cfa9 --- /dev/null +++ b/scripts/expertise/expertise_bh_trap_dam_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_trap_dam_2') + + actor.addSkillMod('expertise_damage_line_dm_cc', 5) + actor.addSkillMod('expertise_action_line_dm_cc', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_trap_dam_2') + + actor.removeSkillMod('expertise_damage_line_dm_cc', 5) + actor.removeSkillMod('expertise_action_line_dm_cc', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_trap_dam_3.py b/scripts/expertise/expertise_bh_trap_dam_3.py new file mode 100644 index 00000000..d8df37c2 --- /dev/null +++ b/scripts/expertise/expertise_bh_trap_dam_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_trap_dam_3') + + actor.addSkillMod('expertise_damage_line_dm_cc', 5) + actor.addSkillMod('expertise_action_line_dm_cc', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_trap_dam_3') + + actor.removeSkillMod('expertise_damage_line_dm_cc', 5) + actor.removeSkillMod('expertise_action_line_dm_cc', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_trap_dam_4.py b/scripts/expertise/expertise_bh_trap_dam_4.py new file mode 100644 index 00000000..895fa7ed --- /dev/null +++ b/scripts/expertise/expertise_bh_trap_dam_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_trap_dam_4') + + actor.addSkillMod('expertise_damage_line_dm_cc', 5) + actor.addSkillMod('expertise_action_line_dm_cc', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_trap_dam_4') + + actor.removeSkillMod('expertise_damage_line_dm_cc', 5) + actor.removeSkillMod('expertise_action_line_dm_cc', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_trap_duration_1.py b/scripts/expertise/expertise_bh_trap_duration_1.py new file mode 100644 index 00000000..a24b5591 --- /dev/null +++ b/scripts/expertise/expertise_bh_trap_duration_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_trap_duration_1') + + actor.addSkillMod('expertise_buff_duration_group_snare', 1) + actor.addSkillMod('expertise_cooldown_line_dm_cc', 20) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_trap_duration_1') + + actor.removeSkillMod('expertise_buff_duration_group_snare', 1) + actor.removeSkillMod('expertise_cooldown_line_dm_cc', 20) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_trap_duration_2.py b/scripts/expertise/expertise_bh_trap_duration_2.py new file mode 100644 index 00000000..4c312043 --- /dev/null +++ b/scripts/expertise/expertise_bh_trap_duration_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_trap_duration_2') + + actor.addSkillMod('expertise_buff_duration_group_snare', 1) + actor.addSkillMod('expertise_cooldown_line_dm_cc', 20) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_trap_duration_2') + + actor.removeSkillMod('expertise_buff_duration_group_snare', 1) + actor.removeSkillMod('expertise_cooldown_line_dm_cc', 20) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_trap_duration_3.py b/scripts/expertise/expertise_bh_trap_duration_3.py new file mode 100644 index 00000000..409ba235 --- /dev/null +++ b/scripts/expertise/expertise_bh_trap_duration_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_trap_duration_3') + + actor.addSkillMod('expertise_buff_duration_group_snare', 1) + actor.addSkillMod('expertise_cooldown_line_dm_cc', 20) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_trap_duration_3') + + actor.removeSkillMod('expertise_buff_duration_group_snare', 1) + actor.removeSkillMod('expertise_cooldown_line_dm_cc', 20) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_trap_rng_1.py b/scripts/expertise/expertise_bh_trap_rng_1.py new file mode 100644 index 00000000..3da9ced9 --- /dev/null +++ b/scripts/expertise/expertise_bh_trap_rng_1.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_trap_rng_1') + + actor.addSkillMod('expertise_area_size_line_trap', 1) + actor.addSkillMod('expertise_area_size_line_diretrap', 1) + actor.addSkillMod('expertise_action_line_trap', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_trap_rng_1') + + actor.removeSkillMod('expertise_area_size_line_trap', 1) + actor.removeSkillMod('expertise_area_size_line_diretrap', 1) + actor.removeSkillMod('expertise_action_line_trap', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bh_trap_rng_2.py b/scripts/expertise/expertise_bh_trap_rng_2.py new file mode 100644 index 00000000..0d853136 --- /dev/null +++ b/scripts/expertise/expertise_bh_trap_rng_2.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.addSkill('expertise_bh_trap_rng_2') + + actor.addSkillMod('expertise_area_size_line_trap', 1) + actor.addSkillMod('expertise_area_size_line_diretrap', 1) + actor.addSkillMod('expertise_action_line_trap', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'bounty_hunter_1a': + return + + actor.removeSkill('expertise_bh_trap_rng_2') + + actor.removeSkillMod('expertise_area_size_line_trap', 1) + actor.removeSkillMod('expertise_area_size_line_diretrap', 1) + actor.removeSkillMod('expertise_action_line_trap', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_abilility_aquisition_mod_1.py b/scripts/expertise/expertise_bm_abilility_aquisition_mod_1.py new file mode 100644 index 00000000..5a44b9cb --- /dev/null +++ b/scripts/expertise/expertise_bm_abilility_aquisition_mod_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_abilility_aquisition_mod_1') + + actor.addSkillMod('expertise_bm_enhanced_skill_acquisition', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_abilility_aquisition_mod_1') + + actor.removeSkillMod('expertise_bm_enhanced_skill_acquisition', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_add_first_pet_bar_1.py b/scripts/expertise/expertise_bm_add_first_pet_bar_1.py new file mode 100644 index 00000000..aca29011 --- /dev/null +++ b/scripts/expertise/expertise_bm_add_first_pet_bar_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_add_first_pet_bar_1') + + actor.addSkillMod('expertise_bm_add_pet_bar', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_add_first_pet_bar_1') + + actor.removeSkillMod('expertise_bm_add_pet_bar', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_add_second_pet_bar_1.py b/scripts/expertise/expertise_bm_add_second_pet_bar_1.py new file mode 100644 index 00000000..385f1057 --- /dev/null +++ b/scripts/expertise/expertise_bm_add_second_pet_bar_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_add_second_pet_bar_1') + + actor.addSkillMod('expertise_bm_add_pet_bar', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_add_second_pet_bar_1') + + actor.removeSkillMod('expertise_bm_add_pet_bar', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_add_third_pet_bar_1.py b/scripts/expertise/expertise_bm_add_third_pet_bar_1.py new file mode 100644 index 00000000..607cc8c8 --- /dev/null +++ b/scripts/expertise/expertise_bm_add_third_pet_bar_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_add_third_pet_bar_1') + + actor.addSkillMod('expertise_bm_add_pet_bar', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_add_third_pet_bar_1') + + actor.removeSkillMod('expertise_bm_add_pet_bar', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_attack_1.py b/scripts/expertise/expertise_bm_attack_1.py new file mode 100644 index 00000000..8b6f795c --- /dev/null +++ b/scripts/expertise/expertise_bm_attack_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_attack_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_attack_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bm_pet_attack_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bm_pet_attack_1') + + return diff --git a/scripts/expertise/expertise_bm_beast_mastery_1.py b/scripts/expertise/expertise_bm_beast_mastery_1.py new file mode 100644 index 00000000..e467a281 --- /dev/null +++ b/scripts/expertise/expertise_bm_beast_mastery_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_beast_mastery_1') + + actor.addSkillMod('expertise_bm_self_debuff_reduction', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_beast_mastery_1') + + actor.removeSkillMod('expertise_bm_self_debuff_reduction', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_creature_knowledge_command_1.py b/scripts/expertise/expertise_bm_creature_knowledge_command_1.py new file mode 100644 index 00000000..3f50c6cd --- /dev/null +++ b/scripts/expertise/expertise_bm_creature_knowledge_command_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_creature_knowledge_command_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_creature_knowledge_command_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bm_creature_knowledge_command_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bm_creature_knowledge_command_1') + + return diff --git a/scripts/expertise/expertise_bm_dexterity_training_1.py b/scripts/expertise/expertise_bm_dexterity_training_1.py new file mode 100644 index 00000000..4162179d --- /dev/null +++ b/scripts/expertise/expertise_bm_dexterity_training_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_dexterity_training_1') + + actor.addSkillMod('expertise_bm_pet_attack_speed', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_dexterity_training_1') + + actor.removeSkillMod('expertise_bm_pet_attack_speed', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_dexterity_training_2.py b/scripts/expertise/expertise_bm_dexterity_training_2.py new file mode 100644 index 00000000..f3c66370 --- /dev/null +++ b/scripts/expertise/expertise_bm_dexterity_training_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_dexterity_training_2') + + actor.addSkillMod('expertise_bm_pet_attack_speed', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_dexterity_training_2') + + actor.removeSkillMod('expertise_bm_pet_attack_speed', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_dna_harvesting_1.py b/scripts/expertise/expertise_bm_dna_harvesting_1.py new file mode 100644 index 00000000..ee8aad65 --- /dev/null +++ b/scripts/expertise/expertise_bm_dna_harvesting_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_dna_harvesting_1') + + actor.addSkillMod('expertise_bm_dna_harvesting_1', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_dna_harvesting_1') + + actor.removeSkillMod('expertise_bm_dna_harvesting_1', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_dna_harvesting_2.py b/scripts/expertise/expertise_bm_dna_harvesting_2.py new file mode 100644 index 00000000..5c0b2044 --- /dev/null +++ b/scripts/expertise/expertise_bm_dna_harvesting_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_dna_harvesting_2') + + actor.addSkillMod('expertise_bm_dna_harvesting_1', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_dna_harvesting_2') + + actor.removeSkillMod('expertise_bm_dna_harvesting_1', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_dna_harvesting_3.py b/scripts/expertise/expertise_bm_dna_harvesting_3.py new file mode 100644 index 00000000..3f287f64 --- /dev/null +++ b/scripts/expertise/expertise_bm_dna_harvesting_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_dna_harvesting_3') + + actor.addSkillMod('expertise_bm_dna_harvesting_1', 40) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_dna_harvesting_3') + + actor.removeSkillMod('expertise_bm_dna_harvesting_1', 40) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_erratic_genius_1.py b/scripts/expertise/expertise_bm_erratic_genius_1.py new file mode 100644 index 00000000..ab96d82c --- /dev/null +++ b/scripts/expertise/expertise_bm_erratic_genius_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_erratic_genius_1') + + actor.addSkillMod('bm_mutation_chance_increase', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_erratic_genius_1') + + actor.removeSkillMod('bm_mutation_chance_increase', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_erratic_genius_2.py b/scripts/expertise/expertise_bm_erratic_genius_2.py new file mode 100644 index 00000000..bc4c75ec --- /dev/null +++ b/scripts/expertise/expertise_bm_erratic_genius_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_erratic_genius_2') + + actor.addSkillMod('bm_mutation_chance_increase', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_erratic_genius_2') + + actor.removeSkillMod('bm_mutation_chance_increase', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_erratic_genius_3.py b/scripts/expertise/expertise_bm_erratic_genius_3.py new file mode 100644 index 00000000..a0ece6c0 --- /dev/null +++ b/scripts/expertise/expertise_bm_erratic_genius_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_erratic_genius_3') + + actor.addSkillMod('bm_mutation_chance_increase', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_erratic_genius_3') + + actor.removeSkillMod('bm_mutation_chance_increase', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_evasion_1.py b/scripts/expertise/expertise_bm_evasion_1.py new file mode 100644 index 00000000..62f8715c --- /dev/null +++ b/scripts/expertise/expertise_bm_evasion_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_evasion_1') + + actor.addSkillMod('expertise_bm_pet_evade_chance', 5) + actor.addSkillMod('expertise_bm_pet_evade_value', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_evasion_1') + + actor.removeSkillMod('expertise_bm_pet_evade_chance', 5) + actor.removeSkillMod('expertise_bm_pet_evade_value', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_evasion_2.py b/scripts/expertise/expertise_bm_evasion_2.py new file mode 100644 index 00000000..f05946e2 --- /dev/null +++ b/scripts/expertise/expertise_bm_evasion_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_evasion_2') + + actor.addSkillMod('expertise_bm_pet_evade_chance', 5) + actor.addSkillMod('expertise_bm_pet_evade_value', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_evasion_2') + + actor.removeSkillMod('expertise_bm_pet_evade_chance', 5) + actor.removeSkillMod('expertise_bm_pet_evade_value', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_evasion_3.py b/scripts/expertise/expertise_bm_evasion_3.py new file mode 100644 index 00000000..84f582e3 --- /dev/null +++ b/scripts/expertise/expertise_bm_evasion_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_evasion_3') + + actor.addSkillMod('expertise_bm_pet_evade_chance', 5) + actor.addSkillMod('expertise_bm_pet_evade_value', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_evasion_3') + + actor.removeSkillMod('expertise_bm_pet_evade_chance', 5) + actor.removeSkillMod('expertise_bm_pet_evade_value', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_exceptional_nutrition_1.py b/scripts/expertise/expertise_bm_exceptional_nutrition_1.py new file mode 100644 index 00000000..dce1b89b --- /dev/null +++ b/scripts/expertise/expertise_bm_exceptional_nutrition_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_exceptional_nutrition_1') + + actor.addSkillMod('expertise_bm_pet_health', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_exceptional_nutrition_1') + + actor.removeSkillMod('expertise_bm_pet_health', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_exceptional_nutrition_2.py b/scripts/expertise/expertise_bm_exceptional_nutrition_2.py new file mode 100644 index 00000000..acd0ed4b --- /dev/null +++ b/scripts/expertise/expertise_bm_exceptional_nutrition_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_exceptional_nutrition_2') + + actor.addSkillMod('expertise_bm_pet_health', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_exceptional_nutrition_2') + + actor.removeSkillMod('expertise_bm_pet_health', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_fortitude_1.py b/scripts/expertise/expertise_bm_fortitude_1.py new file mode 100644 index 00000000..bb3c54c6 --- /dev/null +++ b/scripts/expertise/expertise_bm_fortitude_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_fortitude_1') + + actor.addSkillMod('expertise_bm_pet_armor', 40) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_fortitude_1') + + actor.removeSkillMod('expertise_bm_pet_armor', 40) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_fortitude_2.py b/scripts/expertise/expertise_bm_fortitude_2.py new file mode 100644 index 00000000..b04ea1e4 --- /dev/null +++ b/scripts/expertise/expertise_bm_fortitude_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_fortitude_2') + + actor.addSkillMod('expertise_bm_pet_armor', 40) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_fortitude_2') + + actor.removeSkillMod('expertise_bm_pet_armor', 40) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_fortitude_3.py b/scripts/expertise/expertise_bm_fortitude_3.py new file mode 100644 index 00000000..466ebff1 --- /dev/null +++ b/scripts/expertise/expertise_bm_fortitude_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_fortitude_3') + + actor.addSkillMod('expertise_bm_pet_armor', 40) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_fortitude_3') + + actor.removeSkillMod('expertise_bm_pet_armor', 40) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_genetic_engineering_1.py b/scripts/expertise/expertise_bm_genetic_engineering_1.py new file mode 100644 index 00000000..865d8630 --- /dev/null +++ b/scripts/expertise/expertise_bm_genetic_engineering_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_genetic_engineering_1') + + actor.addSkillMod('expertise_bm_genetic_engineering', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_genetic_engineering_1') + + actor.removeSkillMod('expertise_bm_genetic_engineering', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_genetic_engineering_2.py b/scripts/expertise/expertise_bm_genetic_engineering_2.py new file mode 100644 index 00000000..f25e5200 --- /dev/null +++ b/scripts/expertise/expertise_bm_genetic_engineering_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_genetic_engineering_2') + + actor.addSkillMod('expertise_bm_genetic_engineering', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_genetic_engineering_2') + + actor.removeSkillMod('expertise_bm_genetic_engineering', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_genetic_engineering_3.py b/scripts/expertise/expertise_bm_genetic_engineering_3.py new file mode 100644 index 00000000..dc3fd5df --- /dev/null +++ b/scripts/expertise/expertise_bm_genetic_engineering_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_genetic_engineering_3') + + actor.addSkillMod('expertise_bm_genetic_engineering', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_genetic_engineering_3') + + actor.removeSkillMod('expertise_bm_genetic_engineering', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_genetic_engineering_4.py b/scripts/expertise/expertise_bm_genetic_engineering_4.py new file mode 100644 index 00000000..283f05f2 --- /dev/null +++ b/scripts/expertise/expertise_bm_genetic_engineering_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_genetic_engineering_4') + + actor.addSkillMod('expertise_bm_genetic_engineering', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_genetic_engineering_4') + + actor.removeSkillMod('expertise_bm_genetic_engineering', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_improved_healing_1.py b/scripts/expertise/expertise_bm_improved_healing_1.py new file mode 100644 index 00000000..5f173fcb --- /dev/null +++ b/scripts/expertise/expertise_bm_improved_healing_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_improved_healing_1') + + actor.addSkillMod('expertise_bm_improved_pet_heal', 20) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_improved_healing_1') + + actor.removeSkillMod('expertise_bm_improved_pet_heal', 20) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_improved_healing_2.py b/scripts/expertise/expertise_bm_improved_healing_2.py new file mode 100644 index 00000000..d93a6af1 --- /dev/null +++ b/scripts/expertise/expertise_bm_improved_healing_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_improved_healing_2') + + actor.addSkillMod('expertise_bm_improved_pet_heal', 20) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_improved_healing_2') + + actor.removeSkillMod('expertise_bm_improved_pet_heal', 20) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_improved_healing_3.py b/scripts/expertise/expertise_bm_improved_healing_3.py new file mode 100644 index 00000000..3a61f218 --- /dev/null +++ b/scripts/expertise/expertise_bm_improved_healing_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_improved_healing_3') + + actor.addSkillMod('expertise_bm_improved_pet_heal', 20) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_improved_healing_3') + + actor.removeSkillMod('expertise_bm_improved_pet_heal', 20) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_incubation_base_1.py b/scripts/expertise/expertise_bm_incubation_base_1.py new file mode 100644 index 00000000..9b7a89bc --- /dev/null +++ b/scripts/expertise/expertise_bm_incubation_base_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_incubation_base_1') + + actor.addSkillMod('expertise_bm_base_mod', 100) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_incubation_base_1') + + actor.removeSkillMod('expertise_bm_base_mod', 100) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bm_collect_dna') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bm_collect_dna') + + return diff --git a/scripts/expertise/expertise_bm_incubation_mod_1.py b/scripts/expertise/expertise_bm_incubation_mod_1.py new file mode 100644 index 00000000..5dcf4b16 --- /dev/null +++ b/scripts/expertise/expertise_bm_incubation_mod_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_incubation_mod_1') + + actor.addSkillMod('expertise_bm_incubation_quality', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_incubation_mod_1') + + actor.removeSkillMod('expertise_bm_incubation_quality', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_incubation_mod_2.py b/scripts/expertise/expertise_bm_incubation_mod_2.py new file mode 100644 index 00000000..022fdeff --- /dev/null +++ b/scripts/expertise/expertise_bm_incubation_mod_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_incubation_mod_2') + + actor.addSkillMod('expertise_bm_incubation_quality', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_incubation_mod_2') + + actor.removeSkillMod('expertise_bm_incubation_quality', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_incubation_mod_3.py b/scripts/expertise/expertise_bm_incubation_mod_3.py new file mode 100644 index 00000000..8460e39e --- /dev/null +++ b/scripts/expertise/expertise_bm_incubation_mod_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_incubation_mod_3') + + actor.addSkillMod('expertise_bm_incubation_quality', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_incubation_mod_3') + + actor.removeSkillMod('expertise_bm_incubation_quality', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_loyalty_mod_1.py b/scripts/expertise/expertise_bm_loyalty_mod_1.py new file mode 100644 index 00000000..628987a3 --- /dev/null +++ b/scripts/expertise/expertise_bm_loyalty_mod_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_loyalty_mod_1') + + actor.addSkillMod('expertise_bm_pet_happiness', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_loyalty_mod_1') + + actor.removeSkillMod('expertise_bm_pet_happiness', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_loyalty_mod_2.py b/scripts/expertise/expertise_bm_loyalty_mod_2.py new file mode 100644 index 00000000..f7c57622 --- /dev/null +++ b/scripts/expertise/expertise_bm_loyalty_mod_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_loyalty_mod_2') + + actor.addSkillMod('expertise_bm_pet_happiness', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_loyalty_mod_2') + + actor.removeSkillMod('expertise_bm_pet_happiness', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_loyalty_mod_3.py b/scripts/expertise/expertise_bm_loyalty_mod_3.py new file mode 100644 index 00000000..255e4b86 --- /dev/null +++ b/scripts/expertise/expertise_bm_loyalty_mod_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_loyalty_mod_3') + + actor.addSkillMod('expertise_bm_pet_happiness', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_loyalty_mod_3') + + actor.removeSkillMod('expertise_bm_pet_happiness', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_mending_1.py b/scripts/expertise/expertise_bm_mending_1.py new file mode 100644 index 00000000..f659d061 --- /dev/null +++ b/scripts/expertise/expertise_bm_mending_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_mending_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_mending_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bm_mend_pet_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bm_mend_pet_1') + + return diff --git a/scripts/expertise/expertise_bm_metagame_mod_1.py b/scripts/expertise/expertise_bm_metagame_mod_1.py new file mode 100644 index 00000000..ad8053c1 --- /dev/null +++ b/scripts/expertise/expertise_bm_metagame_mod_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_metagame_mod_1') + + actor.addSkillMod('expertise_bm_incubation_time', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_metagame_mod_1') + + actor.removeSkillMod('expertise_bm_incubation_time', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_metagame_mod_2.py b/scripts/expertise/expertise_bm_metagame_mod_2.py new file mode 100644 index 00000000..af8ff1d4 --- /dev/null +++ b/scripts/expertise/expertise_bm_metagame_mod_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_metagame_mod_2') + + actor.addSkillMod('expertise_bm_incubation_time', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_metagame_mod_2') + + actor.removeSkillMod('expertise_bm_incubation_time', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_metagame_mod_3.py b/scripts/expertise/expertise_bm_metagame_mod_3.py new file mode 100644 index 00000000..70409e9c --- /dev/null +++ b/scripts/expertise/expertise_bm_metagame_mod_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_metagame_mod_3') + + actor.addSkillMod('expertise_bm_incubation_time', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_metagame_mod_3') + + actor.removeSkillMod('expertise_bm_incubation_time', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_metagame_mod_4.py b/scripts/expertise/expertise_bm_metagame_mod_4.py new file mode 100644 index 00000000..1e31b545 --- /dev/null +++ b/scripts/expertise/expertise_bm_metagame_mod_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_metagame_mod_4') + + actor.addSkillMod('expertise_bm_incubation_time', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_metagame_mod_4') + + actor.removeSkillMod('expertise_bm_incubation_time', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_pet_dodge_1.py b/scripts/expertise/expertise_bm_pet_dodge_1.py new file mode 100644 index 00000000..17868349 --- /dev/null +++ b/scripts/expertise/expertise_bm_pet_dodge_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_pet_dodge_1') + + actor.addSkillMod('expertise_pet_dodge', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_pet_dodge_1') + + actor.removeSkillMod('expertise_pet_dodge', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_pet_dodge_2.py b/scripts/expertise/expertise_bm_pet_dodge_2.py new file mode 100644 index 00000000..9a6766ad --- /dev/null +++ b/scripts/expertise/expertise_bm_pet_dodge_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_pet_dodge_2') + + actor.addSkillMod('expertise_pet_dodge', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_pet_dodge_2') + + actor.removeSkillMod('expertise_pet_dodge', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_pet_dodge_3.py b/scripts/expertise/expertise_bm_pet_dodge_3.py new file mode 100644 index 00000000..6166d92b --- /dev/null +++ b/scripts/expertise/expertise_bm_pet_dodge_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_pet_dodge_3') + + actor.addSkillMod('expertise_pet_dodge', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_pet_dodge_3') + + actor.removeSkillMod('expertise_pet_dodge', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_pet_recovery_1.py b/scripts/expertise/expertise_bm_pet_recovery_1.py new file mode 100644 index 00000000..5ecf5f40 --- /dev/null +++ b/scripts/expertise/expertise_bm_pet_recovery_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_pet_recovery_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_pet_recovery_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_pet_recovery_2.py b/scripts/expertise/expertise_bm_pet_recovery_2.py new file mode 100644 index 00000000..ddbf4dae --- /dev/null +++ b/scripts/expertise/expertise_bm_pet_recovery_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_pet_recovery_2') + + actor.addSkillMod('expertise_bm_pet_revive_time', 5) + actor.addSkillMod('expertise_bm_pet_recovery', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_pet_recovery_2') + + actor.removeSkillMod('expertise_bm_pet_revive_time', 5) + actor.removeSkillMod('expertise_bm_pet_recovery', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_pet_recovery_3.py b/scripts/expertise/expertise_bm_pet_recovery_3.py new file mode 100644 index 00000000..9be05560 --- /dev/null +++ b/scripts/expertise/expertise_bm_pet_recovery_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_pet_recovery_3') + + actor.addSkillMod('expertise_bm_pet_revive_time', 5) + actor.addSkillMod('expertise_bm_pet_recovery', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_pet_recovery_3') + + actor.removeSkillMod('expertise_bm_pet_revive_time', 5) + actor.removeSkillMod('expertise_bm_pet_recovery', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_savagery_1.py b/scripts/expertise/expertise_bm_savagery_1.py new file mode 100644 index 00000000..7315df92 --- /dev/null +++ b/scripts/expertise/expertise_bm_savagery_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_savagery_1') + + actor.addSkillMod('expertise_bm_pet_damage', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_savagery_1') + + actor.removeSkillMod('expertise_bm_pet_damage', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_savagery_2.py b/scripts/expertise/expertise_bm_savagery_2.py new file mode 100644 index 00000000..31e83042 --- /dev/null +++ b/scripts/expertise/expertise_bm_savagery_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_savagery_2') + + actor.addSkillMod('expertise_bm_pet_damage', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_savagery_2') + + actor.removeSkillMod('expertise_bm_pet_damage', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_savagery_3.py b/scripts/expertise/expertise_bm_savagery_3.py new file mode 100644 index 00000000..c5619d8d --- /dev/null +++ b/scripts/expertise/expertise_bm_savagery_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_savagery_3') + + actor.addSkillMod('expertise_bm_pet_damage', 40) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_savagery_3') + + actor.removeSkillMod('expertise_bm_pet_damage', 40) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_soothing_comfort_1.py b/scripts/expertise/expertise_bm_soothing_comfort_1.py new file mode 100644 index 00000000..543104f4 --- /dev/null +++ b/scripts/expertise/expertise_bm_soothing_comfort_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_soothing_comfort_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_soothing_comfort_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('bm_soothing_comfort_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('bm_soothing_comfort_1') + + return diff --git a/scripts/expertise/expertise_bm_specialized_supplements_1.py b/scripts/expertise/expertise_bm_specialized_supplements_1.py new file mode 100644 index 00000000..4506f29e --- /dev/null +++ b/scripts/expertise/expertise_bm_specialized_supplements_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_specialized_supplements_1') + + actor.addSkillMod('expertise_bm_pet_regen', 100) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_specialized_supplements_1') + + actor.removeSkillMod('expertise_bm_pet_regen', 100) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_bm_train_mount_1.py b/scripts/expertise/expertise_bm_train_mount_1.py new file mode 100644 index 00000000..0199dd5c --- /dev/null +++ b/scripts/expertise/expertise_bm_train_mount_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_bm_train_mount_1') + + actor.addSkillMod('expertise_bm_train_mount', 100) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_bm_train_mount_1') + + actor.removeSkillMod('expertise_bm_train_mount', 100) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_angled_shrapnel_1.py b/scripts/expertise/expertise_co_angled_shrapnel_1.py new file mode 100644 index 00000000..0b649f92 --- /dev/null +++ b/scripts/expertise/expertise_co_angled_shrapnel_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_angled_shrapnel_1') + + actor.addSkillMod('expertise_area_size_line_co_remote_detonator', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_angled_shrapnel_1') + + actor.removeSkillMod('expertise_area_size_line_co_remote_detonator', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_angled_shrapnel_2.py b/scripts/expertise/expertise_co_angled_shrapnel_2.py new file mode 100644 index 00000000..a8801a55 --- /dev/null +++ b/scripts/expertise/expertise_co_angled_shrapnel_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_angled_shrapnel_2') + + actor.addSkillMod('expertise_area_size_line_co_remote_detonator', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_angled_shrapnel_2') + + actor.removeSkillMod('expertise_area_size_line_co_remote_detonator', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_armor_cracker_1.py b/scripts/expertise/expertise_co_armor_cracker_1.py new file mode 100644 index 00000000..fe7606f0 --- /dev/null +++ b/scripts/expertise/expertise_co_armor_cracker_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_armor_cracker_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_armor_cracker_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('co_armor_cracker') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('co_armor_cracker') + + return diff --git a/scripts/expertise/expertise_co_base_of_operations_1.py b/scripts/expertise/expertise_co_base_of_operations_1.py new file mode 100644 index 00000000..34f5548a --- /dev/null +++ b/scripts/expertise/expertise_co_base_of_operations_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_base_of_operations_1') + + actor.addSkillMod('expertise_co_pos_secured_line_armor', 1000) + actor.addSkillMod('expertise_co_pos_secured_line_boo_critical', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_base_of_operations_1') + + actor.removeSkillMod('expertise_co_pos_secured_line_armor', 1000) + actor.removeSkillMod('expertise_co_pos_secured_line_boo_critical', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_blast_radius_1.py b/scripts/expertise/expertise_co_blast_radius_1.py new file mode 100644 index 00000000..f9c87cc7 --- /dev/null +++ b/scripts/expertise/expertise_co_blast_radius_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_blast_radius_1') + + actor.addSkillMod('expertise_area_size_line_co_grenade', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_blast_radius_1') + + actor.removeSkillMod('expertise_area_size_line_co_grenade', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_blast_radius_2.py b/scripts/expertise/expertise_co_blast_radius_2.py new file mode 100644 index 00000000..c640ac02 --- /dev/null +++ b/scripts/expertise/expertise_co_blast_radius_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_blast_radius_2') + + actor.addSkillMod('expertise_area_size_line_co_grenade', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_blast_radius_2') + + actor.removeSkillMod('expertise_area_size_line_co_grenade', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_blast_radius_3.py b/scripts/expertise/expertise_co_blast_radius_3.py new file mode 100644 index 00000000..d4263326 --- /dev/null +++ b/scripts/expertise/expertise_co_blast_radius_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_blast_radius_3') + + actor.addSkillMod('expertise_area_size_line_co_grenade', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_blast_radius_3') + + actor.removeSkillMod('expertise_area_size_line_co_grenade', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_blast_radius_4.py b/scripts/expertise/expertise_co_blast_radius_4.py new file mode 100644 index 00000000..64490261 --- /dev/null +++ b/scripts/expertise/expertise_co_blast_radius_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_blast_radius_4') + + actor.addSkillMod('expertise_area_size_line_co_grenade', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_blast_radius_4') + + actor.removeSkillMod('expertise_area_size_line_co_grenade', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_blast_resistance_1.py b/scripts/expertise/expertise_co_blast_resistance_1.py new file mode 100644 index 00000000..8aff3074 --- /dev/null +++ b/scripts/expertise/expertise_co_blast_resistance_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_blast_resistance_1') + + actor.addSkillMod('area_damage_resist_full_percentage', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_blast_resistance_1') + + actor.removeSkillMod('area_damage_resist_full_percentage', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_blast_resistance_2.py b/scripts/expertise/expertise_co_blast_resistance_2.py new file mode 100644 index 00000000..7efcf286 --- /dev/null +++ b/scripts/expertise/expertise_co_blast_resistance_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_blast_resistance_2') + + actor.addSkillMod('area_damage_resist_full_percentage', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_blast_resistance_2') + + actor.removeSkillMod('area_damage_resist_full_percentage', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_blast_resistance_3.py b/scripts/expertise/expertise_co_blast_resistance_3.py new file mode 100644 index 00000000..57b839ca --- /dev/null +++ b/scripts/expertise/expertise_co_blast_resistance_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_blast_resistance_3') + + actor.addSkillMod('area_damage_resist_full_percentage', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_blast_resistance_3') + + actor.removeSkillMod('area_damage_resist_full_percentage', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_blast_resistance_4.py b/scripts/expertise/expertise_co_blast_resistance_4.py new file mode 100644 index 00000000..08838e5a --- /dev/null +++ b/scripts/expertise/expertise_co_blast_resistance_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_blast_resistance_4') + + actor.addSkillMod('area_damage_resist_full_percentage', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_blast_resistance_4') + + actor.removeSkillMod('area_damage_resist_full_percentage', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_blow_em_away_1.py b/scripts/expertise/expertise_co_blow_em_away_1.py new file mode 100644 index 00000000..829d7e74 --- /dev/null +++ b/scripts/expertise/expertise_co_blow_em_away_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_blow_em_away_1') + + actor.addSkillMod('expertise_co_cluster_bomblet', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_blow_em_away_1') + + actor.removeSkillMod('expertise_co_cluster_bomblet', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_blow_em_away_2.py b/scripts/expertise/expertise_co_blow_em_away_2.py new file mode 100644 index 00000000..59dc0e4e --- /dev/null +++ b/scripts/expertise/expertise_co_blow_em_away_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_blow_em_away_2') + + actor.addSkillMod('expertise_co_cluster_bomblet', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_blow_em_away_2') + + actor.removeSkillMod('expertise_co_cluster_bomblet', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_burst_fire_1.py b/scripts/expertise/expertise_co_burst_fire_1.py new file mode 100644 index 00000000..f627677e --- /dev/null +++ b/scripts/expertise/expertise_co_burst_fire_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_burst_fire_1') + + actor.addSkillMod('expertise_co_pos_secured_line_burst_fire_proc', 10) + actor.addSkillMod('expertise_co_pos_secured_line_burst_fire_devastation_bonus', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_burst_fire_1') + + actor.removeSkillMod('expertise_co_pos_secured_line_burst_fire_proc', 10) + actor.removeSkillMod('expertise_co_pos_secured_line_burst_fire_devastation_bonus', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_burst_fire_2.py b/scripts/expertise/expertise_co_burst_fire_2.py new file mode 100644 index 00000000..ac874237 --- /dev/null +++ b/scripts/expertise/expertise_co_burst_fire_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_burst_fire_2') + + actor.addSkillMod('expertise_co_pos_secured_line_burst_fire_proc', 10) + actor.addSkillMod('expertise_co_pos_secured_line_burst_fire_devastation_bonus', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_burst_fire_2') + + actor.removeSkillMod('expertise_co_pos_secured_line_burst_fire_proc', 10) + actor.removeSkillMod('expertise_co_pos_secured_line_burst_fire_devastation_bonus', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_cluster_bomb.py b/scripts/expertise/expertise_co_cluster_bomb.py new file mode 100644 index 00000000..410e0121 --- /dev/null +++ b/scripts/expertise/expertise_co_cluster_bomb.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_cluster_bomb') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_cluster_bomb') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('co_cluster_bomb') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('co_cluster_bomb') + + return diff --git a/scripts/expertise/expertise_co_diagnostic_armor_1.py b/scripts/expertise/expertise_co_diagnostic_armor_1.py new file mode 100644 index 00000000..5eaac3ad --- /dev/null +++ b/scripts/expertise/expertise_co_diagnostic_armor_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_diagnostic_armor_1') + + actor.addSkillMod('expertise_dot_absorption_all', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_diagnostic_armor_1') + + actor.removeSkillMod('expertise_dot_absorption_all', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_enhanced_fuel_cans_1.py b/scripts/expertise/expertise_co_enhanced_fuel_cans_1.py new file mode 100644 index 00000000..a05bf5ea --- /dev/null +++ b/scripts/expertise/expertise_co_enhanced_fuel_cans_1.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_enhanced_fuel_cans_1') + + actor.addSkillMod('expertise_action_weapon_12', 5) + actor.addSkillMod('expertise_action_weapon_13', 5) + actor.addSkillMod('commando_passive_dot', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_enhanced_fuel_cans_1') + + actor.removeSkillMod('expertise_action_weapon_12', 5) + actor.removeSkillMod('expertise_action_weapon_13', 5) + actor.removeSkillMod('commando_passive_dot', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_enhanced_fuel_cans_2.py b/scripts/expertise/expertise_co_enhanced_fuel_cans_2.py new file mode 100644 index 00000000..1a4a142d --- /dev/null +++ b/scripts/expertise/expertise_co_enhanced_fuel_cans_2.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_enhanced_fuel_cans_2') + + actor.addSkillMod('expertise_action_weapon_12', 5) + actor.addSkillMod('expertise_action_weapon_13', 5) + actor.addSkillMod('commando_passive_dot', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_enhanced_fuel_cans_2') + + actor.removeSkillMod('expertise_action_weapon_12', 5) + actor.removeSkillMod('expertise_action_weapon_13', 5) + actor.removeSkillMod('commando_passive_dot', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_enhanced_fuel_cans_3.py b/scripts/expertise/expertise_co_enhanced_fuel_cans_3.py new file mode 100644 index 00000000..9b8ca94a --- /dev/null +++ b/scripts/expertise/expertise_co_enhanced_fuel_cans_3.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_enhanced_fuel_cans_3') + + actor.addSkillMod('expertise_action_weapon_12', 5) + actor.addSkillMod('expertise_action_weapon_13', 5) + actor.addSkillMod('commando_passive_dot', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_enhanced_fuel_cans_3') + + actor.removeSkillMod('expertise_action_weapon_12', 5) + actor.removeSkillMod('expertise_action_weapon_13', 5) + actor.removeSkillMod('commando_passive_dot', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_enhanced_fuel_cans_4.py b/scripts/expertise/expertise_co_enhanced_fuel_cans_4.py new file mode 100644 index 00000000..df5fd47f --- /dev/null +++ b/scripts/expertise/expertise_co_enhanced_fuel_cans_4.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_enhanced_fuel_cans_4') + + actor.addSkillMod('expertise_action_weapon_12', 5) + actor.addSkillMod('expertise_action_weapon_13', 5) + actor.addSkillMod('commando_passive_dot', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_enhanced_fuel_cans_4') + + actor.removeSkillMod('expertise_action_weapon_12', 5) + actor.removeSkillMod('expertise_action_weapon_13', 5) + actor.removeSkillMod('commando_passive_dot', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_flashbang_1.py b/scripts/expertise/expertise_co_flashbang_1.py new file mode 100644 index 00000000..5408fa91 --- /dev/null +++ b/scripts/expertise/expertise_co_flashbang_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_flashbang_1') + + actor.addSkillMod('expertise_co_flash_bang', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_flashbang_1') + + actor.removeSkillMod('expertise_co_flash_bang', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_flashbang_2.py b/scripts/expertise/expertise_co_flashbang_2.py new file mode 100644 index 00000000..806107a1 --- /dev/null +++ b/scripts/expertise/expertise_co_flashbang_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_flashbang_2') + + actor.addSkillMod('expertise_co_flash_bang', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_flashbang_2') + + actor.removeSkillMod('expertise_co_flash_bang', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_focus_beam_1.py b/scripts/expertise/expertise_co_focus_beam_1.py new file mode 100644 index 00000000..b74caea5 --- /dev/null +++ b/scripts/expertise/expertise_co_focus_beam_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_focus_beam_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_focus_beam_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('co_hw_dm_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('co_hw_dm_1') + + return diff --git a/scripts/expertise/expertise_co_heavy_ammunition_1.py b/scripts/expertise/expertise_co_heavy_ammunition_1.py new file mode 100644 index 00000000..86e9e6d5 --- /dev/null +++ b/scripts/expertise/expertise_co_heavy_ammunition_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_heavy_ammunition_1') + + actor.addSkillMod('expertise_damage_weapon_0', 2) + actor.addSkillMod('expertise_damage_weapon_1', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_heavy_ammunition_1') + + actor.removeSkillMod('expertise_damage_weapon_0', 2) + actor.removeSkillMod('expertise_damage_weapon_1', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_heavy_ammunition_2.py b/scripts/expertise/expertise_co_heavy_ammunition_2.py new file mode 100644 index 00000000..82c48ece --- /dev/null +++ b/scripts/expertise/expertise_co_heavy_ammunition_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_heavy_ammunition_2') + + actor.addSkillMod('expertise_damage_weapon_0', 2) + actor.addSkillMod('expertise_damage_weapon_1', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_heavy_ammunition_2') + + actor.removeSkillMod('expertise_damage_weapon_0', 2) + actor.removeSkillMod('expertise_damage_weapon_1', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_heavy_ammunition_3.py b/scripts/expertise/expertise_co_heavy_ammunition_3.py new file mode 100644 index 00000000..c87f41dd --- /dev/null +++ b/scripts/expertise/expertise_co_heavy_ammunition_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_heavy_ammunition_3') + + actor.addSkillMod('expertise_damage_weapon_0', 2) + actor.addSkillMod('expertise_damage_weapon_1', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_heavy_ammunition_3') + + actor.removeSkillMod('expertise_damage_weapon_0', 2) + actor.removeSkillMod('expertise_damage_weapon_1', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_heavy_ammunition_4.py b/scripts/expertise/expertise_co_heavy_ammunition_4.py new file mode 100644 index 00000000..20577637 --- /dev/null +++ b/scripts/expertise/expertise_co_heavy_ammunition_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_heavy_ammunition_4') + + actor.addSkillMod('expertise_damage_weapon_0', 2) + actor.addSkillMod('expertise_damage_weapon_1', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_heavy_ammunition_4') + + actor.removeSkillMod('expertise_damage_weapon_0', 2) + actor.removeSkillMod('expertise_damage_weapon_1', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_hose_down_1.py b/scripts/expertise/expertise_co_hose_down_1.py new file mode 100644 index 00000000..bc6dfcfc --- /dev/null +++ b/scripts/expertise/expertise_co_hose_down_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_hose_down_1') + + actor.addSkillMod('expertise_action_line_co_dm', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_hose_down_1') + + actor.removeSkillMod('expertise_action_line_co_dm', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_hose_down_2.py b/scripts/expertise/expertise_co_hose_down_2.py new file mode 100644 index 00000000..e4944ff0 --- /dev/null +++ b/scripts/expertise/expertise_co_hose_down_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_hose_down_2') + + actor.addSkillMod('expertise_action_line_co_dm', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_hose_down_2') + + actor.removeSkillMod('expertise_action_line_co_dm', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_imp_position_secured_1.py b/scripts/expertise/expertise_co_imp_position_secured_1.py new file mode 100644 index 00000000..76c5c253 --- /dev/null +++ b/scripts/expertise/expertise_co_imp_position_secured_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_imp_position_secured_1') + + actor.addSkillMod('expertise_action_line_co_imp_pos_sec', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_imp_position_secured_1') + + actor.removeSkillMod('expertise_action_line_co_imp_pos_sec', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_imp_position_secured_2.py b/scripts/expertise/expertise_co_imp_position_secured_2.py new file mode 100644 index 00000000..c4caa65e --- /dev/null +++ b/scripts/expertise/expertise_co_imp_position_secured_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_imp_position_secured_2') + + actor.addSkillMod('expertise_action_line_co_imp_pos_sec', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_imp_position_secured_2') + + actor.removeSkillMod('expertise_action_line_co_imp_pos_sec', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_imp_position_secured_3.py b/scripts/expertise/expertise_co_imp_position_secured_3.py new file mode 100644 index 00000000..eecc94ca --- /dev/null +++ b/scripts/expertise/expertise_co_imp_position_secured_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_imp_position_secured_3') + + actor.addSkillMod('expertise_action_line_co_imp_pos_sec', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_imp_position_secured_3') + + actor.removeSkillMod('expertise_action_line_co_imp_pos_sec', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_imp_riddle_armor_1.py b/scripts/expertise/expertise_co_imp_riddle_armor_1.py new file mode 100644 index 00000000..e05eaba7 --- /dev/null +++ b/scripts/expertise/expertise_co_imp_riddle_armor_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_imp_riddle_armor_1') + + actor.addSkillMod('expertise_cooldown_line_co_riddle_armor', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_imp_riddle_armor_1') + + actor.removeSkillMod('expertise_cooldown_line_co_riddle_armor', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_imp_riddle_armor_2.py b/scripts/expertise/expertise_co_imp_riddle_armor_2.py new file mode 100644 index 00000000..a6c99f37 --- /dev/null +++ b/scripts/expertise/expertise_co_imp_riddle_armor_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_imp_riddle_armor_2') + + actor.addSkillMod('expertise_cooldown_line_co_riddle_armor', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_imp_riddle_armor_2') + + actor.removeSkillMod('expertise_cooldown_line_co_riddle_armor', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_imp_stand_fast_1.py b/scripts/expertise/expertise_co_imp_stand_fast_1.py new file mode 100644 index 00000000..aa2b8fdd --- /dev/null +++ b/scripts/expertise/expertise_co_imp_stand_fast_1.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_imp_stand_fast_1') + + actor.addSkillMod('expertise_damage_decrease_percentage', 5) + actor.addSkillMod('expertise_buff_duration_line_co_stand_fast', 2) + actor.addSkillMod('expertise_cooldown_line_co_stand_fast', 120) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_imp_stand_fast_1') + + actor.removeSkillMod('expertise_damage_decrease_percentage', 5) + actor.removeSkillMod('expertise_buff_duration_line_co_stand_fast', 2) + actor.removeSkillMod('expertise_cooldown_line_co_stand_fast', 120) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_imp_stand_fast_2.py b/scripts/expertise/expertise_co_imp_stand_fast_2.py new file mode 100644 index 00000000..d5d1f95e --- /dev/null +++ b/scripts/expertise/expertise_co_imp_stand_fast_2.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_imp_stand_fast_2') + + actor.addSkillMod('expertise_damage_decrease_percentage', 5) + actor.addSkillMod('expertise_buff_duration_line_co_stand_fast', 2) + actor.addSkillMod('expertise_cooldown_line_co_stand_fast', 120) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_imp_stand_fast_2') + + actor.removeSkillMod('expertise_damage_decrease_percentage', 5) + actor.removeSkillMod('expertise_buff_duration_line_co_stand_fast', 2) + actor.removeSkillMod('expertise_cooldown_line_co_stand_fast', 120) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_imp_stand_fast_3.py b/scripts/expertise/expertise_co_imp_stand_fast_3.py new file mode 100644 index 00000000..1cc88783 --- /dev/null +++ b/scripts/expertise/expertise_co_imp_stand_fast_3.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_imp_stand_fast_3') + + actor.addSkillMod('expertise_damage_decrease_percentage', 5) + actor.addSkillMod('expertise_buff_duration_line_co_stand_fast', 2) + actor.addSkillMod('expertise_cooldown_line_co_stand_fast', 120) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_imp_stand_fast_3') + + actor.removeSkillMod('expertise_damage_decrease_percentage', 5) + actor.removeSkillMod('expertise_buff_duration_line_co_stand_fast', 2) + actor.removeSkillMod('expertise_cooldown_line_co_stand_fast', 120) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_improved_explosives_1.py b/scripts/expertise/expertise_co_improved_explosives_1.py new file mode 100644 index 00000000..d4c61b00 --- /dev/null +++ b/scripts/expertise/expertise_co_improved_explosives_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_improved_explosives_1') + + actor.addSkillMod('expertise_damage_line_co_remote_detonator', 75) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_improved_explosives_1') + + actor.removeSkillMod('expertise_damage_line_co_remote_detonator', 75) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_improved_explosives_2.py b/scripts/expertise/expertise_co_improved_explosives_2.py new file mode 100644 index 00000000..088ad931 --- /dev/null +++ b/scripts/expertise/expertise_co_improved_explosives_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_improved_explosives_2') + + actor.addSkillMod('expertise_damage_line_co_remote_detonator', 75) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_improved_explosives_2') + + actor.removeSkillMod('expertise_damage_line_co_remote_detonator', 75) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_improved_explosives_3.py b/scripts/expertise/expertise_co_improved_explosives_3.py new file mode 100644 index 00000000..36f59b79 --- /dev/null +++ b/scripts/expertise/expertise_co_improved_explosives_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_improved_explosives_3') + + actor.addSkillMod('expertise_damage_line_co_remote_detonator', 75) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_improved_explosives_3') + + actor.removeSkillMod('expertise_damage_line_co_remote_detonator', 75) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_improved_explosives_4.py b/scripts/expertise/expertise_co_improved_explosives_4.py new file mode 100644 index 00000000..0388018e --- /dev/null +++ b/scripts/expertise/expertise_co_improved_explosives_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_improved_explosives_4') + + actor.addSkillMod('expertise_damage_line_co_remote_detonator', 75) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_improved_explosives_4') + + actor.removeSkillMod('expertise_damage_line_co_remote_detonator', 75) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_keen_eye_1.py b/scripts/expertise/expertise_co_keen_eye_1.py new file mode 100644 index 00000000..03a62449 --- /dev/null +++ b/scripts/expertise/expertise_co_keen_eye_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_keen_eye_1') + + actor.addSkillMod('expertise_range_bonus_ranged', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_keen_eye_1') + + actor.removeSkillMod('expertise_range_bonus_ranged', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_keen_eye_2.py b/scripts/expertise/expertise_co_keen_eye_2.py new file mode 100644 index 00000000..b5fcd60b --- /dev/null +++ b/scripts/expertise/expertise_co_keen_eye_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_keen_eye_2') + + actor.addSkillMod('expertise_range_bonus_ranged', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_keen_eye_2') + + actor.removeSkillMod('expertise_range_bonus_ranged', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_killing_grimace_1.py b/scripts/expertise/expertise_co_killing_grimace_1.py new file mode 100644 index 00000000..18b03ffe --- /dev/null +++ b/scripts/expertise/expertise_co_killing_grimace_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_killing_grimace_1') + + actor.addSkillMod('expertise_co_killing_spree_target', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_killing_grimace_1') + + actor.removeSkillMod('expertise_co_killing_spree_target', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_killing_grimace_2.py b/scripts/expertise/expertise_co_killing_grimace_2.py new file mode 100644 index 00000000..0c1ca2e8 --- /dev/null +++ b/scripts/expertise/expertise_co_killing_grimace_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_killing_grimace_2') + + actor.addSkillMod('expertise_co_killing_spree_target', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_killing_grimace_2') + + actor.removeSkillMod('expertise_co_killing_spree_target', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_killing_spree.py b/scripts/expertise/expertise_co_killing_spree.py new file mode 100644 index 00000000..915251d0 --- /dev/null +++ b/scripts/expertise/expertise_co_killing_spree.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_killing_spree') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_killing_spree') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('co_killing_spree') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('co_killing_spree') + + return diff --git a/scripts/expertise/expertise_co_lethal_beam_1.py b/scripts/expertise/expertise_co_lethal_beam_1.py new file mode 100644 index 00000000..4a96f6d4 --- /dev/null +++ b/scripts/expertise/expertise_co_lethal_beam_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_lethal_beam_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_lethal_beam_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('co_hw_dm_crit_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('co_hw_dm_crit_1') + + return diff --git a/scripts/expertise/expertise_co_marksman_1.py b/scripts/expertise/expertise_co_marksman_1.py new file mode 100644 index 00000000..431a914c --- /dev/null +++ b/scripts/expertise/expertise_co_marksman_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_marksman_1') + + actor.addSkillMod('expertise_action_rifle', 4) + actor.addSkillMod('expertise_action_carbine', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_marksman_1') + + actor.removeSkillMod('expertise_action_rifle', 4) + actor.removeSkillMod('expertise_action_carbine', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_marksman_2.py b/scripts/expertise/expertise_co_marksman_2.py new file mode 100644 index 00000000..578f6bfc --- /dev/null +++ b/scripts/expertise/expertise_co_marksman_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_marksman_2') + + actor.addSkillMod('expertise_action_rifle', 4) + actor.addSkillMod('expertise_action_carbine', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_marksman_2') + + actor.removeSkillMod('expertise_action_rifle', 4) + actor.removeSkillMod('expertise_action_carbine', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_marksman_3.py b/scripts/expertise/expertise_co_marksman_3.py new file mode 100644 index 00000000..39027c30 --- /dev/null +++ b/scripts/expertise/expertise_co_marksman_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_marksman_3') + + actor.addSkillMod('expertise_action_rifle', 4) + actor.addSkillMod('expertise_action_carbine', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_marksman_3') + + actor.removeSkillMod('expertise_action_rifle', 4) + actor.removeSkillMod('expertise_action_carbine', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_mirror_armor_1.py b/scripts/expertise/expertise_co_mirror_armor_1.py new file mode 100644 index 00000000..ce6c5cb5 --- /dev/null +++ b/scripts/expertise/expertise_co_mirror_armor_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_mirror_armor_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_mirror_armor_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('co_mirror_armor') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('co_mirror_armor') + + return diff --git a/scripts/expertise/expertise_co_on_target_1.py b/scripts/expertise/expertise_co_on_target_1.py new file mode 100644 index 00000000..7ed1aa7e --- /dev/null +++ b/scripts/expertise/expertise_co_on_target_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_on_target_1') + + actor.addSkillMod('expertise_co_pos_secured_line_critical', 2) + actor.addSkillMod('expertise_co_pos_secured_line_protection', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_on_target_1') + + actor.removeSkillMod('expertise_co_pos_secured_line_critical', 2) + actor.removeSkillMod('expertise_co_pos_secured_line_protection', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_on_target_2.py b/scripts/expertise/expertise_co_on_target_2.py new file mode 100644 index 00000000..bf31c706 --- /dev/null +++ b/scripts/expertise/expertise_co_on_target_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_on_target_2') + + actor.addSkillMod('expertise_co_pos_secured_line_critical', 2) + actor.addSkillMod('expertise_co_pos_secured_line_protection', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_on_target_2') + + actor.removeSkillMod('expertise_co_pos_secured_line_critical', 2) + actor.removeSkillMod('expertise_co_pos_secured_line_protection', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_on_target_3.py b/scripts/expertise/expertise_co_on_target_3.py new file mode 100644 index 00000000..9cca1f5d --- /dev/null +++ b/scripts/expertise/expertise_co_on_target_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_on_target_3') + + actor.addSkillMod('expertise_co_pos_secured_line_critical', 2) + actor.addSkillMod('expertise_co_pos_secured_line_protection', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_on_target_3') + + actor.removeSkillMod('expertise_co_pos_secured_line_critical', 2) + actor.removeSkillMod('expertise_co_pos_secured_line_protection', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_on_target_4.py b/scripts/expertise/expertise_co_on_target_4.py new file mode 100644 index 00000000..e9a0a325 --- /dev/null +++ b/scripts/expertise/expertise_co_on_target_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_on_target_4') + + actor.addSkillMod('expertise_co_pos_secured_line_critical', 2) + actor.addSkillMod('expertise_co_pos_secured_line_protection', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_on_target_4') + + actor.removeSkillMod('expertise_co_pos_secured_line_critical', 2) + actor.removeSkillMod('expertise_co_pos_secured_line_protection', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_packed_explosives_1.py b/scripts/expertise/expertise_co_packed_explosives_1.py new file mode 100644 index 00000000..da5644ab --- /dev/null +++ b/scripts/expertise/expertise_co_packed_explosives_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_packed_explosives_1') + + actor.addSkillMod('expertise_damage_line_co_grenade', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_packed_explosives_1') + + actor.removeSkillMod('expertise_damage_line_co_grenade', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_packed_explosives_2.py b/scripts/expertise/expertise_co_packed_explosives_2.py new file mode 100644 index 00000000..ee0655e3 --- /dev/null +++ b/scripts/expertise/expertise_co_packed_explosives_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_packed_explosives_2') + + actor.addSkillMod('expertise_damage_line_co_grenade', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_packed_explosives_2') + + actor.removeSkillMod('expertise_damage_line_co_grenade', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_packed_explosives_3.py b/scripts/expertise/expertise_co_packed_explosives_3.py new file mode 100644 index 00000000..0bdf9fde --- /dev/null +++ b/scripts/expertise/expertise_co_packed_explosives_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_packed_explosives_3') + + actor.addSkillMod('expertise_damage_line_co_grenade', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_packed_explosives_3') + + actor.removeSkillMod('expertise_damage_line_co_grenade', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_packed_explosives_4.py b/scripts/expertise/expertise_co_packed_explosives_4.py new file mode 100644 index 00000000..e8ca7037 --- /dev/null +++ b/scripts/expertise/expertise_co_packed_explosives_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_packed_explosives_4') + + actor.addSkillMod('expertise_damage_line_co_grenade', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_packed_explosives_4') + + actor.removeSkillMod('expertise_damage_line_co_grenade', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_position_secured_1.py b/scripts/expertise/expertise_co_position_secured_1.py new file mode 100644 index 00000000..dfee8b0a --- /dev/null +++ b/scripts/expertise/expertise_co_position_secured_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_position_secured_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_position_secured_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('co_position_secured') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('co_position_secured') + + return diff --git a/scripts/expertise/expertise_co_remote_detonator_1.py b/scripts/expertise/expertise_co_remote_detonator_1.py new file mode 100644 index 00000000..d90c8d4f --- /dev/null +++ b/scripts/expertise/expertise_co_remote_detonator_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_remote_detonator_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_remote_detonator_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('co_remote_detonator_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('co_remote_detonator_1') + + return diff --git a/scripts/expertise/expertise_co_riddle_armor_1.py b/scripts/expertise/expertise_co_riddle_armor_1.py new file mode 100644 index 00000000..4e3ebd79 --- /dev/null +++ b/scripts/expertise/expertise_co_riddle_armor_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_riddle_armor_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_riddle_armor_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('co_riddle_armor') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('co_riddle_armor') + + return diff --git a/scripts/expertise/expertise_co_short_fuse_1.py b/scripts/expertise/expertise_co_short_fuse_1.py new file mode 100644 index 00000000..54240603 --- /dev/null +++ b/scripts/expertise/expertise_co_short_fuse_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_short_fuse_1') + + actor.addSkillMod('expertise_delay_reduce_line_co_grenade', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_short_fuse_1') + + actor.removeSkillMod('expertise_delay_reduce_line_co_grenade', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_stim_armor_1.py b/scripts/expertise/expertise_co_stim_armor_1.py new file mode 100644 index 00000000..abe74611 --- /dev/null +++ b/scripts/expertise/expertise_co_stim_armor_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_stim_armor_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_stim_armor_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('co_stim_armor') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('co_stim_armor') + + return diff --git a/scripts/expertise/expertise_co_strong_arm_1.py b/scripts/expertise/expertise_co_strong_arm_1.py new file mode 100644 index 00000000..03ebed5f --- /dev/null +++ b/scripts/expertise/expertise_co_strong_arm_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_strong_arm_1') + + actor.addSkillMod('expertise_action_line_co_grenade', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_strong_arm_1') + + actor.removeSkillMod('expertise_action_line_co_grenade', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_strong_arm_2.py b/scripts/expertise/expertise_co_strong_arm_2.py new file mode 100644 index 00000000..126ff5b7 --- /dev/null +++ b/scripts/expertise/expertise_co_strong_arm_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_strong_arm_2') + + actor.addSkillMod('expertise_action_line_co_grenade', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_strong_arm_2') + + actor.removeSkillMod('expertise_action_line_co_grenade', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_strong_arm_3.py b/scripts/expertise/expertise_co_strong_arm_3.py new file mode 100644 index 00000000..8ed34544 --- /dev/null +++ b/scripts/expertise/expertise_co_strong_arm_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_strong_arm_3') + + actor.addSkillMod('expertise_action_line_co_grenade', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_strong_arm_3') + + actor.removeSkillMod('expertise_action_line_co_grenade', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_strong_arm_4.py b/scripts/expertise/expertise_co_strong_arm_4.py new file mode 100644 index 00000000..ea9ec450 --- /dev/null +++ b/scripts/expertise/expertise_co_strong_arm_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_strong_arm_4') + + actor.addSkillMod('expertise_action_line_co_grenade', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_strong_arm_4') + + actor.removeSkillMod('expertise_action_line_co_grenade', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_suppressing_fire_1.py b/scripts/expertise/expertise_co_suppressing_fire_1.py new file mode 100644 index 00000000..a9192094 --- /dev/null +++ b/scripts/expertise/expertise_co_suppressing_fire_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_suppressing_fire_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_suppressing_fire_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('co_suppressing_fire') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('co_suppressing_fire') + + return diff --git a/scripts/expertise/expertise_co_suppression_efficiency_1.py b/scripts/expertise/expertise_co_suppression_efficiency_1.py new file mode 100644 index 00000000..72851743 --- /dev/null +++ b/scripts/expertise/expertise_co_suppression_efficiency_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_suppression_efficiency_1') + + actor.addSkillMod('expertise_supression_speed', 10) + actor.addSkillMod('expertise_supression_glance', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_suppression_efficiency_1') + + actor.removeSkillMod('expertise_supression_speed', 10) + actor.removeSkillMod('expertise_supression_glance', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_suppression_efficiency_2.py b/scripts/expertise/expertise_co_suppression_efficiency_2.py new file mode 100644 index 00000000..97830b16 --- /dev/null +++ b/scripts/expertise/expertise_co_suppression_efficiency_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_suppression_efficiency_2') + + actor.addSkillMod('expertise_supression_speed', 10) + actor.addSkillMod('expertise_supression_glance', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_suppression_efficiency_2') + + actor.removeSkillMod('expertise_supression_speed', 10) + actor.removeSkillMod('expertise_supression_glance', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_suppression_efficiency_3.py b/scripts/expertise/expertise_co_suppression_efficiency_3.py new file mode 100644 index 00000000..a0d3e6b6 --- /dev/null +++ b/scripts/expertise/expertise_co_suppression_efficiency_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_suppression_efficiency_3') + + actor.addSkillMod('expertise_supression_speed', 10) + actor.addSkillMod('expertise_supression_glance', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_suppression_efficiency_3') + + actor.removeSkillMod('expertise_supression_speed', 10) + actor.removeSkillMod('expertise_supression_glance', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_suppression_efficiency_4.py b/scripts/expertise/expertise_co_suppression_efficiency_4.py new file mode 100644 index 00000000..3898d8fd --- /dev/null +++ b/scripts/expertise/expertise_co_suppression_efficiency_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_suppression_efficiency_4') + + actor.addSkillMod('expertise_supression_speed', 10) + actor.addSkillMod('expertise_supression_glance', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_suppression_efficiency_4') + + actor.removeSkillMod('expertise_supression_speed', 10) + actor.removeSkillMod('expertise_supression_glance', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_tibanna_gas_1.py b/scripts/expertise/expertise_co_tibanna_gas_1.py new file mode 100644 index 00000000..f3c83322 --- /dev/null +++ b/scripts/expertise/expertise_co_tibanna_gas_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_tibanna_gas_1') + + actor.addSkillMod('expertise_damage_weapon_3', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_tibanna_gas_1') + + actor.removeSkillMod('expertise_damage_weapon_3', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_tibanna_gas_2.py b/scripts/expertise/expertise_co_tibanna_gas_2.py new file mode 100644 index 00000000..ccc62783 --- /dev/null +++ b/scripts/expertise/expertise_co_tibanna_gas_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_tibanna_gas_2') + + actor.addSkillMod('expertise_damage_weapon_3', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_tibanna_gas_2') + + actor.removeSkillMod('expertise_damage_weapon_3', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_tibanna_gas_3.py b/scripts/expertise/expertise_co_tibanna_gas_3.py new file mode 100644 index 00000000..49895f55 --- /dev/null +++ b/scripts/expertise/expertise_co_tibanna_gas_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_tibanna_gas_3') + + actor.addSkillMod('expertise_damage_weapon_3', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_tibanna_gas_3') + + actor.removeSkillMod('expertise_damage_weapon_3', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_tibanna_gas_4.py b/scripts/expertise/expertise_co_tibanna_gas_4.py new file mode 100644 index 00000000..09e23289 --- /dev/null +++ b/scripts/expertise/expertise_co_tibanna_gas_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_tibanna_gas_4') + + actor.addSkillMod('expertise_damage_weapon_3', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_tibanna_gas_4') + + actor.removeSkillMod('expertise_damage_weapon_3', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_timer_reset_1.py b/scripts/expertise/expertise_co_timer_reset_1.py new file mode 100644 index 00000000..c1f4cdb0 --- /dev/null +++ b/scripts/expertise/expertise_co_timer_reset_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_timer_reset_1') + + actor.addSkillMod('expertise_delay_line_co_remote_detonator', 240) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_timer_reset_1') + + actor.removeSkillMod('expertise_delay_line_co_remote_detonator', 240) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_timer_reset_2.py b/scripts/expertise/expertise_co_timer_reset_2.py new file mode 100644 index 00000000..452832a5 --- /dev/null +++ b/scripts/expertise/expertise_co_timer_reset_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_timer_reset_2') + + actor.addSkillMod('expertise_delay_line_co_remote_detonator', 240) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_timer_reset_2') + + actor.removeSkillMod('expertise_delay_line_co_remote_detonator', 240) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_youll_regret_that_1.py b/scripts/expertise/expertise_co_youll_regret_that_1.py new file mode 100644 index 00000000..eae8c028 --- /dev/null +++ b/scripts/expertise/expertise_co_youll_regret_that_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_youll_regret_that_1') + + actor.addSkillMod('kill_meter_co_youll_regret_that_reac', 100) + actor.addSkillMod('expertise_youll_regret_that', 1000) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_youll_regret_that_1') + + actor.removeSkillMod('kill_meter_co_youll_regret_that_reac', 100) + actor.removeSkillMod('expertise_youll_regret_that', 1000) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_youll_regret_that_2.py b/scripts/expertise/expertise_co_youll_regret_that_2.py new file mode 100644 index 00000000..8075c520 --- /dev/null +++ b/scripts/expertise/expertise_co_youll_regret_that_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_youll_regret_that_2') + + actor.addSkillMod('kill_meter_co_youll_regret_that_reac', 0) + actor.addSkillMod('expertise_youll_regret_that', 1000) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_youll_regret_that_2') + + actor.removeSkillMod('kill_meter_co_youll_regret_that_reac', 0) + actor.removeSkillMod('expertise_youll_regret_that', 1000) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_youll_regret_that_3.py b/scripts/expertise/expertise_co_youll_regret_that_3.py new file mode 100644 index 00000000..e4724ece --- /dev/null +++ b/scripts/expertise/expertise_co_youll_regret_that_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_youll_regret_that_3') + + actor.addSkillMod('kill_meter_co_youll_regret_that_reac', 0) + actor.addSkillMod('expertise_youll_regret_that', 1000) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_youll_regret_that_3') + + actor.removeSkillMod('kill_meter_co_youll_regret_that_reac', 0) + actor.removeSkillMod('expertise_youll_regret_that', 1000) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_co_youll_regret_that_4.py b/scripts/expertise/expertise_co_youll_regret_that_4.py new file mode 100644 index 00000000..b4e02069 --- /dev/null +++ b/scripts/expertise/expertise_co_youll_regret_that_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.addSkill('expertise_co_youll_regret_that_4') + + actor.addSkillMod('kill_meter_co_youll_regret_that_reac', 0) + actor.addSkillMod('expertise_youll_regret_that', 1000) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'commando_1a': + return + + actor.removeSkill('expertise_co_youll_regret_that_4') + + actor.removeSkillMod('kill_meter_co_youll_regret_that_reac', 0) + actor.removeSkillMod('expertise_youll_regret_that', 1000) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_cybernetic_dexterity_1.py b/scripts/expertise/expertise_cybernetic_dexterity_1.py new file mode 100644 index 00000000..173aec59 --- /dev/null +++ b/scripts/expertise/expertise_cybernetic_dexterity_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_cybernetic_dexterity_1') + + actor.addSkillMod('cybernetic_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_cybernetic_dexterity_1') + + actor.removeSkillMod('cybernetic_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_cybernetic_dexterity_2.py b/scripts/expertise/expertise_cybernetic_dexterity_2.py new file mode 100644 index 00000000..1627c0f4 --- /dev/null +++ b/scripts/expertise/expertise_cybernetic_dexterity_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_cybernetic_dexterity_2') + + actor.addSkillMod('cybernetic_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_cybernetic_dexterity_2') + + actor.removeSkillMod('cybernetic_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_cybernetic_dexterity_3.py b/scripts/expertise/expertise_cybernetic_dexterity_3.py new file mode 100644 index 00000000..e80429b1 --- /dev/null +++ b/scripts/expertise/expertise_cybernetic_dexterity_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_cybernetic_dexterity_3') + + actor.addSkillMod('cybernetic_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_cybernetic_dexterity_3') + + actor.removeSkillMod('cybernetic_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_cybernetic_dexterity_4.py b/scripts/expertise/expertise_cybernetic_dexterity_4.py new file mode 100644 index 00000000..9e47bf2b --- /dev/null +++ b/scripts/expertise/expertise_cybernetic_dexterity_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_cybernetic_dexterity_4') + + actor.addSkillMod('cybernetic_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_cybernetic_dexterity_4') + + actor.removeSkillMod('cybernetic_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_artisan_advanced_theory_1.py b/scripts/expertise/expertise_domestic_artisan_advanced_theory_1.py new file mode 100644 index 00000000..bd8a80ca --- /dev/null +++ b/scripts/expertise/expertise_domestic_artisan_advanced_theory_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_artisan_advanced_theory_1') + + actor.addSkillMod('general_experimentation', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_artisan_advanced_theory_1') + + actor.removeSkillMod('general_experimentation', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_artisan_dexterity_1.py b/scripts/expertise/expertise_domestic_artisan_dexterity_1.py new file mode 100644 index 00000000..f473579f --- /dev/null +++ b/scripts/expertise/expertise_domestic_artisan_dexterity_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_artisan_dexterity_1') + + actor.addSkillMod('general_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_artisan_dexterity_1') + + actor.removeSkillMod('general_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_artisan_dexterity_2.py b/scripts/expertise/expertise_domestic_artisan_dexterity_2.py new file mode 100644 index 00000000..913a4d0e --- /dev/null +++ b/scripts/expertise/expertise_domestic_artisan_dexterity_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_artisan_dexterity_2') + + actor.addSkillMod('general_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_artisan_dexterity_2') + + actor.removeSkillMod('general_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_artisan_dexterity_3.py b/scripts/expertise/expertise_domestic_artisan_dexterity_3.py new file mode 100644 index 00000000..a430b03f --- /dev/null +++ b/scripts/expertise/expertise_domestic_artisan_dexterity_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_artisan_dexterity_3') + + actor.addSkillMod('general_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_artisan_dexterity_3') + + actor.removeSkillMod('general_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_artisan_dexterity_4.py b/scripts/expertise/expertise_domestic_artisan_dexterity_4.py new file mode 100644 index 00000000..aa5c57b2 --- /dev/null +++ b/scripts/expertise/expertise_domestic_artisan_dexterity_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_artisan_dexterity_4') + + actor.addSkillMod('general_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_artisan_dexterity_4') + + actor.removeSkillMod('general_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_artisan_hypothesis_1.py b/scripts/expertise/expertise_domestic_artisan_hypothesis_1.py new file mode 100644 index 00000000..00c3dbcb --- /dev/null +++ b/scripts/expertise/expertise_domestic_artisan_hypothesis_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_artisan_hypothesis_1') + + actor.addSkillMod('expertise_experimentation_increase_artisan', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_artisan_hypothesis_1') + + actor.removeSkillMod('expertise_experimentation_increase_artisan', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_artisan_hypothesis_2.py b/scripts/expertise/expertise_domestic_artisan_hypothesis_2.py new file mode 100644 index 00000000..b0e1ffc0 --- /dev/null +++ b/scripts/expertise/expertise_domestic_artisan_hypothesis_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_artisan_hypothesis_2') + + actor.addSkillMod('expertise_experimentation_increase_artisan', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_artisan_hypothesis_2') + + actor.removeSkillMod('expertise_experimentation_increase_artisan', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_artisan_hypothesis_3.py b/scripts/expertise/expertise_domestic_artisan_hypothesis_3.py new file mode 100644 index 00000000..e3411464 --- /dev/null +++ b/scripts/expertise/expertise_domestic_artisan_hypothesis_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_artisan_hypothesis_3') + + actor.addSkillMod('expertise_experimentation_increase_artisan', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_artisan_hypothesis_3') + + actor.removeSkillMod('expertise_experimentation_increase_artisan', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_artisan_hypothesis_4.py b/scripts/expertise/expertise_domestic_artisan_hypothesis_4.py new file mode 100644 index 00000000..81e4a849 --- /dev/null +++ b/scripts/expertise/expertise_domestic_artisan_hypothesis_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_artisan_hypothesis_4') + + actor.addSkillMod('expertise_experimentation_increase_artisan', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_artisan_hypothesis_4') + + actor.removeSkillMod('expertise_experimentation_increase_artisan', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_chef_advanced_theory_1.py b/scripts/expertise/expertise_domestic_chef_advanced_theory_1.py new file mode 100644 index 00000000..e3012ee2 --- /dev/null +++ b/scripts/expertise/expertise_domestic_chef_advanced_theory_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_chef_advanced_theory_1') + + actor.addSkillMod('food_experimentation', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_chef_advanced_theory_1') + + actor.removeSkillMod('food_experimentation', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_chef_dexterity_1.py b/scripts/expertise/expertise_domestic_chef_dexterity_1.py new file mode 100644 index 00000000..0a8f7fdd --- /dev/null +++ b/scripts/expertise/expertise_domestic_chef_dexterity_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_chef_dexterity_1') + + actor.addSkillMod('food_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_chef_dexterity_1') + + actor.removeSkillMod('food_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_chef_dexterity_2.py b/scripts/expertise/expertise_domestic_chef_dexterity_2.py new file mode 100644 index 00000000..b5430961 --- /dev/null +++ b/scripts/expertise/expertise_domestic_chef_dexterity_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_chef_dexterity_2') + + actor.addSkillMod('food_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_chef_dexterity_2') + + actor.removeSkillMod('food_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_chef_dexterity_3.py b/scripts/expertise/expertise_domestic_chef_dexterity_3.py new file mode 100644 index 00000000..f2e888a5 --- /dev/null +++ b/scripts/expertise/expertise_domestic_chef_dexterity_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_chef_dexterity_3') + + actor.addSkillMod('food_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_chef_dexterity_3') + + actor.removeSkillMod('food_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_chef_dexterity_4.py b/scripts/expertise/expertise_domestic_chef_dexterity_4.py new file mode 100644 index 00000000..0c8c273e --- /dev/null +++ b/scripts/expertise/expertise_domestic_chef_dexterity_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_chef_dexterity_4') + + actor.addSkillMod('food_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_chef_dexterity_4') + + actor.removeSkillMod('food_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_chef_hypothesis_1.py b/scripts/expertise/expertise_domestic_chef_hypothesis_1.py new file mode 100644 index 00000000..4d0ef1b3 --- /dev/null +++ b/scripts/expertise/expertise_domestic_chef_hypothesis_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_chef_hypothesis_1') + + actor.addSkillMod('expertise_experimentation_increase_chef', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_chef_hypothesis_1') + + actor.removeSkillMod('expertise_experimentation_increase_chef', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_chef_hypothesis_2.py b/scripts/expertise/expertise_domestic_chef_hypothesis_2.py new file mode 100644 index 00000000..2203b3f4 --- /dev/null +++ b/scripts/expertise/expertise_domestic_chef_hypothesis_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_chef_hypothesis_2') + + actor.addSkillMod('expertise_experimentation_increase_chef', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_chef_hypothesis_2') + + actor.removeSkillMod('expertise_experimentation_increase_chef', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_chef_hypothesis_3.py b/scripts/expertise/expertise_domestic_chef_hypothesis_3.py new file mode 100644 index 00000000..b82e5505 --- /dev/null +++ b/scripts/expertise/expertise_domestic_chef_hypothesis_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_chef_hypothesis_3') + + actor.addSkillMod('expertise_experimentation_increase_chef', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_chef_hypothesis_3') + + actor.removeSkillMod('expertise_experimentation_increase_chef', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_chef_hypothesis_4.py b/scripts/expertise/expertise_domestic_chef_hypothesis_4.py new file mode 100644 index 00000000..53e10ab3 --- /dev/null +++ b/scripts/expertise/expertise_domestic_chef_hypothesis_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_chef_hypothesis_4') + + actor.addSkillMod('expertise_experimentation_increase_chef', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_chef_hypothesis_4') + + actor.removeSkillMod('expertise_experimentation_increase_chef', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_chef_insight_1.py b/scripts/expertise/expertise_domestic_chef_insight_1.py new file mode 100644 index 00000000..1e07a424 --- /dev/null +++ b/scripts/expertise/expertise_domestic_chef_insight_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_chef_insight_1') + + actor.addSkillMod('expertise_complexity_decrease_chef', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_chef_insight_1') + + actor.removeSkillMod('expertise_complexity_decrease_chef', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_chef_insight_2.py b/scripts/expertise/expertise_domestic_chef_insight_2.py new file mode 100644 index 00000000..b3c8a9b9 --- /dev/null +++ b/scripts/expertise/expertise_domestic_chef_insight_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_chef_insight_2') + + actor.addSkillMod('expertise_complexity_decrease_chef', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_chef_insight_2') + + actor.removeSkillMod('expertise_complexity_decrease_chef', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_chef_keen_understanding_1.py b/scripts/expertise/expertise_domestic_chef_keen_understanding_1.py new file mode 100644 index 00000000..4449c44c --- /dev/null +++ b/scripts/expertise/expertise_domestic_chef_keen_understanding_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_chef_keen_understanding_1') + + actor.addSkillMod('expertise_complexity_decrease_chef', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_chef_keen_understanding_1') + + actor.removeSkillMod('expertise_complexity_decrease_chef', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_chef_keen_understanding_2.py b/scripts/expertise/expertise_domestic_chef_keen_understanding_2.py new file mode 100644 index 00000000..3fdc103f --- /dev/null +++ b/scripts/expertise/expertise_domestic_chef_keen_understanding_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_chef_keen_understanding_2') + + actor.addSkillMod('expertise_complexity_decrease_chef', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_chef_keen_understanding_2') + + actor.removeSkillMod('expertise_complexity_decrease_chef', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_chef_schematic_1_1.py b/scripts/expertise/expertise_domestic_chef_schematic_1_1.py new file mode 100644 index 00000000..47138106 --- /dev/null +++ b/scripts/expertise/expertise_domestic_chef_schematic_1_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_chef_schematic_1_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_chef_schematic_1_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_chef_schematic_2_1.py b/scripts/expertise/expertise_domestic_chef_schematic_2_1.py new file mode 100644 index 00000000..1ec86323 --- /dev/null +++ b/scripts/expertise/expertise_domestic_chef_schematic_2_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_chef_schematic_2_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_chef_schematic_2_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_resource_processing_1.py b/scripts/expertise/expertise_domestic_resource_processing_1.py new file mode 100644 index 00000000..62a2adf5 --- /dev/null +++ b/scripts/expertise/expertise_domestic_resource_processing_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_resource_processing_1') + + actor.addSkillMod('expertise_resource_quality_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_resource_processing_1') + + actor.removeSkillMod('expertise_resource_quality_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_resource_processing_2.py b/scripts/expertise/expertise_domestic_resource_processing_2.py new file mode 100644 index 00000000..ccd73bd5 --- /dev/null +++ b/scripts/expertise/expertise_domestic_resource_processing_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_resource_processing_2') + + actor.addSkillMod('expertise_resource_quality_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_resource_processing_2') + + actor.removeSkillMod('expertise_resource_quality_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_resource_refinement_1.py b/scripts/expertise/expertise_domestic_resource_refinement_1.py new file mode 100644 index 00000000..fd3e810f --- /dev/null +++ b/scripts/expertise/expertise_domestic_resource_refinement_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_resource_refinement_1') + + actor.addSkillMod('expertise_resource_quality_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_resource_refinement_1') + + actor.removeSkillMod('expertise_resource_quality_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_resource_refinement_2.py b/scripts/expertise/expertise_domestic_resource_refinement_2.py new file mode 100644 index 00000000..9dfedf70 --- /dev/null +++ b/scripts/expertise/expertise_domestic_resource_refinement_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_resource_refinement_2') + + actor.addSkillMod('expertise_resource_quality_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_resource_refinement_2') + + actor.removeSkillMod('expertise_resource_quality_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_tailor_advanced_theory_1.py b/scripts/expertise/expertise_domestic_tailor_advanced_theory_1.py new file mode 100644 index 00000000..2a84d182 --- /dev/null +++ b/scripts/expertise/expertise_domestic_tailor_advanced_theory_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_tailor_advanced_theory_1') + + actor.addSkillMod('clothing_experimentation', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_tailor_advanced_theory_1') + + actor.removeSkillMod('clothing_experimentation', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_tailor_attachment_upgrade_1.py b/scripts/expertise/expertise_domestic_tailor_attachment_upgrade_1.py new file mode 100644 index 00000000..c3be240b --- /dev/null +++ b/scripts/expertise/expertise_domestic_tailor_attachment_upgrade_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_tailor_attachment_upgrade_1') + + actor.addSkillMod('expertise_attachment_upgrade', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_tailor_attachment_upgrade_1') + + actor.removeSkillMod('expertise_attachment_upgrade', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_tailor_dexterity_1.py b/scripts/expertise/expertise_domestic_tailor_dexterity_1.py new file mode 100644 index 00000000..c0c3c0bb --- /dev/null +++ b/scripts/expertise/expertise_domestic_tailor_dexterity_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_tailor_dexterity_1') + + actor.addSkillMod('clothing_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_tailor_dexterity_1') + + actor.removeSkillMod('clothing_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_tailor_dexterity_2.py b/scripts/expertise/expertise_domestic_tailor_dexterity_2.py new file mode 100644 index 00000000..24fb5fc8 --- /dev/null +++ b/scripts/expertise/expertise_domestic_tailor_dexterity_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_tailor_dexterity_2') + + actor.addSkillMod('clothing_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_tailor_dexterity_2') + + actor.removeSkillMod('clothing_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_tailor_dexterity_3.py b/scripts/expertise/expertise_domestic_tailor_dexterity_3.py new file mode 100644 index 00000000..8bee3264 --- /dev/null +++ b/scripts/expertise/expertise_domestic_tailor_dexterity_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_tailor_dexterity_3') + + actor.addSkillMod('clothing_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_tailor_dexterity_3') + + actor.removeSkillMod('clothing_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_tailor_dexterity_4.py b/scripts/expertise/expertise_domestic_tailor_dexterity_4.py new file mode 100644 index 00000000..828adfd1 --- /dev/null +++ b/scripts/expertise/expertise_domestic_tailor_dexterity_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_tailor_dexterity_4') + + actor.addSkillMod('clothing_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_tailor_dexterity_4') + + actor.removeSkillMod('clothing_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_tailor_hypothesis_1.py b/scripts/expertise/expertise_domestic_tailor_hypothesis_1.py new file mode 100644 index 00000000..d384d0ea --- /dev/null +++ b/scripts/expertise/expertise_domestic_tailor_hypothesis_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_tailor_hypothesis_1') + + actor.addSkillMod('expertise_experimentation_increase_tailor', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_tailor_hypothesis_1') + + actor.removeSkillMod('expertise_experimentation_increase_tailor', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_tailor_hypothesis_2.py b/scripts/expertise/expertise_domestic_tailor_hypothesis_2.py new file mode 100644 index 00000000..dc25b650 --- /dev/null +++ b/scripts/expertise/expertise_domestic_tailor_hypothesis_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_tailor_hypothesis_2') + + actor.addSkillMod('expertise_experimentation_increase_tailor', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_tailor_hypothesis_2') + + actor.removeSkillMod('expertise_experimentation_increase_tailor', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_tailor_hypothesis_3.py b/scripts/expertise/expertise_domestic_tailor_hypothesis_3.py new file mode 100644 index 00000000..41572d81 --- /dev/null +++ b/scripts/expertise/expertise_domestic_tailor_hypothesis_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_tailor_hypothesis_3') + + actor.addSkillMod('expertise_experimentation_increase_tailor', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_tailor_hypothesis_3') + + actor.removeSkillMod('expertise_experimentation_increase_tailor', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_tailor_hypothesis_4.py b/scripts/expertise/expertise_domestic_tailor_hypothesis_4.py new file mode 100644 index 00000000..2009c763 --- /dev/null +++ b/scripts/expertise/expertise_domestic_tailor_hypothesis_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_tailor_hypothesis_4') + + actor.addSkillMod('expertise_experimentation_increase_tailor', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_tailor_hypothesis_4') + + actor.removeSkillMod('expertise_experimentation_increase_tailor', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_tailor_insight_1.py b/scripts/expertise/expertise_domestic_tailor_insight_1.py new file mode 100644 index 00000000..1734ab71 --- /dev/null +++ b/scripts/expertise/expertise_domestic_tailor_insight_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_tailor_insight_1') + + actor.addSkillMod('expertise_complexity_decrease_tailor', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_tailor_insight_1') + + actor.removeSkillMod('expertise_complexity_decrease_tailor', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_tailor_insight_2.py b/scripts/expertise/expertise_domestic_tailor_insight_2.py new file mode 100644 index 00000000..e65231bd --- /dev/null +++ b/scripts/expertise/expertise_domestic_tailor_insight_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_tailor_insight_2') + + actor.addSkillMod('expertise_complexity_decrease_tailor', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_tailor_insight_2') + + actor.removeSkillMod('expertise_complexity_decrease_tailor', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_tailor_keen_understanding_1.py b/scripts/expertise/expertise_domestic_tailor_keen_understanding_1.py new file mode 100644 index 00000000..59a274ff --- /dev/null +++ b/scripts/expertise/expertise_domestic_tailor_keen_understanding_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_tailor_keen_understanding_1') + + actor.addSkillMod('expertise_complexity_decrease_tailor', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_tailor_keen_understanding_1') + + actor.removeSkillMod('expertise_complexity_decrease_tailor', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_tailor_keen_understanding_2.py b/scripts/expertise/expertise_domestic_tailor_keen_understanding_2.py new file mode 100644 index 00000000..1504d0e2 --- /dev/null +++ b/scripts/expertise/expertise_domestic_tailor_keen_understanding_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_tailor_keen_understanding_2') + + actor.addSkillMod('expertise_complexity_decrease_tailor', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_tailor_keen_understanding_2') + + actor.removeSkillMod('expertise_complexity_decrease_tailor', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_domestic_tailor_socket_bonus_1.py b/scripts/expertise/expertise_domestic_tailor_socket_bonus_1.py new file mode 100644 index 00000000..9c86c720 --- /dev/null +++ b/scripts/expertise/expertise_domestic_tailor_socket_bonus_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.addSkill('expertise_domestic_tailor_socket_bonus_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_dom_1a': + return + + actor.removeSkill('expertise_domestic_tailor_socket_bonus_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_affability_1.py b/scripts/expertise/expertise_en_affability_1.py new file mode 100644 index 00000000..7057b18d --- /dev/null +++ b/scripts/expertise/expertise_en_affability_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_affability_1') + + actor.addSkillMod('expertise_en_performance_increase', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_affability_1') + + actor.removeSkillMod('expertise_en_performance_increase', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_affability_2.py b/scripts/expertise/expertise_en_affability_2.py new file mode 100644 index 00000000..fe7cad65 --- /dev/null +++ b/scripts/expertise/expertise_en_affability_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_affability_2') + + actor.addSkillMod('expertise_en_performance_increase', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_affability_2') + + actor.removeSkillMod('expertise_en_performance_increase', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_affability_3.py b/scripts/expertise/expertise_en_affability_3.py new file mode 100644 index 00000000..7a73a8ef --- /dev/null +++ b/scripts/expertise/expertise_en_affability_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_affability_3') + + actor.addSkillMod('expertise_en_performance_increase', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_affability_3') + + actor.removeSkillMod('expertise_en_performance_increase', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_affability_4.py b/scripts/expertise/expertise_en_affability_4.py new file mode 100644 index 00000000..3ae998dc --- /dev/null +++ b/scripts/expertise/expertise_en_affability_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_affability_4') + + actor.addSkillMod('expertise_en_performance_increase', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_affability_4') + + actor.removeSkillMod('expertise_en_performance_increase', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_allure_1.py b/scripts/expertise/expertise_en_allure_1.py new file mode 100644 index 00000000..e4c017a8 --- /dev/null +++ b/scripts/expertise/expertise_en_allure_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_allure_1') + + actor.addSkillMod('expertise_buff_duration_line_en_unhealthy_fixation_debuff', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_allure_1') + + actor.removeSkillMod('expertise_buff_duration_line_en_unhealthy_fixation_debuff', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_allure_2.py b/scripts/expertise/expertise_en_allure_2.py new file mode 100644 index 00000000..bb95fb7b --- /dev/null +++ b/scripts/expertise/expertise_en_allure_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_allure_2') + + actor.addSkillMod('expertise_buff_duration_line_en_unhealthy_fixation_debuff', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_allure_2') + + actor.removeSkillMod('expertise_buff_duration_line_en_unhealthy_fixation_debuff', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_allure_3.py b/scripts/expertise/expertise_en_allure_3.py new file mode 100644 index 00000000..b0385c29 --- /dev/null +++ b/scripts/expertise/expertise_en_allure_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_allure_3') + + actor.addSkillMod('expertise_buff_duration_line_en_unhealthy_fixation_debuff', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_allure_3') + + actor.removeSkillMod('expertise_buff_duration_line_en_unhealthy_fixation_debuff', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_annulling_1.py b/scripts/expertise/expertise_en_annulling_1.py new file mode 100644 index 00000000..a2565ffd --- /dev/null +++ b/scripts/expertise/expertise_en_annulling_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_annulling_1') + + actor.addSkillMod('expertise_buff_en_void_dance_buff', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_annulling_1') + + actor.removeSkillMod('expertise_buff_en_void_dance_buff', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_annulling_2.py b/scripts/expertise/expertise_en_annulling_2.py new file mode 100644 index 00000000..c80a1394 --- /dev/null +++ b/scripts/expertise/expertise_en_annulling_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_annulling_2') + + actor.addSkillMod('expertise_buff_en_void_dance_buff', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_annulling_2') + + actor.removeSkillMod('expertise_buff_en_void_dance_buff', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_annulling_3.py b/scripts/expertise/expertise_en_annulling_3.py new file mode 100644 index 00000000..457479f8 --- /dev/null +++ b/scripts/expertise/expertise_en_annulling_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_annulling_3') + + actor.addSkillMod('expertise_buff_en_void_dance_buff', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_annulling_3') + + actor.removeSkillMod('expertise_buff_en_void_dance_buff', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_conditioned_vessel_1.py b/scripts/expertise/expertise_en_conditioned_vessel_1.py new file mode 100644 index 00000000..49149612 --- /dev/null +++ b/scripts/expertise/expertise_en_conditioned_vessel_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_conditioned_vessel_1') + + actor.addSkillMod('expertise_damage_melee', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_conditioned_vessel_1') + + actor.removeSkillMod('expertise_damage_melee', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_conditioned_vessel_2.py b/scripts/expertise/expertise_en_conditioned_vessel_2.py new file mode 100644 index 00000000..e8dd80c1 --- /dev/null +++ b/scripts/expertise/expertise_en_conditioned_vessel_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_conditioned_vessel_2') + + actor.addSkillMod('expertise_damage_melee', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_conditioned_vessel_2') + + actor.removeSkillMod('expertise_damage_melee', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_conditioned_vessel_3.py b/scripts/expertise/expertise_en_conditioned_vessel_3.py new file mode 100644 index 00000000..e32a7943 --- /dev/null +++ b/scripts/expertise/expertise_en_conditioned_vessel_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_conditioned_vessel_3') + + actor.addSkillMod('expertise_damage_melee', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_conditioned_vessel_3') + + actor.removeSkillMod('expertise_damage_melee', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_conditioned_vessel_4.py b/scripts/expertise/expertise_en_conditioned_vessel_4.py new file mode 100644 index 00000000..ce6146de --- /dev/null +++ b/scripts/expertise/expertise_en_conditioned_vessel_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_conditioned_vessel_4') + + actor.addSkillMod('expertise_damage_melee', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_conditioned_vessel_4') + + actor.removeSkillMod('expertise_damage_melee', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_controlled_spin_1.py b/scripts/expertise/expertise_en_controlled_spin_1.py new file mode 100644 index 00000000..4ff248df --- /dev/null +++ b/scripts/expertise/expertise_en_controlled_spin_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_controlled_spin_1') + + actor.addSkillMod('expertise_damage_line_en_sweeping_pirouette', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_controlled_spin_1') + + actor.removeSkillMod('expertise_damage_line_en_sweeping_pirouette', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_controlled_spin_2.py b/scripts/expertise/expertise_en_controlled_spin_2.py new file mode 100644 index 00000000..3b9f1f51 --- /dev/null +++ b/scripts/expertise/expertise_en_controlled_spin_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_controlled_spin_2') + + actor.addSkillMod('expertise_damage_line_en_sweeping_pirouette', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_controlled_spin_2') + + actor.removeSkillMod('expertise_damage_line_en_sweeping_pirouette', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_controlled_spin_3.py b/scripts/expertise/expertise_en_controlled_spin_3.py new file mode 100644 index 00000000..222ca61c --- /dev/null +++ b/scripts/expertise/expertise_en_controlled_spin_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_controlled_spin_3') + + actor.addSkillMod('expertise_damage_line_en_sweeping_pirouette', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_controlled_spin_3') + + actor.removeSkillMod('expertise_damage_line_en_sweeping_pirouette', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_creativity_1.py b/scripts/expertise/expertise_en_creativity_1.py new file mode 100644 index 00000000..0583185f --- /dev/null +++ b/scripts/expertise/expertise_en_creativity_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_creativity_1') + + actor.addSkillMod('expertise_en_inspire_base_point_increase', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_creativity_1') + + actor.removeSkillMod('expertise_en_inspire_base_point_increase', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_creativity_2.py b/scripts/expertise/expertise_en_creativity_2.py new file mode 100644 index 00000000..e04aea75 --- /dev/null +++ b/scripts/expertise/expertise_en_creativity_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_creativity_2') + + actor.addSkillMod('expertise_en_inspire_base_point_increase', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_creativity_2') + + actor.removeSkillMod('expertise_en_inspire_base_point_increase', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_creativity_3.py b/scripts/expertise/expertise_en_creativity_3.py new file mode 100644 index 00000000..581aff38 --- /dev/null +++ b/scripts/expertise/expertise_en_creativity_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_creativity_3') + + actor.addSkillMod('expertise_en_inspire_base_point_increase', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_creativity_3') + + actor.removeSkillMod('expertise_en_inspire_base_point_increase', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_creativity_4.py b/scripts/expertise/expertise_en_creativity_4.py new file mode 100644 index 00000000..35867c4a --- /dev/null +++ b/scripts/expertise/expertise_en_creativity_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_creativity_4') + + actor.addSkillMod('expertise_en_inspire_base_point_increase', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_creativity_4') + + actor.removeSkillMod('expertise_en_inspire_base_point_increase', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_dramatic_flair_1.py b/scripts/expertise/expertise_en_dramatic_flair_1.py new file mode 100644 index 00000000..4195deb4 --- /dev/null +++ b/scripts/expertise/expertise_en_dramatic_flair_1.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_dramatic_flair_1') + + actor.addSkillMod('constitution_modified', 15) + actor.addSkillMod('strength_modified', 15) + actor.addSkillMod('stamina_modified', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_dramatic_flair_1') + + actor.removeSkillMod('constitution_modified', 15) + actor.removeSkillMod('strength_modified', 15) + actor.removeSkillMod('stamina_modified', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_dramatic_flair_2.py b/scripts/expertise/expertise_en_dramatic_flair_2.py new file mode 100644 index 00000000..8706a5d3 --- /dev/null +++ b/scripts/expertise/expertise_en_dramatic_flair_2.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_dramatic_flair_2') + + actor.addSkillMod('constitution_modified', 15) + actor.addSkillMod('strength_modified', 15) + actor.addSkillMod('stamina_modified', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_dramatic_flair_2') + + actor.removeSkillMod('constitution_modified', 15) + actor.removeSkillMod('strength_modified', 15) + actor.removeSkillMod('stamina_modified', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_dramatic_flair_3.py b/scripts/expertise/expertise_en_dramatic_flair_3.py new file mode 100644 index 00000000..070e4796 --- /dev/null +++ b/scripts/expertise/expertise_en_dramatic_flair_3.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_dramatic_flair_3') + + actor.addSkillMod('constitution_modified', 15) + actor.addSkillMod('strength_modified', 15) + actor.addSkillMod('stamina_modified', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_dramatic_flair_3') + + actor.removeSkillMod('constitution_modified', 15) + actor.removeSkillMod('strength_modified', 15) + actor.removeSkillMod('stamina_modified', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_dramatic_flair_4.py b/scripts/expertise/expertise_en_dramatic_flair_4.py new file mode 100644 index 00000000..74442f0d --- /dev/null +++ b/scripts/expertise/expertise_en_dramatic_flair_4.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_dramatic_flair_4') + + actor.addSkillMod('constitution_modified', 15) + actor.addSkillMod('strength_modified', 15) + actor.addSkillMod('stamina_modified', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_dramatic_flair_4') + + actor.removeSkillMod('constitution_modified', 15) + actor.removeSkillMod('strength_modified', 15) + actor.removeSkillMod('stamina_modified', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_emotional_prescience_1.py b/scripts/expertise/expertise_en_emotional_prescience_1.py new file mode 100644 index 00000000..3b7660fa --- /dev/null +++ b/scripts/expertise/expertise_en_emotional_prescience_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_emotional_prescience_1') + + actor.addSkillMod('expertise_glancing_blow_all', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_emotional_prescience_1') + + actor.removeSkillMod('expertise_glancing_blow_all', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_emotional_prescience_2.py b/scripts/expertise/expertise_en_emotional_prescience_2.py new file mode 100644 index 00000000..f114424f --- /dev/null +++ b/scripts/expertise/expertise_en_emotional_prescience_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_emotional_prescience_2') + + actor.addSkillMod('expertise_glancing_blow_all', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_emotional_prescience_2') + + actor.removeSkillMod('expertise_glancing_blow_all', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_emotional_prescience_3.py b/scripts/expertise/expertise_en_emotional_prescience_3.py new file mode 100644 index 00000000..237d5361 --- /dev/null +++ b/scripts/expertise/expertise_en_emotional_prescience_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_emotional_prescience_3') + + actor.addSkillMod('expertise_glancing_blow_all', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_emotional_prescience_3') + + actor.removeSkillMod('expertise_glancing_blow_all', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_emotional_prescience_4.py b/scripts/expertise/expertise_en_emotional_prescience_4.py new file mode 100644 index 00000000..482d9bb2 --- /dev/null +++ b/scripts/expertise/expertise_en_emotional_prescience_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_emotional_prescience_4') + + actor.addSkillMod('expertise_glancing_blow_all', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_emotional_prescience_4') + + actor.removeSkillMod('expertise_glancing_blow_all', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_encore_heal_1.py b/scripts/expertise/expertise_en_encore_heal_1.py new file mode 100644 index 00000000..45e2ff4a --- /dev/null +++ b/scripts/expertise/expertise_en_encore_heal_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_encore_heal_1') + + actor.addSkillMod('expertise_healing_line_en_heal', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_encore_heal_1') + + actor.removeSkillMod('expertise_healing_line_en_heal', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_encore_heal_2.py b/scripts/expertise/expertise_en_encore_heal_2.py new file mode 100644 index 00000000..ea8aea9d --- /dev/null +++ b/scripts/expertise/expertise_en_encore_heal_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_encore_heal_2') + + actor.addSkillMod('expertise_healing_line_en_heal', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_encore_heal_2') + + actor.removeSkillMod('expertise_healing_line_en_heal', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_encore_heal_3.py b/scripts/expertise/expertise_en_encore_heal_3.py new file mode 100644 index 00000000..d8036306 --- /dev/null +++ b/scripts/expertise/expertise_en_encore_heal_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_encore_heal_3') + + actor.addSkillMod('expertise_healing_line_en_heal', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_encore_heal_3') + + actor.removeSkillMod('expertise_healing_line_en_heal', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_flush_with_success_1.py b/scripts/expertise/expertise_en_flush_with_success_1.py new file mode 100644 index 00000000..f94ae5e5 --- /dev/null +++ b/scripts/expertise/expertise_en_flush_with_success_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_flush_with_success_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_flush_with_success_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('en_flush_with_success_buff_package') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('en_flush_with_success_buff_package') + + return diff --git a/scripts/expertise/expertise_en_focused_control_1.py b/scripts/expertise/expertise_en_focused_control_1.py new file mode 100644 index 00000000..d781a25e --- /dev/null +++ b/scripts/expertise/expertise_en_focused_control_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_focused_control_1') + + actor.addSkillMod('expertise_action_weapon_melee', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_focused_control_1') + + actor.removeSkillMod('expertise_action_weapon_melee', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_focused_control_2.py b/scripts/expertise/expertise_en_focused_control_2.py new file mode 100644 index 00000000..9e78ebe3 --- /dev/null +++ b/scripts/expertise/expertise_en_focused_control_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_focused_control_2') + + actor.addSkillMod('expertise_action_weapon_melee', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_focused_control_2') + + actor.removeSkillMod('expertise_action_weapon_melee', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_focused_control_3.py b/scripts/expertise/expertise_en_focused_control_3.py new file mode 100644 index 00000000..17a8b154 --- /dev/null +++ b/scripts/expertise/expertise_en_focused_control_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_focused_control_3') + + actor.addSkillMod('expertise_action_weapon_melee', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_focused_control_3') + + actor.removeSkillMod('expertise_action_weapon_melee', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_focused_control_4.py b/scripts/expertise/expertise_en_focused_control_4.py new file mode 100644 index 00000000..cc4e07a9 --- /dev/null +++ b/scripts/expertise/expertise_en_focused_control_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_focused_control_4') + + actor.addSkillMod('expertise_action_weapon_melee', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_focused_control_4') + + actor.removeSkillMod('expertise_action_weapon_melee', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_folded_inward_1.py b/scripts/expertise/expertise_en_folded_inward_1.py new file mode 100644 index 00000000..55c57629 --- /dev/null +++ b/scripts/expertise/expertise_en_folded_inward_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_folded_inward_1') + + actor.addSkillMod('expertise_innate_protection_all', 250) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_folded_inward_1') + + actor.removeSkillMod('expertise_innate_protection_all', 250) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_folded_inward_2.py b/scripts/expertise/expertise_en_folded_inward_2.py new file mode 100644 index 00000000..65df6e4f --- /dev/null +++ b/scripts/expertise/expertise_en_folded_inward_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_folded_inward_2') + + actor.addSkillMod('expertise_innate_protection_all', 250) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_folded_inward_2') + + actor.removeSkillMod('expertise_innate_protection_all', 250) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_folded_inward_3.py b/scripts/expertise/expertise_en_folded_inward_3.py new file mode 100644 index 00000000..7717392f --- /dev/null +++ b/scripts/expertise/expertise_en_folded_inward_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_folded_inward_3') + + actor.addSkillMod('expertise_innate_protection_all', 250) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_folded_inward_3') + + actor.removeSkillMod('expertise_innate_protection_all', 250) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_folded_inward_4.py b/scripts/expertise/expertise_en_folded_inward_4.py new file mode 100644 index 00000000..7ece6014 --- /dev/null +++ b/scripts/expertise/expertise_en_folded_inward_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_folded_inward_4') + + actor.addSkillMod('expertise_innate_protection_all', 250) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_folded_inward_4') + + actor.removeSkillMod('expertise_innate_protection_all', 250) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_go_with_the_flow_1.py b/scripts/expertise/expertise_en_go_with_the_flow_1.py new file mode 100644 index 00000000..5f8c9bfa --- /dev/null +++ b/scripts/expertise/expertise_en_go_with_the_flow_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_go_with_the_flow_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_go_with_the_flow_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('en_go_with_the_flow_buff_package') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('en_go_with_the_flow_buff_package') + + return diff --git a/scripts/expertise/expertise_en_harvest_faire_1.py b/scripts/expertise/expertise_en_harvest_faire_1.py new file mode 100644 index 00000000..924feeb4 --- /dev/null +++ b/scripts/expertise/expertise_en_harvest_faire_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_harvest_faire_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_harvest_faire_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('en_harvest_faire_buff_package') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('en_harvest_faire_buff_package') + + return diff --git a/scripts/expertise/expertise_en_heal_1.py b/scripts/expertise/expertise_en_heal_1.py new file mode 100644 index 00000000..a80678b6 --- /dev/null +++ b/scripts/expertise/expertise_en_heal_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_heal_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_heal_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('en_heal_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('en_heal_1') + + return diff --git a/scripts/expertise/expertise_en_holism_1.py b/scripts/expertise/expertise_en_holism_1.py new file mode 100644 index 00000000..8240988c --- /dev/null +++ b/scripts/expertise/expertise_en_holism_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_holism_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_holism_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('en_healer_buff_package') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('en_healer_buff_package') + + return diff --git a/scripts/expertise/expertise_en_holographic_duration_1.py b/scripts/expertise/expertise_en_holographic_duration_1.py new file mode 100644 index 00000000..2b9bcf4d --- /dev/null +++ b/scripts/expertise/expertise_en_holographic_duration_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_holographic_duration_1') + + actor.addSkillMod('expertise_en_holographic_duration', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_holographic_duration_1') + + actor.removeSkillMod('expertise_en_holographic_duration', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_holographic_mastery_1.py b/scripts/expertise/expertise_en_holographic_mastery_1.py new file mode 100644 index 00000000..49e65ba1 --- /dev/null +++ b/scripts/expertise/expertise_en_holographic_mastery_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_holographic_mastery_1') + + actor.addSkillMod('expertise_en_holographic_additional_backup', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_holographic_mastery_1') + + actor.removeSkillMod('expertise_en_holographic_additional_backup', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_holographic_mastery_2.py b/scripts/expertise/expertise_en_holographic_mastery_2.py new file mode 100644 index 00000000..231c7f2e --- /dev/null +++ b/scripts/expertise/expertise_en_holographic_mastery_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_holographic_mastery_2') + + actor.addSkillMod('expertise_en_holographic_additional_backup', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_holographic_mastery_2') + + actor.removeSkillMod('expertise_en_holographic_additional_backup', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_improv_1.py b/scripts/expertise/expertise_en_improv_1.py new file mode 100644 index 00000000..72cdde87 --- /dev/null +++ b/scripts/expertise/expertise_en_improv_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_improv_1') + + actor.addSkillMod('expertise_en_improv', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_improv_1') + + actor.removeSkillMod('expertise_en_improv', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_fitness_1.py b/scripts/expertise/expertise_en_inspired_fitness_1.py new file mode 100644 index 00000000..0c390c15 --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_fitness_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_fitness_1') + + actor.addSkillMod('expertise_en_inspire_attrib_increase', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_fitness_1') + + actor.removeSkillMod('expertise_en_inspire_attrib_increase', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_fitness_2.py b/scripts/expertise/expertise_en_inspired_fitness_2.py new file mode 100644 index 00000000..6c5673b2 --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_fitness_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_fitness_2') + + actor.addSkillMod('expertise_en_inspire_attrib_increase', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_fitness_2') + + actor.removeSkillMod('expertise_en_inspire_attrib_increase', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_fitness_3.py b/scripts/expertise/expertise_en_inspired_fitness_3.py new file mode 100644 index 00000000..e5612aa8 --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_fitness_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_fitness_3') + + actor.addSkillMod('expertise_en_inspire_attrib_increase', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_fitness_3') + + actor.removeSkillMod('expertise_en_inspire_attrib_increase', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_fitness_4.py b/scripts/expertise/expertise_en_inspired_fitness_4.py new file mode 100644 index 00000000..e3dd6795 --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_fitness_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_fitness_4') + + actor.addSkillMod('expertise_en_inspire_attrib_increase', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_fitness_4') + + actor.removeSkillMod('expertise_en_inspire_attrib_increase', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_industry_1.py b/scripts/expertise/expertise_en_inspired_industry_1.py new file mode 100644 index 00000000..984745b2 --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_industry_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_industry_1') + + actor.addSkillMod('expertise_en_inspire_trader_increase', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_industry_1') + + actor.removeSkillMod('expertise_en_inspire_trader_increase', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_industry_2.py b/scripts/expertise/expertise_en_inspired_industry_2.py new file mode 100644 index 00000000..bf04fe23 --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_industry_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_industry_2') + + actor.addSkillMod('expertise_en_inspire_trader_increase', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_industry_2') + + actor.removeSkillMod('expertise_en_inspire_trader_increase', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_industry_3.py b/scripts/expertise/expertise_en_inspired_industry_3.py new file mode 100644 index 00000000..7aa507cd --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_industry_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_industry_3') + + actor.addSkillMod('expertise_en_inspire_trader_increase', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_industry_3') + + actor.removeSkillMod('expertise_en_inspire_trader_increase', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_industry_4.py b/scripts/expertise/expertise_en_inspired_industry_4.py new file mode 100644 index 00000000..eb6e23dc --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_industry_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_industry_4') + + actor.addSkillMod('expertise_en_inspire_trader_increase', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_industry_4') + + actor.removeSkillMod('expertise_en_inspire_trader_increase', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_reactions_1.py b/scripts/expertise/expertise_en_inspired_reactions_1.py new file mode 100644 index 00000000..70e22c6b --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_reactions_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_reactions_1') + + actor.addSkillMod('expertise_en_inspire_proc_chance_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_reactions_1') + + actor.removeSkillMod('expertise_en_inspire_proc_chance_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_reactions_2.py b/scripts/expertise/expertise_en_inspired_reactions_2.py new file mode 100644 index 00000000..8c43af78 --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_reactions_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_reactions_2') + + actor.addSkillMod('expertise_en_inspire_proc_chance_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_reactions_2') + + actor.removeSkillMod('expertise_en_inspire_proc_chance_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_reactions_3.py b/scripts/expertise/expertise_en_inspired_reactions_3.py new file mode 100644 index 00000000..8cb9b345 --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_reactions_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_reactions_3') + + actor.addSkillMod('expertise_en_inspire_proc_chance_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_reactions_3') + + actor.removeSkillMod('expertise_en_inspire_proc_chance_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_reactions_4.py b/scripts/expertise/expertise_en_inspired_reactions_4.py new file mode 100644 index 00000000..fabf14bf --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_reactions_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_reactions_4') + + actor.addSkillMod('expertise_en_inspire_proc_chance_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_reactions_4') + + actor.removeSkillMod('expertise_en_inspire_proc_chance_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_resilience_1.py b/scripts/expertise/expertise_en_inspired_resilience_1.py new file mode 100644 index 00000000..f758fba6 --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_resilience_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_resilience_1') + + actor.addSkillMod('expertise_en_inspire_resist_increase', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_resilience_1') + + actor.removeSkillMod('expertise_en_inspire_resist_increase', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_resilience_2.py b/scripts/expertise/expertise_en_inspired_resilience_2.py new file mode 100644 index 00000000..9bb7a05a --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_resilience_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_resilience_2') + + actor.addSkillMod('expertise_en_inspire_resist_increase', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_resilience_2') + + actor.removeSkillMod('expertise_en_inspire_resist_increase', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_resilience_3.py b/scripts/expertise/expertise_en_inspired_resilience_3.py new file mode 100644 index 00000000..9be4cfb8 --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_resilience_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_resilience_3') + + actor.addSkillMod('expertise_en_inspire_resist_increase', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_resilience_3') + + actor.removeSkillMod('expertise_en_inspire_resist_increase', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_resilience_4.py b/scripts/expertise/expertise_en_inspired_resilience_4.py new file mode 100644 index 00000000..964c5a3d --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_resilience_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_resilience_4') + + actor.addSkillMod('expertise_en_inspire_resist_increase', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_resilience_4') + + actor.removeSkillMod('expertise_en_inspire_resist_increase', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_warfare_1.py b/scripts/expertise/expertise_en_inspired_warfare_1.py new file mode 100644 index 00000000..e912692f --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_warfare_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_warfare_1') + + actor.addSkillMod('expertise_en_combat_buff_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_warfare_1') + + actor.removeSkillMod('expertise_en_combat_buff_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_warfare_2.py b/scripts/expertise/expertise_en_inspired_warfare_2.py new file mode 100644 index 00000000..20007561 --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_warfare_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_warfare_2') + + actor.addSkillMod('expertise_en_combat_buff_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_warfare_2') + + actor.removeSkillMod('expertise_en_combat_buff_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_warfare_3.py b/scripts/expertise/expertise_en_inspired_warfare_3.py new file mode 100644 index 00000000..8c94697d --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_warfare_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_warfare_3') + + actor.addSkillMod('expertise_en_combat_buff_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_warfare_3') + + actor.removeSkillMod('expertise_en_combat_buff_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_inspired_warfare_4.py b/scripts/expertise/expertise_en_inspired_warfare_4.py new file mode 100644 index 00000000..9a235b2e --- /dev/null +++ b/scripts/expertise/expertise_en_inspired_warfare_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_inspired_warfare_4') + + actor.addSkillMod('expertise_en_combat_buff_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_inspired_warfare_4') + + actor.removeSkillMod('expertise_en_combat_buff_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_intense_performer_1.py b/scripts/expertise/expertise_en_intense_performer_1.py new file mode 100644 index 00000000..545cb29d --- /dev/null +++ b/scripts/expertise/expertise_en_intense_performer_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_intense_performer_1') + + actor.addSkillMod('expertise_en_inspire_pulse_duration_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_intense_performer_1') + + actor.removeSkillMod('expertise_en_inspire_pulse_duration_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_intense_performer_2.py b/scripts/expertise/expertise_en_intense_performer_2.py new file mode 100644 index 00000000..5cab16af --- /dev/null +++ b/scripts/expertise/expertise_en_intense_performer_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_intense_performer_2') + + actor.addSkillMod('expertise_en_inspire_pulse_duration_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_intense_performer_2') + + actor.removeSkillMod('expertise_en_inspire_pulse_duration_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_intense_performer_3.py b/scripts/expertise/expertise_en_intense_performer_3.py new file mode 100644 index 00000000..2906eb60 --- /dev/null +++ b/scripts/expertise/expertise_en_intense_performer_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_intense_performer_3') + + actor.addSkillMod('expertise_en_inspire_pulse_duration_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_intense_performer_3') + + actor.removeSkillMod('expertise_en_inspire_pulse_duration_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_intense_performer_4.py b/scripts/expertise/expertise_en_intense_performer_4.py new file mode 100644 index 00000000..b1a35e36 --- /dev/null +++ b/scripts/expertise/expertise_en_intense_performer_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_intense_performer_4') + + actor.addSkillMod('expertise_en_inspire_pulse_duration_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_intense_performer_4') + + actor.removeSkillMod('expertise_en_inspire_pulse_duration_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_lasting_impression_1.py b/scripts/expertise/expertise_en_lasting_impression_1.py new file mode 100644 index 00000000..00d71f54 --- /dev/null +++ b/scripts/expertise/expertise_en_lasting_impression_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_lasting_impression_1') + + actor.addSkillMod('expertise_en_inspire_buff_duration_increase', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_lasting_impression_1') + + actor.removeSkillMod('expertise_en_inspire_buff_duration_increase', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_lasting_impression_2.py b/scripts/expertise/expertise_en_lasting_impression_2.py new file mode 100644 index 00000000..af780c13 --- /dev/null +++ b/scripts/expertise/expertise_en_lasting_impression_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_lasting_impression_2') + + actor.addSkillMod('expertise_en_inspire_buff_duration_increase', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_lasting_impression_2') + + actor.removeSkillMod('expertise_en_inspire_buff_duration_increase', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_lasting_impression_3.py b/scripts/expertise/expertise_en_lasting_impression_3.py new file mode 100644 index 00000000..15e469e6 --- /dev/null +++ b/scripts/expertise/expertise_en_lasting_impression_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_lasting_impression_3') + + actor.addSkillMod('expertise_en_inspire_buff_duration_increase', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_lasting_impression_3') + + actor.removeSkillMod('expertise_en_inspire_buff_duration_increase', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_lasting_impression_4.py b/scripts/expertise/expertise_en_lasting_impression_4.py new file mode 100644 index 00000000..6d5abf56 --- /dev/null +++ b/scripts/expertise/expertise_en_lasting_impression_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_lasting_impression_4') + + actor.addSkillMod('expertise_en_inspire_buff_duration_increase', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_lasting_impression_4') + + actor.removeSkillMod('expertise_en_inspire_buff_duration_increase', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_project_will_1.py b/scripts/expertise/expertise_en_project_will_1.py new file mode 100644 index 00000000..621d018b --- /dev/null +++ b/scripts/expertise/expertise_en_project_will_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_project_will_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_project_will_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('en_project_will_0') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('en_project_will_0') + + return diff --git a/scripts/expertise/expertise_en_rising_spirit_1.py b/scripts/expertise/expertise_en_rising_spirit_1.py new file mode 100644 index 00000000..e6d8c87a --- /dev/null +++ b/scripts/expertise/expertise_en_rising_spirit_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_rising_spirit_1') + + actor.addSkillMod('expertise_undiminished_critical_melee', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_rising_spirit_1') + + actor.removeSkillMod('expertise_undiminished_critical_melee', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_rising_spirit_2.py b/scripts/expertise/expertise_en_rising_spirit_2.py new file mode 100644 index 00000000..9071bce3 --- /dev/null +++ b/scripts/expertise/expertise_en_rising_spirit_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_rising_spirit_2') + + actor.addSkillMod('expertise_undiminished_critical_melee', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_rising_spirit_2') + + actor.removeSkillMod('expertise_undiminished_critical_melee', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_rising_spirit_3.py b/scripts/expertise/expertise_en_rising_spirit_3.py new file mode 100644 index 00000000..80eb4c9d --- /dev/null +++ b/scripts/expertise/expertise_en_rising_spirit_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_rising_spirit_3') + + actor.addSkillMod('expertise_undiminished_critical_melee', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_rising_spirit_3') + + actor.removeSkillMod('expertise_undiminished_critical_melee', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_rising_spirit_4.py b/scripts/expertise/expertise_en_rising_spirit_4.py new file mode 100644 index 00000000..8151c478 --- /dev/null +++ b/scripts/expertise/expertise_en_rising_spirit_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_rising_spirit_4') + + actor.addSkillMod('expertise_undiminished_critical_melee', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_rising_spirit_4') + + actor.removeSkillMod('expertise_undiminished_critical_melee', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_second_chance_1.py b/scripts/expertise/expertise_en_second_chance_1.py new file mode 100644 index 00000000..b8a8fd5b --- /dev/null +++ b/scripts/expertise/expertise_en_second_chance_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_second_chance_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_second_chance_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('en_second_chance_buff_package') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('en_second_chance_buff_package') + + return diff --git a/scripts/expertise/expertise_en_show_stopper_1.py b/scripts/expertise/expertise_en_show_stopper_1.py new file mode 100644 index 00000000..e462f413 --- /dev/null +++ b/scripts/expertise/expertise_en_show_stopper_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_show_stopper_1') + + actor.addSkillMod('expertise_critical_hit_reduction', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_show_stopper_1') + + actor.removeSkillMod('expertise_critical_hit_reduction', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_show_stopper_2.py b/scripts/expertise/expertise_en_show_stopper_2.py new file mode 100644 index 00000000..91828c58 --- /dev/null +++ b/scripts/expertise/expertise_en_show_stopper_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_show_stopper_2') + + actor.addSkillMod('expertise_critical_hit_reduction', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_show_stopper_2') + + actor.removeSkillMod('expertise_critical_hit_reduction', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_show_stopper_3.py b/scripts/expertise/expertise_en_show_stopper_3.py new file mode 100644 index 00000000..ea0d428b --- /dev/null +++ b/scripts/expertise/expertise_en_show_stopper_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_show_stopper_3') + + actor.addSkillMod('expertise_critical_hit_reduction', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_show_stopper_3') + + actor.removeSkillMod('expertise_critical_hit_reduction', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_spiral_kick_1.py b/scripts/expertise/expertise_en_spiral_kick_1.py new file mode 100644 index 00000000..f58c1624 --- /dev/null +++ b/scripts/expertise/expertise_en_spiral_kick_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_spiral_kick_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_spiral_kick_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('en_spiral_kick_0') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('en_spiral_kick_0') + + return diff --git a/scripts/expertise/expertise_en_sprint_1.py b/scripts/expertise/expertise_en_sprint_1.py new file mode 100644 index 00000000..c1c59fec --- /dev/null +++ b/scripts/expertise/expertise_en_sprint_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_sprint_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_sprint_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('en_sprint_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('en_sprint_1') + + return diff --git a/scripts/expertise/expertise_en_stage_presence_1.py b/scripts/expertise/expertise_en_stage_presence_1.py new file mode 100644 index 00000000..03d43717 --- /dev/null +++ b/scripts/expertise/expertise_en_stage_presence_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_stage_presence_1') + + actor.addSkillMod('expertise_dodge', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_stage_presence_1') + + actor.removeSkillMod('expertise_dodge', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_stage_presence_2.py b/scripts/expertise/expertise_en_stage_presence_2.py new file mode 100644 index 00000000..08d9c491 --- /dev/null +++ b/scripts/expertise/expertise_en_stage_presence_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_stage_presence_2') + + actor.addSkillMod('expertise_dodge', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_stage_presence_2') + + actor.removeSkillMod('expertise_dodge', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_stage_presence_3.py b/scripts/expertise/expertise_en_stage_presence_3.py new file mode 100644 index 00000000..6761e10e --- /dev/null +++ b/scripts/expertise/expertise_en_stage_presence_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_stage_presence_3') + + actor.addSkillMod('expertise_dodge', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_stage_presence_3') + + actor.removeSkillMod('expertise_dodge', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_strike_1.py b/scripts/expertise/expertise_en_strike_1.py new file mode 100644 index 00000000..c254bca2 --- /dev/null +++ b/scripts/expertise/expertise_en_strike_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_strike_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_strike_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('en_strike_0') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('en_strike_0') + + return diff --git a/scripts/expertise/expertise_en_sweeping_pirouette_1.py b/scripts/expertise/expertise_en_sweeping_pirouette_1.py new file mode 100644 index 00000000..34fb24f9 --- /dev/null +++ b/scripts/expertise/expertise_en_sweeping_pirouette_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_sweeping_pirouette_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_sweeping_pirouette_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('en_sweeping_pirouette_0') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('en_sweeping_pirouette_0') + + return diff --git a/scripts/expertise/expertise_en_thought_as_action_1.py b/scripts/expertise/expertise_en_thought_as_action_1.py new file mode 100644 index 00000000..773cdea4 --- /dev/null +++ b/scripts/expertise/expertise_en_thought_as_action_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_thought_as_action_1') + + actor.addSkillMod('expertise_innate_protection_all', 250) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_thought_as_action_1') + + actor.removeSkillMod('expertise_innate_protection_all', 250) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_thought_as_action_2.py b/scripts/expertise/expertise_en_thought_as_action_2.py new file mode 100644 index 00000000..a22d2466 --- /dev/null +++ b/scripts/expertise/expertise_en_thought_as_action_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_thought_as_action_2') + + actor.addSkillMod('expertise_innate_protection_all', 250) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_thought_as_action_2') + + actor.removeSkillMod('expertise_innate_protection_all', 250) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_thought_as_action_3.py b/scripts/expertise/expertise_en_thought_as_action_3.py new file mode 100644 index 00000000..3f0d6007 --- /dev/null +++ b/scripts/expertise/expertise_en_thought_as_action_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_thought_as_action_3') + + actor.addSkillMod('expertise_innate_protection_all', 250) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_thought_as_action_3') + + actor.removeSkillMod('expertise_innate_protection_all', 250) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_thought_as_action_4.py b/scripts/expertise/expertise_en_thought_as_action_4.py new file mode 100644 index 00000000..3df60d96 --- /dev/null +++ b/scripts/expertise/expertise_en_thought_as_action_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_thought_as_action_4') + + actor.addSkillMod('expertise_innate_protection_all', 250) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_thought_as_action_4') + + actor.removeSkillMod('expertise_innate_protection_all', 250) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_thrill_1.py b/scripts/expertise/expertise_en_thrill_1.py new file mode 100644 index 00000000..7db5db05 --- /dev/null +++ b/scripts/expertise/expertise_en_thrill_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_thrill_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_thrill_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('en_thrill') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('en_thrill') + + return diff --git a/scripts/expertise/expertise_en_to_the_hilt_1.py b/scripts/expertise/expertise_en_to_the_hilt_1.py new file mode 100644 index 00000000..612021f5 --- /dev/null +++ b/scripts/expertise/expertise_en_to_the_hilt_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_to_the_hilt_1') + + actor.addSkillMod('expertise_buff_duration_line_en_debuff_thrill', 2) + actor.addSkillMod('expertise_en_debuff_thrill_increase', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_to_the_hilt_1') + + actor.removeSkillMod('expertise_buff_duration_line_en_debuff_thrill', 2) + actor.removeSkillMod('expertise_en_debuff_thrill_increase', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_to_the_hilt_2.py b/scripts/expertise/expertise_en_to_the_hilt_2.py new file mode 100644 index 00000000..1e86749d --- /dev/null +++ b/scripts/expertise/expertise_en_to_the_hilt_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_to_the_hilt_2') + + actor.addSkillMod('expertise_buff_duration_line_en_debuff_thrill', 2) + actor.addSkillMod('expertise_en_debuff_thrill_increase', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_to_the_hilt_2') + + actor.removeSkillMod('expertise_buff_duration_line_en_debuff_thrill', 2) + actor.removeSkillMod('expertise_en_debuff_thrill_increase', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_unhealthy_fixation_1.py b/scripts/expertise/expertise_en_unhealthy_fixation_1.py new file mode 100644 index 00000000..9b22e915 --- /dev/null +++ b/scripts/expertise/expertise_en_unhealthy_fixation_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_unhealthy_fixation_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_unhealthy_fixation_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('en_unhealthy_fixation') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('en_unhealthy_fixation') + + return diff --git a/scripts/expertise/expertise_en_uprising_1.py b/scripts/expertise/expertise_en_uprising_1.py new file mode 100644 index 00000000..efe9a7dd --- /dev/null +++ b/scripts/expertise/expertise_en_uprising_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_uprising_1') + + actor.addSkillMod('expertise_critical_line_en_spiral_kick', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_uprising_1') + + actor.removeSkillMod('expertise_critical_line_en_spiral_kick', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_uprising_2.py b/scripts/expertise/expertise_en_uprising_2.py new file mode 100644 index 00000000..d05c6024 --- /dev/null +++ b/scripts/expertise/expertise_en_uprising_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_uprising_2') + + actor.addSkillMod('expertise_critical_line_en_spiral_kick', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_uprising_2') + + actor.removeSkillMod('expertise_critical_line_en_spiral_kick', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_en_void_dance_1.py b/scripts/expertise/expertise_en_void_dance_1.py new file mode 100644 index 00000000..578b08a5 --- /dev/null +++ b/scripts/expertise/expertise_en_void_dance_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.addSkill('expertise_en_void_dance_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'entertainer_1a': + return + + actor.removeSkill('expertise_en_void_dance_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('en_void_dance') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('en_void_dance') + + return diff --git a/scripts/expertise/expertise_engineering_artisan_advanced_theory_1.py b/scripts/expertise/expertise_engineering_artisan_advanced_theory_1.py new file mode 100644 index 00000000..aaf17d68 --- /dev/null +++ b/scripts/expertise/expertise_engineering_artisan_advanced_theory_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_artisan_advanced_theory_1') + + actor.addSkillMod('general_experimentation', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_artisan_advanced_theory_1') + + actor.removeSkillMod('general_experimentation', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_artisan_dexterity_1.py b/scripts/expertise/expertise_engineering_artisan_dexterity_1.py new file mode 100644 index 00000000..1f4d7860 --- /dev/null +++ b/scripts/expertise/expertise_engineering_artisan_dexterity_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_artisan_dexterity_1') + + actor.addSkillMod('general_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_artisan_dexterity_1') + + actor.removeSkillMod('general_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_artisan_dexterity_2.py b/scripts/expertise/expertise_engineering_artisan_dexterity_2.py new file mode 100644 index 00000000..28cff05e --- /dev/null +++ b/scripts/expertise/expertise_engineering_artisan_dexterity_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_artisan_dexterity_2') + + actor.addSkillMod('general_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_artisan_dexterity_2') + + actor.removeSkillMod('general_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_artisan_dexterity_3.py b/scripts/expertise/expertise_engineering_artisan_dexterity_3.py new file mode 100644 index 00000000..11e3b091 --- /dev/null +++ b/scripts/expertise/expertise_engineering_artisan_dexterity_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_artisan_dexterity_3') + + actor.addSkillMod('general_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_artisan_dexterity_3') + + actor.removeSkillMod('general_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_artisan_dexterity_4.py b/scripts/expertise/expertise_engineering_artisan_dexterity_4.py new file mode 100644 index 00000000..ae8bab3f --- /dev/null +++ b/scripts/expertise/expertise_engineering_artisan_dexterity_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_artisan_dexterity_4') + + actor.addSkillMod('general_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_artisan_dexterity_4') + + actor.removeSkillMod('general_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_artisan_hypothesis_1.py b/scripts/expertise/expertise_engineering_artisan_hypothesis_1.py new file mode 100644 index 00000000..eb7b0aa0 --- /dev/null +++ b/scripts/expertise/expertise_engineering_artisan_hypothesis_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_artisan_hypothesis_1') + + actor.addSkillMod('expertise_experimentation_increase_artisan', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_artisan_hypothesis_1') + + actor.removeSkillMod('expertise_experimentation_increase_artisan', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_artisan_hypothesis_2.py b/scripts/expertise/expertise_engineering_artisan_hypothesis_2.py new file mode 100644 index 00000000..14e79abd --- /dev/null +++ b/scripts/expertise/expertise_engineering_artisan_hypothesis_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_artisan_hypothesis_2') + + actor.addSkillMod('expertise_experimentation_increase_artisan', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_artisan_hypothesis_2') + + actor.removeSkillMod('expertise_experimentation_increase_artisan', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_artisan_hypothesis_3.py b/scripts/expertise/expertise_engineering_artisan_hypothesis_3.py new file mode 100644 index 00000000..29b90722 --- /dev/null +++ b/scripts/expertise/expertise_engineering_artisan_hypothesis_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_artisan_hypothesis_3') + + actor.addSkillMod('expertise_experimentation_increase_artisan', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_artisan_hypothesis_3') + + actor.removeSkillMod('expertise_experimentation_increase_artisan', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_artisan_hypothesis_4.py b/scripts/expertise/expertise_engineering_artisan_hypothesis_4.py new file mode 100644 index 00000000..1ffb1f9a --- /dev/null +++ b/scripts/expertise/expertise_engineering_artisan_hypothesis_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_artisan_hypothesis_4') + + actor.addSkillMod('expertise_experimentation_increase_artisan', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_artisan_hypothesis_4') + + actor.removeSkillMod('expertise_experimentation_increase_artisan', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_cybernetic_advanced_theory_1.py b/scripts/expertise/expertise_engineering_cybernetic_advanced_theory_1.py new file mode 100644 index 00000000..2a99c79f --- /dev/null +++ b/scripts/expertise/expertise_engineering_cybernetic_advanced_theory_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_cybernetic_advanced_theory_1') + + actor.addSkillMod('cybernetic_experimentation', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_cybernetic_advanced_theory_1') + + actor.removeSkillMod('cybernetic_experimentation', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_cybernetic_hypothesis_1.py b/scripts/expertise/expertise_engineering_cybernetic_hypothesis_1.py new file mode 100644 index 00000000..a23e203d --- /dev/null +++ b/scripts/expertise/expertise_engineering_cybernetic_hypothesis_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_cybernetic_hypothesis_1') + + actor.addSkillMod('expertise_experimentation_increase_cybernetic', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_cybernetic_hypothesis_1') + + actor.removeSkillMod('expertise_experimentation_increase_cybernetic', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_cybernetic_hypothesis_2.py b/scripts/expertise/expertise_engineering_cybernetic_hypothesis_2.py new file mode 100644 index 00000000..017890cd --- /dev/null +++ b/scripts/expertise/expertise_engineering_cybernetic_hypothesis_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_cybernetic_hypothesis_2') + + actor.addSkillMod('expertise_experimentation_increase_cybernetic', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_cybernetic_hypothesis_2') + + actor.removeSkillMod('expertise_experimentation_increase_cybernetic', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_cybernetic_hypothesis_3.py b/scripts/expertise/expertise_engineering_cybernetic_hypothesis_3.py new file mode 100644 index 00000000..adef4cc9 --- /dev/null +++ b/scripts/expertise/expertise_engineering_cybernetic_hypothesis_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_cybernetic_hypothesis_3') + + actor.addSkillMod('expertise_experimentation_increase_cybernetic', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_cybernetic_hypothesis_3') + + actor.removeSkillMod('expertise_experimentation_increase_cybernetic', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_cybernetic_hypothesis_4.py b/scripts/expertise/expertise_engineering_cybernetic_hypothesis_4.py new file mode 100644 index 00000000..85aab1da --- /dev/null +++ b/scripts/expertise/expertise_engineering_cybernetic_hypothesis_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_cybernetic_hypothesis_4') + + actor.addSkillMod('expertise_experimentation_increase_cybernetic', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_cybernetic_hypothesis_4') + + actor.removeSkillMod('expertise_experimentation_increase_cybernetic', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_cybernetic_negative_effects_reduction_1.py b/scripts/expertise/expertise_engineering_cybernetic_negative_effects_reduction_1.py new file mode 100644 index 00000000..1a6c2b4e --- /dev/null +++ b/scripts/expertise/expertise_engineering_cybernetic_negative_effects_reduction_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_cybernetic_negative_effects_reduction_1') + + actor.addSkillMod('expertise_cybernetic_negative_effects_reduction', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_cybernetic_negative_effects_reduction_1') + + actor.removeSkillMod('expertise_cybernetic_negative_effects_reduction', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_cybernetic_negative_effects_reduction_2.py b/scripts/expertise/expertise_engineering_cybernetic_negative_effects_reduction_2.py new file mode 100644 index 00000000..52dfd22b --- /dev/null +++ b/scripts/expertise/expertise_engineering_cybernetic_negative_effects_reduction_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_cybernetic_negative_effects_reduction_2') + + actor.addSkillMod('expertise_cybernetic_negative_effects_reduction', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_cybernetic_negative_effects_reduction_2') + + actor.removeSkillMod('expertise_cybernetic_negative_effects_reduction', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_cybernetic_negative_effects_reduction_3.py b/scripts/expertise/expertise_engineering_cybernetic_negative_effects_reduction_3.py new file mode 100644 index 00000000..eb2c7532 --- /dev/null +++ b/scripts/expertise/expertise_engineering_cybernetic_negative_effects_reduction_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_cybernetic_negative_effects_reduction_3') + + actor.addSkillMod('expertise_cybernetic_negative_effects_reduction', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_cybernetic_negative_effects_reduction_3') + + actor.removeSkillMod('expertise_cybernetic_negative_effects_reduction', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_cybernetic_negative_effects_reduction_4.py b/scripts/expertise/expertise_engineering_cybernetic_negative_effects_reduction_4.py new file mode 100644 index 00000000..da6d8d56 --- /dev/null +++ b/scripts/expertise/expertise_engineering_cybernetic_negative_effects_reduction_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_cybernetic_negative_effects_reduction_4') + + actor.addSkillMod('expertise_cybernetic_negative_effects_reduction', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_cybernetic_negative_effects_reduction_4') + + actor.removeSkillMod('expertise_cybernetic_negative_effects_reduction', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_cybernetic_s03_schematics_1.py b/scripts/expertise/expertise_engineering_cybernetic_s03_schematics_1.py new file mode 100644 index 00000000..f20459ec --- /dev/null +++ b/scripts/expertise/expertise_engineering_cybernetic_s03_schematics_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_cybernetic_s03_schematics_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_cybernetic_s03_schematics_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_droid_advanced_theory_1.py b/scripts/expertise/expertise_engineering_droid_advanced_theory_1.py new file mode 100644 index 00000000..36c97c2d --- /dev/null +++ b/scripts/expertise/expertise_engineering_droid_advanced_theory_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_droid_advanced_theory_1') + + actor.addSkillMod('droid_experimentation', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_droid_advanced_theory_1') + + actor.removeSkillMod('droid_experimentation', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_droid_dexterity_1.py b/scripts/expertise/expertise_engineering_droid_dexterity_1.py new file mode 100644 index 00000000..4195d6b0 --- /dev/null +++ b/scripts/expertise/expertise_engineering_droid_dexterity_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_droid_dexterity_1') + + actor.addSkillMod('droid_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_droid_dexterity_1') + + actor.removeSkillMod('droid_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_droid_dexterity_2.py b/scripts/expertise/expertise_engineering_droid_dexterity_2.py new file mode 100644 index 00000000..53052f6a --- /dev/null +++ b/scripts/expertise/expertise_engineering_droid_dexterity_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_droid_dexterity_2') + + actor.addSkillMod('droid_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_droid_dexterity_2') + + actor.removeSkillMod('droid_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_droid_dexterity_3.py b/scripts/expertise/expertise_engineering_droid_dexterity_3.py new file mode 100644 index 00000000..438fbf7c --- /dev/null +++ b/scripts/expertise/expertise_engineering_droid_dexterity_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_droid_dexterity_3') + + actor.addSkillMod('droid_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_droid_dexterity_3') + + actor.removeSkillMod('droid_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_droid_dexterity_4.py b/scripts/expertise/expertise_engineering_droid_dexterity_4.py new file mode 100644 index 00000000..6547a684 --- /dev/null +++ b/scripts/expertise/expertise_engineering_droid_dexterity_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_droid_dexterity_4') + + actor.addSkillMod('droid_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_droid_dexterity_4') + + actor.removeSkillMod('droid_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_droid_hypothesis_1.py b/scripts/expertise/expertise_engineering_droid_hypothesis_1.py new file mode 100644 index 00000000..a57e47ed --- /dev/null +++ b/scripts/expertise/expertise_engineering_droid_hypothesis_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_droid_hypothesis_1') + + actor.addSkillMod('expertise_experimentation_increase_droid', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_droid_hypothesis_1') + + actor.removeSkillMod('expertise_experimentation_increase_droid', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_droid_hypothesis_2.py b/scripts/expertise/expertise_engineering_droid_hypothesis_2.py new file mode 100644 index 00000000..4658c156 --- /dev/null +++ b/scripts/expertise/expertise_engineering_droid_hypothesis_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_droid_hypothesis_2') + + actor.addSkillMod('expertise_experimentation_increase_droid', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_droid_hypothesis_2') + + actor.removeSkillMod('expertise_experimentation_increase_droid', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_droid_hypothesis_3.py b/scripts/expertise/expertise_engineering_droid_hypothesis_3.py new file mode 100644 index 00000000..3f8a59a1 --- /dev/null +++ b/scripts/expertise/expertise_engineering_droid_hypothesis_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_droid_hypothesis_3') + + actor.addSkillMod('expertise_experimentation_increase_droid', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_droid_hypothesis_3') + + actor.removeSkillMod('expertise_experimentation_increase_droid', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_droid_hypothesis_4.py b/scripts/expertise/expertise_engineering_droid_hypothesis_4.py new file mode 100644 index 00000000..fc794c58 --- /dev/null +++ b/scripts/expertise/expertise_engineering_droid_hypothesis_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_droid_hypothesis_4') + + actor.addSkillMod('expertise_experimentation_increase_droid', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_droid_hypothesis_4') + + actor.removeSkillMod('expertise_experimentation_increase_droid', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_droid_insight_1.py b/scripts/expertise/expertise_engineering_droid_insight_1.py new file mode 100644 index 00000000..afb13261 --- /dev/null +++ b/scripts/expertise/expertise_engineering_droid_insight_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_droid_insight_1') + + actor.addSkillMod('expertise_complexity_decrease_droid', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_droid_insight_1') + + actor.removeSkillMod('expertise_complexity_decrease_droid', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_droid_insight_2.py b/scripts/expertise/expertise_engineering_droid_insight_2.py new file mode 100644 index 00000000..9a3ccca5 --- /dev/null +++ b/scripts/expertise/expertise_engineering_droid_insight_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_droid_insight_2') + + actor.addSkillMod('expertise_complexity_decrease_droid', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_droid_insight_2') + + actor.removeSkillMod('expertise_complexity_decrease_droid', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_droid_keen_understanding_1.py b/scripts/expertise/expertise_engineering_droid_keen_understanding_1.py new file mode 100644 index 00000000..e47da182 --- /dev/null +++ b/scripts/expertise/expertise_engineering_droid_keen_understanding_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_droid_keen_understanding_1') + + actor.addSkillMod('expertise_complexity_decrease_droid', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_droid_keen_understanding_1') + + actor.removeSkillMod('expertise_complexity_decrease_droid', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_droid_keen_understanding_2.py b/scripts/expertise/expertise_engineering_droid_keen_understanding_2.py new file mode 100644 index 00000000..5cd3dd65 --- /dev/null +++ b/scripts/expertise/expertise_engineering_droid_keen_understanding_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_droid_keen_understanding_2') + + actor.addSkillMod('expertise_complexity_decrease_droid', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_droid_keen_understanding_2') + + actor.removeSkillMod('expertise_complexity_decrease_droid', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_droid_schematic_1_1.py b/scripts/expertise/expertise_engineering_droid_schematic_1_1.py new file mode 100644 index 00000000..6340cdd7 --- /dev/null +++ b/scripts/expertise/expertise_engineering_droid_schematic_1_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_droid_schematic_1_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_droid_schematic_1_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_droid_schematic_2_1.py b/scripts/expertise/expertise_engineering_droid_schematic_2_1.py new file mode 100644 index 00000000..9ade7f61 --- /dev/null +++ b/scripts/expertise/expertise_engineering_droid_schematic_2_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_droid_schematic_2_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_droid_schematic_2_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_resource_processing_1.py b/scripts/expertise/expertise_engineering_resource_processing_1.py new file mode 100644 index 00000000..6c8953a7 --- /dev/null +++ b/scripts/expertise/expertise_engineering_resource_processing_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_resource_processing_1') + + actor.addSkillMod('expertise_resource_quality_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_resource_processing_1') + + actor.removeSkillMod('expertise_resource_quality_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_resource_processing_2.py b/scripts/expertise/expertise_engineering_resource_processing_2.py new file mode 100644 index 00000000..e0d9b8cf --- /dev/null +++ b/scripts/expertise/expertise_engineering_resource_processing_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_resource_processing_2') + + actor.addSkillMod('expertise_resource_quality_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_resource_processing_2') + + actor.removeSkillMod('expertise_resource_quality_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_resource_refinement_1.py b/scripts/expertise/expertise_engineering_resource_refinement_1.py new file mode 100644 index 00000000..635c1e44 --- /dev/null +++ b/scripts/expertise/expertise_engineering_resource_refinement_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_resource_refinement_1') + + actor.addSkillMod('expertise_resource_quality_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_resource_refinement_1') + + actor.removeSkillMod('expertise_resource_quality_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_resource_refinement_2.py b/scripts/expertise/expertise_engineering_resource_refinement_2.py new file mode 100644 index 00000000..0246b71c --- /dev/null +++ b/scripts/expertise/expertise_engineering_resource_refinement_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_resource_refinement_2') + + actor.addSkillMod('expertise_resource_quality_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_resource_refinement_2') + + actor.removeSkillMod('expertise_resource_quality_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_weaponsmith_attachment_upgrade_1.py b/scripts/expertise/expertise_engineering_weaponsmith_attachment_upgrade_1.py new file mode 100644 index 00000000..8f59c85c --- /dev/null +++ b/scripts/expertise/expertise_engineering_weaponsmith_attachment_upgrade_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_weaponsmith_attachment_upgrade_1') + + actor.addSkillMod('expertise_attachment_upgrade', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_weaponsmith_attachment_upgrade_1') + + actor.removeSkillMod('expertise_attachment_upgrade', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_engineering_weaponsmith_socket_bonus_1.py b/scripts/expertise/expertise_engineering_weaponsmith_socket_bonus_1.py new file mode 100644 index 00000000..ea4bbe96 --- /dev/null +++ b/scripts/expertise/expertise_engineering_weaponsmith_socket_bonus_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.addSkill('expertise_engineering_weaponsmith_socket_bonus_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_eng_1a': + return + + actor.removeSkill('expertise_engineering_weaponsmith_socket_bonus_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_alacrity_1.py b/scripts/expertise/expertise_fs_general_alacrity_1.py new file mode 100644 index 00000000..e7bc1b47 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_alacrity_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_alacrity_1') + + actor.addSkillMod('expertise_glancing_blow_all', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_alacrity_1') + + actor.removeSkillMod('expertise_glancing_blow_all', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_alacrity_2.py b/scripts/expertise/expertise_fs_general_alacrity_2.py new file mode 100644 index 00000000..5c64bc75 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_alacrity_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_alacrity_2') + + actor.addSkillMod('expertise_glancing_blow_all', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_alacrity_2') + + actor.removeSkillMod('expertise_glancing_blow_all', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_alacrity_3.py b/scripts/expertise/expertise_fs_general_alacrity_3.py new file mode 100644 index 00000000..5f903c17 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_alacrity_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_alacrity_3') + + actor.addSkillMod('expertise_glancing_blow_all', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_alacrity_3') + + actor.removeSkillMod('expertise_glancing_blow_all', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_alacrity_4.py b/scripts/expertise/expertise_fs_general_alacrity_4.py new file mode 100644 index 00000000..6a9bd9fa --- /dev/null +++ b/scripts/expertise/expertise_fs_general_alacrity_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_alacrity_4') + + actor.addSkillMod('expertise_glancing_blow_all', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_alacrity_4') + + actor.removeSkillMod('expertise_glancing_blow_all', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_exacting_strikes_1.py b/scripts/expertise/expertise_fs_general_exacting_strikes_1.py new file mode 100644 index 00000000..2236311e --- /dev/null +++ b/scripts/expertise/expertise_fs_general_exacting_strikes_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_exacting_strikes_1') + + actor.addSkillMod('expertise_damage_line_fs_sweep', 2) + actor.addSkillMod('expertise_damage_line_fs_dm', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_exacting_strikes_1') + + actor.removeSkillMod('expertise_damage_line_fs_sweep', 2) + actor.removeSkillMod('expertise_damage_line_fs_dm', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_exacting_strikes_2.py b/scripts/expertise/expertise_fs_general_exacting_strikes_2.py new file mode 100644 index 00000000..2b4161b2 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_exacting_strikes_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_exacting_strikes_2') + + actor.addSkillMod('expertise_damage_line_fs_sweep', 2) + actor.addSkillMod('expertise_damage_line_fs_dm', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_exacting_strikes_2') + + actor.removeSkillMod('expertise_damage_line_fs_sweep', 2) + actor.removeSkillMod('expertise_damage_line_fs_dm', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_exacting_strikes_3.py b/scripts/expertise/expertise_fs_general_exacting_strikes_3.py new file mode 100644 index 00000000..cc542875 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_exacting_strikes_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_exacting_strikes_3') + + actor.addSkillMod('expertise_damage_line_fs_sweep', 2) + actor.addSkillMod('expertise_damage_line_fs_dm', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_exacting_strikes_3') + + actor.removeSkillMod('expertise_damage_line_fs_sweep', 2) + actor.removeSkillMod('expertise_damage_line_fs_dm', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_exacting_strikes_4.py b/scripts/expertise/expertise_fs_general_exacting_strikes_4.py new file mode 100644 index 00000000..448389c0 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_exacting_strikes_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_exacting_strikes_4') + + actor.addSkillMod('expertise_damage_line_fs_sweep', 2) + actor.addSkillMod('expertise_damage_line_fs_dm', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_exacting_strikes_4') + + actor.removeSkillMod('expertise_damage_line_fs_sweep', 2) + actor.removeSkillMod('expertise_damage_line_fs_dm', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_fidelity_1.py b/scripts/expertise/expertise_fs_general_fidelity_1.py new file mode 100644 index 00000000..e16b3a39 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_fidelity_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_fidelity_1') + + actor.addSkillMod('expertise_damage_melee', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_fidelity_1') + + actor.removeSkillMod('expertise_damage_melee', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_fidelity_2.py b/scripts/expertise/expertise_fs_general_fidelity_2.py new file mode 100644 index 00000000..b529242d --- /dev/null +++ b/scripts/expertise/expertise_fs_general_fidelity_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_fidelity_2') + + actor.addSkillMod('expertise_damage_melee', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_fidelity_2') + + actor.removeSkillMod('expertise_damage_melee', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_force_cloak_1.py b/scripts/expertise/expertise_fs_general_force_cloak_1.py new file mode 100644 index 00000000..fd748f6d --- /dev/null +++ b/scripts/expertise/expertise_fs_general_force_cloak_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_force_cloak_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_force_cloak_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('fs_buff_invis_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('fs_buff_invis_1') + + return diff --git a/scripts/expertise/expertise_fs_general_force_shockwave_1.py b/scripts/expertise/expertise_fs_general_force_shockwave_1.py new file mode 100644 index 00000000..05f5873a --- /dev/null +++ b/scripts/expertise/expertise_fs_general_force_shockwave_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_force_shockwave_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_force_shockwave_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('fs_dm_cc_crit_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('fs_dm_cc_crit_1') + + return diff --git a/scripts/expertise/expertise_fs_general_grace_in_motion_1.py b/scripts/expertise/expertise_fs_general_grace_in_motion_1.py new file mode 100644 index 00000000..e2207030 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_grace_in_motion_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_grace_in_motion_1') + + actor.addSkillMod('expertise_action_lightsaber', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_grace_in_motion_1') + + actor.removeSkillMod('expertise_action_lightsaber', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_grace_in_motion_2.py b/scripts/expertise/expertise_fs_general_grace_in_motion_2.py new file mode 100644 index 00000000..9b520c39 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_grace_in_motion_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_grace_in_motion_2') + + actor.addSkillMod('expertise_action_lightsaber', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_grace_in_motion_2') + + actor.removeSkillMod('expertise_action_lightsaber', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_grace_in_motion_3.py b/scripts/expertise/expertise_fs_general_grace_in_motion_3.py new file mode 100644 index 00000000..acedaa7a --- /dev/null +++ b/scripts/expertise/expertise_fs_general_grace_in_motion_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_grace_in_motion_3') + + actor.addSkillMod('expertise_action_lightsaber', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_grace_in_motion_3') + + actor.removeSkillMod('expertise_action_lightsaber', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_heightened_speed_1.py b/scripts/expertise/expertise_fs_general_heightened_speed_1.py new file mode 100644 index 00000000..1f410c98 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_heightened_speed_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_heightened_speed_1') + + actor.addSkillMod('expertise_movement_buff_fs_force_run', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_heightened_speed_1') + + actor.removeSkillMod('expertise_movement_buff_fs_force_run', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_heightened_speed_2.py b/scripts/expertise/expertise_fs_general_heightened_speed_2.py new file mode 100644 index 00000000..7aed8948 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_heightened_speed_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_heightened_speed_2') + + actor.addSkillMod('expertise_movement_buff_fs_force_run', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_heightened_speed_2') + + actor.removeSkillMod('expertise_movement_buff_fs_force_run', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_heightened_speed_3.py b/scripts/expertise/expertise_fs_general_heightened_speed_3.py new file mode 100644 index 00000000..847e3c06 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_heightened_speed_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_heightened_speed_3') + + actor.addSkillMod('expertise_movement_buff_fs_force_run', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_heightened_speed_3') + + actor.removeSkillMod('expertise_movement_buff_fs_force_run', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_heightened_speed_4.py b/scripts/expertise/expertise_fs_general_heightened_speed_4.py new file mode 100644 index 00000000..878c1750 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_heightened_speed_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_heightened_speed_4') + + actor.addSkillMod('expertise_movement_buff_fs_force_run', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_heightened_speed_4') + + actor.removeSkillMod('expertise_movement_buff_fs_force_run', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_improved_crippling_accuracy_1.py b/scripts/expertise/expertise_fs_general_improved_crippling_accuracy_1.py new file mode 100644 index 00000000..7339e6cf --- /dev/null +++ b/scripts/expertise/expertise_fs_general_improved_crippling_accuracy_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_improved_crippling_accuracy_1') + + actor.addSkillMod('expertise_buff_duration_line_fs_force_throw', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_improved_crippling_accuracy_1') + + actor.removeSkillMod('expertise_buff_duration_line_fs_force_throw', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_improved_crippling_accuracy_2.py b/scripts/expertise/expertise_fs_general_improved_crippling_accuracy_2.py new file mode 100644 index 00000000..1535e2c6 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_improved_crippling_accuracy_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_improved_crippling_accuracy_2') + + actor.addSkillMod('expertise_buff_duration_line_fs_force_throw', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_improved_crippling_accuracy_2') + + actor.removeSkillMod('expertise_buff_duration_line_fs_force_throw', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_improved_crippling_accuracy_3.py b/scripts/expertise/expertise_fs_general_improved_crippling_accuracy_3.py new file mode 100644 index 00000000..fb5ffa62 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_improved_crippling_accuracy_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_improved_crippling_accuracy_3') + + actor.addSkillMod('expertise_buff_duration_line_fs_force_throw', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_improved_crippling_accuracy_3') + + actor.removeSkillMod('expertise_buff_duration_line_fs_force_throw', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_improved_force_cloak_1.py b/scripts/expertise/expertise_fs_general_improved_force_cloak_1.py new file mode 100644 index 00000000..29eb5f11 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_improved_force_cloak_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_improved_force_cloak_1') + + actor.addSkillMod('expertise_force_cloak_combat_escape', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_improved_force_cloak_1') + + actor.removeSkillMod('expertise_force_cloak_combat_escape', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_improved_force_shockwave_1.py b/scripts/expertise/expertise_fs_general_improved_force_shockwave_1.py new file mode 100644 index 00000000..9eab98c3 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_improved_force_shockwave_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_improved_force_shockwave_1') + + actor.addSkillMod('expertise_damage_line_fs_cc_crit', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_improved_force_shockwave_1') + + actor.removeSkillMod('expertise_damage_line_fs_cc_crit', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_improved_force_shockwave_2.py b/scripts/expertise/expertise_fs_general_improved_force_shockwave_2.py new file mode 100644 index 00000000..f51b5f9e --- /dev/null +++ b/scripts/expertise/expertise_fs_general_improved_force_shockwave_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_improved_force_shockwave_2') + + actor.addSkillMod('expertise_damage_line_fs_cc_crit', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_improved_force_shockwave_2') + + actor.removeSkillMod('expertise_damage_line_fs_cc_crit', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_improved_force_shockwave_3.py b/scripts/expertise/expertise_fs_general_improved_force_shockwave_3.py new file mode 100644 index 00000000..85d26f98 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_improved_force_shockwave_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_improved_force_shockwave_3') + + actor.addSkillMod('expertise_damage_line_fs_cc_crit', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_improved_force_shockwave_3') + + actor.removeSkillMod('expertise_damage_line_fs_cc_crit', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_improved_force_throw_1.py b/scripts/expertise/expertise_fs_general_improved_force_throw_1.py new file mode 100644 index 00000000..982a4921 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_improved_force_throw_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_improved_force_throw_1') + + actor.addSkillMod('expertise_damage_line_fs_force_throw', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_improved_force_throw_1') + + actor.removeSkillMod('expertise_damage_line_fs_force_throw', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_improved_force_throw_2.py b/scripts/expertise/expertise_fs_general_improved_force_throw_2.py new file mode 100644 index 00000000..303292ef --- /dev/null +++ b/scripts/expertise/expertise_fs_general_improved_force_throw_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_improved_force_throw_2') + + actor.addSkillMod('expertise_damage_line_fs_force_throw', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_improved_force_throw_2') + + actor.removeSkillMod('expertise_damage_line_fs_force_throw', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_improved_saber_block_1.py b/scripts/expertise/expertise_fs_general_improved_saber_block_1.py new file mode 100644 index 00000000..25d545c9 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_improved_saber_block_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_improved_saber_block_1') + + actor.addSkillMod('expertise_saber_block', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_improved_saber_block_1') + + actor.removeSkillMod('expertise_saber_block', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_improved_saber_block_2.py b/scripts/expertise/expertise_fs_general_improved_saber_block_2.py new file mode 100644 index 00000000..066a2128 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_improved_saber_block_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_improved_saber_block_2') + + actor.addSkillMod('expertise_saber_block', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_improved_saber_block_2') + + actor.removeSkillMod('expertise_saber_block', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_improved_saber_block_3.py b/scripts/expertise/expertise_fs_general_improved_saber_block_3.py new file mode 100644 index 00000000..75e6e32b --- /dev/null +++ b/scripts/expertise/expertise_fs_general_improved_saber_block_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_improved_saber_block_3') + + actor.addSkillMod('expertise_saber_block', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_improved_saber_block_3') + + actor.removeSkillMod('expertise_saber_block', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_incisiveness_1.py b/scripts/expertise/expertise_fs_general_incisiveness_1.py new file mode 100644 index 00000000..78afb069 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_incisiveness_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_incisiveness_1') + + actor.addSkillMod('expertise_critical_niche_all', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_incisiveness_1') + + actor.removeSkillMod('expertise_critical_niche_all', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_incisiveness_2.py b/scripts/expertise/expertise_fs_general_incisiveness_2.py new file mode 100644 index 00000000..05f9afbf --- /dev/null +++ b/scripts/expertise/expertise_fs_general_incisiveness_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_incisiveness_2') + + actor.addSkillMod('expertise_critical_niche_all', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_incisiveness_2') + + actor.removeSkillMod('expertise_critical_niche_all', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_incisiveness_3.py b/scripts/expertise/expertise_fs_general_incisiveness_3.py new file mode 100644 index 00000000..8ee564ee --- /dev/null +++ b/scripts/expertise/expertise_fs_general_incisiveness_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_incisiveness_3') + + actor.addSkillMod('expertise_critical_niche_all', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_incisiveness_3') + + actor.removeSkillMod('expertise_critical_niche_all', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_premonition_1.py b/scripts/expertise/expertise_fs_general_premonition_1.py new file mode 100644 index 00000000..1d1ae63c --- /dev/null +++ b/scripts/expertise/expertise_fs_general_premonition_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_premonition_1') + + actor.addSkillMod('expertise_evasion_chance', 2) + actor.addSkillMod('expertise_evasion_value', 8) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_premonition_1') + + actor.removeSkillMod('expertise_evasion_chance', 2) + actor.removeSkillMod('expertise_evasion_value', 8) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_premonition_2.py b/scripts/expertise/expertise_fs_general_premonition_2.py new file mode 100644 index 00000000..28578c27 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_premonition_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_premonition_2') + + actor.addSkillMod('expertise_evasion_chance', 2) + actor.addSkillMod('expertise_evasion_value', 8) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_premonition_2') + + actor.removeSkillMod('expertise_evasion_chance', 2) + actor.removeSkillMod('expertise_evasion_value', 8) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_premonition_3.py b/scripts/expertise/expertise_fs_general_premonition_3.py new file mode 100644 index 00000000..ac4aac07 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_premonition_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_premonition_3') + + actor.addSkillMod('expertise_evasion_chance', 2) + actor.addSkillMod('expertise_evasion_value', 8) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_premonition_3') + + actor.removeSkillMod('expertise_evasion_chance', 2) + actor.removeSkillMod('expertise_evasion_value', 8) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_premonition_4.py b/scripts/expertise/expertise_fs_general_premonition_4.py new file mode 100644 index 00000000..21b22f54 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_premonition_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_premonition_4') + + actor.addSkillMod('expertise_evasion_chance', 2) + actor.addSkillMod('expertise_evasion_value', 8) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_premonition_4') + + actor.removeSkillMod('expertise_evasion_chance', 2) + actor.removeSkillMod('expertise_evasion_value', 8) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_second_wind_1.py b/scripts/expertise/expertise_fs_general_second_wind_1.py new file mode 100644 index 00000000..e2bf66c3 --- /dev/null +++ b/scripts/expertise/expertise_fs_general_second_wind_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_second_wind_1') + + actor.addSkillMod('expertise_buff_duration_line_fs_force_run', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_second_wind_1') + + actor.removeSkillMod('expertise_buff_duration_line_fs_force_run', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_second_wind_2.py b/scripts/expertise/expertise_fs_general_second_wind_2.py new file mode 100644 index 00000000..ed634e1a --- /dev/null +++ b/scripts/expertise/expertise_fs_general_second_wind_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_second_wind_2') + + actor.addSkillMod('expertise_buff_duration_line_fs_force_run', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_second_wind_2') + + actor.removeSkillMod('expertise_buff_duration_line_fs_force_run', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_general_stance_saber_block_1.py b/scripts/expertise/expertise_fs_general_stance_saber_block_1.py new file mode 100644 index 00000000..8abdcf0c --- /dev/null +++ b/scripts/expertise/expertise_fs_general_stance_saber_block_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_general_stance_saber_block_1') + + actor.addSkillMod('expertise_stance_saber_block', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_general_stance_saber_block_1') + + actor.removeSkillMod('expertise_stance_saber_block', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_anticipate_aggression_1.py b/scripts/expertise/expertise_fs_path_anticipate_aggression_1.py new file mode 100644 index 00000000..ab29d84c --- /dev/null +++ b/scripts/expertise/expertise_fs_path_anticipate_aggression_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_anticipate_aggression_1') + + actor.addSkillMod('expertise_stance_anticipate_aggression', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_anticipate_aggression_1') + + actor.removeSkillMod('expertise_stance_anticipate_aggression', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_anticipate_aggression_2.py b/scripts/expertise/expertise_fs_path_anticipate_aggression_2.py new file mode 100644 index 00000000..89805eca --- /dev/null +++ b/scripts/expertise/expertise_fs_path_anticipate_aggression_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_anticipate_aggression_2') + + actor.addSkillMod('expertise_stance_anticipate_aggression', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_anticipate_aggression_2') + + actor.removeSkillMod('expertise_stance_anticipate_aggression', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_brutality_1.py b/scripts/expertise/expertise_fs_path_brutality_1.py new file mode 100644 index 00000000..68602970 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_brutality_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_brutality_1') + + actor.addSkillMod('expertise_focus_critical_buff_line', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_brutality_1') + + actor.removeSkillMod('expertise_focus_critical_buff_line', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_brutality_2.py b/scripts/expertise/expertise_fs_path_brutality_2.py new file mode 100644 index 00000000..f93f423b --- /dev/null +++ b/scripts/expertise/expertise_fs_path_brutality_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_brutality_2') + + actor.addSkillMod('expertise_focus_critical_buff_line', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_brutality_2') + + actor.removeSkillMod('expertise_focus_critical_buff_line', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_brutality_3.py b/scripts/expertise/expertise_fs_path_brutality_3.py new file mode 100644 index 00000000..389093f0 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_brutality_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_brutality_3') + + actor.addSkillMod('expertise_focus_critical_buff_line', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_brutality_3') + + actor.removeSkillMod('expertise_focus_critical_buff_line', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_brutality_4.py b/scripts/expertise/expertise_fs_path_brutality_4.py new file mode 100644 index 00000000..9e40e1e4 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_brutality_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_brutality_4') + + actor.addSkillMod('expertise_focus_critical_buff_line', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_brutality_4') + + actor.removeSkillMod('expertise_focus_critical_buff_line', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_cautious_nature_1.py b/scripts/expertise/expertise_fs_path_cautious_nature_1.py new file mode 100644 index 00000000..006f4c2c --- /dev/null +++ b/scripts/expertise/expertise_fs_path_cautious_nature_1.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_cautious_nature_1') + + actor.addSkillMod('expertise_stance_constitution', 10) + actor.addSkillMod('expertise_stance_parry', 1) + actor.addSkillMod('expertise_stance_evasion', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_cautious_nature_1') + + actor.removeSkillMod('expertise_stance_constitution', 10) + actor.removeSkillMod('expertise_stance_parry', 1) + actor.removeSkillMod('expertise_stance_evasion', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_cautious_nature_2.py b/scripts/expertise/expertise_fs_path_cautious_nature_2.py new file mode 100644 index 00000000..e2abb040 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_cautious_nature_2.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_cautious_nature_2') + + actor.addSkillMod('expertise_stance_constitution', 10) + actor.addSkillMod('expertise_stance_parry', 1) + actor.addSkillMod('expertise_stance_evasion', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_cautious_nature_2') + + actor.removeSkillMod('expertise_stance_constitution', 10) + actor.removeSkillMod('expertise_stance_parry', 1) + actor.removeSkillMod('expertise_stance_evasion', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_cautious_nature_3.py b/scripts/expertise/expertise_fs_path_cautious_nature_3.py new file mode 100644 index 00000000..7255557a --- /dev/null +++ b/scripts/expertise/expertise_fs_path_cautious_nature_3.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_cautious_nature_3') + + actor.addSkillMod('expertise_stance_constitution', 10) + actor.addSkillMod('expertise_stance_parry', 1) + actor.addSkillMod('expertise_stance_evasion', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_cautious_nature_3') + + actor.removeSkillMod('expertise_stance_constitution', 10) + actor.removeSkillMod('expertise_stance_parry', 1) + actor.removeSkillMod('expertise_stance_evasion', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_cautious_nature_4.py b/scripts/expertise/expertise_fs_path_cautious_nature_4.py new file mode 100644 index 00000000..5c7b4e62 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_cautious_nature_4.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_cautious_nature_4') + + actor.addSkillMod('expertise_stance_constitution', 10) + actor.addSkillMod('expertise_stance_parry', 1) + actor.addSkillMod('expertise_stance_evasion', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_cautious_nature_4') + + actor.removeSkillMod('expertise_stance_constitution', 10) + actor.removeSkillMod('expertise_stance_parry', 1) + actor.removeSkillMod('expertise_stance_evasion', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_cloud_minds_1.py b/scripts/expertise/expertise_fs_path_cloud_minds_1.py new file mode 100644 index 00000000..6fa583aa --- /dev/null +++ b/scripts/expertise/expertise_fs_path_cloud_minds_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_cloud_minds_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_cloud_minds_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('fs_mind_trick_2') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('fs_mind_trick_2') + + return diff --git a/scripts/expertise/expertise_fs_path_dark_lightning_1.py b/scripts/expertise/expertise_fs_path_dark_lightning_1.py new file mode 100644 index 00000000..6bea7d3e --- /dev/null +++ b/scripts/expertise/expertise_fs_path_dark_lightning_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_dark_lightning_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_dark_lightning_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('fs_ae_dm_cc_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('fs_ae_dm_cc_1') + + return diff --git a/scripts/expertise/expertise_fs_path_expansive_trickery_1.py b/scripts/expertise/expertise_fs_path_expansive_trickery_1.py new file mode 100644 index 00000000..4e48ff9c --- /dev/null +++ b/scripts/expertise/expertise_fs_path_expansive_trickery_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_expansive_trickery_1') + + actor.addSkillMod('expertise_area_size_single_fs_mind_trick_2', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_expansive_trickery_1') + + actor.removeSkillMod('expertise_area_size_single_fs_mind_trick_2', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_flurry.py b/scripts/expertise/expertise_fs_path_flurry.py new file mode 100644 index 00000000..0c9dbb88 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_flurry.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_flurry') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_flurry') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('fs_flurry_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('fs_flurry_1') + + return diff --git a/scripts/expertise/expertise_fs_path_force_choke_1.py b/scripts/expertise/expertise_fs_path_force_choke_1.py new file mode 100644 index 00000000..b38da3a8 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_force_choke_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_force_choke_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_force_choke_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('fs_dm_cc_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('fs_dm_cc_1') + + return diff --git a/scripts/expertise/expertise_fs_path_force_clarity_1.py b/scripts/expertise/expertise_fs_path_force_clarity_1.py new file mode 100644 index 00000000..651153f9 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_force_clarity_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_force_clarity_1') + + actor.addSkillMod('expertise_stance_fs_force_clarity', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_force_clarity_1') + + actor.removeSkillMod('expertise_stance_fs_force_clarity', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_force_drain_1.py b/scripts/expertise/expertise_fs_path_force_drain_1.py new file mode 100644 index 00000000..e8c5fee3 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_force_drain_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_force_drain_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_force_drain_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('fs_drain_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('fs_drain_1') + + return diff --git a/scripts/expertise/expertise_fs_path_forsake_fear_1.py b/scripts/expertise/expertise_fs_path_forsake_fear_1.py new file mode 100644 index 00000000..6ef13e11 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_forsake_fear_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_forsake_fear_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_forsake_fear_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('fs_forsake_fear') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('fs_forsake_fear') + + return diff --git a/scripts/expertise/expertise_fs_path_hermetic_touch_1.py b/scripts/expertise/expertise_fs_path_hermetic_touch_1.py new file mode 100644 index 00000000..8361fe7d --- /dev/null +++ b/scripts/expertise/expertise_fs_path_hermetic_touch_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_hermetic_touch_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_hermetic_touch_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('fs_hermetic_touch') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('fs_hermetic_touch') + + return diff --git a/scripts/expertise/expertise_fs_path_improved_force_choke_1.py b/scripts/expertise/expertise_fs_path_improved_force_choke_1.py new file mode 100644 index 00000000..e01d7586 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_improved_force_choke_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_improved_force_choke_1') + + actor.addSkillMod('expertise_damage_line_fs_dm_cc', 10) + actor.addSkillMod('expertise_dot_damage_line_fs_dm_cc', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_improved_force_choke_1') + + actor.removeSkillMod('expertise_damage_line_fs_dm_cc', 10) + actor.removeSkillMod('expertise_dot_damage_line_fs_dm_cc', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_improved_force_choke_2.py b/scripts/expertise/expertise_fs_path_improved_force_choke_2.py new file mode 100644 index 00000000..53971b85 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_improved_force_choke_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_improved_force_choke_2') + + actor.addSkillMod('expertise_damage_line_fs_dm_cc', 10) + actor.addSkillMod('expertise_dot_damage_line_fs_dm_cc', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_improved_force_choke_2') + + actor.removeSkillMod('expertise_damage_line_fs_dm_cc', 10) + actor.removeSkillMod('expertise_dot_damage_line_fs_dm_cc', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_improved_force_drain_1.py b/scripts/expertise/expertise_fs_path_improved_force_drain_1.py new file mode 100644 index 00000000..2665853a --- /dev/null +++ b/scripts/expertise/expertise_fs_path_improved_force_drain_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_improved_force_drain_1') + + actor.addSkillMod('expertise_fs_imp_drain', 33) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_improved_force_drain_1') + + actor.removeSkillMod('expertise_fs_imp_drain', 33) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_improved_force_drain_2.py b/scripts/expertise/expertise_fs_path_improved_force_drain_2.py new file mode 100644 index 00000000..61d92bb5 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_improved_force_drain_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_improved_force_drain_2') + + actor.addSkillMod('expertise_fs_imp_drain', 33) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_improved_force_drain_2') + + actor.removeSkillMod('expertise_fs_imp_drain', 33) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_improved_force_drain_3.py b/scripts/expertise/expertise_fs_path_improved_force_drain_3.py new file mode 100644 index 00000000..4ecb65bf --- /dev/null +++ b/scripts/expertise/expertise_fs_path_improved_force_drain_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_improved_force_drain_3') + + actor.addSkillMod('expertise_fs_imp_drain', 34) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_improved_force_drain_3') + + actor.removeSkillMod('expertise_fs_imp_drain', 34) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_improved_saber_reflect_1.py b/scripts/expertise/expertise_fs_path_improved_saber_reflect_1.py new file mode 100644 index 00000000..f68eb3ae --- /dev/null +++ b/scripts/expertise/expertise_fs_path_improved_saber_reflect_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_improved_saber_reflect_1') + + actor.addSkillMod('expertise_damage_line_fs_saber_reflect', 50) + actor.addSkillMod('expertise_force_alacrity', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_improved_saber_reflect_1') + + actor.removeSkillMod('expertise_damage_line_fs_saber_reflect', 50) + actor.removeSkillMod('expertise_force_alacrity', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_improved_saber_reflect_2.py b/scripts/expertise/expertise_fs_path_improved_saber_reflect_2.py new file mode 100644 index 00000000..6d95b6e7 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_improved_saber_reflect_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_improved_saber_reflect_2') + + actor.addSkillMod('expertise_damage_line_fs_saber_reflect', 50) + actor.addSkillMod('expertise_force_alacrity', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_improved_saber_reflect_2') + + actor.removeSkillMod('expertise_damage_line_fs_saber_reflect', 50) + actor.removeSkillMod('expertise_force_alacrity', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_lethargy_1.py b/scripts/expertise/expertise_fs_path_lethargy_1.py new file mode 100644 index 00000000..7039b6d8 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_lethargy_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_lethargy_1') + + actor.addSkillMod('expertise_buff_duration_line_fs_mind_trick', 2) + actor.addSkillMod('expertise_action_damage_line_fs_mind_trick', 250) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_lethargy_1') + + actor.removeSkillMod('expertise_buff_duration_line_fs_mind_trick', 2) + actor.removeSkillMod('expertise_action_damage_line_fs_mind_trick', 250) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_lethargy_2.py b/scripts/expertise/expertise_fs_path_lethargy_2.py new file mode 100644 index 00000000..6b294600 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_lethargy_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_lethargy_2') + + actor.addSkillMod('expertise_buff_duration_line_fs_mind_trick', 2) + actor.addSkillMod('expertise_action_damage_line_fs_mind_trick', 250) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_lethargy_2') + + actor.removeSkillMod('expertise_buff_duration_line_fs_mind_trick', 2) + actor.removeSkillMod('expertise_action_damage_line_fs_mind_trick', 250) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_lethargy_3.py b/scripts/expertise/expertise_fs_path_lethargy_3.py new file mode 100644 index 00000000..9966bbad --- /dev/null +++ b/scripts/expertise/expertise_fs_path_lethargy_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_lethargy_3') + + actor.addSkillMod('expertise_buff_duration_line_fs_mind_trick', 2) + actor.addSkillMod('expertise_action_damage_line_fs_mind_trick', 250) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_lethargy_3') + + actor.removeSkillMod('expertise_buff_duration_line_fs_mind_trick', 2) + actor.removeSkillMod('expertise_action_damage_line_fs_mind_trick', 250) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_lethargy_4.py b/scripts/expertise/expertise_fs_path_lethargy_4.py new file mode 100644 index 00000000..ca3b2e10 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_lethargy_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_lethargy_4') + + actor.addSkillMod('expertise_buff_duration_line_fs_mind_trick', 2) + actor.addSkillMod('expertise_action_damage_line_fs_mind_trick', 250) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_lethargy_4') + + actor.removeSkillMod('expertise_buff_duration_line_fs_mind_trick', 2) + actor.removeSkillMod('expertise_action_damage_line_fs_mind_trick', 250) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_maelstrom_1.py b/scripts/expertise/expertise_fs_path_maelstrom_1.py new file mode 100644 index 00000000..39b07550 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_maelstrom_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_maelstrom_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_maelstrom_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('fs_maelstrom_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('fs_maelstrom_1') + + return diff --git a/scripts/expertise/expertise_fs_path_perceptive_sentinel_1.py b/scripts/expertise/expertise_fs_path_perceptive_sentinel_1.py new file mode 100644 index 00000000..3803bf98 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_perceptive_sentinel_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_perceptive_sentinel_1') + + actor.addSkillMod('expertise_stance_perceptive_sentinel', 1) + actor.addSkillMod('expertise_stance_perceptive_sentinel_pvp', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_perceptive_sentinel_1') + + actor.removeSkillMod('expertise_stance_perceptive_sentinel', 1) + actor.removeSkillMod('expertise_stance_perceptive_sentinel_pvp', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_perceptive_sentinel_2.py b/scripts/expertise/expertise_fs_path_perceptive_sentinel_2.py new file mode 100644 index 00000000..e8944848 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_perceptive_sentinel_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_perceptive_sentinel_2') + + actor.addSkillMod('expertise_stance_perceptive_sentinel', 1) + actor.addSkillMod('expertise_stance_perceptive_sentinel_pvp', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_perceptive_sentinel_2') + + actor.removeSkillMod('expertise_stance_perceptive_sentinel', 1) + actor.removeSkillMod('expertise_stance_perceptive_sentinel_pvp', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_perceptive_sentinel_3.py b/scripts/expertise/expertise_fs_path_perceptive_sentinel_3.py new file mode 100644 index 00000000..a4bd42b0 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_perceptive_sentinel_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_perceptive_sentinel_3') + + actor.addSkillMod('expertise_stance_perceptive_sentinel', 1) + actor.addSkillMod('expertise_stance_perceptive_sentinel_pvp', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_perceptive_sentinel_3') + + actor.removeSkillMod('expertise_stance_perceptive_sentinel', 1) + actor.removeSkillMod('expertise_stance_perceptive_sentinel_pvp', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_perceptive_sentinel_4.py b/scripts/expertise/expertise_fs_path_perceptive_sentinel_4.py new file mode 100644 index 00000000..f3a94bb6 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_perceptive_sentinel_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_perceptive_sentinel_4') + + actor.addSkillMod('expertise_stance_perceptive_sentinel', 1) + actor.addSkillMod('expertise_stance_perceptive_sentinel_pvp', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_perceptive_sentinel_4') + + actor.removeSkillMod('expertise_stance_perceptive_sentinel', 1) + actor.removeSkillMod('expertise_stance_perceptive_sentinel_pvp', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_reactive_response_1.py b/scripts/expertise/expertise_fs_path_reactive_response_1.py new file mode 100644 index 00000000..7742793f --- /dev/null +++ b/scripts/expertise/expertise_fs_path_reactive_response_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_reactive_response_1') + + actor.addSkillMod('expertise_stance_damage_add_to_action', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_reactive_response_1') + + actor.removeSkillMod('expertise_stance_damage_add_to_action', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_reactive_response_2.py b/scripts/expertise/expertise_fs_path_reactive_response_2.py new file mode 100644 index 00000000..a46db04e --- /dev/null +++ b/scripts/expertise/expertise_fs_path_reactive_response_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_reactive_response_2') + + actor.addSkillMod('expertise_stance_damage_add_to_action', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_reactive_response_2') + + actor.removeSkillMod('expertise_stance_damage_add_to_action', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_remorseless_nature_1.py b/scripts/expertise/expertise_fs_path_remorseless_nature_1.py new file mode 100644 index 00000000..a155f97c --- /dev/null +++ b/scripts/expertise/expertise_fs_path_remorseless_nature_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_remorseless_nature_1') + + actor.addSkillMod('expertise_focus_stamina', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_remorseless_nature_1') + + actor.removeSkillMod('expertise_focus_stamina', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_remorseless_nature_2.py b/scripts/expertise/expertise_fs_path_remorseless_nature_2.py new file mode 100644 index 00000000..28db8826 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_remorseless_nature_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_remorseless_nature_2') + + actor.addSkillMod('expertise_focus_stamina', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_remorseless_nature_2') + + actor.removeSkillMod('expertise_focus_stamina', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_remorseless_nature_3.py b/scripts/expertise/expertise_fs_path_remorseless_nature_3.py new file mode 100644 index 00000000..7089a65c --- /dev/null +++ b/scripts/expertise/expertise_fs_path_remorseless_nature_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_remorseless_nature_3') + + actor.addSkillMod('expertise_focus_stamina', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_remorseless_nature_3') + + actor.removeSkillMod('expertise_focus_stamina', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_remorseless_nature_4.py b/scripts/expertise/expertise_fs_path_remorseless_nature_4.py new file mode 100644 index 00000000..49440a2d --- /dev/null +++ b/scripts/expertise/expertise_fs_path_remorseless_nature_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_remorseless_nature_4') + + actor.addSkillMod('expertise_focus_stamina', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_remorseless_nature_4') + + actor.removeSkillMod('expertise_focus_stamina', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_riposte_1.py b/scripts/expertise/expertise_fs_path_riposte_1.py new file mode 100644 index 00000000..b7470a65 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_riposte_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_riposte_1') + + actor.addSkillMod('expertise_stance_riposte', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_riposte_1') + + actor.removeSkillMod('expertise_stance_riposte', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_riposte_2.py b/scripts/expertise/expertise_fs_path_riposte_2.py new file mode 100644 index 00000000..de7b4623 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_riposte_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_riposte_2') + + actor.addSkillMod('expertise_stance_riposte', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_riposte_2') + + actor.removeSkillMod('expertise_stance_riposte', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_ruthless_precision_1.py b/scripts/expertise/expertise_fs_path_ruthless_precision_1.py new file mode 100644 index 00000000..fc577d81 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_ruthless_precision_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_ruthless_precision_1') + + actor.addSkillMod('expertise_focus_damage_increase', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_ruthless_precision_1') + + actor.removeSkillMod('expertise_focus_damage_increase', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_ruthless_precision_2.py b/scripts/expertise/expertise_fs_path_ruthless_precision_2.py new file mode 100644 index 00000000..4275711a --- /dev/null +++ b/scripts/expertise/expertise_fs_path_ruthless_precision_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_ruthless_precision_2') + + actor.addSkillMod('expertise_focus_damage_increase', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_ruthless_precision_2') + + actor.removeSkillMod('expertise_focus_damage_increase', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_ruthless_precision_3.py b/scripts/expertise/expertise_fs_path_ruthless_precision_3.py new file mode 100644 index 00000000..0639dd2b --- /dev/null +++ b/scripts/expertise/expertise_fs_path_ruthless_precision_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_ruthless_precision_3') + + actor.addSkillMod('expertise_focus_damage_increase', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_ruthless_precision_3') + + actor.removeSkillMod('expertise_focus_damage_increase', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_ruthless_precision_4.py b/scripts/expertise/expertise_fs_path_ruthless_precision_4.py new file mode 100644 index 00000000..7a46125c --- /dev/null +++ b/scripts/expertise/expertise_fs_path_ruthless_precision_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_ruthless_precision_4') + + actor.addSkillMod('expertise_focus_damage_increase', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_ruthless_precision_4') + + actor.removeSkillMod('expertise_focus_damage_increase', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_saber_reflect_1.py b/scripts/expertise/expertise_fs_path_saber_reflect_1.py new file mode 100644 index 00000000..2895ccac --- /dev/null +++ b/scripts/expertise/expertise_fs_path_saber_reflect_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_saber_reflect_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_saber_reflect_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('fs_saber_reflect_buff') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('fs_saber_reflect_buff') + + return diff --git a/scripts/expertise/expertise_fs_path_saber_shackle_1.py b/scripts/expertise/expertise_fs_path_saber_shackle_1.py new file mode 100644 index 00000000..9f2fe63f --- /dev/null +++ b/scripts/expertise/expertise_fs_path_saber_shackle_1.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_saber_shackle_1') + + actor.addSkillMod('expertise_stance_saber_throw_snare_chance', 25) + actor.addSkillMod('expertise_stance_saber_throw_root_chance', 2) + actor.addSkillMod('expertise_damage_line_fs_dm', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_saber_shackle_1') + + actor.removeSkillMod('expertise_stance_saber_throw_snare_chance', 25) + actor.removeSkillMod('expertise_stance_saber_throw_root_chance', 2) + actor.removeSkillMod('expertise_damage_line_fs_dm', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_saber_shackle_2.py b/scripts/expertise/expertise_fs_path_saber_shackle_2.py new file mode 100644 index 00000000..76d3d5fa --- /dev/null +++ b/scripts/expertise/expertise_fs_path_saber_shackle_2.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_saber_shackle_2') + + actor.addSkillMod('expertise_stance_saber_throw_snare_chance', 25) + actor.addSkillMod('expertise_stance_saber_throw_root_chance', 2) + actor.addSkillMod('expertise_damage_line_fs_dm', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_saber_shackle_2') + + actor.removeSkillMod('expertise_stance_saber_throw_snare_chance', 25) + actor.removeSkillMod('expertise_stance_saber_throw_root_chance', 2) + actor.removeSkillMod('expertise_damage_line_fs_dm', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_saber_shackle_3.py b/scripts/expertise/expertise_fs_path_saber_shackle_3.py new file mode 100644 index 00000000..7c4b0c3e --- /dev/null +++ b/scripts/expertise/expertise_fs_path_saber_shackle_3.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_saber_shackle_3') + + actor.addSkillMod('expertise_stance_saber_throw_snare_chance', 25) + actor.addSkillMod('expertise_stance_saber_throw_root_chance', 2) + actor.addSkillMod('expertise_damage_line_fs_dm', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_saber_shackle_3') + + actor.removeSkillMod('expertise_stance_saber_throw_snare_chance', 25) + actor.removeSkillMod('expertise_stance_saber_throw_root_chance', 2) + actor.removeSkillMod('expertise_damage_line_fs_dm', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_saber_shackle_4.py b/scripts/expertise/expertise_fs_path_saber_shackle_4.py new file mode 100644 index 00000000..889e106d --- /dev/null +++ b/scripts/expertise/expertise_fs_path_saber_shackle_4.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_saber_shackle_4') + + actor.addSkillMod('expertise_stance_saber_throw_snare_chance', 25) + actor.addSkillMod('expertise_stance_saber_throw_root_chance', 2) + actor.addSkillMod('expertise_damage_line_fs_dm', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_saber_shackle_4') + + actor.removeSkillMod('expertise_stance_saber_throw_snare_chance', 25) + actor.removeSkillMod('expertise_stance_saber_throw_root_chance', 2) + actor.removeSkillMod('expertise_damage_line_fs_dm', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_soothing_aura_1.py b/scripts/expertise/expertise_fs_path_soothing_aura_1.py new file mode 100644 index 00000000..d2ce8171 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_soothing_aura_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_soothing_aura_1') + + actor.addSkillMod('expertise_stance_healing_line_fs_heal', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_soothing_aura_1') + + actor.removeSkillMod('expertise_stance_healing_line_fs_heal', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_soothing_aura_2.py b/scripts/expertise/expertise_fs_path_soothing_aura_2.py new file mode 100644 index 00000000..eb134506 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_soothing_aura_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_soothing_aura_2') + + actor.addSkillMod('expertise_stance_healing_line_fs_heal', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_soothing_aura_2') + + actor.removeSkillMod('expertise_stance_healing_line_fs_heal', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_soothing_aura_3.py b/scripts/expertise/expertise_fs_path_soothing_aura_3.py new file mode 100644 index 00000000..ea794b23 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_soothing_aura_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_soothing_aura_3') + + actor.addSkillMod('expertise_stance_healing_line_fs_heal', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_soothing_aura_3') + + actor.removeSkillMod('expertise_stance_healing_line_fs_heal', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_soothing_aura_4.py b/scripts/expertise/expertise_fs_path_soothing_aura_4.py new file mode 100644 index 00000000..b209ea53 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_soothing_aura_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_soothing_aura_4') + + actor.addSkillMod('expertise_stance_healing_line_fs_heal', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_soothing_aura_4') + + actor.removeSkillMod('expertise_stance_healing_line_fs_heal', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_strangulation_1.py b/scripts/expertise/expertise_fs_path_strangulation_1.py new file mode 100644 index 00000000..7e57f9af --- /dev/null +++ b/scripts/expertise/expertise_fs_path_strangulation_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_strangulation_1') + + actor.addSkillMod('expertise_fs_imp_choke', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_strangulation_1') + + actor.removeSkillMod('expertise_fs_imp_choke', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_strangulation_2.py b/scripts/expertise/expertise_fs_path_strangulation_2.py new file mode 100644 index 00000000..40534bff --- /dev/null +++ b/scripts/expertise/expertise_fs_path_strangulation_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_strangulation_2') + + actor.addSkillMod('expertise_fs_imp_choke', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_strangulation_2') + + actor.removeSkillMod('expertise_fs_imp_choke', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_tempt_hatred_1.py b/scripts/expertise/expertise_fs_path_tempt_hatred_1.py new file mode 100644 index 00000000..7bf99377 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_tempt_hatred_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_tempt_hatred_1') + + actor.addSkillMod('expertise_focus_damage_add_to_action', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_tempt_hatred_1') + + actor.removeSkillMod('expertise_focus_damage_add_to_action', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_tempt_hatred_2.py b/scripts/expertise/expertise_fs_path_tempt_hatred_2.py new file mode 100644 index 00000000..9abf4c24 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_tempt_hatred_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_tempt_hatred_2') + + actor.addSkillMod('expertise_focus_damage_add_to_action', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_tempt_hatred_2') + + actor.removeSkillMod('expertise_focus_damage_add_to_action', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_wracking_energy_1.py b/scripts/expertise/expertise_fs_path_wracking_energy_1.py new file mode 100644 index 00000000..425b7931 --- /dev/null +++ b/scripts/expertise/expertise_fs_path_wracking_energy_1.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_wracking_energy_1') + + actor.addSkillMod('expertise_fs_dm_armor_bypass', 25) + actor.addSkillMod('expertise_buff_duration_line_fs_ae_dm_cc', 2) + actor.addSkillMod('expertise_buff_chance_line_fs_ae_dm_cc', 100) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_wracking_energy_1') + + actor.removeSkillMod('expertise_fs_dm_armor_bypass', 25) + actor.removeSkillMod('expertise_buff_duration_line_fs_ae_dm_cc', 2) + actor.removeSkillMod('expertise_buff_chance_line_fs_ae_dm_cc', 100) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_wracking_energy_2.py b/scripts/expertise/expertise_fs_path_wracking_energy_2.py new file mode 100644 index 00000000..298130bc --- /dev/null +++ b/scripts/expertise/expertise_fs_path_wracking_energy_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_wracking_energy_2') + + actor.addSkillMod('expertise_fs_dm_armor_bypass', 25) + actor.addSkillMod('expertise_buff_duration_line_fs_ae_dm_cc', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_wracking_energy_2') + + actor.removeSkillMod('expertise_fs_dm_armor_bypass', 25) + actor.removeSkillMod('expertise_buff_duration_line_fs_ae_dm_cc', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_wracking_energy_3.py b/scripts/expertise/expertise_fs_path_wracking_energy_3.py new file mode 100644 index 00000000..7ebb9e6a --- /dev/null +++ b/scripts/expertise/expertise_fs_path_wracking_energy_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_wracking_energy_3') + + actor.addSkillMod('expertise_fs_dm_armor_bypass', 25) + actor.addSkillMod('expertise_buff_duration_line_fs_ae_dm_cc', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_wracking_energy_3') + + actor.removeSkillMod('expertise_fs_dm_armor_bypass', 25) + actor.removeSkillMod('expertise_buff_duration_line_fs_ae_dm_cc', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_fs_path_wracking_energy_4.py b/scripts/expertise/expertise_fs_path_wracking_energy_4.py new file mode 100644 index 00000000..6818335f --- /dev/null +++ b/scripts/expertise/expertise_fs_path_wracking_energy_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.addSkill('expertise_fs_path_wracking_energy_4') + + actor.addSkillMod('expertise_fs_dm_armor_bypass', 25) + actor.addSkillMod('expertise_buff_duration_line_fs_ae_dm_cc', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'force_sensitive_1a': + return + + actor.removeSkill('expertise_fs_path_wracking_energy_4') + + actor.removeSkillMod('expertise_fs_dm_armor_bypass', 25) + actor.removeSkillMod('expertise_buff_duration_line_fs_ae_dm_cc', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_agility_1.py b/scripts/expertise/expertise_me_agility_1.py new file mode 100644 index 00000000..29ea50ff --- /dev/null +++ b/scripts/expertise/expertise_me_agility_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_agility_1') + + actor.addSkillMod('agility_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_agility_1') + + actor.removeSkillMod('agility_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_agility_2.py b/scripts/expertise/expertise_me_agility_2.py new file mode 100644 index 00000000..f92f5a4b --- /dev/null +++ b/scripts/expertise/expertise_me_agility_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_agility_2') + + actor.addSkillMod('agility_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_agility_2') + + actor.removeSkillMod('agility_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_agility_3.py b/scripts/expertise/expertise_me_agility_3.py new file mode 100644 index 00000000..7441af33 --- /dev/null +++ b/scripts/expertise/expertise_me_agility_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_agility_3') + + actor.addSkillMod('agility_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_agility_3') + + actor.removeSkillMod('agility_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_agility_4.py b/scripts/expertise/expertise_me_agility_4.py new file mode 100644 index 00000000..89603b75 --- /dev/null +++ b/scripts/expertise/expertise_me_agility_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_agility_4') + + actor.addSkillMod('agility_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_agility_4') + + actor.removeSkillMod('agility_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_agro_healing_1.py b/scripts/expertise/expertise_me_agro_healing_1.py new file mode 100644 index 00000000..5e44ee56 --- /dev/null +++ b/scripts/expertise/expertise_me_agro_healing_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_agro_healing_1') + + actor.addSkillMod('expertise_agro_healing', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_agro_healing_1') + + actor.removeSkillMod('expertise_agro_healing', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_agro_healing_2.py b/scripts/expertise/expertise_me_agro_healing_2.py new file mode 100644 index 00000000..454ce643 --- /dev/null +++ b/scripts/expertise/expertise_me_agro_healing_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_agro_healing_2') + + actor.addSkillMod('expertise_agro_healing', 20) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_agro_healing_2') + + actor.removeSkillMod('expertise_agro_healing', 20) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_agro_healing_3.py b/scripts/expertise/expertise_me_agro_healing_3.py new file mode 100644 index 00000000..b795406e --- /dev/null +++ b/scripts/expertise/expertise_me_agro_healing_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_agro_healing_3') + + actor.addSkillMod('expertise_agro_healing', 20) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_agro_healing_3') + + actor.removeSkillMod('expertise_agro_healing', 20) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_bacta_bomb_1.py b/scripts/expertise/expertise_me_bacta_bomb_1.py new file mode 100644 index 00000000..64d190c5 --- /dev/null +++ b/scripts/expertise/expertise_me_bacta_bomb_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_bacta_bomb_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_bacta_bomb_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_bacta_bomb_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_bacta_bomb_1') + + return diff --git a/scripts/expertise/expertise_me_bacta_grenade_1.py b/scripts/expertise/expertise_me_bacta_grenade_1.py new file mode 100644 index 00000000..2f16ef84 --- /dev/null +++ b/scripts/expertise/expertise_me_bacta_grenade_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_bacta_grenade_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_bacta_grenade_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_bacta_grenade_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_bacta_grenade_1') + + return diff --git a/scripts/expertise/expertise_me_bacta_resistance_1.py b/scripts/expertise/expertise_me_bacta_resistance_1.py new file mode 100644 index 00000000..1c26ade5 --- /dev/null +++ b/scripts/expertise/expertise_me_bacta_resistance_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_bacta_resistance_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_bacta_resistance_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_bacta_resistance_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_bacta_resistance_1') + + return diff --git a/scripts/expertise/expertise_me_blood_cleaners_1.py b/scripts/expertise/expertise_me_blood_cleaners_1.py new file mode 100644 index 00000000..b4de82c1 --- /dev/null +++ b/scripts/expertise/expertise_me_blood_cleaners_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_blood_cleaners_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_blood_cleaners_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_blood_cleaners_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_blood_cleaners_1') + + return diff --git a/scripts/expertise/expertise_me_burst_1.py b/scripts/expertise/expertise_me_burst_1.py new file mode 100644 index 00000000..f9b65f16 --- /dev/null +++ b/scripts/expertise/expertise_me_burst_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_burst_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_burst_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_burst_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_burst_1') + + return diff --git a/scripts/expertise/expertise_me_carbine_damage_1.py b/scripts/expertise/expertise_me_carbine_damage_1.py new file mode 100644 index 00000000..ae18ecf9 --- /dev/null +++ b/scripts/expertise/expertise_me_carbine_damage_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_carbine_damage_1') + + actor.addSkillMod('expertise_damage_weapon_1', 2) + actor.addSkillMod('expertise_damage_weapon_2', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_carbine_damage_1') + + actor.removeSkillMod('expertise_damage_weapon_1', 2) + actor.removeSkillMod('expertise_damage_weapon_2', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_carbine_damage_2.py b/scripts/expertise/expertise_me_carbine_damage_2.py new file mode 100644 index 00000000..50bd5fa2 --- /dev/null +++ b/scripts/expertise/expertise_me_carbine_damage_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_carbine_damage_2') + + actor.addSkillMod('expertise_damage_weapon_1', 2) + actor.addSkillMod('expertise_damage_weapon_2', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_carbine_damage_2') + + actor.removeSkillMod('expertise_damage_weapon_1', 2) + actor.removeSkillMod('expertise_damage_weapon_2', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_carbine_damage_3.py b/scripts/expertise/expertise_me_carbine_damage_3.py new file mode 100644 index 00000000..8a65e510 --- /dev/null +++ b/scripts/expertise/expertise_me_carbine_damage_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_carbine_damage_3') + + actor.addSkillMod('expertise_damage_weapon_1', 3) + actor.addSkillMod('expertise_damage_weapon_2', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_carbine_damage_3') + + actor.removeSkillMod('expertise_damage_weapon_1', 3) + actor.removeSkillMod('expertise_damage_weapon_2', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_carbine_damage_4.py b/scripts/expertise/expertise_me_carbine_damage_4.py new file mode 100644 index 00000000..ddd1ca17 --- /dev/null +++ b/scripts/expertise/expertise_me_carbine_damage_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_carbine_damage_4') + + actor.addSkillMod('expertise_damage_weapon_1', 3) + actor.addSkillMod('expertise_damage_weapon_2', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_carbine_damage_4') + + actor.removeSkillMod('expertise_damage_weapon_1', 3) + actor.removeSkillMod('expertise_damage_weapon_2', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_cranial_smash_1.py b/scripts/expertise/expertise_me_cranial_smash_1.py new file mode 100644 index 00000000..98d77547 --- /dev/null +++ b/scripts/expertise/expertise_me_cranial_smash_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_cranial_smash_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_cranial_smash_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_cranial_smash_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_cranial_smash_1') + + return diff --git a/scripts/expertise/expertise_me_cure_affliction_1.py b/scripts/expertise/expertise_me_cure_affliction_1.py new file mode 100644 index 00000000..6a794b64 --- /dev/null +++ b/scripts/expertise/expertise_me_cure_affliction_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_cure_affliction_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_cure_affliction_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_cure_affliction_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_cure_affliction_1') + + return diff --git a/scripts/expertise/expertise_me_dot_damage_1.py b/scripts/expertise/expertise_me_dot_damage_1.py new file mode 100644 index 00000000..3251e445 --- /dev/null +++ b/scripts/expertise/expertise_me_dot_damage_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_dot_damage_1') + + actor.addSkillMod('expertise_dot_increase', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_dot_damage_1') + + actor.removeSkillMod('expertise_dot_increase', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_dot_damage_2.py b/scripts/expertise/expertise_me_dot_damage_2.py new file mode 100644 index 00000000..4c361396 --- /dev/null +++ b/scripts/expertise/expertise_me_dot_damage_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_dot_damage_2') + + actor.addSkillMod('expertise_dot_increase', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_dot_damage_2') + + actor.removeSkillMod('expertise_dot_increase', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_dot_damage_3.py b/scripts/expertise/expertise_me_dot_damage_3.py new file mode 100644 index 00000000..84865714 --- /dev/null +++ b/scripts/expertise/expertise_me_dot_damage_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_dot_damage_3') + + actor.addSkillMod('expertise_dot_increase', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_dot_damage_3') + + actor.removeSkillMod('expertise_dot_increase', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_dot_duration_1.py b/scripts/expertise/expertise_me_dot_duration_1.py new file mode 100644 index 00000000..b7962f70 --- /dev/null +++ b/scripts/expertise/expertise_me_dot_duration_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_dot_duration_1') + + actor.addSkillMod('expertise_dot_duration_line_me_dot', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_dot_duration_1') + + actor.removeSkillMod('expertise_dot_duration_line_me_dot', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_dot_duration_2.py b/scripts/expertise/expertise_me_dot_duration_2.py new file mode 100644 index 00000000..7a514071 --- /dev/null +++ b/scripts/expertise/expertise_me_dot_duration_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_dot_duration_2') + + actor.addSkillMod('expertise_dot_duration_line_me_dot', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_dot_duration_2') + + actor.removeSkillMod('expertise_dot_duration_line_me_dot', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_dot_duration_3.py b/scripts/expertise/expertise_me_dot_duration_3.py new file mode 100644 index 00000000..8b2bb169 --- /dev/null +++ b/scripts/expertise/expertise_me_dot_duration_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_dot_duration_3') + + actor.addSkillMod('expertise_dot_duration_line_me_dot', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_dot_duration_3') + + actor.removeSkillMod('expertise_dot_duration_line_me_dot', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_dueterium_rounds_1.py b/scripts/expertise/expertise_me_dueterium_rounds_1.py new file mode 100644 index 00000000..b7d57e44 --- /dev/null +++ b/scripts/expertise/expertise_me_dueterium_rounds_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_dueterium_rounds_1') + + actor.addSkillMod('expertise_dueterium_rounds_proc', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_dueterium_rounds_1') + + actor.removeSkillMod('expertise_dueterium_rounds_proc', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_electrolyte_drain_1.py b/scripts/expertise/expertise_me_electrolyte_drain_1.py new file mode 100644 index 00000000..d7eb33ac --- /dev/null +++ b/scripts/expertise/expertise_me_electrolyte_drain_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_electrolyte_drain_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_electrolyte_drain_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_electrolyte_drain_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_electrolyte_drain_1') + + return diff --git a/scripts/expertise/expertise_me_energy_armor_1.py b/scripts/expertise/expertise_me_energy_armor_1.py new file mode 100644 index 00000000..2fc984be --- /dev/null +++ b/scripts/expertise/expertise_me_energy_armor_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_energy_armor_1') + + actor.addSkillMod('expertise_innate_protection_all', 225) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_energy_armor_1') + + actor.removeSkillMod('expertise_innate_protection_all', 225) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_energy_armor_2.py b/scripts/expertise/expertise_me_energy_armor_2.py new file mode 100644 index 00000000..0d02a8a1 --- /dev/null +++ b/scripts/expertise/expertise_me_energy_armor_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_energy_armor_2') + + actor.addSkillMod('expertise_innate_protection_all', 225) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_energy_armor_2') + + actor.removeSkillMod('expertise_innate_protection_all', 225) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_energy_armor_3.py b/scripts/expertise/expertise_me_energy_armor_3.py new file mode 100644 index 00000000..cfc6f250 --- /dev/null +++ b/scripts/expertise/expertise_me_energy_armor_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_energy_armor_3') + + actor.addSkillMod('expertise_innate_protection_all', 225) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_energy_armor_3') + + actor.removeSkillMod('expertise_innate_protection_all', 225) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_energy_armor_4.py b/scripts/expertise/expertise_me_energy_armor_4.py new file mode 100644 index 00000000..76181747 --- /dev/null +++ b/scripts/expertise/expertise_me_energy_armor_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_energy_armor_4') + + actor.addSkillMod('expertise_innate_protection_all', 225) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_energy_armor_4') + + actor.removeSkillMod('expertise_innate_protection_all', 225) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_enhance_agility_1.py b/scripts/expertise/expertise_me_enhance_agility_1.py new file mode 100644 index 00000000..fd112eb9 --- /dev/null +++ b/scripts/expertise/expertise_me_enhance_agility_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_enhance_agility_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_enhance_agility_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_enhance_agility_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_enhance_agility_1') + + return diff --git a/scripts/expertise/expertise_me_enhance_block_1.py b/scripts/expertise/expertise_me_enhance_block_1.py new file mode 100644 index 00000000..962c59d5 --- /dev/null +++ b/scripts/expertise/expertise_me_enhance_block_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_enhance_block_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_enhance_block_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_enhance_block_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_enhance_block_1') + + return diff --git a/scripts/expertise/expertise_me_enhance_dodge_1.py b/scripts/expertise/expertise_me_enhance_dodge_1.py new file mode 100644 index 00000000..60af46b2 --- /dev/null +++ b/scripts/expertise/expertise_me_enhance_dodge_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_enhance_dodge_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_enhance_dodge_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_enhance_dodge_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_enhance_dodge_1') + + return diff --git a/scripts/expertise/expertise_me_enhance_duration_1.py b/scripts/expertise/expertise_me_enhance_duration_1.py new file mode 100644 index 00000000..9b54c0a7 --- /dev/null +++ b/scripts/expertise/expertise_me_enhance_duration_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_enhance_duration_1') + + actor.addSkillMod('expertise_buff_duration_line_me_enhance', 300) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_enhance_duration_1') + + actor.removeSkillMod('expertise_buff_duration_line_me_enhance', 300) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_enhance_duration_2.py b/scripts/expertise/expertise_me_enhance_duration_2.py new file mode 100644 index 00000000..4b66e476 --- /dev/null +++ b/scripts/expertise/expertise_me_enhance_duration_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_enhance_duration_2') + + actor.addSkillMod('expertise_buff_duration_line_me_enhance', 300) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_enhance_duration_2') + + actor.removeSkillMod('expertise_buff_duration_line_me_enhance', 300) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_enhance_duration_3.py b/scripts/expertise/expertise_me_enhance_duration_3.py new file mode 100644 index 00000000..336b9d27 --- /dev/null +++ b/scripts/expertise/expertise_me_enhance_duration_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_enhance_duration_3') + + actor.addSkillMod('expertise_buff_duration_line_me_enhance', 600) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_enhance_duration_3') + + actor.removeSkillMod('expertise_buff_duration_line_me_enhance', 600) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_enhance_precision_1.py b/scripts/expertise/expertise_me_enhance_precision_1.py new file mode 100644 index 00000000..f12da671 --- /dev/null +++ b/scripts/expertise/expertise_me_enhance_precision_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_enhance_precision_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_enhance_precision_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_enhance_precision_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_enhance_precision_1') + + return diff --git a/scripts/expertise/expertise_me_enhance_strength_1.py b/scripts/expertise/expertise_me_enhance_strength_1.py new file mode 100644 index 00000000..29bab818 --- /dev/null +++ b/scripts/expertise/expertise_me_enhance_strength_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_enhance_strength_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_enhance_strength_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_enhance_strength_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_enhance_strength_1') + + return diff --git a/scripts/expertise/expertise_me_enhancement_specialist_1.py b/scripts/expertise/expertise_me_enhancement_specialist_1.py new file mode 100644 index 00000000..145b50e9 --- /dev/null +++ b/scripts/expertise/expertise_me_enhancement_specialist_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_enhancement_specialist_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_enhancement_specialist_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_enhance_action_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_enhance_action_1') + + return diff --git a/scripts/expertise/expertise_me_evasion_1.py b/scripts/expertise/expertise_me_evasion_1.py new file mode 100644 index 00000000..7e62f496 --- /dev/null +++ b/scripts/expertise/expertise_me_evasion_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_evasion_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_evasion_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_evasion_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_evasion_1') + + return diff --git a/scripts/expertise/expertise_me_heal_action_1.py b/scripts/expertise/expertise_me_heal_action_1.py new file mode 100644 index 00000000..984b1b6e --- /dev/null +++ b/scripts/expertise/expertise_me_heal_action_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_heal_action_1') + + actor.addSkillMod('expertise_action_line_me_heal', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_heal_action_1') + + actor.removeSkillMod('expertise_action_line_me_heal', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_heal_action_2.py b/scripts/expertise/expertise_me_heal_action_2.py new file mode 100644 index 00000000..e650d1e5 --- /dev/null +++ b/scripts/expertise/expertise_me_heal_action_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_heal_action_2') + + actor.addSkillMod('expertise_action_line_me_heal', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_heal_action_2') + + actor.removeSkillMod('expertise_action_line_me_heal', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_heal_action_3.py b/scripts/expertise/expertise_me_heal_action_3.py new file mode 100644 index 00000000..a5457655 --- /dev/null +++ b/scripts/expertise/expertise_me_heal_action_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_heal_action_3') + + actor.addSkillMod('expertise_action_line_me_heal', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_heal_action_3') + + actor.removeSkillMod('expertise_action_line_me_heal', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_heal_damage_1.py b/scripts/expertise/expertise_me_heal_damage_1.py new file mode 100644 index 00000000..59b07cdf --- /dev/null +++ b/scripts/expertise/expertise_me_heal_damage_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_heal_damage_1') + + actor.addSkillMod('expertise_healing_line_me_heal', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_heal_damage_1') + + actor.removeSkillMod('expertise_healing_line_me_heal', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_heal_damage_2.py b/scripts/expertise/expertise_me_heal_damage_2.py new file mode 100644 index 00000000..c059fc9b --- /dev/null +++ b/scripts/expertise/expertise_me_heal_damage_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_heal_damage_2') + + actor.addSkillMod('expertise_healing_line_me_heal', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_heal_damage_2') + + actor.removeSkillMod('expertise_healing_line_me_heal', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_heal_damage_3.py b/scripts/expertise/expertise_me_heal_damage_3.py new file mode 100644 index 00000000..94eb5732 --- /dev/null +++ b/scripts/expertise/expertise_me_heal_damage_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_heal_damage_3') + + actor.addSkillMod('expertise_healing_line_me_heal', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_heal_damage_3') + + actor.removeSkillMod('expertise_healing_line_me_heal', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_heal_damage_4.py b/scripts/expertise/expertise_me_heal_damage_4.py new file mode 100644 index 00000000..85a946e6 --- /dev/null +++ b/scripts/expertise/expertise_me_heal_damage_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_heal_damage_4') + + actor.addSkillMod('expertise_healing_line_me_heal', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_heal_damage_4') + + actor.removeSkillMod('expertise_healing_line_me_heal', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_hot_duration_1.py b/scripts/expertise/expertise_me_hot_duration_1.py new file mode 100644 index 00000000..dcdd6ac2 --- /dev/null +++ b/scripts/expertise/expertise_me_hot_duration_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_hot_duration_1') + + actor.addSkillMod('expertise_healing_line_me_hot', 10) + actor.addSkillMod('expertise_healing_line_me_hot_ae', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_hot_duration_1') + + actor.removeSkillMod('expertise_healing_line_me_hot', 10) + actor.removeSkillMod('expertise_healing_line_me_hot_ae', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_hot_duration_2.py b/scripts/expertise/expertise_me_hot_duration_2.py new file mode 100644 index 00000000..dccbe005 --- /dev/null +++ b/scripts/expertise/expertise_me_hot_duration_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_hot_duration_2') + + actor.addSkillMod('expertise_healing_line_me_hot', 10) + actor.addSkillMod('expertise_healing_line_me_hot_ae', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_hot_duration_2') + + actor.removeSkillMod('expertise_healing_line_me_hot', 10) + actor.removeSkillMod('expertise_healing_line_me_hot_ae', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_hot_duration_3.py b/scripts/expertise/expertise_me_hot_duration_3.py new file mode 100644 index 00000000..558430c1 --- /dev/null +++ b/scripts/expertise/expertise_me_hot_duration_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_hot_duration_3') + + actor.addSkillMod('expertise_healing_line_me_hot', 15) + actor.addSkillMod('expertise_healing_line_me_hot_ae', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_hot_duration_3') + + actor.removeSkillMod('expertise_healing_line_me_hot', 15) + actor.removeSkillMod('expertise_healing_line_me_hot_ae', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_hot_duration_4.py b/scripts/expertise/expertise_me_hot_duration_4.py new file mode 100644 index 00000000..9783531f --- /dev/null +++ b/scripts/expertise/expertise_me_hot_duration_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_hot_duration_4') + + actor.addSkillMod('expertise_healing_line_me_hot', 15) + actor.addSkillMod('expertise_healing_line_me_hot_ae', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_hot_duration_4') + + actor.removeSkillMod('expertise_healing_line_me_hot', 15) + actor.removeSkillMod('expertise_healing_line_me_hot_ae', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_humanoid_crits_1.py b/scripts/expertise/expertise_me_humanoid_crits_1.py new file mode 100644 index 00000000..4176b559 --- /dev/null +++ b/scripts/expertise/expertise_me_humanoid_crits_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_humanoid_crits_1') + + actor.addSkillMod('expertise_critical_niche_pvp', 1) + actor.addSkillMod('expertise_critical_niche_npc', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_humanoid_crits_1') + + actor.removeSkillMod('expertise_critical_niche_pvp', 1) + actor.removeSkillMod('expertise_critical_niche_npc', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_humanoid_crits_2.py b/scripts/expertise/expertise_me_humanoid_crits_2.py new file mode 100644 index 00000000..dd7995cb --- /dev/null +++ b/scripts/expertise/expertise_me_humanoid_crits_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_humanoid_crits_2') + + actor.addSkillMod('expertise_critical_niche_pvp', 2) + actor.addSkillMod('expertise_critical_niche_npc', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_humanoid_crits_2') + + actor.removeSkillMod('expertise_critical_niche_pvp', 2) + actor.removeSkillMod('expertise_critical_niche_npc', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_humanoid_crits_3.py b/scripts/expertise/expertise_me_humanoid_crits_3.py new file mode 100644 index 00000000..2351be93 --- /dev/null +++ b/scripts/expertise/expertise_me_humanoid_crits_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_humanoid_crits_3') + + actor.addSkillMod('expertise_critical_niche_pvp', 2) + actor.addSkillMod('expertise_critical_niche_npc', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_humanoid_crits_3') + + actor.removeSkillMod('expertise_critical_niche_pvp', 2) + actor.removeSkillMod('expertise_critical_niche_npc', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_induce_insanity_1.py b/scripts/expertise/expertise_me_induce_insanity_1.py new file mode 100644 index 00000000..10f45c55 --- /dev/null +++ b/scripts/expertise/expertise_me_induce_insanity_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_induce_insanity_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_induce_insanity_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_induce_insanity_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_induce_insanity_1') + + return diff --git a/scripts/expertise/expertise_me_kinetic_armor_1.py b/scripts/expertise/expertise_me_kinetic_armor_1.py new file mode 100644 index 00000000..26b5dea7 --- /dev/null +++ b/scripts/expertise/expertise_me_kinetic_armor_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_kinetic_armor_1') + + actor.addSkillMod('expertise_innate_protection_all', 225) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_kinetic_armor_1') + + actor.removeSkillMod('expertise_innate_protection_all', 225) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_kinetic_armor_2.py b/scripts/expertise/expertise_me_kinetic_armor_2.py new file mode 100644 index 00000000..72f3ba66 --- /dev/null +++ b/scripts/expertise/expertise_me_kinetic_armor_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_kinetic_armor_2') + + actor.addSkillMod('expertise_innate_protection_all', 225) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_kinetic_armor_2') + + actor.removeSkillMod('expertise_innate_protection_all', 225) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_kinetic_armor_3.py b/scripts/expertise/expertise_me_kinetic_armor_3.py new file mode 100644 index 00000000..794c9185 --- /dev/null +++ b/scripts/expertise/expertise_me_kinetic_armor_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_kinetic_armor_3') + + actor.addSkillMod('expertise_innate_protection_all', 225) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_kinetic_armor_3') + + actor.removeSkillMod('expertise_innate_protection_all', 225) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_kinetic_armor_4.py b/scripts/expertise/expertise_me_kinetic_armor_4.py new file mode 100644 index 00000000..722e4b58 --- /dev/null +++ b/scripts/expertise/expertise_me_kinetic_armor_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_kinetic_armor_4') + + actor.addSkillMod('expertise_innate_protection_all', 225) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_kinetic_armor_4') + + actor.removeSkillMod('expertise_innate_protection_all', 225) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_poison_knuckle_1.py b/scripts/expertise/expertise_me_poison_knuckle_1.py new file mode 100644 index 00000000..2b6b617e --- /dev/null +++ b/scripts/expertise/expertise_me_poison_knuckle_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_poison_knuckle_1') + + actor.addSkillMod('expertise_poison_knuckle_proc', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_poison_knuckle_1') + + actor.removeSkillMod('expertise_poison_knuckle_proc', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_precision_1.py b/scripts/expertise/expertise_me_precision_1.py new file mode 100644 index 00000000..8c6f96ed --- /dev/null +++ b/scripts/expertise/expertise_me_precision_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_precision_1') + + actor.addSkillMod('precision_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_precision_1') + + actor.removeSkillMod('precision_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_precision_2.py b/scripts/expertise/expertise_me_precision_2.py new file mode 100644 index 00000000..2873f46c --- /dev/null +++ b/scripts/expertise/expertise_me_precision_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_precision_2') + + actor.addSkillMod('precision_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_precision_2') + + actor.removeSkillMod('precision_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_precision_3.py b/scripts/expertise/expertise_me_precision_3.py new file mode 100644 index 00000000..d8996229 --- /dev/null +++ b/scripts/expertise/expertise_me_precision_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_precision_3') + + actor.addSkillMod('precision_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_precision_3') + + actor.removeSkillMod('precision_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_precision_4.py b/scripts/expertise/expertise_me_precision_4.py new file mode 100644 index 00000000..2a2643bb --- /dev/null +++ b/scripts/expertise/expertise_me_precision_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_precision_4') + + actor.addSkillMod('precision_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_precision_4') + + actor.removeSkillMod('precision_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_reckless_stimulation_1.py b/scripts/expertise/expertise_me_reckless_stimulation_1.py new file mode 100644 index 00000000..d8085f3b --- /dev/null +++ b/scripts/expertise/expertise_me_reckless_stimulation_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_reckless_stimulation_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_reckless_stimulation_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_reckless_stimulation_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_reckless_stimulation_1') + + return diff --git a/scripts/expertise/expertise_me_revive_duration_1.py b/scripts/expertise/expertise_me_revive_duration_1.py new file mode 100644 index 00000000..17a19551 --- /dev/null +++ b/scripts/expertise/expertise_me_revive_duration_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_revive_duration_1') + + actor.addSkillMod('expertise_cooldown_line_me_revive', 5) + actor.addSkillMod('expertise_cooldown_line_me_aoe_revive', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_revive_duration_1') + + actor.removeSkillMod('expertise_cooldown_line_me_revive', 5) + actor.removeSkillMod('expertise_cooldown_line_me_aoe_revive', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_revive_duration_2.py b/scripts/expertise/expertise_me_revive_duration_2.py new file mode 100644 index 00000000..ffe5144d --- /dev/null +++ b/scripts/expertise/expertise_me_revive_duration_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_revive_duration_2') + + actor.addSkillMod('expertise_cooldown_line_me_revive', 5) + actor.addSkillMod('expertise_cooldown_line_me_aoe_revive', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_revive_duration_2') + + actor.removeSkillMod('expertise_cooldown_line_me_revive', 5) + actor.removeSkillMod('expertise_cooldown_line_me_aoe_revive', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_revive_duration_3.py b/scripts/expertise/expertise_me_revive_duration_3.py new file mode 100644 index 00000000..4d89125e --- /dev/null +++ b/scripts/expertise/expertise_me_revive_duration_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_revive_duration_3') + + actor.addSkillMod('expertise_cooldown_line_me_revive', 5) + actor.addSkillMod('expertise_cooldown_line_me_aoe_revive', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_revive_duration_3') + + actor.removeSkillMod('expertise_cooldown_line_me_revive', 5) + actor.removeSkillMod('expertise_cooldown_line_me_aoe_revive', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_serotonin_boost_1.py b/scripts/expertise/expertise_me_serotonin_boost_1.py new file mode 100644 index 00000000..be920b81 --- /dev/null +++ b/scripts/expertise/expertise_me_serotonin_boost_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_serotonin_boost_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_serotonin_boost_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_serotonin_boost_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_serotonin_boost_1') + + return diff --git a/scripts/expertise/expertise_me_serotonin_purge_1.py b/scripts/expertise/expertise_me_serotonin_purge_1.py new file mode 100644 index 00000000..34a60137 --- /dev/null +++ b/scripts/expertise/expertise_me_serotonin_purge_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_serotonin_purge_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_serotonin_purge_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_serotonin_purge_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_serotonin_purge_1') + + return diff --git a/scripts/expertise/expertise_me_stasis_1.py b/scripts/expertise/expertise_me_stasis_1.py new file mode 100644 index 00000000..f174c539 --- /dev/null +++ b/scripts/expertise/expertise_me_stasis_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_stasis_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_stasis_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_stasis_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_stasis_1') + + return diff --git a/scripts/expertise/expertise_me_strength_1.py b/scripts/expertise/expertise_me_strength_1.py new file mode 100644 index 00000000..b266ed84 --- /dev/null +++ b/scripts/expertise/expertise_me_strength_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_strength_1') + + actor.addSkillMod('strength_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_strength_1') + + actor.removeSkillMod('strength_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_strength_2.py b/scripts/expertise/expertise_me_strength_2.py new file mode 100644 index 00000000..99f72bb5 --- /dev/null +++ b/scripts/expertise/expertise_me_strength_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_strength_2') + + actor.addSkillMod('strength_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_strength_2') + + actor.removeSkillMod('strength_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_strength_3.py b/scripts/expertise/expertise_me_strength_3.py new file mode 100644 index 00000000..f677cd7e --- /dev/null +++ b/scripts/expertise/expertise_me_strength_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_strength_3') + + actor.addSkillMod('strength_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_strength_3') + + actor.removeSkillMod('strength_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_strength_4.py b/scripts/expertise/expertise_me_strength_4.py new file mode 100644 index 00000000..6da9d910 --- /dev/null +++ b/scripts/expertise/expertise_me_strength_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_strength_4') + + actor.addSkillMod('strength_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_strength_4') + + actor.removeSkillMod('strength_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_thyroid_rupture_1.py b/scripts/expertise/expertise_me_thyroid_rupture_1.py new file mode 100644 index 00000000..229a2796 --- /dev/null +++ b/scripts/expertise/expertise_me_thyroid_rupture_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_thyroid_rupture_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_thyroid_rupture_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_thyroid_rupture_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_thyroid_rupture_1') + + return diff --git a/scripts/expertise/expertise_me_traumatize_1.py b/scripts/expertise/expertise_me_traumatize_1.py new file mode 100644 index 00000000..69856b36 --- /dev/null +++ b/scripts/expertise/expertise_me_traumatize_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_traumatize_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_traumatize_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('me_traumatize_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('me_traumatize_1') + + return diff --git a/scripts/expertise/expertise_me_unarmed_crit_1.py b/scripts/expertise/expertise_me_unarmed_crit_1.py new file mode 100644 index 00000000..77d9b653 --- /dev/null +++ b/scripts/expertise/expertise_me_unarmed_crit_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_unarmed_crit_1') + + actor.addSkillMod('expertise_undiminished_critical_melee', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_unarmed_crit_1') + + actor.removeSkillMod('expertise_undiminished_critical_melee', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_unarmed_crit_2.py b/scripts/expertise/expertise_me_unarmed_crit_2.py new file mode 100644 index 00000000..5a6bb469 --- /dev/null +++ b/scripts/expertise/expertise_me_unarmed_crit_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_unarmed_crit_2') + + actor.addSkillMod('expertise_undiminished_critical_melee', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_unarmed_crit_2') + + actor.removeSkillMod('expertise_undiminished_critical_melee', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_unarmed_crit_3.py b/scripts/expertise/expertise_me_unarmed_crit_3.py new file mode 100644 index 00000000..f5c332ea --- /dev/null +++ b/scripts/expertise/expertise_me_unarmed_crit_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_unarmed_crit_3') + + actor.addSkillMod('expertise_undiminished_critical_melee', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_unarmed_crit_3') + + actor.removeSkillMod('expertise_undiminished_critical_melee', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_unarmed_damage_1.py b/scripts/expertise/expertise_me_unarmed_damage_1.py new file mode 100644 index 00000000..aa61fb7e --- /dev/null +++ b/scripts/expertise/expertise_me_unarmed_damage_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_unarmed_damage_1') + + actor.addSkillMod('expertise_damage_melee', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_unarmed_damage_1') + + actor.removeSkillMod('expertise_damage_melee', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_unarmed_damage_2.py b/scripts/expertise/expertise_me_unarmed_damage_2.py new file mode 100644 index 00000000..7a11aedc --- /dev/null +++ b/scripts/expertise/expertise_me_unarmed_damage_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_unarmed_damage_2') + + actor.addSkillMod('expertise_damage_melee', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_unarmed_damage_2') + + actor.removeSkillMod('expertise_damage_melee', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_unarmed_damage_3.py b/scripts/expertise/expertise_me_unarmed_damage_3.py new file mode 100644 index 00000000..9ca773ae --- /dev/null +++ b/scripts/expertise/expertise_me_unarmed_damage_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_unarmed_damage_3') + + actor.addSkillMod('expertise_damage_melee', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_unarmed_damage_3') + + actor.removeSkillMod('expertise_damage_melee', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_unarmed_damage_4.py b/scripts/expertise/expertise_me_unarmed_damage_4.py new file mode 100644 index 00000000..8164d9c5 --- /dev/null +++ b/scripts/expertise/expertise_me_unarmed_damage_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_unarmed_damage_4') + + actor.addSkillMod('expertise_damage_melee', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_unarmed_damage_4') + + actor.removeSkillMod('expertise_damage_melee', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_vital_action_1.py b/scripts/expertise/expertise_me_vital_action_1.py new file mode 100644 index 00000000..ac935c5d --- /dev/null +++ b/scripts/expertise/expertise_me_vital_action_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_vital_action_1') + + actor.addSkillMod('expertise_action_line_me_dm', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_vital_action_1') + + actor.removeSkillMod('expertise_action_line_me_dm', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_vital_action_2.py b/scripts/expertise/expertise_me_vital_action_2.py new file mode 100644 index 00000000..a3614ac8 --- /dev/null +++ b/scripts/expertise/expertise_me_vital_action_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_vital_action_2') + + actor.addSkillMod('expertise_action_line_me_dm', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_vital_action_2') + + actor.removeSkillMod('expertise_action_line_me_dm', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_vital_action_3.py b/scripts/expertise/expertise_me_vital_action_3.py new file mode 100644 index 00000000..cfdcac09 --- /dev/null +++ b/scripts/expertise/expertise_me_vital_action_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_vital_action_3') + + actor.addSkillMod('expertise_action_line_me_dm', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_vital_action_3') + + actor.removeSkillMod('expertise_action_line_me_dm', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_vital_action_4.py b/scripts/expertise/expertise_me_vital_action_4.py new file mode 100644 index 00000000..df14ebf9 --- /dev/null +++ b/scripts/expertise/expertise_me_vital_action_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_vital_action_4') + + actor.addSkillMod('expertise_action_line_me_dm', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_vital_action_4') + + actor.removeSkillMod('expertise_action_line_me_dm', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_vital_damage_1.py b/scripts/expertise/expertise_me_vital_damage_1.py new file mode 100644 index 00000000..a3b86e64 --- /dev/null +++ b/scripts/expertise/expertise_me_vital_damage_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_vital_damage_1') + + actor.addSkillMod('expertise_damage_line_me_dm', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_vital_damage_1') + + actor.removeSkillMod('expertise_damage_line_me_dm', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_vital_damage_2.py b/scripts/expertise/expertise_me_vital_damage_2.py new file mode 100644 index 00000000..425891d3 --- /dev/null +++ b/scripts/expertise/expertise_me_vital_damage_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_vital_damage_2') + + actor.addSkillMod('expertise_damage_line_me_dm', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_vital_damage_2') + + actor.removeSkillMod('expertise_damage_line_me_dm', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_vital_damage_3.py b/scripts/expertise/expertise_me_vital_damage_3.py new file mode 100644 index 00000000..d1c6b17d --- /dev/null +++ b/scripts/expertise/expertise_me_vital_damage_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_vital_damage_3') + + actor.addSkillMod('expertise_damage_line_me_dm', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_vital_damage_3') + + actor.removeSkillMod('expertise_damage_line_me_dm', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_me_vital_damage_4.py b/scripts/expertise/expertise_me_vital_damage_4.py new file mode 100644 index 00000000..fbeb571c --- /dev/null +++ b/scripts/expertise/expertise_me_vital_damage_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.addSkill('expertise_me_vital_damage_4') + + actor.addSkillMod('expertise_damage_line_me_dm', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'medic_1a': + return + + actor.removeSkill('expertise_me_vital_damage_4') + + actor.removeSkillMod('expertise_damage_line_me_dm', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_armorsmith_advanced_theory_1.py b/scripts/expertise/expertise_munition_armorsmith_advanced_theory_1.py new file mode 100644 index 00000000..c7b03de3 --- /dev/null +++ b/scripts/expertise/expertise_munition_armorsmith_advanced_theory_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_armorsmith_advanced_theory_1') + + actor.addSkillMod('armor_experimentation', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_armorsmith_advanced_theory_1') + + actor.removeSkillMod('armor_experimentation', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_armorsmith_attachment_upgrade_1.py b/scripts/expertise/expertise_munition_armorsmith_attachment_upgrade_1.py new file mode 100644 index 00000000..00e4e545 --- /dev/null +++ b/scripts/expertise/expertise_munition_armorsmith_attachment_upgrade_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_armorsmith_attachment_upgrade_1') + + actor.addSkillMod('expertise_attachment_upgrade', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_armorsmith_attachment_upgrade_1') + + actor.removeSkillMod('expertise_attachment_upgrade', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_armorsmith_dexterity_1.py b/scripts/expertise/expertise_munition_armorsmith_dexterity_1.py new file mode 100644 index 00000000..81d08c77 --- /dev/null +++ b/scripts/expertise/expertise_munition_armorsmith_dexterity_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_armorsmith_dexterity_1') + + actor.addSkillMod('armor_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_armorsmith_dexterity_1') + + actor.removeSkillMod('armor_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_armorsmith_dexterity_2.py b/scripts/expertise/expertise_munition_armorsmith_dexterity_2.py new file mode 100644 index 00000000..9c217bba --- /dev/null +++ b/scripts/expertise/expertise_munition_armorsmith_dexterity_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_armorsmith_dexterity_2') + + actor.addSkillMod('armor_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_armorsmith_dexterity_2') + + actor.removeSkillMod('armor_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_armorsmith_dexterity_3.py b/scripts/expertise/expertise_munition_armorsmith_dexterity_3.py new file mode 100644 index 00000000..e26013a5 --- /dev/null +++ b/scripts/expertise/expertise_munition_armorsmith_dexterity_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_armorsmith_dexterity_3') + + actor.addSkillMod('armor_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_armorsmith_dexterity_3') + + actor.removeSkillMod('armor_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_armorsmith_dexterity_4.py b/scripts/expertise/expertise_munition_armorsmith_dexterity_4.py new file mode 100644 index 00000000..96c50f98 --- /dev/null +++ b/scripts/expertise/expertise_munition_armorsmith_dexterity_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_armorsmith_dexterity_4') + + actor.addSkillMod('armor_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_armorsmith_dexterity_4') + + actor.removeSkillMod('armor_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_armorsmith_hypothesis_1.py b/scripts/expertise/expertise_munition_armorsmith_hypothesis_1.py new file mode 100644 index 00000000..df25bf70 --- /dev/null +++ b/scripts/expertise/expertise_munition_armorsmith_hypothesis_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_armorsmith_hypothesis_1') + + actor.addSkillMod('expertise_experimentation_increase_armorsmith', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_armorsmith_hypothesis_1') + + actor.removeSkillMod('expertise_experimentation_increase_armorsmith', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_armorsmith_hypothesis_2.py b/scripts/expertise/expertise_munition_armorsmith_hypothesis_2.py new file mode 100644 index 00000000..03d1cd9e --- /dev/null +++ b/scripts/expertise/expertise_munition_armorsmith_hypothesis_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_armorsmith_hypothesis_2') + + actor.addSkillMod('expertise_experimentation_increase_armorsmith', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_armorsmith_hypothesis_2') + + actor.removeSkillMod('expertise_experimentation_increase_armorsmith', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_armorsmith_hypothesis_3.py b/scripts/expertise/expertise_munition_armorsmith_hypothesis_3.py new file mode 100644 index 00000000..31e3d0a5 --- /dev/null +++ b/scripts/expertise/expertise_munition_armorsmith_hypothesis_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_armorsmith_hypothesis_3') + + actor.addSkillMod('expertise_experimentation_increase_armorsmith', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_armorsmith_hypothesis_3') + + actor.removeSkillMod('expertise_experimentation_increase_armorsmith', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_armorsmith_hypothesis_4.py b/scripts/expertise/expertise_munition_armorsmith_hypothesis_4.py new file mode 100644 index 00000000..3aaf3ca5 --- /dev/null +++ b/scripts/expertise/expertise_munition_armorsmith_hypothesis_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_armorsmith_hypothesis_4') + + actor.addSkillMod('expertise_experimentation_increase_armorsmith', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_armorsmith_hypothesis_4') + + actor.removeSkillMod('expertise_experimentation_increase_armorsmith', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_armorsmith_insight_1.py b/scripts/expertise/expertise_munition_armorsmith_insight_1.py new file mode 100644 index 00000000..f4836dd3 --- /dev/null +++ b/scripts/expertise/expertise_munition_armorsmith_insight_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_armorsmith_insight_1') + + actor.addSkillMod('expertise_complexity_decrease_armorsmith', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_armorsmith_insight_1') + + actor.removeSkillMod('expertise_complexity_decrease_armorsmith', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_armorsmith_insight_2.py b/scripts/expertise/expertise_munition_armorsmith_insight_2.py new file mode 100644 index 00000000..d0b5d3b0 --- /dev/null +++ b/scripts/expertise/expertise_munition_armorsmith_insight_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_armorsmith_insight_2') + + actor.addSkillMod('expertise_complexity_decrease_armorsmith', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_armorsmith_insight_2') + + actor.removeSkillMod('expertise_complexity_decrease_armorsmith', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_armorsmith_keen_understanding_1.py b/scripts/expertise/expertise_munition_armorsmith_keen_understanding_1.py new file mode 100644 index 00000000..9b7863bb --- /dev/null +++ b/scripts/expertise/expertise_munition_armorsmith_keen_understanding_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_armorsmith_keen_understanding_1') + + actor.addSkillMod('expertise_complexity_decrease_armorsmith', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_armorsmith_keen_understanding_1') + + actor.removeSkillMod('expertise_complexity_decrease_armorsmith', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_armorsmith_keen_understanding_2.py b/scripts/expertise/expertise_munition_armorsmith_keen_understanding_2.py new file mode 100644 index 00000000..9671c726 --- /dev/null +++ b/scripts/expertise/expertise_munition_armorsmith_keen_understanding_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_armorsmith_keen_understanding_2') + + actor.addSkillMod('expertise_complexity_decrease_armorsmith', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_armorsmith_keen_understanding_2') + + actor.removeSkillMod('expertise_complexity_decrease_armorsmith', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_armorsmith_socket_bonus_1.py b/scripts/expertise/expertise_munition_armorsmith_socket_bonus_1.py new file mode 100644 index 00000000..31a4bf81 --- /dev/null +++ b/scripts/expertise/expertise_munition_armorsmith_socket_bonus_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_armorsmith_socket_bonus_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_armorsmith_socket_bonus_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_artisan_advanced_theory_1.py b/scripts/expertise/expertise_munition_artisan_advanced_theory_1.py new file mode 100644 index 00000000..1e5fe723 --- /dev/null +++ b/scripts/expertise/expertise_munition_artisan_advanced_theory_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_artisan_advanced_theory_1') + + actor.addSkillMod('general_experimentation', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_artisan_advanced_theory_1') + + actor.removeSkillMod('general_experimentation', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_artisan_dexterity_1.py b/scripts/expertise/expertise_munition_artisan_dexterity_1.py new file mode 100644 index 00000000..638088a7 --- /dev/null +++ b/scripts/expertise/expertise_munition_artisan_dexterity_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_artisan_dexterity_1') + + actor.addSkillMod('general_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_artisan_dexterity_1') + + actor.removeSkillMod('general_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_artisan_dexterity_2.py b/scripts/expertise/expertise_munition_artisan_dexterity_2.py new file mode 100644 index 00000000..447143e8 --- /dev/null +++ b/scripts/expertise/expertise_munition_artisan_dexterity_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_artisan_dexterity_2') + + actor.addSkillMod('general_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_artisan_dexterity_2') + + actor.removeSkillMod('general_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_artisan_dexterity_3.py b/scripts/expertise/expertise_munition_artisan_dexterity_3.py new file mode 100644 index 00000000..2100f2c7 --- /dev/null +++ b/scripts/expertise/expertise_munition_artisan_dexterity_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_artisan_dexterity_3') + + actor.addSkillMod('general_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_artisan_dexterity_3') + + actor.removeSkillMod('general_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_artisan_dexterity_4.py b/scripts/expertise/expertise_munition_artisan_dexterity_4.py new file mode 100644 index 00000000..4442f4d5 --- /dev/null +++ b/scripts/expertise/expertise_munition_artisan_dexterity_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_artisan_dexterity_4') + + actor.addSkillMod('general_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_artisan_dexterity_4') + + actor.removeSkillMod('general_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_artisan_hypothesis_1.py b/scripts/expertise/expertise_munition_artisan_hypothesis_1.py new file mode 100644 index 00000000..80d37471 --- /dev/null +++ b/scripts/expertise/expertise_munition_artisan_hypothesis_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_artisan_hypothesis_1') + + actor.addSkillMod('expertise_experimentation_increase_artisan', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_artisan_hypothesis_1') + + actor.removeSkillMod('expertise_experimentation_increase_artisan', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_artisan_hypothesis_2.py b/scripts/expertise/expertise_munition_artisan_hypothesis_2.py new file mode 100644 index 00000000..d842f507 --- /dev/null +++ b/scripts/expertise/expertise_munition_artisan_hypothesis_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_artisan_hypothesis_2') + + actor.addSkillMod('expertise_experimentation_increase_artisan', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_artisan_hypothesis_2') + + actor.removeSkillMod('expertise_experimentation_increase_artisan', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_artisan_hypothesis_3.py b/scripts/expertise/expertise_munition_artisan_hypothesis_3.py new file mode 100644 index 00000000..c4498501 --- /dev/null +++ b/scripts/expertise/expertise_munition_artisan_hypothesis_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_artisan_hypothesis_3') + + actor.addSkillMod('expertise_experimentation_increase_artisan', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_artisan_hypothesis_3') + + actor.removeSkillMod('expertise_experimentation_increase_artisan', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_artisan_hypothesis_4.py b/scripts/expertise/expertise_munition_artisan_hypothesis_4.py new file mode 100644 index 00000000..9e217fe9 --- /dev/null +++ b/scripts/expertise/expertise_munition_artisan_hypothesis_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_artisan_hypothesis_4') + + actor.addSkillMod('expertise_experimentation_increase_artisan', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_artisan_hypothesis_4') + + actor.removeSkillMod('expertise_experimentation_increase_artisan', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_resource_processing_1.py b/scripts/expertise/expertise_munition_resource_processing_1.py new file mode 100644 index 00000000..cbbef8f6 --- /dev/null +++ b/scripts/expertise/expertise_munition_resource_processing_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_resource_processing_1') + + actor.addSkillMod('expertise_resource_quality_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_resource_processing_1') + + actor.removeSkillMod('expertise_resource_quality_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_resource_processing_2.py b/scripts/expertise/expertise_munition_resource_processing_2.py new file mode 100644 index 00000000..02eed65b --- /dev/null +++ b/scripts/expertise/expertise_munition_resource_processing_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_resource_processing_2') + + actor.addSkillMod('expertise_resource_quality_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_resource_processing_2') + + actor.removeSkillMod('expertise_resource_quality_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_resource_refinement_1.py b/scripts/expertise/expertise_munition_resource_refinement_1.py new file mode 100644 index 00000000..0d500f72 --- /dev/null +++ b/scripts/expertise/expertise_munition_resource_refinement_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_resource_refinement_1') + + actor.addSkillMod('expertise_resource_quality_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_resource_refinement_1') + + actor.removeSkillMod('expertise_resource_quality_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_resource_refinement_2.py b/scripts/expertise/expertise_munition_resource_refinement_2.py new file mode 100644 index 00000000..5b794681 --- /dev/null +++ b/scripts/expertise/expertise_munition_resource_refinement_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_resource_refinement_2') + + actor.addSkillMod('expertise_resource_quality_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_resource_refinement_2') + + actor.removeSkillMod('expertise_resource_quality_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_weaponsmith_advanced_theory_1.py b/scripts/expertise/expertise_munition_weaponsmith_advanced_theory_1.py new file mode 100644 index 00000000..bfd79df3 --- /dev/null +++ b/scripts/expertise/expertise_munition_weaponsmith_advanced_theory_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_weaponsmith_advanced_theory_1') + + actor.addSkillMod('weapon_experimentation', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_weaponsmith_advanced_theory_1') + + actor.removeSkillMod('weapon_experimentation', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_weaponsmith_dexterity_1.py b/scripts/expertise/expertise_munition_weaponsmith_dexterity_1.py new file mode 100644 index 00000000..fd035fd8 --- /dev/null +++ b/scripts/expertise/expertise_munition_weaponsmith_dexterity_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_weaponsmith_dexterity_1') + + actor.addSkillMod('weapon_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_weaponsmith_dexterity_1') + + actor.removeSkillMod('weapon_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_weaponsmith_dexterity_2.py b/scripts/expertise/expertise_munition_weaponsmith_dexterity_2.py new file mode 100644 index 00000000..6e0ace46 --- /dev/null +++ b/scripts/expertise/expertise_munition_weaponsmith_dexterity_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_weaponsmith_dexterity_2') + + actor.addSkillMod('weapon_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_weaponsmith_dexterity_2') + + actor.removeSkillMod('weapon_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_weaponsmith_dexterity_3.py b/scripts/expertise/expertise_munition_weaponsmith_dexterity_3.py new file mode 100644 index 00000000..7ca11203 --- /dev/null +++ b/scripts/expertise/expertise_munition_weaponsmith_dexterity_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_weaponsmith_dexterity_3') + + actor.addSkillMod('weapon_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_weaponsmith_dexterity_3') + + actor.removeSkillMod('weapon_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_weaponsmith_dexterity_4.py b/scripts/expertise/expertise_munition_weaponsmith_dexterity_4.py new file mode 100644 index 00000000..492a2b7f --- /dev/null +++ b/scripts/expertise/expertise_munition_weaponsmith_dexterity_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_weaponsmith_dexterity_4') + + actor.addSkillMod('weapon_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_weaponsmith_dexterity_4') + + actor.removeSkillMod('weapon_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_weaponsmith_hypothesis_1.py b/scripts/expertise/expertise_munition_weaponsmith_hypothesis_1.py new file mode 100644 index 00000000..01a84b79 --- /dev/null +++ b/scripts/expertise/expertise_munition_weaponsmith_hypothesis_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_weaponsmith_hypothesis_1') + + actor.addSkillMod('expertise_experimentation_increase_weaponsmith', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_weaponsmith_hypothesis_1') + + actor.removeSkillMod('expertise_experimentation_increase_weaponsmith', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_weaponsmith_hypothesis_2.py b/scripts/expertise/expertise_munition_weaponsmith_hypothesis_2.py new file mode 100644 index 00000000..c55b807d --- /dev/null +++ b/scripts/expertise/expertise_munition_weaponsmith_hypothesis_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_weaponsmith_hypothesis_2') + + actor.addSkillMod('expertise_experimentation_increase_weaponsmith', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_weaponsmith_hypothesis_2') + + actor.removeSkillMod('expertise_experimentation_increase_weaponsmith', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_weaponsmith_hypothesis_3.py b/scripts/expertise/expertise_munition_weaponsmith_hypothesis_3.py new file mode 100644 index 00000000..1236e5a7 --- /dev/null +++ b/scripts/expertise/expertise_munition_weaponsmith_hypothesis_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_weaponsmith_hypothesis_3') + + actor.addSkillMod('expertise_experimentation_increase_weaponsmith', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_weaponsmith_hypothesis_3') + + actor.removeSkillMod('expertise_experimentation_increase_weaponsmith', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_weaponsmith_hypothesis_4.py b/scripts/expertise/expertise_munition_weaponsmith_hypothesis_4.py new file mode 100644 index 00000000..233610d9 --- /dev/null +++ b/scripts/expertise/expertise_munition_weaponsmith_hypothesis_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_weaponsmith_hypothesis_4') + + actor.addSkillMod('expertise_experimentation_increase_weaponsmith', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_weaponsmith_hypothesis_4') + + actor.removeSkillMod('expertise_experimentation_increase_weaponsmith', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_weaponsmith_insight_1.py b/scripts/expertise/expertise_munition_weaponsmith_insight_1.py new file mode 100644 index 00000000..f4775f7e --- /dev/null +++ b/scripts/expertise/expertise_munition_weaponsmith_insight_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_weaponsmith_insight_1') + + actor.addSkillMod('expertise_complexity_decrease_weaponsmith', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_weaponsmith_insight_1') + + actor.removeSkillMod('expertise_complexity_decrease_weaponsmith', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_weaponsmith_insight_2.py b/scripts/expertise/expertise_munition_weaponsmith_insight_2.py new file mode 100644 index 00000000..0bd0d617 --- /dev/null +++ b/scripts/expertise/expertise_munition_weaponsmith_insight_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_weaponsmith_insight_2') + + actor.addSkillMod('expertise_complexity_decrease_weaponsmith', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_weaponsmith_insight_2') + + actor.removeSkillMod('expertise_complexity_decrease_weaponsmith', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_weaponsmith_keen_understanding_1.py b/scripts/expertise/expertise_munition_weaponsmith_keen_understanding_1.py new file mode 100644 index 00000000..bf78a146 --- /dev/null +++ b/scripts/expertise/expertise_munition_weaponsmith_keen_understanding_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_weaponsmith_keen_understanding_1') + + actor.addSkillMod('expertise_complexity_decrease_weaponsmith', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_weaponsmith_keen_understanding_1') + + actor.removeSkillMod('expertise_complexity_decrease_weaponsmith', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_munition_weaponsmith_keen_understanding_2.py b/scripts/expertise/expertise_munition_weaponsmith_keen_understanding_2.py new file mode 100644 index 00000000..7bf75f62 --- /dev/null +++ b/scripts/expertise/expertise_munition_weaponsmith_keen_understanding_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.addSkill('expertise_munition_weaponsmith_keen_understanding_2') + + actor.addSkillMod('expertise_complexity_decrease_weaponsmith', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_mun_1a': + return + + actor.removeSkill('expertise_munition_weaponsmith_keen_understanding_2') + + actor.removeSkillMod('expertise_complexity_decrease_weaponsmith', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_1h_crit_1.py b/scripts/expertise/expertise_of_1h_crit_1.py new file mode 100644 index 00000000..461ff94d --- /dev/null +++ b/scripts/expertise/expertise_of_1h_crit_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_1h_crit_1') + + actor.addSkillMod('expertise_undiminished_critical_melee', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_1h_crit_1') + + actor.removeSkillMod('expertise_undiminished_critical_melee', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_1h_crit_2.py b/scripts/expertise/expertise_of_1h_crit_2.py new file mode 100644 index 00000000..60a05278 --- /dev/null +++ b/scripts/expertise/expertise_of_1h_crit_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_1h_crit_2') + + actor.addSkillMod('expertise_undiminished_critical_melee', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_1h_crit_2') + + actor.removeSkillMod('expertise_undiminished_critical_melee', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_1h_dam_1.py b/scripts/expertise/expertise_of_1h_dam_1.py new file mode 100644 index 00000000..b8be4494 --- /dev/null +++ b/scripts/expertise/expertise_of_1h_dam_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_1h_dam_1') + + actor.addSkillMod('expertise_damage_melee', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_1h_dam_1') + + actor.removeSkillMod('expertise_damage_melee', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_1h_dam_2.py b/scripts/expertise/expertise_of_1h_dam_2.py new file mode 100644 index 00000000..e4edd536 --- /dev/null +++ b/scripts/expertise/expertise_of_1h_dam_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_1h_dam_2') + + actor.addSkillMod('expertise_damage_melee', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_1h_dam_2') + + actor.removeSkillMod('expertise_damage_melee', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_1h_dam_3.py b/scripts/expertise/expertise_of_1h_dam_3.py new file mode 100644 index 00000000..aa845e86 --- /dev/null +++ b/scripts/expertise/expertise_of_1h_dam_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_1h_dam_3') + + actor.addSkillMod('expertise_damage_melee', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_1h_dam_3') + + actor.removeSkillMod('expertise_damage_melee', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_1h_dam_4.py b/scripts/expertise/expertise_of_1h_dam_4.py new file mode 100644 index 00000000..8041c7e1 --- /dev/null +++ b/scripts/expertise/expertise_of_1h_dam_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_1h_dam_4') + + actor.addSkillMod('expertise_damage_melee', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_1h_dam_4') + + actor.removeSkillMod('expertise_damage_melee', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_advanced_paint_1.py b/scripts/expertise/expertise_of_advanced_paint_1.py new file mode 100644 index 00000000..3174e3a1 --- /dev/null +++ b/scripts/expertise/expertise_of_advanced_paint_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_advanced_paint_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_advanced_paint_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_deb_def_4') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_deb_def_4') + + return diff --git a/scripts/expertise/expertise_of_advanced_tactics_1.py b/scripts/expertise/expertise_of_advanced_tactics_1.py new file mode 100644 index 00000000..1bbd138c --- /dev/null +++ b/scripts/expertise/expertise_of_advanced_tactics_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_advanced_tactics_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_advanced_tactics_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_buff_def_4') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_buff_def_4') + + return diff --git a/scripts/expertise/expertise_of_aggro_channel_1.py b/scripts/expertise/expertise_of_aggro_channel_1.py new file mode 100644 index 00000000..854b3726 --- /dev/null +++ b/scripts/expertise/expertise_of_aggro_channel_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_aggro_channel_1') + + actor.addSkillMod('expertise_aggro_channel', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_aggro_channel_1') + + actor.removeSkillMod('expertise_aggro_channel', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_aggro_channel') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_aggro_channel') + + return diff --git a/scripts/expertise/expertise_of_aoe_act_1.py b/scripts/expertise/expertise_of_aoe_act_1.py new file mode 100644 index 00000000..ca6b47a6 --- /dev/null +++ b/scripts/expertise/expertise_of_aoe_act_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_aoe_act_1') + + actor.addSkillMod('expertise_action_line_of_aoe', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_aoe_act_1') + + actor.removeSkillMod('expertise_action_line_of_aoe', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_aoe_act_2.py b/scripts/expertise/expertise_of_aoe_act_2.py new file mode 100644 index 00000000..7d2e2aaf --- /dev/null +++ b/scripts/expertise/expertise_of_aoe_act_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_aoe_act_2') + + actor.addSkillMod('expertise_action_line_of_aoe', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_aoe_act_2') + + actor.removeSkillMod('expertise_action_line_of_aoe', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_aoe_act_3.py b/scripts/expertise/expertise_of_aoe_act_3.py new file mode 100644 index 00000000..a07c0839 --- /dev/null +++ b/scripts/expertise/expertise_of_aoe_act_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_aoe_act_3') + + actor.addSkillMod('expertise_action_line_of_aoe', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_aoe_act_3') + + actor.removeSkillMod('expertise_action_line_of_aoe', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_aoe_act_4.py b/scripts/expertise/expertise_of_aoe_act_4.py new file mode 100644 index 00000000..221991d5 --- /dev/null +++ b/scripts/expertise/expertise_of_aoe_act_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_aoe_act_4') + + actor.addSkillMod('expertise_action_line_of_aoe', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_aoe_act_4') + + actor.removeSkillMod('expertise_action_line_of_aoe', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_aoe_crit_1.py b/scripts/expertise/expertise_of_aoe_crit_1.py new file mode 100644 index 00000000..f099eb09 --- /dev/null +++ b/scripts/expertise/expertise_of_aoe_crit_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_aoe_crit_1') + + actor.addSkillMod('expertise_critical_line_of_aoe', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_aoe_crit_1') + + actor.removeSkillMod('expertise_critical_line_of_aoe', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_aoe_crit_2.py b/scripts/expertise/expertise_of_aoe_crit_2.py new file mode 100644 index 00000000..9c9f80e4 --- /dev/null +++ b/scripts/expertise/expertise_of_aoe_crit_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_aoe_crit_2') + + actor.addSkillMod('expertise_critical_line_of_aoe', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_aoe_crit_2') + + actor.removeSkillMod('expertise_critical_line_of_aoe', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_aoe_crit_3.py b/scripts/expertise/expertise_of_aoe_crit_3.py new file mode 100644 index 00000000..e8c9cfaf --- /dev/null +++ b/scripts/expertise/expertise_of_aoe_crit_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_aoe_crit_3') + + actor.addSkillMod('expertise_critical_line_of_aoe', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_aoe_crit_3') + + actor.removeSkillMod('expertise_critical_line_of_aoe', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_aoe_dam_1.py b/scripts/expertise/expertise_of_aoe_dam_1.py new file mode 100644 index 00000000..aecafb91 --- /dev/null +++ b/scripts/expertise/expertise_of_aoe_dam_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_aoe_dam_1') + + actor.addSkillMod('expertise_damage_line_of_aoe', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_aoe_dam_1') + + actor.removeSkillMod('expertise_damage_line_of_aoe', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_aoe_dam_2.py b/scripts/expertise/expertise_of_aoe_dam_2.py new file mode 100644 index 00000000..b4051206 --- /dev/null +++ b/scripts/expertise/expertise_of_aoe_dam_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_aoe_dam_2') + + actor.addSkillMod('expertise_damage_line_of_aoe', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_aoe_dam_2') + + actor.removeSkillMod('expertise_damage_line_of_aoe', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_armor_eng_1.py b/scripts/expertise/expertise_of_armor_eng_1.py new file mode 100644 index 00000000..bbcb6419 --- /dev/null +++ b/scripts/expertise/expertise_of_armor_eng_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_armor_eng_1') + + actor.addSkillMod('expertise_innate_protection_energy', 500) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_armor_eng_1') + + actor.removeSkillMod('expertise_innate_protection_energy', 500) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_armor_eng_2.py b/scripts/expertise/expertise_of_armor_eng_2.py new file mode 100644 index 00000000..a3384177 --- /dev/null +++ b/scripts/expertise/expertise_of_armor_eng_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_armor_eng_2') + + actor.addSkillMod('expertise_innate_protection_energy', 500) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_armor_eng_2') + + actor.removeSkillMod('expertise_innate_protection_energy', 500) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_armor_kin_1.py b/scripts/expertise/expertise_of_armor_kin_1.py new file mode 100644 index 00000000..06713c28 --- /dev/null +++ b/scripts/expertise/expertise_of_armor_kin_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_armor_kin_1') + + actor.addSkillMod('expertise_innate_protection_kinetic', 500) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_armor_kin_1') + + actor.removeSkillMod('expertise_innate_protection_kinetic', 500) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_armor_kin_2.py b/scripts/expertise/expertise_of_armor_kin_2.py new file mode 100644 index 00000000..b1654a38 --- /dev/null +++ b/scripts/expertise/expertise_of_armor_kin_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_armor_kin_2') + + actor.addSkillMod('expertise_innate_protection_kinetic', 500) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_armor_kin_2') + + actor.removeSkillMod('expertise_innate_protection_kinetic', 500) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_charge_1.py b/scripts/expertise/expertise_of_charge_1.py new file mode 100644 index 00000000..14086fb6 --- /dev/null +++ b/scripts/expertise/expertise_of_charge_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_charge_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_charge_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_charge_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_charge_1') + + return diff --git a/scripts/expertise/expertise_of_constitution_1.py b/scripts/expertise/expertise_of_constitution_1.py new file mode 100644 index 00000000..0e6e578c --- /dev/null +++ b/scripts/expertise/expertise_of_constitution_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_constitution_1') + + actor.addSkillMod('constitution_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_constitution_1') + + actor.removeSkillMod('constitution_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_constitution_2.py b/scripts/expertise/expertise_of_constitution_2.py new file mode 100644 index 00000000..7332ea67 --- /dev/null +++ b/scripts/expertise/expertise_of_constitution_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_constitution_2') + + actor.addSkillMod('constitution_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_constitution_2') + + actor.removeSkillMod('constitution_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_constitution_3.py b/scripts/expertise/expertise_of_constitution_3.py new file mode 100644 index 00000000..96cb9137 --- /dev/null +++ b/scripts/expertise/expertise_of_constitution_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_constitution_3') + + actor.addSkillMod('constitution_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_constitution_3') + + actor.removeSkillMod('constitution_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_constitution_4.py b/scripts/expertise/expertise_of_constitution_4.py new file mode 100644 index 00000000..0ba009e9 --- /dev/null +++ b/scripts/expertise/expertise_of_constitution_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_constitution_4') + + actor.addSkillMod('constitution_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_constitution_4') + + actor.removeSkillMod('constitution_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_decapitate_1.py b/scripts/expertise/expertise_of_decapitate_1.py new file mode 100644 index 00000000..5cfb1494 --- /dev/null +++ b/scripts/expertise/expertise_of_decapitate_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_decapitate_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_decapitate_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_decapitate_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_decapitate_1') + + return diff --git a/scripts/expertise/expertise_of_dm_1.py b/scripts/expertise/expertise_of_dm_1.py new file mode 100644 index 00000000..165617c2 --- /dev/null +++ b/scripts/expertise/expertise_of_dm_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_dm_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_dm_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_pistol_dm') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_pistol_dm') + + return diff --git a/scripts/expertise/expertise_of_drillmaster_1.py b/scripts/expertise/expertise_of_drillmaster_1.py new file mode 100644 index 00000000..1216d427 --- /dev/null +++ b/scripts/expertise/expertise_of_drillmaster_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_drillmaster_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_drillmaster_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_drillmaster_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_drillmaster_1') + + return diff --git a/scripts/expertise/expertise_of_emergency_shield.py b/scripts/expertise/expertise_of_emergency_shield.py new file mode 100644 index 00000000..e3a8b519 --- /dev/null +++ b/scripts/expertise/expertise_of_emergency_shield.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_emergency_shield') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_emergency_shield') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_emergency_shield') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_emergency_shield') + + return diff --git a/scripts/expertise/expertise_of_firepower_1.py b/scripts/expertise/expertise_of_firepower_1.py new file mode 100644 index 00000000..ff310741 --- /dev/null +++ b/scripts/expertise/expertise_of_firepower_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_firepower_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_firepower_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_firepower_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_firepower_1') + + return diff --git a/scripts/expertise/expertise_of_firepower_cool_1.py b/scripts/expertise/expertise_of_firepower_cool_1.py new file mode 100644 index 00000000..d844f5f4 --- /dev/null +++ b/scripts/expertise/expertise_of_firepower_cool_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_firepower_cool_1') + + actor.addSkillMod('expertise_cooldown_line_of_firepower', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_firepower_cool_1') + + actor.removeSkillMod('expertise_cooldown_line_of_firepower', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_firepower_cool_2.py b/scripts/expertise/expertise_of_firepower_cool_2.py new file mode 100644 index 00000000..b0fab74f --- /dev/null +++ b/scripts/expertise/expertise_of_firepower_cool_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_firepower_cool_2') + + actor.addSkillMod('expertise_cooldown_line_of_firepower', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_firepower_cool_2') + + actor.removeSkillMod('expertise_cooldown_line_of_firepower', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_firepower_cool_3.py b/scripts/expertise/expertise_of_firepower_cool_3.py new file mode 100644 index 00000000..666c9647 --- /dev/null +++ b/scripts/expertise/expertise_of_firepower_cool_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_firepower_cool_3') + + actor.addSkillMod('expertise_cooldown_line_of_firepower', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_firepower_cool_3') + + actor.removeSkillMod('expertise_cooldown_line_of_firepower', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_focus_fire_1.py b/scripts/expertise/expertise_of_focus_fire_1.py new file mode 100644 index 00000000..7b0cbaff --- /dev/null +++ b/scripts/expertise/expertise_of_focus_fire_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_focus_fire_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_focus_fire_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_focus_fire_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_focus_fire_1') + + return diff --git a/scripts/expertise/expertise_of_group_buff_duration_1.py b/scripts/expertise/expertise_of_group_buff_duration_1.py new file mode 100644 index 00000000..363bd385 --- /dev/null +++ b/scripts/expertise/expertise_of_group_buff_duration_1.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_group_buff_duration_1') + + actor.addSkillMod('expertise_buff_duration_line_of_group_buff', 15) + actor.addSkillMod('expertise_aura_maintain', 1) + actor.addSkillMod('expertise_action_line_of_group_buff', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_group_buff_duration_1') + + actor.removeSkillMod('expertise_buff_duration_line_of_group_buff', 15) + actor.removeSkillMod('expertise_aura_maintain', 1) + actor.removeSkillMod('expertise_action_line_of_group_buff', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_group_buff_duration_2.py b/scripts/expertise/expertise_of_group_buff_duration_2.py new file mode 100644 index 00000000..a8e441bc --- /dev/null +++ b/scripts/expertise/expertise_of_group_buff_duration_2.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_group_buff_duration_2') + + actor.addSkillMod('expertise_buff_duration_line_of_group_buff', 15) + actor.addSkillMod('expertise_aura_maintain', 1) + actor.addSkillMod('expertise_action_line_of_group_buff', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_group_buff_duration_2') + + actor.removeSkillMod('expertise_buff_duration_line_of_group_buff', 15) + actor.removeSkillMod('expertise_aura_maintain', 1) + actor.removeSkillMod('expertise_action_line_of_group_buff', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_heal_cool_1.py b/scripts/expertise/expertise_of_heal_cool_1.py new file mode 100644 index 00000000..fe729bcf --- /dev/null +++ b/scripts/expertise/expertise_of_heal_cool_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_heal_cool_1') + + actor.addSkillMod('expertise_cooldown_line_of_heal', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_heal_cool_1') + + actor.removeSkillMod('expertise_cooldown_line_of_heal', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_heal_cool_2.py b/scripts/expertise/expertise_of_heal_cool_2.py new file mode 100644 index 00000000..93d3f257 --- /dev/null +++ b/scripts/expertise/expertise_of_heal_cool_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_heal_cool_2') + + actor.addSkillMod('expertise_cooldown_line_of_heal', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_heal_cool_2') + + actor.removeSkillMod('expertise_cooldown_line_of_heal', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_heal_dam_1.py b/scripts/expertise/expertise_of_heal_dam_1.py new file mode 100644 index 00000000..5040250a --- /dev/null +++ b/scripts/expertise/expertise_of_heal_dam_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_heal_dam_1') + + actor.addSkillMod('expertise_healing_line_of_heal', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_heal_dam_1') + + actor.removeSkillMod('expertise_healing_line_of_heal', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_heal_dam_2.py b/scripts/expertise/expertise_of_heal_dam_2.py new file mode 100644 index 00000000..40917e3b --- /dev/null +++ b/scripts/expertise/expertise_of_heal_dam_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_heal_dam_2') + + actor.addSkillMod('expertise_healing_line_of_heal', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_heal_dam_2') + + actor.removeSkillMod('expertise_healing_line_of_heal', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_inspiration_1.py b/scripts/expertise/expertise_of_inspiration_1.py new file mode 100644 index 00000000..8905b42d --- /dev/null +++ b/scripts/expertise/expertise_of_inspiration_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_inspiration_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_inspiration_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_inspiration_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_inspiration_1') + + return diff --git a/scripts/expertise/expertise_of_last_words_1.py b/scripts/expertise/expertise_of_last_words_1.py new file mode 100644 index 00000000..540a29c7 --- /dev/null +++ b/scripts/expertise/expertise_of_last_words_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_last_words_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_last_words_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_leg_strike_1.py b/scripts/expertise/expertise_of_leg_strike_1.py new file mode 100644 index 00000000..3eb59a01 --- /dev/null +++ b/scripts/expertise/expertise_of_leg_strike_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_leg_strike_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_leg_strike_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_leg_strike_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_leg_strike_1') + + return diff --git a/scripts/expertise/expertise_of_medical_sup_1.py b/scripts/expertise/expertise_of_medical_sup_1.py new file mode 100644 index 00000000..06c7287d --- /dev/null +++ b/scripts/expertise/expertise_of_medical_sup_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_medical_sup_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_medical_sup_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_medical_sup_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_medical_sup_1') + + return diff --git a/scripts/expertise/expertise_of_paint_dam_1.py b/scripts/expertise/expertise_of_paint_dam_1.py new file mode 100644 index 00000000..ba5725e3 --- /dev/null +++ b/scripts/expertise/expertise_of_paint_dam_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_paint_dam_1') + + actor.addSkillMod('expertise_damage_line_of_paint', 10) + actor.addSkillMod('expertise_action_line_of_paint', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_paint_dam_1') + + actor.removeSkillMod('expertise_damage_line_of_paint', 10) + actor.removeSkillMod('expertise_action_line_of_paint', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_paint_dam_2.py b/scripts/expertise/expertise_of_paint_dam_2.py new file mode 100644 index 00000000..12995cae --- /dev/null +++ b/scripts/expertise/expertise_of_paint_dam_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_paint_dam_2') + + actor.addSkillMod('expertise_damage_line_of_paint', 10) + actor.addSkillMod('expertise_action_line_of_paint', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_paint_dam_2') + + actor.removeSkillMod('expertise_damage_line_of_paint', 10) + actor.removeSkillMod('expertise_action_line_of_paint', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_paint_debuff_1.py b/scripts/expertise/expertise_of_paint_debuff_1.py new file mode 100644 index 00000000..5b2ac0cd --- /dev/null +++ b/scripts/expertise/expertise_of_paint_debuff_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_paint_debuff_1') + + actor.addSkillMod('expertise_of_adv_paint_debuff', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_paint_debuff_1') + + actor.removeSkillMod('expertise_of_adv_paint_debuff', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_paint_expose_1.py b/scripts/expertise/expertise_of_paint_expose_1.py new file mode 100644 index 00000000..91c6d84b --- /dev/null +++ b/scripts/expertise/expertise_of_paint_expose_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_paint_expose_1') + + actor.addSkillMod('expertise_of_adv_paint_expose', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_paint_expose_1') + + actor.removeSkillMod('expertise_of_adv_paint_expose', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_pistol_bleed.py b/scripts/expertise/expertise_of_pistol_bleed.py new file mode 100644 index 00000000..2c9835a0 --- /dev/null +++ b/scripts/expertise/expertise_of_pistol_bleed.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_pistol_bleed') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_pistol_bleed') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_pistol_bleed') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_pistol_bleed') + + return diff --git a/scripts/expertise/expertise_of_pistol_crit_1.py b/scripts/expertise/expertise_of_pistol_crit_1.py new file mode 100644 index 00000000..bc787fd9 --- /dev/null +++ b/scripts/expertise/expertise_of_pistol_crit_1.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_pistol_crit_1') + + actor.addSkillMod('expertise_undiminished_critical_pistol', 5) + actor.addSkillMod('expertise_undiminished_critical_carbine', 5) + actor.addSkillMod('expertise_range_bonus_pistol', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_pistol_crit_1') + + actor.removeSkillMod('expertise_undiminished_critical_pistol', 5) + actor.removeSkillMod('expertise_undiminished_critical_carbine', 5) + actor.removeSkillMod('expertise_range_bonus_pistol', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_pistol_crit_2.py b/scripts/expertise/expertise_of_pistol_crit_2.py new file mode 100644 index 00000000..8d0101ba --- /dev/null +++ b/scripts/expertise/expertise_of_pistol_crit_2.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_pistol_crit_2') + + actor.addSkillMod('expertise_undiminished_critical_pistol', 5) + actor.addSkillMod('expertise_undiminished_critical_carbine', 5) + actor.addSkillMod('expertise_range_bonus_pistol', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_pistol_crit_2') + + actor.removeSkillMod('expertise_undiminished_critical_pistol', 5) + actor.removeSkillMod('expertise_undiminished_critical_carbine', 5) + actor.removeSkillMod('expertise_range_bonus_pistol', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_pistol_dam_1.py b/scripts/expertise/expertise_of_pistol_dam_1.py new file mode 100644 index 00000000..dc46dd87 --- /dev/null +++ b/scripts/expertise/expertise_of_pistol_dam_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_pistol_dam_1') + + actor.addSkillMod('expertise_damage_weapon_1', 2) + actor.addSkillMod('expertise_damage_weapon_2', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_pistol_dam_1') + + actor.removeSkillMod('expertise_damage_weapon_1', 2) + actor.removeSkillMod('expertise_damage_weapon_2', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_pistol_dam_2.py b/scripts/expertise/expertise_of_pistol_dam_2.py new file mode 100644 index 00000000..efd000de --- /dev/null +++ b/scripts/expertise/expertise_of_pistol_dam_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_pistol_dam_2') + + actor.addSkillMod('expertise_damage_weapon_1', 2) + actor.addSkillMod('expertise_damage_weapon_2', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_pistol_dam_2') + + actor.removeSkillMod('expertise_damage_weapon_1', 2) + actor.removeSkillMod('expertise_damage_weapon_2', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_pistol_dam_3.py b/scripts/expertise/expertise_of_pistol_dam_3.py new file mode 100644 index 00000000..d433e2e7 --- /dev/null +++ b/scripts/expertise/expertise_of_pistol_dam_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_pistol_dam_3') + + actor.addSkillMod('expertise_damage_weapon_1', 2) + actor.addSkillMod('expertise_damage_weapon_2', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_pistol_dam_3') + + actor.removeSkillMod('expertise_damage_weapon_1', 2) + actor.removeSkillMod('expertise_damage_weapon_2', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_pistol_dam_4.py b/scripts/expertise/expertise_of_pistol_dam_4.py new file mode 100644 index 00000000..a9dc63c6 --- /dev/null +++ b/scripts/expertise/expertise_of_pistol_dam_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_pistol_dam_4') + + actor.addSkillMod('expertise_damage_weapon_1', 2) + actor.addSkillMod('expertise_damage_weapon_2', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_pistol_dam_4') + + actor.removeSkillMod('expertise_damage_weapon_1', 2) + actor.removeSkillMod('expertise_damage_weapon_2', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_precision_1.py b/scripts/expertise/expertise_of_precision_1.py new file mode 100644 index 00000000..8933a340 --- /dev/null +++ b/scripts/expertise/expertise_of_precision_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_precision_1') + + actor.addSkillMod('precision_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_precision_1') + + actor.removeSkillMod('precision_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_precision_2.py b/scripts/expertise/expertise_of_precision_2.py new file mode 100644 index 00000000..0d2f5a03 --- /dev/null +++ b/scripts/expertise/expertise_of_precision_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_precision_2') + + actor.addSkillMod('precision_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_precision_2') + + actor.removeSkillMod('precision_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_precision_3.py b/scripts/expertise/expertise_of_precision_3.py new file mode 100644 index 00000000..78b48b4e --- /dev/null +++ b/scripts/expertise/expertise_of_precision_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_precision_3') + + actor.addSkillMod('precision_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_precision_3') + + actor.removeSkillMod('precision_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_precision_4.py b/scripts/expertise/expertise_of_precision_4.py new file mode 100644 index 00000000..04824268 --- /dev/null +++ b/scripts/expertise/expertise_of_precision_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_precision_4') + + actor.addSkillMod('precision_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_precision_4') + + actor.removeSkillMod('precision_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_purge_1.py b/scripts/expertise/expertise_of_purge_1.py new file mode 100644 index 00000000..c6c4bdfa --- /dev/null +++ b/scripts/expertise/expertise_of_purge_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_purge_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_purge_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_purge_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_purge_1') + + return diff --git a/scripts/expertise/expertise_of_reinforcements_1.py b/scripts/expertise/expertise_of_reinforcements_1.py new file mode 100644 index 00000000..7c68a80f --- /dev/null +++ b/scripts/expertise/expertise_of_reinforcements_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_reinforcements_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_reinforcements_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_reinforcements_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_reinforcements_1') + + return diff --git a/scripts/expertise/expertise_of_scatter_1.py b/scripts/expertise/expertise_of_scatter_1.py new file mode 100644 index 00000000..e9ce9565 --- /dev/null +++ b/scripts/expertise/expertise_of_scatter_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_scatter_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_scatter_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_scatter_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_scatter_1') + + return diff --git a/scripts/expertise/expertise_of_stamina_1.py b/scripts/expertise/expertise_of_stamina_1.py new file mode 100644 index 00000000..deaa1e13 --- /dev/null +++ b/scripts/expertise/expertise_of_stamina_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_stamina_1') + + actor.addSkillMod('stamina_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_stamina_1') + + actor.removeSkillMod('stamina_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_stamina_2.py b/scripts/expertise/expertise_of_stamina_2.py new file mode 100644 index 00000000..3dcfda6b --- /dev/null +++ b/scripts/expertise/expertise_of_stamina_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_stamina_2') + + actor.addSkillMod('stamina_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_stamina_2') + + actor.removeSkillMod('stamina_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_stamina_3.py b/scripts/expertise/expertise_of_stamina_3.py new file mode 100644 index 00000000..fa6810b5 --- /dev/null +++ b/scripts/expertise/expertise_of_stamina_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_stamina_3') + + actor.addSkillMod('stamina_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_stamina_3') + + actor.removeSkillMod('stamina_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_stamina_4.py b/scripts/expertise/expertise_of_stamina_4.py new file mode 100644 index 00000000..94dbeab3 --- /dev/null +++ b/scripts/expertise/expertise_of_stamina_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_stamina_4') + + actor.addSkillMod('stamina_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_stamina_4') + + actor.removeSkillMod('stamina_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_stimulator_1.py b/scripts/expertise/expertise_of_stimulator_1.py new file mode 100644 index 00000000..6e66f3b4 --- /dev/null +++ b/scripts/expertise/expertise_of_stimulator_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_stimulator_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_stimulator_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_stimulator_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_stimulator_1') + + return diff --git a/scripts/expertise/expertise_of_strength_1.py b/scripts/expertise/expertise_of_strength_1.py new file mode 100644 index 00000000..b2fa95d0 --- /dev/null +++ b/scripts/expertise/expertise_of_strength_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_strength_1') + + actor.addSkillMod('strength_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_strength_1') + + actor.removeSkillMod('strength_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_strength_2.py b/scripts/expertise/expertise_of_strength_2.py new file mode 100644 index 00000000..8a05bcc3 --- /dev/null +++ b/scripts/expertise/expertise_of_strength_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_strength_2') + + actor.addSkillMod('strength_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_strength_2') + + actor.removeSkillMod('strength_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_strength_3.py b/scripts/expertise/expertise_of_strength_3.py new file mode 100644 index 00000000..6dbddcf1 --- /dev/null +++ b/scripts/expertise/expertise_of_strength_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_strength_3') + + actor.addSkillMod('strength_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_strength_3') + + actor.removeSkillMod('strength_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_strength_4.py b/scripts/expertise/expertise_of_strength_4.py new file mode 100644 index 00000000..067d377a --- /dev/null +++ b/scripts/expertise/expertise_of_strength_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_strength_4') + + actor.addSkillMod('strength_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_strength_4') + + actor.removeSkillMod('strength_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_sup_cool_1.py b/scripts/expertise/expertise_of_sup_cool_1.py new file mode 100644 index 00000000..aaa7224b --- /dev/null +++ b/scripts/expertise/expertise_of_sup_cool_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_sup_cool_1') + + actor.addSkillMod('expertise_cooldown_line_of_sup', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_sup_cool_1') + + actor.removeSkillMod('expertise_cooldown_line_of_sup', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_sup_cool_2.py b/scripts/expertise/expertise_of_sup_cool_2.py new file mode 100644 index 00000000..8beb380c --- /dev/null +++ b/scripts/expertise/expertise_of_sup_cool_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_sup_cool_2') + + actor.addSkillMod('expertise_cooldown_line_of_sup', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_sup_cool_2') + + actor.removeSkillMod('expertise_cooldown_line_of_sup', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_sup_cool_3.py b/scripts/expertise/expertise_of_sup_cool_3.py new file mode 100644 index 00000000..9e6e8c8d --- /dev/null +++ b/scripts/expertise/expertise_of_sup_cool_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_sup_cool_3') + + actor.addSkillMod('expertise_cooldown_line_of_sup', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_sup_cool_3') + + actor.removeSkillMod('expertise_cooldown_line_of_sup', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_sup_cool_4.py b/scripts/expertise/expertise_of_sup_cool_4.py new file mode 100644 index 00000000..083f92ab --- /dev/null +++ b/scripts/expertise/expertise_of_sup_cool_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_sup_cool_4') + + actor.addSkillMod('expertise_cooldown_line_of_sup', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_sup_cool_4') + + actor.removeSkillMod('expertise_cooldown_line_of_sup', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_sure_act_1.py b/scripts/expertise/expertise_of_sure_act_1.py new file mode 100644 index 00000000..14e31356 --- /dev/null +++ b/scripts/expertise/expertise_of_sure_act_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_sure_act_1') + + actor.addSkillMod('expertise_action_line_of_sure', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_sure_act_1') + + actor.removeSkillMod('expertise_action_line_of_sure', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_sure_act_2.py b/scripts/expertise/expertise_of_sure_act_2.py new file mode 100644 index 00000000..441a8ce7 --- /dev/null +++ b/scripts/expertise/expertise_of_sure_act_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_sure_act_2') + + actor.addSkillMod('expertise_action_line_of_sure', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_sure_act_2') + + actor.removeSkillMod('expertise_action_line_of_sure', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_sure_act_3.py b/scripts/expertise/expertise_of_sure_act_3.py new file mode 100644 index 00000000..908d9e13 --- /dev/null +++ b/scripts/expertise/expertise_of_sure_act_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_sure_act_3') + + actor.addSkillMod('expertise_action_line_of_sure', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_sure_act_3') + + actor.removeSkillMod('expertise_action_line_of_sure', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_sure_act_4.py b/scripts/expertise/expertise_of_sure_act_4.py new file mode 100644 index 00000000..b876afe3 --- /dev/null +++ b/scripts/expertise/expertise_of_sure_act_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_sure_act_4') + + actor.addSkillMod('expertise_action_line_of_sure', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_sure_act_4') + + actor.removeSkillMod('expertise_action_line_of_sure', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_sure_dam_1.py b/scripts/expertise/expertise_of_sure_dam_1.py new file mode 100644 index 00000000..4a18bcb2 --- /dev/null +++ b/scripts/expertise/expertise_of_sure_dam_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_sure_dam_1') + + actor.addSkillMod('expertise_damage_line_of_sure', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_sure_dam_1') + + actor.removeSkillMod('expertise_damage_line_of_sure', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_sure_dam_2.py b/scripts/expertise/expertise_of_sure_dam_2.py new file mode 100644 index 00000000..9d199519 --- /dev/null +++ b/scripts/expertise/expertise_of_sure_dam_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_sure_dam_2') + + actor.addSkillMod('expertise_damage_line_of_sure', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_sure_dam_2') + + actor.removeSkillMod('expertise_damage_line_of_sure', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_sure_dam_3.py b/scripts/expertise/expertise_of_sure_dam_3.py new file mode 100644 index 00000000..f39ac985 --- /dev/null +++ b/scripts/expertise/expertise_of_sure_dam_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_sure_dam_3') + + actor.addSkillMod('expertise_damage_line_of_sure', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_sure_dam_3') + + actor.removeSkillMod('expertise_damage_line_of_sure', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_tactical_sup_1.py b/scripts/expertise/expertise_of_tactical_sup_1.py new file mode 100644 index 00000000..ce701bb6 --- /dev/null +++ b/scripts/expertise/expertise_of_tactical_sup_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_tactical_sup_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_tactical_sup_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_of_vortex_1.py b/scripts/expertise/expertise_of_vortex_1.py new file mode 100644 index 00000000..e2a24f55 --- /dev/null +++ b/scripts/expertise/expertise_of_vortex_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.addSkill('expertise_of_vortex_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'officer_1a': + return + + actor.removeSkill('expertise_of_vortex_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('of_vortex_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('of_vortex_1') + + return diff --git a/scripts/expertise/expertise_sm_general_bad_odds_1.py b/scripts/expertise/expertise_sm_general_bad_odds_1.py new file mode 100644 index 00000000..e2c44993 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_bad_odds_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_bad_odds_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_bad_odds_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sm_bad_odds_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sm_bad_odds_1') + + return diff --git a/scripts/expertise/expertise_sm_general_break_the_deal_1.py b/scripts/expertise/expertise_sm_general_break_the_deal_1.py new file mode 100644 index 00000000..f12dfb8f --- /dev/null +++ b/scripts/expertise/expertise_sm_general_break_the_deal_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_break_the_deal_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_break_the_deal_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sm_break_the_deal') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sm_break_the_deal') + + return diff --git a/scripts/expertise/expertise_sm_general_double_deal_1.py b/scripts/expertise/expertise_sm_general_double_deal_1.py new file mode 100644 index 00000000..237b1cbd --- /dev/null +++ b/scripts/expertise/expertise_sm_general_double_deal_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_double_deal_1') + + actor.addSkillMod('expertise_double_deal_chance', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_double_deal_1') + + actor.removeSkillMod('expertise_double_deal_chance', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_double_deal_2.py b/scripts/expertise/expertise_sm_general_double_deal_2.py new file mode 100644 index 00000000..f5b3e464 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_double_deal_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_double_deal_2') + + actor.addSkillMod('expertise_double_deal_chance', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_double_deal_2') + + actor.removeSkillMod('expertise_double_deal_chance', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_elbow_grease_1.py b/scripts/expertise/expertise_sm_general_elbow_grease_1.py new file mode 100644 index 00000000..92f55ca2 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_elbow_grease_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_elbow_grease_1') + + actor.addSkillMod('expertise_action_weapon_melee', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_elbow_grease_1') + + actor.removeSkillMod('expertise_action_weapon_melee', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_end_of_the_line_1.py b/scripts/expertise/expertise_sm_general_end_of_the_line_1.py new file mode 100644 index 00000000..3afc6b0b --- /dev/null +++ b/scripts/expertise/expertise_sm_general_end_of_the_line_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_end_of_the_line_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_end_of_the_line_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sm_end_of_the_line') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sm_end_of_the_line') + + return diff --git a/scripts/expertise/expertise_sm_general_enhanced_luck_1.py b/scripts/expertise/expertise_sm_general_enhanced_luck_1.py new file mode 100644 index 00000000..3446d7af --- /dev/null +++ b/scripts/expertise/expertise_sm_general_enhanced_luck_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_enhanced_luck_1') + + actor.addSkillMod('strength_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_enhanced_luck_1') + + actor.removeSkillMod('strength_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_enhanced_luck_2.py b/scripts/expertise/expertise_sm_general_enhanced_luck_2.py new file mode 100644 index 00000000..f0402408 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_enhanced_luck_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_enhanced_luck_2') + + actor.addSkillMod('strength_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_enhanced_luck_2') + + actor.removeSkillMod('strength_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_enhanced_luck_3.py b/scripts/expertise/expertise_sm_general_enhanced_luck_3.py new file mode 100644 index 00000000..dc8fb800 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_enhanced_luck_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_enhanced_luck_3') + + actor.addSkillMod('strength_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_enhanced_luck_3') + + actor.removeSkillMod('strength_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_enhanced_luck_4.py b/scripts/expertise/expertise_sm_general_enhanced_luck_4.py new file mode 100644 index 00000000..6c844743 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_enhanced_luck_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_enhanced_luck_4') + + actor.addSkillMod('strength_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_enhanced_luck_4') + + actor.removeSkillMod('strength_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_enhanced_precision_1.py b/scripts/expertise/expertise_sm_general_enhanced_precision_1.py new file mode 100644 index 00000000..9a865689 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_enhanced_precision_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_enhanced_precision_1') + + actor.addSkillMod('agility_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_enhanced_precision_1') + + actor.removeSkillMod('agility_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_enhanced_precision_2.py b/scripts/expertise/expertise_sm_general_enhanced_precision_2.py new file mode 100644 index 00000000..dda076b0 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_enhanced_precision_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_enhanced_precision_2') + + actor.addSkillMod('agility_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_enhanced_precision_2') + + actor.removeSkillMod('agility_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_enhanced_precision_3.py b/scripts/expertise/expertise_sm_general_enhanced_precision_3.py new file mode 100644 index 00000000..3d93777f --- /dev/null +++ b/scripts/expertise/expertise_sm_general_enhanced_precision_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_enhanced_precision_3') + + actor.addSkillMod('agility_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_enhanced_precision_3') + + actor.removeSkillMod('agility_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_enhanced_precision_4.py b/scripts/expertise/expertise_sm_general_enhanced_precision_4.py new file mode 100644 index 00000000..3aa85853 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_enhanced_precision_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_enhanced_precision_4') + + actor.addSkillMod('agility_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_enhanced_precision_4') + + actor.removeSkillMod('agility_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_gun_oil_1.py b/scripts/expertise/expertise_sm_general_gun_oil_1.py new file mode 100644 index 00000000..f71e62d5 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_gun_oil_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_gun_oil_1') + + actor.addSkillMod('expertise_action_weapon_2', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_gun_oil_1') + + actor.removeSkillMod('expertise_action_weapon_2', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_hair_trigger_1.py b/scripts/expertise/expertise_sm_general_hair_trigger_1.py new file mode 100644 index 00000000..0bc61fb4 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_hair_trigger_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_hair_trigger_1') + + actor.addSkillMod('expertise_action_line_sm_dm', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_hair_trigger_1') + + actor.removeSkillMod('expertise_action_line_sm_dm', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_hair_trigger_2.py b/scripts/expertise/expertise_sm_general_hair_trigger_2.py new file mode 100644 index 00000000..9dc7f200 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_hair_trigger_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_hair_trigger_2') + + actor.addSkillMod('expertise_action_line_sm_dm', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_hair_trigger_2') + + actor.removeSkillMod('expertise_action_line_sm_dm', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_hair_trigger_3.py b/scripts/expertise/expertise_sm_general_hair_trigger_3.py new file mode 100644 index 00000000..0d81af85 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_hair_trigger_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_hair_trigger_3') + + actor.addSkillMod('expertise_action_line_sm_dm', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_hair_trigger_3') + + actor.removeSkillMod('expertise_action_line_sm_dm', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_hair_trigger_4.py b/scripts/expertise/expertise_sm_general_hair_trigger_4.py new file mode 100644 index 00000000..5309084c --- /dev/null +++ b/scripts/expertise/expertise_sm_general_hair_trigger_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_hair_trigger_4') + + actor.addSkillMod('expertise_action_line_sm_dm', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_hair_trigger_4') + + actor.removeSkillMod('expertise_action_line_sm_dm', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_hammer_fanning_1.py b/scripts/expertise/expertise_sm_general_hammer_fanning_1.py new file mode 100644 index 00000000..8108302d --- /dev/null +++ b/scripts/expertise/expertise_sm_general_hammer_fanning_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_hammer_fanning_1') + + actor.addSkillMod('expertise_sm_ranged_shot_proc', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_hammer_fanning_1') + + actor.removeSkillMod('expertise_sm_ranged_shot_proc', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_hammer_fanning_2.py b/scripts/expertise/expertise_sm_general_hammer_fanning_2.py new file mode 100644 index 00000000..d15065e5 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_hammer_fanning_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_hammer_fanning_2') + + actor.addSkillMod('expertise_sm_ranged_shot_proc', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_hammer_fanning_2') + + actor.removeSkillMod('expertise_sm_ranged_shot_proc', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_hammer_fanning_3.py b/scripts/expertise/expertise_sm_general_hammer_fanning_3.py new file mode 100644 index 00000000..f37b9495 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_hammer_fanning_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_hammer_fanning_3') + + actor.addSkillMod('expertise_sm_ranged_shot_proc', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_hammer_fanning_3') + + actor.removeSkillMod('expertise_sm_ranged_shot_proc', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_hammer_fanning_4.py b/scripts/expertise/expertise_sm_general_hammer_fanning_4.py new file mode 100644 index 00000000..de5f58b2 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_hammer_fanning_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_hammer_fanning_4') + + actor.addSkillMod('expertise_sm_ranged_shot_proc', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_hammer_fanning_4') + + actor.removeSkillMod('expertise_sm_ranged_shot_proc', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_head_crack_1.py b/scripts/expertise/expertise_sm_general_head_crack_1.py new file mode 100644 index 00000000..41521dc6 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_head_crack_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_head_crack_1') + + actor.addSkillMod('expertise_sm_melee_stun_proc', 6) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_head_crack_1') + + actor.removeSkillMod('expertise_sm_melee_stun_proc', 6) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_head_crack_2.py b/scripts/expertise/expertise_sm_general_head_crack_2.py new file mode 100644 index 00000000..44d451ed --- /dev/null +++ b/scripts/expertise/expertise_sm_general_head_crack_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_head_crack_2') + + actor.addSkillMod('expertise_sm_melee_stun_proc', 6) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_head_crack_2') + + actor.removeSkillMod('expertise_sm_melee_stun_proc', 6) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_hidden_padding_1.py b/scripts/expertise/expertise_sm_general_hidden_padding_1.py new file mode 100644 index 00000000..e0294af3 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_hidden_padding_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_hidden_padding_1') + + actor.addSkillMod('expertise_overridable_protection_generic', 1475) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_hidden_padding_1') + + actor.removeSkillMod('expertise_overridable_protection_generic', 1475) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_hidden_padding_2.py b/scripts/expertise/expertise_sm_general_hidden_padding_2.py new file mode 100644 index 00000000..e3662b44 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_hidden_padding_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_hidden_padding_2') + + actor.addSkillMod('expertise_overridable_protection_generic', 1475) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_hidden_padding_2') + + actor.removeSkillMod('expertise_overridable_protection_generic', 1475) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_idiot_proof_plan_1.py b/scripts/expertise/expertise_sm_general_idiot_proof_plan_1.py new file mode 100644 index 00000000..d9c15db8 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_idiot_proof_plan_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_idiot_proof_plan_1') + + actor.addSkillMod('damage_decrease_percentage', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_idiot_proof_plan_1') + + actor.removeSkillMod('damage_decrease_percentage', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_idiot_proof_plan_2.py b/scripts/expertise/expertise_sm_general_idiot_proof_plan_2.py new file mode 100644 index 00000000..6cd3dace --- /dev/null +++ b/scripts/expertise/expertise_sm_general_idiot_proof_plan_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_idiot_proof_plan_2') + + actor.addSkillMod('damage_decrease_percentage', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_idiot_proof_plan_2') + + actor.removeSkillMod('damage_decrease_percentage', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_lined_pockets_1.py b/scripts/expertise/expertise_sm_general_lined_pockets_1.py new file mode 100644 index 00000000..5d53be45 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_lined_pockets_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_lined_pockets_1') + + actor.addSkillMod('expertise_overridable_protection_generic', 1475) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_lined_pockets_1') + + actor.removeSkillMod('expertise_overridable_protection_generic', 1475) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_lined_pockets_2.py b/scripts/expertise/expertise_sm_general_lined_pockets_2.py new file mode 100644 index 00000000..03209a76 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_lined_pockets_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_lined_pockets_2') + + actor.addSkillMod('expertise_overridable_protection_generic', 1475) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_lined_pockets_2') + + actor.removeSkillMod('expertise_overridable_protection_generic', 1475) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_meager_fortune_1.py b/scripts/expertise/expertise_sm_general_meager_fortune_1.py new file mode 100644 index 00000000..557528ad --- /dev/null +++ b/scripts/expertise/expertise_sm_general_meager_fortune_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_meager_fortune_1') + + actor.addSkillMod('expertise_spot_a_sucker_critical_decrease', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_meager_fortune_1') + + actor.removeSkillMod('expertise_spot_a_sucker_critical_decrease', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_narrow_escape_1.py b/scripts/expertise/expertise_sm_general_narrow_escape_1.py new file mode 100644 index 00000000..3993e41e --- /dev/null +++ b/scripts/expertise/expertise_sm_general_narrow_escape_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_narrow_escape_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_narrow_escape_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sm_narrow_escape_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sm_narrow_escape_1') + + return diff --git a/scripts/expertise/expertise_sm_general_nerf_herder_1.py b/scripts/expertise/expertise_sm_general_nerf_herder_1.py new file mode 100644 index 00000000..127d4f16 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_nerf_herder_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_nerf_herder_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_nerf_herder_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sm_nerf_herder') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sm_nerf_herder') + + return diff --git a/scripts/expertise/expertise_sm_general_off_the_cuff_1.py b/scripts/expertise/expertise_sm_general_off_the_cuff_1.py new file mode 100644 index 00000000..fec22b4e --- /dev/null +++ b/scripts/expertise/expertise_sm_general_off_the_cuff_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_off_the_cuff_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_off_the_cuff_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sm_off_the_cuff') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sm_off_the_cuff') + + return diff --git a/scripts/expertise/expertise_sm_general_one_two_pummel_1.py b/scripts/expertise/expertise_sm_general_one_two_pummel_1.py new file mode 100644 index 00000000..b9eb89bd --- /dev/null +++ b/scripts/expertise/expertise_sm_general_one_two_pummel_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_one_two_pummel_1') + + actor.addSkillMod('expertise_sm_melee_proc', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_one_two_pummel_1') + + actor.removeSkillMod('expertise_sm_melee_proc', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_one_two_pummel_2.py b/scripts/expertise/expertise_sm_general_one_two_pummel_2.py new file mode 100644 index 00000000..dbd447d9 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_one_two_pummel_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_one_two_pummel_2') + + actor.addSkillMod('expertise_sm_melee_proc', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_one_two_pummel_2') + + actor.removeSkillMod('expertise_sm_melee_proc', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_one_two_pummel_3.py b/scripts/expertise/expertise_sm_general_one_two_pummel_3.py new file mode 100644 index 00000000..98060a5d --- /dev/null +++ b/scripts/expertise/expertise_sm_general_one_two_pummel_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_one_two_pummel_3') + + actor.addSkillMod('expertise_sm_melee_proc', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_one_two_pummel_3') + + actor.removeSkillMod('expertise_sm_melee_proc', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_one_two_pummel_4.py b/scripts/expertise/expertise_sm_general_one_two_pummel_4.py new file mode 100644 index 00000000..6b7e15b7 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_one_two_pummel_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_one_two_pummel_4') + + actor.addSkillMod('expertise_sm_melee_proc', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_one_two_pummel_4') + + actor.removeSkillMod('expertise_sm_melee_proc', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_poor_prospect_1.py b/scripts/expertise/expertise_sm_general_poor_prospect_1.py new file mode 100644 index 00000000..d1d9d03c --- /dev/null +++ b/scripts/expertise/expertise_sm_general_poor_prospect_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_poor_prospect_1') + + actor.addSkillMod('expertise_spot_a_sucker_damage_decrease_chance', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_poor_prospect_1') + + actor.removeSkillMod('expertise_spot_a_sucker_damage_decrease_chance', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_poor_prospect_2.py b/scripts/expertise/expertise_sm_general_poor_prospect_2.py new file mode 100644 index 00000000..ba6e97ae --- /dev/null +++ b/scripts/expertise/expertise_sm_general_poor_prospect_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_poor_prospect_2') + + actor.addSkillMod('expertise_spot_a_sucker_damage_decrease_chance', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_poor_prospect_2') + + actor.removeSkillMod('expertise_spot_a_sucker_damage_decrease_chance', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_precise_bead_1.py b/scripts/expertise/expertise_sm_general_precise_bead_1.py new file mode 100644 index 00000000..e2d219f6 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_precise_bead_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_precise_bead_1') + + actor.addSkillMod('expertise_undiminished_critical_pistol', 5) + actor.addSkillMod('expertise_range_bonus_pistol', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_precise_bead_1') + + actor.removeSkillMod('expertise_undiminished_critical_pistol', 5) + actor.removeSkillMod('expertise_range_bonus_pistol', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_precise_bead_2.py b/scripts/expertise/expertise_sm_general_precise_bead_2.py new file mode 100644 index 00000000..b3ae274d --- /dev/null +++ b/scripts/expertise/expertise_sm_general_precise_bead_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_precise_bead_2') + + actor.addSkillMod('expertise_undiminished_critical_pistol', 5) + actor.addSkillMod('expertise_range_bonus_pistol', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_precise_bead_2') + + actor.removeSkillMod('expertise_undiminished_critical_pistol', 5) + actor.removeSkillMod('expertise_range_bonus_pistol', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_spot_a_sucker_1.py b/scripts/expertise/expertise_sm_general_spot_a_sucker_1.py new file mode 100644 index 00000000..18b3ce1c --- /dev/null +++ b/scripts/expertise/expertise_sm_general_spot_a_sucker_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_spot_a_sucker_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_spot_a_sucker_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sm_spot_a_sucker_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sm_spot_a_sucker_1') + + return diff --git a/scripts/expertise/expertise_sm_general_switcheroo_1.py b/scripts/expertise/expertise_sm_general_switcheroo_1.py new file mode 100644 index 00000000..bec0a317 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_switcheroo_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_switcheroo_1') + + actor.addSkillMod('expertise_critical_hit_reduction', 1) + actor.addSkillMod('expertise_glancing_blow_all', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_switcheroo_1') + + actor.removeSkillMod('expertise_critical_hit_reduction', 1) + actor.removeSkillMod('expertise_glancing_blow_all', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_switcheroo_2.py b/scripts/expertise/expertise_sm_general_switcheroo_2.py new file mode 100644 index 00000000..eb79a782 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_switcheroo_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_switcheroo_2') + + actor.addSkillMod('expertise_critical_hit_reduction', 1) + actor.addSkillMod('expertise_glancing_blow_all', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_switcheroo_2') + + actor.removeSkillMod('expertise_critical_hit_reduction', 1) + actor.removeSkillMod('expertise_glancing_blow_all', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_switcheroo_3.py b/scripts/expertise/expertise_sm_general_switcheroo_3.py new file mode 100644 index 00000000..9732dbf7 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_switcheroo_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_switcheroo_3') + + actor.addSkillMod('expertise_critical_hit_reduction', 1) + actor.addSkillMod('expertise_glancing_blow_all', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_switcheroo_3') + + actor.removeSkillMod('expertise_critical_hit_reduction', 1) + actor.removeSkillMod('expertise_glancing_blow_all', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_switcheroo_4.py b/scripts/expertise/expertise_sm_general_switcheroo_4.py new file mode 100644 index 00000000..b5d082a5 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_switcheroo_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_switcheroo_4') + + actor.addSkillMod('expertise_critical_hit_reduction', 1) + actor.addSkillMod('expertise_glancing_blow_all', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_switcheroo_4') + + actor.removeSkillMod('expertise_critical_hit_reduction', 1) + actor.removeSkillMod('expertise_glancing_blow_all', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_general_wretched_fate_1.py b/scripts/expertise/expertise_sm_general_wretched_fate_1.py new file mode 100644 index 00000000..25287ad7 --- /dev/null +++ b/scripts/expertise/expertise_sm_general_wretched_fate_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_general_wretched_fate_1') + + actor.addSkillMod('expertise_spot_a_sucker_glance_chance', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_general_wretched_fate_1') + + actor.removeSkillMod('expertise_spot_a_sucker_glance_chance', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_beat_down_1.py b/scripts/expertise/expertise_sm_path_beat_down_1.py new file mode 100644 index 00000000..af1829d9 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_beat_down_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_beat_down_1') + + actor.addSkillMod('expertise_buff_duration_line_sm_pistol_whip', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_beat_down_1') + + actor.removeSkillMod('expertise_buff_duration_line_sm_pistol_whip', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_beat_down_2.py b/scripts/expertise/expertise_sm_path_beat_down_2.py new file mode 100644 index 00000000..692ea516 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_beat_down_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_beat_down_2') + + actor.addSkillMod('expertise_buff_duration_line_sm_pistol_whip', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_beat_down_2') + + actor.removeSkillMod('expertise_buff_duration_line_sm_pistol_whip', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_best_deal_ever_1.py b/scripts/expertise/expertise_sm_path_best_deal_ever_1.py new file mode 100644 index 00000000..2abbe97f --- /dev/null +++ b/scripts/expertise/expertise_sm_path_best_deal_ever_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_best_deal_ever_1') + + actor.addSkillMod('expertise_buff_best_deal_ever', 3) + actor.addSkillMod('expertise_junk_dealer_cut', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_best_deal_ever_1') + + actor.removeSkillMod('expertise_buff_best_deal_ever', 3) + actor.removeSkillMod('expertise_junk_dealer_cut', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_best_deal_ever_2.py b/scripts/expertise/expertise_sm_path_best_deal_ever_2.py new file mode 100644 index 00000000..8d50a957 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_best_deal_ever_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_best_deal_ever_2') + + actor.addSkillMod('expertise_buff_best_deal_ever', 3) + actor.addSkillMod('expertise_junk_dealer_cut', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_best_deal_ever_2') + + actor.removeSkillMod('expertise_buff_best_deal_ever', 3) + actor.removeSkillMod('expertise_junk_dealer_cut', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_blaster_at_your_side_1.py b/scripts/expertise/expertise_sm_path_blaster_at_your_side_1.py new file mode 100644 index 00000000..fcbf88bf --- /dev/null +++ b/scripts/expertise/expertise_sm_path_blaster_at_your_side_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_blaster_at_your_side_1') + + actor.addSkillMod('level_add_to_damage', 100) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_blaster_at_your_side_1') + + actor.removeSkillMod('level_add_to_damage', 100) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_blaster_at_your_side_2.py b/scripts/expertise/expertise_sm_path_blaster_at_your_side_2.py new file mode 100644 index 00000000..d1297d00 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_blaster_at_your_side_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_blaster_at_your_side_2') + + actor.addSkillMod('level_add_to_damage', 100) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_blaster_at_your_side_2') + + actor.removeSkillMod('level_add_to_damage', 100) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_blindside_1.py b/scripts/expertise/expertise_sm_path_blindside_1.py new file mode 100644 index 00000000..082ed6a7 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_blindside_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_blindside_1') + + actor.addSkillMod('expertise_buff_duration_line_sm_skullduggery', 13) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_blindside_1') + + actor.removeSkillMod('expertise_buff_duration_line_sm_skullduggery', 13) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_blindside_2.py b/scripts/expertise/expertise_sm_path_blindside_2.py new file mode 100644 index 00000000..3af5ea33 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_blindside_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_blindside_2') + + actor.addSkillMod('expertise_buff_duration_line_sm_skullduggery', 13) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_blindside_2') + + actor.removeSkillMod('expertise_buff_duration_line_sm_skullduggery', 13) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_card_up_your_sleeve_1.py b/scripts/expertise/expertise_sm_path_card_up_your_sleeve_1.py new file mode 100644 index 00000000..14d4ae68 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_card_up_your_sleeve_1.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_card_up_your_sleeve_1') + + actor.addSkillMod('expertise_double_hit_chance', 10) + actor.addSkillMod('expertise_sm_card_ranged_proc', 25) + actor.addSkillMod('expertise_sm_card_melee_proc', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_card_up_your_sleeve_1') + + actor.removeSkillMod('expertise_double_hit_chance', 10) + actor.removeSkillMod('expertise_sm_card_ranged_proc', 25) + actor.removeSkillMod('expertise_sm_card_melee_proc', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_card_up_your_sleeve_2.py b/scripts/expertise/expertise_sm_path_card_up_your_sleeve_2.py new file mode 100644 index 00000000..56aaad3a --- /dev/null +++ b/scripts/expertise/expertise_sm_path_card_up_your_sleeve_2.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_card_up_your_sleeve_2') + + actor.addSkillMod('expertise_double_hit_chance', 10) + actor.addSkillMod('expertise_sm_card_ranged_proc', 25) + actor.addSkillMod('expertise_sm_card_melee_proc', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_card_up_your_sleeve_2') + + actor.removeSkillMod('expertise_double_hit_chance', 10) + actor.removeSkillMod('expertise_sm_card_ranged_proc', 25) + actor.removeSkillMod('expertise_sm_card_melee_proc', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_card_up_your_sleeve_3.py b/scripts/expertise/expertise_sm_path_card_up_your_sleeve_3.py new file mode 100644 index 00000000..e86ff955 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_card_up_your_sleeve_3.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_card_up_your_sleeve_3') + + actor.addSkillMod('expertise_double_hit_chance', 10) + actor.addSkillMod('expertise_sm_card_ranged_proc', 25) + actor.addSkillMod('expertise_sm_card_melee_proc', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_card_up_your_sleeve_3') + + actor.removeSkillMod('expertise_double_hit_chance', 10) + actor.removeSkillMod('expertise_sm_card_ranged_proc', 25) + actor.removeSkillMod('expertise_sm_card_melee_proc', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_card_up_your_sleeve_4.py b/scripts/expertise/expertise_sm_path_card_up_your_sleeve_4.py new file mode 100644 index 00000000..e687b8de --- /dev/null +++ b/scripts/expertise/expertise_sm_path_card_up_your_sleeve_4.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_card_up_your_sleeve_4') + + actor.addSkillMod('expertise_double_hit_chance', 10) + actor.addSkillMod('expertise_sm_card_ranged_proc', 25) + actor.addSkillMod('expertise_sm_card_melee_proc', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_card_up_your_sleeve_4') + + actor.removeSkillMod('expertise_double_hit_chance', 10) + actor.removeSkillMod('expertise_sm_card_ranged_proc', 25) + actor.removeSkillMod('expertise_sm_card_melee_proc', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_easy_money_1.py b/scripts/expertise/expertise_sm_path_easy_money_1.py new file mode 100644 index 00000000..9d8550f0 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_easy_money_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_easy_money_1') + + actor.addSkillMod('luck_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_easy_money_1') + + actor.removeSkillMod('luck_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_easy_money_2.py b/scripts/expertise/expertise_sm_path_easy_money_2.py new file mode 100644 index 00000000..70412fba --- /dev/null +++ b/scripts/expertise/expertise_sm_path_easy_money_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_easy_money_2') + + actor.addSkillMod('luck_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_easy_money_2') + + actor.removeSkillMod('luck_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_easy_money_3.py b/scripts/expertise/expertise_sm_path_easy_money_3.py new file mode 100644 index 00000000..3a44209a --- /dev/null +++ b/scripts/expertise/expertise_sm_path_easy_money_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_easy_money_3') + + actor.addSkillMod('luck_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_easy_money_3') + + actor.removeSkillMod('luck_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_easy_money_4.py b/scripts/expertise/expertise_sm_path_easy_money_4.py new file mode 100644 index 00000000..aaf2d0ef --- /dev/null +++ b/scripts/expertise/expertise_sm_path_easy_money_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_easy_money_4') + + actor.addSkillMod('luck_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_easy_money_4') + + actor.removeSkillMod('luck_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_eat_dirt_1.py b/scripts/expertise/expertise_sm_path_eat_dirt_1.py new file mode 100644 index 00000000..7f3776b3 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_eat_dirt_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_eat_dirt_1') + + actor.addSkillMod('expertise_miss_by_luck', 6) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_eat_dirt_1') + + actor.removeSkillMod('expertise_miss_by_luck', 6) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_eat_dirt_2.py b/scripts/expertise/expertise_sm_path_eat_dirt_2.py new file mode 100644 index 00000000..897d340c --- /dev/null +++ b/scripts/expertise/expertise_sm_path_eat_dirt_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_eat_dirt_2') + + actor.addSkillMod('expertise_miss_by_luck', 6) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_eat_dirt_2') + + actor.removeSkillMod('expertise_miss_by_luck', 6) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_fake_goods_1.py b/scripts/expertise/expertise_sm_path_fake_goods_1.py new file mode 100644 index 00000000..5b414151 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_fake_goods_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_fake_goods_1') + + actor.addSkillMod('expertise_buff_duration_line_sm_false_hope', 1) + actor.addSkillMod('expertise_delay_reduce_line_sm_false_hope', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_fake_goods_1') + + actor.removeSkillMod('expertise_buff_duration_line_sm_false_hope', 1) + actor.removeSkillMod('expertise_delay_reduce_line_sm_false_hope', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_fake_goods_2.py b/scripts/expertise/expertise_sm_path_fake_goods_2.py new file mode 100644 index 00000000..75d5968e --- /dev/null +++ b/scripts/expertise/expertise_sm_path_fake_goods_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_fake_goods_2') + + actor.addSkillMod('expertise_buff_duration_line_sm_false_hope', 1) + actor.addSkillMod('expertise_delay_reduce_line_sm_false_hope', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_fake_goods_2') + + actor.removeSkillMod('expertise_buff_duration_line_sm_false_hope', 1) + actor.removeSkillMod('expertise_delay_reduce_line_sm_false_hope', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_false_hope_1.py b/scripts/expertise/expertise_sm_path_false_hope_1.py new file mode 100644 index 00000000..92c2b34d --- /dev/null +++ b/scripts/expertise/expertise_sm_path_false_hope_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_false_hope_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_false_hope_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sm_false_hope') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sm_false_hope') + + return diff --git a/scripts/expertise/expertise_sm_path_feeling_lucky_1.py b/scripts/expertise/expertise_sm_path_feeling_lucky_1.py new file mode 100644 index 00000000..93fd0635 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_feeling_lucky_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_feeling_lucky_1') + + actor.addSkillMod('expertise_increase_smuggler_loot', 1) + actor.addSkillMod('expertise_sm_feeling_lucky_chance_proc', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_feeling_lucky_1') + + actor.removeSkillMod('expertise_increase_smuggler_loot', 1) + actor.removeSkillMod('expertise_sm_feeling_lucky_chance_proc', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_feeling_lucky_2.py b/scripts/expertise/expertise_sm_path_feeling_lucky_2.py new file mode 100644 index 00000000..ea2f7d6b --- /dev/null +++ b/scripts/expertise/expertise_sm_path_feeling_lucky_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_feeling_lucky_2') + + actor.addSkillMod('expertise_increase_smuggler_loot', 1) + actor.addSkillMod('expertise_sm_feeling_lucky_chance_proc', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_feeling_lucky_2') + + actor.removeSkillMod('expertise_increase_smuggler_loot', 1) + actor.removeSkillMod('expertise_sm_feeling_lucky_chance_proc', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_feeling_lucky_3.py b/scripts/expertise/expertise_sm_path_feeling_lucky_3.py new file mode 100644 index 00000000..a18e89b4 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_feeling_lucky_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_feeling_lucky_3') + + actor.addSkillMod('expertise_increase_smuggler_loot', 1) + actor.addSkillMod('expertise_sm_feeling_lucky_chance_proc', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_feeling_lucky_3') + + actor.removeSkillMod('expertise_increase_smuggler_loot', 1) + actor.removeSkillMod('expertise_sm_feeling_lucky_chance_proc', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_feeling_lucky_4.py b/scripts/expertise/expertise_sm_path_feeling_lucky_4.py new file mode 100644 index 00000000..4a924398 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_feeling_lucky_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_feeling_lucky_4') + + actor.addSkillMod('expertise_increase_smuggler_loot', 1) + actor.addSkillMod('expertise_sm_feeling_lucky_chance_proc', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_feeling_lucky_4') + + actor.removeSkillMod('expertise_increase_smuggler_loot', 1) + actor.removeSkillMod('expertise_sm_feeling_lucky_chance_proc', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_flying_tackle_1.py b/scripts/expertise/expertise_sm_path_flying_tackle_1.py new file mode 100644 index 00000000..cb696d20 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_flying_tackle_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_flying_tackle_1') + + actor.addSkillMod('expertise_stun_line_sm_pistol_whip', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_flying_tackle_1') + + actor.removeSkillMod('expertise_stun_line_sm_pistol_whip', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_flying_tackle_2.py b/scripts/expertise/expertise_sm_path_flying_tackle_2.py new file mode 100644 index 00000000..fdf47b07 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_flying_tackle_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_flying_tackle_2') + + actor.addSkillMod('expertise_stun_line_sm_pistol_whip', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_flying_tackle_2') + + actor.removeSkillMod('expertise_stun_line_sm_pistol_whip', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_healthy_profits_1.py b/scripts/expertise/expertise_sm_path_healthy_profits_1.py new file mode 100644 index 00000000..431019aa --- /dev/null +++ b/scripts/expertise/expertise_sm_path_healthy_profits_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_healthy_profits_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_healthy_profits_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sm_summon_medic') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sm_summon_medic') + + return diff --git a/scripts/expertise/expertise_sm_path_impossible_odds_1.py b/scripts/expertise/expertise_sm_path_impossible_odds_1.py new file mode 100644 index 00000000..63e78de4 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_impossible_odds_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_impossible_odds_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_impossible_odds_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sm_impossible_odds') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sm_impossible_odds') + + return diff --git a/scripts/expertise/expertise_sm_path_inside_information_1.py b/scripts/expertise/expertise_sm_path_inside_information_1.py new file mode 100644 index 00000000..3bdba930 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_inside_information_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_inside_information_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_inside_information_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sm_inside_information') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sm_inside_information') + + return diff --git a/scripts/expertise/expertise_sm_path_loaded_chance_dice_1.py b/scripts/expertise/expertise_sm_path_loaded_chance_dice_1.py new file mode 100644 index 00000000..ccc1e6ba --- /dev/null +++ b/scripts/expertise/expertise_sm_path_loaded_chance_dice_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_loaded_chance_dice_1') + + actor.addSkillMod('expertise_increase_hit_by_luck', 5) + actor.addSkillMod('expertise_buff_duration_line_sm_impossible_odds', 13) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_loaded_chance_dice_1') + + actor.removeSkillMod('expertise_increase_hit_by_luck', 5) + actor.removeSkillMod('expertise_buff_duration_line_sm_impossible_odds', 13) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_loaded_chance_dice_2.py b/scripts/expertise/expertise_sm_path_loaded_chance_dice_2.py new file mode 100644 index 00000000..1af5ac14 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_loaded_chance_dice_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_loaded_chance_dice_2') + + actor.addSkillMod('expertise_increase_hit_by_luck', 5) + actor.addSkillMod('expertise_buff_duration_line_sm_impossible_odds', 13) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_loaded_chance_dice_2') + + actor.removeSkillMod('expertise_increase_hit_by_luck', 5) + actor.removeSkillMod('expertise_buff_duration_line_sm_impossible_odds', 13) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_lucky_break_1.py b/scripts/expertise/expertise_sm_path_lucky_break_1.py new file mode 100644 index 00000000..df59283b --- /dev/null +++ b/scripts/expertise/expertise_sm_path_lucky_break_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_lucky_break_1') + + actor.addSkillMod('expertise_lucky_break_chance', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_lucky_break_1') + + actor.removeSkillMod('expertise_lucky_break_chance', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_lucky_break_2.py b/scripts/expertise/expertise_sm_path_lucky_break_2.py new file mode 100644 index 00000000..fabd837e --- /dev/null +++ b/scripts/expertise/expertise_sm_path_lucky_break_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_lucky_break_2') + + actor.addSkillMod('expertise_lucky_break_chance', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_lucky_break_2') + + actor.removeSkillMod('expertise_lucky_break_chance', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_lucky_break_3.py b/scripts/expertise/expertise_sm_path_lucky_break_3.py new file mode 100644 index 00000000..572d050f --- /dev/null +++ b/scripts/expertise/expertise_sm_path_lucky_break_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_lucky_break_3') + + actor.addSkillMod('expertise_lucky_break_chance', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_lucky_break_3') + + actor.removeSkillMod('expertise_lucky_break_chance', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_lucky_break_4.py b/scripts/expertise/expertise_sm_path_lucky_break_4.py new file mode 100644 index 00000000..8a29ac79 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_lucky_break_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_lucky_break_4') + + actor.addSkillMod('expertise_lucky_break_chance', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_lucky_break_4') + + actor.removeSkillMod('expertise_lucky_break_chance', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_off_the_books_1.py b/scripts/expertise/expertise_sm_path_off_the_books_1.py new file mode 100644 index 00000000..eeac5c97 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_off_the_books_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_off_the_books_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_off_the_books_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sm_off_the_books') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sm_off_the_books') + + return diff --git a/scripts/expertise/expertise_sm_path_pistol_whip_1.py b/scripts/expertise/expertise_sm_path_pistol_whip_1.py new file mode 100644 index 00000000..e1dd1a3f --- /dev/null +++ b/scripts/expertise/expertise_sm_path_pistol_whip_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_pistol_whip_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_pistol_whip_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sm_pistol_whip_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sm_pistol_whip_1') + + return diff --git a/scripts/expertise/expertise_sm_path_ploy_1.py b/scripts/expertise/expertise_sm_path_ploy_1.py new file mode 100644 index 00000000..972f5cf6 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_ploy_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_ploy_1') + + actor.addSkillMod('precision_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_ploy_1') + + actor.removeSkillMod('precision_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_ploy_2.py b/scripts/expertise/expertise_sm_path_ploy_2.py new file mode 100644 index 00000000..a49453d7 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_ploy_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_ploy_2') + + actor.addSkillMod('precision_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_ploy_2') + + actor.removeSkillMod('precision_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_ploy_3.py b/scripts/expertise/expertise_sm_path_ploy_3.py new file mode 100644 index 00000000..84904cdf --- /dev/null +++ b/scripts/expertise/expertise_sm_path_ploy_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_ploy_3') + + actor.addSkillMod('precision_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_ploy_3') + + actor.removeSkillMod('precision_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_ploy_4.py b/scripts/expertise/expertise_sm_path_ploy_4.py new file mode 100644 index 00000000..4ca79a1f --- /dev/null +++ b/scripts/expertise/expertise_sm_path_ploy_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_ploy_4') + + actor.addSkillMod('precision_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_ploy_4') + + actor.removeSkillMod('precision_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_quick_fix_1.py b/scripts/expertise/expertise_sm_path_quick_fix_1.py new file mode 100644 index 00000000..522a120c --- /dev/null +++ b/scripts/expertise/expertise_sm_path_quick_fix_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_quick_fix_1') + + actor.addSkillMod('expertise_healing_line_sm_heal', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_quick_fix_1') + + actor.removeSkillMod('expertise_healing_line_sm_heal', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_quick_fix_2.py b/scripts/expertise/expertise_sm_path_quick_fix_2.py new file mode 100644 index 00000000..2f4cdc81 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_quick_fix_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_quick_fix_2') + + actor.addSkillMod('expertise_healing_line_sm_heal', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_quick_fix_2') + + actor.removeSkillMod('expertise_healing_line_sm_heal', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_quick_fix_3.py b/scripts/expertise/expertise_sm_path_quick_fix_3.py new file mode 100644 index 00000000..42f74088 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_quick_fix_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_quick_fix_3') + + actor.addSkillMod('expertise_healing_line_sm_heal', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_quick_fix_3') + + actor.removeSkillMod('expertise_healing_line_sm_heal', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_quick_fix_4.py b/scripts/expertise/expertise_sm_path_quick_fix_4.py new file mode 100644 index 00000000..c041fb6e --- /dev/null +++ b/scripts/expertise/expertise_sm_path_quick_fix_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_quick_fix_4') + + actor.addSkillMod('expertise_healing_line_sm_heal', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_quick_fix_4') + + actor.removeSkillMod('expertise_healing_line_sm_heal', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_scandal_1.py b/scripts/expertise/expertise_sm_path_scandal_1.py new file mode 100644 index 00000000..d3201976 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_scandal_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_scandal_1') + + actor.addSkillMod('expertise_damage_area_effect', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_scandal_1') + + actor.removeSkillMod('expertise_damage_area_effect', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_scandal_2.py b/scripts/expertise/expertise_sm_path_scandal_2.py new file mode 100644 index 00000000..5a14559b --- /dev/null +++ b/scripts/expertise/expertise_sm_path_scandal_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_scandal_2') + + actor.addSkillMod('expertise_damage_area_effect', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_scandal_2') + + actor.removeSkillMod('expertise_damage_area_effect', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_scandal_3.py b/scripts/expertise/expertise_sm_path_scandal_3.py new file mode 100644 index 00000000..0d7ae351 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_scandal_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_scandal_3') + + actor.addSkillMod('expertise_damage_area_effect', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_scandal_3') + + actor.removeSkillMod('expertise_damage_area_effect', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_scandal_4.py b/scripts/expertise/expertise_sm_path_scandal_4.py new file mode 100644 index 00000000..96b3235c --- /dev/null +++ b/scripts/expertise/expertise_sm_path_scandal_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_scandal_4') + + actor.addSkillMod('expertise_damage_area_effect', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_scandal_4') + + actor.removeSkillMod('expertise_damage_area_effect', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_shoot_first_1.py b/scripts/expertise/expertise_sm_path_shoot_first_1.py new file mode 100644 index 00000000..af429bb5 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_shoot_first_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_shoot_first_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_shoot_first_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sm_shoot_first_1') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sm_shoot_first_1') + + return diff --git a/scripts/expertise/expertise_sm_path_skullduggery_1.py b/scripts/expertise/expertise_sm_path_skullduggery_1.py new file mode 100644 index 00000000..3da59a99 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_skullduggery_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_skullduggery_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_skullduggery_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sm_skullduggery') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sm_skullduggery') + + return diff --git a/scripts/expertise/expertise_sm_path_sleight_of_hand_1.py b/scripts/expertise/expertise_sm_path_sleight_of_hand_1.py new file mode 100644 index 00000000..555dc04d --- /dev/null +++ b/scripts/expertise/expertise_sm_path_sleight_of_hand_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_sleight_of_hand_1') + + actor.addSkillMod('expertise_hit_by_luck', 8) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_sleight_of_hand_1') + + actor.removeSkillMod('expertise_hit_by_luck', 8) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_sleight_of_hand_2.py b/scripts/expertise/expertise_sm_path_sleight_of_hand_2.py new file mode 100644 index 00000000..50a5b317 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_sleight_of_hand_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_sleight_of_hand_2') + + actor.addSkillMod('expertise_hit_by_luck', 8) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_sleight_of_hand_2') + + actor.removeSkillMod('expertise_hit_by_luck', 8) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_smooth_move_1.py b/scripts/expertise/expertise_sm_path_smooth_move_1.py new file mode 100644 index 00000000..c04b10a0 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_smooth_move_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_smooth_move_1') + + actor.addSkillMod('expertise_damage_melee', 1) + actor.addSkillMod('expertise_damage_weapon_2', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_smooth_move_1') + + actor.removeSkillMod('expertise_damage_melee', 1) + actor.removeSkillMod('expertise_damage_weapon_2', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_smooth_move_2.py b/scripts/expertise/expertise_sm_path_smooth_move_2.py new file mode 100644 index 00000000..e7f8a910 --- /dev/null +++ b/scripts/expertise/expertise_sm_path_smooth_move_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_smooth_move_2') + + actor.addSkillMod('expertise_damage_melee', 1) + actor.addSkillMod('expertise_damage_weapon_2', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_smooth_move_2') + + actor.removeSkillMod('expertise_damage_melee', 1) + actor.removeSkillMod('expertise_damage_weapon_2', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_smooth_move_3.py b/scripts/expertise/expertise_sm_path_smooth_move_3.py new file mode 100644 index 00000000..036e78ed --- /dev/null +++ b/scripts/expertise/expertise_sm_path_smooth_move_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_smooth_move_3') + + actor.addSkillMod('expertise_damage_melee', 1) + actor.addSkillMod('expertise_damage_weapon_2', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_smooth_move_3') + + actor.removeSkillMod('expertise_damage_melee', 1) + actor.removeSkillMod('expertise_damage_weapon_2', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_smooth_move_4.py b/scripts/expertise/expertise_sm_path_smooth_move_4.py new file mode 100644 index 00000000..c608477d --- /dev/null +++ b/scripts/expertise/expertise_sm_path_smooth_move_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_smooth_move_4') + + actor.addSkillMod('expertise_damage_melee', 1) + actor.addSkillMod('expertise_damage_weapon_2', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_smooth_move_4') + + actor.removeSkillMod('expertise_damage_melee', 1) + actor.removeSkillMod('expertise_damage_weapon_2', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_under_the_counter_1.py b/scripts/expertise/expertise_sm_path_under_the_counter_1.py new file mode 100644 index 00000000..563ac15f --- /dev/null +++ b/scripts/expertise/expertise_sm_path_under_the_counter_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_under_the_counter_1') + + actor.addSkillMod('expertise_buff_under_the_counter', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_under_the_counter_1') + + actor.removeSkillMod('expertise_buff_under_the_counter', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sm_path_under_the_counter_2.py b/scripts/expertise/expertise_sm_path_under_the_counter_2.py new file mode 100644 index 00000000..f4a1f72c --- /dev/null +++ b/scripts/expertise/expertise_sm_path_under_the_counter_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.addSkill('expertise_sm_path_under_the_counter_2') + + actor.addSkillMod('expertise_buff_under_the_counter', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'smuggler_1a': + return + + actor.removeSkill('expertise_sm_path_under_the_counter_2') + + actor.removeSkillMod('expertise_buff_under_the_counter', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_assassins_blade_1.py b/scripts/expertise/expertise_sp_assassins_blade_1.py new file mode 100644 index 00000000..93a526dd --- /dev/null +++ b/scripts/expertise/expertise_sp_assassins_blade_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_assassins_blade_1') + + actor.addSkillMod('expertise_strikethrough_chance', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_assassins_blade_1') + + actor.removeSkillMod('expertise_strikethrough_chance', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_assassins_blade_2.py b/scripts/expertise/expertise_sp_assassins_blade_2.py new file mode 100644 index 00000000..ec05ff91 --- /dev/null +++ b/scripts/expertise/expertise_sp_assassins_blade_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_assassins_blade_2') + + actor.addSkillMod('expertise_strikethrough_chance', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_assassins_blade_2') + + actor.removeSkillMod('expertise_strikethrough_chance', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_assassins_blade_4.py b/scripts/expertise/expertise_sp_assassins_blade_4.py new file mode 100644 index 00000000..1c18ae9f --- /dev/null +++ b/scripts/expertise/expertise_sp_assassins_blade_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_assassins_blade_4') + + actor.addSkillMod('expertise_strikethrough_chance', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_assassins_blade_4') + + actor.removeSkillMod('expertise_strikethrough_chance', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_assassins_mark.py b/scripts/expertise/expertise_sp_assassins_mark.py new file mode 100644 index 00000000..c15c1096 --- /dev/null +++ b/scripts/expertise/expertise_sp_assassins_mark.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_assassins_mark') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_assassins_mark') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sp_assassins_mark') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sp_assassins_mark') + + return diff --git a/scripts/expertise/expertise_sp_avoid_damage_1.py b/scripts/expertise/expertise_sp_avoid_damage_1.py new file mode 100644 index 00000000..8e706bc7 --- /dev/null +++ b/scripts/expertise/expertise_sp_avoid_damage_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_avoid_damage_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_avoid_damage_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sp_avoid_damage') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sp_avoid_damage') + + return diff --git a/scripts/expertise/expertise_sp_burst_of_shadows_1.py b/scripts/expertise/expertise_sp_burst_of_shadows_1.py new file mode 100644 index 00000000..a15ceaf2 --- /dev/null +++ b/scripts/expertise/expertise_sp_burst_of_shadows_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_burst_of_shadows_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_burst_of_shadows_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sp_burst_of_shadows') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sp_burst_of_shadows') + + return diff --git a/scripts/expertise/expertise_sp_careful_observation_1.py b/scripts/expertise/expertise_sp_careful_observation_1.py new file mode 100644 index 00000000..16654a46 --- /dev/null +++ b/scripts/expertise/expertise_sp_careful_observation_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_careful_observation_1') + + actor.addSkillMod('detect_hidden', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_careful_observation_1') + + actor.removeSkillMod('detect_hidden', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_careful_observation_2.py b/scripts/expertise/expertise_sp_careful_observation_2.py new file mode 100644 index 00000000..24e1430f --- /dev/null +++ b/scripts/expertise/expertise_sp_careful_observation_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_careful_observation_2') + + actor.addSkillMod('detect_hidden', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_careful_observation_2') + + actor.removeSkillMod('detect_hidden', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_cheap_shots_1.py b/scripts/expertise/expertise_sp_cheap_shots_1.py new file mode 100644 index 00000000..25e6ce82 --- /dev/null +++ b/scripts/expertise/expertise_sp_cheap_shots_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_cheap_shots_1') + + actor.addSkillMod('expertise_action_weapon_ranged', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_cheap_shots_1') + + actor.removeSkillMod('expertise_action_weapon_ranged', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_cheap_shots_2.py b/scripts/expertise/expertise_sp_cheap_shots_2.py new file mode 100644 index 00000000..80c50bbd --- /dev/null +++ b/scripts/expertise/expertise_sp_cheap_shots_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_cheap_shots_2') + + actor.addSkillMod('expertise_action_weapon_ranged', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_cheap_shots_2') + + actor.removeSkillMod('expertise_action_weapon_ranged', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_cheap_shots_3.py b/scripts/expertise/expertise_sp_cheap_shots_3.py new file mode 100644 index 00000000..b109039c --- /dev/null +++ b/scripts/expertise/expertise_sp_cheap_shots_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_cheap_shots_3') + + actor.addSkillMod('expertise_action_weapon_ranged', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_cheap_shots_3') + + actor.removeSkillMod('expertise_action_weapon_ranged', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_cheap_shots_4.py b/scripts/expertise/expertise_sp_cheap_shots_4.py new file mode 100644 index 00000000..473d1c54 --- /dev/null +++ b/scripts/expertise/expertise_sp_cheap_shots_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_cheap_shots_4') + + actor.addSkillMod('expertise_action_weapon_ranged', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_cheap_shots_4') + + actor.removeSkillMod('expertise_action_weapon_ranged', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_cheap_strikes_1.py b/scripts/expertise/expertise_sp_cheap_strikes_1.py new file mode 100644 index 00000000..b32c86b8 --- /dev/null +++ b/scripts/expertise/expertise_sp_cheap_strikes_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_cheap_strikes_1') + + actor.addSkillMod('expertise_action_weapon_melee', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_cheap_strikes_1') + + actor.removeSkillMod('expertise_action_weapon_melee', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_cheap_strikes_2.py b/scripts/expertise/expertise_sp_cheap_strikes_2.py new file mode 100644 index 00000000..a88b5b7a --- /dev/null +++ b/scripts/expertise/expertise_sp_cheap_strikes_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_cheap_strikes_2') + + actor.addSkillMod('expertise_action_weapon_melee', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_cheap_strikes_2') + + actor.removeSkillMod('expertise_action_weapon_melee', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_cheap_strikes_3.py b/scripts/expertise/expertise_sp_cheap_strikes_3.py new file mode 100644 index 00000000..c3e9a8a0 --- /dev/null +++ b/scripts/expertise/expertise_sp_cheap_strikes_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_cheap_strikes_3') + + actor.addSkillMod('expertise_action_weapon_melee', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_cheap_strikes_3') + + actor.removeSkillMod('expertise_action_weapon_melee', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_cheap_strikes_4.py b/scripts/expertise/expertise_sp_cheap_strikes_4.py new file mode 100644 index 00000000..2f58d895 --- /dev/null +++ b/scripts/expertise/expertise_sp_cheap_strikes_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_cheap_strikes_4') + + actor.addSkillMod('expertise_action_weapon_melee', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_cheap_strikes_4') + + actor.removeSkillMod('expertise_action_weapon_melee', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_cloak_and_dagger_1.py b/scripts/expertise/expertise_sp_cloak_and_dagger_1.py new file mode 100644 index 00000000..f1333f00 --- /dev/null +++ b/scripts/expertise/expertise_sp_cloak_and_dagger_1.py @@ -0,0 +1,54 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_cloak_and_dagger_1') + + actor.addSkillMod('expertise_damage_line_sp_stealth_melee', 20) + actor.addSkillMod('expertise_damage_line_sp_stealth_ranged', 20) + actor.addSkillMod('expertise_dot_damage_line_sp_stealth_melee', 20) + actor.addSkillMod('expertise_dot_damage_line_sp_stealth_ranged', 20) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_cloak_and_dagger_1') + + actor.removeSkillMod('expertise_damage_line_sp_stealth_melee', 20) + actor.removeSkillMod('expertise_damage_line_sp_stealth_ranged', 20) + actor.removeSkillMod('expertise_dot_damage_line_sp_stealth_melee', 20) + actor.removeSkillMod('expertise_dot_damage_line_sp_stealth_ranged', 20) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_cloak_and_dagger_2.py b/scripts/expertise/expertise_sp_cloak_and_dagger_2.py new file mode 100644 index 00000000..f9ac5034 --- /dev/null +++ b/scripts/expertise/expertise_sp_cloak_and_dagger_2.py @@ -0,0 +1,54 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_cloak_and_dagger_2') + + actor.addSkillMod('expertise_damage_line_sp_stealth_melee', 20) + actor.addSkillMod('expertise_damage_line_sp_stealth_ranged', 20) + actor.addSkillMod('expertise_dot_damage_line_sp_stealth_melee', 20) + actor.addSkillMod('expertise_dot_damage_line_sp_stealth_ranged', 20) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_cloak_and_dagger_2') + + actor.removeSkillMod('expertise_damage_line_sp_stealth_melee', 20) + actor.removeSkillMod('expertise_damage_line_sp_stealth_ranged', 20) + actor.removeSkillMod('expertise_dot_damage_line_sp_stealth_melee', 20) + actor.removeSkillMod('expertise_dot_damage_line_sp_stealth_ranged', 20) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_cloak_and_dagger_3.py b/scripts/expertise/expertise_sp_cloak_and_dagger_3.py new file mode 100644 index 00000000..977c7b67 --- /dev/null +++ b/scripts/expertise/expertise_sp_cloak_and_dagger_3.py @@ -0,0 +1,54 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_cloak_and_dagger_3') + + actor.addSkillMod('expertise_damage_line_sp_stealth_melee', 20) + actor.addSkillMod('expertise_damage_line_sp_stealth_ranged', 20) + actor.addSkillMod('expertise_dot_damage_line_sp_stealth_melee', 20) + actor.addSkillMod('expertise_dot_damage_line_sp_stealth_ranged', 20) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_cloak_and_dagger_3') + + actor.removeSkillMod('expertise_damage_line_sp_stealth_melee', 20) + actor.removeSkillMod('expertise_damage_line_sp_stealth_ranged', 20) + actor.removeSkillMod('expertise_dot_damage_line_sp_stealth_melee', 20) + actor.removeSkillMod('expertise_dot_damage_line_sp_stealth_ranged', 20) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_cloak_and_dagger_4.py b/scripts/expertise/expertise_sp_cloak_and_dagger_4.py new file mode 100644 index 00000000..bc53f9a9 --- /dev/null +++ b/scripts/expertise/expertise_sp_cloak_and_dagger_4.py @@ -0,0 +1,54 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_cloak_and_dagger_4') + + actor.addSkillMod('expertise_damage_line_sp_stealth_melee', 20) + actor.addSkillMod('expertise_damage_line_sp_stealth_ranged', 20) + actor.addSkillMod('expertise_dot_damage_line_sp_stealth_melee', 20) + actor.addSkillMod('expertise_dot_damage_line_sp_stealth_ranged', 20) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_cloak_and_dagger_4') + + actor.removeSkillMod('expertise_damage_line_sp_stealth_melee', 20) + actor.removeSkillMod('expertise_damage_line_sp_stealth_ranged', 20) + actor.removeSkillMod('expertise_dot_damage_line_sp_stealth_melee', 20) + actor.removeSkillMod('expertise_dot_damage_line_sp_stealth_ranged', 20) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_cloaked_attacks_1.py b/scripts/expertise/expertise_sp_cloaked_attacks_1.py new file mode 100644 index 00000000..d96a977e --- /dev/null +++ b/scripts/expertise/expertise_sp_cloaked_attacks_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_cloaked_attacks_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_cloaked_attacks_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sp_ambush_snipe_0') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sp_ambush_snipe_0') + + return diff --git a/scripts/expertise/expertise_sp_cloaked_recovery_1.py b/scripts/expertise/expertise_sp_cloaked_recovery_1.py new file mode 100644 index 00000000..17e8cb25 --- /dev/null +++ b/scripts/expertise/expertise_sp_cloaked_recovery_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_cloaked_recovery_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_cloaked_recovery_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sp_cloaked_recovery_0') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sp_cloaked_recovery_0') + + return diff --git a/scripts/expertise/expertise_sp_cloaking_armor_1.py b/scripts/expertise/expertise_sp_cloaking_armor_1.py new file mode 100644 index 00000000..80d1afc1 --- /dev/null +++ b/scripts/expertise/expertise_sp_cloaking_armor_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_cloaking_armor_1') + + actor.addSkillMod('camouflage', 35) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_cloaking_armor_1') + + actor.removeSkillMod('camouflage', 35) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_cloaking_armor_2.py b/scripts/expertise/expertise_sp_cloaking_armor_2.py new file mode 100644 index 00000000..79cb0d6f --- /dev/null +++ b/scripts/expertise/expertise_sp_cloaking_armor_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_cloaking_armor_2') + + actor.addSkillMod('camouflage', 40) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_cloaking_armor_2') + + actor.removeSkillMod('camouflage', 40) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_close_quarters_1.py b/scripts/expertise/expertise_sp_close_quarters_1.py new file mode 100644 index 00000000..7f47d8c4 --- /dev/null +++ b/scripts/expertise/expertise_sp_close_quarters_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_close_quarters_1') + + actor.addSkillMod('expertise_damage_melee', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_close_quarters_1') + + actor.removeSkillMod('expertise_damage_melee', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_close_quarters_2.py b/scripts/expertise/expertise_sp_close_quarters_2.py new file mode 100644 index 00000000..11685e64 --- /dev/null +++ b/scripts/expertise/expertise_sp_close_quarters_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_close_quarters_2') + + actor.addSkillMod('expertise_damage_melee', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_close_quarters_2') + + actor.removeSkillMod('expertise_damage_melee', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_close_quarters_3.py b/scripts/expertise/expertise_sp_close_quarters_3.py new file mode 100644 index 00000000..ee025e54 --- /dev/null +++ b/scripts/expertise/expertise_sp_close_quarters_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_close_quarters_3') + + actor.addSkillMod('expertise_damage_melee', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_close_quarters_3') + + actor.removeSkillMod('expertise_damage_melee', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_covert_mastery_1.py b/scripts/expertise/expertise_sp_covert_mastery_1.py new file mode 100644 index 00000000..114d70b6 --- /dev/null +++ b/scripts/expertise/expertise_sp_covert_mastery_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_covert_mastery_1') + + actor.addSkillMod('expertise_covert_mastery', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_covert_mastery_1') + + actor.removeSkillMod('expertise_covert_mastery', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_crippling_traps_1.py b/scripts/expertise/expertise_sp_crippling_traps_1.py new file mode 100644 index 00000000..9189c956 --- /dev/null +++ b/scripts/expertise/expertise_sp_crippling_traps_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_crippling_traps_1') + + actor.addSkillMod('expertise_sp_cripple_trap_proc_increase', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_crippling_traps_1') + + actor.removeSkillMod('expertise_sp_cripple_trap_proc_increase', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_crippling_traps_2.py b/scripts/expertise/expertise_sp_crippling_traps_2.py new file mode 100644 index 00000000..c7b2170e --- /dev/null +++ b/scripts/expertise/expertise_sp_crippling_traps_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_crippling_traps_2') + + actor.addSkillMod('expertise_sp_cripple_trap_proc_increase', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_crippling_traps_2') + + actor.removeSkillMod('expertise_sp_cripple_trap_proc_increase', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_deadly_pistols_1.py b/scripts/expertise/expertise_sp_deadly_pistols_1.py new file mode 100644 index 00000000..fc98249a --- /dev/null +++ b/scripts/expertise/expertise_sp_deadly_pistols_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_deadly_pistols_1') + + actor.addSkillMod('expertise_damage_ranged', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_deadly_pistols_1') + + actor.removeSkillMod('expertise_damage_ranged', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_deadly_pistols_2.py b/scripts/expertise/expertise_sp_deadly_pistols_2.py new file mode 100644 index 00000000..6f51bb5e --- /dev/null +++ b/scripts/expertise/expertise_sp_deadly_pistols_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_deadly_pistols_2') + + actor.addSkillMod('expertise_damage_ranged', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_deadly_pistols_2') + + actor.removeSkillMod('expertise_damage_ranged', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_deadly_pistols_3.py b/scripts/expertise/expertise_sp_deadly_pistols_3.py new file mode 100644 index 00000000..2e75294c --- /dev/null +++ b/scripts/expertise/expertise_sp_deadly_pistols_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_deadly_pistols_3') + + actor.addSkillMod('expertise_damage_ranged', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_deadly_pistols_3') + + actor.removeSkillMod('expertise_damage_ranged', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_deadly_toxins_1.py b/scripts/expertise/expertise_sp_deadly_toxins_1.py new file mode 100644 index 00000000..7e8dc0c9 --- /dev/null +++ b/scripts/expertise/expertise_sp_deadly_toxins_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_deadly_toxins_1') + + actor.addSkillMod('expertise_critical_line_fldmot', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_deadly_toxins_1') + + actor.removeSkillMod('expertise_critical_line_fldmot', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_deadly_toxins_2.py b/scripts/expertise/expertise_sp_deadly_toxins_2.py new file mode 100644 index 00000000..1995b0dc --- /dev/null +++ b/scripts/expertise/expertise_sp_deadly_toxins_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_deadly_toxins_2') + + actor.addSkillMod('expertise_critical_line_fldmot', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_deadly_toxins_2') + + actor.removeSkillMod('expertise_critical_line_fldmot', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_decoy_1.py b/scripts/expertise/expertise_sp_decoy_1.py new file mode 100644 index 00000000..4888c20c --- /dev/null +++ b/scripts/expertise/expertise_sp_decoy_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_decoy_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_decoy_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sp_decoy') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sp_decoy') + + return diff --git a/scripts/expertise/expertise_sp_diversion_1.py b/scripts/expertise/expertise_sp_diversion_1.py new file mode 100644 index 00000000..aa564906 --- /dev/null +++ b/scripts/expertise/expertise_sp_diversion_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_diversion_1') + + actor.addSkillMod('expertise_improved_decoy', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_diversion_1') + + actor.removeSkillMod('expertise_improved_decoy', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_diversion_2.py b/scripts/expertise/expertise_sp_diversion_2.py new file mode 100644 index 00000000..d8b6c134 --- /dev/null +++ b/scripts/expertise/expertise_sp_diversion_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_diversion_2') + + actor.addSkillMod('expertise_improved_decoy', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_diversion_2') + + actor.removeSkillMod('expertise_improved_decoy', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_equilibrium.py b/scripts/expertise/expertise_sp_equilibrium.py new file mode 100644 index 00000000..d42cdb4d --- /dev/null +++ b/scripts/expertise/expertise_sp_equilibrium.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_equilibrium') + + actor.addSkillMod('freeshot_case_miss', 1) + actor.addSkillMod('freeshot_case_dodge', 1) + actor.addSkillMod('freeshot_case_parry', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_equilibrium') + + actor.removeSkillMod('freeshot_case_miss', 1) + actor.removeSkillMod('freeshot_case_dodge', 1) + actor.removeSkillMod('freeshot_case_parry', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_expose_shadows_1.py b/scripts/expertise/expertise_sp_expose_shadows_1.py new file mode 100644 index 00000000..4b08472a --- /dev/null +++ b/scripts/expertise/expertise_sp_expose_shadows_1.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_expose_shadows_1') + + actor.addSkillMod('expertise_sp_reveal_shadows_distance_increase', 5) + actor.addSkillMod('expertise_sp_reveal_shadows_detect_chance_increase', 3) + actor.addSkillMod('expertise_cooldown_line_sp_reveal_shadows', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_expose_shadows_1') + + actor.removeSkillMod('expertise_sp_reveal_shadows_distance_increase', 5) + actor.removeSkillMod('expertise_sp_reveal_shadows_detect_chance_increase', 3) + actor.removeSkillMod('expertise_cooldown_line_sp_reveal_shadows', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_expose_shadows_2.py b/scripts/expertise/expertise_sp_expose_shadows_2.py new file mode 100644 index 00000000..79a4cf58 --- /dev/null +++ b/scripts/expertise/expertise_sp_expose_shadows_2.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_expose_shadows_2') + + actor.addSkillMod('expertise_sp_reveal_shadows_distance_increase', 5) + actor.addSkillMod('expertise_sp_reveal_shadows_detect_chance_increase', 3) + actor.addSkillMod('expertise_cooldown_line_sp_reveal_shadows', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_expose_shadows_2') + + actor.removeSkillMod('expertise_sp_reveal_shadows_distance_increase', 5) + actor.removeSkillMod('expertise_sp_reveal_shadows_detect_chance_increase', 3) + actor.removeSkillMod('expertise_cooldown_line_sp_reveal_shadows', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_expose_shadows_3.py b/scripts/expertise/expertise_sp_expose_shadows_3.py new file mode 100644 index 00000000..648a6cb4 --- /dev/null +++ b/scripts/expertise/expertise_sp_expose_shadows_3.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_expose_shadows_3') + + actor.addSkillMod('expertise_sp_reveal_shadows_distance_increase', 5) + actor.addSkillMod('expertise_sp_reveal_shadows_detect_chance_increase', 3) + actor.addSkillMod('expertise_cooldown_line_sp_reveal_shadows', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_expose_shadows_3') + + actor.removeSkillMod('expertise_sp_reveal_shadows_distance_increase', 5) + actor.removeSkillMod('expertise_sp_reveal_shadows_detect_chance_increase', 3) + actor.removeSkillMod('expertise_cooldown_line_sp_reveal_shadows', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_expose_shadows_4.py b/scripts/expertise/expertise_sp_expose_shadows_4.py new file mode 100644 index 00000000..cce077b5 --- /dev/null +++ b/scripts/expertise/expertise_sp_expose_shadows_4.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_expose_shadows_4') + + actor.addSkillMod('expertise_sp_reveal_shadows_distance_increase', 5) + actor.addSkillMod('expertise_sp_reveal_shadows_detect_chance_increase', 3) + actor.addSkillMod('expertise_cooldown_line_sp_reveal_shadows', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_expose_shadows_4') + + actor.removeSkillMod('expertise_sp_reveal_shadows_distance_increase', 5) + actor.removeSkillMod('expertise_sp_reveal_shadows_detect_chance_increase', 3) + actor.removeSkillMod('expertise_cooldown_line_sp_reveal_shadows', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_glancing_armor_1.py b/scripts/expertise/expertise_sp_glancing_armor_1.py new file mode 100644 index 00000000..2bc35f22 --- /dev/null +++ b/scripts/expertise/expertise_sp_glancing_armor_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_glancing_armor_1') + + actor.addSkillMod('expertise_dodge', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_glancing_armor_1') + + actor.removeSkillMod('expertise_dodge', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_glancing_armor_2.py b/scripts/expertise/expertise_sp_glancing_armor_2.py new file mode 100644 index 00000000..84e0e50d --- /dev/null +++ b/scripts/expertise/expertise_sp_glancing_armor_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_glancing_armor_2') + + actor.addSkillMod('expertise_dodge', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_glancing_armor_2') + + actor.removeSkillMod('expertise_dodge', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_hidden_daggers_1.py b/scripts/expertise/expertise_sp_hidden_daggers_1.py new file mode 100644 index 00000000..2b947a0c --- /dev/null +++ b/scripts/expertise/expertise_sp_hidden_daggers_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_hidden_daggers_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_hidden_daggers_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sp_hd_ability_0') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sp_hd_ability_0') + + return diff --git a/scripts/expertise/expertise_sp_improved_first_aid_1.py b/scripts/expertise/expertise_sp_improved_first_aid_1.py new file mode 100644 index 00000000..302ef8e0 --- /dev/null +++ b/scripts/expertise/expertise_sp_improved_first_aid_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_improved_first_aid_1') + + actor.addSkillMod('expertise_target_healing_bonus', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_improved_first_aid_1') + + actor.removeSkillMod('expertise_target_healing_bonus', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_improved_first_aid_2.py b/scripts/expertise/expertise_sp_improved_first_aid_2.py new file mode 100644 index 00000000..5c810822 --- /dev/null +++ b/scripts/expertise/expertise_sp_improved_first_aid_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_improved_first_aid_2') + + actor.addSkillMod('expertise_target_healing_bonus', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_improved_first_aid_2') + + actor.removeSkillMod('expertise_target_healing_bonus', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_improved_spys_fang_1.py b/scripts/expertise/expertise_sp_improved_spys_fang_1.py new file mode 100644 index 00000000..a91bbc75 --- /dev/null +++ b/scripts/expertise/expertise_sp_improved_spys_fang_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_improved_spys_fang_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_improved_spys_fang_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sp_dot_0') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sp_dot_0') + + return diff --git a/scripts/expertise/expertise_sp_increased_agility_1.py b/scripts/expertise/expertise_sp_increased_agility_1.py new file mode 100644 index 00000000..e3c8d957 --- /dev/null +++ b/scripts/expertise/expertise_sp_increased_agility_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_increased_agility_1') + + actor.addSkillMod('agility_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_increased_agility_1') + + actor.removeSkillMod('agility_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_increased_agility_2.py b/scripts/expertise/expertise_sp_increased_agility_2.py new file mode 100644 index 00000000..b5728cc0 --- /dev/null +++ b/scripts/expertise/expertise_sp_increased_agility_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_increased_agility_2') + + actor.addSkillMod('agility_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_increased_agility_2') + + actor.removeSkillMod('agility_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_increased_strength_1.py b/scripts/expertise/expertise_sp_increased_strength_1.py new file mode 100644 index 00000000..005cf60d --- /dev/null +++ b/scripts/expertise/expertise_sp_increased_strength_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_increased_strength_1') + + actor.addSkillMod('strength_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_increased_strength_1') + + actor.removeSkillMod('strength_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_increased_strength_2.py b/scripts/expertise/expertise_sp_increased_strength_2.py new file mode 100644 index 00000000..16b7b90f --- /dev/null +++ b/scripts/expertise/expertise_sp_increased_strength_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_increased_strength_2') + + actor.addSkillMod('strength_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_increased_strength_2') + + actor.removeSkillMod('strength_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_initiative_1.py b/scripts/expertise/expertise_sp_initiative_1.py new file mode 100644 index 00000000..edb3db3d --- /dev/null +++ b/scripts/expertise/expertise_sp_initiative_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_initiative_1') + + actor.addSkillMod('expertise_critical_line_sp_stealth_melee', 15) + actor.addSkillMod('expertise_critical_line_sp_stealth_ranged', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_initiative_1') + + actor.removeSkillMod('expertise_critical_line_sp_stealth_melee', 15) + actor.removeSkillMod('expertise_critical_line_sp_stealth_ranged', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_initiative_2.py b/scripts/expertise/expertise_sp_initiative_2.py new file mode 100644 index 00000000..fefb02bf --- /dev/null +++ b/scripts/expertise/expertise_sp_initiative_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_initiative_2') + + actor.addSkillMod('expertise_critical_line_sp_stealth_melee', 15) + actor.addSkillMod('expertise_critical_line_sp_stealth_ranged', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_initiative_2') + + actor.removeSkillMod('expertise_critical_line_sp_stealth_melee', 15) + actor.removeSkillMod('expertise_critical_line_sp_stealth_ranged', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_initiative_3.py b/scripts/expertise/expertise_sp_initiative_3.py new file mode 100644 index 00000000..56a20d27 --- /dev/null +++ b/scripts/expertise/expertise_sp_initiative_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_initiative_3') + + actor.addSkillMod('expertise_critical_line_sp_stealth_melee', 15) + actor.addSkillMod('expertise_critical_line_sp_stealth_ranged', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_initiative_3') + + actor.removeSkillMod('expertise_critical_line_sp_stealth_melee', 15) + actor.removeSkillMod('expertise_critical_line_sp_stealth_ranged', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_initiative_4.py b/scripts/expertise/expertise_sp_initiative_4.py new file mode 100644 index 00000000..a3847b2a --- /dev/null +++ b/scripts/expertise/expertise_sp_initiative_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_initiative_4') + + actor.addSkillMod('expertise_critical_line_sp_stealth_melee', 15) + actor.addSkillMod('expertise_critical_line_sp_stealth_ranged', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_initiative_4') + + actor.removeSkillMod('expertise_critical_line_sp_stealth_melee', 15) + actor.removeSkillMod('expertise_critical_line_sp_stealth_ranged', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_jagged_edge_1.py b/scripts/expertise/expertise_sp_jagged_edge_1.py new file mode 100644 index 00000000..3b094630 --- /dev/null +++ b/scripts/expertise/expertise_sp_jagged_edge_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_jagged_edge_1') + + actor.addSkillMod('expertise_critical_damage_increase', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_jagged_edge_1') + + actor.removeSkillMod('expertise_critical_damage_increase', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_jagged_edge_2.py b/scripts/expertise/expertise_sp_jagged_edge_2.py new file mode 100644 index 00000000..b63c3a03 --- /dev/null +++ b/scripts/expertise/expertise_sp_jagged_edge_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_jagged_edge_2') + + actor.addSkillMod('expertise_critical_damage_increase', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_jagged_edge_2') + + actor.removeSkillMod('expertise_critical_damage_increase', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_jagged_edge_3.py b/scripts/expertise/expertise_sp_jagged_edge_3.py new file mode 100644 index 00000000..467a8ecb --- /dev/null +++ b/scripts/expertise/expertise_sp_jagged_edge_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_jagged_edge_3') + + actor.addSkillMod('expertise_critical_damage_increase', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_jagged_edge_3') + + actor.removeSkillMod('expertise_critical_damage_increase', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_noxious_traps_1.py b/scripts/expertise/expertise_sp_noxious_traps_1.py new file mode 100644 index 00000000..6bdcfe7d --- /dev/null +++ b/scripts/expertise/expertise_sp_noxious_traps_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_noxious_traps_1') + + actor.addSkillMod('expertise_damage_line_fldmot', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_noxious_traps_1') + + actor.removeSkillMod('expertise_damage_line_fldmot', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_noxious_traps_2.py b/scripts/expertise/expertise_sp_noxious_traps_2.py new file mode 100644 index 00000000..27dbf617 --- /dev/null +++ b/scripts/expertise/expertise_sp_noxious_traps_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_noxious_traps_2') + + actor.addSkillMod('expertise_damage_line_fldmot', 15) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_noxious_traps_2') + + actor.removeSkillMod('expertise_damage_line_fldmot', 15) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_opportunity_1.py b/scripts/expertise/expertise_sp_opportunity_1.py new file mode 100644 index 00000000..a775b549 --- /dev/null +++ b/scripts/expertise/expertise_sp_opportunity_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_opportunity_1') + + actor.addSkillMod('expertise_critical_niche_all', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_opportunity_1') + + actor.removeSkillMod('expertise_critical_niche_all', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_opportunity_2.py b/scripts/expertise/expertise_sp_opportunity_2.py new file mode 100644 index 00000000..d8a596ae --- /dev/null +++ b/scripts/expertise/expertise_sp_opportunity_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_opportunity_2') + + actor.addSkillMod('expertise_critical_niche_all', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_opportunity_2') + + actor.removeSkillMod('expertise_critical_niche_all', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_opportunity_3.py b/scripts/expertise/expertise_sp_opportunity_3.py new file mode 100644 index 00000000..92872b63 --- /dev/null +++ b/scripts/expertise/expertise_sp_opportunity_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_opportunity_3') + + actor.addSkillMod('expertise_critical_niche_all', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_opportunity_3') + + actor.removeSkillMod('expertise_critical_niche_all', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_opportunity_4.py b/scripts/expertise/expertise_sp_opportunity_4.py new file mode 100644 index 00000000..021557d0 --- /dev/null +++ b/scripts/expertise/expertise_sp_opportunity_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_opportunity_4') + + actor.addSkillMod('expertise_critical_niche_all', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_opportunity_4') + + actor.removeSkillMod('expertise_critical_niche_all', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_precision_1.py b/scripts/expertise/expertise_sp_precision_1.py new file mode 100644 index 00000000..0838078e --- /dev/null +++ b/scripts/expertise/expertise_sp_precision_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_precision_1') + + actor.addSkillMod('precision_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_precision_1') + + actor.removeSkillMod('precision_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_precision_2.py b/scripts/expertise/expertise_sp_precision_2.py new file mode 100644 index 00000000..646d2555 --- /dev/null +++ b/scripts/expertise/expertise_sp_precision_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_precision_2') + + actor.addSkillMod('precision_modified', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_precision_2') + + actor.removeSkillMod('precision_modified', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_preparation_1.py b/scripts/expertise/expertise_sp_preparation_1.py new file mode 100644 index 00000000..f9642ef1 --- /dev/null +++ b/scripts/expertise/expertise_sp_preparation_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_preparation_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_preparation_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sp_preparation') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sp_preparation') + + return diff --git a/scripts/expertise/expertise_sp_protective_armor_1.py b/scripts/expertise/expertise_sp_protective_armor_1.py new file mode 100644 index 00000000..cc1f4fce --- /dev/null +++ b/scripts/expertise/expertise_sp_protective_armor_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_protective_armor_1') + + actor.addSkillMod('expertise_innate_protection_kinetic', 300) + actor.addSkillMod('expertise_innate_protection_energy', 300) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_protective_armor_1') + + actor.removeSkillMod('expertise_innate_protection_kinetic', 300) + actor.removeSkillMod('expertise_innate_protection_energy', 300) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_protective_armor_2.py b/scripts/expertise/expertise_sp_protective_armor_2.py new file mode 100644 index 00000000..d28b98fa --- /dev/null +++ b/scripts/expertise/expertise_sp_protective_armor_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_protective_armor_2') + + actor.addSkillMod('expertise_innate_protection_kinetic', 300) + actor.addSkillMod('expertise_innate_protection_energy', 300) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_protective_armor_2') + + actor.removeSkillMod('expertise_innate_protection_kinetic', 300) + actor.removeSkillMod('expertise_innate_protection_energy', 300) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_protective_armor_3.py b/scripts/expertise/expertise_sp_protective_armor_3.py new file mode 100644 index 00000000..362cf151 --- /dev/null +++ b/scripts/expertise/expertise_sp_protective_armor_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_protective_armor_3') + + actor.addSkillMod('expertise_innate_protection_kinetic', 300) + actor.addSkillMod('expertise_innate_protection_energy', 300) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_protective_armor_3') + + actor.removeSkillMod('expertise_innate_protection_kinetic', 300) + actor.removeSkillMod('expertise_innate_protection_energy', 300) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_protective_armor_4.py b/scripts/expertise/expertise_sp_protective_armor_4.py new file mode 100644 index 00000000..217d1cf2 --- /dev/null +++ b/scripts/expertise/expertise_sp_protective_armor_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_protective_armor_4') + + actor.addSkillMod('expertise_innate_protection_kinetic', 300) + actor.addSkillMod('expertise_innate_protection_energy', 300) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_protective_armor_4') + + actor.removeSkillMod('expertise_innate_protection_kinetic', 300) + actor.removeSkillMod('expertise_innate_protection_energy', 300) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_puncturing_strikes_1.py b/scripts/expertise/expertise_sp_puncturing_strikes_1.py new file mode 100644 index 00000000..b6a49540 --- /dev/null +++ b/scripts/expertise/expertise_sp_puncturing_strikes_1.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_puncturing_strikes_1') + + actor.addSkillMod('expertise_damage_line_sp_stealth_melee', 10) + actor.addSkillMod('expertise_damage_line_sp_hd_melee', 10) + actor.addSkillMod('expertise_damage_line_sp_stealth_ranged', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_puncturing_strikes_1') + + actor.removeSkillMod('expertise_damage_line_sp_stealth_melee', 10) + actor.removeSkillMod('expertise_damage_line_sp_hd_melee', 10) + actor.removeSkillMod('expertise_damage_line_sp_stealth_ranged', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_puncturing_strikes_2.py b/scripts/expertise/expertise_sp_puncturing_strikes_2.py new file mode 100644 index 00000000..9b72c541 --- /dev/null +++ b/scripts/expertise/expertise_sp_puncturing_strikes_2.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_puncturing_strikes_2') + + actor.addSkillMod('expertise_damage_line_sp_stealth_melee', 10) + actor.addSkillMod('expertise_damage_line_sp_hd_melee', 10) + actor.addSkillMod('expertise_damage_line_sp_stealth_ranged', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_puncturing_strikes_2') + + actor.removeSkillMod('expertise_damage_line_sp_stealth_melee', 10) + actor.removeSkillMod('expertise_damage_line_sp_hd_melee', 10) + actor.removeSkillMod('expertise_damage_line_sp_stealth_ranged', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_puncturing_strikes_3.py b/scripts/expertise/expertise_sp_puncturing_strikes_3.py new file mode 100644 index 00000000..f744abd6 --- /dev/null +++ b/scripts/expertise/expertise_sp_puncturing_strikes_3.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_puncturing_strikes_3') + + actor.addSkillMod('expertise_damage_line_sp_stealth_melee', 10) + actor.addSkillMod('expertise_damage_line_sp_hd_melee', 10) + actor.addSkillMod('expertise_damage_line_sp_stealth_ranged', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_puncturing_strikes_3') + + actor.removeSkillMod('expertise_damage_line_sp_stealth_melee', 10) + actor.removeSkillMod('expertise_damage_line_sp_hd_melee', 10) + actor.removeSkillMod('expertise_damage_line_sp_stealth_ranged', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_puncturing_strikes_4.py b/scripts/expertise/expertise_sp_puncturing_strikes_4.py new file mode 100644 index 00000000..4ff64223 --- /dev/null +++ b/scripts/expertise/expertise_sp_puncturing_strikes_4.py @@ -0,0 +1,52 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_puncturing_strikes_4') + + actor.addSkillMod('expertise_damage_line_sp_stealth_melee', 10) + actor.addSkillMod('expertise_damage_line_sp_hd_melee', 10) + actor.addSkillMod('expertise_damage_line_sp_stealth_ranged', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_puncturing_strikes_4') + + actor.removeSkillMod('expertise_damage_line_sp_stealth_melee', 10) + actor.removeSkillMod('expertise_damage_line_sp_hd_melee', 10) + actor.removeSkillMod('expertise_damage_line_sp_stealth_ranged', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_quiet_steps_1.py b/scripts/expertise/expertise_sp_quiet_steps_1.py new file mode 100644 index 00000000..bf0844a0 --- /dev/null +++ b/scripts/expertise/expertise_sp_quiet_steps_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_quiet_steps_1') + + actor.addSkillMod('expertise_avoidance_overpower', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_quiet_steps_1') + + actor.removeSkillMod('expertise_avoidance_overpower', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_quiet_steps_2.py b/scripts/expertise/expertise_sp_quiet_steps_2.py new file mode 100644 index 00000000..e9cee417 --- /dev/null +++ b/scripts/expertise/expertise_sp_quiet_steps_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_quiet_steps_2') + + actor.addSkillMod('expertise_avoidance_overpower', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_quiet_steps_2') + + actor.removeSkillMod('expertise_avoidance_overpower', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_rapid_concealment_1.py b/scripts/expertise/expertise_sp_rapid_concealment_1.py new file mode 100644 index 00000000..a2e0ad1a --- /dev/null +++ b/scripts/expertise/expertise_sp_rapid_concealment_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_rapid_concealment_1') + + actor.addSkillMod('expertise_cooldown_line_sp_smoke', 30) + actor.addSkillMod('expertise_cooldown_line_sp_burst_shadows', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_rapid_concealment_1') + + actor.removeSkillMod('expertise_cooldown_line_sp_smoke', 30) + actor.removeSkillMod('expertise_cooldown_line_sp_burst_shadows', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_rapid_concealment_2.py b/scripts/expertise/expertise_sp_rapid_concealment_2.py new file mode 100644 index 00000000..7ab413ab --- /dev/null +++ b/scripts/expertise/expertise_sp_rapid_concealment_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_rapid_concealment_2') + + actor.addSkillMod('expertise_cooldown_line_sp_smoke', 30) + actor.addSkillMod('expertise_cooldown_line_sp_burst_shadows', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_rapid_concealment_2') + + actor.removeSkillMod('expertise_cooldown_line_sp_smoke', 30) + actor.removeSkillMod('expertise_cooldown_line_sp_burst_shadows', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_rapid_concealment_3.py b/scripts/expertise/expertise_sp_rapid_concealment_3.py new file mode 100644 index 00000000..d8cc0332 --- /dev/null +++ b/scripts/expertise/expertise_sp_rapid_concealment_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_rapid_concealment_3') + + actor.addSkillMod('expertise_cooldown_line_sp_smoke', 30) + actor.addSkillMod('expertise_cooldown_line_sp_burst_shadows', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_rapid_concealment_3') + + actor.removeSkillMod('expertise_cooldown_line_sp_smoke', 30) + actor.removeSkillMod('expertise_cooldown_line_sp_burst_shadows', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_rapid_concealment_4.py b/scripts/expertise/expertise_sp_rapid_concealment_4.py new file mode 100644 index 00000000..179d007a --- /dev/null +++ b/scripts/expertise/expertise_sp_rapid_concealment_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_rapid_concealment_4') + + actor.addSkillMod('expertise_cooldown_line_sp_smoke', 30) + actor.addSkillMod('expertise_cooldown_line_sp_burst_shadows', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_rapid_concealment_4') + + actor.removeSkillMod('expertise_cooldown_line_sp_smoke', 30) + actor.removeSkillMod('expertise_cooldown_line_sp_burst_shadows', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_resonance.py b/scripts/expertise/expertise_sp_resonance.py new file mode 100644 index 00000000..1f0fd64c --- /dev/null +++ b/scripts/expertise/expertise_sp_resonance.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_resonance') + + actor.addSkillMod('expertise_onstrikethrough_proc_sp_resonance', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_resonance') + + actor.removeSkillMod('expertise_onstrikethrough_proc_sp_resonance', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_reveal_shadows_1.py b/scripts/expertise/expertise_sp_reveal_shadows_1.py new file mode 100644 index 00000000..12bd2510 --- /dev/null +++ b/scripts/expertise/expertise_sp_reveal_shadows_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_reveal_shadows_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_reveal_shadows_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sp_reveal_shadows') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sp_reveal_shadows') + + return diff --git a/scripts/expertise/expertise_sp_run_its_course_1.py b/scripts/expertise/expertise_sp_run_its_course_1.py new file mode 100644 index 00000000..15365503 --- /dev/null +++ b/scripts/expertise/expertise_sp_run_its_course_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_run_its_course_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_run_its_course_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sp_run_its_course') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sp_run_its_course') + + return diff --git a/scripts/expertise/expertise_sp_savagery.py b/scripts/expertise/expertise_sp_savagery.py new file mode 100644 index 00000000..fce6867c --- /dev/null +++ b/scripts/expertise/expertise_sp_savagery.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_savagery') + + actor.addSkillMod('expertise_oncrit_proc_sp_savagery', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_savagery') + + actor.removeSkillMod('expertise_oncrit_proc_sp_savagery', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_shadows_embrace_1.py b/scripts/expertise/expertise_sp_shadows_embrace_1.py new file mode 100644 index 00000000..8acb23d6 --- /dev/null +++ b/scripts/expertise/expertise_sp_shadows_embrace_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_shadows_embrace_1') + + actor.addSkillMod('expertise_buff_duration_line_sp_burst_shadows', 2) + actor.addSkillMod('expertise_cooldown_line_sp_burst_shadows', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_shadows_embrace_1') + + actor.removeSkillMod('expertise_buff_duration_line_sp_burst_shadows', 2) + actor.removeSkillMod('expertise_cooldown_line_sp_burst_shadows', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_shadows_embrace_2.py b/scripts/expertise/expertise_sp_shadows_embrace_2.py new file mode 100644 index 00000000..7f894561 --- /dev/null +++ b/scripts/expertise/expertise_sp_shadows_embrace_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_shadows_embrace_2') + + actor.addSkillMod('expertise_buff_duration_line_sp_burst_shadows', 2) + actor.addSkillMod('expertise_cooldown_line_sp_burst_shadows', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_shadows_embrace_2') + + actor.removeSkillMod('expertise_buff_duration_line_sp_burst_shadows', 2) + actor.removeSkillMod('expertise_cooldown_line_sp_burst_shadows', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_shadows_embrace_3.py b/scripts/expertise/expertise_sp_shadows_embrace_3.py new file mode 100644 index 00000000..ab5023c0 --- /dev/null +++ b/scripts/expertise/expertise_sp_shadows_embrace_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_shadows_embrace_3') + + actor.addSkillMod('expertise_buff_duration_line_sp_burst_shadows', 2) + actor.addSkillMod('expertise_cooldown_line_sp_burst_shadows', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_shadows_embrace_3') + + actor.removeSkillMod('expertise_buff_duration_line_sp_burst_shadows', 2) + actor.removeSkillMod('expertise_cooldown_line_sp_burst_shadows', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_shadows_embrace_4.py b/scripts/expertise/expertise_sp_shadows_embrace_4.py new file mode 100644 index 00000000..a98522ee --- /dev/null +++ b/scripts/expertise/expertise_sp_shadows_embrace_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_shadows_embrace_4') + + actor.addSkillMod('expertise_buff_duration_line_sp_burst_shadows', 2) + actor.addSkillMod('expertise_cooldown_line_sp_burst_shadows', 30) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_shadows_embrace_4') + + actor.removeSkillMod('expertise_buff_duration_line_sp_burst_shadows', 2) + actor.removeSkillMod('expertise_cooldown_line_sp_burst_shadows', 30) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_shifty_setup_1.py b/scripts/expertise/expertise_sp_shifty_setup_1.py new file mode 100644 index 00000000..90865851 --- /dev/null +++ b/scripts/expertise/expertise_sp_shifty_setup_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_shifty_setup_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_shifty_setup_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sp_shifty_setup') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sp_shifty_setup') + + return diff --git a/scripts/expertise/expertise_sp_smoke_mirrors.py b/scripts/expertise/expertise_sp_smoke_mirrors.py new file mode 100644 index 00000000..5e88dd3e --- /dev/null +++ b/scripts/expertise/expertise_sp_smoke_mirrors.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_smoke_mirrors') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_smoke_mirrors') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + actor.addAbility('sp_smoke_mirrors') + + return + +def removeAbilities(core, actor, player): + + actor.removeAbility('sp_smoke_mirrors') + + return diff --git a/scripts/expertise/expertise_sp_smoke_screen_1.py b/scripts/expertise/expertise_sp_smoke_screen_1.py new file mode 100644 index 00000000..1deb5789 --- /dev/null +++ b/scripts/expertise/expertise_sp_smoke_screen_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_smoke_screen_1') + + actor.addSkillMod('expertise_movement_buff_invis_sp_buff_invis_1', -10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_smoke_screen_1') + + actor.removeSkillMod('expertise_movement_buff_invis_sp_buff_invis_1', -10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_smoke_screen_2.py b/scripts/expertise/expertise_sp_smoke_screen_2.py new file mode 100644 index 00000000..e091741b --- /dev/null +++ b/scripts/expertise/expertise_sp_smoke_screen_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_smoke_screen_2') + + actor.addSkillMod('expertise_movement_buff_invis_sp_buff_invis_1', -10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_smoke_screen_2') + + actor.removeSkillMod('expertise_movement_buff_invis_sp_buff_invis_1', -10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_smoke_screen_3.py b/scripts/expertise/expertise_sp_smoke_screen_3.py new file mode 100644 index 00000000..c8ba6991 --- /dev/null +++ b/scripts/expertise/expertise_sp_smoke_screen_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_smoke_screen_3') + + actor.addSkillMod('expertise_movement_buff_invis_sp_buff_invis_1', -10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_smoke_screen_3') + + actor.removeSkillMod('expertise_movement_buff_invis_sp_buff_invis_1', -10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_smoke_screen_4.py b/scripts/expertise/expertise_sp_smoke_screen_4.py new file mode 100644 index 00000000..f4f00aa4 --- /dev/null +++ b/scripts/expertise/expertise_sp_smoke_screen_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_smoke_screen_4') + + actor.addSkillMod('expertise_movement_buff_invis_sp_buff_invis_1', -10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_smoke_screen_4') + + actor.removeSkillMod('expertise_movement_buff_invis_sp_buff_invis_1', -10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_steup_1.py b/scripts/expertise/expertise_sp_steup_1.py new file mode 100644 index 00000000..b039c564 --- /dev/null +++ b/scripts/expertise/expertise_sp_steup_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_steup_1') + + actor.addSkillMod('expertise_action_line_sp_stealth_melee', 5) + actor.addSkillMod('expertise_action_line_sp_stealth_ranged', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_steup_1') + + actor.removeSkillMod('expertise_action_line_sp_stealth_melee', 5) + actor.removeSkillMod('expertise_action_line_sp_stealth_ranged', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_steup_2.py b/scripts/expertise/expertise_sp_steup_2.py new file mode 100644 index 00000000..9450fa6a --- /dev/null +++ b/scripts/expertise/expertise_sp_steup_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_steup_2') + + actor.addSkillMod('expertise_action_line_sp_stealth_melee', 5) + actor.addSkillMod('expertise_action_line_sp_stealth_ranged', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_steup_2') + + actor.removeSkillMod('expertise_action_line_sp_stealth_melee', 5) + actor.removeSkillMod('expertise_action_line_sp_stealth_ranged', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_steup_3.py b/scripts/expertise/expertise_sp_steup_3.py new file mode 100644 index 00000000..d0b36017 --- /dev/null +++ b/scripts/expertise/expertise_sp_steup_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_steup_3') + + actor.addSkillMod('expertise_action_line_sp_stealth_melee', 5) + actor.addSkillMod('expertise_action_line_sp_stealth_ranged', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_steup_3') + + actor.removeSkillMod('expertise_action_line_sp_stealth_melee', 5) + actor.removeSkillMod('expertise_action_line_sp_stealth_ranged', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_steup_4.py b/scripts/expertise/expertise_sp_steup_4.py new file mode 100644 index 00000000..dd9ce2f4 --- /dev/null +++ b/scripts/expertise/expertise_sp_steup_4.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_steup_4') + + actor.addSkillMod('expertise_action_line_sp_stealth_melee', 5) + actor.addSkillMod('expertise_action_line_sp_stealth_ranged', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_steup_4') + + actor.removeSkillMod('expertise_action_line_sp_stealth_melee', 5) + actor.removeSkillMod('expertise_action_line_sp_stealth_ranged', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_undercover_1.py b/scripts/expertise/expertise_sp_undercover_1.py new file mode 100644 index 00000000..05754013 --- /dev/null +++ b/scripts/expertise/expertise_sp_undercover_1.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_undercover_1') + + actor.addSkillMod('expertise_movement_buff_invis_sp_buff_invis_1', -5) + actor.addSkillMod('expertise_movement_buff_invis_sp_buff_stealth_1', -20) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_undercover_1') + + actor.removeSkillMod('expertise_movement_buff_invis_sp_buff_invis_1', -5) + actor.removeSkillMod('expertise_movement_buff_invis_sp_buff_stealth_1', -20) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_undercover_2.py b/scripts/expertise/expertise_sp_undercover_2.py new file mode 100644 index 00000000..50edd523 --- /dev/null +++ b/scripts/expertise/expertise_sp_undercover_2.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_undercover_2') + + actor.addSkillMod('expertise_movement_buff_invis_sp_buff_invis_1', -5) + actor.addSkillMod('expertise_movement_buff_invis_sp_buff_stealth_1', -20) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_undercover_2') + + actor.removeSkillMod('expertise_movement_buff_invis_sp_buff_invis_1', -5) + actor.removeSkillMod('expertise_movement_buff_invis_sp_buff_stealth_1', -20) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_undercover_3.py b/scripts/expertise/expertise_sp_undercover_3.py new file mode 100644 index 00000000..23d181c5 --- /dev/null +++ b/scripts/expertise/expertise_sp_undercover_3.py @@ -0,0 +1,50 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_undercover_3') + + actor.addSkillMod('expertise_movement_buff_invis_sp_buff_invis_1', -5) + actor.addSkillMod('expertise_movement_buff_invis_sp_buff_stealth_1', -20) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_undercover_3') + + actor.removeSkillMod('expertise_movement_buff_invis_sp_buff_invis_1', -5) + actor.removeSkillMod('expertise_movement_buff_invis_sp_buff_stealth_1', -20) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_vibrogenerator_1.py b/scripts/expertise/expertise_sp_vibrogenerator_1.py new file mode 100644 index 00000000..90cb92c6 --- /dev/null +++ b/scripts/expertise/expertise_sp_vibrogenerator_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_vibrogenerator_1') + + actor.addSkillMod('expertise_armor_neglect', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_vibrogenerator_1') + + actor.removeSkillMod('expertise_armor_neglect', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_vibrogenerator_2.py b/scripts/expertise/expertise_sp_vibrogenerator_2.py new file mode 100644 index 00000000..4d047dc5 --- /dev/null +++ b/scripts/expertise/expertise_sp_vibrogenerator_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_vibrogenerator_2') + + actor.addSkillMod('expertise_armor_neglect', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_vibrogenerator_2') + + actor.removeSkillMod('expertise_armor_neglect', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_vibrogenerator_3.py b/scripts/expertise/expertise_sp_vibrogenerator_3.py new file mode 100644 index 00000000..810b8b4d --- /dev/null +++ b/scripts/expertise/expertise_sp_vibrogenerator_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_vibrogenerator_3') + + actor.addSkillMod('expertise_armor_neglect', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_vibrogenerator_3') + + actor.removeSkillMod('expertise_armor_neglect', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_sp_without_a_trace_1.py b/scripts/expertise/expertise_sp_without_a_trace_1.py new file mode 100644 index 00000000..35327fdf --- /dev/null +++ b/scripts/expertise/expertise_sp_without_a_trace_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.addSkill('expertise_sp_without_a_trace_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'spy_1a': + return + + actor.removeSkill('expertise_sp_without_a_trace_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_architect_advanced_theory_1.py b/scripts/expertise/expertise_structure_architect_advanced_theory_1.py new file mode 100644 index 00000000..762a10ca --- /dev/null +++ b/scripts/expertise/expertise_structure_architect_advanced_theory_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_architect_advanced_theory_1') + + actor.addSkillMod('structure_experimentation', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_architect_advanced_theory_1') + + actor.removeSkillMod('structure_experimentation', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_architect_dexterity_1.py b/scripts/expertise/expertise_structure_architect_dexterity_1.py new file mode 100644 index 00000000..eaf875af --- /dev/null +++ b/scripts/expertise/expertise_structure_architect_dexterity_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_architect_dexterity_1') + + actor.addSkillMod('structure_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_architect_dexterity_1') + + actor.removeSkillMod('structure_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_architect_dexterity_2.py b/scripts/expertise/expertise_structure_architect_dexterity_2.py new file mode 100644 index 00000000..e3a98a3d --- /dev/null +++ b/scripts/expertise/expertise_structure_architect_dexterity_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_architect_dexterity_2') + + actor.addSkillMod('structure_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_architect_dexterity_2') + + actor.removeSkillMod('structure_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_architect_dexterity_3.py b/scripts/expertise/expertise_structure_architect_dexterity_3.py new file mode 100644 index 00000000..ca3b2d31 --- /dev/null +++ b/scripts/expertise/expertise_structure_architect_dexterity_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_architect_dexterity_3') + + actor.addSkillMod('structure_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_architect_dexterity_3') + + actor.removeSkillMod('structure_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_architect_dexterity_4.py b/scripts/expertise/expertise_structure_architect_dexterity_4.py new file mode 100644 index 00000000..a3d8534f --- /dev/null +++ b/scripts/expertise/expertise_structure_architect_dexterity_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_architect_dexterity_4') + + actor.addSkillMod('structure_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_architect_dexterity_4') + + actor.removeSkillMod('structure_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_architect_hypothesis_1.py b/scripts/expertise/expertise_structure_architect_hypothesis_1.py new file mode 100644 index 00000000..b5eafa01 --- /dev/null +++ b/scripts/expertise/expertise_structure_architect_hypothesis_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_architect_hypothesis_1') + + actor.addSkillMod('expertise_experimentation_increase_architect', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_architect_hypothesis_1') + + actor.removeSkillMod('expertise_experimentation_increase_architect', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_architect_hypothesis_2.py b/scripts/expertise/expertise_structure_architect_hypothesis_2.py new file mode 100644 index 00000000..ec83d7d4 --- /dev/null +++ b/scripts/expertise/expertise_structure_architect_hypothesis_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_architect_hypothesis_2') + + actor.addSkillMod('expertise_experimentation_increase_architect', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_architect_hypothesis_2') + + actor.removeSkillMod('expertise_experimentation_increase_architect', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_architect_hypothesis_3.py b/scripts/expertise/expertise_structure_architect_hypothesis_3.py new file mode 100644 index 00000000..15ddc720 --- /dev/null +++ b/scripts/expertise/expertise_structure_architect_hypothesis_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_architect_hypothesis_3') + + actor.addSkillMod('expertise_experimentation_increase_architect', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_architect_hypothesis_3') + + actor.removeSkillMod('expertise_experimentation_increase_architect', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_architect_hypothesis_4.py b/scripts/expertise/expertise_structure_architect_hypothesis_4.py new file mode 100644 index 00000000..00e33f1b --- /dev/null +++ b/scripts/expertise/expertise_structure_architect_hypothesis_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_architect_hypothesis_4') + + actor.addSkillMod('expertise_experimentation_increase_architect', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_architect_hypothesis_4') + + actor.removeSkillMod('expertise_experimentation_increase_architect', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_architect_insight_1.py b/scripts/expertise/expertise_structure_architect_insight_1.py new file mode 100644 index 00000000..ff19b257 --- /dev/null +++ b/scripts/expertise/expertise_structure_architect_insight_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_architect_insight_1') + + actor.addSkillMod('expertise_complexity_decrease_architect', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_architect_insight_1') + + actor.removeSkillMod('expertise_complexity_decrease_architect', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_architect_insight_2.py b/scripts/expertise/expertise_structure_architect_insight_2.py new file mode 100644 index 00000000..e48c07f5 --- /dev/null +++ b/scripts/expertise/expertise_structure_architect_insight_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_architect_insight_2') + + actor.addSkillMod('expertise_complexity_decrease_architect', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_architect_insight_2') + + actor.removeSkillMod('expertise_complexity_decrease_architect', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_architect_keen_understanding_1.py b/scripts/expertise/expertise_structure_architect_keen_understanding_1.py new file mode 100644 index 00000000..1ff82037 --- /dev/null +++ b/scripts/expertise/expertise_structure_architect_keen_understanding_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_architect_keen_understanding_1') + + actor.addSkillMod('expertise_complexity_decrease_architect', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_architect_keen_understanding_1') + + actor.removeSkillMod('expertise_complexity_decrease_architect', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_architect_keen_understanding_2.py b/scripts/expertise/expertise_structure_architect_keen_understanding_2.py new file mode 100644 index 00000000..552ebd65 --- /dev/null +++ b/scripts/expertise/expertise_structure_architect_keen_understanding_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_architect_keen_understanding_2') + + actor.addSkillMod('expertise_complexity_decrease_architect', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_architect_keen_understanding_2') + + actor.removeSkillMod('expertise_complexity_decrease_architect', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_architect_schematic_1_1.py b/scripts/expertise/expertise_structure_architect_schematic_1_1.py new file mode 100644 index 00000000..7ef6e4eb --- /dev/null +++ b/scripts/expertise/expertise_structure_architect_schematic_1_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_architect_schematic_1_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_architect_schematic_1_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_architect_schematic_2_1.py b/scripts/expertise/expertise_structure_architect_schematic_2_1.py new file mode 100644 index 00000000..7df673d9 --- /dev/null +++ b/scripts/expertise/expertise_structure_architect_schematic_2_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_architect_schematic_2_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_architect_schematic_2_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_artisan_advanced_theory_1.py b/scripts/expertise/expertise_structure_artisan_advanced_theory_1.py new file mode 100644 index 00000000..f2498949 --- /dev/null +++ b/scripts/expertise/expertise_structure_artisan_advanced_theory_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_artisan_advanced_theory_1') + + actor.addSkillMod('general_experimentation', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_artisan_advanced_theory_1') + + actor.removeSkillMod('general_experimentation', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_artisan_dexterity_1.py b/scripts/expertise/expertise_structure_artisan_dexterity_1.py new file mode 100644 index 00000000..5dd3479f --- /dev/null +++ b/scripts/expertise/expertise_structure_artisan_dexterity_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_artisan_dexterity_1') + + actor.addSkillMod('general_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_artisan_dexterity_1') + + actor.removeSkillMod('general_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_artisan_dexterity_2.py b/scripts/expertise/expertise_structure_artisan_dexterity_2.py new file mode 100644 index 00000000..7390c520 --- /dev/null +++ b/scripts/expertise/expertise_structure_artisan_dexterity_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_artisan_dexterity_2') + + actor.addSkillMod('general_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_artisan_dexterity_2') + + actor.removeSkillMod('general_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_artisan_dexterity_3.py b/scripts/expertise/expertise_structure_artisan_dexterity_3.py new file mode 100644 index 00000000..91971842 --- /dev/null +++ b/scripts/expertise/expertise_structure_artisan_dexterity_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_artisan_dexterity_3') + + actor.addSkillMod('general_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_artisan_dexterity_3') + + actor.removeSkillMod('general_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_artisan_dexterity_4.py b/scripts/expertise/expertise_structure_artisan_dexterity_4.py new file mode 100644 index 00000000..4cb0041e --- /dev/null +++ b/scripts/expertise/expertise_structure_artisan_dexterity_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_artisan_dexterity_4') + + actor.addSkillMod('general_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_artisan_dexterity_4') + + actor.removeSkillMod('general_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_artisan_hypothesis_1.py b/scripts/expertise/expertise_structure_artisan_hypothesis_1.py new file mode 100644 index 00000000..18cbdb54 --- /dev/null +++ b/scripts/expertise/expertise_structure_artisan_hypothesis_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_artisan_hypothesis_1') + + actor.addSkillMod('expertise_experimentation_increase_artisan', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_artisan_hypothesis_1') + + actor.removeSkillMod('expertise_experimentation_increase_artisan', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_artisan_hypothesis_2.py b/scripts/expertise/expertise_structure_artisan_hypothesis_2.py new file mode 100644 index 00000000..1260a16f --- /dev/null +++ b/scripts/expertise/expertise_structure_artisan_hypothesis_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_artisan_hypothesis_2') + + actor.addSkillMod('expertise_experimentation_increase_artisan', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_artisan_hypothesis_2') + + actor.removeSkillMod('expertise_experimentation_increase_artisan', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_artisan_hypothesis_3.py b/scripts/expertise/expertise_structure_artisan_hypothesis_3.py new file mode 100644 index 00000000..5101ccc2 --- /dev/null +++ b/scripts/expertise/expertise_structure_artisan_hypothesis_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_artisan_hypothesis_3') + + actor.addSkillMod('expertise_experimentation_increase_artisan', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_artisan_hypothesis_3') + + actor.removeSkillMod('expertise_experimentation_increase_artisan', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_artisan_hypothesis_4.py b/scripts/expertise/expertise_structure_artisan_hypothesis_4.py new file mode 100644 index 00000000..ae1c642f --- /dev/null +++ b/scripts/expertise/expertise_structure_artisan_hypothesis_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_artisan_hypothesis_4') + + actor.addSkillMod('expertise_experimentation_increase_artisan', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_artisan_hypothesis_4') + + actor.removeSkillMod('expertise_experimentation_increase_artisan', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_resource_processing_1.py b/scripts/expertise/expertise_structure_resource_processing_1.py new file mode 100644 index 00000000..80444cc0 --- /dev/null +++ b/scripts/expertise/expertise_structure_resource_processing_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_resource_processing_1') + + actor.addSkillMod('expertise_resource_quality_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_resource_processing_1') + + actor.removeSkillMod('expertise_resource_quality_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_resource_processing_2.py b/scripts/expertise/expertise_structure_resource_processing_2.py new file mode 100644 index 00000000..89253106 --- /dev/null +++ b/scripts/expertise/expertise_structure_resource_processing_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_resource_processing_2') + + actor.addSkillMod('expertise_resource_quality_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_resource_processing_2') + + actor.removeSkillMod('expertise_resource_quality_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_resource_refinement_1.py b/scripts/expertise/expertise_structure_resource_refinement_1.py new file mode 100644 index 00000000..948b3822 --- /dev/null +++ b/scripts/expertise/expertise_structure_resource_refinement_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_resource_refinement_1') + + actor.addSkillMod('expertise_resource_quality_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_resource_refinement_1') + + actor.removeSkillMod('expertise_resource_quality_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_resource_refinement_2.py b/scripts/expertise/expertise_structure_resource_refinement_2.py new file mode 100644 index 00000000..bc8e7478 --- /dev/null +++ b/scripts/expertise/expertise_structure_resource_refinement_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_resource_refinement_2') + + actor.addSkillMod('expertise_resource_quality_increase', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_resource_refinement_2') + + actor.removeSkillMod('expertise_resource_quality_increase', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_shipwright_advanced_theory_1.py b/scripts/expertise/expertise_structure_shipwright_advanced_theory_1.py new file mode 100644 index 00000000..3ad59ca5 --- /dev/null +++ b/scripts/expertise/expertise_structure_shipwright_advanced_theory_1.py @@ -0,0 +1,60 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_shipwright_advanced_theory_1') + + actor.addSkillMod('chassis_experimentation', 10) + actor.addSkillMod('weapon_systems_experimentation', 10) + actor.addSkillMod('engine_experimentation', 10) + actor.addSkillMod('booster_experimentation', 10) + actor.addSkillMod('power_systems_experimentation', 10) + actor.addSkillMod('shields_experimentation', 10) + actor.addSkillMod('advanced_ship_experimentation', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_shipwright_advanced_theory_1') + + actor.removeSkillMod('chassis_experimentation', 10) + actor.removeSkillMod('weapon_systems_experimentation', 10) + actor.removeSkillMod('engine_experimentation', 10) + actor.removeSkillMod('booster_experimentation', 10) + actor.removeSkillMod('power_systems_experimentation', 10) + actor.removeSkillMod('shields_experimentation', 10) + actor.removeSkillMod('advanced_ship_experimentation', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_shipwright_dexterity_1.py b/scripts/expertise/expertise_structure_shipwright_dexterity_1.py new file mode 100644 index 00000000..210f669b --- /dev/null +++ b/scripts/expertise/expertise_structure_shipwright_dexterity_1.py @@ -0,0 +1,60 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_shipwright_dexterity_1') + + actor.addSkillMod('chassis_assembly', 5) + actor.addSkillMod('engine_assembly', 5) + actor.addSkillMod('booster_assembly', 5) + actor.addSkillMod('power_systems', 5) + actor.addSkillMod('weapon_systems', 5) + actor.addSkillMod('shields_assembly', 5) + actor.addSkillMod('advanced_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_shipwright_dexterity_1') + + actor.removeSkillMod('chassis_assembly', 5) + actor.removeSkillMod('engine_assembly', 5) + actor.removeSkillMod('booster_assembly', 5) + actor.removeSkillMod('power_systems', 5) + actor.removeSkillMod('weapon_systems', 5) + actor.removeSkillMod('shields_assembly', 5) + actor.removeSkillMod('advanced_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_shipwright_dexterity_2.py b/scripts/expertise/expertise_structure_shipwright_dexterity_2.py new file mode 100644 index 00000000..b1bc4bd6 --- /dev/null +++ b/scripts/expertise/expertise_structure_shipwright_dexterity_2.py @@ -0,0 +1,60 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_shipwright_dexterity_2') + + actor.addSkillMod('chassis_assembly', 5) + actor.addSkillMod('engine_assembly', 5) + actor.addSkillMod('booster_assembly', 5) + actor.addSkillMod('power_systems', 5) + actor.addSkillMod('weapon_systems', 5) + actor.addSkillMod('shields_assembly', 5) + actor.addSkillMod('advanced_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_shipwright_dexterity_2') + + actor.removeSkillMod('chassis_assembly', 5) + actor.removeSkillMod('engine_assembly', 5) + actor.removeSkillMod('booster_assembly', 5) + actor.removeSkillMod('power_systems', 5) + actor.removeSkillMod('weapon_systems', 5) + actor.removeSkillMod('shields_assembly', 5) + actor.removeSkillMod('advanced_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_shipwright_dexterity_3.py b/scripts/expertise/expertise_structure_shipwright_dexterity_3.py new file mode 100644 index 00000000..09592b62 --- /dev/null +++ b/scripts/expertise/expertise_structure_shipwright_dexterity_3.py @@ -0,0 +1,60 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_shipwright_dexterity_3') + + actor.addSkillMod('chassis_assembly', 5) + actor.addSkillMod('engine_assembly', 5) + actor.addSkillMod('booster_assembly', 5) + actor.addSkillMod('power_systems', 5) + actor.addSkillMod('weapon_systems', 5) + actor.addSkillMod('shields_assembly', 5) + actor.addSkillMod('advanced_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_shipwright_dexterity_3') + + actor.removeSkillMod('chassis_assembly', 5) + actor.removeSkillMod('engine_assembly', 5) + actor.removeSkillMod('booster_assembly', 5) + actor.removeSkillMod('power_systems', 5) + actor.removeSkillMod('weapon_systems', 5) + actor.removeSkillMod('shields_assembly', 5) + actor.removeSkillMod('advanced_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_shipwright_dexterity_4.py b/scripts/expertise/expertise_structure_shipwright_dexterity_4.py new file mode 100644 index 00000000..242ccbd2 --- /dev/null +++ b/scripts/expertise/expertise_structure_shipwright_dexterity_4.py @@ -0,0 +1,60 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_shipwright_dexterity_4') + + actor.addSkillMod('chassis_assembly', 5) + actor.addSkillMod('engine_assembly', 5) + actor.addSkillMod('booster_assembly', 5) + actor.addSkillMod('power_systems', 5) + actor.addSkillMod('weapon_systems', 5) + actor.addSkillMod('shields_assembly', 5) + actor.addSkillMod('advanced_assembly', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_shipwright_dexterity_4') + + actor.removeSkillMod('chassis_assembly', 5) + actor.removeSkillMod('engine_assembly', 5) + actor.removeSkillMod('booster_assembly', 5) + actor.removeSkillMod('power_systems', 5) + actor.removeSkillMod('weapon_systems', 5) + actor.removeSkillMod('shields_assembly', 5) + actor.removeSkillMod('advanced_assembly', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_shipwright_hypothesis_1.py b/scripts/expertise/expertise_structure_shipwright_hypothesis_1.py new file mode 100644 index 00000000..6fc0b225 --- /dev/null +++ b/scripts/expertise/expertise_structure_shipwright_hypothesis_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_shipwright_hypothesis_1') + + actor.addSkillMod('expertise_experimentation_increase_shipwright', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_shipwright_hypothesis_1') + + actor.removeSkillMod('expertise_experimentation_increase_shipwright', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_shipwright_hypothesis_2.py b/scripts/expertise/expertise_structure_shipwright_hypothesis_2.py new file mode 100644 index 00000000..101a7342 --- /dev/null +++ b/scripts/expertise/expertise_structure_shipwright_hypothesis_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_shipwright_hypothesis_2') + + actor.addSkillMod('expertise_experimentation_increase_shipwright', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_shipwright_hypothesis_2') + + actor.removeSkillMod('expertise_experimentation_increase_shipwright', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_shipwright_hypothesis_3.py b/scripts/expertise/expertise_structure_shipwright_hypothesis_3.py new file mode 100644 index 00000000..2c00785c --- /dev/null +++ b/scripts/expertise/expertise_structure_shipwright_hypothesis_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_shipwright_hypothesis_3') + + actor.addSkillMod('expertise_experimentation_increase_shipwright', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_shipwright_hypothesis_3') + + actor.removeSkillMod('expertise_experimentation_increase_shipwright', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_shipwright_hypothesis_4.py b/scripts/expertise/expertise_structure_shipwright_hypothesis_4.py new file mode 100644 index 00000000..d723697e --- /dev/null +++ b/scripts/expertise/expertise_structure_shipwright_hypothesis_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_shipwright_hypothesis_4') + + actor.addSkillMod('expertise_experimentation_increase_shipwright', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_shipwright_hypothesis_4') + + actor.removeSkillMod('expertise_experimentation_increase_shipwright', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_shipwright_insight_1.py b/scripts/expertise/expertise_structure_shipwright_insight_1.py new file mode 100644 index 00000000..82b35892 --- /dev/null +++ b/scripts/expertise/expertise_structure_shipwright_insight_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_shipwright_insight_1') + + actor.addSkillMod('expertise_complexity_decrease_shipwright', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_shipwright_insight_1') + + actor.removeSkillMod('expertise_complexity_decrease_shipwright', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_shipwright_insight_2.py b/scripts/expertise/expertise_structure_shipwright_insight_2.py new file mode 100644 index 00000000..d50e67a5 --- /dev/null +++ b/scripts/expertise/expertise_structure_shipwright_insight_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_shipwright_insight_2') + + actor.addSkillMod('expertise_complexity_decrease_shipwright', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_shipwright_insight_2') + + actor.removeSkillMod('expertise_complexity_decrease_shipwright', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_shipwright_keen_understanding_1.py b/scripts/expertise/expertise_structure_shipwright_keen_understanding_1.py new file mode 100644 index 00000000..06d07813 --- /dev/null +++ b/scripts/expertise/expertise_structure_shipwright_keen_understanding_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_shipwright_keen_understanding_1') + + actor.addSkillMod('expertise_complexity_decrease_shipwright', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_shipwright_keen_understanding_1') + + actor.removeSkillMod('expertise_complexity_decrease_shipwright', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_shipwright_keen_understanding_2.py b/scripts/expertise/expertise_structure_shipwright_keen_understanding_2.py new file mode 100644 index 00000000..bd0f235a --- /dev/null +++ b/scripts/expertise/expertise_structure_shipwright_keen_understanding_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_shipwright_keen_understanding_2') + + actor.addSkillMod('expertise_complexity_decrease_shipwright', 2) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_shipwright_keen_understanding_2') + + actor.removeSkillMod('expertise_complexity_decrease_shipwright', 2) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_shipwright_schematic_1_1.py b/scripts/expertise/expertise_structure_shipwright_schematic_1_1.py new file mode 100644 index 00000000..7e8de7a2 --- /dev/null +++ b/scripts/expertise/expertise_structure_shipwright_schematic_1_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_shipwright_schematic_1_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_shipwright_schematic_1_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_structure_shipwright_schematic_2_1.py b/scripts/expertise/expertise_structure_shipwright_schematic_2_1.py new file mode 100644 index 00000000..71c2d9b5 --- /dev/null +++ b/scripts/expertise/expertise_structure_shipwright_schematic_2_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.addSkill('expertise_structure_shipwright_schematic_2_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_struct_1a': + return + + actor.removeSkill('expertise_structure_shipwright_schematic_2_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_test_add_proc.py b/scripts/expertise/expertise_test_add_proc.py new file mode 100644 index 00000000..777edb05 --- /dev/null +++ b/scripts/expertise/expertise_test_add_proc.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_test_add_proc') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_test_add_proc') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_test_add_reac.py b/scripts/expertise/expertise_test_add_reac.py new file mode 100644 index 00000000..201f236d --- /dev/null +++ b/scripts/expertise/expertise_test_add_reac.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_test_add_reac') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_test_add_reac') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_test_postreq_1.py b/scripts/expertise/expertise_test_postreq_1.py new file mode 100644 index 00000000..c166d925 --- /dev/null +++ b/scripts/expertise/expertise_test_postreq_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_test_postreq_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_test_postreq_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_test_prereq1_1.py b/scripts/expertise/expertise_test_prereq1_1.py new file mode 100644 index 00000000..375a8d70 --- /dev/null +++ b/scripts/expertise/expertise_test_prereq1_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_test_prereq1_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_test_prereq1_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_test_prereq2_1.py b/scripts/expertise/expertise_test_prereq2_1.py new file mode 100644 index 00000000..064511dd --- /dev/null +++ b/scripts/expertise/expertise_test_prereq2_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_test_prereq2_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_test_prereq2_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_test_prereq3_1.py b/scripts/expertise/expertise_test_prereq3_1.py new file mode 100644 index 00000000..109827f9 --- /dev/null +++ b/scripts/expertise/expertise_test_prereq3_1.py @@ -0,0 +1,46 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.addSkill('expertise_test_prereq3_1') + + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'all_1a': + return + + actor.removeSkill('expertise_test_prereq3_1') + + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_business_accounting_1.py b/scripts/expertise/expertise_trader_business_accounting_1.py new file mode 100644 index 00000000..79324ca3 --- /dev/null +++ b/scripts/expertise/expertise_trader_business_accounting_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_business_accounting_1') + + actor.addSkillMod('expertise_vendor_cost_decrease', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_business_accounting_1') + + actor.removeSkillMod('expertise_vendor_cost_decrease', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_business_accounting_2.py b/scripts/expertise/expertise_trader_business_accounting_2.py new file mode 100644 index 00000000..86469f30 --- /dev/null +++ b/scripts/expertise/expertise_trader_business_accounting_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_business_accounting_2') + + actor.addSkillMod('expertise_vendor_cost_decrease', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_business_accounting_2') + + actor.removeSkillMod('expertise_vendor_cost_decrease', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_business_accounting_3.py b/scripts/expertise/expertise_trader_business_accounting_3.py new file mode 100644 index 00000000..cc43a91d --- /dev/null +++ b/scripts/expertise/expertise_trader_business_accounting_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_business_accounting_3') + + actor.addSkillMod('expertise_vendor_cost_decrease', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_business_accounting_3') + + actor.removeSkillMod('expertise_vendor_cost_decrease', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_business_accounting_4.py b/scripts/expertise/expertise_trader_business_accounting_4.py new file mode 100644 index 00000000..0c751506 --- /dev/null +++ b/scripts/expertise/expertise_trader_business_accounting_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_business_accounting_4') + + actor.addSkillMod('expertise_vendor_cost_decrease', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_business_accounting_4') + + actor.removeSkillMod('expertise_vendor_cost_decrease', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_factory_energy_1.py b/scripts/expertise/expertise_trader_factory_energy_1.py new file mode 100644 index 00000000..cd7525fc --- /dev/null +++ b/scripts/expertise/expertise_trader_factory_energy_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_factory_energy_1') + + actor.addSkillMod('expertise_factory_energy_decrease', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_factory_energy_1') + + actor.removeSkillMod('expertise_factory_energy_decrease', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_factory_energy_2.py b/scripts/expertise/expertise_trader_factory_energy_2.py new file mode 100644 index 00000000..ab07aa02 --- /dev/null +++ b/scripts/expertise/expertise_trader_factory_energy_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_factory_energy_2') + + actor.addSkillMod('expertise_factory_energy_decrease', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_factory_energy_2') + + actor.removeSkillMod('expertise_factory_energy_decrease', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_factory_energy_3.py b/scripts/expertise/expertise_trader_factory_energy_3.py new file mode 100644 index 00000000..04bac30c --- /dev/null +++ b/scripts/expertise/expertise_trader_factory_energy_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_factory_energy_3') + + actor.addSkillMod('expertise_factory_energy_decrease', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_factory_energy_3') + + actor.removeSkillMod('expertise_factory_energy_decrease', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_factory_energy_4.py b/scripts/expertise/expertise_trader_factory_energy_4.py new file mode 100644 index 00000000..b2012ebc --- /dev/null +++ b/scripts/expertise/expertise_trader_factory_energy_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_factory_energy_4') + + actor.addSkillMod('expertise_factory_energy_decrease', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_factory_energy_4') + + actor.removeSkillMod('expertise_factory_energy_decrease', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_factory_maintenance_1.py b/scripts/expertise/expertise_trader_factory_maintenance_1.py new file mode 100644 index 00000000..539c8406 --- /dev/null +++ b/scripts/expertise/expertise_trader_factory_maintenance_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_factory_maintenance_1') + + actor.addSkillMod('expertise_factory_maintenance_decrease', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_factory_maintenance_1') + + actor.removeSkillMod('expertise_factory_maintenance_decrease', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_factory_maintenance_2.py b/scripts/expertise/expertise_trader_factory_maintenance_2.py new file mode 100644 index 00000000..917acca1 --- /dev/null +++ b/scripts/expertise/expertise_trader_factory_maintenance_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_factory_maintenance_2') + + actor.addSkillMod('expertise_factory_maintenance_decrease', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_factory_maintenance_2') + + actor.removeSkillMod('expertise_factory_maintenance_decrease', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_factory_maintenance_3.py b/scripts/expertise/expertise_trader_factory_maintenance_3.py new file mode 100644 index 00000000..58fdaa1d --- /dev/null +++ b/scripts/expertise/expertise_trader_factory_maintenance_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_factory_maintenance_3') + + actor.addSkillMod('expertise_factory_maintenance_decrease', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_factory_maintenance_3') + + actor.removeSkillMod('expertise_factory_maintenance_decrease', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_factory_maintenance_4.py b/scripts/expertise/expertise_trader_factory_maintenance_4.py new file mode 100644 index 00000000..51f4dff6 --- /dev/null +++ b/scripts/expertise/expertise_trader_factory_maintenance_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_factory_maintenance_4') + + actor.addSkillMod('expertise_factory_maintenance_decrease', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_factory_maintenance_4') + + actor.removeSkillMod('expertise_factory_maintenance_decrease', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_factory_production_1.py b/scripts/expertise/expertise_trader_factory_production_1.py new file mode 100644 index 00000000..9f82bcae --- /dev/null +++ b/scripts/expertise/expertise_trader_factory_production_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_factory_production_1') + + actor.addSkillMod('factory_speed', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_factory_production_1') + + actor.removeSkillMod('factory_speed', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_factory_production_2.py b/scripts/expertise/expertise_trader_factory_production_2.py new file mode 100644 index 00000000..97a69abe --- /dev/null +++ b/scripts/expertise/expertise_trader_factory_production_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_factory_production_2') + + actor.addSkillMod('factory_speed', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_factory_production_2') + + actor.removeSkillMod('factory_speed', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_harvester_collection_1.py b/scripts/expertise/expertise_trader_harvester_collection_1.py new file mode 100644 index 00000000..f509b4ce --- /dev/null +++ b/scripts/expertise/expertise_trader_harvester_collection_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_harvester_collection_1') + + actor.addSkillMod('expertise_harvester_collection_increase', 20) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_harvester_collection_1') + + actor.removeSkillMod('expertise_harvester_collection_increase', 20) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_harvester_collection_2.py b/scripts/expertise/expertise_trader_harvester_collection_2.py new file mode 100644 index 00000000..fb287890 --- /dev/null +++ b/scripts/expertise/expertise_trader_harvester_collection_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_harvester_collection_2') + + actor.addSkillMod('expertise_harvester_collection_increase', 10) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_harvester_collection_2') + + actor.removeSkillMod('expertise_harvester_collection_increase', 10) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_harvester_energy_1.py b/scripts/expertise/expertise_trader_harvester_energy_1.py new file mode 100644 index 00000000..b0a7f738 --- /dev/null +++ b/scripts/expertise/expertise_trader_harvester_energy_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_harvester_energy_1') + + actor.addSkillMod('expertise_harvester_energy_decrease', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_harvester_energy_1') + + actor.removeSkillMod('expertise_harvester_energy_decrease', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_harvester_energy_2.py b/scripts/expertise/expertise_trader_harvester_energy_2.py new file mode 100644 index 00000000..d6822bed --- /dev/null +++ b/scripts/expertise/expertise_trader_harvester_energy_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_harvester_energy_2') + + actor.addSkillMod('expertise_harvester_energy_decrease', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_harvester_energy_2') + + actor.removeSkillMod('expertise_harvester_energy_decrease', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_harvester_energy_3.py b/scripts/expertise/expertise_trader_harvester_energy_3.py new file mode 100644 index 00000000..35e85782 --- /dev/null +++ b/scripts/expertise/expertise_trader_harvester_energy_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_harvester_energy_3') + + actor.addSkillMod('expertise_harvester_energy_decrease', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_harvester_energy_3') + + actor.removeSkillMod('expertise_harvester_energy_decrease', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_harvester_energy_4.py b/scripts/expertise/expertise_trader_harvester_energy_4.py new file mode 100644 index 00000000..f7132f84 --- /dev/null +++ b/scripts/expertise/expertise_trader_harvester_energy_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_harvester_energy_4') + + actor.addSkillMod('expertise_harvester_energy_decrease', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_harvester_energy_4') + + actor.removeSkillMod('expertise_harvester_energy_decrease', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_harvester_maintenance_1.py b/scripts/expertise/expertise_trader_harvester_maintenance_1.py new file mode 100644 index 00000000..0dbf85ca --- /dev/null +++ b/scripts/expertise/expertise_trader_harvester_maintenance_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_harvester_maintenance_1') + + actor.addSkillMod('expertise_harvester_maintenance_decrease', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_harvester_maintenance_1') + + actor.removeSkillMod('expertise_harvester_maintenance_decrease', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_harvester_maintenance_2.py b/scripts/expertise/expertise_trader_harvester_maintenance_2.py new file mode 100644 index 00000000..e581d20d --- /dev/null +++ b/scripts/expertise/expertise_trader_harvester_maintenance_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_harvester_maintenance_2') + + actor.addSkillMod('expertise_harvester_maintenance_decrease', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_harvester_maintenance_2') + + actor.removeSkillMod('expertise_harvester_maintenance_decrease', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_harvester_maintenance_3.py b/scripts/expertise/expertise_trader_harvester_maintenance_3.py new file mode 100644 index 00000000..85c77180 --- /dev/null +++ b/scripts/expertise/expertise_trader_harvester_maintenance_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_harvester_maintenance_3') + + actor.addSkillMod('expertise_harvester_maintenance_decrease', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_harvester_maintenance_3') + + actor.removeSkillMod('expertise_harvester_maintenance_decrease', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_harvester_maintenance_4.py b/scripts/expertise/expertise_trader_harvester_maintenance_4.py new file mode 100644 index 00000000..e04f5f73 --- /dev/null +++ b/scripts/expertise/expertise_trader_harvester_maintenance_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_harvester_maintenance_4') + + actor.addSkillMod('expertise_harvester_maintenance_decrease', 4) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_harvester_maintenance_4') + + actor.removeSkillMod('expertise_harvester_maintenance_decrease', 4) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_harvester_storage_1.py b/scripts/expertise/expertise_trader_harvester_storage_1.py new file mode 100644 index 00000000..ad6c85ee --- /dev/null +++ b/scripts/expertise/expertise_trader_harvester_storage_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_harvester_storage_1') + + actor.addSkillMod('expertise_havester_storage_increase', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_harvester_storage_1') + + actor.removeSkillMod('expertise_havester_storage_increase', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_harvester_storage_2.py b/scripts/expertise/expertise_trader_harvester_storage_2.py new file mode 100644 index 00000000..9ac213e9 --- /dev/null +++ b/scripts/expertise/expertise_trader_harvester_storage_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_harvester_storage_2') + + actor.addSkillMod('expertise_havester_storage_increase', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_harvester_storage_2') + + actor.removeSkillMod('expertise_havester_storage_increase', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_harvester_storage_3.py b/scripts/expertise/expertise_trader_harvester_storage_3.py new file mode 100644 index 00000000..1c2abe57 --- /dev/null +++ b/scripts/expertise/expertise_trader_harvester_storage_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_harvester_storage_3') + + actor.addSkillMod('expertise_havester_storage_increase', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_harvester_storage_3') + + actor.removeSkillMod('expertise_havester_storage_increase', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_harvester_storage_4.py b/scripts/expertise/expertise_trader_harvester_storage_4.py new file mode 100644 index 00000000..9abc452b --- /dev/null +++ b/scripts/expertise/expertise_trader_harvester_storage_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_harvester_storage_4') + + actor.addSkillMod('expertise_havester_storage_increase', 3) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_harvester_storage_4') + + actor.removeSkillMod('expertise_havester_storage_increase', 3) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_personnel_management_1.py b/scripts/expertise/expertise_trader_personnel_management_1.py new file mode 100644 index 00000000..9e618df1 --- /dev/null +++ b/scripts/expertise/expertise_trader_personnel_management_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_personnel_management_1') + + actor.addSkillMod('manage_vendor', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_personnel_management_1') + + actor.removeSkillMod('manage_vendor', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_personnel_management_2.py b/scripts/expertise/expertise_trader_personnel_management_2.py new file mode 100644 index 00000000..465e9b8e --- /dev/null +++ b/scripts/expertise/expertise_trader_personnel_management_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_personnel_management_2') + + actor.addSkillMod('manage_vendor', 1) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_personnel_management_2') + + actor.removeSkillMod('manage_vendor', 1) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_reverse_engineering_1.py b/scripts/expertise/expertise_trader_reverse_engineering_1.py new file mode 100644 index 00000000..6c6a1599 --- /dev/null +++ b/scripts/expertise/expertise_trader_reverse_engineering_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_reverse_engineering_1') + + actor.addSkillMod('expertise_reverse_engineering_bonus', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_reverse_engineering_1') + + actor.removeSkillMod('expertise_reverse_engineering_bonus', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_reverse_engineering_2.py b/scripts/expertise/expertise_trader_reverse_engineering_2.py new file mode 100644 index 00000000..a0716403 --- /dev/null +++ b/scripts/expertise/expertise_trader_reverse_engineering_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_reverse_engineering_2') + + actor.addSkillMod('expertise_reverse_engineering_bonus', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_reverse_engineering_2') + + actor.removeSkillMod('expertise_reverse_engineering_bonus', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_sampling_collection_1.py b/scripts/expertise/expertise_trader_sampling_collection_1.py new file mode 100644 index 00000000..cb6861b2 --- /dev/null +++ b/scripts/expertise/expertise_trader_sampling_collection_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_sampling_collection_1') + + actor.addSkillMod('expertise_resource_sampling_increase', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_sampling_collection_1') + + actor.removeSkillMod('expertise_resource_sampling_increase', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_sampling_collection_2.py b/scripts/expertise/expertise_trader_sampling_collection_2.py new file mode 100644 index 00000000..f1c55a3d --- /dev/null +++ b/scripts/expertise/expertise_trader_sampling_collection_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_sampling_collection_2') + + actor.addSkillMod('expertise_resource_sampling_increase', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_sampling_collection_2') + + actor.removeSkillMod('expertise_resource_sampling_increase', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_sampling_collection_3.py b/scripts/expertise/expertise_trader_sampling_collection_3.py new file mode 100644 index 00000000..b6a31585 --- /dev/null +++ b/scripts/expertise/expertise_trader_sampling_collection_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_sampling_collection_3') + + actor.addSkillMod('expertise_resource_sampling_increase', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_sampling_collection_3') + + actor.removeSkillMod('expertise_resource_sampling_increase', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_sampling_collection_4.py b/scripts/expertise/expertise_trader_sampling_collection_4.py new file mode 100644 index 00000000..08805c30 --- /dev/null +++ b/scripts/expertise/expertise_trader_sampling_collection_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_sampling_collection_4') + + actor.addSkillMod('expertise_resource_sampling_increase', 25) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_sampling_collection_4') + + actor.removeSkillMod('expertise_resource_sampling_increase', 25) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_sampling_efficiency_1.py b/scripts/expertise/expertise_trader_sampling_efficiency_1.py new file mode 100644 index 00000000..0722f5bb --- /dev/null +++ b/scripts/expertise/expertise_trader_sampling_efficiency_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_sampling_efficiency_1') + + actor.addSkillMod('expertise_resource_sampling_time_decrease', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_sampling_efficiency_1') + + actor.removeSkillMod('expertise_resource_sampling_time_decrease', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_sampling_efficiency_2.py b/scripts/expertise/expertise_trader_sampling_efficiency_2.py new file mode 100644 index 00000000..c9043c3f --- /dev/null +++ b/scripts/expertise/expertise_trader_sampling_efficiency_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_sampling_efficiency_2') + + actor.addSkillMod('expertise_resource_sampling_time_decrease', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_sampling_efficiency_2') + + actor.removeSkillMod('expertise_resource_sampling_time_decrease', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_sampling_efficiency_3.py b/scripts/expertise/expertise_trader_sampling_efficiency_3.py new file mode 100644 index 00000000..2d3d621c --- /dev/null +++ b/scripts/expertise/expertise_trader_sampling_efficiency_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_sampling_efficiency_3') + + actor.addSkillMod('expertise_resource_sampling_time_decrease', 5) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_sampling_efficiency_3') + + actor.removeSkillMod('expertise_resource_sampling_time_decrease', 5) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_warehousing_1.py b/scripts/expertise/expertise_trader_warehousing_1.py new file mode 100644 index 00000000..c865daf6 --- /dev/null +++ b/scripts/expertise/expertise_trader_warehousing_1.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_warehousing_1') + + actor.addSkillMod('vendor_item_limit', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_warehousing_1') + + actor.removeSkillMod('vendor_item_limit', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_warehousing_2.py b/scripts/expertise/expertise_trader_warehousing_2.py new file mode 100644 index 00000000..99f6db9d --- /dev/null +++ b/scripts/expertise/expertise_trader_warehousing_2.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_warehousing_2') + + actor.addSkillMod('vendor_item_limit', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_warehousing_2') + + actor.removeSkillMod('vendor_item_limit', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_warehousing_3.py b/scripts/expertise/expertise_trader_warehousing_3.py new file mode 100644 index 00000000..19d00373 --- /dev/null +++ b/scripts/expertise/expertise_trader_warehousing_3.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_warehousing_3') + + actor.addSkillMod('vendor_item_limit', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_warehousing_3') + + actor.removeSkillMod('vendor_item_limit', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return diff --git a/scripts/expertise/expertise_trader_warehousing_4.py b/scripts/expertise/expertise_trader_warehousing_4.py new file mode 100644 index 00000000..cb2f936c --- /dev/null +++ b/scripts/expertise/expertise_trader_warehousing_4.py @@ -0,0 +1,48 @@ +import sys + +def addExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.addSkill('expertise_trader_warehousing_4') + + actor.addSkillMod('vendor_item_limit', 50) + + addAbilities(core, actor, player) + + return + +def removeExpertisePoint(core, actor): + + player = actor.getSlottedObject('ghost') + + if not player: + return + + if not player.getProfession() == 'trader_1a': + return + + actor.removeSkill('expertise_trader_warehousing_4') + + actor.removeSkillMod('vendor_item_limit', 50) + + removeAbilities(core, actor, player) + + return + +# this checks what abilities the player gets by level, need to also call this on level-up +def addAbilities(core, actor, player): + + + return + +def removeAbilities(core, actor, player): + + + return