Adjusted anomaly damage scaling

Chronomancy 'teleport' spells now behave similarly to other teleport spells
Anomaly swap should no longer be able to swap players into vaults
Spacetime mastery hit bonus fixed
Adjusted static history scaling


git-svn-id: http://svn.net-core.org/repos/t-engine4@4377 51575b47-30f0-44d4-a5cc-537603b46e54

game/modules/tome/data/talents/chronomancy/anomalies.lua

@@ -19,6 +19,11 @@
 
 local Object = require "engine.Object"
 
+getAnomalyDamage = function(self)
+	local damage = math.pow(self:getParadox()/50, 2)
+	return damage
+end
+
 newTalent{
 	name = "Anomaly Teleport",
 	type = {"chronomancy/anomalies", 1},
@@ -254,7 +259,7 @@ newTalent{
 	type = {"chronomancy/anomalies", 1},
 	points = 1,
 	type_no_req = true,
-	getDamage = function(self, t) return self:getParadox()/40 end,
+	getDamage = function(self, t) return getAnomalyDamage(self)/4 end,
 	getDuration = function(self, t) return math.ceil (self:getParadox()/50) end,
 	message = "A temporal storm rages around @Source@.",
 	action = function(self, t)
@@ -429,6 +434,8 @@ newTalent{
 	direct_hit = true,
 	type_no_req = true,
 	getRange = function(self, t) return math.ceil(self:getParadox()/20) end,
+	getConfuseDuration = function(self, t) return math.floor(self:getParadox()/200)end,
+	getConfuseEfficency = function(self, t) return self:getParadox()/10 end,
 	message = "Reality has shifted.",
 	action = function(self, t)
 		local tgts = {}
@@ -440,24 +447,35 @@ newTalent{
 			end
 		end end
 
-		-- Randomly take targets
+		-- Randomly take a target
 		local tg = {type="hit", range=self:getTalentRange(t), talent=t}
-		for i = 1, 1 do
-			if #tgts <= 0 then break end
-			local a, id = rng.table(tgts)
-			table.remove(tgts, id)
-
-		local px, py = self.x, self.y
-		local gx, gy = a.x, a.y
-
-		self:move(gx, gy, true)
-		a:move(px, py, true)
-		self:move(gx, gy, true)
-		a:move(px, py, true)
-		game.level.map:particleEmitter(px, py, 1, "teleport")
-		game.level.map:particleEmitter(gx, gy, 1, "teleport")
-
+		local a, id = rng.table(tgts)
+		local target = a
+		
+		if target:canBe("teleport") and self:canBe("teleport") then
+			-- first remove the target so the destination tile is empty
+			game.level.map:remove(target.x, target.y, Map.ACTOR)
+			local px, py 
+			px, py = self.x, self.y
+			if self:teleportRandom(a.x, a.y, 0) then
+				-- return the target at the casters old location
+				game.level.map(px, py, Map.ACTOR, target)
+				self.x, self.y, target.x, target.y = target.x, target.y, px, py
+				game.level.map:particleEmitter(target.x, target.y, 1, "temporal_teleport")
+				game.level.map:particleEmitter(self.x, self.y, 1, "temporal_teleport")
+				-- confuse them both
+				self:project(tg, target.x, target.y, DamageType.CONFUSION, { dur = t.getConfuseDuration(self, t), dam = t.getConfuseEfficency(self, t), })
+				self:project(tg, self.x, self.y, DamageType.CONFUSION, { dur = t.getConfuseDuration(self, t), dam = t.getConfuseEfficency(self, t),	})
+			else
+				-- return the target without effect
+				game.level.map(target.x, target.y, Map.ACTOR, target)
+				game.logSeen(self, "The spell fizzles!")
+			end
+		else
+			game.logSeen(target, "%s resists the swap!", target.name:capitalize())
 		end
+
+		game:playSoundNear(self, "talents/teleport")
 		return true
 	end,
 	info = function(self, t)
@@ -474,7 +492,7 @@ newTalent{
 	type_no_req = true,
 	getTargetCount = function(self, t) return 1 end,
 	getRadius = function(self, t) return math.ceil(self:getParadox()/100) end,
-	getDamage = function(self, t) return self:getParadox()/20 end,
+	getDamage = function(self, t) return getAnomalyDamage(self) end,
 	message = "@Source@ has caused a Gravity Spike.",
 	action = function(self, t)
 		local tgts = {}

game/modules/tome/data/talents/chronomancy/chronomancer.lua

@@ -25,16 +25,19 @@ newTalentType{ allow_random=true, no_silence=true, is_spell=true, type="chronoma
 newTalentType{ allow_random=true, no_silence=true, is_spell=true, type="chronomancy/matter", name = "matter", description = "Change and shape matter itself." }
 newTalentType{ allow_random=true, no_silence=true, is_spell=true, type="chronomancy/paradox", name = "paradox", description = "Create loopholes in the laws of spacetime." }
 newTalentType{ allow_random=true, no_silence=true, is_spell=true, type="chronomancy/speed-control", name = "Speed Control", description = "Control how fast objects and creatures move through spacetime." }
-newTalentType{ allow_random=true, no_silence=true, is_spell=true, type="chronomancy/temporal-archery", name = "Temporal Archery", description = "A blend of chronomancy and ranged combat." }
 newTalentType{ allow_random=true, no_silence=true, is_spell=true, type="chronomancy/temporal-combat", name = "Temporal Combat", description = "A blend of chronomancy and physical combat." }
 newTalentType{ allow_random=true, no_silence=true, is_spell=true, type="chronomancy/timeline-threading", name = "Timeline Threading", description = "Examine and alter the timelines that make up the spacetime continuum." }
 newTalentType{ allow_random=true, no_silence=true, is_spell=true, type="chronomancy/timetravel", name = "Time Travel", description = "Travel through time yourself or send your foes into the future.." }
 newTalentType{ allow_random=true, no_silence=true, is_spell=true, type="chronomancy/spacetime-folding", name = "Spacetime Folding", description = "Mastery of folding points in space." }
 newTalentType{ allow_random=true, no_silence=true, is_spell=true, type="chronomancy/spacetime-weaving", name = "Spacetime Weaving", generic = true, description = "Weave the threads of spacetime and correct the damage you've caused through your meddling." }
-newTalentType{ allow_random=true, no_silence=true, is_spell=true, type="chronomancy/other", name = "Other", generic = true, description = "Miscellaneous Chronomancy effects." }
+
+
+newTalentType{ no_silence=true, is_spell=true, type="chronomancy/temporal-archery", name = "Temporal Archery", description = "A blend of chronomancy and ranged combat." }
+newTalentType{ no_silence=true, is_spell=true, type="chronomancy/other", name = "Other", generic = true, description = "Miscellaneous Chronomancy effects." }
+
 
 -- Anomalies are not learnable but can occur instead of an intended spell when paradox gets to high.
-newTalentType{ allow_random=true, no_silence=true, is_spell=true, type="chronomancy/anomalies", name = "anomalies", description = "Spacetime anomalies that can randomly occur when paradox is to high." }
+newTalentType{ no_silence=true, is_spell=true, type="chronomancy/anomalies", name = "anomalies", description = "Spacetime anomalies that can randomly occur when paradox is to high." }
 
 -- Generic requires for chronomancy spells based on talent level
 chrono_req1 = {

game/modules/tome/data/talents/chronomancy/chronomancy.lua

@@ -69,19 +69,18 @@ newTalent{
 	getDuration = function(self, t) 
 		local duration = 1 + math.floor(self:getTalentLevel(t)/2)
 		if self:knowTalent(self.T_PARADOX_MASTERY) then
-			duration = 1 + math.floor((self:getTalentLevel(t)/2) + self:getTalentLevel(self.T_PARADOX_MASTERY)/2)
+			duration = 1 + math.floor((self:getTalentLevel(t)/2) + (self:getTalentLevel(self.T_PARADOX_MASTERY)/2))
 		end
 		
 		return duration
 	end,
 	getReduction = function(self, t)
-		local modifier = self:getWil()
+		local reduction = self:combatTalentStatDamage(t, "wil", 20, 400)
 		--check for Paradox Mastery
 		if self:knowTalent(self.T_PARADOX_MASTERY) then
-			modifier = modifier * (1 + (self:getTalentLevel(self.T_PARADOX_MASTERY)/10 or 0))
+			reduction = reduction * (1 + (self:getTalentLevel(self.T_PARADOX_MASTERY)/10 or 0))
 		end
-
-		local reduction = (20 + (modifier * self:getTalentLevel(t)/2))
+		
 		return reduction
 	end,
 	action = function(self, t)

game/modules/tome/data/talents/chronomancy/spacetime-folding.lua

@@ -62,11 +62,6 @@ newTalent{
 		local tx, ty, target = self:getTarget(tg)
 		if not tx or not ty then return nil end
 		tx, ty = checkBackfire(self, tx, ty, t.paradox)
-		if core.fov.distance(self.x, self.y, tx, ty) > self:getTalentRange(t) then return nil end
-				if not self:canBe("teleport") or game.level.map.attrs(tx, ty, "no_teleport") or game.level.map.attrs(self.x, self.y, "no_teleport") then
-			game.logSeen(self, "The spell fizzles!")
-			return true
-		end
 		if tx then
 			local _ _, tx, ty = self:canProject(tg, tx, ty)
 			if tx then
@@ -74,40 +69,34 @@ newTalent{
 				if not target then return nil end
 			end
 		end
-
+		
 		-- checks for spacetime mastery hit bonus
 		local power = self:combatSpellpower()
 		if self:knowTalent(self.T_SPACETIME_MASTERY) then
-			power = self:combatSpellpower() * 1 + (self:getTalentLevel(self.T_SPACETIME_MASTERY)/10)
+			power = self:combatSpellpower() * (1 + self:getTalentLevel(self.T_SPACETIME_MASTERY)/10)
 		end
-
-		if target:canBe("teleport") then
-			local hit = self:checkHit(power, target:combatSpellResist() + (target:attr("continuum_destabilization") or 0))
-			if not hit then
-				game.logSeen(target, "The spell fizzles!")
-				return true
+		
+		if target:canBe("teleport") and self:checkHit(power, target:combatSpellResist() + (target:attr("continuum_destabilization") or 0)) then
+			-- first remove the target so the destination tile is empty
+			game.level.map:remove(target.x, target.y, Map.ACTOR)
+			local px, py 
+			px, py = self.x, self.y
+			if self:teleportRandom(tx, ty, 0) then
+				-- return the target at the casters old location
+				game.level.map(px, py, Map.ACTOR, target)
+				self.x, self.y, target.x, target.y = target.x, target.y, px, py
+				game.level.map:particleEmitter(target.x, target.y, 1, "temporal_teleport")
+				game.level.map:particleEmitter(self.x, self.y, 1, "temporal_teleport")
+				target:setEffect(target.EFF_CONTINUUM_DESTABILIZATION, 100, {power=self:combatSpellpower(0.3)})
+				-- confuse them
+				self:project(tg, target.x, target.y, DamageType.CONFUSION, { dur = t.getConfuseDuration(self, t), dam = t.getConfuseEfficency(self, t),	})
 			else
-				self:project(tg, tx, ty, DamageType.CONFUSION, {
-					dur = t.getConfuseDuration(self, t),
-					dam = t.getConfuseEfficency(self, t),
-				})
+				-- return the target without effect
+				game.level.map(target.x, target.y, Map.ACTOR, target)
+				game.logSeen(self, "The spell fizzles!")
 			end
-		end
-
-		-- Annoy them!
-		if target ~= self and target:reactionToward(self) < 0 then target:setTarget(self) end
-
-		game.level.map:remove(self.x, self.y, Map.ACTOR)
-		game.level.map:remove(target.x, target.y, Map.ACTOR)
-		game.level.map(self.x, self.y, Map.ACTOR, target)
-		game.level.map(target.x, target.y, Map.ACTOR, self)
-		self.x, self.y, target.x, target.y = target.x, target.y, self.x, self.y
-		game.level.map:particleEmitter(target.x, target.y, 1, "temporal_teleport")
-		game.level.map:particleEmitter(self.x, self.y, 1, "temporal_teleport")
-
-
-		if target ~= self then
-			target:setEffect(target.EFF_CONTINUUM_DESTABILIZATION, 100, {power=self:combatSpellpower(0.3)})
+		else
+			game.logSeen(target, "%s resists the swap!", target.name:capitalize())
 		end
 
 		game:playSoundNear(self, "talents/teleport")
@@ -166,36 +155,38 @@ newTalent{
 		local tg = self:getTalentTarget(t)
 		local x, y = self:getTarget(tg)
 		if not x or not y then return nil end
+		if not self:hasLOS(x, y) or game.level.map:checkEntity(x, y, Map.TERRAIN, "block_move") then game.logSeen(self, "You can't move there.") return nil	end
 		x, y = checkBackfire(self, x, y, t.paradox)
 		local _ _, x, y = self:canProject(tg, x, y)
-
-		if not self:canBe("teleport") or game.level.map.attrs(x, y, "no_teleport") then
-			game.logSeen(self, "The spell fizzles!")
-			return true
-		end
-
-		if self:hasLOS(x, y) and not game.level.map:checkEntity(x, y, Map.TERRAIN, "block_move") then
+		
+		-- indirect fire after the teleport from the x, y to our old starting spot would be best here 
+		-- but checking for no_teleport we can make an educated guess rather or not the teleport will work
+		if not game.level.map.attrs(x, y, "no_teleport") then
+			local y = y
+			if game.level.data.no_teleport_south and y  > self.y then 
+				y = self.y
+			end
 			local dam = self:spellCrit(t.getDamage(self, t))
 			self:project(tg, x, y, DamageType.TEMPORALSTUN, dam)
 			game.level.map:particleEmitter(self.x, self.y, math.max(math.abs(x-self.x), math.abs(y-self.y)), "temporal_lightning", {tx=x-self.x, ty=y-self.y})
 			game:playSoundNear(self, "talents/lightning")
-			local tx, ty = util.findFreeGrid(x, y, 5, true, {[Map.ACTOR]=true})
-			if tx and ty then
-				self:move(tx, ty, true)
+		end
+		
+		-- since we're using a precise teleport we'll look for a free grid first
+		local tx, ty = util.findFreeGrid(x, y, 5, true, {[Map.ACTOR]=true})
+		if tx and ty then
+			if not self:teleportRandom(tx, ty, 0) then
+				game.logSeen(self, "The spell fizzles!")
 			end
-		else
-			game.logSeen(self, "You can't move there.")
-			return nil
 		end
-
+		
 		return true
 	end,
 	info = function(self, t)
 		local damage = t.getDamage(self, t)
-		local range = self:getTalentRange(t)
-		return ([[Violently fold the space between yourself and another point within a range of %d.  You move to the selected point and leave a temporal wake behind that stuns for 4 turns and inflicts %0.2f temporal damage to everything in the path.
+		return ([[Violently fold the space between yourself and another point within range.  You move to the target location and leave a temporal wake behind that stuns for 4 turns and inflicts %0.2f temporal damage to everything in the path.
 		The damage will scale with your Paradox and Spellpower and the range will increase with the talent level.]]):
-		format(range, damDesc(self, DamageType.TEMPORAL, damage))
+		format(damDesc(self, DamageType.TEMPORAL, damage))
 	end,
 }
 
@@ -235,4 +226,3 @@ newTalent{
 		format (damage*100)
 	end,
 }]=]
-

game/modules/tome/data/talents/chronomancy/spacetime-weaving.lua

@@ -39,30 +39,28 @@ newTalent{
 	direct_hit = true,
 	action = function(self, t)
 		local tg = self:getTalentTarget(t)
-		local x, y, target = self:getTarget(tg)
+		local x, y = self:getTarget(tg)
 		if not x or not y then return nil end
+		if not self:hasLOS(x, y) and self:getTalentLevel(t) < 4 then
+			game.logSeen(self, "You do not have line of sight.")
+			return nil
+		end
 		x, y = checkBackfire(self, x, y, t.paradox)
 		local __, x, y = self:canProject(tg, x, y)
-		
-		if not self:canBe("teleport") or game.level.map.attrs(x, y, "no_teleport") then
-			game.logSeen(self, "The spell fizzles!")
-			return true
-		end
 	
-		if not game.level.map:checkEntity(x, y, Map.TERRAIN, "block_move") then
-			local tx, ty = util.findFreeGrid(x, y, 5, true, {[Map.ACTOR]=true})
-			if tx and ty then
-				self:move(tx, ty, true)
+		game.level.map:particleEmitter(self.x, self.y, 1, "temporal_teleport")
+		
+		-- since we're using a precise teleport we'll look for a free grid first
+		local tx, ty = util.findFreeGrid(x, y, 5, true, {[Map.ACTOR]=true})
+		if tx and ty then
+			if not self:teleportRandom(tx, ty, 0) then
+				game.logSeen(self, "The spell fizzles!")
 			end
-			game.level.map:particleEmitter(self.x, self.y, 1, "temporal_teleport")
-			self:move(tx, ty, true)
-			game.level.map:particleEmitter(self.x, self.y, 1, "temporal_teleport")
-			game:playSoundNear(self, "talents/teleport")
-		else
-			game.logSeen(self, "You cannot move there.")
-			return nil
 		end
 		
+		game.level.map:particleEmitter(self.x, self.y, 1, "temporal_teleport")
+		game:playSoundNear(self, "talents/teleport")
+		
 		return true
 	end,
 	info = function(self, t)
@@ -94,37 +92,36 @@ newTalent{
 		local tg = self:getTalentTarget(t)
 		local actors = {}
 		
+		--checks for spacetime mastery hit bonus
+		local power = self:combatSpellpower()
+		if self:knowTalent(self.T_SPACETIME_MASTERY) then
+			power = self:combatSpellpower() * (1 + self:getTalentLevel(self.T_SPACETIME_MASTERY)/10)
+		end
+		
 		self:project(tg, self.x, self.y, function(px, py)
 			local target = game.level.map(px, py, Map.ACTOR)
 			if not target or target == self then return end
-			
-			--checks for spacetime mastery hit bonus
-			local power = self:combatSpellpower()
-			if self:knowTalent(self.T_SPACETIME_MASTERY) then
-				power = self:combatSpellpower() * 1 + (self:getTalentLevel(self.T_SPACETIME_MASTERY)/10)
-			end
-			
-			if target:canBe("teleport") then
-				local hit = self:checkHit(power, target:combatSpellResist() + (target:attr("continuum_destabilization") or 0))
-				if not hit then	
-					game.logSeen(target, "%s resists the banishment!", target.name:capitalize())
-					return
-				end
-			else 
+			if self:checkHit(power, target:combatSpellResist() + (target:attr("continuum_destabilization") or 0)) and target:canBe("teleport") then
+				actors[#actors+1] = target
+			else
 				game.logSeen(target, "%s resists the banishment!", target.name:capitalize())
-				return
 			end
-			
-			actors[#actors+1] = target
 		end)
 
+		local do_fizzle = false
 		for i, a in ipairs(actors) do
 			game.level.map:particleEmitter(a.x, a.y, 1, "teleport")
-			a:teleportRandom(a.x, a.y, self:getTalentRadius(t) * 4, self:getTalentRadius(t) * 2)
+			if not a:teleportRandom(a.x, a.y, self:getTalentRadius(t) * 4, self:getTalentRadius(t) * 2) then
+				do_fizzle = true
+			end
 			a:setEffect(a.EFF_CONTINUUM_DESTABILIZATION, 100, {power=self:combatSpellpower(0.3)})
 			game.level.map:particleEmitter(a.x, a.y, 1, "teleport")
 		end
 		
+		if do_fizzle == true then
+			game.logSeen(self, "The spell fizzles!")
+		end
+		
 		game.level.map:particleEmitter(self.x, self.y, tg.radius, "ball_teleport", {radius=tg.radius})
 		game:playSoundNear(self, "talents/teleport")
 		
@@ -162,13 +159,8 @@ newTalent{
 		if not entrance_x or not entrance_y then return nil end
 		local _ _, entrance_x, entrance_y = self:canProject(tg, entrance_x, entrance_y)
 		local trap = game.level.map(entrance_x, entrance_y, engine.Map.TRAP)
-		if trap then
-			game.logPlayer(self, "You can't place a wormhole entrance on a trap.")
-		return end
-		if game.level.map.attrs(entrance_x, entrance_y, "no_teleport") or game.level.map:checkEntity(entrance_x, entrance_y, Map.TERRAIN, "block_move") then
-			game.logPlayer(self, "You cannot place a wormhole here.")
-			return false
-		end
+		if trap or game.level.map:checkEntity(entrance_x, entrance_y, Map.TERRAIN, "block_move") then game.logPlayer(self, "You can't place a wormhole entrance here.") return end
+
 		-- Finding the exit location
 		-- First, find the center possible exit locations
 		local x, y, radius, minimum_distance
@@ -180,55 +172,69 @@ newTalent{
 			if not x then return nil end
 			-- See if we can actually project to the selected location
 			if not self:canProject(tg, x, y) then
-				game.logPlayer(self, "Pick a valid location")
+				game.logPlayer(self, "Pick a valid location.")
 				return false
 			end
 		else
 			x, y = self.x, self.y
-			radius = 15
+			radius = self:getTalentRange(t)
 			minimum_distance = 10
 		end
 		-- Second, select one of the possible exit locations
 		local poss = {}
-			for i = x - radius, x + radius do
-				for j = y - radius, y + radius do
-					if game.level.map:isBound(i, j) and
-						core.fov.distance(x, y, i, j) <= radius and
-						core.fov.distance(x, y, i, j) >= minimum_distance and
-						self:canMove(i, j) and not game.level.map.attrs(i, j, "no_teleport") and not game.level.map(i, j, engine.Map.TRAP) then
-						poss[#poss+1] = {i,j}
-					end
+		for i = x - radius, x + radius do
+			for j = y - radius, y + radius do
+				if game.level.map:isBound(i, j) and
+					core.fov.distance(x, y, i, j) <= radius and
+					core.fov.distance(x, y, i, j) >= minimum_distance and
+					self:canMove(i, j) and not game.level.map(i, j, engine.Map.TRAP) then
+					poss[#poss+1] = {i,j}
 				end
 			end
-			if #poss == 0 then
-				game.logPlayer(self, "No exit location could be found.")
-			return false end
-			local pos = poss[rng.range(1, #poss)]
-			exit_x, exit_y = pos[1], pos[2]
+		end
+		if #poss == 0 then game.logPlayer(self, "No exit location could be found.")	return false end
+		local pos = poss[rng.range(1, #poss)]
+		exit_x, exit_y = pos[1], pos[2]
 		print("[[wormhole]] entrance ", entrance_x, " :: ", entrance_y)
 		print("[[wormhole]] exit ", exit_x, " :: ", exit_y)
+		
+		--checks for spacetime mastery hit bonus
+		local power = self:combatSpellpower()
+		if self:knowTalent(self.T_SPACETIME_MASTERY) then
+			power = self:combatSpellpower() * (1 + self:getTalentLevel(self.T_SPACETIME_MASTERY)/10)
+		end
+		
 		-- Adding the entrance wormhole
 		local entrance = mod.class.Trap.new{
 			name = "wormhole",
 			type = "annoy", subtype="teleport", id_by_type=true, unided_name = "trap",
 			image = "terrain/wormhole.png",
 			display = '&', color_r=255, color_g=255, color_b=255, back_color=colors.STEEL_BLUE,
-			message = "@Target@ moves through the wormhole.",
+			message = "@Target@ moves onto the wormhole.",
+			temporary = t.getDuration(self, t),
+			x = entrance_x, y = entrance_y,
+			canAct = false,
+			energy = {value=0},
+			disarm = function(self, x, y, who) return false end,
+			check_hit = power,
+			destabilization_power = self:combatSpellpower(0.3),
+			summoned_by = self, -- "summoner" is immune to it's own traps
 			triggered = function(self, x, y, who)
-				local tx, ty = util.findFreeGrid(self.dest.x, self.dest.y, 5, true, {[engine.Map.ACTOR]=true})
-				if not tx or not who:canBe("teleport") or game.level.map.attrs(tx, ty, "no_teleport") then
-					game.logPlayer(who, "You try to enter the wormhole but a violent force pushes you back.")
-					return true
+				if who:checkHit(self.check_hit, who:combatSpellResist(), 0, 95, 15) and who:canBe("teleport") or who == self.summoned_by then
+					-- since we're using a precise teleport we'll look for a free grid first
+					local tx, ty = util.findFreeGrid(self.dest.x, self.dest.y, 5, true, {[Map.ACTOR]=true})
+					if tx and ty then
+						if not who:teleportRandom(tx, ty, 0) then
+							game.logSeen(who, "%s tries to enter the wormhole but a violent force pushes it back.", who.name:capitalize())
+						elseif who ~= self.summoned_by then
+							who:setEffect(who.EFF_CONTINUUM_DESTABILIZATION, 100, {power=self.destabilization_power})
+						end
+					end
 				else
-					who:move(tx, ty, true)
+					game.logSeen(who, "%s ignores the wormhole.", who.name:capitalize())
 				end
 				return true
 			end,
-			disarm = function(self, x, y, who) return false end,
-			temporary = t.getDuration(self, t),
-			x = entrance_x, y = entrance_y,
-			canAct = false,
-			energy = {value=0},
 			act = function(self)
 				self:useEnergy()
 				self.temporary = self.temporary - 1
@@ -245,6 +251,7 @@ newTalent{
 		game.zone:addEntity(game.level, entrance, "trap", entrance_x, entrance_y)
 		game.level.map:particleEmitter(entrance_x, entrance_y, 1, "teleport")
 		game:playSoundNear(self, "talents/heal")
+		
 		-- Adding the exit wormhole
 		local exit = entrance:clone()
 		exit.x = exit_x
@@ -254,16 +261,18 @@ newTalent{
 		exit:setKnown(self, true)
 		game.zone:addEntity(game.level, exit, "trap", exit_x, exit_y)
 		game.level.map:particleEmitter(exit_x, exit_y, 1, "teleport")
+		
 		-- Linking the wormholes
 		entrance.dest = exit
 		exit.dest = entrance
+		
 		game.logSeen(self, "%s folds the space between two points.", self.name)
 		return true
 	end,
 	info = function(self, t)
 		local duration = t.getDuration(self, t)
 		local radius = self:getTalentRadius(t)
-		return ([[You fold the space between yourself and another point, allowing travel back and forth between them for the next %d turns.
+		return ([[You fold the space between yourself and a random point within range, creating a pair of wormholes.  Any creature stepping on either wormhole will be teleported to the other.  The wormholes will last %d turns.
 		At level 4 you may choose the exit location target area (radius %d).  The duration will scale with your Paradox.
 		This spell takes no time to cast.]])
 		:format(duration, radius)
@@ -294,7 +303,7 @@ newTalent{
 		local cooldown = self:getTalentLevelRaw(t)
 		local wormhole = self:getTalentLevelRaw(t) * 2
 		local power = self:getTalentLevel(t) * 10
-		return ([[Your mastery of spacetime reduces the cooldown of banish, dimensional step, swap, and temporal wake by %d and the cooldown of wormhole by %d.  Also improves your chances of hitting targets with effects that may cause continuum destablization (Banish, Time Skip, etc.) as well as your chance of overcoming continuum destabilization by %d%%.]]):
+		return ([[Your mastery of spacetime reduces the cooldown of banish, dimensional step, swap, and temporal wake by %d and the cooldown of wormhole by %d.  Also improves your chances of hitting targets with chronomancy effects that may cause continuum destablization (Banish, Time Skip, etc.) as well as your chance of overcoming continuum destabilization by %d%%.]]):
 		format(cooldown, wormhole, power)
 	end,
 }
\ No newline at end of file

game/modules/tome/data/talents/chronomancy/timetravel.lua

@@ -45,7 +45,7 @@ newTalent{
 		-- checks for spacetime mastery hit bonus
 		local power = self:combatSpellpower()
 		if self:knowTalent(self.T_SPACETIME_MASTERY) then
-			power = self:combatSpellpower() * 1 + (self:getTalentLevel(self.T_SPACETIME_MASTERY)/10)
+			power = self:combatSpellpower() * (1 + self:getTalentLevel(self.T_SPACETIME_MASTERY)/10)
 		end
 		
 		if target then