From 296c84f616871f6073af2feec55c273c909cd3f1 Mon Sep 17 00:00:00 2001
From: dg <dg@51575b47-30f0-44d4-a5cc-537603b46e54>
Date: Wed, 4 Jul 2012 19:27:36 +0000
Subject: [PATCH] Fixed gnaw Fixed crosstier effects on gestures Fixed unarmed
mastery physical power
git-svn-id: http://svn.net-core.org/repos/t-engine4@5333 51575b47-30f0-44d4-a5cc-537603b46e54
---
game/modules/tome/class/Actor.lua | 156 ++++++++++--
game/modules/tome/class/Object.lua | 22 ++
game/modules/tome/class/PlayerDisplay.lua | 4 +-
game/modules/tome/class/interface/Archery.lua | 14 +-
game/modules/tome/class/interface/Combat.lua | 23 +-
.../tome/class/interface/TooltipsData.lua | 11 +-
game/modules/tome/class/uiset/Minimalist.lua | 10 +-
.../tome/data/birth/classes/psionic.lua | 22 +-
game/modules/tome/data/damage_types.lua | 20 +-
.../tome/data/talents/cunning/ambush.lua | 1 +
game/modules/tome/data/talents/misc/npcs.lua | 27 --
.../tome/data/talents/psionic/discharge.lua | 229 +++++++++++++++++
.../tome/data/talents/psionic/distortion.lua | 229 +++++++++++++++++
.../tome/data/talents/psionic/feedback.lua | 167 ++-----------
.../tome/data/talents/psionic/mentalism.lua | 234 ++++++++++++++++++
.../tome/data/talents/psionic/nightmare.lua | 229 +++++++++++++++++
.../tome/data/talents/psionic/psionic.lua | 19 +-
.../data/talents/psionic/psychic-assault.lua | 95 ++++++-
.../tome/data/talents/psionic/slumber.lua | 229 +++++++++++++++++
.../tome/data/talents/psionic/solipsism.lua | 44 ++--
.../data/talents/psionic/thought-forms.lua | 229 +++++++++++++++++
.../tome/data/talents/psionic/trance.lua | 181 ++++++++++++++
.../tome/data/timed_effects/magical.lua | 2 +-
.../tome/data/timed_effects/mental.lua | 19 --
.../modules/tome/data/timed_effects/other.lua | 20 --
game/modules/tome/dialogs/CharacterSheet.lua | 8 +-
26 files changed, 1962 insertions(+), 282 deletions(-)
create mode 100644 game/modules/tome/data/talents/psionic/discharge.lua
create mode 100644 game/modules/tome/data/talents/psionic/distortion.lua
create mode 100644 game/modules/tome/data/talents/psionic/mentalism.lua
create mode 100644 game/modules/tome/data/talents/psionic/nightmare.lua
create mode 100644 game/modules/tome/data/talents/psionic/slumber.lua
create mode 100644 game/modules/tome/data/talents/psionic/thought-forms.lua
create mode 100644 game/modules/tome/data/talents/psionic/trance.lua
diff --git a/game/modules/tome/class/Actor.lua b/game/modules/tome/class/Actor.lua
index e3206f6ba1..9ae26c323e 100644
--- a/game/modules/tome/class/Actor.lua
+++ b/game/modules/tome/class/Actor.lua
@@ -73,6 +73,7 @@ _M.temporary_values_conf.global_speed_add = "newest"
_M.temporary_values_conf.movement_speed = "mult0"
_M.temporary_values_conf.combat_physspeed = "mult0"
_M.temporary_values_conf.combat_spellspeed = "mult0"
+_M.temporary_values_conf.combat_mentalspeed = "mult0"
-- Damage cap takes the lowest
_M.temporary_values_conf.flat_damage_cap = "lowest"
@@ -96,6 +97,7 @@ function _M:init(t, no_default)
self.combat_physcrit = 0
self.combat_physspeed = 1
self.combat_spellspeed = 1
+ self.combat_mentalspeed = 1
self.combat_spellcrit = 0
self.combat_spellpower = 0
self.combat_mindpower = 0
@@ -338,7 +340,7 @@ function _M:actBase()
if self:hasEffect(self.EFF_SOLIPSISM) then
self:removeEffect(self.EFF_SOLIPSISM)
end
- self:setEffect(self.EFF_CLARITY, 1, {power = current_psi_percentage - self:attr("clarity_threshold")})
+ self:setEffect(self.EFF_CLARITY, 1, {power = math.max(0.5, current_psi_percentage - self:attr("clarity_threshold"))})
elseif self:hasEffect(self.EFF_SOLIPSISM) then
self:removeEffect(self.EFF_SOLIPSISM)
elseif self:hasEffect(self.EFF_CLARITY) then
@@ -381,8 +383,8 @@ function _M:actBase()
self:regenResources()
-- update psionic feedback
- if self.psionic_feedback and self.psionic_feedback > 0 then
- self.psionic_feedback = math.max(0, self.psionic_feedback - 1)
+ if self:getFeedback() > 0 then
+ self:incFeedback(-self:getFeedbackDecay())
end
-- Compute timed effects
@@ -461,6 +463,10 @@ function _M:actBase()
self:forceUseTalent(self.T_DAUNTING_PRESENCE, {ignore_energy=true})
end
end
+ if self:isTalentActive(self.T_FEEDBACK_OVERFLOW) and self:attr("psionic_overflow") then
+ local t = self:getTalentFromId(self.T_FEEDBACK_OVERFLOW)
+ t.doOverflowDischarge(self, t)
+ end
self:triggerHook{"Actor:actBase:Effects"}
end
@@ -1329,10 +1335,10 @@ function _M:regenLife()
if self.life_regen and not self:attr("no_life_regen") then
local regen = self.life_regen * util.bound((self.healing_factor or 1), 0, 2.5)
- -- Psionic Balance
- if self:knowTalent(self.T_BALANCE) then
- local t = self:getTalentFromId(self.T_BALANCE)
- local ratio = t.getBalanceRatio(self, t)
+ -- Solipsism
+ if self:knowTalent(self.T_SOLIPSISM) then
+ local t = self:getTalentFromId(self.T_SOLIPSISM)
+ local ratio = t.getConversionRatio(self, t)
local psi_increase = regen * ratio
self:incPsi(psi_increase)
-- Quality of life hack, doesn't decrease life regen while resting.. was way to painful
@@ -1395,9 +1401,9 @@ function _M:onHeal(value, src)
end
-- Psionic Balance
- if self:knowTalent(self.T_BALANCE) then
- local t = self:getTalentFromId(self.T_BALANCE)
- local ratio = t.getBalanceRatio(self, t)
+ if self:knowTalent(self.T_SOLIPSISM) then
+ local t = self:getTalentFromId(self.T_SOLIPSISM)
+ local ratio = t.getConversionRatio(self, t)
local psi_increase = value * ratio
self:incPsi(psi_increase)
value = value - psi_increase
@@ -1455,6 +1461,11 @@ function _M:onTakeHit(value, src)
return 0
end
+ if self.knowTalent and self:knowTalent(self.T_DISMISSAL) then
+ local t = self:getTalentFromId(self.T_DISMISSAL)
+ value = t.doDismissalOnHit(self, value, src, t)
+ end
+
if self:attr("retribution") then
-- Absorb damage into the retribution
if value / 2 <= self.retribution_absorb then
@@ -1645,16 +1656,29 @@ function _M:onTakeHit(value, src)
end
-- Feedback pool: Stores damage as energy to use later
- if self.psionic_feedback then
- local current = self.psionic_feedback
- local max = self.psionic_feedback_max or 100
- self.psionic_feedback = math.min(self.psionic_feedback_max, self.psionic_feedback + value)
+ if self:getMaxFeedback() > 0 and src ~= self then
+ local ratio = 0.5
+ if self:knowTalent(self.T_FEEDBACK) then
+ local t = self:getTalentFromId(self.T_FEEDBACK)
+ ratio = t.getConversionRatio(self, t)
+ end
+
+ local feedback_gain = value * ratio
+
+ -- Overflow?
+ if self:isTalentActive(self.T_FEEDBACK_OVERFLOW) then
+ local set_overflow = feedback_gain + self:getFeedback() - self:getMaxFeedback()
+ if set_overflow > 0 then
+ self.psionic_overflow = math.min(self.psionic_overflow_max, set_overflow + (self.psionic_overflow or 0))
+ end
+ end
+ self:incFeedback(feedback_gain)
end
-- Solipsism
- if self.knowTalent and self:knowTalent(self.T_SOLIPSISM) then
+ if self:knowTalent(self.T_SOLIPSISM) then
local t = self:getTalentFromId(self.T_SOLIPSISM)
- local damage_to_psi = value * t.damageToPsi(self, t)
+ local damage_to_psi = value * t.getConversionRatio(self, t)
if self:getPsi() > damage_to_psi then
self:incPsi(-damage_to_psi)
else
@@ -2474,6 +2498,15 @@ function _M:onWear(o, bypass_set)
o:check("on_wear", self)
if o.wielder then
for k, e in pairs(o.wielder) do
+ -- Apply Psychometry
+ if self:knowTalent(self.T_PSYCHOMETRY) and o.power_source and (o.power_source.psionic or o.power_source.nature or o.power_source.antimagic) then
+ local multiplier = 0.05 + (self:getTalentLevel(self.T_PSYCHOMETRY) / 33)
+ if e >= 1 then
+ e = math.ceil(e * (1 + multiplier))
+ else
+ e = e * (1 + multiplier)
+ end
+ end
o.wielded[k] = self:addTemporaryValue(k, e)
end
end
@@ -2947,6 +2980,60 @@ function _M:incVim(v)
end
end
+-- Feedback Psuedo-Resource Functions
+function _M:getFeedback()
+ if self.psionic_feedback then
+ return self.psionic_feedback
+ else
+ return 0
+ end
+end
+
+function _M:getMaxFeedback()
+ if self.psionic_feedback_max then
+ return self.psionic_feedback_max
+ else
+ return 0
+ end
+end
+
+function _M:incFeedback(v, set)
+ if not set then
+ self.psionic_feedback = util.bound(self.psionic_feedback + v, 0, self:getMaxFeedback())
+ else
+ self.psionic_feedback = math.min(v, self:getMaxFeedback())
+ end
+end
+
+function _M:incMaxFeedback(v, set)
+ -- give the actor base feedback if it doesn't have any
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+
+ if not set then
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + v
+ else
+ self.psionic_feedback_max = v
+ end
+
+ -- auto unlearn feedback if below 0
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback = nil
+ self.psionic_feedback_max = nil
+ end
+end
+
+function _M:getFeedbackDecay()
+ if self.psionic_feedback and self.psionic_feedback > 0 then
+ local feedback_decay = math.max(1, self.psionic_feedback / 10)
+ return feedback_decay
+ else
+ return 0
+ end
+end
+
+
--- Called before a talent is used
-- Check the actor can cast it
-- @param ab the talent (not the id, the table)
@@ -3046,9 +3133,15 @@ function _M:preUseTalent(ab, silent, fake)
if not silent then game.logPlayer(self, "You do not have enough hate to use %s.", ab.name) end
return false
end
- if ab.psi and self:getPsi() < ab.psi * (100 + 2 * self:combatFatigue()) / 100 then
- if not silent then game.logPlayer(self, "You do not have enough energy to cast %s.", ab.name) end
+ if ab.psi then
+ local talent_cost = ab.psi * (100 + 2 * self:combatFatigue()) / 100
+ if self:getPsi() < talent_cost and self:getFeedback() < talent_cost then
+ if not silent then game.logPlayer(self, "You do not have enough energy to cast %s.", ab.name) end
return false
+ end
+ end
+ if ab.feedback and self:getFeedback() < ab.feedback * (100 + 2 * self:combatFatigue()) / 100 then
+ if not silent then game.logPlayer(self, "You do not have enough energy to cast %s.", ab.name) end
end
end
@@ -3181,6 +3274,8 @@ function _M:postUseTalent(ab, ret)
self:useEnergy(game.energy_to_act * self:combatSummonSpeed())
elseif ab.type[1]:find("^technique/") then
self:useEnergy(game.energy_to_act * self:combatSpeed())
+ elseif ab.type[1]:find("^psionic/") then
+ self:useEnergy(game.energy_to_act * self:combatMentalSpeed())
else
self:useEnergy()
end
@@ -3284,7 +3379,18 @@ function _M:postUseTalent(ab, ret)
trigger = true; self:incParadox(ab.paradox * (1 + (self.paradox / 300)))
end
if ab.psi and not self:attr("zero_resource_cost") then
- trigger = true; self:incPsi(-ab.psi * (100 + 2 * self:combatFatigue()) / 100)
+ trigger = true
+ local cost = ab.psi * (100 + 2 * self:combatFatigue()) / 100
+ -- Feedback adjustment
+ if self:getFeedback() > 0 then
+ local old_cost = cost
+ cost = cost - self:getFeedback()
+ self:incFeedback(-old_cost)
+ end
+ self:incPsi(-cost)
+ end
+ if ab.feedback and not self:attr("zero_resource_cost") then
+ trigger = true; self:incFeedback(-ab.feedback * (100 + 2 * self:combatFatigue()) / 100)
end
end
@@ -3371,9 +3477,6 @@ function _M:breakStepUp()
if self:hasEffect(self.EFF_REFLEXIVE_DODGING) then
self:removeEffect(self.EFF_REFLEXIVE_DODGING)
end
- if self:hasEffect(self.EFF_DISMISSAL) then
- self:removeEffect(self.EFF_DISMISSAL)
- end
end
--- Breaks lightning speed if active
@@ -3428,6 +3531,7 @@ function _M:getTalentFullDescription(t, addlevel, config)
if t.hate or t.sustain_hate then d:add({"color",0x6f,0xff,0x83}, "Hate cost: ", {"color", 127, 127, 127}, ""..(t.hate or t.sustain_hate * (100 + 2 * self:combatFatigue()) / 100), true) end
if t.paradox or t.sustain_paradox then d:add({"color",0x6f,0xff,0x83}, "Paradox cost: ", {"color", 176, 196, 222}, ("%0.2f"):format(t.sustain_paradox or t.paradox * (1 + (self.paradox / 300))), true) end
if t.psi or t.sustain_psi then d:add({"color",0x6f,0xff,0x83}, "Psi cost: ", {"color",0x7f,0xff,0xd4}, ""..(t.sustain_psi or t.psi * (100 + 2 * self:combatFatigue()) / 100), true) end
+ if t.feedback or t.sustain_feedback then d:add({"color",0x6f,0xff,0x83}, "Feedback cost: ", {"color",0xFF, 0xFF, 0x00}, ""..(t.sustain_feedback or t.feedback * (100 + 2 * self:combatFatigue()) / 100), true) end
end
if t.mode ~= "passive" then
if self:getTalentRange(t) > 1 then d:add({"color",0x6f,0xff,0x83}, "Range: ", {"color",0xFF,0xFF,0xFF}, ("%0.2f"):format(self:getTalentRange(t)), true)
@@ -3767,7 +3871,13 @@ function _M:on_set_temporary_effect(eff_id, e, p)
if not p.no_ct_effect and not e.no_ct_effect and e.status == "detrimental" then self:crossTierEffect(eff_id, p.apply_power, p.apply_save or save_for_effects[e.type]) end
p.total_dur = p.dur
- if e.status == "detrimental" and self:checkHit(save, p.apply_power, 0, 95) then
+ -- Bonus save for schism
+ if self:attr("psionic_schism") and e.status == "detrimental" and save_type == "combatMentalResist" and self:checkHit(save, p.apply_power, 0, 95) then
+ game.logSeen(self, "#ORANGE#%s mental clone shrugs off the effect '%s'!", self.name:capitalize(), e.desc)
+ p.dur = 0
+ end
+
+ if e.status == "detrimental" and self:checkHit(save, p.apply_power, 0, 95) and p.dur > 0 then
game.logSeen(self, "#ORANGE#%s shrugs off the effect '%s'!", self.name:capitalize(), e.desc)
p.dur = 0
end
diff --git a/game/modules/tome/class/Object.lua b/game/modules/tome/class/Object.lua
index 2d39b119e3..c3a2a0b8af 100644
--- a/game/modules/tome/class/Object.lua
+++ b/game/modules/tome/class/Object.lua
@@ -529,6 +529,24 @@ function _M:getTextualDesc(compare_with)
if special ~= "" then
desc:add(found and {"color","WHITE"} or {"color","GREEN"}, "Special effect when this weapon crits: "..special, {"color","LAST"}, true)
end
+
+ local special = ""
+ if combat.special_on_kill then
+ special = combat.special_on_kill.desc
+ end
+ local found = false
+ for i, v in ipairs(compare_with or {}) do
+ if v[field] and v[field].special_on_kill then
+ if special ~= v[field].special_on_kill.desc then
+ desc:add({"color","RED"}, "Special effect when this weapon kills: "..v[field].special_on_kill.desc, {"color","LAST"}, true)
+ else
+ found = true
+ end
+ end
+ end
+ if special ~= "" then
+ desc:add(found and {"color","WHITE"} or {"color","GREEN"}, "Special effect when this weapon kills: "..special, {"color","LAST"}, true)
+ end
found = false
for i, v in ipairs(compare_with or {}) do
@@ -949,6 +967,10 @@ function _M:getTextualDesc(compare_with)
if w.demon then
desc:add("The wearer is treated as a demon.", true)
end
+
+ if w.blind then
+ desc:add("The wearer is blinded.", true)
+ end
if w.blind_fight then
desc:add({"color", "YELLOW"}, "Blind-Fight:", {"color", "LAST"}, "This item allows the wearer to attack unseen targets without any penalties.", true)
diff --git a/game/modules/tome/class/PlayerDisplay.lua b/game/modules/tome/class/PlayerDisplay.lua
index 85c985fd2d..f01240a2f1 100644
--- a/game/modules/tome/class/PlayerDisplay.lua
+++ b/game/modules/tome/class/PlayerDisplay.lua
@@ -373,8 +373,8 @@ function _M:display()
)) h = h + self.font_h
end
- if player.psionic_feedback_max then
- self:mouseTooltip(self.TOOLTIP_FEEDBACK, self:makeTextureBar("#7fffd4#Feedback:", nil, player.psionic_feedback or 0, player.psionic_feedback_max, -1, x, h, 255, 255, 255,
+ if player:getMaxFeedback() > 0 then
+ self:mouseTooltip(self.TOOLTIP_FEEDBACK, self:makeTextureBar("#7fffd4#Feedback:", nil, player:getFeedback(), player:getMaxFeedback(), player:getFeedbackDecay(), x, h, 255, 255, 255,
{r=colors.YELLOW.r / 2, g=colors.YELLOW.g / 2, b=colors.YELLOW.b / 2},
{r=colors.YELLOW.r / 5, g=colors.YELLOW.g / 5, b=colors.YELLOW.b / 5}
)) h = h + self.font_h
diff --git a/game/modules/tome/class/interface/Archery.lua b/game/modules/tome/class/interface/Archery.lua
index efe33461c4..93394361ab 100644
--- a/game/modules/tome/class/interface/Archery.lua
+++ b/game/modules/tome/class/interface/Archery.lua
@@ -306,14 +306,24 @@ local function archery_projectile(tx, ty, tg, self, tmp)
end
-- Special effect on crit
- if crit and weapon and weapon.special_on_crit and weapon.special_on_crit.fct and (not target.dead or weapon.special_on_hit.on_kill) then
+ if crit and weapon and weapon.special_on_crit and weapon.special_on_crit.fct and (not target.dead or weapon.special_on_crit.on_kill) then
weapon.special_on_crit.fct(weapon, self, target)
end
-- Special effect on crit AMMO!
- if crit and ammo and ammo.special_on_crit and ammo.special_on_crit.fct and (not target.dead or ammo.special_on_hit.on_kill) then
+ if crit and ammo and ammo.special_on_crit and ammo.special_on_crit.fct and (not target.dead or ammo.special_on_crit.on_kill) then
ammo.special_on_crit.fct(ammo, self, target)
end
+
+ -- Special effect on kill
+ if hitted and weapon and weapon.special_on_kill and weapon.special_on_kill.fct and target.dead then
+ weapon.special_on_kill.fct(weapon, self, target)
+ end
+
+ -- Special effect on kill A-A-A-AMMMO!
+ if hitted and ammo and ammo.special_on_kill and ammo.special_on_kill.fct and target.dead then
+ ammo.special_on_kill.fct(ammo, self, target)
+ end
-- Temporal cast
if hitted and not target.dead and self:knowTalent(self.T_WEAPON_FOLDING) and self:isTalentActive(self.T_WEAPON_FOLDING) then
diff --git a/game/modules/tome/class/interface/Combat.lua b/game/modules/tome/class/interface/Combat.lua
index e1029d2934..fb8abecea3 100644
--- a/game/modules/tome/class/interface/Combat.lua
+++ b/game/modules/tome/class/interface/Combat.lua
@@ -613,6 +613,10 @@ function _M:attackTargetWith(target, weapon, damtype, mult, force_dam)
if hitted and crit and weapon and weapon.special_on_crit and weapon.special_on_crit.fct and (not target.dead or weapon.special_on_crit.on_kill) then
weapon.special_on_crit.fct(weapon, self, target)
end
+
+ if hitted and weapon and weapon.special_on_kill and weapon.special_on_kill.fct and target.dead then
+ weapon.special_on_kill.fct(weapon, self, target)
+ end
-- Poison coating
@@ -994,7 +998,7 @@ function _M:combatPhysicalpower(mod, weapon)
if not weapon then
local inven = self:getInven(self.INVEN_MAINHAND)
- if inven and inven[1] then weapon = inven[1].combat end
+ if inven and inven[1] then weapon = inven[1].combat else weapon = self.combat end
end
add = add + 5 * self:combatCheckTraining(weapon)
@@ -1101,6 +1105,11 @@ function _M:combatSpellSpeed()
return 1 / self.combat_spellspeed
end
+-- Gets mental speed
+function _M:combatMentalSpeed()
+ return 1 / self.combat_mentalspeed
+end
+
--- Gets summon speed
function _M:combatSummonSpeed()
return math.max(1 - ((self:attr("fast_summons") or 0) / 100), 0.1)
@@ -1318,7 +1327,17 @@ function _M:combatSpellResist(fake)
if self:knowTalent(self.T_POWER_IS_MONEY) then
add = add + util.bound(self.money / (90 - self:getTalentLevelRaw(self.T_POWER_IS_MONEY) * 5), 0, self:getTalentLevelRaw(self.T_POWER_IS_MONEY) * 7)
end
- return self:rescaleCombatStats(self.combat_spellresist + (self:getMag() + self:getWil() + (self:getLck() - 50) * 0.5) * 0.35 + add)
+
+ -- To return later
+ local total = self:rescaleCombatStats(self.combat_spellresist + (self:getMag() + self:getWil() + (self:getLck() - 50) * 0.5) * 0.35 + add)
+
+ -- Psionic Balance
+ if self:knowTalent(self.T_BALANCE) then
+ local t = self:getTalentFromId(self.T_BALANCE)
+ local ratio = t.getBalanceRatio(self, t)
+ total = (1 - ratio)*total + self:combatMentalResist(fake)*ratio
+ end
+ return total
end
--- Computes mental resistance
diff --git a/game/modules/tome/class/interface/TooltipsData.lua b/game/modules/tome/class/interface/TooltipsData.lua
index 5b1c44f799..96ddefa194 100644
--- a/game/modules/tome/class/interface/TooltipsData.lua
+++ b/game/modules/tome/class/interface/TooltipsData.lua
@@ -116,9 +116,10 @@ Your capacity for storing energy is determined by your Willpower.
]]
TOOLTIP_FEEDBACK = [[#GOLD#Feedback#LAST#
-Feedback represents energy you've stored up from being attacked. It decays quickly over time.
-To get meaningful amounts back in combat, you must take damage.
+Feedback represents using pain as a means of psionic grounding and it can be used in place of Psi.
+To get meaningful amounts back in combat, you must take damage (at a base 50%% conversion rate though some talents can improve this ratio).
Your capacity for storing feedback is determined by how many talents you know that harness it.
+Feedback decays quickly over time.
]]
TOOLTIP_NECROTIC_AURA = [[#GOLD#Necrotic Aura#LAST#
@@ -165,7 +166,11 @@ The additional time you have to attack (in melee or ranged).
It represents how many more attacks you can do in the same time.
I.E: at 100% you will be able to do 100% more attacks (aka twice as many) in the same time it would have taken you to do one at 0% speed.
]]
-
+TOOLTIP_SPEED_MENTAL = [[#GOLD#Mental Speed#LAST#
+The additional time you have to use a mental power.
+It represents how many more mental powers you can do in the same time.
+I.E: at 100% you will be able to do 100% more attacks (aka twice as many) in the same time it would have taken you to do one at 0% speed.
+]]
-------------------------------------------------------------
-- Stats
-------------------------------------------------------------
diff --git a/game/modules/tome/class/uiset/Minimalist.lua b/game/modules/tome/class/uiset/Minimalist.lua
index d088dccab2..3d53ac70f8 100644
--- a/game/modules/tome/class/uiset/Minimalist.lua
+++ b/game/modules/tome/class/uiset/Minimalist.lua
@@ -981,16 +981,16 @@ function _M:displayResources(scale, bx, by, a)
sshat[1]:toScreenFull(x-6, y+8, sshat[6], sshat[7], sshat[2], sshat[3], 1, 1, 1, a)
bshat[1]:toScreenFull(x, y, bshat[6], bshat[7], bshat[2], bshat[3], 1, 1, 1, a)
if feedback_sha.shad then feedback_sha:setUniform("a", a) feedback_sha.shad:use(true) end
- local p = player.psionic_feedback / player.psionic_feedback_max
+ local p = player:getFeedback() / player:getMaxFeedback()
shat[1]:toScreenPrecise(x+49, y+10, shat[6] * p, shat[7], 0, p * 1/shat[4], 0, 1/shat[5], feedback_c[1], feedback_c[2], feedback_c[3], a)
if feedback_sha.shad then feedback_sha.shad:use(false) end
- if not self.res.feedback or self.res.feedback.vc ~= player.psionic_feedback or self.res.feedback.vm ~= player.psionic_feedback_max or self.res.feedback.vr ~= -1 then
+ if not self.res.feedback or self.res.feedback.vc ~= player:getFeedback() or self.res.feedback.vm ~= player:getMaxFeedback() or self.res.feedback.vr ~= player:getFeedbackDecay() then
self.res.feedback = {
hidable = "Feedback",
- vc = player.psionic_feedback, vm = player.psionic_feedback_max, vr = -1,
- cur = {core.display.drawStringBlendedNewSurface(font_sha, ("%d/%d"):format(player.psionic_feedback, player.psionic_feedback_max), 255, 255, 255):glTexture()},
- regen={core.display.drawStringBlendedNewSurface(sfont_sha, ("%+0.2f"):format(-1), 255, 255, 255):glTexture()},
+ vc = player:getFeedback(), vm = player:getMaxFeedback(), vr = player:getFeedbackDecay(),
+ cur = {core.display.drawStringBlendedNewSurface(font_sha, ("%d/%d"):format(player:getFeedback(), player:getMaxFeedback()), 255, 255, 255):glTexture()},
+ regen={core.display.drawStringBlendedNewSurface(sfont_sha, ("%+0.2f"):format(-player:getFeedbackDecay()), 255, 255, 255):glTexture()},
}
end
local dt = self.res.feedback.cur
diff --git a/game/modules/tome/data/birth/classes/psionic.lua b/game/modules/tome/data/birth/classes/psionic.lua
index 3e9565c426..87876b6b44 100644
--- a/game/modules/tome/data/birth/classes/psionic.lua
+++ b/game/modules/tome/data/birth/classes/psionic.lua
@@ -162,16 +162,32 @@ newBirthDescriptor{
"#LIGHT_BLUE# * +0 Magic, +5 Willpower, +4 Cunning",
"#GOLD#Life per level:#LIGHT_BLUE# -4 (*special*)",
},
+ not_on_random_boss = true, -- remove later, this is here so half-finished talents don't end up on bosses
power_source = {psionic=true},
stats = { str=0, wil=5, cun=4, },
talents_types = {
- ["psionic/feedback"]={true, 0.3},
- ["psionic/psychic-assault"]={true, 0.3},
+ -- class
+ ["psionic/discharge"]={true, 0},
+ ["psionic/distortion"]={true, 0.3},
+ ["psionic/slumber"]={true, 0.3},
["psionic/solipsism"]={true, 0.3},
+ ["psionic/thought-forms"]={true, 0.3},
+
+ -- generic
+ ["psionic/mentalism"]={true, 0.3},
+ ["cunning/survival"]={true, 0},
+ ["psionic/feedback"]={true, 0},
+
+ -- locked trees
+ ["psionic/psychic-assault"]={false, 0},
+ ["psionic/nightmare"]={false, 0.3},
+ -- generic
+ ["psionic/trance"]={false, 0.3},
+
},
talents = {
[ActorTalents.T_FEEDBACK] = 1,
- [ActorTalents.T_PSYCHIC_LOBOTOMY] = 1,
+ [ActorTalents.T_MIND_SEAR] = 1,
[ActorTalents.T_SOLIPSISM] = 1,
},
copy = {
diff --git a/game/modules/tome/data/damage_types.lua b/game/modules/tome/data/damage_types.lua
index f43952c8cb..3a5f0df9d6 100644
--- a/game/modules/tome/data/damage_types.lua
+++ b/game/modules/tome/data/damage_types.lua
@@ -250,6 +250,24 @@ setDefaultProjector(function(src, x, y, type, dam, tmp, no_martyr)
end
end
end
+
+ -- Psychic Projection
+ if src.attr and src:attr("is_psychic_projection") then
+ if type == DamageType.MIND then
+ if target.hasEffect and target:hasEffect(target.EFF_MINDLINK) then
+ local eff = target:hasEffect(target.EFF_MINDLINK)
+ if eff.src == self then
+ dam = dam
+ end
+ elseif target.subtype and target.subtype == "ghost" then
+ dam = dam
+ else
+ dam = 0
+ end
+ else
+ dam = 0
+ end
+ end
print("[PROJECTOR] final dam", dam)
@@ -456,7 +474,7 @@ newDamageType{
local mindpower, mentalresist
if _G.type(dam) == "table" then dam, mindpower, mentalresist, alwaysHit, crossTierChance = dam.dam, dam.mindpower, dam.mentalresist, dam.alwaysHit, dam.crossTierChance end
if alwaysHit or target:checkHit(mindpower or src:combatMindpower(), mentalresist or target:combatMentalResist(), 0, 95, 15) then
- if crossTierChance and rng.chance(crossTierChance) then
+ if crossTierChance and rng.percent(crossTierChance) then
target:crossTierEffect(target.EFF_BRAINLOCKED, src:combatMindpower())
end
return DamageType.defaultProjector(src, x, y, type, dam)
diff --git a/game/modules/tome/data/talents/cunning/ambush.lua b/game/modules/tome/data/talents/cunning/ambush.lua
index c532313061..7330184109 100644
--- a/game/modules/tome/data/talents/cunning/ambush.lua
+++ b/game/modules/tome/data/talents/cunning/ambush.lua
@@ -154,6 +154,7 @@ newTalent{
m.stealth = t.getStealthPower(self, t)
for i = 1, 10 do
m:unlearnTalent(m.T_AMBUSCADE)
+ m:unlearnTalent(m.T_PROJECTION) -- no recurssive projections
m:unlearnTalent(m.T_STEALTH)
m:unlearnTalent(m.T_HIDE_IN_PLAIN_SIGHT)
end
diff --git a/game/modules/tome/data/talents/misc/npcs.lua b/game/modules/tome/data/talents/misc/npcs.lua
index 2d8daebf62..557d447600 100644
--- a/game/modules/tome/data/talents/misc/npcs.lua
+++ b/game/modules/tome/data/talents/misc/npcs.lua
@@ -1045,33 +1045,6 @@ newTalent{
end,
}
-newTalent{
- name = "Mind Sear",
- type = {"psionic/other", 1},
- points = 5,
- cooldown = 2,
- psi = 5,
- range = 7,
- direct_hit = true,
- requires_target = true,
- target = function(self, t)
- return {type="beam", range=self:getTalentRange(t), talent=t}
- end,
- tactical = { ATTACK = { MIND = 3 } },
- action = function(self, t)
- local tg = self:getTalentTarget(t)
- local x, y = self:getTarget(tg)
- if not x or not y then return nil end
- self:project(tg, x, y, DamageType.MIND, self:mindCrit(self:combatTalentMindDamage(t, 10, 340)), {type="mind"})
- game:playSoundNear(self, "talents/spell_generic")
- return true
- end,
- info = function(self, t)
- return ([[Sends a telepathic attack, trying to destroy the brains of any target in the beam, doing %0.2f mind damage.
- The damage will increase with Willpower and Cunning stats.]]):format(self:combatTalentMindDamage(t, 10, 340))
- end,
-}
-
newTalent{
name = "Silence",
type = {"psionic/other", 1},
diff --git a/game/modules/tome/data/talents/psionic/discharge.lua b/game/modules/tome/data/talents/psionic/discharge.lua
new file mode 100644
index 0000000000..d28a897da9
--- /dev/null
+++ b/game/modules/tome/data/talents/psionic/discharge.lua
@@ -0,0 +1,229 @@
+-- ToME - Tales of Maj'Eyal
+-- Copyright (C) 2009, 2010, 2011, 2012 Nicolas Casalini
+--
+-- This program is free software: you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation, either version 3 of the License, or
+-- (at your option) any later version.
+--
+-- This program is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+-- GNU General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with this program. If not, see <http://www.gnu.org/licenses/>.
+--
+-- Nicolas Casalini "DarkGod"
+-- darkgod@te4.org
+
+-- Edge TODO: Sounds, Particles, Talent Icons; All Talents
+
+newTalent{
+ name = "Psychic Discharge",
+ type = {"psionic/discharge", 2},
+ points = 5,
+ require = psi_wil_req2,
+ cooldown = 5,
+ tactical = { DISABLE = 2},
+ range = 0,
+ direct_hit = true,
+ requires_target = true,
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 20, 150) end,
+ radius = function(self, t) return 1 + math.ceil(self:getTalentLevel(t)) end,
+ target = function(self, t)
+ return {type="cone", range=self:getTalentRange(t), radius=self:getTalentRadius(t), selffire=false}
+ end,
+ on_pre_use = function(self, t, silent) if self.psionic_feedback <= 0 then if not silent then game.logPlayer(self, "You have no feedback to power this talent.") end return false end return true end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 100
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 100
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ action = function(self, t)
+ local tg = self:getTalentTarget(t)
+ local x, y = self:getTarget(tg)
+
+ local damage = math.min(self.psionic_feedback, t.getDamage(self, t))
+ self:project(tg, x, y, DamageType.MIND, {dam=self:mindCrit(damage), crossTierChance=math.max(100, damage)})
+
+ self.psionic_feedback = self.psionic_feedback - damage
+
+ return true
+ end,
+ info = function(self, t)
+ local damage = t.getDamage(self, t)
+ local radius = self:getTalentRadius(t)
+ return ([[You now store damage you take from outside sources as psionic feedback. Activate to discharge up to %0.2f feedback in a %d radius cone. Targets in the area will suffer mind damage and may be brain locked by this attack.
+ Learning this talent will increase the amount of feedback you can store by 100 (first talent point only).
+ The damage will scale with your mindpower.]]):format(damage, radius)
+ end,
+}
+
+newTalent{
+ name = "Conversion",
+ type = {"psionic/discharge", 2},
+ points = 5,
+ require = psi_wil_req2,
+ cooldown = 15,
+ tactical = { PSI = 2},
+ on_pre_use = function(self, t, silent) if self:getFeedback() > 0 then if not silent then game.logPlayer(self, "You have no feedback to power this talent.") end return false end return true end,
+ getShieldPower = function(self, t) return self:combatTalentMindDamage(t, 20, 300) end,
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 10, 50) end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 50
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 50
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ action = function(self, t)
+ local power = math.min(self.psionic_feedback, t.getShieldPower(self, t))
+ self:setEffect(self.EFF_RESONANCE_SHIELD, 10, {power = self:mindCrit(power), dam = t.getDamage(self, t)})
+ self.psionic_feedback = self.psionic_feedback - power
+ return true
+ end,
+ info = function(self, t)
+ local shield_power = t.getShieldPower(self, t)
+ local damage = t.getDamage(self, t)
+ return ([[Activate to convert up to %0.2f feedback into a resonance shield that will absorb 50%% of all damage you take and inflict %0.2f mind damage to melee attackers.
+ Learning this talent will increase the amount of feedback you can store by 50 (first talent point only).
+ The conversion ratio will scale with your mindpower and the effect lasts up to ten turns.]]):format(shield_power, damDesc(self, DamageType.MIND, damage))
+ end,
+}
+
+newTalent{
+ name = "Feedback Overflow",
+ type = {"psionic/discharge", 3},
+ points = 5,
+ require = psi_wil_req3,
+ mode = "sustained",
+ sustain_psi = 20,
+ cooldown = 18,
+ tactical = { BUFF = 2 },
+ getMaxOverflow = function(self, t) return self.psionic_feedback_max * (self:combatTalentMindDamage(t, 20, 100)/100) end,
+ radius = function(self, t) return math.ceil(self:getTalentLevel(t)/2) end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 50
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 50
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ doOverflowDischarge = function(self, t)
+ local tg = {type="ball", range=0, radius=self:getTalentRadius(t), selffire=false, friendlyfire=false}
+ local damage = self.psionic_overflow
+ self:project(tg, self.x, self.y, DamageType.MIND, self:mindCrit(damage))
+ -- Lose remaining overflow
+ self.psionic_overflow = nil
+ end,
+ activate = function(self, t)
+ game:playSoundNear(self, "talents/flame")
+ return {
+ ov = self:addTemporaryValue("psionic_overflow_max", t.getMaxOverflow(self, t)),
+ }
+ end,
+ deactivate = function(self, t, p)
+ self:removeTemporaryValue("psionic_overflow_max", p.ov)
+ return true
+ end,
+ info = function(self, t)
+ local overflow = t.getMaxOverflow(self, t)
+ local radius = self:getTalentRadius(t)
+ return ([[While active you store up to %d excess feedback as overflow. At the start of your turn the overflow will be unleased as mind damage in a radius of %d.
+ Learning this talent will increase the amount of feedback you can store by 50 (first talent point only).
+ The max excess you can store will improve with your mindpower and max feedback.]]):format(overflow, radius)
+ end,
+}
+
+newTalent{
+ name = "Kinetic Discharge",
+ type = {"psionic/discharge", 4},
+ points = 5,
+ require = psi_wil_req4,
+ cooldown = 10,
+ tactical = { ATTACKAREA = {PHYSICAL = 2}, DISABLE = { knockback = 2 }, },
+ range = 0,
+ radius = function(self, t) return 1 + math.ceil(self:getTalentLevel(t)) end,
+ direct_hit = true,
+ requires_target = true,
+ target = function(self, t)
+ return {type="ball", range=self:getTalentRange(t), talent=t}
+ end,
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 20, 230) end,
+ on_pre_use = function(self, t, silent) if self.psionic_feedback <= 0 then if not silent then game.logPlayer(self, "You have no feedback to power this talent.") end return false end return not self:hasEffect(self.EFF_REGENERATION) end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 50
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 50
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ action = function(self, t)
+ local tg = self:getTalentTarget(t)
+ if not x or not y then return nil end
+
+ local damage = math.min(self.psionic_feedback, t.getDamage(self, t))
+ self:project(tg, x, y, DamageType.MINDKNOCKBACK, self:mindCrit(damage))
+ self.psionic_feedback = self.psionic_feedback - damage
+
+ return true
+ end,
+ info = function(self, t)
+ local damage = t.getDamage(self, t)
+ local radius = self:getTalentRadius(t)
+ return ([[Activate to convert up to %0.2f of stored feedback into a blast of kinetic energy. Targets out to a radius of %d will suffer physical damage and may be knocked back.
+ Learning this talent will increase the amount of feedback you can store by 50 (first talent point only).
+ The damage will scale with your mindpower.]]):format(damDesc(self, DamageType.PHYSICAL, damage), radius)
+ end,
+}
\ No newline at end of file
diff --git a/game/modules/tome/data/talents/psionic/distortion.lua b/game/modules/tome/data/talents/psionic/distortion.lua
new file mode 100644
index 0000000000..589ddcb1e6
--- /dev/null
+++ b/game/modules/tome/data/talents/psionic/distortion.lua
@@ -0,0 +1,229 @@
+-- ToME - Tales of Maj'Eyal
+-- Copyright (C) 2009, 2010, 2011, 2012 Nicolas Casalini
+--
+-- This program is free software: you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation, either version 3 of the License, or
+-- (at your option) any later version.
+--
+-- This program is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+-- GNU General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with this program. If not, see <http://www.gnu.org/licenses/>.
+--
+-- Nicolas Casalini "DarkGod"
+-- darkgod@te4.org
+
+-- Edge TODO: Sounds, Particles, Talent Icons; All Talents
+
+newTalent{
+ name = "Distortion",
+ type = {"psionic/distortion", 1},
+ points = 5,
+ require = psi_wil_req1,
+ cooldown = 5,
+ tactical = { DISABLE = 2},
+ range = 0,
+ direct_hit = true,
+ requires_target = true,
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 20, 150) end,
+ radius = function(self, t) return 1 + math.ceil(self:getTalentLevel(t)) end,
+ target = function(self, t)
+ return {type="cone", range=self:getTalentRange(t), radius=self:getTalentRadius(t), selffire=false}
+ end,
+ on_pre_use = function(self, t, silent) if self.psionic_feedback <= 0 then if not silent then game.logPlayer(self, "You have no feedback to power this talent.") end return false end return true end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 100
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 100
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ action = function(self, t)
+ local tg = self:getTalentTarget(t)
+ local x, y = self:getTarget(tg)
+
+ local damage = math.min(self.psionic_feedback, t.getDamage(self, t))
+ self:project(tg, x, y, DamageType.MIND, {dam=self:mindCrit(damage), crossTierChance=math.max(100, damage)})
+
+ self.psionic_feedback = self.psionic_feedback - damage
+
+ return true
+ end,
+ info = function(self, t)
+ local damage = t.getDamage(self, t)
+ local radius = self:getTalentRadius(t)
+ return ([[You now store damage you take from outside sources as psionic feedback. Activate to distortion up to %0.2f feedback in a %d radius cone. Targets in the area will suffer mind damage and may be brain locked by this attack.
+ Learning this talent will increase the amount of feedback you can store by 100 (first talent point only).
+ The damage will scale with your mindpower.]]):format(damage, radius)
+ end,
+}
+
+newTalent{
+ name = "Distortion 2",
+ type = {"psionic/distortion", 2},
+ points = 5,
+ require = psi_wil_req2,
+ mode = "sustained",
+ sustain_psi = 20,
+ cooldown = 18,
+ tactical = { BUFF = 2 },
+ getMaxOverflow = function(self, t) return self.psionic_feedback_max * (self:combatTalentMindDamage(t, 20, 100)/100) end,
+ radius = function(self, t) return math.ceil(self:getTalentLevel(t)/2) end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 50
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 50
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ doOverflowdistortion = function(self, t)
+ local tg = {type="ball", range=0, radius=self:getTalentRadius(t), selffire=false, friendlyfire=false}
+ local damage = self.psionic_overflow
+ self:project(tg, self.x, self.y, DamageType.MIND, self:mindCrit(damage))
+ -- Lose remaining overflow
+ self.psionic_overflow = nil
+ end,
+ activate = function(self, t)
+ game:playSoundNear(self, "talents/flame")
+ return {
+ ov = self:addTemporaryValue("psionic_overflow_max", t.getMaxOverflow(self, t)),
+ }
+ end,
+ deactivate = function(self, t, p)
+ self:removeTemporaryValue("psionic_overflow_max", p.ov)
+ return true
+ end,
+ info = function(self, t)
+ local overflow = t.getMaxOverflow(self, t)
+ local radius = self:getTalentRadius(t)
+ return ([[While active you store up to %d excess feedback as overflow. At the start of your turn the overflow will be unleased as mind damage in a radius of %d.
+ Learning this talent will increase the amount of feedback you can store by 50 (first talent point only).
+ The max excess you can store will improve with your mindpower and max feedback.]]):format(overflow, radius)
+ end,
+}
+
+newTalent{
+ name = "Distortion 3",
+ type = {"psionic/distortion", 3},
+ points = 5,
+ require = psi_wil_req3,
+ cooldown = 10,
+ tactical = { ATTACKAREA = {PHYSICAL = 2}, DISABLE = { knockback = 2 }, },
+ range = 0,
+ radius = function(self, t) return 1 + math.ceil(self:getTalentLevel(t)) end,
+ direct_hit = true,
+ requires_target = true,
+ target = function(self, t)
+ return {type="ball", range=self:getTalentRange(t), talent=t}
+ end,
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 20, 230) end,
+ on_pre_use = function(self, t, silent) if self.psionic_feedback <= 0 then if not silent then game.logPlayer(self, "You have no feedback to power this talent.") end return false end return not self:hasEffect(self.EFF_REGENERATION) end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 50
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 50
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ action = function(self, t)
+ local tg = self:getTalentTarget(t)
+ if not x or not y then return nil end
+
+ local damage = math.min(self.psionic_feedback, t.getDamage(self, t))
+ self:project(tg, x, y, DamageType.MINDKNOCKBACK, self:mindCrit(damage))
+ self.psionic_feedback = self.psionic_feedback - damage
+
+ return true
+ end,
+ info = function(self, t)
+ local damage = t.getDamage(self, t)
+ local radius = self:getTalentRadius(t)
+ return ([[Activate to convert up to %0.2f of stored feedback into a blast of kinetic energy. Targets out to a radius of %d will suffer physical damage and may be knocked back.
+ Learning this talent will increase the amount of feedback you can store by 50 (first talent point only).
+ The damage will scale with your mindpower.]]):format(damDesc(self, DamageType.PHYSICAL, damage), radius)
+ end,
+}
+
+newTalent{
+ name = "Distortion 4",
+ type = {"psionic/distortion", 4},
+ points = 5,
+ require = psi_wil_req4,
+ cooldown = 15,
+ tactical = { DEFEND = 2, ATTACK = {MIND = 2}},
+ on_pre_use = function(self, t, silent) if self.psionic_feedback <= 0 then if not silent then game.logPlayer(self, "You have no feedback to power this talent.") end return false end return true end,
+ getShieldPower = function(self, t) return self:combatTalentMindDamage(t, 20, 300) end,
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 10, 50) end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 100
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 100
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ action = function(self, t)
+ local power = math.min(self.psionic_feedback, t.getShieldPower(self, t))
+ self:setEffect(self.EFF_RESONANCE_SHIELD, 10, {power = self:mindCrit(power), dam = t.getDamage(self, t)})
+ self.psionic_feedback = self.psionic_feedback - power
+ return true
+ end,
+ info = function(self, t)
+ local shield_power = t.getShieldPower(self, t)
+ local damage = t.getDamage(self, t)
+ return ([[Activate to conver up to %0.2f feedback into a resonance shield that will absorb 50%% of all damage you take and inflict %0.2f mind damage to melee attackers.
+ Learning this talent will increase the amount of feedback you can store by 100 (first talent point only).
+ The conversion ratio will scale with your mindpower and the effect lasts up to ten turns.]]):format(shield_power, damDesc(self, DamageType.MIND, damage))
+ end,
+}
\ No newline at end of file
diff --git a/game/modules/tome/data/talents/psionic/feedback.lua b/game/modules/tome/data/talents/psionic/feedback.lua
index 9c8f0a9624..687b3d5ed3 100644
--- a/game/modules/tome/data/talents/psionic/feedback.lua
+++ b/game/modules/tome/data/talents/psionic/feedback.lua
@@ -17,130 +17,42 @@
-- Nicolas Casalini "DarkGod"
-- darkgod@te4.org
--- TODO: Sounds and particles
+-- Edge TODO: Sounds, Particles, Talent Icons; All Talents
newTalent{
name = "Feedback",
type = {"psionic/feedback", 1},
- points = 5,
+ points = 5,
require = psi_wil_req1,
- cooldown = 10,
- psi = 10,
- tactical = { PSI = 2 },
- on_pre_use = function(self, t, silent) if self.psionic_feedback <= 0 then if not silent then game.logPlayer(self, "You have no feedback to power this talent.") end return false end return not self:hasEffect(self.EFF_REGENERATION) end,
- getConversionRatio = function(self, t) return self:combatTalentMindDamage(t, 50, 150)/100 end,
+ mode = "passive",
+ dont_provide_pool = true,
+ getConversionRatio = function(self, t) return (50 + self:combatTalentMindDamage(t, 10, 100)) / 100 end,
on_learn = function(self, t)
- if self:getTalentLevelRaw(t) == 1 then
- if not self.psionic_feedback then
- self.psionic_feedback = 0
- end
- self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 50
- end
+ self:incMaxFeedback(10)
return true
end,
on_unlearn = function(self, t)
- if not self:knowTalent(t) then
- self.psionic_feedback_max = self.psionic_feedback_max - 50
- if self.psionic_feedback_max <= 0 then
- self.psionic_feedback_max = nil
- self.psionic_feedback = nil
- end
- end
- return true
- end,
- action = function(self, t)
- local power = self.psionic_feedback * t.getConversionRatio(self, t)
- self:setEffect(self.EFF_REGENERATION, 5, {power = self:mindCrit(power/5)})
- self.psionic_feedback = 0
+ self:incMaxFeedback(-10)
return true
end,
info = function(self, t)
local conversion = t.getConversionRatio(self, t)
- return ([[You now store damage you take as psionic feedback. Activating this talent removes all stored feedback, converting %d%% of the stored energy into life regen over the next five turns.
- Learning this talent will increase the amount of feedback you can store by 50 (first talent point only).
+ return ([[You channel your pain, gaining %d%% of all damage you take from outside sources as Psionic Feedback. When using powers that require Psi you'll spend Feedback first if you have any.
+ Each talent point invested will increase the amount of feedback you can store by 10 and Feedback will decay at the rate of 10%% or 1 per turn, whichever is greater.
The conversion ratio will scale with your mindpower.]]):format(conversion * 100)
end,
}
-newTalent{
- name = "Discharge",
- type = {"psionic/feedback", 2},
- points = 5,
- require = psi_wil_req2,
- cooldown = 10,
- psi = 10,
- tactical = { DISABLE = 2},
- range = 0,
- direct_hit = true,
- requires_target = true,
- getConversionRatio = function(self, t) return 100 - math.min(50, self:combatTalentMindDamage(t, 0, 50)) end,
- getDuration = function(self, t)
- local power = (self.psionic_feedback or 0) / t.getConversionRatio(self, t)
- local duration = 1 + math.floor(power)
- return duration
- end,
- radius = function(self, t) return math.ceil(self:getTalentLevel(t)) end,
- target = function(self, t)
- return {type="ball", range=self:getTalentRange(t), radius=self:getTalentRadius(t), selffire=false}
- end,
- on_pre_use = function(self, t, silent) if self.psionic_feedback <= 0 then if not silent then game.logPlayer(self, "You have no feedback to power this talent.") end return false end return true end,
- on_learn = function(self, t)
- if self:getTalentLevelRaw(t) == 1 then
- if not self.psionic_feedback then
- self.psionic_feedback = 0
- end
- self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 50
- end
- return true
- end,
- on_unlearn = function(self, t)
- if not self:knowTalent(t) then
- self.psionic_feedback_max = self.psionic_feedback_max - 50
- if self.psionic_feedback_max <= 0 then
- self.psionic_feedback_max = nil
- self.psionic_feedback = nil
- end
- end
- return true
- end,
- action = function(self, t)
- local tg = self:getTalentTarget(t)
-
- self:project(tg, self.x, self.y, function(px, py)
- local target = game.level.map(px, py, engine.Map.ACTOR)
- if not target then return end
-
- if target:canBe("stun") then
- target:setEffect(target.EFF_DAZED, math.floor(self:mindCrit(t.getDuration(self, t))), {apply_power=self:combatMindpower()})
- else
- game.logSeen(target, "%s resists the daze!", target.name:capitalize())
- end
- game.level.map:particleEmitter(px, py, 1, "light")
- end)
-
- self.psionic_feedback = 0
-
- return true
- end,
- info = function(self, t)
- local conversion = t.getConversionRatio(self, t)
- local radius = self:getTalentRadius(t)
- return ([[Activate to discharge all stored feedback, dazing creatures in a radius of %d for 1 turn. The duration of the effect will be increased by 1 for every %d feedback you have stored.
- Learning this talent will increase the amount of feedback you can store by 50 (first talent point only).
- The conversion ratio will scale with your mindpower.]]):format(radius, conversion)
- end,
-}
-
newTalent{
name = "Resonance Shield",
type = {"psionic/feedback", 3},
- points = 5,
+ points = 5,
+ feedback = 10,
require = psi_wil_req3,
cooldown = 15,
- psi = 10,
tactical = { DEFEND = 2, ATTACK = {MIND = 2}},
on_pre_use = function(self, t, silent) if self.psionic_feedback <= 0 then if not silent then game.logPlayer(self, "You have no feedback to power this talent.") end return false end return true end,
- getConversionRatio = function(self, t) return self:combatTalentMindDamage(t, 50, 150) / 100 end,
+ getShieldPower = function(self, t) return self:combatTalentMindDamage(t, 20, 300) end,
getDamage = function(self, t) return self:combatTalentMindDamage(t, 10, 50) end,
on_learn = function(self, t)
if self:getTalentLevelRaw(t) == 1 then
@@ -162,60 +74,17 @@ newTalent{
return true
end,
action = function(self, t)
- local power = (self.psionic_feedback or 0) * t.getConversionRatio(self, t)
- self:setEffect(self.EFF_RESONANCE_SHIELD, 10, {power = self:mindCrit(power), dam = self:mindCrit(t.getDamage(self, t))})
- self.psionic_feedback = 0
+ local power = math.min(self.psionic_feedback, t.getShieldPower(self, t))
+ self:setEffect(self.EFF_RESONANCE_SHIELD, 10, {power = self:mindCrit(power), dam = t.getDamage(self, t)})
+ self.psionic_feedback = self.psionic_feedback - power
return true
end,
info = function(self, t)
- local conversion = t.getConversionRatio(self, t)
+ local shield_power = t.getShieldPower(self, t)
local damage = t.getDamage(self, t)
- return ([[Activate to remove all stored feedback, converting %d%% of the stored energy into a resonance field that will absorb 50%% of all damage you take and inflict %0.2f mind damage to melee attackers.
+ return ([[Activate to convert up to %0.2f feedback into a resonance shield that will absorb 50%% of all damage you take and inflict %0.2f mind damage to melee attackers.
Learning this talent will increase the amount of feedback you can store by 50 (first talent point only).
- The conversion ratio will scale with your mindpower and the effect lasts up to ten turns.]]):format(conversion * 100, damDesc(self, DamageType.MIND, damage))
+ The conversion ratio will scale with your mindpower and the effect lasts up to ten turns.]]):format(shield_power, damDesc(self, DamageType.MIND, damage))
end,
}
-newTalent{
- name = "Feedback Loop",
- type = {"psionic/feedback", 4},
- points = 5,
- require = psi_wil_req4,
- cooldown = 24,
- psi = 10,
- tactical = { FEEDBACK = 2 },
- getConversionRatio = function(self, t) return math.min(100, self:combatTalentMindDamage(t, 20, 100))/100 end,
- getFeedbackIncrease = function(self, t) return (self.psionic_feedback_max or 0) * t.getConversionRatio(self, t) end,
- no_energy = true,
- on_learn = function(self, t)
- if self:getTalentLevelRaw(t) == 1 then
- if not self.psionic_feedback then
- self.psionic_feedback = 0
- end
- self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 50
- end
- return true
- end,
- on_unlearn = function(self, t)
- if not self:knowTalent(t) then
- self.psionic_feedback_max = self.psionic_feedback_max - 50
- if self.psionic_feedback_max <= 0 then
- self.psionic_feedback_max = nil
- self.psionic_feedback = nil
- end
- end
- return true
- end,
- action = function(self, t)
- self.psionic_feedback = math.min(self.psionic_feedback_max or 0, (self.psionic_feedback or 0) + t.getFeedbackIncrease(self, t))
- return true
- end,
- info = function(self, t)
- local conversion = t.getConversionRatio(self, t)
- local feedback = t.getFeedbackIncrease(self, t)
- return ([[Activate to instantly convert psi (the cost of the talent) into %d%% of your maximum feedback (currently %d).
- Learning this talent will increase the amount of feedback you can store by 50 (first talent point only).
- The feedback gain will scale with your mindpower.
- This talent takes no time to use.]]):format(conversion * 100, feedback)
- end,
-}
\ No newline at end of file
diff --git a/game/modules/tome/data/talents/psionic/mentalism.lua b/game/modules/tome/data/talents/psionic/mentalism.lua
new file mode 100644
index 0000000000..26b55d3b2f
--- /dev/null
+++ b/game/modules/tome/data/talents/psionic/mentalism.lua
@@ -0,0 +1,234 @@
+-- ToME - Tales of Maj'Eyal
+-- Copyright (C) 2009, 2010, 2011, 2012 Nicolas Casalini
+--
+-- This program is free software: you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation, either version 3 of the License, or
+-- (at your option) any later version.
+--
+-- This program is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+-- GNU General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with this program. If not, see <http://www.gnu.org/licenses/>.
+--
+-- Nicolas Casalini "DarkGod"
+-- darkgod@te4.org
+
+-- Edge TODO: Sounds, Particles, Talent Icons; Mind Link
+
+local Map = require "engine.Map"
+
+newTalent{
+ name = "Projection",
+ type = {"psionic/mentalism", 1},
+ points = 5,
+ require = psi_wil_req1,
+ mode = "sustained",
+ sustain_psi = 10,
+ cooldown = 24,
+ no_npc_use = true,
+ getMaxDistance = function(self, t) return 5 + math.ceil(self:combatTalentMindDamage(t, 10, 20)) end,
+ getSensoryPower = function(self, t) return math.ceil(self:combatTalentMindDamage(t, 10, 40)) end,
+ getDuration = function(self, t) return 2 + math.ceil(self:getTalentLevel(t)*2) end,
+ activate = function(self, t)
+ if self:attr("is_psychic_projection") then return true end
+ local x, y = util.findFreeGrid(self.x, self.y, 1, true, {[Map.ACTOR]=true})
+ if not x then
+ game.logPlayer(self, "Not enough space to invoke your spirit!")
+ return
+ end
+
+ local m = self:clone{
+ shader = "shadow_simulacrum",
+ no_drops = true,
+ faction = self.faction,
+ summoner = self, summoner_gain_exp=true,
+ summon_time = t.getMaxDistance(self, t),
+ ai_target = {actor=nil},
+ ai = "summoned", ai_real = "tactical",
+ subtype = "ghost", is_psychic_projection = 1,
+ name = "Projection of "..self.name,
+ desc = [[A ghostly figure.]],
+ }
+ m:removeAllMOs()
+ m.make_escort = nil
+ m.on_added_to_level = nil
+
+ m.energy.value = 0
+ m.player = nil
+ m.max_life = m.max_life
+ m.life = util.bound(m.life, 0, m.max_life)
+ m.forceLevelup = function() end
+ m.die = nil
+ m.on_die = nil
+ m.on_acquire_target = nil
+ m.seen_by = nil
+ m.puuid = nil
+ m.on_takehit = nil
+ m.can_talk = nil
+ m.clone_on_hit = nil
+ m.exp_worth = 0
+ m.no_inventory_access = true
+ m.can_change_level = false
+ m.remove_from_party_on_death = true
+ for i = 1, 10 do
+ m:unlearnTalent(m.T_AMBUSCADE) -- no recurssive projections
+ end
+
+ m.can_pass = {pass_wall=70}
+ m.no_breath = 1
+ m.invisible = (m.invisible or 0) + 1
+ m.see_invisible = (m.see_invisible or 0) + t.getSensoryPower(self, t)
+ m.see_stealth = (m.see_stealth or 0) + t.getSensoryPower(self, t)
+ m.lite = 0
+ m.infravision = (m.infravision or 0) + 10
+
+
+ -- Connection to the summoner functions
+ local max_distance = t.getMaxDistance(self, t)
+ local summon_time = t.getDuration(self, t)
+ m.on_act = function(self)
+ -- only check these very other turn to prevent to much spam
+ if math.mod(self.summon_time, 2) == 0 and self.summon_time > 0 then
+ if core.fov.distance(self.x, self.y, self.summoner.x, self.summoner.y) < max_distance and not self.summoner.dead then
+ self.summon_time = summon_time
+ elseif not self.summoner.dead then
+ game.logPlayer(self, "#LIGHT_RED#The psychic link is growing weak...")
+ else
+ game.logPlayer(self, "#LIGHT_RED#You're being pulled into the void!")
+ end
+ end
+ end
+ --summoner takes hit
+ m.on_takehit = function(self, value, src) self.summoner:takeHit(value, src) return value end
+ -- summoner deactivates talent when we die
+ m.on_die = function(self)
+ if not self.summoner.dead then
+ game.logPlayer(self, "#LIGHT_RED#A violent force pushes you back into your body!")
+ self.summoner:forceUseTalent(self.summoner.T_PROJECTION, {ignore_energy=true})
+ end
+ end
+
+ game.zone:addEntity(game.level, m, "actor", x, y)
+
+ if game.party:hasMember(self) then
+ game.party:addMember(m, {
+ control="full",
+ type = m.type, subtype="ghost",
+ title="Projection of "..self.name,
+ temporary_level=1,
+ orders = {target=true},
+ on_control = function(self)
+ self.summoner.projection_ai = self.summoner.ai
+ self.summoner.ai = "none"
+ self:forceUseTalent(self.T_PROJECTION, {ignore_energy=true})
+ end,
+ on_uncontrol = function(self)
+ self.summoner.ai = self.summoner.projection_ai
+ self.summon_time = 0
+ self.summoner:forceUseTalent(self.summoner.T_PROJECTION, {ignore_energy=true})
+ game:onTickEnd(function() game.party:removeMember(self) end)
+ end,
+ })
+ end
+ game:onTickEnd(function() game.party:setPlayer(m) self:resetCanSeeCache() end)
+
+ return true
+ end,
+ deactivate = function(self, t, p)
+ game:onTickEnd(function()
+ if self:attr("is_psychic_projection") then
+ game.party:setPlayer(self.summoner)
+ else
+ game.party:setPlayer(self)
+ end
+ end)
+ return true
+ end,
+ info = function(self, t)
+ local max_distance = t.getMaxDistance(self, t)
+ local senses = t.getSensoryPower(self, t)
+ local duration = t.getDuration(self, t)
+ return ([[Activate to project your mind from your body. In this state you're invisible, can see invisible and stealthed creatures (+%d detection power), can move through walls, and do not need air to survive.
+ All damage you suffer is shared with your physical body and you can sustain the projection indifinetly within a radius of %d. Beyond that distance the connection will begin to weaken and you'll have %d turns before your projection dissipates.
+ While active you may only damage 'ghosts' and creatures you've formed a Mind Link with and even then can only use mind damage for such attacks.
+ To return to your body, simply release control of the projection.]]):format(senses, max_distance, duration)
+ end,
+}
+
+newTalent{
+ name = "Mind Link",
+ type = {"psionic/mentalism", 2},
+ points = 5,
+ require = psi_wil_req2,
+ cooldown = 15,
+ tactical = { DEFEND = 2, ATTACK = {MIND = 2}},
+ getShieldPower = function(self, t) return self:combatTalentMindDamage(t, 20, 300) end,
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 10, 50) end,
+ action = function(self, t)
+ local power = math.min(self.psionic_feedback, t.getShieldPower(self, t))
+ self:setEffect(self.EFF_RESONANCE_SHIELD, 10, {power = self:mindCrit(power), dam = t.getDamage(self, t)})
+ self.psionic_feedback = self.psionic_feedback - power
+ return true
+ end,
+ info = function(self, t)
+ local shield_power = t.getShieldPower(self, t)
+ local damage = t.getDamage(self, t)
+ return ([[Activate to conver up to %0.2f feedback into a resonance shield that will absorb 50%% of all damage you take and inflict %0.2f mind damage to melee attackers.
+ Learning this talent will increase the amount of feedback you can store by 100 (first talent point only).
+ The conversion ratio will scale with your mindpower and the effect lasts up to ten turns.]]):format(shield_power, damDesc(self, DamageType.MIND, damage))
+ end,
+}
+
+newTalent{
+ name = "Psychometry",
+ type = {"psionic/mentalism", 3},
+ points = 5,
+ require = psi_wil_req3,
+ mode = "passive",
+ getMultiplier = function(self, t) return 0.05 + (self:getTalentLevel(t) / 33) end,
+ info = function(self, t)
+ local multiplier = t.getMultiplier(self, t)
+ return ([[When you wield or wear an item infused by psionic, nature, or arcane-disrupting forces you improve all values under its 'when wielded/worn' field by %d%%.
+ Note this doesn't change the item itself, but rather the effects it has on your person (the item description will not reflect the improved values).]]):format(multiplier * 100)
+ end,
+}
+
+newTalent{
+ name = "Schism",
+ type = {"psionic/mentalism", 4},
+ points = 5,
+ require = psi_wil_req4,
+ mode = "sustained",
+ sustain_psi = 20,
+ cooldown = 50,
+ remove_on_zero = true,
+ tactical = { BUFF=2, DEFEND=2},
+ getSpeed = function(self, t) return self:combatTalentMindDamage(t, 5, 30) end,
+ getDrain = function(self, t) return math.max(1, 5 - (self:getTalentLevelRaw(t))/2) end,
+ activate = function(self, t)
+ game:playSoundNear(self, "talents/heal")
+ local ret = {
+ speed = self:addTemporaryValue("combat_mentalspeed", t.getSpeed(self, t)/ 100),
+ schism = self:addTemporaryValue("psionic_schism", 1),
+ drain = self:addTemporaryValue("psi_regen", - t.getDrain(self, t)),
+ }
+ return ret
+ end,
+ deactivate = function(self, t, p)
+ self:removeTemporaryValue("combat_mentalspeed", p.speed)
+ self:removeTemporaryValue("psionic_schism", p.schism)
+ self:removeTemporaryValue("psi_regen", p.drain)
+ return true
+ end,
+ info = function(self, t)
+ local speed = t.getSpeed(self, t)
+ local drain = t.getDrain(self, t)
+ return ([[Divide your mental faculties, increasing the speed at which you perform psionic talents by %d%%. While active any mental saves you roll against status effects will be checked twice, taking the better of the two results.
+ Maintaining this effect constantly drains your Psi (%0.2f per turn).
+ The speed increase will scale with your mindpower.]]):format(speed, drain)
+ end,
+}
diff --git a/game/modules/tome/data/talents/psionic/nightmare.lua b/game/modules/tome/data/talents/psionic/nightmare.lua
new file mode 100644
index 0000000000..fecd746388
--- /dev/null
+++ b/game/modules/tome/data/talents/psionic/nightmare.lua
@@ -0,0 +1,229 @@
+-- ToME - Tales of Maj'Eyal
+-- Copyright (C) 2009, 2010, 2011, 2012 Nicolas Casalini
+--
+-- This program is free software: you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation, either version 3 of the License, or
+-- (at your option) any later version.
+--
+-- This program is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+-- GNU General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with this program. If not, see <http://www.gnu.org/licenses/>.
+--
+-- Nicolas Casalini "DarkGod"
+-- darkgod@te4.org
+
+-- Edge TODO: Sounds, Particles, Talent Icons; All Talents
+
+newTalent{
+ name = "Nightmare 1",
+ type = {"psionic/nightmare", 1},
+ points = 5,
+ require = psi_wil_req1,
+ cooldown = 5,
+ tactical = { DISABLE = 2},
+ range = 0,
+ direct_hit = true,
+ requires_target = true,
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 20, 150) end,
+ radius = function(self, t) return 1 + math.ceil(self:getTalentLevel(t)) end,
+ target = function(self, t)
+ return {type="cone", range=self:getTalentRange(t), radius=self:getTalentRadius(t), selffire=false}
+ end,
+ on_pre_use = function(self, t, silent) if self.psionic_feedback <= 0 then if not silent then game.logPlayer(self, "You have no feedback to power this talent.") end return false end return true end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 100
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 100
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ action = function(self, t)
+ local tg = self:getTalentTarget(t)
+ local x, y = self:getTarget(tg)
+
+ local damage = math.min(self.psionic_feedback, t.getDamage(self, t))
+ self:project(tg, x, y, DamageType.MIND, {dam=self:mindCrit(damage), crossTierChance=math.max(100, damage)})
+
+ self.psionic_feedback = self.psionic_feedback - damage
+
+ return true
+ end,
+ info = function(self, t)
+ local damage = t.getDamage(self, t)
+ local radius = self:getTalentRadius(t)
+ return ([[You now store damage you take from outside sources as psionic feedback. Activate to nightmare up to %0.2f feedback in a %d radius cone. Targets in the area will suffer mind damage and may be brain locked by this attack.
+ Learning this talent will increase the amount of feedback you can store by 100 (first talent point only).
+ The damage will scale with your mindpower.]]):format(damage, radius)
+ end,
+}
+
+newTalent{
+ name = "Nightmare 2",
+ type = {"psionic/nightmare", 2},
+ points = 5,
+ require = psi_wil_req2,
+ mode = "sustained",
+ sustain_psi = 20,
+ cooldown = 18,
+ tactical = { BUFF = 2 },
+ getMaxOverflow = function(self, t) return self.psionic_feedback_max * (self:combatTalentMindDamage(t, 20, 100)/100) end,
+ radius = function(self, t) return math.ceil(self:getTalentLevel(t)/2) end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 50
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 50
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ doOverflownightmare = function(self, t)
+ local tg = {type="ball", range=0, radius=self:getTalentRadius(t), selffire=false, friendlyfire=false}
+ local damage = self.psionic_overflow
+ self:project(tg, self.x, self.y, DamageType.MIND, self:mindCrit(damage))
+ -- Lose remaining overflow
+ self.psionic_overflow = nil
+ end,
+ activate = function(self, t)
+ game:playSoundNear(self, "talents/flame")
+ return {
+ ov = self:addTemporaryValue("psionic_overflow_max", t.getMaxOverflow(self, t)),
+ }
+ end,
+ deactivate = function(self, t, p)
+ self:removeTemporaryValue("psionic_overflow_max", p.ov)
+ return true
+ end,
+ info = function(self, t)
+ local overflow = t.getMaxOverflow(self, t)
+ local radius = self:getTalentRadius(t)
+ return ([[While active you store up to %d excess feedback as overflow. At the start of your turn the overflow will be unleased as mind damage in a radius of %d.
+ Learning this talent will increase the amount of feedback you can store by 50 (first talent point only).
+ The max excess you can store will improve with your mindpower and max feedback.]]):format(overflow, radius)
+ end,
+}
+
+newTalent{
+ name = "Nightmare 3",
+ type = {"psionic/nightmare", 3},
+ points = 5,
+ require = psi_wil_req3,
+ cooldown = 10,
+ tactical = { ATTACKAREA = {PHYSICAL = 2}, DISABLE = { knockback = 2 }, },
+ range = 0,
+ radius = function(self, t) return 1 + math.ceil(self:getTalentLevel(t)) end,
+ direct_hit = true,
+ requires_target = true,
+ target = function(self, t)
+ return {type="ball", range=self:getTalentRange(t), talent=t}
+ end,
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 20, 230) end,
+ on_pre_use = function(self, t, silent) if self.psionic_feedback <= 0 then if not silent then game.logPlayer(self, "You have no feedback to power this talent.") end return false end return not self:hasEffect(self.EFF_REGENERATION) end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 50
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 50
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ action = function(self, t)
+ local tg = self:getTalentTarget(t)
+ if not x or not y then return nil end
+
+ local damage = math.min(self.psionic_feedback, t.getDamage(self, t))
+ self:project(tg, x, y, DamageType.MINDKNOCKBACK, self:mindCrit(damage))
+ self.psionic_feedback = self.psionic_feedback - damage
+
+ return true
+ end,
+ info = function(self, t)
+ local damage = t.getDamage(self, t)
+ local radius = self:getTalentRadius(t)
+ return ([[Activate to convert up to %0.2f of stored feedback into a blast of kinetic energy. Targets out to a radius of %d will suffer physical damage and may be knocked back.
+ Learning this talent will increase the amount of feedback you can store by 50 (first talent point only).
+ The damage will scale with your mindpower.]]):format(damDesc(self, DamageType.PHYSICAL, damage), radius)
+ end,
+}
+
+newTalent{
+ name = "Nightmare 4",
+ type = {"psionic/nightmare", 4},
+ points = 5,
+ require = psi_wil_req4,
+ cooldown = 15,
+ tactical = { DEFEND = 2, ATTACK = {MIND = 2}},
+ on_pre_use = function(self, t, silent) if self.psionic_feedback <= 0 then if not silent then game.logPlayer(self, "You have no feedback to power this talent.") end return false end return true end,
+ getShieldPower = function(self, t) return self:combatTalentMindDamage(t, 20, 300) end,
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 10, 50) end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 100
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 100
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ action = function(self, t)
+ local power = math.min(self.psionic_feedback, t.getShieldPower(self, t))
+ self:setEffect(self.EFF_RESONANCE_SHIELD, 10, {power = self:mindCrit(power), dam = t.getDamage(self, t)})
+ self.psionic_feedback = self.psionic_feedback - power
+ return true
+ end,
+ info = function(self, t)
+ local shield_power = t.getShieldPower(self, t)
+ local damage = t.getDamage(self, t)
+ return ([[Activate to conver up to %0.2f feedback into a resonance shield that will absorb 50%% of all damage you take and inflict %0.2f mind damage to melee attackers.
+ Learning this talent will increase the amount of feedback you can store by 100 (first talent point only).
+ The conversion ratio will scale with your mindpower and the effect lasts up to ten turns.]]):format(shield_power, damDesc(self, DamageType.MIND, damage))
+ end,
+}
\ No newline at end of file
diff --git a/game/modules/tome/data/talents/psionic/psionic.lua b/game/modules/tome/data/talents/psionic/psionic.lua
index 1f03e7bcd1..1a276bc52b 100644
--- a/game/modules/tome/data/talents/psionic/psionic.lua
+++ b/game/modules/tome/data/talents/psionic/psionic.lua
@@ -36,10 +36,18 @@ newTalentType{ allow_random=true, type="psionic/brainstorm", name = "brainstorm"
-- Secret Project...
-- Solipsist Talent Trees
-newTalentType{ allow_random=true, type="psionic/psychic-assault", name = "psychic assault", description = "Directly attack your opponents minds." }
+newTalentType{ allow_random=true, type="psionic/discharge", name = "discharge", description = "Store and discharge psychic feedback." }
+newTalentType{ allow_random=true, type="psionic/distortion", name = "distortion", description = "Distort reality with your mental energy." }
+newTalentType{ allow_random=true, type="psionic/nightmare", name = "nightmare", description = "Manifest your enemies nightmares." }
+newTalentType{ allow_random=true, type="psionic/psychic-assault", name = "Psychic Assault", description = "Directly attack your opponents minds." }
+newTalentType{ allow_random=true, type="psionic/slumber", name = "slumber", description = "Force enemies into a deep sleep." }
newTalentType{ allow_random=true, type="psionic/solipsism", name = "solipsism", description = "Nothing exists outside the minds ability to perceive it." }
+newTalentType{ allow_random=true, type="psionic/thought-forms", name = "Thought-Forms", description = "Manifest your thoughts as psionic summons." }
+
-- Generic Solipsist Trees
-newTalentType{ allow_random=true, type="psionic/feedback", generic = true, name = "feedback", description = "Store and discharge psychic feedback." }
+newTalentType{ allow_random=true, type="psionic/mentalism", generic = true, name = "mentalism", description = "ESP and other various mental powers." }
+newTalentType{ allow_random=true, type="psionic/feedback", generic = true, name = "feedback", description = "Store and manipulate psychic feedback." }
+newTalentType{ allow_random=true, type="psionic/trance", generic = true, name = "trance", description = "Put your mind into a deep trance." }
newTalentType{ allow_random=true, type="psionic/possession", name = "possession", description = "You have learnt to shed away your body, allowing you to possess any other." }
@@ -171,9 +179,16 @@ load("/data/talents/psionic/psi-archery.lua")
load("/data/talents/psionic/grip.lua")
-- Solipsist
+load("/data/talents/psionic/discharge.lua")
+load("/data/talents/psionic/distortion.lua")
+load("/data/talents/psionic/mentalism.lua")
load("/data/talents/psionic/feedback.lua")
+load("/data/talents/psionic/nightmare.lua")
load("/data/talents/psionic/psychic-assault.lua")
+load("/data/talents/psionic/slumber.lua")
load("/data/talents/psionic/solipsism.lua")
+load("/data/talents/psionic/thought-forms.lua")
+load("/data/talents/psionic/trance.lua")
load("/data/talents/psionic/possession.lua")
diff --git a/game/modules/tome/data/talents/psionic/psychic-assault.lua b/game/modules/tome/data/talents/psionic/psychic-assault.lua
index 9d0a5a3ed1..ef9b9cf874 100644
--- a/game/modules/tome/data/talents/psionic/psychic-assault.lua
+++ b/game/modules/tome/data/talents/psionic/psychic-assault.lua
@@ -17,9 +17,43 @@
-- Nicolas Casalini "DarkGod"
-- darkgod@te4.org
+-- Edge TODO: Sounds, Particles, Talent Icons; All Talents
+-- Idea (5:06:11 PM) Neuq: Sunder mind - Hit the enemy for X mind damage + Y mind damage for every stack of Sunder mind he has on him? :)
+
newTalent{
- name = "Psychic Lobotomy",
+ name = "Sunder Mind",
type = {"psionic/psychic-assault", 1},
+ require = psi_wil_req1,
+ points = 5,
+ cooldown = 2,
+ psi = 5,
+ range = 7,
+ direct_hit = true,
+ requires_target = true,
+ target = function(self, t)
+ return {type="beam", range=self:getTalentRange(t), talent=t}
+ end,
+ tactical = { ATTACK = { MIND = 3 } },
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 10, 340) end,
+ action = function(self, t)
+ local tg = self:getTalentTarget(t)
+ local x, y = self:getTarget(tg)
+ if not x or not y then return nil end
+ self:project(tg, x, y, DamageType.MIND, self:mindCrit(self:combatTalentMindDamage(t, 10, 340)), {type="mind"})
+ game:playSoundNear(self, "talents/spell_generic")
+ return true
+ end,
+ info = function(self, t)
+ local damage = t.getDamage(self, t)
+ return ([[Sends a telepathic attack, trying to destroy the brains of any target in the beam, doing %0.2f mind damage.
+ The damage will increase with your mindpower.]]):format(damDesc(self, DamageType.PHYSICAL, damage))
+ end,
+}
+
+newTalent{
+ name = "Psychic Lobotomy",
+ type = {"psionic/psychic-assault", 2},
+ require = psi_wil_req2,
points = 5,
cooldown = 6,
range = 10,
@@ -60,5 +94,64 @@ newTalent{
end,
}
+newTalent{
+ name = "Mind Sear",
+ type = {"psionic/psychic-assault", 1},
+ require = psi_wil_req1,
+ points = 5,
+ cooldown = 2,
+ psi = 5,
+ range = 7,
+ direct_hit = true,
+ requires_target = true,
+ target = function(self, t)
+ return {type="beam", range=self:getTalentRange(t), talent=t}
+ end,
+ tactical = { ATTACK = { MIND = 3 } },
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 10, 340) end,
+ action = function(self, t)
+ local tg = self:getTalentTarget(t)
+ local x, y = self:getTarget(tg)
+ if not x or not y then return nil end
+ self:project(tg, x, y, DamageType.MIND, self:mindCrit(self:combatTalentMindDamage(t, 10, 340)), {type="mind"})
+ game:playSoundNear(self, "talents/spell_generic")
+ return true
+ end,
+ info = function(self, t)
+ local damage = t.getDamage(self, t)
+ return ([[Sends a telepathic attack, trying to destroy the brains of any target in the beam, doing %0.2f mind damage.
+ The damage will increase with your mindpower.]]):format(damDesc(self, DamageType.PHYSICAL, damage))
+ end,
+}
+
+newTalent{
+ name = "Brain Lock", -- sustain, gives chance to brain lock enemies when mental damage is applied
+ type = {"psionic/psychic-assault", 1},
+ require = psi_wil_req1,
+ points = 5,
+ cooldown = 2,
+ psi = 5,
+ range = 7,
+ direct_hit = true,
+ requires_target = true,
+ target = function(self, t)
+ return {type="beam", range=self:getTalentRange(t), talent=t}
+ end,
+ tactical = { ATTACK = { MIND = 3 } },
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 10, 340) end,
+ action = function(self, t)
+ local tg = self:getTalentTarget(t)
+ local x, y = self:getTarget(tg)
+ if not x or not y then return nil end
+ self:project(tg, x, y, DamageType.MIND, self:mindCrit(self:combatTalentMindDamage(t, 10, 340)), {type="mind"})
+ game:playSoundNear(self, "talents/spell_generic")
+ return true
+ end,
+ info = function(self, t)
+ local damage = t.getDamage(self, t)
+ return ([[Sends a telepathic attack, trying to destroy the brains of any target in the beam, doing %0.2f mind damage.
+ The damage will increase with your mindpower.]]):format(damDesc(self, DamageType.PHYSICAL, damage))
+ end,
+}
-- Idea, Brain Rupture
\ No newline at end of file
diff --git a/game/modules/tome/data/talents/psionic/slumber.lua b/game/modules/tome/data/talents/psionic/slumber.lua
new file mode 100644
index 0000000000..fd9c7a95a6
--- /dev/null
+++ b/game/modules/tome/data/talents/psionic/slumber.lua
@@ -0,0 +1,229 @@
+-- ToME - Tales of Maj'Eyal
+-- Copyright (C) 2009, 2010, 2011, 2012 Nicolas Casalini
+--
+-- This program is free software: you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation, either version 3 of the License, or
+-- (at your option) any later version.
+--
+-- This program is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+-- GNU General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with this program. If not, see <http://www.gnu.org/licenses/>.
+--
+-- Nicolas Casalini "DarkGod"
+-- darkgod@te4.org
+
+-- Edge TODO: Sounds, Particles, Talent Icons; All Talents
+
+newTalent{
+ name = "Sleep",
+ type = {"psionic/slumber", 1},
+ points = 5,
+ require = psi_wil_req1,
+ cooldown = 5,
+ tactical = { DISABLE = 2},
+ range = 0,
+ direct_hit = true,
+ requires_target = true,
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 20, 150) end,
+ radius = function(self, t) return 1 + math.ceil(self:getTalentLevel(t)) end,
+ target = function(self, t)
+ return {type="cone", range=self:getTalentRange(t), radius=self:getTalentRadius(t), selffire=false}
+ end,
+ on_pre_use = function(self, t, silent) if self.psionic_feedback <= 0 then if not silent then game.logPlayer(self, "You have no feedback to power this talent.") end return false end return true end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 100
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 100
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ action = function(self, t)
+ local tg = self:getTalentTarget(t)
+ local x, y = self:getTarget(tg)
+
+ local damage = math.min(self.psionic_feedback, t.getDamage(self, t))
+ self:project(tg, x, y, DamageType.MIND, {dam=self:mindCrit(damage), crossTierChance=math.max(100, damage)})
+
+ self.psionic_feedback = self.psionic_feedback - damage
+
+ return true
+ end,
+ info = function(self, t)
+ local damage = t.getDamage(self, t)
+ local radius = self:getTalentRadius(t)
+ return ([[You now store damage you take from outside sources as psionic feedback. Activate to slumber up to %0.2f feedback in a %d radius cone. Targets in the area will suffer mind damage and may be brain locked by this attack.
+ Learning this talent will increase the amount of feedback you can store by 100 (first talent point only).
+ The damage will scale with your mindpower.]]):format(damage, radius)
+ end,
+}
+
+newTalent{
+ name = "Fitful Slumber",
+ type = {"psionic/slumber", 2},
+ points = 5,
+ require = psi_wil_req2,
+ mode = "sustained",
+ sustain_psi = 20,
+ cooldown = 18,
+ tactical = { BUFF = 2 },
+ getMaxOverflow = function(self, t) return self.psionic_feedback_max * (self:combatTalentMindDamage(t, 20, 100)/100) end,
+ radius = function(self, t) return math.ceil(self:getTalentLevel(t)/2) end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 50
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 50
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ doOverflowslumber = function(self, t)
+ local tg = {type="ball", range=0, radius=self:getTalentRadius(t), selffire=false, friendlyfire=false}
+ local damage = self.psionic_overflow
+ self:project(tg, self.x, self.y, DamageType.MIND, self:mindCrit(damage))
+ -- Lose remaining overflow
+ self.psionic_overflow = nil
+ end,
+ activate = function(self, t)
+ game:playSoundNear(self, "talents/flame")
+ return {
+ ov = self:addTemporaryValue("psionic_overflow_max", t.getMaxOverflow(self, t)),
+ }
+ end,
+ deactivate = function(self, t, p)
+ self:removeTemporaryValue("psionic_overflow_max", p.ov)
+ return true
+ end,
+ info = function(self, t)
+ local overflow = t.getMaxOverflow(self, t)
+ local radius = self:getTalentRadius(t)
+ return ([[While active you store up to %d excess feedback as overflow. At the start of your turn the overflow will be unleased as mind damage in a radius of %d.
+ Learning this talent will increase the amount of feedback you can store by 50 (first talent point only).
+ The max excess you can store will improve with your mindpower and max feedback.]]):format(overflow, radius)
+ end,
+}
+
+newTalent{
+ name = "Contagious Slumber",
+ type = {"psionic/slumber", 3},
+ points = 5,
+ require = psi_wil_req3,
+ cooldown = 10,
+ tactical = { ATTACKAREA = {PHYSICAL = 2}, DISABLE = { knockback = 2 }, },
+ range = 0,
+ radius = function(self, t) return 1 + math.ceil(self:getTalentLevel(t)) end,
+ direct_hit = true,
+ requires_target = true,
+ target = function(self, t)
+ return {type="ball", range=self:getTalentRange(t), talent=t}
+ end,
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 20, 230) end,
+ on_pre_use = function(self, t, silent) if self.psionic_feedback <= 0 then if not silent then game.logPlayer(self, "You have no feedback to power this talent.") end return false end return not self:hasEffect(self.EFF_REGENERATION) end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 50
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 50
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ action = function(self, t)
+ local tg = self:getTalentTarget(t)
+ if not x or not y then return nil end
+
+ local damage = math.min(self.psionic_feedback, t.getDamage(self, t))
+ self:project(tg, x, y, DamageType.MINDKNOCKBACK, self:mindCrit(damage))
+ self.psionic_feedback = self.psionic_feedback - damage
+
+ return true
+ end,
+ info = function(self, t)
+ local damage = t.getDamage(self, t)
+ local radius = self:getTalentRadius(t)
+ return ([[Activate to convert up to %0.2f of stored feedback into a blast of kinetic energy. Targets out to a radius of %d will suffer physical damage and may be knocked back.
+ Learning this talent will increase the amount of feedback you can store by 50 (first talent point only).
+ The damage will scale with your mindpower.]]):format(damDesc(self, DamageType.PHYSICAL, damage), radius)
+ end,
+}
+
+newTalent{
+ name = "Sandman",
+ type = {"psionic/slumber", 4},
+ points = 5,
+ require = psi_wil_req4,
+ cooldown = 15,
+ tactical = { DEFEND = 2, ATTACK = {MIND = 2}},
+ on_pre_use = function(self, t, silent) if self.psionic_feedback <= 0 then if not silent then game.logPlayer(self, "You have no feedback to power this talent.") end return false end return true end,
+ getShieldPower = function(self, t) return self:combatTalentMindDamage(t, 20, 300) end,
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 10, 50) end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 100
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 100
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ action = function(self, t)
+ local power = math.min(self.psionic_feedback, t.getShieldPower(self, t))
+ self:setEffect(self.EFF_RESONANCE_SHIELD, 10, {power = self:mindCrit(power), dam = t.getDamage(self, t)})
+ self.psionic_feedback = self.psionic_feedback - power
+ return true
+ end,
+ info = function(self, t)
+ local shield_power = t.getShieldPower(self, t)
+ local damage = t.getDamage(self, t)
+ return ([[Activate to conver up to %0.2f feedback into a resonance shield that will absorb 50%% of all damage you take and inflict %0.2f mind damage to melee attackers.
+ Learning this talent will increase the amount of feedback you can store by 100 (first talent point only).
+ The conversion ratio will scale with your mindpower and the effect lasts up to ten turns.]]):format(shield_power, damDesc(self, DamageType.MIND, damage))
+ end,
+}
\ No newline at end of file
diff --git a/game/modules/tome/data/talents/psionic/solipsism.lua b/game/modules/tome/data/talents/psionic/solipsism.lua
index e1c2f35601..6005ae6a0d 100644
--- a/game/modules/tome/data/talents/psionic/solipsism.lua
+++ b/game/modules/tome/data/talents/psionic/solipsism.lua
@@ -18,7 +18,7 @@
-- darkgod@te4.org
--- TODO: Sounds and particles
+-- Edge TODO: Sounds, Particles
newTalent{
name = "Solipsism",
@@ -27,7 +27,7 @@ newTalent{
require = psi_wil_req1,
mode = "passive",
no_unlearn_last = true,
- damageToPsi = function(self, t) return math.min(self:getTalentLevel(t) * 0.15, 1) end,
+ getConversionRatio = function(self, t) return math.min(self:getTalentLevel(t) * 0.15, 1) end,
on_learn = function(self, t)
self:incMaxPsi(10)
if self:getTalentLevelRaw(t) == 1 then
@@ -45,11 +45,11 @@ newTalent{
return true
end,
info = function(self, t)
- local damage_to_psi = t.damageToPsi(self, t)
+ local conversion_ratio = t.getConversionRatio(self, t)
return ([[You believe that your mind is the center of everything. Permanently increases the amount of psi you gain per level by 10 and reduces your life rating (affects life at level up) to 0 (one time only adjustment).
- You also have learned to overcome physical damage with your mind alone and convert %d%% of all damage into psi damage.
+ You also have learned to overcome damage with your mind alone and convert %d%% of all damage into psi damage and %d%% of your healing and life regen now recovers Psi instead of life.
Increases your solipsism threshold by 20%% (first point only), reducing global speed if your Psi falls below the threshold (currently %d%%).
- Each talent point invested will also increase your max Psi by 10.]]):format(damage_to_psi * 100, self.solipsism_threshold * 100)
+ Each talent point invested will also increase your max Psi by 10.]]):format(conversion_ratio * 100, conversion_ratio * 100, self.solipsism_threshold * 100)
end,
}
@@ -76,9 +76,9 @@ newTalent{
end,
info = function(self, t)
local ratio = t.getBalanceRatio(self, t) * 100
- return ([[%d%% of your healing and life regen now recovers Psi instead of life. You now use %d%% of your physical save value and %d%% of your mental save value for physical saving throws.
+ return ([[You now substitute %d%% of your mental save for %d%% of your physical and spell saves throws (so at 100%% you would effectively use mental save for all saving throw rolls).
Increases your solipsism threshold by 10%% (first point only), reducing global speed if your Psi falls below the threshold (currently %d%%).
- Each talent point invested will also increase your max Psi by 10.]]):format(ratio, ratio, ratio, self.solipsism_threshold * 100)
+ Each talent point invested will also increase your max Psi by 10.]]):format(ratio, ratio, self.solipsism_threshold * 100)
end,
}
@@ -92,9 +92,7 @@ newTalent{
on_learn = function(self, t)
self:incMaxPsi(10)
self.solipsism_threshold = (self.solipsism_threshold or 0) + 0.1
- if self:getTalentLevelRaw(t) == 1 then
- self.clarity_threshold = t.getClarityThreshold(self, t)
- end
+ self.clarity_threshold = t.getClarityThreshold(self, t)
return true
end,
on_unlearn = function(self, t)
@@ -109,7 +107,7 @@ newTalent{
end,
info = function(self, t)
local threshold = t.getClarityThreshold(self, t)
- return ([[For every percent that your Psi pool exceeds %d%% you gain 1%% global speed.
+ return ([[For every percent that your Psi pool exceeds %d%% you gain 1%% global speed (up to a maximum of 50%%).
Increases your solipsism threshold by 10%% (first point only), reducing global speed if your Psi falls below the threshold (currently %d%%).
Each talent point invested will also increase your max Psi by 10.]]):format(threshold * 100, self.solipsism_threshold * 100)
end,
@@ -120,10 +118,8 @@ newTalent{
type = {"psionic/solipsism", 4},
points = 5,
require = psi_wil_req4,
- cooldown = 12,
- psi = 20,
- tactical = { DEFEND = 2},
- getDuration = function(self, t) return 1 + math.ceil(self:getTalentLevel(t)) end,
+ mode = "passive",
+ getSavePercentage = function(self, t) return math.min(2, 0.3 + self:getTalentLevel(t)/5) end,
on_learn = function(self, t)
self:incMaxPsi(10)
if self:getTalentLevelRaw(t) == 1 then
@@ -138,14 +134,20 @@ newTalent{
end
return true
end,
- action = function(self, t)
- self:setEffect(self.EFF_DISMISSAL, t.getDuration(self, t), {})
- return true
+ doDismissalOnHit = function(self, value, src, t)
+ local saving_throw = self:combatMindCrit(t.getSavePercentage(self, t))
+ print("[Dismissal] ", self.name:capitalize(), " attempting to ignore ", value, "damage from ", src.name:capitalize(), "using", saving_throw, "mental save.")
+ if self:checkHit(math.floor(saving_throw), value) then
+ game.logSeen(self, "%s dismisses %s's attack!", self.name:capitalize(), src.name:capitalize())
+ return 0
+ else
+ return value
+ end
end,
info = function(self, t)
- local duration = t.getDuration(self, t)
- return ([[You dismiss 'reality' as merely a figment of your mind. For the next %d turns you are immune to all damage and ignore new status effects. Performing any action other then movement will reaffirm your belief in 'reality' and end the effect.
+ local save_percentage = t.getSavePercentage(self, t)
+ return ([[Each time you take damage you roll %d%% of your mental save against it. If the saving throw succeeds the damage will be reduced to 0.
Increases your solipsism threshold by 10%% (first point only), reducing global speed if your Psi falls below the threshold (currently %d%%).
- Each talent point invested will also increase your max Psi by 10.]]):format(duration, self.solipsism_threshold * 100)
+ Each talent point invested will also increase your max Psi by 10.]]):format(save_percentage * 100, self.solipsism_threshold * 100)
end,
}
diff --git a/game/modules/tome/data/talents/psionic/thought-forms.lua b/game/modules/tome/data/talents/psionic/thought-forms.lua
new file mode 100644
index 0000000000..5ca2ce7c5c
--- /dev/null
+++ b/game/modules/tome/data/talents/psionic/thought-forms.lua
@@ -0,0 +1,229 @@
+-- ToME - Tales of Maj'Eyal
+-- Copyright (C) 2009, 2010, 2011, 2012 Nicolas Casalini
+--
+-- This program is free software: you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation, either version 3 of the License, or
+-- (at your option) any later version.
+--
+-- This program is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+-- GNU General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with this program. If not, see <http://www.gnu.org/licenses/>.
+--
+-- Nicolas Casalini "DarkGod"
+-- darkgod@te4.org
+
+-- Edge TODO: Sounds, Particles, Talent Icons; All Talents
+
+newTalent{
+ name = "Thought Form1",
+ type = {"psionic/thought-forms", 1},
+ points = 5,
+ require = psi_wil_req1,
+ cooldown = 5,
+ tactical = { DISABLE = 2},
+ range = 0,
+ direct_hit = true,
+ requires_target = true,
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 20, 150) end,
+ radius = function(self, t) return 1 + math.ceil(self:getTalentLevel(t)) end,
+ target = function(self, t)
+ return {type="cone", range=self:getTalentRange(t), radius=self:getTalentRadius(t), selffire=false}
+ end,
+ on_pre_use = function(self, t, silent) if self.psionic_feedback <= 0 then if not silent then game.logPlayer(self, "You have no feedback to power this talent.") end return false end return true end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 100
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 100
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ action = function(self, t)
+ local tg = self:getTalentTarget(t)
+ local x, y = self:getTarget(tg)
+
+ local damage = math.min(self.psionic_feedback, t.getDamage(self, t))
+ self:project(tg, x, y, DamageType.MIND, {dam=self:mindCrit(damage), crossTierChance=math.max(100, damage)})
+
+ self.psionic_feedback = self.psionic_feedback - damage
+
+ return true
+ end,
+ info = function(self, t)
+ local damage = t.getDamage(self, t)
+ local radius = self:getTalentRadius(t)
+ return ([[You now store damage you take from outside sources as psionic feedback. Activate to discharge up to %0.2f feedback in a %d radius cone. Targets in the area will suffer mind damage and may be brain locked by this attack.
+ Learning this talent will increase the amount of feedback you can store by 100 (first talent point only).
+ The damage will scale with your mindpower.]]):format(damage, radius)
+ end,
+}
+
+newTalent{
+ name = "Thought Form2",
+ type = {"psionic/thought-forms", 2},
+ points = 5,
+ require = psi_wil_req2,
+ mode = "sustained",
+ sustain_psi = 20,
+ cooldown = 18,
+ tactical = { BUFF = 2 },
+ getMaxOverflow = function(self, t) return self.psionic_feedback_max * (self:combatTalentMindDamage(t, 20, 100)/100) end,
+ radius = function(self, t) return math.ceil(self:getTalentLevel(t)/2) end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 50
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 50
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ doOverflowDischarge = function(self, t)
+ local tg = {type="ball", range=0, radius=self:getTalentRadius(t), selffire=false, friendlyfire=false}
+ local damage = self.psionic_overflow
+ self:project(tg, self.x, self.y, DamageType.MIND, self:mindCrit(damage))
+ -- Lose remaining overflow
+ self.psionic_overflow = nil
+ end,
+ activate = function(self, t)
+ game:playSoundNear(self, "talents/flame")
+ return {
+ ov = self:addTemporaryValue("psionic_overflow_max", t.getMaxOverflow(self, t)),
+ }
+ end,
+ deactivate = function(self, t, p)
+ self:removeTemporaryValue("psionic_overflow_max", p.ov)
+ return true
+ end,
+ info = function(self, t)
+ local overflow = t.getMaxOverflow(self, t)
+ local radius = self:getTalentRadius(t)
+ return ([[While active you store up to %d excess feedback as overflow. At the start of your turn the overflow will be unleased as mind damage in a radius of %d.
+ Learning this talent will increase the amount of feedback you can store by 50 (first talent point only).
+ The max excess you can store will improve with your mindpower and max feedback.]]):format(overflow, radius)
+ end,
+}
+
+newTalent{
+ name = "Thought Form3",
+ type = {"psionic/thought-forms", 3},
+ points = 5,
+ require = psi_wil_req3,
+ cooldown = 10,
+ tactical = { ATTACKAREA = {PHYSICAL = 2}, DISABLE = { knockback = 2 }, },
+ range = 0,
+ radius = function(self, t) return 1 + math.ceil(self:getTalentLevel(t)) end,
+ direct_hit = true,
+ requires_target = true,
+ target = function(self, t)
+ return {type="ball", range=self:getTalentRange(t), talent=t}
+ end,
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 20, 230) end,
+ on_pre_use = function(self, t, silent) if self.psionic_feedback <= 0 then if not silent then game.logPlayer(self, "You have no feedback to power this talent.") end return false end return not self:hasEffect(self.EFF_REGENERATION) end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 50
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 50
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ action = function(self, t)
+ local tg = self:getTalentTarget(t)
+ if not x or not y then return nil end
+
+ local damage = math.min(self.psionic_feedback, t.getDamage(self, t))
+ self:project(tg, x, y, DamageType.MINDKNOCKBACK, self:mindCrit(damage))
+ self.psionic_feedback = self.psionic_feedback - damage
+
+ return true
+ end,
+ info = function(self, t)
+ local damage = t.getDamage(self, t)
+ local radius = self:getTalentRadius(t)
+ return ([[Activate to convert up to %0.2f of stored feedback into a blast of kinetic energy. Targets out to a radius of %d will suffer physical damage and may be knocked back.
+ Learning this talent will increase the amount of feedback you can store by 50 (first talent point only).
+ The damage will scale with your mindpower.]]):format(damDesc(self, DamageType.PHYSICAL, damage), radius)
+ end,
+}
+
+newTalent{
+ name = "Thought Form4",
+ type = {"psionic/thought-forms", 4},
+ points = 5,
+ require = psi_wil_req4,
+ cooldown = 15,
+ tactical = { DEFEND = 2, ATTACK = {MIND = 2}},
+ on_pre_use = function(self, t, silent) if self.psionic_feedback <= 0 then if not silent then game.logPlayer(self, "You have no feedback to power this talent.") end return false end return true end,
+ getShieldPower = function(self, t) return self:combatTalentMindDamage(t, 20, 300) end,
+ getDamage = function(self, t) return self:combatTalentMindDamage(t, 10, 50) end,
+ on_learn = function(self, t)
+ if self:getTalentLevelRaw(t) == 1 then
+ if not self.psionic_feedback then
+ self.psionic_feedback = 0
+ end
+ self.psionic_feedback_max = (self.psionic_feedback_max or 0) + 100
+ end
+ return true
+ end,
+ on_unlearn = function(self, t)
+ if not self:knowTalent(t) then
+ self.psionic_feedback_max = self.psionic_feedback_max - 100
+ if self.psionic_feedback_max <= 0 then
+ self.psionic_feedback_max = nil
+ self.psionic_feedback = nil
+ end
+ end
+ return true
+ end,
+ action = function(self, t)
+ local power = math.min(self.psionic_feedback, t.getShieldPower(self, t))
+ self:setEffect(self.EFF_RESONANCE_SHIELD, 10, {power = self:mindCrit(power), dam = t.getDamage(self, t)})
+ self.psionic_feedback = self.psionic_feedback - power
+ return true
+ end,
+ info = function(self, t)
+ local shield_power = t.getShieldPower(self, t)
+ local damage = t.getDamage(self, t)
+ return ([[Activate to conver up to %0.2f feedback into a resonance shield that will absorb 50%% of all damage you take and inflict %0.2f mind damage to melee attackers.
+ Learning this talent will increase the amount of feedback you can store by 100 (first talent point only).
+ The conversion ratio will scale with your mindpower and the effect lasts up to ten turns.]]):format(shield_power, damDesc(self, DamageType.MIND, damage))
+ end,
+}
\ No newline at end of file
diff --git a/game/modules/tome/data/talents/psionic/trance.lua b/game/modules/tome/data/talents/psionic/trance.lua
new file mode 100644
index 0000000000..cef666c92e
--- /dev/null
+++ b/game/modules/tome/data/talents/psionic/trance.lua
@@ -0,0 +1,181 @@
+-- ToME - Tales of Maj'Eyal
+-- Copyright (C) 2009, 2010, 2011, 2012 Nicolas Casalini
+--
+-- This program is free software: you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation, either version 3 of the License, or
+-- (at your option) any later version.
+--
+-- This program is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+-- GNU General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with this program. If not, see <http://www.gnu.org/licenses/>.
+--
+-- Nicolas Casalini "DarkGod"
+-- darkgod@te4.org
+
+-- Edge TODO: Sounds, Particles, Talent Icons; Trance of Focus; Deep Trance
+
+local function cancelTrances(self)
+ local trances = {self.T_TRANCE_OF_CLARITY, self.T_TRANCE_OF_PURITY, self.T_TRANCE_OF_FOCUS}
+ for i, t in ipairs(trances) do
+ if self:isTalentActive(t) then
+ self:forceUseTalent(t, {ignore_energy=true})
+ end
+ end
+end
+
+newTalent{
+ name = "Trance of Purity",
+ type = {"psionic/trance", 1},
+ points = 5,
+ require = psi_wil_req1,
+ cooldown = 12,
+ tactical = { BUFF = 2 },
+ mode = "sustained",
+ sustain_psi = 20,
+ getSavingThrows = function(self, t) return self:combatTalentMindDamage(t, 5, 50) end,
+ getPurgeChance = function(self, t) return 50 - math.min(30, self:combatTalentMindDamage(t, 0, 30)) end,
+ activate = function(self, t)
+ local effs = {}
+ local chance = 100
+
+ -- go through all timed effects
+ for eff_id, p in pairs(self.tmp) do
+ local e = self.tempeffect_def[eff_id]
+ if e.type ~= "other" and e.status == "detrimental" then
+ effs[#effs+1] = {"effect", eff_id}
+ end
+ end
+
+ -- Check chance to remove effects and purge them if possible
+ while chance > 0 and #effs > 0 do
+ local eff = rng.tableRemove(effs)
+ if eff[1] == "effect" and rng.percent(chance) then
+ self:removeEffect(eff[2])
+ chance = chance - t.getPurgeChance(self, t)
+ end
+ end
+
+ -- activate sustain
+ cancelTrances(self)
+ local power = t.getSavingThrows(self, t)
+ game:playSoundNear(self, "talents/spell_generic2")
+ local ret = {
+ phys = self:addTemporaryValue("combat_physresist", power),
+ spell = self:addTemporaryValue("combat_spellresist", power),
+ mental = self:addTemporaryValue("combat_mentalresist", power),
+ -- particle = self:addParticles(Particles.new("golden_shield", 1))
+ }
+ return ret
+ end,
+ deactivate = function(self, t, p)
+ -- self:removeParticles(p.particle)
+ self:removeTemporaryValue("combat_physresist", p.phys)
+ self:removeTemporaryValue("combat_spellresist", p.spell)
+ self:removeTemporaryValue("combat_mentalresist", p.mental)
+ return true
+ end,
+ info = function(self, t)
+ local purge = t.getPurgeChance(self, t)
+ local saves = t.getSavingThrows(self, t)
+ return ([[Activate to purge negative status effects (100%% chance for the first effect, -%d%% less chance for each subsequent effect). While this talent is sustained all your saving throws are increased by %d.
+ The chance to purge and saving throw bonus will scale with your mindpower.
+ Only one trance may be active at a time.]]):format(purge, saves)
+ end,
+}
+
+newTalent{
+ short_name = "TRANCE_OF_WELL_BEING",
+ name = "Trance of Well-Being",
+ type = {"psionic/trance", 2},
+ points = 5,
+ require = psi_wil_req2,
+ cooldown = 12,
+ tactical = { BUFF = 2 },
+ mode = "sustained",
+ sustain_psi = 20,
+ getHeal = function(self, t) return self:combatTalentMindDamage(t, 20, 340) end,
+ getHealingModifier = function(self, t) return self:combatTalentMindDamage(t, 10, 50) end,
+ getLifeRegen = function(self, t) return self:combatTalentMindDamage(t, 10, 50) / 10 end,
+ activate = function(self, t)
+ self:heal(self:mindCrit(t.getHeal(self, t)))
+
+ cancelTrances(self)
+ game:playSoundNear(self, "talents/spell_generic2")
+ local ret = {
+ heal_mod = self:addTemporaryValue("healing_factor", t.getHealingModifier(self, t)/100),
+ regen = self:addTemporaryValue("life_regen", t.getLifeRegen(self, t)),
+ }
+
+ return ret
+ end,
+ deactivate = function(self, t, p)
+ self:removeTemporaryValue("healing_factor", p.heal_mod)
+ self:removeTemporaryValue("life_regen", p.regen)
+ return true
+ end,
+ info = function(self, t)
+ local heal = t.getHeal(self, t)
+ local healing_modifier = t.getHealingModifier(self, t)
+ local regen = t.getLifeRegen(self, t)
+ return ([[Activate to heal yourself for %0.2f life. While this talent is sustained your healing modifier will be increased by %d%% and your life regen by %0.2f.
+ The effects will scale with your mindpower.
+ Only one trance may be active at a time.]]):format(heal, healing_modifier, regen)
+ end,
+}
+
+newTalent{
+ name = "Trance of Focus",
+ type = {"psionic/trance", 3},
+ points = 5,
+ require = psi_wil_req3,
+ cooldown = 12,
+ tactical = { BUFF = 2 },
+ mode = "sustained",
+ sustain_psi = 20,
+ getCriticalPower = function(self, t) return self:combatTalentMindDamage(t, 10, 50) end,
+ getCriticalChance = function(self, t) return self:combatTalentMindDamage(t, 4, 12) end,
+ activate = function(self, t)
+ self:setEffect(self.EFF_TRANCE_OF_FOCUS, 10, {t.getCriticalPower(self, t)})
+
+ cancelTrances(self)
+ local power = t.getCriticalChance(self, t)
+ game:playSoundNear(self, "talents/spell_generic2")
+ local ret = {
+ phys = self:addTemporaryValue("combat_physcrit", power),
+ spell = self:addTemporaryValue("combat_spellcrit", power),
+ mental = self:addTemporaryValue("combat_mindcrit", power),
+ }
+
+ return ret
+ end,
+ deactivate = function(self, t, p)
+ self:removeTemporaryValue("combat_physcrit", p.phys)
+ self:removeTemporaryValue("combat_spellcrit", p.spell)
+ self:removeTemporaryValue("combat_mindcrit", p.mental)
+ return true
+ end,
+ info = function(self, t)
+ local power = t.getCriticalPower(self, t)
+ local chance = t.getCriticalChance(self, t)
+ return ([[Activate to increase your critical strike damage by %d%% for 10 turns. While this talent is sustained your critical strike chance is improved by +%d%%.
+ The effects will scale with your mindpower.
+ Only one trance may be active at a time.]]):format(power, chance)
+ end,
+}
+
+newTalent{
+ name = "Deep Trance",
+ type = {"psionic/trance", 4},
+ points = 5,
+ require = psi_wil_req4,
+ mode = "passive",
+ info = function(self, t)
+ return ([[When you wield or wear an item infused by psionic, nature, or arcane-disrupting forces you improve all values under its 'when wielded/worn' field %d%%.
+ Note this doesn't change the item itself, but rather the effects it has on your person (the item description will not reflect the improved values).]]):format(1)
+ end,
+}
\ No newline at end of file
diff --git a/game/modules/tome/data/timed_effects/magical.lua b/game/modules/tome/data/timed_effects/magical.lua
index 1a01cd9ace..ccebc0abb2 100644
--- a/game/modules/tome/data/timed_effects/magical.lua
+++ b/game/modules/tome/data/timed_effects/magical.lua
@@ -1552,7 +1552,7 @@ newEffect{
type = "magical",
subtype = {disease=true, blight=true},
status = "detrimental",
- parameters = {},
+ parameters = {str = 0, con = 0, dex = 0, make_ghoul = 0},
on_gain = function(self, err) return "#Target# is afflicted by ghoul rot!" end,
on_lose = function(self, err) return "#Target# is free from the ghoul rot." end,
-- Damage each turn
diff --git a/game/modules/tome/data/timed_effects/mental.lua b/game/modules/tome/data/timed_effects/mental.lua
index f17a324a8d..52cc20c303 100644
--- a/game/modules/tome/data/timed_effects/mental.lua
+++ b/game/modules/tome/data/timed_effects/mental.lua
@@ -2318,25 +2318,6 @@ newEffect{
end,
}
-
-newEffect{
- name = "FEEDBACK", image = "talents/feedback.png",
- desc = "Feedback",
- long_desc = function(self, eff) return ("The target is converting feedback into Psi regen at the rate of %0.2f per turn."):format(eff.power) end,
- type = "mental",
- subtype = { psionic=true },
- status = "beneficial",
- parameters = { power=1 },
- on_gain = function(self, err) return "#target# is recovering Psi quickly.", "+Feedback" end,
- on_lose = function(self, err) return "#target#'s Psi recover has returned to normal.", "-Feedback" end,
- activate = function(self, eff)
- eff.tid = self:addTemporaryValue("psi_regen", eff.power)
- end,
- deactivate = function(self, eff)
- self:removeTemporaryValue("psi_regen", eff.tid)
- end,
-}
-
newEffect{
name = "RESONANCE_SHIELD", image = "talents/resonance_shield.png",
desc = "Resonance Shield",
diff --git a/game/modules/tome/data/timed_effects/other.lua b/game/modules/tome/data/timed_effects/other.lua
index 78c8404bfd..33acaf83d0 100644
--- a/game/modules/tome/data/timed_effects/other.lua
+++ b/game/modules/tome/data/timed_effects/other.lua
@@ -1577,23 +1577,3 @@ newEffect{
self:removeTemporaryValue("global_speed_add", eff.tmpid)
end,
}
-
-newEffect{
- name = "DISMISSAL", image = "talents/dismissal.png",
- desc = "Dismissal",
- long_desc = function(self, eff) return "The target has dismissed reality. For the duration it is immune to new status effects and all damage." end,
- type = "other",
- subtype = { psionic=true },
- status = "beneficial",
- parameters = {},
- on_gain = function(self, err) return "#Target# dismisses reality!", "+Dismissal" end,
- on_lose = function(self, err) return "#Target# reaffirms it's belief in reality.", "-Dismissal" end,
- activate = function(self, eff)
- eff.iid = self:addTemporaryValue("invulnerable", 1)
- eff.imid = self:addTemporaryValue("status_effect_immune", 1)
- end,
- deactivate = function(self, eff)
- self:removeTemporaryValue("invulnerable", eff.iid)
- self:removeTemporaryValue("status_effect_immune", eff.imid)
- end,
-}
\ No newline at end of file
diff --git a/game/modules/tome/dialogs/CharacterSheet.lua b/game/modules/tome/dialogs/CharacterSheet.lua
index bce9ca95c9..7371d10429 100644
--- a/game/modules/tome/dialogs/CharacterSheet.lua
+++ b/game/modules/tome/dialogs/CharacterSheet.lua
@@ -364,7 +364,11 @@ function _M:drawDialog(kind, actor_to_compare)
end
if player:knowTalent(player.T_PSI_POOL) then
text = compare_fields(player, actor_to_compare, "max_psi", "%d", "%+.0f")
- self:mouseTooltip(self.TOOLTIP_PSI, s:drawColorStringBlended(self.font, ("#7fffd4#PSI: #00ff00#%d/%s"):format(player:getPsi(), text), w, h, 255, 255, 255, true)) h = h + self.font_h
+ self:mouseTooltip(self.TOOLTIP_PSI, s:drawColorStringBlended(self.font, ("#7fffd4#Psi: #00ff00#%d/%s"):format(player:getPsi(), text), w, h, 255, 255, 255, true)) h = h + self.font_h
+ end
+ if player:getMaxFeedback() > 0 then
+ text = compare_fields(player, actor_to_compare, "psionic_feedback_max", "%d", "%+.0f")
+ self:mouseTooltip(self.TOOLTIP_FEEDBACK, s:drawColorStringBlended(self.font, ("#7fffd4#Feedback: #00ff00#%d/%s"):format(player:getFeedback(), text), w, h, 255, 255, 255, true)) h = h + self.font_h
end
if player:knowTalent(player.T_EQUILIBRIUM_POOL) then
text = compare_fields(player, actor_to_compare, function(actor) local _, chance = actor:equilibriumChance() return 100 - chance end, "%d%%", "%+.1f%%", 1, true)
@@ -383,6 +387,8 @@ function _M:drawDialog(kind, actor_to_compare)
self:mouseTooltip(self.TOOLTIP_SPEED_SPELL, s:drawColorStringBlended(self.font, ("Spell speed : #00ff00#%s"):format(text), w, h, 255, 255, 255, true)) h = h + self.font_h
text = compare_fields(player, actor_to_compare, function(actor) return actor.combat_physspeed - 1 end, "%.2f%%", "%+.2f%%", 100)
self:mouseTooltip(self.TOOLTIP_SPEED_ATTACK, s:drawColorStringBlended(self.font, ("Attack speed : #00ff00#%s"):format(text), w, h, 255, 255, 255, true)) h = h + self.font_h
+ text = compare_fields(player, actor_to_compare, function(actor) return actor.combat_mentalspeed - 1 end, "%.2f%%", "%+.2f%%", 100)
+ self:mouseTooltip(self.TOOLTIP_SPEED_MENTAL, s:drawColorStringBlended(self.font, ("Mental speed : #00ff00#%s"):format(text), w, h, 255, 255, 255, true)) h = h + self.font_h
h = h + self.font_h
if player.died_times then
text = compare_fields(player, actor_to_compare, function(actor) return #actor.died_times end, "%3d", "%+.0f")
--
GitLab