diff --git a/game/modules/tome/class/Actor.lua b/game/modules/tome/class/Actor.lua
index 9e98c806a1170c96abb4da80cddf68a6c16e8eb2..096f55f2a1582538fc50bba1fb19a531ea6fdf9e 100644
--- a/game/modules/tome/class/Actor.lua
+++ b/game/modules/tome/class/Actor.lua
@@ -493,6 +493,12 @@ function _M:actBase()
 				t.doMindStorm(self, t, p)
 			end
 		end
+		
+		if self:isTalentActive(self.T_DREAMFORGE) then
+			local t, p = self:getTalentFromId(self.T_DREAMFORGE), self:isTalentActive(self.T_DREAMFORGE)
+			t.doForgeStrike(self, t, p)
+		end	
+	
 
 		self:triggerHook{"Actor:actBase:Effects"}
 	end
@@ -2937,7 +2943,7 @@ function _M:learnPool(t)
 		self:learnTalent(self.T_PSI_POOL, true)
 		self.resource_pool_refs[self.T_PSI_POOL] = (self.resource_pool_refs[self.T_PSI_POOL] or 0) + 1
 	end
-	if t.type[1]:find("^psionic/feedback") or t.type[1]:find("^psionic/discharge")and not self:knowTalent(self.T_FEEDBACK_POOL) then
+	if t.type[1]:find("^psionic/feedback") or t.type[1]:find("^psionic/discharge") and not self:knowTalent(self.T_FEEDBACK_POOL) then
 		self:learnTalent(self.T_FEEDBACK_POOL, true)
 	end
 	-- If we learn an archery talent, also learn to shoot
diff --git a/game/modules/tome/class/interface/Archery.lua b/game/modules/tome/class/interface/Archery.lua
index 57e60fbc56a5066805e9a88b5ffdabbb4e52337f..621452a0e05032d63f1d9adeff15210531aa2933 100644
--- a/game/modules/tome/class/interface/Archery.lua
+++ b/game/modules/tome/class/interface/Archery.lua
@@ -361,6 +361,8 @@ local function archery_projectile(tx, ty, tg, self, tmp)
 	if hitted and not target.dead and target:attr("stamina_regen_when_hit") then target:incStamina(target.stamina_regen_when_hit) end
 	if hitted and not target.dead and target:attr("mana_regen_when_hit") then target:incMana(target.mana_regen_when_hit) end
 	if hitted and not target.dead and target:attr("equilibrium_regen_when_hit") then target:incEquilibrium(-target.equilibrium_regen_when_hit) end
+	if hitted and not target.dead and target:attr("psi_regen_when_hit") then target:incPsi(target.psi_regen_when_hit) end
+	if hitted and not target.dead and target:attr("hate_regen_when_hit") then target:incHate(target.hate_regen_when_hit) end
 	
 	-- Resource regen on hit
 	if hitted and self:attr("stamina_regen_on_hit") then self:incStamina(self.stamina_regen_on_hit) end
diff --git a/game/modules/tome/data/birth/classes/psionic.lua b/game/modules/tome/data/birth/classes/psionic.lua
index 0212f663ecd7080e98da86dccda728a586b7f8dd..6b6e15aa1ccda2edf3fcc6411876441d3aa0ffa3 100644
--- a/game/modules/tome/data/birth/classes/psionic.lua
+++ b/game/modules/tome/data/birth/classes/psionic.lua
@@ -169,6 +169,7 @@ newBirthDescriptor{
 	talents_types = {
 		-- class
 		["psionic/distortion"]={true, 0.3},
+		["psionic/dream-smith"]={true, 0.3},
 		["psionic/psychic-assault"]={true, 0.3},
 		["psionic/slumber"]={true, 0.3},
 		["psionic/solipsism"]={true, 0.3},
@@ -182,6 +183,7 @@ newBirthDescriptor{
 		
 		-- locked trees
 		["psionic/discharge"]={false, 0.3},
+		["psionic/dream-forge"]={false, 0.3},
 		["psionic/nightmare"]={false, 0.3},
 	},
 	talents = {
diff --git a/game/modules/tome/data/damage_types.lua b/game/modules/tome/data/damage_types.lua
index 855058ba67ae94829a2bbc3782ce63a85934931b..88edc4e73e9d7b9e5c70ed3dbad871e97d14c7ff 100644
--- a/game/modules/tome/data/damage_types.lua
+++ b/game/modules/tome/data/damage_types.lua
@@ -56,6 +56,10 @@ setDefaultProjector(function(src, x, y, type, dam, tmp, no_martyr)
 			local e = target.tempeffect_def[target.EFF_BLOCKING]
 			dam = e.do_block(type, dam, target.tmp[target.EFF_BLOCKING], target, src)
 		end
+		if target.isTalentActive and target:isTalentActive(target.T_FORGE_SHIELD) then
+			local t = target:getTalentFromId(target.T_FORGE_SHIELD)
+			dam = t.doForgeShield(type, dam, t, target, src)
+		end
 
 		-- Increases damage
 		local mind_linked = false
@@ -2138,4 +2142,48 @@ newDamageType{
 			end
 		end
 	end,
+}
+
+-- Mind/Fire damage with lots of parameter options
+newDamageType{
+	name = "dreamforge", type = "DREAMFORGE",
+	projector = function(src, x, y, type, dam, tmp)
+		local target = game.level.map(x, y, Map.ACTOR)
+		if not target then return end
+		local power, dur, dist, do_particles
+		tmp = tmp or {}
+		if _G.type(dam) == "table" then dam, power, dur, dist, do_particles = dam.dam, dam.power, dam.dur, dam.dist, dam.do_particles end
+		if target and not tmp[target] then 
+			if src:checkHit(src:combatMindpower(), target:combatMentalResist(), 0, 95) then
+				DamageType:get(DamageType.MIND).projector(src, x, y, DamageType.MIND, {dam=dam/2, alwaysHit=true})
+				DamageType:get(DamageType.FIREBURN).projector(src, x, y, DamageType.FIREBURN, dam/2)
+				if power and power > 0 then 
+					local silent = true and target:hasEffect(target.EFF_BROKEN_DREAM) or false
+					target:setEffect(target.EFF_BROKEN_DREAM, dur, {power=power}, silent)
+					target:crossTierEffect(target.EFF_BRAINLOCKED, src:combatMindpower())
+				end
+				-- Do knockback
+				if dist then
+					if target:canBe("knockback") then
+						target:knockback(src.x, src.y, dist)
+						target:crossTierEffect(target.EFF_OFFBALANCE, src:combatMindpower())
+						game.logSeen(target, "%s is knocked back!", target.name:capitalize())
+					else
+						game.logSeen(target, "%s resists the forge bellow!", target.name:capitalize())
+					end
+				end
+				if do_particles then
+					if rng.percent(50) then
+						game.level.map:particleEmitter(target.x, target.y, 1, "generic_discharge", {rm=225, rM=255, gm=160, gM=160, bm=0, bM=0, am=35, aM=90})
+					elseif hit then
+						game.level.map:particleEmitter(target.x, target.y, 1, "generic_discharge", {rm=225, rM=255, gm=225, gM=255, bm=255, bM=255, am=35, aM=90})
+					end
+				end
+			else -- Save for half damage
+				DamageType:get(DamageType.MIND).projector(src, x, y, DamageType.MIND, {dam=dam/4, alwaysHit=true})
+				DamageType:get(DamageType.FIREBURN).projector(src, x, y, DamageType.FIREBURN, dam/4)
+				game.logSeen(target, "%s resists the dream forge!", target.name:capitalize())
+			end
+		end
+	end,
 }
\ No newline at end of file
diff --git a/game/modules/tome/data/gfx/effects/broken_dream.png b/game/modules/tome/data/gfx/effects/broken_dream.png
new file mode 100644
index 0000000000000000000000000000000000000000..6572d17912c49fe4276e15650e7d3cf75421fdf8
Binary files /dev/null and b/game/modules/tome/data/gfx/effects/broken_dream.png differ
diff --git a/game/modules/tome/data/gfx/particles/dreamhammer.lua b/game/modules/tome/data/gfx/particles/dreamhammer.lua
new file mode 100644
index 0000000000000000000000000000000000000000..abc535e90532e22e99207d4ac81a5266161f2ce5
--- /dev/null
+++ b/game/modules/tome/data/gfx/particles/dreamhammer.lua
@@ -0,0 +1,45 @@
+-- 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
+
+base_size = 64
+local nb = 1
+
+return {
+	system_rotation = 225 + math.deg(math.atan2(ty-sy, tx-sx)), system_rotationv = 0,
+
+	base = 1000,
+
+	angle = { 0, 0 }, anglev = { 0, 0 }, anglea = { 0, 0 },
+
+	life = { 10, 10 },
+	size = { 64, 64 }, sizev = {0, 0}, sizea = {0, 0},
+
+	r = {255, 255}, rv = {0, 0}, ra = {0, 0},
+	g = {255, 255}, gv = {0, 0}, ga = {0, 0},
+	b = {255, 255}, bv = {0, 0}, ba = {0, 0},
+	a = {255, 255}, av = {0, 0}, aa = {0, 0},
+
+},
+ function(self)
+	if nb == 1 then
+		self.ps:emit(1)
+		nb = nb -1
+	end
+end,
+ 1, tile, true
diff --git a/game/modules/tome/data/gfx/shockbolt/object/dream_hammer.png b/game/modules/tome/data/gfx/shockbolt/object/dream_hammer.png
new file mode 100644
index 0000000000000000000000000000000000000000..9ccdd24db274fefd3266cf729cd7658d54dee77b
Binary files /dev/null and b/game/modules/tome/data/gfx/shockbolt/object/dream_hammer.png differ
diff --git a/game/modules/tome/data/gfx/talents/dream_crusher.png b/game/modules/tome/data/gfx/talents/dream_crusher.png
new file mode 100644
index 0000000000000000000000000000000000000000..add18a553e091451f9b0426284993276009e5e57
Binary files /dev/null and b/game/modules/tome/data/gfx/talents/dream_crusher.png differ
diff --git a/game/modules/tome/data/gfx/talents/dream_hammer.png b/game/modules/tome/data/gfx/talents/dream_hammer.png
new file mode 100644
index 0000000000000000000000000000000000000000..6d9e3f2c187a075350ef06255bef83e05cfdd9ce
Binary files /dev/null and b/game/modules/tome/data/gfx/talents/dream_hammer.png differ
diff --git a/game/modules/tome/data/gfx/talents/dreamforge.png b/game/modules/tome/data/gfx/talents/dreamforge.png
new file mode 100644
index 0000000000000000000000000000000000000000..7c8e1259d52dd00222199b41a3183bd8d44a90d1
Binary files /dev/null and b/game/modules/tome/data/gfx/talents/dreamforge.png differ
diff --git a/game/modules/tome/data/gfx/talents/forge_armor.png b/game/modules/tome/data/gfx/talents/forge_armor.png
new file mode 100644
index 0000000000000000000000000000000000000000..d48f3267c71b19d02eafe914b8b842e2aa66a0c6
Binary files /dev/null and b/game/modules/tome/data/gfx/talents/forge_armor.png differ
diff --git a/game/modules/tome/data/gfx/talents/forge_bellows.png b/game/modules/tome/data/gfx/talents/forge_bellows.png
new file mode 100644
index 0000000000000000000000000000000000000000..ac33b3c0a1ad2edd2106f3c3ff7ea4c9041ba1f7
Binary files /dev/null and b/game/modules/tome/data/gfx/talents/forge_bellows.png differ
diff --git a/game/modules/tome/data/gfx/talents/forge_echoes.png b/game/modules/tome/data/gfx/talents/forge_echoes.png
new file mode 100644
index 0000000000000000000000000000000000000000..a6fdb221643b3795358acf28494570dcfa85c21e
Binary files /dev/null and b/game/modules/tome/data/gfx/talents/forge_echoes.png differ
diff --git a/game/modules/tome/data/gfx/talents/forge_shield.png b/game/modules/tome/data/gfx/talents/forge_shield.png
new file mode 100644
index 0000000000000000000000000000000000000000..52e0bd13d8366377d0186a41ad5d9e3bcbe71fbd
Binary files /dev/null and b/game/modules/tome/data/gfx/talents/forge_shield.png differ
diff --git a/game/modules/tome/data/gfx/talents/hammer_toss.png b/game/modules/tome/data/gfx/talents/hammer_toss.png
new file mode 100644
index 0000000000000000000000000000000000000000..73e08ef8ab95ab66682a33524c08a9276f8f0f66
Binary files /dev/null and b/game/modules/tome/data/gfx/talents/hammer_toss.png differ
diff --git a/game/modules/tome/data/talents/chronomancy/spacetime-weaving.lua b/game/modules/tome/data/talents/chronomancy/spacetime-weaving.lua
index 29eaa632cdb4e764805776f1da76bbc48d9f6e07..b71b453e2f43315fc58d28b001cc61c6bfe2ca76 100644
--- a/game/modules/tome/data/talents/chronomancy/spacetime-weaving.lua
+++ b/game/modules/tome/data/talents/chronomancy/spacetime-weaving.lua
@@ -64,7 +64,7 @@ newTalent{
 	info = function(self, t)
 		local range = self:getTalentRange(t)
 		return ([[Teleports you to up to %d tiles away to a targeted location in line of sight.  Additional talent points increase the range.
-		This spell takes no time to cast..]]):format(range)
+		This spell takes no time to cast.]]):format(range)
 	end,
 }
 
diff --git a/game/modules/tome/data/talents/psionic/distortion.lua b/game/modules/tome/data/talents/psionic/distortion.lua
index e11c835d71402bdfc0c3cb2967deb2af4251cce0..e693b315cb9e367cfff0fe87c159b4923a0294d6 100644
--- a/game/modules/tome/data/talents/psionic/distortion.lua
+++ b/game/modules/tome/data/talents/psionic/distortion.lua
@@ -152,7 +152,6 @@ newTalent{
 	target = function(self, t)
 		return {type="hit", range=self:getTalentRange(t), nolock=true, talent=t}
 	end,
-	tactical = { ATTACKAREA = { PHYSICAL = 2 }, DISABLE = 1 },
 	action = function(self, t)
 		local tg = self:getTalentTarget(t)
 		local x, y = self:getTarget(tg)
@@ -166,8 +165,8 @@ newTalent{
 		local e = Object.new{
 			old_feat = oe,
 			type = oe.type, subtype = oe.subtype,
-			name = "maelstrom", image = oe.image, --add_mos = {{image = "terrain/wormhole.png"}},
-			display = '&', color_r=255, color_g=255, color_b=255, back_color=colors.STEEL_BLUE,
+			name = "maelstrom", image = oe.image,
+			display = oe.display, color=oe.color, back_color=oe.back_color,
 			always_remember = true,
 			temporary = t.getDuration(self, t),
 			is_maelstrom = true,
diff --git a/game/modules/tome/data/talents/psionic/dream-forge.lua b/game/modules/tome/data/talents/psionic/dream-forge.lua
new file mode 100644
index 0000000000000000000000000000000000000000..dd68a6e9c1d1535c32c5eb79e7c20af1c60af117
--- /dev/null
+++ b/game/modules/tome/data/talents/psionic/dream-forge.lua
@@ -0,0 +1,267 @@
+-- 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
+
+local Object = require "mod.class.Object"
+
+newTalent{
+	name = "Forge Shield",
+	type = {"psionic/dream-forge", 1},
+	points = 5, 
+	require = psi_wil_high1,
+	cooldown = 24,
+	sustain_psi = 25,
+	mode = "sustained",
+	tactical = { DEFEND = 2, },
+	getPower = function(self, t) return self:combatTalentMindDamage(t, 15, 150) end,
+	doForgeShield = function(type, dam, t, self, src)
+		-- Grab our damage threshold
+		local dam_threshold = self.max_life * 0.08
+		if self:knowTalent(self.T_SOLIPSISM) then
+			local t = self:getTalentFromId(self.T_SOLIPSISM)
+			local ratio = t.getConversionRatio(self, t)
+			local psi_percent =  self:getMaxPsi() * t.getConversionRatio(self, t)
+			dam_threshold = (self.max_life * (1 - ratio) + psi_percent) * 0.08
+		end
+
+		local dur = self:getTalentLevel(t) >= 5 and 2 or 1
+		local blocked
+		local amt = dam
+		local eff = self:hasEffect(self.EFF_FORGE_SHIELD)
+		if not eff and dam > dam_threshold then
+			self:setEffect(self.EFF_FORGE_SHIELD, dur, {power=t.getPower(self, t), number=1, d_types={[type]=true}})
+			amt = util.bound(dam - t.getPower(self, t), 0, dam)
+			blocked = t.getPower(self, t)
+			game.logSeen(self, "#ORANGE#%s forges a dream shield to block the attack!", self.name:capitalize())
+		elseif eff and eff.d_types[type] then
+			amt = util.bound(dam - eff.power, 0, dam)
+			blocked = eff.power
+		elseif eff and dam > dam_threshold * (1 + eff.number) then
+			eff.number = eff.number + 1
+			eff.d_types[type] = true
+			amt = util.bound(dam - eff.power, 0, dam)
+			blocked = eff.power
+			game.logSeen(self, "#ORANGE#%s's dream shield has been strengthened by the attack!", self.name:capitalize())
+		end
+
+		if blocked then
+			print("[Forge Shield] blocked", math.min(blocked, dam), DamageType.dam_def[type].name, "damage")
+		end
+		
+		if amt == 0 and src.life then src:setEffect(src.EFF_COUNTERSTRIKE, 1, {power=t.getPower(self, t), no_ct_effect=true, src=self, nb=1}) end
+		return amt
+	end,
+	activate = function(self, t)
+		game:playSoundNear(self, "talents/spell_generic")
+		local ret ={
+		}
+		if self:knowTalent(self.T_FORGE_ARMOR) then
+			local t = self:getTalentFromId(self.T_FORGE_ARMOR)
+			ret.def = self:addTemporaryValue("combat_def", t.getDefense(self, t))
+			ret.armor = self:addTemporaryValue("combat_armor", t.getArmor(self, t))
+			ret.psi = self:addTemporaryValue("psi_regen_when_hit", t.getPsiRegen(self, t))
+		end
+		return ret
+	end,
+	deactivate = function(self, t, p)
+		if p.def then self:removeTemporaryValue("combat_def", p.def) end
+		if p.armor then self:removeTemporaryValue("combat_armor", p.armor) end
+		if p.psi then self:removeTemporaryValue("psi_regen_when_hit", p.psi) end
+	
+		return true	
+	end,
+	info = function(self, t)
+		local power = t.getPower(self, t)
+		return ([[When an attack would deal 8%% or more of your effective health you forge the Dream Shield to protect yourself, reducing the damage of all attacks of that type by %0.2f for the next turn.
+		You may block multiple damage types at one time but the base damage threshold increases by 8%% per damage type the shield is already blocking.
+		If you block all of an attack's damage, the attacker will be vulnerable to a deadly counterstrike (a normal attack will instead deal 200%% damage) for one turn.
+		At talent level five the block effect will last two turns.
+		This talent scales with your mindpower.]]):format(power)
+	end,
+}
+
+newTalent{
+	name = "Forge Bellows",
+	type = {"psionic/dream-forge", 2},
+	points = 5, 
+	require = psi_wil_high2,
+	cooldown = 24,
+	psi = 30,
+	tactical = { ATTACKAREA = { FIRE = 2, MIND = 2}, ESCAPE = 2, },
+	range = 0,
+	radius = function(self, t) return math.min(10, 3 + math.ceil(self:getTalentLevel(t)/2)) end,
+	requires_target = true,
+	target = function(self, t)
+		return {type="cone", range=self:getTalentRange(t), friendlyfire=false, radius = self:getTalentRadius(t), talent=t}
+	end,
+	getDuration = function(self, t) return 5 + math.floor(self:getTalentLevel(t)) end,
+	getBlastDamage = function(self, t) return self:combatTalentMindDamage(t, 20, 200) end,
+	getForgeDamage = function(self, t) return self:combatTalentMindDamage(t, 0, 25) 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
+
+		local blast_damage = self:mindCrit(t.getBlastDamage(self, t))
+		local forge_damage = self:mindCrit(t.getForgeDamage(self, t))
+		
+		-- Do our blast first
+		self:project(tg, x, y, DamageType.DREAMFORGE, {dam=blast_damage, dist=math.ceil(tg.radius/2)})
+		
+		-- Now build our Barrier
+		self:project(tg, x, y, function(px, py, tg, self)
+			local oe = game.level.map(px, py, Map.TERRAIN)
+			if rng.percent(50) or not oe or oe.is_forgebarrier or game.level.map:checkAllEntities(px, py, "block_move") then return end
+			
+			local e = Object.new{
+				old_feat = oe,
+				type = oe.type, subtype = oe.subtype,
+				name = "forge barrier", image = "terrain/lava/lava_mountain5.png",
+				display = '#', color=colors.RED, back_color=colors.DARK_GREY,
+				shader = "shadow_simulacrum",
+				shader_args = { color = {0.6, 0.0, 0.0}, base = 0.9, time_factor = 1500 },
+				always_remember = true,
+				can_pass = {pass_wall=1},
+				block_move = true,
+				block_sight = true,
+				temporary = t.getDuration(self, t),
+				is_forgebarrier = true,
+				x = px, y = py,
+				canAct = false,
+				dam = forge_damage,
+				radius = self:getTalentRadius(t),
+				act = function(self)
+					local tg = {type="ball", range=0, friendlyfire=false, radius = 1, talent=t, x=self.x, y=self.y,}
+					self.summoner:project(tg, self.x, self.y, engine.DamageType.DREAMFORGE, self.dam)
+									
+					self:useEnergy()
+					self.temporary = self.temporary - 1
+					if self.temporary <= 0 then
+						game.level.map(self.x, self.y, engine.Map.TERRAIN, self.old_feat)
+						game.level:removeEntity(self)
+						game.level.map:updateMap(self.x, self.y)
+					end
+				end,
+				summoner_gain_exp = true,
+				summoner = self,
+			}
+		
+			game.level:addEntity(e)
+			game.level.map(px, py, Map.TERRAIN, e)
+			game.nicer_tiles:updateAround(game.level, px, py)
+			game.level.map:updateMap(px, py)
+		end)
+		game:playSoundNear(self, "talents/fireflash")
+		return true
+	end,
+	info = function(self, t)
+		local blast_damage = t.getBlastDamage(self, t)
+		local radius = self:getTalentRadius(t)
+		local duration = t.getDuration(self, t)
+		local forge_damage = t.getForgeDamage(self, t)
+		return ([[Release the bellows of the forge upon your surroundings, inflicting %0.2f mind damage, %0.2f burning damage, and knocking back your enemies in a radius %d cone.
+		Affected terrain may be changed (50%% chance) for %d turns into forge walls that block movement and inflict %0.2f mind and %0.2f fire damage on nearby enemies.
+		The damage and knockback chance will scale with your mindpower.]]):
+		format(damDesc(self, DamageType.MIND, blast_damage), damDesc(self, DamageType.FIRE, blast_damage), radius, duration, damDesc(self, DamageType.MIND, forge_damage), damDesc(self, DamageType.FIRE, forge_damage))
+	end,
+}
+
+newTalent{
+	name = "Forge Armor",
+	type = {"psionic/dream-forge", 3},
+	points = 5,
+	require = psi_wil_high3,
+	mode = "passive",
+	getArmor = function(self, t) return self:combatTalentMindDamage(t, 5, 50) end,
+	getDefense = function(self, t) return self:combatTalentMindDamage(t, 5, 25) end,
+	getPsiRegen = function(self, t) return self:combatTalentMindDamage(t, 1, 5) end,
+	info = function(self, t)
+		local armor = t.getArmor(self, t)
+		local defense = t.getDefense(self, t)
+		local psi = t.getPsiRegen(self, t)
+		return([[Your Forge Shield talent now increses your armor by %d, your defense by %d, and gives you %0.2f psi when you're hit by a melee or ranged attack.
+		The bonuses will scale with your mindpower.]]):format(armor, defense, psi)
+	end,
+}
+
+newTalent{
+	name = "Dreamforge",
+	type = {"psionic/dream-forge", 4},
+	points = 5, 
+	require = psi_wil_high4,
+	cooldown = 24,
+	sustain_psi = 50,
+	mode = "sustained",
+	no_sustain_autoreset = true,
+	tactical = { ATTACKAREA = { FIRE = 2, MIND = 2}, DEBUFF = 2, },
+	range = 0,
+	radius = function(self, t) return math.min(5, 1 + math.ceil(self:getTalentLevel(t)/2)) end,
+	target = function(self, t)
+		return {type="ball", range=self:getTalentRange(t), friendlyfire=false, radius = self:getTalentRadius(t), talent=t}
+	end,
+	getDamage = function(self, t) return math.ceil(self:combatTalentMindDamage(t, 10, 100)) end,
+	getPower = function(self, t) return math.floor(self:combatTalentMindDamage(t, 5, 50)) end,
+	getDuration = function(self, t) return 1 + math.floor(self:getTalentLevel(t)/2) end,
+	doForgeStrike = function(self, t, p)
+		-- If we moved reset the forge
+		if self.x ~= p.x or self.y ~= p.y or p.new then
+			p.x = self.x; p.y=self.y; p.radius=0; p.damage=0; p.power=0; p.new = nil;
+		-- Otherwise we strike the forge
+		elseif not self.resting then
+			local max_radius = self:getTalentRadius(t)
+			local max_damage = t.getDamage(self, t)
+			local power = t.getPower(self, t)
+			local dur = 0
+			p.radius = math.min(p.radius + 1, max_radius)
+
+			if p.damage < max_damage then
+				p.radius = math.min(p.radius + 1, max_radius)
+				p.damage = math.min(max_damage/4 + p.damage, max_damage)
+				game.logSeen(self, "#GOLD#%s strikes the dreamforge!", self.name:capitalize())
+			elseif p.power == 0 then
+				p.power = power
+				dur = t.getDuration(self, t)
+				game.logSeen(self, "#GOLD#%s begins breaking dreams!", self.name:capitalize())
+				game:playSoundNear(self, "talents/lightning_loud")
+			end
+			local tg = {type="ball", range=self:getTalentRange(t), friendlyfire=false, radius=p.radius, talent=t}
+			self:project(tg, self.x, self.y, engine.DamageType.DREAMFORGE, {dam=self:combatMindCrit(p.damage), power=p.power, dur=dur, do_particles=true })
+		end
+	end,
+	activate = function(self, t)
+		local ret ={
+			x = self.x, y=self.y, radius=0, damage=0, power=0, new = true,
+		}
+		game:playSoundNear(self, "talents/devouringflame")
+		return ret
+	end,
+	deactivate = function(self, t, p)
+		return true	
+	end,
+	info = function(self, t)
+		local radius = self:getTalentRadius(t)
+		local damage = t.getDamage(self, t)
+		local power = t.getPower(self, t)
+		local duration = t.getDuration(self, t)
+		return ([[The pounding forge of thought in your mind is released upon your surroundings.  Each turn that you remain stationary you'll strike the dreamforge, inflicting mind and burning damage on enemies around you.
+		The effect will build over five turns, until it reaches a maximum radius of %d, maximum mind damage of %0.2f, and maximum burning damage of %0.2f.
+		At this point you'll begin breaking the dreams of enemies who hear the forge, reducing their mental save by %d and giving them a %d%% chance of spell failure due too the tremendous echo in their minds for %d turns.
+		The damage and dream breaking effect will scale with your mindpower.]]):
+		format(radius, damDesc(self, DamageType.MIND, damage), damDesc(self, DamageType.FIRE, damage), power, power, duration)
+	end,
+}
diff --git a/game/modules/tome/data/talents/psionic/dream-smith.lua b/game/modules/tome/data/talents/psionic/dream-smith.lua
new file mode 100644
index 0000000000000000000000000000000000000000..03ad7e0d5d45850d7aa2c029557a1e16db2fc418
--- /dev/null
+++ b/game/modules/tome/data/talents/psionic/dream-smith.lua
@@ -0,0 +1,276 @@
+-- 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
+
+-- Dream-Forge Hammer
+function useDreamHammer(self)
+	local combat = {
+		talented = "dream",
+		sound = {"actions/melee", pitch=0.6, vol=1.2}, sound_miss = {"actions/melee", pitch=0.6, vol=1.2},
+
+		wil_attack = true,
+		damrange = 1.5,
+		physspeed = 1, 
+		dam = 16,
+		apr = 0,
+		atk = 0,
+		physcrit = 0,
+		dammod = {wil=1.2},
+		melee_project = {},
+	}
+	if self:knowTalent(self.T_DREAM_HAMMER) then
+		local t = self:getTalentFromId(self.T_DREAM_HAMMER)
+		combat.dam = 16 + t.getBaseDamage(self, t)
+		combat.apr = 0 + t.getBaseApr(self, t)
+		combat.physcrit = 0 + t.getBaseCrit(self, t)
+		combat.atk = 0 + t.getBaseAtk(self, t)
+	end
+	if self:knowTalent(self.T_HAMMER_TOSS) then
+		local t = self:getTalentFromId(self.T_HAMMER_TOSS)
+		combat.atk = t.getAttackTotal(self, t)
+	end
+	if self:knowTalent(self.T_FORGE_ECHOES) then
+		local t = self:getTalentFromId(self.T_FORGE_ECHOES)
+		combat.melee_project = { [engine.DamageType.DREAMFORGE] = t.getProject(self, t) }
+	end
+	return combat
+end
+
+newTalent{
+	name = "Dream Smith's Hammer",
+	short_name = "DREAM_HAMMER",
+	type = {"psionic/dream-smith", 1},
+	points = 5, 
+	require = psi_wil_req1,
+	cooldown = 6,
+	psi = 5,
+	requires_target = true,
+	tactical = { ATTACK = { weapon = 2 } },
+	getDamage = function(self, t) return self:combatTalentWeaponDamage(t, 1.4, 2.1) end,
+	getBaseDamage = function(self, t) return self:combatTalentMindDamage(t, 0, 60) end,
+	getBaseAtk = function(self, t) return self:combatTalentMindDamage(t, 0, 20) end,
+	getBaseApr = function(self, t) return self:combatTalentMindDamage(t, 0, 20) end,
+	getBaseCrit = function(self, t) return self:combatTalentMindDamage(t, 0, 20) end,
+	action = function(self, t)
+		local tg = {type="hit", range=self:getTalentRange(t)}
+		local x, y, target = self:getTarget(tg)
+		if not x or not y or not target then return nil end
+		if core.fov.distance(self.x, self.y, x, y) > 1 then return nil end
+		local speed, hit = self:attackTargetWith(target, useDreamHammer(self), nil, t.getDamage(self, t))
+		game.level.map:particleEmitter(target.x, target.y, 1, "dreamhammer", {tile="shockbolt/object/dream_hammer", tx=target.x, ty=target.y, sx=self.x, sy=self.y})
+		
+		-- Reset Dream Smith talents
+		if hit then
+			for tid, cd in pairs(self.talents_cd) do
+				local tt = self:getTalentFromId(tid)
+				if tt.type[1]=="psionic/dream-smith" then
+					self.talents_cd[tid] = 0
+				end
+			end
+			if rng.percent(50) then
+				game.level.map:particleEmitter(self.x, self.y, 1, "generic_charge", {rm=225, rM=255, gm=0, gM=0, bm=0, bM=0, am=35, aM=90})
+			elseif hit then
+				game.level.map:particleEmitter(self.x, self.y, 1, "generic_charge", {rm=225, rM=255, gm=225, gM=255, bm=0, bM=0, am=35, aM=90})
+			end
+			game:playSoundNear(self, "talents/heal")
+		end
+
+		return true
+	end,
+	info = function(self, t)
+		local damage = t.getDamage(self, t)
+		local weapon_damage = useDreamHammer(self).dam
+		local weapon_range = useDreamHammer(self).dam * useDreamHammer(self).damrange
+		local weapon_atk = useDreamHammer(self).atk
+		local weapon_apr = useDreamHammer(self).apr
+		local weapon_crit = useDreamHammer(self).physcrit
+		return ([[Smith a hammer from the dream forge and strike a nearby foe, inflicting %d%% weapon damage.  If the attack hits it will bring all Dream Smith talents off cooldown.
+		The base power, accuracy, armour penetration, and critical strike chance of the weapon will scale with your mindpower.
+
+		Current Dream Hammer Stats
+		Base Power: %0.2f - %0.2f
+		Uses Stats: 120%% Wil
+		Damage Type: Physical
+		Accuracy is based on willpower for this weapon.
+		Accuracy Bonus: +%d
+		Armour Penetration: +%d
+		Physical Crit. Chance: +%d]]):format(damage * 100, weapon_damage, weapon_range, weapon_atk, weapon_apr, weapon_crit)
+	end,
+}
+
+newTalent{
+	name = "Hammer Toss",
+	type = {"psionic/dream-smith", 2},
+	points = 5, 
+	require = psi_wil_req2,
+	cooldown = 8,
+	psi = 10,
+	tactical = { ATTACKAREA = { weapon = 2 } },
+	range = function(self, t) return 5 + self:getTalentLevelRaw(t) end,
+	requires_target = true,
+	proj_speed = 10,
+	target = function(self, t)
+		return {type="beam", range=self:getTalentRange(t), selffire=false, talent=t, display={display='', particle="arrow", particle_args={tile="shockbolt/object/dream_hammer"}, trail="firetrail"}}
+	end,
+	getDamage = function(self, t) return self:combatTalentWeaponDamage(t, 1, 1.5) end,
+	getAttack = function(self, t) return self:getTalentLevel(t) * 10 end, -- Used for the talent display
+	getAttackTotal = function(self, t)
+		local base_atk = 0
+		if self:knowTalent(self.T_DREAM_HAMMER) then
+			local t = self:getTalentFromId(self.T_DREAM_HAMMER)
+			base_atk = 0 + t.getBaseAtk(self, t)
+		end
+		return base_atk + t.getAttack(self, t)
+	end,
+	getDreamHammer = function(self, t) return useDreamHammer(self) end, -- To prevent upvalue issues
+	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
+		local _ _, x, y = self:canProject(tg, x, y)
+		
+		print("[Dream Hammer Throw] Projection from", self.x, self.y, "to", x, y)
+		self:projectile(tg, x, y, function(px, py, tg, self)
+			local tmp_target = game.level.map(px, py, engine.Map.ACTOR)
+			if tmp_target and tmp_target ~= self then
+				local t = self:getTalentFromId(self.T_HAMMER_TOSS)
+				self:attackTargetWith(tmp_target, t.getDreamHammer(self, t), nil, t.getDamage(self, t))
+			end
+			if x == px and y == py and self and self.x and self.y then
+				print("[Dream Hammer Return] Projection from", x, y, "to", self.x, self.y)
+				local tgr = tg
+				tgr.x, tgr.y = px, py
+				self:projectile(tgr, self.x, self.y, function(px, py, tgr, self)
+					local tmp_target = game.level.map(px, py, engine.Map.ACTOR)
+					local t = self:getTalentFromId(self.T_HAMMER_TOSS)
+					if tmp_target and tmp_target ~= self then
+						self:attackTargetWith(tmp_target, t.getDreamHammer(self, t), nil, t.getDamage(self, t))
+					end
+				end)
+			end
+		end)
+		
+		game:playSoundNear(self, "talents/warp")
+		return true
+	end,
+	info = function(self, t)
+		local damage = t.getDamage(self, t)
+		local attack_bonus = t.getAttack(self, t)
+		return ([[Throw your Dream Hammer at a distant target, inflicting %d%% weapon damage on all creatures between you and it.  After reaching it's destination the Dream Hammer will return, potentially hitting creatures a second time.
+		Learning this talent increases the accuracy of your Dream Hammer by %d.]]):format(damage * 100, attack_bonus)
+	end,
+}
+
+newTalent{
+	name = "Dream Crusher",
+	type = {"psionic/dream-smith", 3},
+	points = 5, 
+	require = psi_wil_req3,
+	cooldown = 12,
+	psi = 10,
+	requires_target = true,
+	tactical = { ATTACK = { weapon = 2 }, DISABLE = { stun = 2 } },
+	getDamage = function(self, t) return self:combatTalentWeaponDamage(t, 1, 1.5) end,
+	getMasteryDamage = function(self, t) return self:getTalentLevel(t) * 10 end,
+	getPercentInc = function(self, t) return math.sqrt(self:getTalentLevel(t) / 5) / 2 end,
+	getStun = function(self, t) return 2 + math.floor(self:getTalentLevel(t)) end,
+	action = function(self, t)
+		local tg = {type="hit", range=self:getTalentRange(t)}
+		local x, y, target = self:getTarget(tg)
+		if not x or not y or not target then return nil end
+		if core.fov.distance(self.x, self.y, x, y) > 1 then return nil end
+		local speed, hit = self:attackTargetWith(target, useDreamHammer(self), nil, t.getDamage(self, t))
+		game.level.map:particleEmitter(target.x, target.y, 1, "dreamhammer", {tile="shockbolt/object/dream_hammer", tx=target.x, ty=target.y, sx=self.x, sy=self.y})
+		
+		-- Try to stun !
+		if hit then
+			if target:canBe("stun") then
+				target:setEffect(target.EFF_STUNNED, t.getStun(self, t), {apply_power=self:combatMindpower()})
+			else
+				game.logSeen(target, "%s resists the stunning blow!", target.name:capitalize())
+			end
+			if rng.percent(50) then
+				game.level.map:particleEmitter(target.x, target.y, 1, "generic_discharge", {rm=225, rM=255, gm=0, gM=0, bm=0, bM=0, am=35, aM=90})
+			elseif hit then
+				game.level.map:particleEmitter(target.x, target.y, 1, "generic_discharge", {rm=225, rM=255, gm=225, gM=255, bm=0, bM=0, am=35, aM=90})
+			end
+			game:playSoundNear(self, "talents/lightning_loud")
+		end
+		return true
+	end,
+	info = function(self, t)
+		local damage = t.getDamage(self, t)
+		local power = t.getMasteryDamage(self, t)
+		local percent = t.getPercentInc(self, t)
+		local stun = t.getStun(self, t)		
+		return ([[Crush your enemy with your Dream Hammer, inflicting %d%% of weapon damage.  If the attack hits, the target is stunned for %d turns.
+		Stun chance improves with your mindpower.  Learning this talent increases your Physical Power for Dream Hammer damage calculations by %d and all damage with Dream Hammer attacks by %d%%.
+		]]):format(damage * 100, stun, power, percent * 100)
+	end,
+}
+
+newTalent{
+	name = "Forge Echoes",
+	type = {"psionic/dream-smith", 4},
+	points = 5, 
+	require = psi_wil_req4,
+	cooldown = 24,
+	psi = 20,
+	tactical = { ATTACKAREA = { weapon = 3 } },
+	radius = function(self, t) return 1 + math.floor(self:getTalentLevel(t)/2) end,
+	requires_target = true,
+	target = function(self, t)
+		return {type="ball", range=self:getTalentRange(t), radius=self:getTalentRadius(t), friendlyfire=false }
+	end,
+	getDamage = function(self, t) return self:combatTalentWeaponDamage(t, 1, 1.5) end,
+	getProject = function(self, t) return self:combatTalentMindDamage(t, 10, 50) end,
+	action = function(self, t)
+		local tg = {type="hit", range=self:getTalentRange(t)}
+		local x, y, target = self:getTarget(tg)
+		if not x or not y or not target then return nil end
+		if core.fov.distance(self.x, self.y, x, y) > 1 then return nil end
+		local speed, hit = self:attackTargetWith(target, useDreamHammer(self), nil, t.getDamage(self, t))
+		game.level.map:particleEmitter(target.x, target.y, 1, "dreamhammer", {tile="shockbolt/object/dream_hammer", tx=target.x, ty=target.y, sx=self.x, sy=self.y})
+		
+		-- Forge Echoe
+		if hit then
+			local tg = self:getTalentTarget(t)
+			self:project(tg, target.x, target.y, function(px, py, tg, self)
+				local tmp_target = game.level.map(px, py, Map.ACTOR)
+				if tmp_target and tmp_target ~= self and tmp_target ~= target then
+					local hit = self:attackTargetWith(tmp_target, useDreamHammer(self), nil, t.getDamage(self, t))
+					if hit and rng.percent(50) then
+						game.level.map:particleEmitter(tmp_target.x, tmp_target.y, 1, "generic_discharge", {rm=225, rM=255, gm=0, gM=0, bm=0, bM=0, am=35, aM=90})
+					elseif hit then
+						game.level.map:particleEmitter(tmp_target.x, tmp_target.y, 1, "generic_discharge", {rm=225, rM=255, gm=225, gM=255, bm=0, bM=0, am=35, aM=90})
+					end
+				end
+			end)
+			game:playSoundNear(self, "talents/echo")
+		end
+		return true
+	end,
+	info = function(self, t)
+		local damage = t.getDamage(self, t)
+		local radius = self:getTalentRadius(t)
+		local project = t.getProject(self, t)
+		return ([[Strike the target with a mighty blow from the forge, inflicting %d%% weapon damage.  If the attack hits the echo of the attack will lash out at all enemies in a %d radius.
+		Learning this talent adds %0.2f mind damage and %0.2f burning damage to your Dream Hammer strikes.
+		The mind and fire damage will scale with your mindpower.]]):format(damage * 100, radius, damDesc(self, DamageType.MIND, project), damDesc(self, DamageType.FIRE, project))
+	end,
+}
\ No newline at end of file
diff --git a/game/modules/tome/data/talents/psionic/nightmare.lua b/game/modules/tome/data/talents/psionic/nightmare.lua
index 7f623786569db5a968aec6c14c1232435d3377c1..62212ba64cdd31cb698937aeec1b4741197f56a5 100644
--- a/game/modules/tome/data/talents/psionic/nightmare.lua
+++ b/game/modules/tome/data/talents/psionic/nightmare.lua
@@ -107,7 +107,7 @@ newTalent{
 
 		local m = target:clone{
 			shader = "shadow_simulacrum",
-			shader_args = { color = {0.6, 0.0, 0.3}, base = 0.3, time_factor = 2000 },
+			shader_args = { color = {0.6, 0.0, 0.3}, base = 0.6, time_factor = 1500 },
 			no_drops = true,
 			faction = self.faction,
 			summoner = self, summoner_gain_exp=true,
diff --git a/game/modules/tome/data/talents/psionic/psionic.lua b/game/modules/tome/data/talents/psionic/psionic.lua
index 2dc38987f803ead4f6101e1c319a7c2f0015845f..f9ea48e1aec025bd377c5e326c8f70818fa42ad2 100644
--- a/game/modules/tome/data/talents/psionic/psionic.lua
+++ b/game/modules/tome/data/talents/psionic/psionic.lua
@@ -34,10 +34,11 @@ newTalentType{ allow_random=true, type="psionic/psi-archery", name = "psi-archer
 newTalentType{ allow_random=true, type="psionic/greater-psi-fighting", name = "greater psi-fighting", description = "Elevate psi-fighting prowess to epic levels." }
 newTalentType{ allow_random=true, type="psionic/brainstorm", name = "brainstorm", description = "Focus your telekinetic powers in ways undreamed of by most mindslayers." }
 
--- Secret Project...
 -- Solipsist Talent Trees
 newTalentType{ allow_random=true, type="psionic/discharge", name = "discharge", description = "Project feedback on the world around you." }
 newTalentType{ allow_random=true, type="psionic/distortion", name = "distortion", description = "Distort reality with your mental energy." }
+newTalentType{ allow_random=true, type="psionic/dream-forge", name = "Dream Forge", description = "Master the dream forge to create powerful armor and effects." }
+newTalentType{ allow_random=true, type="psionic/dream-smith", name = "Dream Smith", description = "Call the dream-forge hammer to smite your foes." }
 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." }
@@ -261,6 +262,8 @@ load("/data/talents/psionic/grip.lua")
 -- Solipsist
 load("/data/talents/psionic/discharge.lua")
 load("/data/talents/psionic/distortion.lua")
+load("/data/talents/psionic/dream-forge.lua")
+load("/data/talents/psionic/dream-smith.lua")
 load("/data/talents/psionic/dreaming.lua")
 load("/data/talents/psionic/mentalism.lua")
 load("/data/talents/psionic/feedback.lua")
@@ -269,7 +272,7 @@ 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/trance.lua")
 
 
 load("/data/talents/psionic/possession.lua")
diff --git a/game/modules/tome/data/talents/psionic/solipsism.lua b/game/modules/tome/data/talents/psionic/solipsism.lua
index 19faccb98b4b0b9c4c3871065ce4b20365be80bd..ff332a191b32c270adfffa70b5b6af2503ab223c 100644
--- a/game/modules/tome/data/talents/psionic/solipsism.lua
+++ b/game/modules/tome/data/talents/psionic/solipsism.lua
@@ -56,7 +56,7 @@ newTalent{
 		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) by 50%% (one time only adjustment).
 		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. 
 		The first talent point invested will also increase the amount of Psi you gain from willpower by 1 but reduce the amount of life you gain from constitution by 0.5.
-		The first talent point also increases your solipsism threshold by 20%% (currently %d%%).]]):format(conversion_ratio * 100, conversion_ratio * 100, self.solipsism_threshold * 100)
+		The first talent point also increases your solipsism threshold by 20%% (currently %d%%), reducing your global speed by 1%% for each percentage your current Psi falls below this threshold.]]):format(conversion_ratio * 100, conversion_ratio * 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
index 24d8fdc0eaed1596394a9602b68ee1d7959e350c..6473a17d3c1d07335c9ffbfb1b62b6c7340936bb 100644
--- a/game/modules/tome/data/talents/psionic/thought-forms.lua
+++ b/game/modules/tome/data/talents/psionic/thought-forms.lua
@@ -103,6 +103,7 @@ newTalent{
 			max_life = resolvers.rngavg(100,110),
 			life_rating = 12,
 			combat_armor = 0, combat_def = 0,
+			stats = { mag=self:getMag(), wil=self:getWil(), cun=self:getCun()},
 			inc_stats = {
 				str = stat_bonus / 2,
 				dex = stat_bonus,
@@ -244,6 +245,7 @@ newTalent{
 			max_life = resolvers.rngavg(100,110),
 			life_rating = 15,
 			combat_armor = 0, combat_def = 0,
+			stats = { mag=self:getMag(), wil=self:getWil(), cun=self:getCun()},
 			inc_stats = {
 				str = stat_bonus,
 				dex = stat_bonus / 2,
@@ -384,6 +386,7 @@ newTalent{
 			max_life = resolvers.rngavg(100,110),
 			life_rating = 15,
 			combat_armor = 0, combat_def = 0,
+			stats = { mag=self:getMag(), wil=self:getWil(), cun=self:getCun()},
 			inc_stats = {
 				str = stat_bonus / 2,
 				dex = stat_bonus / 2,
@@ -478,7 +481,7 @@ newTalent{
 	info = function(self, t)
 		local bonus = t.getStatBonus(self, t)
 		local range = self:getTalentRange(t)
-		return([[Forge a guardian from your thoughts alone.  Your guardian's primary stat will be improved by %d and it's two secondary stats by %d.
+		return([[Forge a guardian from your thoughts alone.  Your guardian's primary stat will be improved by %d, it's two secondary stats by %d, and it will have magic, cunning, and willpower equal to your own.
 		At talent level one you may forge a mighty bowman clad in leather armor, at level three a powerful warrior wielding a two-handed weapon, and at level five a strong defender using a sword and shield.
 		Thought forms can only be maintained up to a range of %d and will rematerialize next to you if this range is exceeded.
 		Only one thought-form may be active at a time and the stat bonuses will improve with your mindpower.]]):format(bonus, bonus/2, range)
diff --git a/game/modules/tome/data/timed_effects/mental.lua b/game/modules/tome/data/timed_effects/mental.lua
index bceca9ef3b3f7bc8a6205e47036c418115605f1d..02b97478bf7f66ed0a5ec7522988fb022d8676d4 100644
--- a/game/modules/tome/data/timed_effects/mental.lua
+++ b/game/modules/tome/data/timed_effects/mental.lua
@@ -2640,8 +2640,8 @@ newEffect{
 	type = "mental",
 	subtype = { psionic=true },
 	status = "detrimental",
-	on_gain = function(self, err) return "#Target# mental functions have been impaired.", "+Sundered Mind" end,
-	on_lose = function(self, err) return "#Target#'s regains it's senses.", "-Sundered Mind" end,
+	on_gain = function(self, err) return "#Target#'s mental functions have been impaired.", "+Sundered Mind" end,
+	on_lose = function(self, err) return "#Target# regains it's senses.", "-Sundered Mind" end,
 	parameters = { power=10 },
 	on_merge = function(self, old_eff, new_eff)
 		self:removeTemporaryValue("combat_mentalresist", old_eff.sunder)
@@ -2658,4 +2658,69 @@ newEffect{
 	deactivate = function(self, eff)
 		self:removeTemporaryValue("combat_mentalresist", eff.sunder)
 	end,
+}
+
+newEffect{
+	name = "BROKEN_DREAM", image = "effects/broken_dream.png",
+	desc = "Broken Dream",
+	long_desc = function(self, eff) return ("The target's dreams have been broken by the dreamforge, reducing it's mental save by %d and reducing it's chance of successfully casting a spell by %d%%."):format(eff.power, eff.power) end,
+	type = "mental",
+	subtype = { psionic=true, morale=true },
+	status = "detrimental",
+	on_gain = function(self, err) return "#Target#'s dreams have been broken.", "+Broken Dream" end,
+	on_lose = function(self, err) return "#Target# regains hope.", "-Broken Dream" end,
+	parameters = { power=10 },
+	activate = function(self, eff)
+		eff.silence = self:addTemporaryValue("spell_failure", eff.power)
+		eff.sunder = self:addTemporaryValue("combat_mentalresist", -eff.power)
+	end,
+	deactivate = function(self, eff)
+		self:removeTemporaryValue("spell_failure", eff.silence)
+		self:removeTemporaryValue("combat_mentalresist", eff.sunder)
+	end,
+}
+
+newEffect{
+	name = "FORGE_SHIELD", image = "talents/block.png",
+	desc = "Forge Shield",
+	long_desc = function(self, eff)
+		local e_string = ""
+		if eff.number == 1 then
+			e_string = DamageType.dam_def[next(eff.d_types)].name
+		else
+			local list = table.keys(eff.d_types)
+			for i = 1, #list do
+				list[i] = DamageType.dam_def[list[i]].name
+			end
+			e_string = table.concat(list, ", ")
+		end
+		local function tchelper(first, rest)
+		  return first:upper()..rest:lower()
+		end
+		return ("Absorbs %d damage from the next blockable attack.  Currently Blocking: %s."):format(eff.power, e_string:gsub("(%a)([%w_']*)", tchelper))
+	end,
+	type = "mental",
+	subtype = { psionic=true },
+	status = "beneficial",
+	parameters = { power=1 },
+	on_gain = function(self, eff) return nil, nil end,
+	on_lose = function(self, eff) return nil, nil end,
+		damage_feedback = function(self, eff, src, value)
+		if eff.particle and eff.particle._shader and eff.particle._shader.shad and src and src.x and src.y then
+			local r = -rng.float(0.2, 0.4)
+			local a = math.atan2(src.y - self.y, src.x - self.x)
+			eff.particle._shader:setUniform("impact", {math.cos(a) * r, math.sin(a) * r})
+			eff.particle._shader:setUniform("impact_tick", core.game.getTime())
+		end
+	end,
+	activate = function(self, eff)
+		if core.shader.active() then
+			eff.particle = self:addParticles(Particles.new("shader_shield", 1, {img="shield2", size_factor=1}, {type="shield", time_factor=12000, color={1.0, 0.5, 0}}))
+		else
+			eff.particle = self:addParticles(Particles.new("time_shield_bubble", 1))
+		end
+	end,
+	deactivate = function(self, eff)
+		self:removeParticles(eff.particle)
+	end,
 }
\ No newline at end of file