diff --git a/game/engine/interface/ActorTalents.lua b/game/engine/interface/ActorTalents.lua
index 489afb4bef02ded78cab86bf04676e1587daca1d..fe935ee2458b8085541b4e9fa762f788fe46f15a 100644
--- a/game/engine/interface/ActorTalents.lua
+++ b/game/engine/interface/ActorTalents.lua
@@ -433,7 +433,9 @@ end
 -- @param t the talent to cooldown
 function _M:startTalentCooldown(t)
 	if not t.cooldown then return end
-	self.talents_cd[t.id] = t.cooldown
+	local cd = t.cooldown
+	if type(cd) == "function" then cd = cd(self, t) end
+	self.talents_cd[t.id] = cd
 	self.changed = true
 end
 
diff --git a/game/engine/interface/PlayerRest.lua b/game/engine/interface/PlayerRest.lua
index c1bf7ed4e50641454fbb769a0937b513b8889299..0cec59a69e8611a4b48e1412ad37bcee5dc73649 100644
--- a/game/engine/interface/PlayerRest.lua
+++ b/game/engine/interface/PlayerRest.lua
@@ -24,15 +24,20 @@ local Dialog = require "engine.Dialog"
 module(..., package.seeall, class.make)
 
 --- Initializes resting
-function _M:restInit()
+function _M:restInit(turns, what, past, on_end)
+	what = what or "resting"
+	past = past or "rested"
 	self.resting = {
+		rest_turns = turns,
+		past = past,
+		on_end = on_end,
 		cnt = 1,
-		dialog = Dialog:simplePopup("Resting...", "You are resting, press any key to stop.", function()
+		dialog = Dialog:simplePopup(what:capitalize().."...", "You are "..what..", press any key to stop.", function()
 			self:restStop()
 		end),
 	}
 	self:useEnergy()
-	game.log("Resting starts...")
+	game.log(what:capitalize().." starts...")
 end
 
 --- Rest a turn
@@ -45,6 +50,7 @@ function _M:restStep()
 	if not self.resting then return false end
 
 	local ret, msg = self:restCheck()
+	if ret and self.resting and self.resting.rest_turns and self.resting.cnt > self.resting.rest_turns then ret = false msg = nil end
 	if not ret then
 		self:restStop(msg)
 		return false
@@ -69,11 +75,12 @@ function _M:restStop(msg)
 	game:unregisterDialog(self.resting.dialog)
 
 	if msg then
-		game.log("Rested for %d turns (stop reason: %s).", self.resting.cnt, msg)
+		game.log(self.resting.past:capitalize().." for %d turns (stop reason: %s).", self.resting.cnt, msg)
 	else
-		game.log("Rested for %d turns.", self.resting.cnt)
+		game.log(self.resting.past:capitalize().." for %d turns.", self.resting.cnt)
 	end
 
+	if self.resting.on_end then self.resting.on_end(self.resting.cnt, self.resting.rest_turns) end
 	self.resting = nil
 	return true
 end
diff --git a/game/modules/tome/class/Actor.lua b/game/modules/tome/class/Actor.lua
index 084df44242ab8d524cd132f17b46df7d0e6dead0..4a0a7604fbf5d293d91e74d443c3b84cd8f371fd 100644
--- a/game/modules/tome/class/Actor.lua
+++ b/game/modules/tome/class/Actor.lua
@@ -248,7 +248,7 @@ function _M:getPathString()
 		ps = ps .. what.."="..check..","
 	end
 	ps = ps.."}}"
-	print("[PATH STRING] for", self.name, " :=: ", ps)
+--	print("[PATH STRING] for", self.name, " :=: ", ps)
 	return ps
 end
 
@@ -647,6 +647,9 @@ function _M:levelup()
 	if self.autolevel then
 		engine.Autolevel:autoLevel(self)
 	end
+
+	-- Force levelup of the golem
+	if self.alchemy_golem then self.alchemy_golem:forceLevelup(self.level) end
 end
 
 --- Notifies a change of stat value
@@ -966,7 +969,7 @@ function _M:getTalentFullDescription(t, addlevel)
 	if self:getTalentRange(t) > 1 then d[#d+1] = "#6fff83#Range: #FFFFFF#"..self:getTalentRange(t)
 	else d[#d+1] = "#6fff83#Range: #FFFFFF#melee/personal"
 	end
-	if t.cooldown then d[#d+1] = "#6fff83#Cooldown: #FFFFFF#"..t.cooldown end
+	if t.cooldown then d[#d+1] = "#6fff83#Cooldown: #FFFFFF#"..util.getval(t.cooldown, self, t) end
 
 	local ret = table.concat(d, "\n").."\n#6fff83#Description: #FFFFFF#"..t.info(self, t)
 
diff --git a/game/modules/tome/class/Game.lua b/game/modules/tome/class/Game.lua
index e1f0b28fd6a91b81d52ce1a41036b1cd73e56bea..96a784d870beb38e28c63be77ec0fbea2644d72e 100644
--- a/game/modules/tome/class/Game.lua
+++ b/game/modules/tome/class/Game.lua
@@ -143,9 +143,11 @@ function _M:newGame()
 		Map:setViewerFaction(self.player.faction)
 		self.paused = true
 		print("[PLAYER BIRTH] resolved!")
-		self.player:grantQuest(self.player.starting_quest)
-		self:registerDialog(require("mod.dialogs.IntroDialog").new(self.player))
-		self.player:resetToFull()
+		self.player:playerLevelup(function()
+			self.player:grantQuest(self.player.starting_quest)
+			self:registerDialog(require("mod.dialogs.IntroDialog").new(self.player))
+			self.player:resetToFull()
+		end)
 	end, quickbirth)
 	self:registerDialog(birth)
 end
diff --git a/game/modules/tome/class/Player.lua b/game/modules/tome/class/Player.lua
index 76318efa8cd622eaa92ceea2be48267e890085be..c64c54bbab73f96055841ebad826c0694eb4b327 100644
--- a/game/modules/tome/class/Player.lua
+++ b/game/modules/tome/class/Player.lua
@@ -328,10 +328,14 @@ function _M:restCheck()
 	if spotted then return false, ("hostile spotted (%s%s)"):format(spotted.actor.name, game.level.map:isOnScreen(spotted.x, spotted.y) and "" or " - offscreen") end
 
 	-- Check ressources, make sure they CAN go up, otherwise we will never stop
-	if self.air_regen < 0 then return false, "loosing breath!" end
-	if self:getMana() < self:getMaxMana() and self.mana_regen > 0 then return true end
-	if self:getStamina() < self:getMaxStamina() and self.stamina_regen > 0 then return true end
-	if self.life < self.max_life and self.life_regen> 0 then return true end
+	if not self.resting.rest_turns then
+		if self.air_regen < 0 then return false, "loosing breath!" end
+		if self:getMana() < self:getMaxMana() and self.mana_regen > 0 then return true end
+		if self:getStamina() < self:getMaxStamina() and self.stamina_regen > 0 then return true end
+		if self.life < self.max_life and self.life_regen> 0 then return true end
+	else
+		return true
+	end
 
 	return false, "all resources and life at maximum"
 end
diff --git a/game/modules/tome/data/birth/classes/mage.lua b/game/modules/tome/data/birth/classes/mage.lua
index 32744e744ba726054288668841c6f302f3416949..a8ce556c13be5513ddf5a2e8977b135fdb3bb7cb 100644
--- a/game/modules/tome/data/birth/classes/mage.lua
+++ b/game/modules/tome/data/birth/classes/mage.lua
@@ -112,8 +112,10 @@ newBirthDescriptor{
 	},
 	talents = {
 		[ActorTalents.T_CREATE_ALCHEMIST_GEMS] = 1,
+		[ActorTalents.T_REFIT_GOLEM] = 1,
 		[ActorTalents.T_THROW_BOMB] = 1,
 		[ActorTalents.T_FIRE_INFUSION] = 1,
+		[ActorTalents.T_GOLEM_TAUNT] = 1,
 	},
 	copy = {
 		max_life = 90,
@@ -129,5 +131,9 @@ newBirthDescriptor{
 			{type="potion", subtype="potion", name="potion of lesser mana", ego_chance=-1000},
 			{type="potion", subtype="potion", name="potion of lesser mana", ego_chance=-1000},
 		},
+		resolvers.generic(function(self)
+			local t = self:getTalentFromId(self.T_REFIT_GOLEM)
+			t.action(self, t)
+		end),
 	},
 }
diff --git a/game/modules/tome/data/gfx/terrain/underground_tree_alpha1.png b/game/modules/tome/data/gfx/terrain/underground_tree_alpha1.png
new file mode 100644
index 0000000000000000000000000000000000000000..cd63192911727f855c368f30aec2bbd7d6a7cdcf
Binary files /dev/null and b/game/modules/tome/data/gfx/terrain/underground_tree_alpha1.png differ
diff --git a/game/modules/tome/data/gfx/terrain/underground_tree_alpha2.png b/game/modules/tome/data/gfx/terrain/underground_tree_alpha2.png
new file mode 100644
index 0000000000000000000000000000000000000000..888123ebf18f780b7ed58c58a86a66382be53608
Binary files /dev/null and b/game/modules/tome/data/gfx/terrain/underground_tree_alpha2.png differ
diff --git a/game/modules/tome/data/gfx/terrain/underground_tree_alpha3.png b/game/modules/tome/data/gfx/terrain/underground_tree_alpha3.png
new file mode 100644
index 0000000000000000000000000000000000000000..80270ab09d07ae2be3e33ed9c75dd534517aed4a
Binary files /dev/null and b/game/modules/tome/data/gfx/terrain/underground_tree_alpha3.png differ
diff --git a/game/modules/tome/data/gfx/terrain/underground_tree_alpha4.png b/game/modules/tome/data/gfx/terrain/underground_tree_alpha4.png
new file mode 100644
index 0000000000000000000000000000000000000000..242bd309c6ba3bd07f6bf4bf641a2c65178b841b
Binary files /dev/null and b/game/modules/tome/data/gfx/terrain/underground_tree_alpha4.png differ
diff --git a/game/modules/tome/data/gfx/terrain/underground_tree_alpha5.png b/game/modules/tome/data/gfx/terrain/underground_tree_alpha5.png
new file mode 100644
index 0000000000000000000000000000000000000000..f3fcce7d2c1bec14dc0ae583f1e7fb495661f03b
Binary files /dev/null and b/game/modules/tome/data/gfx/terrain/underground_tree_alpha5.png differ
diff --git a/game/modules/tome/data/gfx/terrain/underground_tree_alpha6.png b/game/modules/tome/data/gfx/terrain/underground_tree_alpha6.png
new file mode 100644
index 0000000000000000000000000000000000000000..30da23348fc380c9f30605a5721e426eaccd70eb
Binary files /dev/null and b/game/modules/tome/data/gfx/terrain/underground_tree_alpha6.png differ
diff --git a/game/modules/tome/data/gfx/terrain/underground_tree_alpha7.png b/game/modules/tome/data/gfx/terrain/underground_tree_alpha7.png
new file mode 100644
index 0000000000000000000000000000000000000000..03a2ffcb7f3b4ef5fb2918ab366e454cd9e7bccb
Binary files /dev/null and b/game/modules/tome/data/gfx/terrain/underground_tree_alpha7.png differ
diff --git a/game/modules/tome/data/talents/spells/alchemy.lua b/game/modules/tome/data/talents/spells/alchemy.lua
index 3ff6073439ee429b5cbf4eecc7322ac3fe944c32..88a842c4fe9f211f5f905c046fdf8a97d22d2799 100644
--- a/game/modules/tome/data/talents/spells/alchemy.lua
+++ b/game/modules/tome/data/talents/spells/alchemy.lua
@@ -25,6 +25,7 @@ newTalent{
 	range = function(self, t)
 		return math.ceil(5 + self:getDex(12))
 	end,
+	mana = 30,
 	action = function(self, t)
 		local nb = rng.range(40, 80)
 
@@ -57,6 +58,7 @@ newTalent{
 	type = {"spell/alchemy", 1},
 	require = spells_req1,
 	points = 5,
+	mana = 5,
 	range = function(self, t)
 		return math.ceil(5 + self:getDex(12))
 	end,
diff --git a/game/modules/tome/data/talents/spells/golemancy.lua b/game/modules/tome/data/talents/spells/golemancy.lua
index 2a383aacbeaac7a9ce1e4b565e6f103b6f1c588a..b6f1c4609aaa1348e8fd00c7fc17ecb53339570b 100644
--- a/game/modules/tome/data/talents/spells/golemancy.lua
+++ b/game/modules/tome/data/talents/spells/golemancy.lua
@@ -46,20 +46,38 @@ end
 
 newTalent{
 	name = "Refit Golem",
-	type = {"spell/golemancy", 1},
+	type = {"spell/golemancy-base", 1},
 	require = spells_req1,
 	points = 1,
+	cooldown = 20,
+	mana = 10,
 	action = function(self, t)
 		if not self.alchemy_golem then
 			self.alchemy_golem = game.zone:finishEntity(game.level, "actor", makeGolem())
 			if not self.alchemy_golem then return end
 			self.alchemy_golem.faction = self.faction
+			self.alchemy_golem.name = "golem (servant of "..self.name..")"
 			self.alchemy_golem.summoner = self
 			self.alchemy_golem.summoner_gain_exp = true
+		else
+			local co = coroutine.running()
+			local ok = false
+			self:restInit(20, "refitting", "refitted", function(cnt, max)
+				if cnt > max then ok = true end
+				coroutine.resume(co)
+			end)
+			coroutine.yield()
+			if not ok then
+				game.logPlayer(self, "You have been interrupted!")
+				return
+			end
 		end
 
 		if game.level:hasEntity(self.alchemy_golem) then
 		else
+			self.alchemy_golem.dead = nil
+			if self.alchemy_golem.life < 0 then self.alchemy_golem.life = self.alchemy_golem.max_life / 3 end
+
 			-- Find space
 			local x, y = util.findFreeGrid(self.x, self.y, 5, true, {[Map.ACTOR]=true})
 			if not x then
@@ -73,70 +91,41 @@ newTalent{
 		return true
 	end,
 	info = function(self, t)
-		return ([[Carve %d to %d alchemist gems out of natural gems.
-		Alchemists gems are used for lots of other spells.]]):format(40, 80)
+		return ([[Interract with your golem, reviving it if it is dead, healing it, ...]])
 	end,
 }
 
 newTalent{
-	name = "Golem: Taunt",
+	name = "Golem: Taunt", short_name = "GOLEM_TAUNT",
 	type = {"spell/golemancy", 1},
 	require = spells_req1,
 	points = 5,
-	range = function(self, t)
-		return math.ceil(5 + self:getDex(12))
-	end,
-	computeDamage = function(self, t, ammo)
-		local inc_dam = 0
-		local damtype = DamageType.FIRE
-		local particle = "ball_fire"
-		if self:isTalentActive(self.T_ACID_INFUSION) then inc_dam = self:getTalentLevel(self.T_ACID_INFUSION) * 0.05; damtype = DamageType.ACID; particle = "ball_acid"
-		elseif self:isTalentActive(self.T_LIGHTNING_INFUSION) then inc_dam = self:getTalentLevel(self.T_LIGHTNING_INFUSION) * 0.05; damtype = DamageType.LIGHTNING; particle = "ball_lightning"
-		elseif self:isTalentActive(self.T_FROST_INFUSION) then inc_dam = self:getTalentLevel(self.T_FROST_INFUSION) * 0.05; damtype = DamageType.ICE; particle = "ball_ice"
-		else inc_dam = self:getTalentLevel(self.T_FIRE_INFUSION) * 0.05
-		end
-		local dam = self:combatTalentSpellDamage(t, 15, 150, (ammo.alchemist_power + self:combatSpellpower()) / 2)
-		dam = dam * (1 + inc_dam)
-		return dam, damtype, particle
+	cooldown = function(self, t)
+		return 20 - self:getTalentLevelRaw(t) * 2
 	end,
+	range = 10,
+	mana = 5,
 	action = function(self, t)
-		local ammo = self:hasAlchemistWeapon()
-		if not ammo then
-			game.logPlayer(self, "You need to ready alchemist gems in your quiver.")
+		if not game.level:hasEntity(self.alchemy_golem) then
+			game.logPlayer(self, "Your golem is currently inactive.")
 			return
 		end
 
-		local tg = {type="ball", range=self:getTalentRange(t), radius=self:getTalentLevelRaw(self.T_EXPLOSION_EXPERT), talent=t}
-		if tg.radius == 0 then tg.type = "hit" end
-		local x, y = self:getTarget(tg)
-		if not x or not y then return nil end
-
-		ammo = self:removeObject(self:getInven("QUIVER"), 1)
-		if not ammo then return end
-
-		local dam, damtype, particle = t.computeDamage(self, t, ammo)
-		local prot = self:getTalentLevelRaw(self.T_ALCHEMIST_PROTECTION) * 0.2
+		local tg = {type="hit", range=self:getTalentRange(t)}
+		game.target.source_actor = self.alchemy_golem
+		local x, y, target = self:getTarget(tg)
+		game.target.source_actor = self
+		if not x or not y or not target then print(1) return nil end
+		if math.floor(core.fov.distance(self.alchemy_golem.x, self.alchemy_golem.y, x, y)) > self:getTalentRange(t) then return nil end
 
-		local grids = self:project(tg, x, y, function(tx, ty)
-			-- Protect yourself
-			local d = dam
-			if tx == self.x and ty == self.y then d = dam * (1 - prot) end
-			DamageType:get(damtype).projector(self, tx, ty, damtype, self:spellCrit(d))
-		end)
+		self.alchemy_golem:setTarget(target)
+		target:setTarget(self.alchemy_golem)
+		game.logPlayer(self, "Your golem provokes %s to attack it.", target.name:capitalize())
 
-		local _ _, x, y = self:canProject(tg, x, y)
-		game.level.map:particleEmitter(x, y, tg.radius, particle, {radius=tg.radius, grids=grids, tx=x, ty=y})
-
-		game:playSoundNear(self, "talents/arcane")
 		return true
 	end,
 	info = function(self, t)
-		local ammo = self:hasAlchemistWeapon()
-		local dam, damtype = 1, DamageType.FIRE
-		if ammo then dam, damtype = t.computeDamage(self, t, ammo) end
-		return ([[Imbue an alchemist gem with an explosive charge of mana and throw it.
-		The gem will explode for %0.2f %s damage.
-		The damage will improve with better gems and Magic stat and the range with your dexterity.]]):format(dam, DamageType:get(damtype).name)
+		return ([[Orders your golem to taunt a target, forcing it to attack the golem.]]):format()
 	end,
 }
 
@@ -144,10 +133,54 @@ newTalent{
 	name = "Golem: Knockback",
 	type = {"spell/golemancy", 2},
 	require = spells_req2,
-	mode = "passive",
 	points = 5,
+	cooldown = 10,
+	range = 10,
+	mana = 5,
+	action = function(self, t)
+		if not game.level:hasEntity(self.alchemy_golem) then
+			game.logPlayer(self, "Your golem is currently inactive.")
+			return
+		end
+
+		local tg = {type="hit", range=self:getTalentRange(t)}
+		game.target.source_actor = self.alchemy_golem
+		local x, y, target = self:getTarget(tg)
+		game.target.source_actor = self
+		if not x or not y or not target then return nil end
+		if math.floor(core.fov.distance(self.alchemy_golem.x, self.alchemy_golem.y, x, y)) > self:getTalentRange(t) then return nil end
+
+		self.alchemy_golem:setTarget(target)
+
+		local l = line.new(self.alchemy_golem.x, self.alchemy_golem.y, x, y)
+		local lx, ly = l()
+		local tx, ty = self.alchemy_golem.x, self.alchemy_golem.y
+		lx, ly = l()
+		while lx and ly do
+			if game.level.map:checkAllEntities(lx, ly, "block_move", self.alchemy_golem) then break end
+			tx, ty = lx, ly
+			lx, ly = l()
+		end
+
+		self.alchemy_golem:move(tx, ty, true)
+
+		-- Attack ?
+		if math.floor(core.fov.distance(self.alchemy_golem.x, self.alchemy_golem.y, x, y)) > 1 then return true end
+		local hit = self.alchemy_golem:attackTarget(target, nil, self.alchemy_golem:combatTalentWeaponDamage(t, 0.8, 1.6), true)
+
+		-- Try to knockback !
+		if hit then
+			if target:checkHit(self.alchemy_golem:combatAttackStr(), target:combatPhysicalResist(), 0, 95, 5 - self.alchemy_golem:getTalentLevel(t) / 2) and target:canBe("knockback") then
+				target:knockback(self.alchemy_golem.x, self.alchemy_golem.y, 3)
+			else
+				game.logSeen(target, "%s resists the knockback!", target.name:capitalize())
+			end
+		end
+
+		return true
+	end,
 	info = function(self, t)
-		return ([[Your alchemist bombs now affect a radius of %d around them.]]):format(self:getTalentLevelRaw(t))
+		return ([[Your golem rushes to the target, knocking it back and doing %d%% damage.]]):format(100 * self:combatTalentWeaponDamage(t, 0.8, 1.6))
 	end,
 }
 
@@ -155,23 +188,54 @@ newTalent{
 	name = "Golem: Crush",
 	type = {"spell/golemancy", 3},
 	require = spells_req3,
-	mode = "passive",
 	points = 5,
-	on_learn = function(self, t)
-		self.resists[DamageType.FIRE] = (self.resists[DamageType.FIRE] or 0) + 3
-		self.resists[DamageType.COLD] = (self.resists[DamageType.COLD] or 0) + 3
-		self.resists[DamageType.LIGHTNING] = (self.resists[DamageType.LIGHTNING] or 0) + 3
-		self.resists[DamageType.ACID] = (self.resists[DamageType.ACID] or 0) + 3
-	end,
-	on_unlearn = function(self, t)
-		self.resists[DamageType.FIRE] = self.resists[DamageType.FIRE] - 3
-		self.resists[DamageType.COLD] = self.resists[DamageType.COLD] - 3
-		self.resists[DamageType.LIGHTNING] = self.resists[DamageType.LIGHTNING] - 3
-		self.resists[DamageType.ACID] = self.resists[DamageType.ACID] - 3
+	cooldown = 10,
+	range = 10,
+	mana = 5,
+	action = function(self, t)
+		if not game.level:hasEntity(self.alchemy_golem) then
+			game.logPlayer(self, "Your golem is currently inactive.")
+			return
+		end
+
+		local tg = {type="hit", range=self:getTalentRange(t)}
+		game.target.source_actor = self.alchemy_golem
+		local x, y, target = self:getTarget(tg)
+		game.target.source_actor = self
+		if not x or not y or not target then return nil end
+		if math.floor(core.fov.distance(self.alchemy_golem.x, self.alchemy_golem.y, x, y)) > self:getTalentRange(t) then return nil end
+
+		self.alchemy_golem:setTarget(target)
+
+		local l = line.new(self.alchemy_golem.x, self.alchemy_golem.y, x, y)
+		local lx, ly = l()
+		local tx, ty = self.alchemy_golem.x, self.alchemy_golem.y
+		lx, ly = l()
+		while lx and ly do
+			if game.level.map:checkAllEntities(lx, ly, "block_move", self.alchemy_golem) then break end
+			tx, ty = lx, ly
+			lx, ly = l()
+		end
+
+		self.alchemy_golem:move(tx, ty, true)
+
+		-- Attack ?
+		if math.floor(core.fov.distance(self.alchemy_golem.x, self.alchemy_golem.y, x, y)) > 1 then return true end
+		local hit = self.alchemy_golem:attackTarget(target, nil, self.alchemy_golem:combatTalentWeaponDamage(t, 0.8, 1.6), true)
+
+		-- Try to knockback !
+		if hit then
+			if target:checkHit(self.alchemy_golem:combatAttackStr(), target:combatPhysicalResist(), 0, 95, 10 - self.alchemy_golem:getTalentLevel(t) / 2) and target:canBe("stun") then
+				target:setEffect(target.EFF_PINNED, 2 + self.alchemy_golem:getTalentLevel(t), {})
+			else
+				game.logSeen(target, "%s resists the crushing!", target.name:capitalize())
+			end
+		end
+
+		return true
 	end,
 	info = function(self, t)
-		return ([[Improves your resistance against your own bombs elemental damage by %d%% and against external one byt %d%%.]]):
-		format(self:getTalentLevelRaw(t) * 20, self:getTalentLevelRaw(t) * 3)
+		return ([[Your golem rushes to the target, crushing and doing %d%% damage.]]):format(100 * self:combatTalentWeaponDamage(t, 0.8, 1.6))
 	end,
 }
 
@@ -180,12 +244,13 @@ newTalent{
 	type = {"spell/golemancy",4},
 	require = spells_req4,
 	points = 5,
+	mana = 10,
+	cooldown = 20,
 	action = function(self, t)
 		game:playSoundNear(self, "talents/arcane")
 		return true
 	end,
 	info = function(self, t)
-		return ([[Carve %d to %d alchemist gems out of muliple natural gems, combining their powers.
-		Alchemists gems are used for lots of other spells.]]):format(40, 80)
+		return ([[Imbue an alchemist gem with an explosive charge of mana and throw it.]]):format()
 	end,
 }
diff --git a/game/modules/tome/data/talents/spells/infusion.lua b/game/modules/tome/data/talents/spells/infusion.lua
index b664b2ab5d6251187793060174dadc8b467aa2dc..02c29afd5c4e07b464c81a70aae8da599891d105 100644
--- a/game/modules/tome/data/talents/spells/infusion.lua
+++ b/game/modules/tome/data/talents/spells/infusion.lua
@@ -45,7 +45,7 @@ newTalent{
 	type = {"spell/infusion", 2},
 	mode = "sustained",
 	require = spells_req2,
-	sustain_mana = 50,
+	sustain_mana = 30,
 	points = 5,
 	cooldown = 30,
 	activate = function(self, t)
@@ -69,7 +69,7 @@ newTalent{
 	type = {"spell/infusion", 2},
 	mode = "sustained",
 	require = spells_req2,
-	sustain_mana = 50,
+	sustain_mana = 30,
 	points = 5,
 	cooldown = 30,
 	activate = function(self, t)
@@ -93,7 +93,7 @@ newTalent{
 	type = {"spell/infusion", 2},
 	mode = "sustained",
 	require = spells_req2,
-	sustain_mana = 50,
+	sustain_mana = 30,
 	points = 5,
 	cooldown = 30,
 	activate = function(self, t)
diff --git a/game/modules/tome/data/talents/spells/spells.lua b/game/modules/tome/data/talents/spells/spells.lua
index 6e1948eb3514be5226870cc5b16678516a913a99..17ff36aca722eb2e7b05e146d06cc039eb9f7554 100644
--- a/game/modules/tome/data/talents/spells/spells.lua
+++ b/game/modules/tome/data/talents/spells/spells.lua
@@ -35,6 +35,7 @@ newTalentType{ type="spell/enhancement", name = "enhancement", description = "Ma
 newTalentType{ type="spell/alchemy-base", name = "alchemy", hide = true, description = "Manipulate gems to turn them into explosive magical bombs." }
 newTalentType{ type="spell/alchemy", name = "alchemy", description = "Manipulate gems to turn them into explosive magical bombs." }
 newTalentType{ type="spell/infusion", name = "infusion", description = "Infusion your gem bombs with the powers of the elements." }
+newTalentType{ type="spell/golemancy-base", name = "golemancy", hide = true, description = "Learn to craft and upgrade your golem." }
 newTalentType{ type="spell/golemancy", name = "golemancy", description = "Learn to craft and upgrade your golem." }
 newTalentType{ type="spell/advanced-golemancy", name = "advanced-golemancy", description = "Advanced golem operations." }
 newTalentType{ type="spell/gemology", name = "gemology", generic = true, description = "Manipulate gems, imbue their powers into other objects." }
diff --git a/ideas/crafting.ods b/ideas/crafting.ods
index 27ed731db629da07867d3fde859eeac96b0a29e9..33659f50e225d4236e7a70c07f18d7171d639d60 100644
Binary files a/ideas/crafting.ods and b/ideas/crafting.ods differ