Added the missing expertise scripts

Created missing expertise scripts and filled them with data from the
game. Leaving Commando out for now as my version have a different
approach which I want to discuss with devs first.

Also added PyCharm project directory to the .gitignore file.

.gitignore

@@ -194,3 +194,9 @@ pip-log.txt
 
 # Mac crap
 .DS_Store
+
+
+#############
+## PyCharm
+#############
+.idea

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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