diff --git a/game/modules/tome/class/Actor.lua b/game/modules/tome/class/Actor.lua
index 581b4412e6b49dfbacb35fc6ada34fd12457b5fd..8abb155c9948ddd9e28270eb00612dd4524cf378 100644
--- a/game/modules/tome/class/Actor.lua
+++ b/game/modules/tome/class/Actor.lua
@@ -165,6 +165,10 @@ function _M:act()
 		local t = self:getTalentFromId(self.T_THUNDERSTORM)
 		t.do_storm(self, t)
 	end
+	if self:isTalentActive(self.T_HYMN_OF_MOONLIGHT) then
+		local t = self:getTalentFromId(self.T_HYMN_OF_MOONLIGHT)
+		t.do_beams(self, t)
+	end
 
 	if self:attr("stunned") then self.energy.value = 0 end
 	if self:attr("dazed") then self.energy.value = 0 end
@@ -502,10 +506,12 @@ function _M:die(src)
 	if rng.percent(33) then self:bloodyDeath() end
 
 	-- Drop stuff
-	for inven_id, inven in pairs(self.inven) do
-		for i, o in ipairs(inven) do
-			if not o.no_drop then
-				game.level.map:addObject(self.x, self.y, o)
+	if not self.no_drops then
+		for inven_id, inven in pairs(self.inven) do
+			for i, o in ipairs(inven) do
+				if not o.no_drop then
+					game.level.map:addObject(self.x, self.y, o)
+				end
 			end
 		end
 	end
diff --git a/game/modules/tome/class/Game.lua b/game/modules/tome/class/Game.lua
index 92827ae2e7c03d72b3621bcfbb16940ac0552316..b04b82a773c7f0c691369efcc3102f88af662452 100644
--- a/game/modules/tome/class/Game.lua
+++ b/game/modules/tome/class/Game.lua
@@ -525,7 +525,8 @@ function _M:setupCommands()
 	self.key:addCommands{
 		[{"_d","ctrl"}] = function()
 			if config.settings.tome.cheat then
-				self:changeLevel(1, "wilderness-arda-fareast")
+--				self:changeLevel(1, "wilderness-arda-fareast")
+				game.level.map:particleEmitter(game.player.x,game.player.y, 1, "nova")
 			end
 		end,
 	}
diff --git a/game/modules/tome/class/Player.lua b/game/modules/tome/class/Player.lua
index 4794828b9c76c3d9bd3ec700975d88e2c363fbf8..785701684a33a32dc27ca3aa4e1a749e48078a71 100644
--- a/game/modules/tome/class/Player.lua
+++ b/game/modules/tome/class/Player.lua
@@ -162,6 +162,11 @@ function _M:playerFOV()
 		self:computeFOV(self.lite, "block_sight", function(x, y, dx, dy, sqdist) game.level.map:applyLite(x, y) end, true, true, true)
 	end
 
+	-- Handle Sense spell, a simple FOV, using cache. Note that this means some terrain features can be made to block sensing
+	if self:attr("infravision") then
+		self:computeFOV(self.infravision, "block_sight", function(x, y) if game.level.map(x, y, game.level.map.ACTOR) then game.level.map.seens(x, y, 1) end end, true, true, true)
+	end
+
 	-- Handle Sense spell, a simple FOV, using cache. Note that this means some terrain features can be made to block sensing
 	if self:attr("detect_range") then
 		self:computeFOV(self:attr("detect_range"), "block_sense", function(x, y)
diff --git a/game/modules/tome/data/birth/classes/divine.lua b/game/modules/tome/data/birth/classes/divine.lua
index fe1cd8d81350e9dbe0c168e9ac3e4dce393fcf4a..971566c4dbf5bf31c30ad38efbaf2cf50f397b37 100644
--- a/game/modules/tome/data/birth/classes/divine.lua
+++ b/game/modules/tome/data/birth/classes/divine.lua
@@ -30,6 +30,7 @@ newBirthDescriptor{
 		{
 			__ALL__ = "never",
 			['Sun Paladin'] = function() return profile.mod.allow_build.divine_sun_paladin and "allow" or "never" end,
+			Anorithil = function() return profile.mod.allow_build.divine_anorithil and "allow" or "never" end,
 		},
 	},
 	copy = {
@@ -75,3 +76,39 @@ newBirthDescriptor{
 		},
 	},
 }
+
+newBirthDescriptor{
+	type = "subclass",
+	name = "Anorithil",
+	desc = {
+		"Anorithils hail from the Gates of Morning, the last bastion of the free people in the Far East.",
+		"Their way of life is well represented by their motto 'We are Grey. We stand between the darkness and the light.'",
+		"They can channel the power of the Sun and the Moon to burn and tear apart all who seek to destroy the Sunwall.",
+		"Masters of sun and moon magic they usually burn their foes with sun rays before calling the fury of the stars.",
+		"Their most important stats are: Magic and Cunning",
+	},
+	stats = { mag=4, cun=2, },
+	talents_types = {
+		["cunning/survival"]={false, 0.1},
+		["divine/sun"]={true, 0.3},
+		["divine/chants"]={true, 0.3},
+		["divine/glyphs"]={true, 0.3},
+		["divine/light"]={false, 0.3},
+		["divine/twilight"]={true, 0.3},
+		["divine/hymns"]={true, 0.3},
+		["divine/star-fury"]={true, 0.3},
+	},
+	talents = {
+		[ActorTalents.T_SEARING_LIGHT] = 1,
+		[ActorTalents.T_MOONLIGHT_RAY] = 1,
+		[ActorTalents.T_HYMN_OF_SHADOWS] = 1,
+		[ActorTalents.T_TWILIGHT] = 1,
+	},
+	copy = {
+		max_life = 90,
+		resolvers.equip{ id=true,
+			{type="weapon", subtype="stagg", name="elm staff", autoreq=true},
+			{type="armor", subtype="cloth", name="robe", autoreq=true},
+		},
+	},
+}
diff --git a/game/modules/tome/data/damage_types.lua b/game/modules/tome/data/damage_types.lua
index 42d8a7e0c64fd1a6ff6241ba6bfbce9f20b220c2..77eefaed4b38fdc98d2a5923bab74db549d4e969 100644
--- a/game/modules/tome/data/damage_types.lua
+++ b/game/modules/tome/data/damage_types.lua
@@ -214,6 +214,23 @@ newDamageType{
 	end,
 }
 
+-- Darkness + Stun
+newDamageType{
+	name = "darkstun", type = "DARKSTUN",
+	projector = function(src, x, y, type, dam)
+		DamageType:get(DamageType.DARKNESS).projector(src, x, y, DamageType.DARKNESS, dam)
+		local target = game.level.map(x, y, Map.ACTOR)
+		if target then
+			-- Set on fire!
+			if target:checkHit(src:combatSpellpower(), target:combatPhysicalResist(), 0, 95, 15) and target:canBe("stun") then
+				target:setEffect(target.EFF_STUNNED, 4, {})
+			else
+				game.logSeen(target, "%s resists the darkness!", target.name:capitalize())
+			end
+		end
+	end,
+}
+
 -- Fire DOT + Stun
 newDamageType{
 	name = "flameshock", type = "FLAMESHOCK",
diff --git a/game/modules/tome/data/gfx/particles/damage_shield.lua b/game/modules/tome/data/gfx/particles/damage_shield.lua
index 232e560bdd8394e46a87fd8d9503ae045cb9ccd1..05e40dcade6e3e5e6666f0cab08e936c0209b675 100644
--- a/game/modules/tome/data/gfx/particles/damage_shield.lua
+++ b/game/modules/tome/data/gfx/particles/damage_shield.lua
@@ -29,8 +29,8 @@ return { generator = function()
 		life = 10,
 		size = 4, sizev = -0.1, sizea = 0,
 
-		x = r * math.cos(a), xv = -0.1, xa = 0,
-		y = r * math.sin(a), yv = -0.1, ya = 0,
+		x = r * math.cos(a), xv = 0, xa = 0,
+		y = r * math.sin(a), yv = 0, ya = 0,
 		dir = dir, dirv = dirv, dira = 0,
 		vel = 1, velv = 0, vela = 0,
 
diff --git a/game/modules/tome/data/gfx/particles/darkness_shield.lua b/game/modules/tome/data/gfx/particles/darkness_shield.lua
new file mode 100644
index 0000000000000000000000000000000000000000..bddd794d5546ae664ae3d66157d47d1cfc101bad
--- /dev/null
+++ b/game/modules/tome/data/gfx/particles/darkness_shield.lua
@@ -0,0 +1,47 @@
+-- ToME - Tales of Middle-Earth
+-- Copyright (C) 2009, 2010 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
+
+return { generator = function()
+	local ad = rng.range(0, 360)
+	local a = math.rad(ad)
+	local dir = math.rad(ad + 90)
+	local r = rng.range(12, 20)
+	local dirv = math.rad(1)
+	local col = rng.range(20, 80)/255
+
+	return {
+		trail = 1,
+		life = 10,
+		size = 4, sizev = 0.1, sizea = 0,
+
+		x = r * math.cos(a), xv = 0, xa = 0,
+		y = r * math.sin(a), yv = 0, ya = 0,
+		dir = dir, dirv = dirv, dira = 0,
+		vel = rng.percent(50) and -1 or 1, velv = 0, vela = 0,
+
+		r = col,  rv = 0, ra = 0,
+		g = col,  gv = 0, ga = 0,
+		b = col,  bv = 0, ba = 0,
+		a = rng.range(220, 255)/255,  av = 0, aa = 0,
+	}
+end, },
+function(self)
+	self.ps:emit(10)
+end,
+100
diff --git a/game/modules/tome/data/gfx/particles/displacement_shield.lua b/game/modules/tome/data/gfx/particles/displacement_shield.lua
index 3378903b3e27605f67dafe8914e70db6696a7712..c84f5ce6b0cdaf03981a453041e1e57c8f78932d 100644
--- a/game/modules/tome/data/gfx/particles/displacement_shield.lua
+++ b/game/modules/tome/data/gfx/particles/displacement_shield.lua
@@ -29,8 +29,8 @@ return { generator = function()
 		life = 10,
 		size = 4, sizev = -0.1, sizea = 0,
 
-		x = r * math.cos(a), xv = -0.1, xa = 0,
-		y = r * math.sin(a), yv = -0.1, ya = 0,
+		x = r * math.cos(a), xv = 0, xa = 0,
+		y = r * math.sin(a), yv = 0, ya = 0,
 		dir = dir, dirv = dirv, dira = 0,
 		vel = 1, velv = 0, vela = 0,
 
diff --git a/game/modules/tome/data/gfx/particles/disruption_shield.lua b/game/modules/tome/data/gfx/particles/disruption_shield.lua
index f4d7911c389e20b3555b834bf2f6d0e12363b4d1..6f3e9f7f55bee30295a7ea13e94c7ede4b2e2df4 100644
--- a/game/modules/tome/data/gfx/particles/disruption_shield.lua
+++ b/game/modules/tome/data/gfx/particles/disruption_shield.lua
@@ -28,8 +28,8 @@ return { generator = function()
 		life = 10,
 		size = 4, sizev = -0.1, sizea = 0,
 
-		x = r * math.cos(a), xv = 0.1, xa = 0,
-		y = r * math.sin(a), yv = 0.1, ya = 0,
+		x = r * math.cos(a), xv = 0, xa = 0,
+		y = r * math.sin(a), yv = 0, ya = 0,
 		dir = dir, dirv = 0.1, dira = 0,
 		vel = 1, velv = 0, vela = -0.2,
 
diff --git a/game/modules/tome/data/gfx/particles/golden_shield.lua b/game/modules/tome/data/gfx/particles/golden_shield.lua
index ede174c4607f646869d600064aefc1764b6c07fc..90126fa96bcebcaa83757c095b5d60a022ba2537 100644
--- a/game/modules/tome/data/gfx/particles/golden_shield.lua
+++ b/game/modules/tome/data/gfx/particles/golden_shield.lua
@@ -29,8 +29,8 @@ return { generator = function()
 		life = 10,
 		size = 4, sizev = -0.1, sizea = 0,
 
-		x = r * math.cos(a), xv = -0.1, xa = 0,
-		y = r * math.sin(a), yv = -0.1, ya = 0,
+		x = r * math.cos(a), xv = 0, xa = 0,
+		y = r * math.sin(a), yv = 0, ya = 0,
 		dir = dir, dirv = dirv, dira = 0,
 		vel = rng.percent(50) and -1 or 1, velv = 0, vela = 0,
 
diff --git a/game/modules/tome/data/gfx/particles/nova.lua b/game/modules/tome/data/gfx/particles/nova.lua
new file mode 100644
index 0000000000000000000000000000000000000000..0b4a44fd3fb859530811f58d745b3abb73977c49
--- /dev/null
+++ b/game/modules/tome/data/gfx/particles/nova.lua
@@ -0,0 +1,48 @@
+-- ToME - Tales of Middle-Earth
+-- Copyright (C) 2009, 2010 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 dur = 3
+
+return { generator = function()
+	local ad = rng.float(0, 360)
+	local a = math.rad(ad)
+
+	return {
+		life = 16,
+		size = 4, sizev = 0, sizea = 0,
+
+		x = 0, xv = 0, xa = 0,
+		y = 0, yv = 0, ya = 0,
+		dir = ad, dirv = 0, dira = 0,
+		vel = (5 + rng.float(0,1)) * dur, velv = 0, vela = 0,
+
+		r = rng.range(140, 200)/255, rv = 0, ra = 0,
+		g = rng.range(180, 220)/255, gv = 0, ga = 0,
+		b = rng.range(220, 240)/255, bv = 0, ba = 0,
+		a = rng.range(230, 255)/255, av = 0, aa = 0,
+	}
+end, },
+function(self)
+	self.nb = (self.nb or 0) + 1
+	if self.nb < 4 then
+		self.ps:emit(1000)
+	end
+end,
+5000,
+"particle_torus";
diff --git a/game/modules/tome/data/gfx/particles/shadow.lua b/game/modules/tome/data/gfx/particles/shadow.lua
new file mode 100644
index 0000000000000000000000000000000000000000..8dd17bcf1104415b2ce1cd8b30e87451ebf90d39
--- /dev/null
+++ b/game/modules/tome/data/gfx/particles/shadow.lua
@@ -0,0 +1,49 @@
+-- ToME - Tales of Middle-Earth
+-- Copyright (C) 2009, 2010 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
+
+return { generator = function()
+	local ad = rng.range(0, 360)
+	local a = math.rad(ad)
+	local dir = math.rad(ad + 180)
+	local r = rng.range(12, 20)
+	local col = rng.range(20, 80)/255
+
+	return {
+		trail = 1,
+		life = 10,
+		size = 4, sizev = 0.08, sizea = 0,
+
+		x = r * math.cos(a), xv = 0, xa = 0,
+		y = r * math.sin(a), yv = 0, ya = 0,
+		dir = dir, dirv = math.rad(3), dira = math.rad(3) / 3,
+		vel = 1.4, velv = 0, vela = 0,
+
+		r = col,  rv = 0, ra = 0,
+		g = col,  gv = 0, ga = 0,
+		b = col,  bv = 0, ba = 0,
+		a = rng.range(220, 255)/255,  av = 0, aa = 0,
+	}
+end, },
+function(self)
+	self.nb = (self.nb or 0) + 1
+	if self.nb < 4 then
+		self.ps:emit(20)
+	end
+end,
+800
diff --git a/game/modules/tome/data/gfx/particles/shadow_beam.lua b/game/modules/tome/data/gfx/particles/shadow_beam.lua
new file mode 100644
index 0000000000000000000000000000000000000000..aa9cd9c8dad6fdfb5d824c964bce456172d01bf0
--- /dev/null
+++ b/game/modules/tome/data/gfx/particles/shadow_beam.lua
@@ -0,0 +1,59 @@
+-- ToME - Tales of Middle-Earth
+-- Copyright (C) 2009, 2010 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
+
+-- Make the ray
+local ray = {}
+local tiles = math.ceil(math.sqrt(tx*tx+ty*ty))
+local tx = tx * engine.Map.tile_w
+local ty = ty * engine.Map.tile_h
+local breakdir = math.rad(rng.range(-8, 8))
+ray.dir = math.atan2(ty, tx)
+ray.size = math.sqrt(tx*tx+ty*ty)
+
+-- Populate the beam based on the forks
+return { generator = function()
+	local a = ray.dir
+	local rad = rng.range(-3,3)
+	local ra = math.rad(rad)
+	local r = rng.range(1, ray.size)
+	local col = rng.range(20, 80)/255
+
+	return {
+		life = 14,
+		size = rng.range(4, 6), sizev = -0.1, sizea = 0,
+
+		x = r * math.cos(a) + 2 * math.cos(ra), xv = 0, xa = 0,
+		y = r * math.sin(a) + 2 * math.sin(ra), yv = 0, ya = 0,
+		dir = rng.percent(50) and ray.dir + math.rad(rng.range(50, 130)) or ray.dir - math.rad(rng.range(50, 130)), dirv = 0, dira = 0,
+		vel = rng.percent(30) and 1 or 0, velv = -0.1, vela = 0.01,
+
+		r = col,  rv = 0, ra = 0,
+		g = col,  gv = 0, ga = 0,
+		b = col,  bv = 0, ba = 0,
+		a = rng.range(220, 255)/255,  av = 0, aa = 0,
+	}
+end, },
+function(self)
+	self.nb = (self.nb or 0) + 1
+	if self.nb < 6 then
+		self.ps:emit(30*tiles)
+	end
+end,
+14*30*tiles,
+"particle_torus"
diff --git a/game/modules/tome/data/gfx/particles/shadow_flash.lua b/game/modules/tome/data/gfx/particles/shadow_flash.lua
new file mode 100644
index 0000000000000000000000000000000000000000..aac2b5620ef90ccff3dca313e8438c36f5066950
--- /dev/null
+++ b/game/modules/tome/data/gfx/particles/shadow_flash.lua
@@ -0,0 +1,132 @@
+-- ToME - Tales of Middle-Earth
+-- Copyright (C) 2009, 2010 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
+
+-- Make up the grids list
+local gs = {}
+
+-- Compute the clipping circle
+local sradius = (radius + 0.5) * (engine.Map.tile_w + engine.Map.tile_h) / 2
+for i = -radius, radius do for j = -radius, radius  do
+	local lastx, lasty = 0, 0
+	local l = line.new(0, 0, i, j)
+	local lx, ly = l()
+	while lx do
+		if grids[lx+tx] and grids[lx+tx][ly+ty] then
+			lastx, lasty = lx, ly
+		else
+			gs[lx] = gs[lx] or {}
+			gs[lx][ly] = {x=lastx, y=lasty, radius=math.sqrt(lastx^2 + lasty^2)}
+--			print("block", lx, ly, "=>", math.sqrt(lastx^2 + lasty^2))
+		end
+		lx, ly = l()
+	end
+end end
+
+local nb = 0
+return { generator = function()
+	local radius = radius
+	local sradius = (radius + 0.5) * (engine.Map.tile_w + engine.Map.tile_h) / 2
+	local ad = rng.float(0, 360)
+	local a = math.rad(ad)
+	local r = rng.float(sradius - 5, sradius)
+	local x = r * math.cos(a)
+	local y = r * math.sin(a)
+	local bx = math.floor(x / engine.Map.tile_w)
+	local by = math.floor(y / engine.Map.tile_h)
+	if gs[bx] and gs[bx][by] and rng.chance(2) then
+--		print("block at angle", ad, radius, ":=>", gs[bx][by].radius)
+		radius = gs[bx][by].radius
+		sradius = (radius + 0.5) * (engine.Map.tile_w + engine.Map.tile_h) / 2
+		local r = rng.float(sradius - 5, sradius)
+		x = r * math.cos(a)
+		y = r * math.sin(a)
+	end
+	local static = rng.percent(40)
+	local col = rng.range(20, 80)/255
+
+	return {
+		trail = 1,
+		life = 24,
+		size = 3, sizev = static and 0.05 or 0.15, sizea = 0,
+
+		x = x, xv = 0, xa = 0,
+		y = y, yv = 0, ya = 0,
+		dir = static and a + math.rad(90 - rng.range(10, 20)) or a, dirv = 0, dira = 0,
+		vel = static and -2 or 0.5 * (-1-nb) * radius / 2.7, velv = 0, vela = static and -0.01 or rng.float(-0.3, -0.2) * 0.3,
+
+		r = col,  rv = 0, ra = 0,
+		g = col,  gv = 0, ga = 0,
+		b = col,  bv = 0, ba = 0,
+		a = rng.range(220, 255)/255,  av = 0, aa = 0,
+	}
+end, },
+function(self)
+	if nb < 5 then
+		self.ps:emit(radius*266)
+		nb = nb + 1
+		self.ps:emit(radius*266)
+		nb = nb + 1
+		self.ps:emit(radius*266)
+		nb = nb + 1
+		self.ps:emit(radius*266)
+		nb = nb + 1
+		self.ps:emit(radius*266)
+		nb = nb + 1
+	end
+end,
+5*radius*266
+
+--[[
+local nb = 0
+return { generator = function()
+	local ad = rng.range(0, 360)
+	local a = math.rad(ad)
+	local r = rng.range(2, sradius)
+	local boundx = r * math.cos(a)
+	local boundy = r * math.sin(a)
+	local x = math.floor(boundx / engine.Map.tile_w) + tx
+	local y = math.floor(boundy / engine.Map.tile_h) + ty
+	if not grids[x] or not grids[x][y] then return end
+
+	return {
+		trail = 1,
+		life = 12,
+		size = 3, sizev = 0.3, sizea = 0,
+
+		x = boundx, xv = 0, xa = 0,
+		y = boundy, yv = 0, ya = 0,
+--		x = r * math.cos(a), xv = -0.1, xa = 0,
+--		y = r * math.sin(a), yv = -0.1, ya = 0,
+		dir = a + 5 * math.rad(rng.range(10, 20)), dirv = math.rad(rng.range(10, 20)), dira = -math.rad(2),
+		vel = 1, velv = 0, vela = 0.1,
+
+		r = rng.range(200, 255)/255,   rv = 0, ra = 0,
+		g = rng.range(120, 170)/255,   gv = 0, ga = 0,
+		b = rng.range(0, 10)/255,      bv = 0, ba = 0,
+		a = rng.range(25, 220)/255,    av = 0, aa = 0,
+	}
+end, },
+function(self)
+	if nb < 2 then
+		self.ps:emit(800)
+		nb = nb + 1
+	end
+end,
+5000
+]]
\ No newline at end of file
diff --git a/game/modules/tome/data/gfx/particles/shadow_zone.lua b/game/modules/tome/data/gfx/particles/shadow_zone.lua
new file mode 100644
index 0000000000000000000000000000000000000000..42707c1f928d794b5e742c1afc9b24d2f92b1b75
--- /dev/null
+++ b/game/modules/tome/data/gfx/particles/shadow_zone.lua
@@ -0,0 +1,47 @@
+-- ToME - Tales of Middle-Earth
+-- Copyright (C) 2009, 2010 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
+
+return { generator = function()
+	local ad = rng.range(0, 360)
+	local a = math.rad(ad)
+	local dir = math.rad(ad + 90)
+	local r = rng.range(1, 20)
+	local dirv = math.rad(1)
+	local col = rng.range(20, 80)/255
+
+	return {
+--		trail = 1,
+		life = 10,
+		size = 4, sizev = -0.1, sizea = 0,
+
+		x = r * math.cos(a), xv = rng.float(-0.4, 0.4), xa = 0,
+		y = r * math.sin(a), yv = rng.float(-0.4, 0.4), ya = 0,
+		dir = dir, dirv = dirv, dira = dir / 20,
+		vel = 1, velv = 0, vela = 0.1,
+
+		r = col,  rv = 0, ra = 0,
+		g = col,  gv = 0, ga = 0,
+		b = col,  bv = 0, ba = 0,
+		a = rng.range(220, 255)/255,  av = 0, aa = 0,
+	}
+end, },
+function(self)
+	self.ps:emit(4)
+end,
+40
diff --git a/game/modules/tome/data/gfx/particles/shield.lua b/game/modules/tome/data/gfx/particles/shield.lua
index 1e7996a69944d2beba9e65096b58a7a6d2fe6e8d..505f80e47d1bf1a22b5ae3c4de9e74ff932109de 100644
--- a/game/modules/tome/data/gfx/particles/shield.lua
+++ b/game/modules/tome/data/gfx/particles/shield.lua
@@ -28,8 +28,8 @@ return { generator = function()
 		life = 10,
 		size = 4, sizev = -0.1, sizea = 0,
 
-		x = r * math.cos(a), xv = 0.1, xa = 0,
-		y = r * math.sin(a), yv = 0.1, ya = 0,
+		x = r * math.cos(a), xv = 0, xa = 0,
+		y = r * math.sin(a), yv = 0, ya = 0,
 		dir = dir, dirv = 1, dira = 0,
 		vel = 1, velv = 0, vela = 0,
 
diff --git a/game/modules/tome/data/gfx/particles/time_shield.lua b/game/modules/tome/data/gfx/particles/time_shield.lua
index 2609b676094efa89a73fda1734a95274ab0a4e32..5ca8718f0571154acb8c540bc95a80ab62956ceb 100644
--- a/game/modules/tome/data/gfx/particles/time_shield.lua
+++ b/game/modules/tome/data/gfx/particles/time_shield.lua
@@ -29,8 +29,8 @@ return { generator = function()
 		life = 10,
 		size = 4, sizev = -0.1, sizea = 0,
 
-		x = r * math.cos(a), xv = -0.1, xa = 0,
-		y = r * math.sin(a), yv = -0.1, ya = 0,
+		x = r * math.cos(a), xv = 0, xa = 0,
+		y = r * math.sin(a), yv = 0, ya = 0,
 		dir = dir, dirv = dirv, dira = 0,
 		vel = 1, velv = 0, vela = 0,
 
diff --git a/game/modules/tome/data/gfx/shaders/water.frag b/game/modules/tome/data/gfx/shaders/water.frag
index 696502708bd9daeaa303b7424e12c351c9fd0c3a..f36341000014ffe070a831bcf1710b652b69c535 100644
--- a/game/modules/tome/data/gfx/shaders/water.frag
+++ b/game/modules/tome/data/gfx/shaders/water.frag
@@ -1,19 +1,19 @@
 uniform float tick;
 uniform sampler3D noisevol;
 uniform vec2 mapCoord;
-uniform sampler2D tex;
-uniform int mapx;
-uniform int mapy;
+uniform vec4 color1;
+uniform vec4 color2;
 
 void main(void)
 {
 	float fTime0_X = tick / 10000;
 	vec2 coord = mapCoord+gl_TexCoord[0].xy;
-	float noisy = texture3D(noisevol,vec3(coord*0.11,fTime0_X)).r;
-	float noisy2 = texture3D(noisevol,vec3(coord*0.47,fTime0_X)).r;
-	float noisy3 = texture3D(noisevol,vec3(coord*0.67,fTime0_X)).r;
+	float noisy = texture3D(noisevol,vec3(coord,fTime0_X)).r;
+	float noisy2 = texture3D(noisevol,vec3(coord/5.0,fTime0_X)).r;
+	float noisy3 = texture3D(noisevol,vec3(coord/7.0,fTime0_X)).r;
 	float noise = (noisy+noisy2+noisy3)/3.0;
 
-	float bump = abs((1.0 * noise)-1.3);
-	gl_FragColor = mix(gl_Color, texture2D(tex, gl_TexCoord[0].xy), bump);
+	float bump = 1.0-abs((2.0 * noise)-1.0);
+	bump *= bump - 0.3;
+	gl_FragColor = mix(color1, color2, bump);
 }
diff --git a/game/modules/tome/data/gfx/shaders/water.lua b/game/modules/tome/data/gfx/shaders/water.lua
index 4df1677f27cd432408a9a44a9981d3a899b901c5..7e2c2cea2d687e8ba99f4ec4c2d718a1251b88af 100644
--- a/game/modules/tome/data/gfx/shaders/water.lua
+++ b/game/modules/tome/data/gfx/shaders/water.lua
@@ -22,6 +22,8 @@ return {
 	vert = nil,
 	args = {
 		noisevol = { texture = 1 },
+		color1 = {0,0,1,1},
+		color2 = {0,0.6,0.8,1},
 	},
 	clone = false,
 }
diff --git a/game/modules/tome/data/maps/wilderness/arda-west.lua b/game/modules/tome/data/maps/wilderness/arda-west.lua
index 90ccf35057bb41f5e1b9c3969ae828409176e4d4..6e8251b822d9c0e84270498cc6820837550bda96 100644
--- a/game/modules/tome/data/maps/wilderness/arda-west.lua
+++ b/game/modules/tome/data/maps/wilderness/arda-west.lua
@@ -29,7 +29,11 @@ quickEntity('t', {show_tooltip=true, name='forest', display='#', color=colors.LI
 quickEntity('l', {show_tooltip=true, name='Lorien', display='#', color=colors.GOLD, back_color=colors.DARK_GREEN, image="terrain/lorien.png", block_move=true})
 quickEntity('v', {show_tooltip=true, name='old forest', display='#', color=colors.GREEN, back_color=colors.DARK_GREEN, image="terrain/tree_dark1.png", block_move=true})
 quickEntity('i', {show_tooltip=true, name='iron mountains', display='^', color=colors.SLATE, back_color=colors.UMBER, image="terrain/mountain.png", block_move=true})
-quickEntity('=', {show_tooltip=true, name='the great sea', display='~', color=colors.DARK_BLUE, back_color=colors.BLUE, image="terrain/river.png", block_move=true, }) -- shader = "water", textures = { function() return core.noise.new(3):makeTexture3D("simplex", 128, 128, 128, 4, 0, 0, 0), true end },
+
+quickEntity('=', {show_tooltip=true, name='the great sea', display='~', color=colors.DARK_BLUE, back_color=colors.BLUE, image="terrain/river.png", block_move=true,
+})
+--shader = "water", textures = { function() return core.noise.new(3):makeTexture3D("simplex", 128, 128, 128, 1, 0, 0, 0), true end }})
+
 quickEntity('.', {show_tooltip=true, name='plains', display='.', color=colors.LIGHT_GREEN, back_color=colors.DARK_GREEN, image="terrain/grass.png", can_encounter=true, equilibrium_level=-10})
 quickEntity('g', {show_tooltip=true, name='Forodwaith, the cold lands', display='.', color=colors.LIGHT_BLUE, back_color=colors.BLUE, can_encounter=true, equilibrium_level=-10})
 quickEntity('q', {show_tooltip=true, name='Icebay of Forochel', display=';', color=colors.LIGHT_BLUE, back_color=colors.BLUE, can_encounter=true, equilibrium_level=-10})
diff --git a/game/modules/tome/data/talents/divine/chants.lua b/game/modules/tome/data/talents/divine/chants.lua
index 743ae57b7be51bb955797b0e2253638428a3d035..9f44f6563467af5ad9cf71805eb4c5bb5eac1f7f 100644
--- a/game/modules/tome/data/talents/divine/chants.lua
+++ b/game/modules/tome/data/talents/divine/chants.lua
@@ -63,7 +63,7 @@ newTalent{
 	end,
 	info = function(self, t)
 		return ([[Chant the glory of the sun, granting you %d physical and spell resistance.
-		In addition it surrounds you with a shield of light, damaging anythnig that attacks you for %0.2f light damage.
+		In addition it surrounds you with a shield of light, damaging anything that attacks you for %0.2f light damage.
 		You may only have one Chant active at once.
 		The resistance and damage will increase with the Magic stat]]):format(5 + self:getTalentLevel(t) * self:combatSpellpower(0.12), 5 + self:getTalentLevel(t) * self:combatSpellpower(0.07))
 	end,
@@ -101,7 +101,7 @@ newTalent{
 	end,
 	info = function(self, t)
 		return ([[Chant the glory of the sun, granting you %d%% physical damage resistance.
-		In addition it surrounds you with a shield of light, damaging anythnig that attacks you for %0.2f light damage.
+		In addition it surrounds you with a shield of light, damaging anything that attacks you for %0.2f light damage.
 		You may only have one Chant active at once.
 		The resistance and damage will increase with the Magic stat]]):format(5 + self:getTalentLevel(t) * self:combatSpellpower(0.08), 5 + self:getTalentLevel(t) * self:combatSpellpower(0.07))
 	end,
@@ -144,7 +144,7 @@ newTalent{
 	end,
 	info = function(self, t)
 		return ([[Chant the glory of the sun, granting you %d%% elemental resistances.
-		In addition it surrounds you with a shield of light, damaging anythnig that attacks you for %0.2f light damage.
+		In addition it surrounds you with a shield of light, damaging anything that attacks you for %0.2f light damage.
 		You may only have one Chant active at once.
 		The resistance and damage will increase with the Magic stat]]):format(5 + self:getTalentLevel(t) * self:combatSpellpower(0.08), 5 + self:getTalentLevel(t) * self:combatSpellpower(0.07))
 	end,
@@ -182,7 +182,7 @@ newTalent{
 	end,
 	info = function(self, t)
 		return ([[Chant the glory of the sun, granting you %d%% more light damage.
-		In addition it surrounds you with a shield of light, damaging anythnig that attacks you for %0.2f light damage.
+		In addition it surrounds you with a shield of light, damaging anything that attacks you for %0.2f light damage.
 		You may only have one Chant active at once.
 		The damage will increase with the Magic stat]]):format(10 + self:getTalentLevel(t) * self:combatSpellpower(0.10), 5 + self:getTalentLevel(t) * self:combatSpellpower(0.07))
 	end,
diff --git a/game/modules/tome/data/talents/divine/divine.lua b/game/modules/tome/data/talents/divine/divine.lua
index cf9a930b8b883fd1855d19f902da3ac0af4d6fe8..750735b57fdf44dcdb57e5b6a579c6867460c59e 100644
--- a/game/modules/tome/data/talents/divine/divine.lua
+++ b/game/modules/tome/data/talents/divine/divine.lua
@@ -24,6 +24,12 @@ newTalentType{ type="divine/combat", name = "combat", description = "Your devoti
 newTalentType{ type="divine/sun", name = "sun", description = "Summon the power of the Sun to burn your foes." }
 newTalentType{ type="divine/glyphs", name = "glyphs", description = "Bind the holy powers into glyphs to trap your foes." }
 
+newTalentType{ type="divine/twilight", name = "twilight", description = "Stand between the darkness and the light, harnessing both." }
+newTalentType{ type="divine/star-fury", name = "star fury", description = "Call fury of the stars and moon to destroy your foes." }
+newTalentType{ type="divine/hymns", name = "hymns", description = "Chant the glory of the moon." }
+
+newTalentType{ type="divine/other", name = "other", description = "Various divine talents." }
+
 -- Generic requires for corruptions based on talent level
 divi_req1 = {
 	stat = { mag=function(level) return 12 + (level-1) * 2 end },
@@ -50,3 +56,7 @@ load("/data/talents/divine/chants.lua")
 load("/data/talents/divine/sun.lua")
 load("/data/talents/divine/combat.lua")
 load("/data/talents/divine/light.lua")
+
+load("/data/talents/divine/twilight.lua")
+load("/data/talents/divine/hymns.lua")
+load("/data/talents/divine/star-fury.lua")
diff --git a/game/modules/tome/data/talents/divine/hymns.lua b/game/modules/tome/data/talents/divine/hymns.lua
new file mode 100644
index 0000000000000000000000000000000000000000..99b6e6f27fbafacfc057954a0e542dc5bc702b69
--- /dev/null
+++ b/game/modules/tome/data/talents/divine/hymns.lua
@@ -0,0 +1,207 @@
+-- ToME - Tales of Middle-Earth
+-- Copyright (C) 2009, 2010 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 function cancelHymns(self)
+	local hymns = {self.T_HYMN_OF_SHADOW, self.T_HYMN_OF_DETECTION, self.T_HYMN_OF_PERSEVERANCE, self.T_HYMN_OF_MOONLIGHT}
+	for i, t in ipairs(hymns) do
+		if self:isTalentActive(t) then
+			local old = self.energy.value
+			self.energy.value = 100000
+			self:useTalent(t)
+			self.energy.value = old
+		end
+	end
+end
+
+newTalent{
+	name = "Hymn of Shadows",
+	type = {"divine/hymns", 1},
+	mode = "sustained",
+	require = divi_req1,
+	points = 5,
+	cooldown = 30,
+	sustain_negative = 20,
+	tactical = {
+		BUFF = 10,
+	},
+	range = 20,
+	activate = function(self, t)
+		cancelHymns(self)
+		local power = 10 + self:getTalentLevel(t) * self:combatSpellpower(0.10)
+		local dam = 5 + self:getTalentLevel(t) * self:combatSpellpower(0.07)
+		game:playSoundNear(self, "talents/spell_generic2")
+		local ret = {
+			onhit = self:addTemporaryValue("on_melee_hit", {[DamageType.DARKNESS]=dam}),
+			phys = self:addTemporaryValue("inc_damage", {[DamageType.DARKNESS] = power}),
+			particle = self:addParticles(Particles.new("darkness_shield", 1))
+		}
+		return ret
+	end,
+	deactivate = function(self, t, p)
+		self:removeParticles(p.particle)
+		self:removeTemporaryValue("on_melee_hit", p.onhit)
+		self:removeTemporaryValue("inc_damage", p.phys)
+		return true
+	end,
+	info = function(self, t)
+		return ([[Chant the glory of the moon, granting you %d%% more darkness damage.
+		In addition it surrounds you with a shield of shadows, damaging anything that attacks you for %0.2f darkness damage.
+		You may only have one Hymn active at once.
+		The damage will increase with the Magic stat]]):format(10 + self:getTalentLevel(t) * self:combatSpellpower(0.10), 5 + self:getTalentLevel(t) * self:combatSpellpower(0.07))
+	end,
+}
+
+newTalent{
+	name = "Hymn of Detection",
+	type = {"divine/hymns", 2},
+	mode = "sustained",
+	require = divi_req2,
+	points = 5,
+	cooldown = 30,
+	sustain_negative = 20,
+	tactical = {
+		BUFF = 10,
+	},
+	range = 20,
+	activate = function(self, t)
+		cancelHymns(self)
+		game:playSoundNear(self, "talents/spell_generic2")
+		local ret = {
+			infravision = self:addTemporaryValue("infravision", math.floor(5 + self:getTalentLevel(t))),
+			particle = self:addParticles(Particles.new("darkness_shield", 1))
+		}
+		return ret
+	end,
+	deactivate = function(self, t, p)
+		self:removeParticles(p.particle)
+		self:removeTemporaryValue("infravision", p.infravision)
+		return true
+	end,
+	info = function(self, t)
+		return ([[Chant the glory of the moon, granting you infravision up to %d grids.
+		In addition it surrounds you with a shield of darkness, damaging anything that attacks you for %0.2f light damage.
+		You may only have one Hymn active at once.
+		The resistance and damage will increase with the Magic stat]]):format(math.floor(5 + self:getTalentLevel(t)), 5 + self:getTalentLevel(t) * self:combatSpellpower(0.07))
+	end,
+}
+
+newTalent{
+	name = "Hymn of Perseverance",
+	type = {"divine/hymns",3},
+	mode = "sustained",
+	require = divi_req3,
+	points = 5,
+	cooldown = 30,
+	sustain_negative = 20,
+	tactical = {
+		BUFF = 10,
+	},
+	range = 20,
+	activate = function(self, t)
+		cancelHymns(self)
+		local power = 5 + self:getTalentLevel(t) * self:combatSpellpower(0.08)
+		local dam = 5 + self:getTalentLevel(t) * self:combatSpellpower(0.07)
+		game:playSoundNear(self, "talents/spell_generic2")
+		local ret = {
+			onhit = self:addTemporaryValue("on_melee_hit", {[DamageType.DARKNESS]=dam}),
+			stun = self:addTemporaryValue("stun_immune", 0.2 + self:getTalentLevel(t) / 10),
+			confusion = self:addTemporaryValue("confusion_immune", 0.2 + self:getTalentLevel(t) / 10),
+			blind = self:addTemporaryValue("blind_immune", 0.2 + self:getTalentLevel(t) / 10),
+			particle = self:addParticles(Particles.new("darkness_shield", 1))
+		}
+		return ret
+	end,
+	deactivate = function(self, t, p)
+		self:removeParticles(p.particle)
+		self:removeTemporaryValue("on_melee_hit", p.onhit)
+		self:removeTemporaryValue("stun_immune", p.stun)
+		self:removeTemporaryValue("confusion_immune", p.confusion)
+		self:removeTemporaryValue("blind_immune", p.blind)
+		return true
+	end,
+	info = function(self, t)
+		return ([[Chant the glory of the moon, granting you %d%% stun, blindness and confusion resistances.
+		In addition it surrounds you with a shield of darkness, damaging anything that attacks you for %0.2f light damage.
+		You may only have one Hymn active at once.
+		The damage will increase with the Magic stat]]):format(100 * (0.2 + self:getTalentLevel(t) / 10), 5 + self:getTalentLevel(t) * self:combatSpellpower(0.07))
+	end,
+}
+
+newTalent{
+	name = "Hymn of Moonlight",
+	type = {"divine/hymns",4},
+	mode = "sustained",
+	require = divi_req4,
+	points = 5,
+	cooldown = 30,
+	sustain_negative = 20,
+	tactical = {
+		BUFF = 10,
+	},
+	range = 20,
+	do_beams = function(self, t)
+		if self:getNegative() <= 0 then
+			local old = self.energy.value
+			self.energy.value = 100000
+			self:useTalent(self.T_HYMN_OF_MOONLIGHT)
+			self.energy.value = old
+			return
+		end
+
+		local tgts = {}
+		local grids = core.fov.circle_grids(self.x, self.y, 5, true)
+		for x, yy in pairs(grids) do for y, _ in pairs(grids[x]) do
+			local a = game.level.map(x, y, Map.ACTOR)
+			if a and self:reactionToward(a) < 0 then
+				tgts[#tgts+1] = a
+			end
+		end end
+
+		-- Randomly take targets
+		local tg = {type="hit", range=self:getTalentRange(t), talent=t}
+		for i = 1, math.floor(self:getTalentLevel(t)) do
+			if #tgts <= 0 then break end
+			local a, id = rng.table(tgts)
+			table.remove(tgts, id)
+
+			self:project(tg, a.x, a.y, DamageType.DARKNESS, rng.avg(1, self:spellCrit(20 + self:combatSpellpower(0.2) * self:getTalentLevel(t)), 3))
+			game.level.map:particleEmitter(self.x, self.y, math.max(math.abs(a.x-self.x), math.abs(a.y-self.y)), "shadow_beam", {tx=a.x-self.x, ty=a.y-self.y})
+			game:playSoundNear(self, "talents/spell_generic")
+		end
+	end,
+	activate = function(self, t)
+		cancelHymns(self)
+		game:playSoundNear(self, "talents/spell_generic")
+		game.logSeen(self, "#DARK_GREY#A shroud of shadow dances around %s!", self.name)
+		return {
+			drain = self:addTemporaryValue("negative_regen", -1 * self:getTalentLevelRaw(t)),
+		}
+	end,
+	deactivate = function(self, t, p)
+		game.logSeen(self, "#DARK_GREY#The shroud of shadows around %s disappears.", self.name)
+		self:removeTemporaryValue("negative_regen", p.drain)
+		return true
+	end,
+	info = function(self, t)
+		return ([[Conjures a shroud of dancing shadows with a radius of 5 that follows you as long as this spell is active.
+		Each turn a random shadow beam will hit up to %d of your foes for 1 to %0.2f damage.
+		This powerful spell will continuously drain negative energy while active.
+		The damage will increase with the Magic stat]]):format(self:getTalentLevel(t), 20 + self:combatSpellpower(0.2) * self:getTalentLevel(t))
+	end,
+}
diff --git a/game/modules/tome/data/talents/divine/star-fury.lua b/game/modules/tome/data/talents/divine/star-fury.lua
new file mode 100644
index 0000000000000000000000000000000000000000..934e03965494514569163bf82c4bbf99f8c2628e
--- /dev/null
+++ b/game/modules/tome/data/talents/divine/star-fury.lua
@@ -0,0 +1,153 @@
+-- ToME - Tales of Middle-Earth
+-- Copyright (C) 2009, 2010 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
+
+newTalent{
+	name = "Moonlight Ray",
+	type = {"divine/star-fury", 1},
+	require = divi_req1,
+	points = 5,
+	cooldown = 3,
+	negative = 10,
+	tactical = {
+		ATTACK = 10,
+	},
+	range = 20,
+	reflectable = true,
+	action = function(self, t)
+		local tg = {type="beam", range=self:getTalentRange(t), talent=t}
+		local x, y = self:getTarget(tg)
+		if not x or not y then return nil end
+		self:project(tg, x, y, DamageType.DARKNESS, self:spellCrit(14 + self:combatSpellpower(0.5) * self:getTalentLevel(t)))
+		local _ _, x, y = self:canProject(tg, x, y)
+		game.level.map:particleEmitter(self.x, self.y, math.max(math.abs(x-self.x), math.abs(y-self.y)), "shadow_beam", {tx=x-self.x, ty=y-self.y})
+		game:playSoundNear(self, "talents/flame")
+		return true
+	end,
+	info = function(self, t)
+		return ([[Calls the power of the Moon into a beam of shadows doing %0.2f damage.
+		The damage will increase with the Magic stat]]):format(14 + self:combatSpellpower(0.5) * self:getTalentLevel(t))
+	end,
+}
+
+newTalent{
+	name = "Shadow Blast",
+	type = {"divine/star-fury", 2},
+	require = divi_req2,
+	points = 5,
+	cooldown = 10,
+	negative = 15,
+	tactical = {
+		ATTACK = 10,
+	},
+	range = 6,
+	action = function(self, t)
+		local duration = self:getTalentLevel(t) + 2
+		local radius = 3
+		local dam = 4 + self:combatSpellpower(0.12) * self:getTalentLevel(t)
+		local tg = {type="ball", range=self:getTalentRange(t), radius=radius, friendlyfire=self:spellFriendlyFire()}
+		local x, y = self:getTarget(tg)
+		if not x or not y then return nil end
+		local _ _, x, y = self:canProject(tg, x, y)
+		local grids = self:project(tg, x, y, DamageType.DARKNESS, self:spellCrit(5 + self:combatSpellpower(0.22) * self:getTalentLevel(t)), {type="shadow"})
+		-- Add a lasting map effect
+		game.level.map:addEffect(self,
+			x, y, duration,
+			DamageType.DARKNESS, dam,
+			radius,
+			5, nil,
+			{type="shadow_zone"},
+			nil, self:spellFriendlyFire()
+		)
+
+		game.level.map:particleEmitter(x, y, tg.radius, "shadow_flash", {radius=tg.radius, grids=grids, tx=x, ty=y})
+
+		game:playSoundNear(self, "talents/cloud")
+		return true
+	end,
+	info = function(self, t)
+		return ([[Invokes a blast of shadows dealing %0.2f darkness damage and leaving a field that does %0.2f darkness damage per turn for %d turns..
+		The damage will increase with the Magic stat]]):
+		format(
+			5 + self:combatSpellpower(0.22) * self:getTalentLevel(t),
+			4 + self:combatSpellpower(0.12) * self:getTalentLevel(t),
+			self:getTalentLevel(t) + 2
+		)
+	end,
+}
+
+newTalent{
+	name = "Twilight Surge",
+	type = {"divine/star-fury",3},
+	require = divi_req3,
+	points = 5,
+	cooldown = 7,
+	negative = -20,
+	positive = -10,
+	tactical = {
+		ATTACK = 10,
+	},
+	range = 2,
+	action = function(self, t)
+		local tg = {type="ball", range=0, radius=self:getTalentRange(t), talent=t, friendlyfire=false}
+		local grids = self:project(tg, self.x, self.y, DamageType.LIGHT, self:spellCrit(10 + self:combatSpellpower(0.2) * self:getTalentLevel(t)))
+		self:project(tg, self.x, self.y, DamageType.DARKNESS, self:spellCrit(10 + self:combatSpellpower(0.2) * self:getTalentLevel(t)))
+		game.level.map:particleEmitter(self.x, self.y, tg.radius, "shadow_flash", {radius=tg.radius, grids=grids, tx=self.x, ty=self.y})
+
+		game:playSoundNear(self, "talents/flame")
+		return true
+	end,
+	info = function(self, t)
+		return ([[A surge of twilight pulses from your, doing %0.2f light and %0.2f darkness damage in a radius of %d.
+		It also regenerates both your negative and positive energies.
+		The damage will increase with the Magic stat]]):
+		format(
+			10 + self:combatSpellpower(0.2) * self:getTalentLevel(t),
+			10 + self:combatSpellpower(0.2) * self:getTalentLevel(t),
+			self:getTalentRange(t)
+		)
+	end,
+}
+
+newTalent{
+	name = "Starfall",
+	type = {"divine/star-fury", 4},
+	require = divi_req4,
+	points = 5,
+	cooldown = 12,
+	negative = 20,
+	tactical = {
+		ATTACKAREA = 10,
+	},
+	range = 10,
+	action = function(self, t)
+		local tg = {type="ball", range=self:getTalentRange(t), radius=1 + math.floor(self:getTalentLevelRaw(t) / 3), friendlyfire=self:spellFriendlyFire(), talent=t}
+		local x, y = self:getTarget(tg)
+		if not x or not y then return nil end
+		local grids = self:project(tg, x, y, DamageType.DARKSTUN, self:spellCrit(28 + self:combatSpellpower(0.5) * self:getTalentLevel(t)))
+
+		local _ _, x, y = self:canProject(tg, x, y)
+		game.level.map:particleEmitter(x, y, tg.radius, "shadow_flash", {radius=tg.radius, grids=grids, tx=x, ty=y})
+		game:playSoundNear(self, "talents/fireflash")
+		return true
+	end,
+	info = function(self, t)
+		return ([[A star falls onto the target, stunning all and doing %0.2f darkness damage.
+		The damage will increase with the Magic stat]]):format(self:getTalentLevel(t), 28 + self:combatSpellpower(0.5) * self:getTalentLevel(t))
+	end,
+}
diff --git a/game/modules/tome/data/talents/divine/sun.lua b/game/modules/tome/data/talents/divine/sun.lua
index 84040579199a0b304ec799ea7ebef5ab816ee331..f5213024ffc5772fee5b53c39198f37c50dd3712 100644
--- a/game/modules/tome/data/talents/divine/sun.lua
+++ b/game/modules/tome/data/talents/divine/sun.lua
@@ -23,7 +23,7 @@ newTalent{
 	require = divi_req1,
 	points = 5,
 	cooldown = 6,
-	positive = -15,
+	positive = -16,
 	tactical = {
 		ATTACK = 10,
 	},
diff --git a/game/modules/tome/data/talents/divine/twilight.lua b/game/modules/tome/data/talents/divine/twilight.lua
new file mode 100644
index 0000000000000000000000000000000000000000..2777fc8c3ced91e0df8d39ccc96371cd2e6aa50b
--- /dev/null
+++ b/game/modules/tome/data/talents/divine/twilight.lua
@@ -0,0 +1,183 @@
+-- ToME - Tales of Middle-Earth
+-- Copyright (C) 2009, 2010 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
+
+newTalent{
+	name = "Twilight",
+	type = {"divine/twilight", 1},
+	require = divi_req1,
+	points = 5,
+	cooldown = 6,
+	positive = 15,
+	tactical = {
+		BUFF = 10,
+	},
+	range = 20,
+	action = function(self, t)
+		self:incNegative(20 + 20 * self:getTalentLevel(t))
+		game:playSoundNear(self, "talents/spell_generic")
+		return true
+	end,
+	info = function(self, t)
+		return ([[You stand between the darkness and the light, allowing you to convert 15 positive energy into %d negative energy.]]):
+		format(20 + 10 * self:getTalentLevel(t))
+	end,
+}
+
+newTalent{
+	name = "Jumpgate: Teleport To", short_name = "JUMPGATE_TELEPORT",
+	type = {"divine/other", 1},
+	points = 1,
+	cooldown = 7,
+	negative = 14,
+	type_no_req = true,
+	tactical = {
+		MOVE = 10,
+	},
+	range = 20,
+	action = function(self, t)
+		local eff = self.sustain_talents[self.T_JUMPGATE]
+		if not eff then
+			game.logPlayer(self, "You must sustain the Jumpgate spell to be able to teleport.")
+			return
+		end
+		game.level.map:particleEmitter(self.x, self.y, 1, "teleport")
+		self:teleportRandom(eff.jumpgate_x, eff.jumpgate_y, 1)
+		game.level.map:particleEmitter(eff.jumpgate_x, eff.jumpgate_y, 1, "teleport")
+		game:playSoundNear(self, "talents/teleport")
+		return true
+	end,
+	info = function(self, t)
+		return ([[You stand between the darkness and the light, allowing you to convert 15 positive energy into %d negative energy.]]):
+		format(20 + 10 * self:getTalentLevel(t))
+	end,
+}
+
+newTalent{
+	name = "Jumpgate",
+	type = {"divine/twilight", 2},
+	require = divi_req2,
+	mode = "sustained",
+	points = 5,
+	cooldown = 20,
+	negative_sustain = 20,
+	tactical = {
+		MOVE = 10,
+	},
+	on_learn = function(self, t)
+		if not self:knowTalent(self.T_JUMPGATE_TELEPORT) then
+			self:learnTalent(self.T_JUMPGATE_TELEPORT)
+		end
+	end,
+	on_unlearn = function(self, t)
+		if not self:knowTalent(t) then
+			self:unlearnTalent(self.T_JUMPGATE_TELEPORT)
+		end
+	end,
+	range = function(self, t)
+		return 10 + 10 * self:getTalentLevelRaw(t)
+	end,
+	activate = function(self, t)
+		local ret = {
+			jumpgate_x = game.player.x,
+			jumpgate_y = game.player.y,
+			particle = self:addParticles(Particles.new("time_shield", 1))
+		}
+		return ret
+	end,
+	deactivate = function(self, t, p)
+		self:removeParticles(p.particle)
+		return true
+	end,
+	info = function(self, t)
+		return ([[Create a shadow jumpgate at your location. As long as you sustain this spell you can use 'Jumpgate: Teleport' to instantly travel to the jumpgate.]])
+	end,
+}
+
+newTalent{
+	name = "Mind Blast",
+	type = {"divine/twilight",3},
+	require = divi_req3,
+	points = 5,
+	cooldown = 15,
+	negative = 15,
+	tactical = {
+		ATTACKAREA = 10,
+	},
+	range = 3,
+	action = function(self, t)
+		local tg = {type="ball", range=0, radius=self:getTalentRange(t), talent=t, friendlyfire=false}
+		self:project(tg, self.x, self.y, DamageType.CONFUSION, {
+			dur = 2 + self:getTalentLevelRaw(t),
+			dam = 50+self:getTalentLevelRaw(t)*10,
+		})
+		game:playSoundNear(self, "talents/flame")
+		return true
+	end,
+	info = function(self, t)
+		return ([[Let out a mental cry that shatters the will of your targets, confusion them for %d turns.]]):
+		format(2 + self:getTalentLevelRaw(t))
+	end,
+}
+
+newTalent{
+	name = "Shadow Simulacrum",
+	type = {"divine/twilight", 4},
+	require = divi_req4,
+	points = 5,
+	cooldown = 30,
+	negative = 10,
+	tactical = {
+		ATTACK = 10,
+	},
+	range = 10,
+	action = function(self, t)
+		local tg = {type="bolt", range=self:getTalentRange(t), talent=t}
+		local tx, ty, target = self:getTarget(tg)
+		if not tx or not ty then return nil end
+		local _ _, tx, ty = self:canProject(tg, tx, ty)
+		local target = game.level.map(tx, ty, Map.ACTOR)
+		if not target or self:reactionToward(target) >= 0 then return end
+
+		-- Find space
+		local x, y = util.findFreeGrid(tx, ty, 5, true, {[Map.ACTOR]=true})
+		if not x then
+			game.logPlayer(self, "Not enough space to summon!")
+			return
+		end
+
+		local m = target:clone{
+			no_drops = true,
+			faction = self.faction,
+			summoner = self, summoner_gain_exp=true,
+			summon_time = math.ceil(self:getTalentLevel(t)) + 3,
+			ai_target = {actor=target}
+		}
+		m.life = m.life / 2
+
+		game.zone:addEntity(game.level, m, "actor", x, y)
+		game.level.map:particleEmitter(x, y, 1, "shadow")
+
+		game:playSoundNear(self, "talents/spell_generic")
+		return true
+	end,
+	info = function(self, t)
+		return ([[Creates a shadowy copy of your target. The copy will attack its progenitor immediately.
+		It stays for %d turns.]]):format(math.ceil(self:getTalentLevel(t)) + 3)
+	end,
+}
diff --git a/game/modules/tome/data/texts/unlock-divine_anorithil.lua b/game/modules/tome/data/texts/unlock-divine_anorithil.lua
new file mode 100644
index 0000000000000000000000000000000000000000..fb1c73e3a17f17d216d860c25f98ab7012cb59bc
--- /dev/null
+++ b/game/modules/tome/data/texts/unlock-divine_anorithil.lua
@@ -0,0 +1,38 @@
+-- ToME - Tales of Middle-Earth
+-- Copyright (C) 2009, 2010 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
+
+return "New Class: #LIGHT_GREEN#Anorithil (Divine)",
+[[
+In the uttermost east of Arda, on the continent known as the Far East, dwells the last remnants of the free people, fighting the Orc Pride and the many perils of the Far East.
+
+Anorithil are elven mages who are trained in special magic to manipulate the Sun and Moon powers.
+They have learned to harness the powers of both shadows and light in their battle against the Pride.
+
+You have discovered the Gates of Morning and can now create new characters with the #LIGHT_GREEN#Anorithil class#WHITE#.
+
+Anorithil are pure spellcasters that rely on posivite and negative energies.
+Class features:#YELLOW#
+- Burn your foes from afar with the light and fire of the Sun
+- Head into battle enhanced by your powerful Sun Chants and Moon Hymns
+- Engulf your foes in the shadows
+- Set glyphs of power to confuse and control your foes#WHITE#
+
+Anorithil use "positive and negative energy" to use their special abilities.
+It is filled by some of their spells and depleted by others, making them alternate their talents.
+]]
diff --git a/game/modules/tome/data/texts/unlock-divine_sun_paladin.lua b/game/modules/tome/data/texts/unlock-divine_sun_paladin.lua
index ab541cdcbe26a6e620739aa22fa6d044ff2ffa67..479258e65823e4a58cde7f23ffd63b36b45b987f 100644
--- a/game/modules/tome/data/texts/unlock-divine_sun_paladin.lua
+++ b/game/modules/tome/data/texts/unlock-divine_sun_paladin.lua
@@ -17,7 +17,7 @@
 -- Nicolas Casalini "DarkGod"
 -- darkgod@te4.org
 
-return "New Class: #LIGHT_GREEN#Sun Paladin",
+return "New Class: #LIGHT_GREEN#Sun Paladin (Divine)",
 [[
 In the uttermost east of Arda, on the continent known as the Far East, dwells the last remnants of the free people, fighting the Orc Pride and the many perils of the Far East.
 
diff --git a/ideas/divine.ods b/ideas/divine.ods
index e02e7f9fb2e1b636b1e7b5c94f285b0e29d2c0fd..51c6ef75bd1c8aaa36e7ae4c0a135f8e7a9bd59e 100644
Binary files a/ideas/divine.ods and b/ideas/divine.ods differ
diff --git a/src/map.c b/src/map.c
index 9a223900c8b6974d79d2efd9214db220bb264c27..f6b865c6ebc5eb268443362038347b79f5208de4 100644
--- a/src/map.c
+++ b/src/map.c
@@ -76,7 +76,6 @@ static int map_object_texture(lua_State *L)
 
 	obj->textures[i] = *t;
 	obj->textures_is3d[i] = is3d;
-	printf("Map Object set texture %d : %d (%d 3D)\n", i, *t, is3d);
 	return 0;
 }
 
diff --git a/src/noise.c b/src/noise.c
index 8301b8549b9f250cfcebe0cddff030a967419d89..6c37d4130e16e56ec1a69ebf0eaf4a0c62592778 100644
--- a/src/noise.c
+++ b/src/noise.c
@@ -245,7 +245,7 @@ static int noise_texture3d(lua_State *L)
 				p[0] = zoom * ((float)(ii+x)) / w;
 				p[1] = zoom * ((float)(jj+y)) / h;
 				p[2] = zoom * ((float)(kk+z)) / d;
-				float v = ((TCOD_noise_simplex(n->noise, p) + 1) / 2) * 255;
+				float v = ((TCOD_noise_fbm_simplex(n->noise, p, 4) + 1) / 2) * 255;
 				map[TEXEL3(i, j, k)] = (GLubyte)v;
 				map[TEXEL3(i, j, k)+1] = (GLubyte)v;
 				map[TEXEL3(i, j, k)+2] = (GLubyte)v;
diff --git a/src/particles.c b/src/particles.c
index d2e9d222c30acff11d67c51493ff91bf50809ec1..c5b84d19258ea549606126bd00adf97371cbbf0f 100644
--- a/src/particles.c
+++ b/src/particles.c
@@ -260,14 +260,15 @@ static int particles_to_screen(lua_State *L)
 	int x = luaL_checknumber(L, 2);
 	int y = luaL_checknumber(L, 3);
 	bool show = lua_toboolean(L, 4);
-	int i = 0;
+	int w = 0;
+	int i, j;
 	bool alive = FALSE;
 
 	glBindTexture(GL_TEXTURE_2D, ps->texture);
 
-	for (i = 0; i < ps->nb; i++)
+	for (w = 0; w < ps->nb; w++)
 	{
-		particle_type *p = &ps->particles[i];
+		particle_type *p = &ps->particles[w];
 
 		if (p->life > 0)
 		{
@@ -279,10 +280,12 @@ static int particles_to_screen(lua_State *L)
 				glBegin(GL_QUADS);
 				if (!p->trail)
 				{
-					glTexCoord2f(0,0); glVertex3f(0 + x + p->x,	0 + y + p->y,		-97);
-					glTexCoord2f(1,0); glVertex3f(p->size + x + p->x,	0 + y + p->y,		-97);
-					glTexCoord2f(1,1); glVertex3f(p->size + x + p->x,	p->size + y + p->y,	-97);
-					glTexCoord2f(0,1); glVertex3f(0 + x + p->x,	p->size + y + p->y,	-97);
+					i = x + p->x - p->size / 2;
+					j = y + p->y - p->size / 2;
+					glTexCoord2f(0,0); glVertex3f(0 + i,	0 + j,		-97);
+					glTexCoord2f(1,0); glVertex3f(p->size + i,	0 + j,		-97);
+					glTexCoord2f(1,1); glVertex3f(p->size + i,	p->size + j,	-97);
+					glTexCoord2f(0,1); glVertex3f(0 + i,	p->size + j,	-97);
 				}
 				else
 				{