-- ToME - Tales of Maj'Eyal
-- Copyright (C) 2009 - 2014 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

require "engine.class"
local Actor = require "engine.Actor"
require "engine.Autolevel"
require "engine.interface.ActorInventory"
require "engine.interface.ActorTemporaryEffects"
require "mod.class.interface.ActorLife"
require "engine.interface.ActorProject"
require "engine.interface.ActorLevel"
require "engine.interface.ActorStats"
require "engine.interface.ActorTalents"
require "engine.interface.ActorResource"
require "engine.interface.BloodyDeath"
require "engine.interface.ActorFOV"
require "mod.class.interface.ActorPartyQuest"
require "mod.class.interface.Combat"
require "mod.class.interface.Archery"
require "mod.class.interface.ActorInscriptions"
local Faction = require "engine.Faction"
local Dialog = require "engine.ui.Dialog"
local Map = require "engine.Map"
local Chat = require "engine.Chat"
local DamageType = require "engine.DamageType"

module(..., package.seeall, class.inherit(
	-- a ToME actor is a complex beast it uses may interfaces
	engine.Actor,
	engine.interface.ActorInventory,
	engine.interface.ActorTemporaryEffects,
	mod.class.interface.ActorLife,
	engine.interface.ActorProject,
	engine.interface.ActorLevel,
	engine.interface.ActorStats,
	engine.interface.ActorTalents,
	engine.interface.ActorResource,
	engine.interface.BloodyDeath,
	engine.interface.ActorFOV,
	mod.class.interface.ActorPartyQuest,
	mod.class.interface.ActorInscriptions,
	mod.class.interface.Combat,
	mod.class.interface.Archery
))

-- Dont save the can_see_cache
_M._no_save_fields.can_see_cache = true

-- Activate fast regen computing
_M._no_save_fields.regenResourcesFast = true

-- Use distance maps
_M.__do_distance_map = true

_M.__is_actor = true

_M.stats_per_level = 3

-- Speeds are multiplicative, not additive
_M.temporary_values_conf.global_speed_add = "newest"
_M.temporary_values_conf.movement_speed = "add" -- Prevent excessive movement speed compounding
_M.temporary_values_conf.combat_physspeed = "add" -- Prevent excessive attack speed compounding
_M.temporary_values_conf.combat_spellspeed = "add" -- Prevent excessive spell speed compounding
_M.temporary_values_conf.combat_mindspeed = "add" -- Prevent excessive mind speed compounding

-- Damage cap takes the lowest
_M.temporary_values_conf.flat_damage_cap = "lowest"

-- Damage redirection takes last
_M.temporary_values_conf.force_use_resist = "last"
_M.temporary_values_conf.force_use_resist_percent = "last"
_M.temporary_values_conf.all_damage_convert = "last"
_M.temporary_values_conf.all_damage_convert_percent = "last"

-- AI
_M.temporary_values_conf.ai_move = "last"

_M.projectile_class = "mod.class.Projectile"

function _M:init(t, no_default)
	-- Define some basic combat stats
	self.energyBase = 0

	self.combat_def = 0
	self.combat_armor = 0
	self.combat_armor_hardiness = 0
	self.combat_atk = 0
	self.combat_apr = 0
	self.combat_dam = 0
	self.global_speed = 1
	self.global_speed_base = 1
	self.global_speed_add = 0
	self.movement_speed = 1
	self.combat_physcrit = 0
	self.combat_physspeed = 1
	self.combat_spellspeed = 1
	self.combat_mindspeed = 1
	self.combat_spellcrit = 0
	self.combat_spellpower = 0
	self.combat_mindpower = 0
	self.combat_mindcrit = 0

	self.combat_physresist = 0
	self.combat_spellresist = 0
	self.combat_mentalresist = 0

	t.old_life = 0

	self.fatigue = 0

	self.spell_cooldown_reduction = 0

	self.unused_stats = self.unused_stats or 3
	self.unused_talents = self.unused_talents or 2
	self.unused_generics = self.unused_generics or 1
	self.unused_talents_types = self.unused_talents_types or 0
	self.unused_prodigies = self.unused_prodigies or 0

	t.healing_factor = t.healing_factor or 1

	t.sight = t.sight or 10

	t.resource_pool_refs = t.resource_pool_refs or {}

	t.lite = t.lite or 0

	t.size_category = t.size_category or 3
	t.rank = t.rank or 2

	t.life_rating = t.life_rating or 10
	t.mana_rating = t.mana_rating or 4
	t.vim_rating = t.vim_rating or 4
	t.stamina_rating = t.stamina_rating or 3
	t.positive_negative_rating = t.positive_negative_rating or 3
	t.psi_rating = t.psi_rating or 0
	t.inc_resource_multi = t.inc_resource_multi or {}

	t.esp = t.esp or {}
	t.esp_range = t.esp_range or 10

	t.talent_cd_reduction = t.talent_cd_reduction or {}

	t.on_melee_hit = t.on_melee_hit or {}
	t.melee_project = t.melee_project or {}
	t.ranged_project = t.ranged_project or {}
	t.can_pass = t.can_pass or {}
	t.move_project = t.move_project or {}
	t.can_breath = t.can_breath or {}

	t.ai_tactic = t.ai_tactic or {}

	-- Resistances
	t.resists = t.resists or {}
	t.resists_cap = t.resists_cap or { all = 100 }
	t.resists_pen = t.resists_pen or {}
	t.resists_self = t.resists_self or {}
	t.resists_actor_type = t.resists_actor_type or {}
	t.resists_cap_actor_type = 70

	-- Absorbs a percentage of damage
	t.damage_affinity = t.damage_affinity or {}

	-- % Increase damage
	t.inc_damage = t.inc_damage or {}
	t.inc_damage_actor_type = t.inc_damage_actor_type or {}

	t.flat_damage_armor = t.flat_damage_armor or {}
	t.flat_damage_cap = t.flat_damage_cap or {}

	-- Default regen
	t.air_regen = t.air_regen or 3
	t.mana_regen = t.mana_regen or 0.5
	t.stamina_regen = t.stamina_regen or 0.3 -- Stamina regens slower than mana
	t.life_regen = t.life_regen or 0.25 -- Life regen real slow
	t.equilibrium_regen = t.equilibrium_regen or 0 -- Equilibrium does not regen
	t.vim_regen = t.vim_regen or 0 -- Vim does not regen
	t.positive_regen = t.positive_regen or -0.2 -- Positive energy slowly decays
	t.negative_regen = t.negative_regen or -0.2 -- Positive energy slowly decays
	t.positive_regen_ref = t.positive_regen_ref or 0.2
	t.negative_regen_ref = t.negative_regen_ref or 0.2
	t.paradox_regen = t.paradox_regen or 0 -- Paradox does not regen
	t.psi_regen = t.psi_regen or 0.2 -- Energy regens slowly
	t.hate_regen = t.hate_regen or 0 -- Hate does not regen
	t.soul_regen = t.soul_regen or 0 -- Souls does not regen

	t.max_positive = t.max_positive or 50
	t.max_negative = t.max_negative or 50
	t.positive = t.positive or 0
	t.negative = t.negative or 0

	t.soul = t.soul or 1

	t.max_hate = t.max_hate or 100
	t.hate = t.hate or 100
	t.baseline_hate = t.baseline_hate or 50 -- below this level hate loss stops
	t.hate_per_kill = t.hate_per_kill or 8
	t.default_hate_per_kill = t.hate_per_kill

	t.equilibrium = t.equilibrium or 0

	t.paradox = t.paradox or 150

	t.money = t.money or 0

	self.turn_procs = {}

	engine.Actor.init(self, t, no_default)
	engine.interface.ActorInventory.init(self, t)
	engine.interface.ActorTemporaryEffects.init(self, t)
	mod.class.interface.ActorLife.init(self, t)
	engine.interface.ActorProject.init(self, t)
	engine.interface.ActorTalents.init(self, t)
	engine.interface.ActorResource.init(self, t)
	engine.interface.ActorStats.init(self, t)
	engine.interface.ActorLevel.init(self, t)
	engine.interface.ActorFOV.init(self, t)
	mod.class.interface.ActorInscriptions.init(self, t)

	-- Default melee barehanded damage
	self.combat = self.combat or {
		dam=1,
		atk=1, apr=0,
		physcrit=0,
		physspeed =1,
		dammod = { str=1 },
		damrange=1.1,
		talented = "unarmed",
	}
	-- Insures we have certain values for gloves to modify
	self.combat.damrange = self.combat.damrange or 1.1
	self.combat.physspeed = self.combat.physspeed or 1
	self.combat.dammod = self.combat.dammod or {str=0.6}

	self.talents[self.T_ATTACK] = self.talents[self.T_ATTACK] or 1

	self:resetCanSeeCache()
	self:recomputeGlobalSpeed()
	self:recomputeRegenResources()
end

function _M:loaded()
	engine.Actor.loaded(self)
	self:recomputeRegenResources()
end

function _M:onEntityMerge(a)
	-- Remove stats to make new stats work
	for i, s in ipairs(_M.stats_def) do
		if a.stats[i] then
			a.stats[s.short_name], a.stats[i] = a.stats[i], nil
		end
	end
end

--- Try to remove all "un-needed" effects, fields, ... for a clean export
function _M:stripForExport()
	self.distance_map = {}
	self.fov = {actors={}, actors_dist={}}
	self.running_fov = nil
	self.running_prev = nil
	self.killedBy = nil
	self.quests = {}
	self.dialog = nil
	self:setTarget(nil)

	-- Disable all sustains, remove all effects
	local list = {}
	for eff_id, _ in pairs(self.tmp) do list[#list+1] = eff_id end
	for _, eff_id in ipairs(list) do self:removeEffect(eff_id, true, true) end

	list = {}
	for tid, act in pairs(self.sustain_talents) do if act then list[#list+1] = tid end end
	while #list > 0 do
		local eff = rng.tableRemove(list)
		self:forceUseTalent(eff, {silent=true, ignore_energy=true, no_equilibrium_fail=true, no_paradox_fail=true, save_cleanup=true})
	end
end

-- Dummy
function _M:runStop() end
function _M:restStop() end

function _M:useEnergy(val)
	engine.Actor.useEnergy(self, val)

	-- handle stalking
	local effStalker = self:hasEffect(self.EFF_STALKER)
	if effStalker then
		if effStalker.hit then
			-- consecutive hit on stalkee..add hate then bonus
			local t = self:getTalentFromId(self.T_STALK)
			self:incHate(t.getHitHateChange(self, t, effStalker.bonus))
			effStalker.bonus = math.min(3, (effStalker.bonus or 1) + 1)
			effStalker.hit = false
		else
			 -- no consecutive hit on stalkee..remove bonus
			effStalker.bonus = math.max(1, (effStalker.bonus or 1) - 1)
		end
	elseif self:isTalentActive(self.T_STALK) then
		local stalk = self:isTalentActive(self.T_STALK)
		if stalk.hit and stalk.hit_target and not stalk.hit_target.dead then
			stalk.hit_turns = (stalk.hit_turns or 0) + 1
			stalk.hit = false

			if stalk.hit_turns > 1 then
				-- multiple hits begin stalking
				local t = self:getTalentFromId(self.T_STALK)
				t.doStalk(self, t, stalk.hit_target)
				stalk.hit_turns = 0
				stalk.hit_target = nil
			end
		else
			stalk.hit = false
			stalk.hit_target = nil
			stalk.hit_turns = 0
		end
	end

	-- Curse of Shrouds: turn shroud of passing on or off
	local eff = self:hasEffect(self.EFF_CURSE_OF_SHROUDS)
	if eff then self.tempeffect_def[self.EFF_CURSE_OF_SHROUDS].doShroudOfPassing(self, eff) end

	-- Do not fire those talents if this is not turn's end
	if self:enoughEnergy() or game.zone.wilderness then return end
end

-- Called at the start of a turn before the actor chooses their action, energy is handled, etc
function _M:actBase()
	-- Stupid sanity check that is actualy useful
	if self.life ~= self.life then self.life = self.max_life end
	if self.life_regen ~= self.life_regen then self.life_regen = 1 end

	-- Solipsism speed effects; calculated before the actor gets energy
	local current_psi_percentage = self:getPsi() / self:getMaxPsi()
	local clarity
	if self:knowTalent(self.T_CLARITY) then
		clarity = self:callTalent(self.T_CLARITY,"getClarityThreshold")
	end
	local eff_solipsis = math.min(self:attr("solipsism_threshold") or 0,clarity or 1) -- effective solipsism_threshold
	if self:attr("solipsism_threshold") and current_psi_percentage < eff_solipsis then
		local solipsism_power = eff_solipsis - current_psi_percentage
		if self:hasEffect(self.EFF_CLARITY) then
			self:removeEffect(self.EFF_CLARITY)
		end
		local p = self:hasEffect(self.EFF_SOLIPSISM)
		if (p and p.power ~= solipsism_power) or not p then
			self:setEffect(self.EFF_SOLIPSISM, 1, {power = solipsism_power})
		end
	elseif clarity and current_psi_percentage > clarity then
		local clarity_power = math.min(1, current_psi_percentage - clarity)
		if self:hasEffect(self.EFF_SOLIPSISM) then
			self:removeEffect(self.EFF_SOLIPSISM)
		end
		local p = self:hasEffect(self.EFF_CLARITY)
		if (p and p.power ~= clarity_power) or not p then
			self:setEffect(self.EFF_CLARITY, 1, {power = math.min(1, current_psi_percentage - clarity)})
		end
	elseif self:hasEffect(self.EFF_SOLIPSISM) then
		self:removeEffect(self.EFF_SOLIPSISM)
	elseif self:hasEffect(self.EFF_CLARITY) then
		self:removeEffect(self.EFF_CLARITY)
	end

	self.energyBase = self.energyBase - game.energy_to_act

	if self:attr("no_timeflow") then
		-- Compute timed effects that can happen even in timeless mode
		self:timedEffects(function(e, p) if e.tick_on_timeless then return true end end)
		return
	end

	if self.__use_build_order then
		self:useBuildOrder()
	end

	-- Break darkest light
	if self:isTalentActive (self.T_DARKEST_LIGHT) and self.positive > self.negative then
		self:forceUseTalent(self.T_DARKEST_LIGHT, {ignore_energy=true})
		game.logSeen(self, "%s's darkness can no longer hold back the light!", self.name:capitalize())
	end
	-- Break mind links
	if self:isTalentActive(self.T_MIND_LINK) then
		local p = self:isTalentActive(self.T_MIND_LINK)
		if not p.target or p.target.dead or not p.target:hasEffect(p.target.EFF_MIND_LINK_TARGET) or not game.level:hasEntity(p.target) then
			self:forceUseTalent(self.T_MIND_LINK, {ignore_energy=true})
		end
	end

	-- Cooldown talents
	if not self:attr("no_talents_cooldown") then self:cooldownTalents() end
	-- Regen resources
	self:regenLife()
	self:regenAmmo()
	if self:knowTalent(self.T_UNNATURAL_BODY) then
		local t = self:getTalentFromId(self.T_UNNATURAL_BODY)
		t.do_regenLife(self, t)
	end

	if self.resting and self.reload then
		local reloaded = self:reload()
		if not reloaded and self.reloadQS then
			self:reloadQS()
		end
	end

	-- update hate regen based on calculated decay rate
	if self:knowTalent(self.T_HATE_POOL) then
		local t = self:getTalentFromId(self.T_HATE_POOL)
		t.updateRegen(self, t)
	end

	if self:attr("positive_at_rest") then
		local v = self.positive_at_rest * self.max_positive / 100
		if self:getPositive() > v or self:attr("positive_at_rest_disable") then self.positive_regen = -self.positive_regen_ref
		elseif self:getPositive() < v then self.positive_regen = self.positive_regen_ref + (self.positive_regen_ref_mod or 0)
		end
	end
	if self:attr("negative_at_rest") then
		local v = self.negative_at_rest * self.max_negative / 100
		if self:getNegative() > v or self:attr("negative_at_rest_disable")  then self.negative_regen = -self.negative_regen_ref
		elseif self:getNegative() < v then self.negative_regen = self.negative_regen_ref + (self.negative_regen_ref_mod or 0)
		end
	end

	self:regenResources()

	-- update psionic feedback
	if self:getFeedback() > 0 then
		local decay = self:getFeedbackDecay()
		if self:knowTalent(self.T_BIOFEEDBACK) then
			local t = self:getTalentFromId(self.T_BIOFEEDBACK)
			self:heal(decay * t.getHealRatio(self, t), self)
		end
		if self:hasEffect(self.EFF_FEEDBACK_LOOP) then
			self:incFeedback(decay)
		else
			self:incFeedback(-decay)
		end
	end

	if self:knowTalent(self.T_GESTURE_OF_GUARDING) then self:setEffect(self.EFF_GESTURE_OF_GUARDING,1,{}) end
	if self:knowTalent(self.T_DUAL_WEAPON_DEFENSE) then self:setEffect(self.EFF_DUAL_WEAPON_DEFENSE,1,{}) end
	if self:knowTalent(self.T_COUNTER_ATTACK) then self:setEffect(self.EFF_COUNTER_ATTACKING,1,{}) end 
	if self:knowTalent(self.T_DEFENSIVE_THROW) then self:setEffect(self.EFF_DEFENSIVE_GRAPPLING,1,{}) end

	-- Compute timed effects
	self:timedEffects()

	-- Handle thunderstorm, even if the actor is stunned or incapacitated it still works
	if not game.zone.wilderness and not self.dead then
		if self:isTalentActive(self.T_THUNDERSTORM) then
			local t = self:getTalentFromId(self.T_THUNDERSTORM)
			t.do_storm(self, t)
		end
		if self:isTalentActive(self.T_BODY_OF_FIRE) then
			local t = self:getTalentFromId(self.T_BODY_OF_FIRE)
			t.do_fire(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:isTalentActive(self.T_BLOOD_FRENZY) then
			local t = self:getTalentFromId(self.T_BLOOD_FRENZY)
			t.do_turn(self, t)
		end
		if self:isTalentActive(self.T_TRUE_GRIT) then
			local t = self:getTalentFromId(self.T_TRUE_GRIT)
			t.do_turn(self, t)
		end
		-- this handles cursed gloom turn based effects
		if self:isTalentActive(self.T_GLOOM) then
			local t = self:getTalentFromId(self.T_GLOOM)
			t.do_gloom(self, t)
		end
		-- this handles cursed call shadows turn based effects
		if self:isTalentActive(self.T_CALL_SHADOWS) then
			local t = self:getTalentFromId(self.T_CALL_SHADOWS)
			t.do_callShadows(self, t)
		end
		-- this handles cursed deflection turn based effects
		if self:isTalentActive(self.T_DEFLECTION) then
			local t = self:getTalentFromId(self.T_DEFLECTION)
			t.do_act(self, t, self:isTalentActive(self.T_DEFLECTION))
		end
		-- this handles doomed unseen force turn based effects
		if self.unseenForce then
			local t = self:getTalentFromId(self.T_UNSEEN_FORCE)
			t.do_unseenForce(self, t)
		end
		-- Curse of Nightmares: Nightmare
		if not self.dead and self:hasEffect(self.EFF_CURSE_OF_NIGHTMARES) then
			local eff = self:hasEffect(self.EFF_CURSE_OF_NIGHTMARES)
			if eff.isHit then
				eff.isHit = false
				self.tempeffect_def[self.EFF_CURSE_OF_NIGHTMARES].doNightmare(self, eff)
			end
		end
		-- this handles Carbon Spike regrowth
		if self:isTalentActive(self.T_CARBON_SPIKES) then
			local t = self:getTalentFromId(self.T_CARBON_SPIKES)
			t.do_carbonRegrowth(self, t)
		end
		-- this handles conditioning talents
		if self:knowTalent(self.T_UNFLINCHING_RESOLVE) then
			local t = self:getTalentFromId(self.T_UNFLINCHING_RESOLVE)
			t.do_unflinching_resolve(self, t)
		end
		if self:isTalentActive(self.T_DAUNTING_PRESENCE) then
			local t = self:getTalentFromId(self.T_DAUNTING_PRESENCE)
			if self.life < t.getMinimumLife(self, t) then
				self:forceUseTalent(self.T_DAUNTING_PRESENCE, {ignore_energy=true})
			end
		end
		-- this handles Mind Storm
		if self:isTalentActive(self.T_MIND_STORM) then
			local t, p = self:getTalentFromId(self.T_MIND_STORM), self:isTalentActive(self.T_MIND_STORM)
			if self:getFeedback() >=5 or p.overcharge >=1 then
				t.doMindStorm(self, t, p)
			end
		end

		if self:isTalentActive(self.T_DREAMFORGE) then
			local t, p = self:getTalentFromId(self.T_DREAMFORGE), self:isTalentActive(self.T_DREAMFORGE)
			t.doForgeStrike(self, t, p)
		end

		local psiweapon = self:getInven("PSIONIC_FOCUS") and self:getInven("PSIONIC_FOCUS")[1]
		if (psiweapon and ( not psiweapon.combat or psiweapon.subtype == "mindstar" )) or not psiweapon then
			if self:isTalentActive(self.T_KINETIC_AURA) then
				local t = self:getTalentFromId(self.T_KINETIC_AURA)
				t.do_kineticaura(self, t)
			end
			if self:isTalentActive(self.T_THERMAL_AURA) then
				local t = self:getTalentFromId(self.T_THERMAL_AURA)
				t.do_thermalaura(self, t)
			end
			if self:isTalentActive(self.T_CHARGED_AURA) then
				local t = self:getTalentFromId(self.T_CHARGED_AURA)
				t.do_chargedaura(self, t)
			end
		end
			
		if self:isTalentActive(self.T_BEYOND_THE_FLESH) then
			local t = self:getTalentFromId(self.T_BEYOND_THE_FLESH)
			t.do_tkautoattack(self, t)
		end
		if self:hasEffect(self.EFF_MASTERFUL_TELEKINETIC_ARCHERY) then
			local t = self:getTalentFromId(self.T_MASTERFUL_TELEKINETIC_ARCHERY)
			t.do_tkautoshoot(self, t)
		end
		
		self:triggerHook{"Actor:actBase:Effects"}

		self:fireTalentCheck("callbackOnActBase")
	end

	-- Suffocate ?
	local air_level, air_condition = game.level.map:checkEntity(self.x, self.y, Map.TERRAIN, "air_level"), game.level.map:checkEntity(self.x, self.y, Map.TERRAIN, "air_condition")
	if air_level then
		if not air_condition or not self.can_breath[air_condition] or self.can_breath[air_condition] <= 0 then
			self:suffocate(-air_level, self, air_condition == "water" and "drowned to death" or nil)
		end
	end
end

function _M:act()
	if not engine.Actor.act(self) then return end

	self.changed = true
	self.turn_procs = {}

	-- If resources are too low, disable sustains
	if self.mana < 1 or self.stamina < 1 or self.psi < 1 or self.vim < 1 then
		for tid, _ in pairs(self.sustain_talents) do
			local t = self:getTalentFromId(tid)
			if (t.sustain_mana and self.mana < 1) or (t.sustain_stamina and self.stamina < 1 and not self:hasEffect(self.EFF_ADRENALINE_SURGE)) then
				self:forceUseTalent(tid, {ignore_energy=true})
			elseif (t.sustain_psi and self.psi < 1) and t.remove_on_zero then
				self:forceUseTalent(tid, {ignore_energy=true})
			elseif (t.sustain_vim and self.vim < 1) and t.remove_on_zero then
				self:forceUseTalent(tid, {ignore_energy=true})
			end
		end
	end

	-- clear grappling
	if self:hasEffect(self.EFF_GRAPPLING) and self.stamina < 1 and not self:hasEffect(self.EFF_ADRENALINE_SURGE) then
		self:removeEffect(self.EFF_GRAPPLING)
	end

	-- disable spell sustains
	if self:attr("spell_failure") then
		for tid, _ in pairs(self.sustain_talents) do
			local t = self:getTalentFromId(tid)
			if t.is_spell and rng.percent(self:attr("spell_failure")/10)then
				self:forceUseTalent(tid, {ignore_energy=true})
				if not silent then game.logSeen(self, "%s has been disrupted by #ORCHID#anti-magic forces#LAST#!", t.name) end
			end
		end
	end

	-- Conduit talent prevents all auras from cooling down
	if self:isTalentActive(self.T_CONDUIT) then
		local auras = self:isTalentActive(self.T_CONDUIT)
		if auras.k_aura_on then
			local t_kinetic_aura = self:getTalentFromId(self.T_KINETIC_AURA)
			self.talents_cd[self.T_KINETIC_AURA] = t_kinetic_aura.cooldown(self, t)
		end
		if auras.t_aura_on then
			local t_thermal_aura = self:getTalentFromId(self.T_THERMAL_AURA)
			self.talents_cd[self.T_THERMAL_AURA] = t_thermal_aura.cooldown(self, t)
		end
		if auras.c_aura_on then
			local t_charged_aura = self:getTalentFromId(self.T_CHARGED_AURA)
			self.talents_cd[self.T_CHARGED_AURA] = t_charged_aura.cooldown(self, t)
		end
	end

	if self:attr("paralyzed") then
		self.paralyzed_counter = (self.paralyzed_counter or 0) + (self:attr("stun_immune") or 0) * 100
		if self.paralyzed_counter < 100 then
			self.energy.value = 0
		else
			-- We are saved for this turn
			self.paralyzed_counter = self.paralyzed_counter - 100
			game.logSeen(self, "%s temporarily fights the paralyzation.", self.name:capitalize())
		end
	end
	if self:attr("stoned") then self.energy.value = 0 end
	if self:attr("dont_act") then self.energy.value = 0 end
	if self:attr("sleep") and not self:attr("lucid_dreamer") then self.energy.value = 0 end
	if self:attr("time_stun") then self.energy.value = 0 end
	if self:attr("time_prison") then self.energy.value = 0 end

	-- Regain natural balance?
	local equilibrium_level = game.level.map:checkEntity(self.x, self.y, Map.TERRAIN, "equilibrium_level")
	if equilibrium_level then self:incEquilibrium(equilibrium_level) end

	-- Do stuff to things standing in the fire
	game.level.map:checkEntity(self.x, self.y, Map.TERRAIN, "on_stand", self)

	-- Still enough energy to act ?
	if self.energy.value < game.energy_to_act then return false end

	-- Still not dead ?
	if self.dead then return false end

	-- Register life for this turn
	self.old_life = self.life

	-- Ok reset the seen cache
	self:resetCanSeeCache()

	if self.on_act then self:on_act() end

	if self.never_act then return false end

	if not game.zone.wilderness and not self:attr("confused") and not self:attr("terrified") then self:automaticTalents() end

	-- Compute bonuses based on actors in FOV
	if self:knowTalent(self.T_MILITANT_MIND) and not self:hasEffect(self.EFF_MILITANT_MIND) then
		local nb_foes = 0
		local act
		for i = 1, #self.fov.actors_dist do
			act = self.fov.actors_dist[i]
			if act and self:reactionToward(act) < 0 and self:canSee(act) then nb_foes = nb_foes + 1 end
		end
		if nb_foes > 1 then
			nb_foes = math.min(nb_foes, 5)
			self:setEffect(self.EFF_MILITANT_MIND, 4, {power=self:getTalentLevel(self.T_MILITANT_MIND) * nb_foes * 1.5})
		end
	end

	-- Beckon (chance to move actor and consume energy)
	if self:hasEffect(self.EFF_BECKONED) then
		self.tempeffect_def[self.EFF_BECKONED].do_act(self, self:hasEffect(self.EFF_BECKONED))
	end
	-- Paranoid (chance to attack anyone nearby)
	if self:hasEffect(self.EFF_PARANOID) then
		self.tempeffect_def[self.EFF_PARANOID].do_act(self, self:hasEffect(self.EFF_PARANOID))
	end
	-- Panicked (chance to run away)
	if self:hasEffect(self.EFF_PANICKED) then
		self.tempeffect_def[self.EFF_PANICKED].do_act(self, self:hasEffect(self.EFF_PANICKED))
	end

	self:fireTalentCheck("callbackOnAct")

	-- Still enough energy to act ?
	if self.energy.value < game.energy_to_act then return false end

	if self.sound_random and rng.chance(self.sound_random_chance or 15) then game:playSoundNear(self, self.sound_random) end

	-- Cauterize ?
	if self:hasEffect(self.EFF_CAUTERIZE) then
		local eff = self:hasEffect(self.EFF_CAUTERIZE)
		if eff.invulnerable then eff.invulnerable = nil end
	end

	return true
end

--- Follow a build order as possible
function _M:useBuildOrder()
	local b = self.__use_build_order

	if self.unused_stats > 0 then
		b.stats.i = b.stats.i or 1
		local nb = 0

		while self.unused_stats > 0 and nb < #b.stats+1 do
			local stat = b.stats[b.stats.i]

			if not (self:getStat(stat, nil, nil, true) >= self.level * 1.4 + 20) and
			   not (self:isStatMax(stat) or self:getStat(stat, nil, nil, true) >= 60 + math.max(0, (self.level - 50))) then
				self:incStat(stat, 1)
				self.unused_stats = self.unused_stats - 1
				nb = -1
				game.log("#VIOLET#Following build order %s; increasing %s by 1.", b.name, self.stats_def[stat].name)
			end
			b.stats.i = util.boundWrap(b.stats.i + 1, 1, #b.stats)
			nb = nb + 1
		end
	end

	if self.unused_talents_types > 0 then
		self.__increased_talent_types = self.__increased_talent_types or {}

		local learn = true
		while learn do
			learn = false
			for i, tt in ipairs(b.types) do
				if self.unused_talents_types > 0 and (self.__increased_talent_types[tt] or 0) == 0 then
					if not self:knowTalentType(tt) then
						self:learnTalentType(tt)
					else
						self.__increased_talent_types[tt] = (self.__increased_talent_types[tt] or 0) + 1
						self:setTalentTypeMastery(tt, self:getTalentTypeMastery(tt) + 0.2)
					end

					game.log("#VIOLET#Following build order %s; learning talent category %s.", b.name, tt)
					self.unused_talents_types = self.unused_talents_types - 1
					table.remove(b.types, i)
					learn = true
					break
				end
			end
		end
	end

	if self.unused_talents > 0 then
		local learn = true
		while learn do
			learn = false
			for i, td in ipairs(b.talents) do
				if td.kind == "class" then
					local t = self:getTalentFromId(td.tid)

					if self.unused_talents > 0 and self:canLearnTalent(t) and self:getTalentLevelRaw(t.id) < t.points then
						self:learnTalent(t.id, true)
						game.log("#VIOLET#Following build order %s; learning talent %s.", b.name, t.name)
						self.unused_talents = self.unused_talents - 1
						table.remove(b.talents, i)
						learn = true
						break
					end
				end
			end
		end
	end

	if self.unused_generics > 0 then
		local learn = true
		while learn do
			learn = false
			for i, td in ipairs(b.talents) do
				if td.kind == "generic" then
					local t = self:getTalentFromId(td.tid)

					if self.unused_generics > 0 and self:canLearnTalent(t) and self:getTalentLevelRaw(t.id) < t.points then
						self:learnTalent(t.id, true)
						game.log("#VIOLET#Following build order %s; learning talent %s.", b.name, t.name)
						self.unused_generics = self.unused_generics - 1
						table.remove(b.talents, i)
						learn = true
						break
					end
				end
			end
		end
	end
end

function _M:loadBuildOrder(file)
	local f = fs.open("/build-orders/"..file, "r")
	if not f then return end

	local b = {name="xxx", stats={}, talents={}, types={}}

	local cur = "name"
	while true do
		local line = f:readLine()
		if not line then break end
		line = line:gsub('[\r\n"]', '')
		local split = line:split(lpeg.S",; \t")

		if split[1] == "#Name" then cur = "name"
		elseif split[1] == "#Stats" then cur = "stats"
		elseif split[1] == "#Talents" then cur = "talents"
		elseif split[1] == "#Types" then cur = "types"
		else
			if cur == "name" then b.name = table.concat(split, " "):trim()
			elseif cur == "stats" then
				b.stats = {}
				for i, s in ipairs(split) do if s ~= "" then table.insert(b.stats, s) end end
			elseif cur == "talents" then
				table.insert(b.talents, {kind=split[2], tid=split[3]})
			elseif cur == "types" then
				table.insert(b.types, split[2])
			end
		end
	end

	if #b.stats > 0 and #b.talents > 0 then
		self.__use_build_order = b
	end
end

--- Setup minimap color for this entity
-- You may overload this method to customize your minimap
function _M:setupMinimapInfo(mo, map)
	if map.actor_player and not map.actor_player:canSee(self) then return end
	if self.rank > 3 then mo:minimap(0xC0, 0x00, 0xAF) return end
	local r = map.actor_player and map.actor_player:reactionToward(self) or -100
	if r < 0 then mo:minimap(240, 0, 0)
	elseif r > 0 then mo:minimap(0, 240, 0)
	else mo:minimap(0, 0, 240)
	end
end

function _M:alterMakeMapObject(tiles, mo, z, lastmo)
	local submo = core.map.newObject(self.uid, 1, self:check("display_on_seen"), self:check("display_on_remember"), self:check("display_on_unknown"), self:check("display_x") or 0, self:check("display_y") or 0, self:check("display_w") or 1, self:check("display_h") or 1, self:check("display_scale") or 1)
	local tex, texx, texy, pos_x, pos_y = tiles:get("", 0, 0, 0, 0, 0, 0, "invis.png", false, false, true)
	submo:texture(0, tex, false, texx, texy, pos_x, pos_y)
	submo:chain(mo)
	if lastmo == mo then lastmo = submo end
	mo = submo
	self._mo = mo

	return mo, z, lastmo
end

local f_self = nil
local f_danger2 = nil
local f_danger1 = nil
local f_powerful = nil
local f_friend = nil
local f_enemy = nil
local f_neutral = nil
local sf_self = nil
local sf_danger2 = nil
local sf_danger1 = nil
local sf_powerful = nil
local sf_friend = nil
local sf_enemy = nil
local sf_neutral = nil
local asf_self = nil
local asf_danger2 = nil
local asf_danger1 = nil
local asf_powerful = nil
local asf_friend = nil
local asf_enemy = nil
local asf_neutral = nil
local ssf_self = nil
local ssf_danger2 = nil
local ssf_danger1 = nil
local ssf_powerful = nil
local ssf_friend = nil
local ssf_enemy = nil
local ssf_neutral = nil
local assf_self = nil
local assf_danger2 = nil
local assf_danger1 = nil
local assf_powerful = nil
local assf_friend = nil
local assf_enemy = nil
local assf_neutral = nil
local ichat = nil

function _M:smallTacticalFrame(map, x, y, w, h, zoom, on_map, tlx, tly)
	if config.settings.tome.small_frame_side then
		local friend = -100
		if self.faction then
			if not map.actor_player then friend = Faction:factionReaction(map.view_faction, self.faction)
			else friend = map.actor_player:reactionToward(self) end
		end

		local sx = w * .015625
		local dx = w * .0625 - sx
		local sy = h * .03125
		local dy = h * .953125 - sy
		if friend < 0 then
			sx = w * .9375
		end
		local lp = math.max(0, self.life) / self.max_life + 0.0001
		if lp > .75 then -- green
			core.display.drawQuad(x + sx, y + sy, dx, dy, 129, 180, 57, 128)
			core.display.drawQuad(x + sx, y + sy + dy * (1-lp), dx, dy * lp, 50, 220, 77, 255)
		elseif lp > .5 then -- yellow
			core.display.drawQuad(x + sx, y + sy, dx, dy, 175, 175, 10, 128)
			core.display.drawQuad(x + sx, y + sy + dy * (1-lp), dx, dy * lp, 240, 252, 35, 255)
		elseif lp > .25 then -- orange
			core.display.drawQuad(x + sx, y + sy, dx, dy, 185, 88, 0, 128)
			core.display.drawQuad(x + sx, y + sy + dy * (1-lp), dx, dy * lp, 255, 156, 21, 255)
		else -- red
			core.display.drawQuad(x + sx, y + sy, dx, dy, 167, 55, 39, 128)
			core.display.drawQuad(x + sx, y + sy + dy * (1-lp), dx, dy * lp, 235, 0, 0, 255)
		end


		local b_self
		local b_powerful
		local b_danger2
		local b_danger1
		local b_friend
		local b_enemy
		local b_neutral
		if config.settings.tome.flagpost_tactical then
			if not assf_self then
				assf_self = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, "alt_side_"..map.faction_self)
				assf_powerful = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, "alt_side_"..map.faction_powerful)
				assf_danger2 = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, "alt_side_"..map.faction_danger2)
				assf_danger1 = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, "alt_side_"..map.faction_danger1)
				assf_friend = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, "alt_side_"..map.faction_friend)
				assf_enemy = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, "alt_side_"..map.faction_enemy)
				assf_neutral = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, "alt_side_"..map.faction_neutral)
			end
			b_self = assf_self
			b_powerful = assf_powerful
			b_danger2 = assf_danger2
			b_danger1 = assf_danger1
			b_friend = assf_friend
			b_enemy = assf_enemy
			b_neutral = assf_neutral
		else
			if not ssf_self then
				ssf_self = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, "side_"..map.faction_self)
				ssf_powerful = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, "side_"..map.faction_powerful)
				ssf_danger2 = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, "side_"..map.faction_danger2)
				ssf_danger1 = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, "side_"..map.faction_danger1)
				ssf_friend = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, "side_"..map.faction_friend)
				ssf_enemy = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, "side_"..map.faction_enemy)
				ssf_neutral = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, "side_"..map.faction_neutral)
			end
			b_self = ssf_self
			b_powerful = ssf_powerful
			b_danger2 = ssf_danger2
			b_danger1 = ssf_danger1
			b_friend = ssf_friend
			b_enemy = ssf_enemy
			b_neutral = ssf_neutral
		end

		if self.faction then
			if self == map.actor_player then
				b_self:toScreen(x, y, w, h)
			elseif map:faction_danger_check(self) then
				if friend >= 0 then b_powerful:toScreen(x, y, w, h)
				else
					if map:faction_danger_check(self, true) then
						b_danger2:toScreen(x, y, w, h)
					else
						b_danger1:toScreen(x, y, w, h)
					end
				end
			elseif friend > 0 then
				b_friend:toScreen(x, y, w, h)
			elseif friend < 0 then
				b_enemy:toScreen(x, y, w, h)
			else
				b_neutral:toScreen(x, y, w, h)
			end
		end
	else
		local sx = w * .078125
		local dx = w * .90625 - sx
		local sy = h * .9375
		local dy = h * .984375 - sy
		local lp = math.max(0, self.life) / self.max_life + 0.0001
		if lp > .75 then -- green
			core.display.drawQuad(x + sx, y + sy, dx, dy, 129, 180, 57, 128)
			core.display.drawQuad(x + sx, y + sy, dx * lp, dy, 50, 220, 77, 255)
		elseif lp > .5 then -- yellow
			core.display.drawQuad(x + sx, y + sy, dx, dy, 175, 175, 10, 128)
			core.display.drawQuad(x + sx, y + sy, dx * lp, dy, 240, 252, 35, 255)
		elseif lp > .25 then -- orange
			core.display.drawQuad(x + sx, y + sy, dx, dy, 185, 88, 0, 128)
			core.display.drawQuad(x + sx, y + sy, dx * lp, dy, 255, 156, 21, 255)
		else -- red
			core.display.drawQuad(x + sx, y + sy, dx, dy, 167, 55, 39, 128)
			core.display.drawQuad(x + sx, y + sy, dx * lp, dy, 235, 0, 0, 255)
		end

		local b_self
		local b_powerful
		local b_danger2
		local b_danger1
		local b_friend
		local b_enemy
		local b_neutral
		if config.settings.tome.flagpost_tactical then
			if not asf_self then
				asf_self = map.tilesTactic:get(nil, 0,0,0, 0,0,0, "alt_down_"..map.faction_self)
				asf_powerful = map.tilesTactic:get(nil, 0,0,0, 0,0,0, "alt_down_"..map.faction_powerful)
				asf_danger2 = map.tilesTactic:get(nil, 0,0,0, 0,0,0, "alt_down_"..map.faction_danger2)
				asf_danger1 = map.tilesTactic:get(nil, 0,0,0, 0,0,0, "alt_down_"..map.faction_danger1)
				asf_friend = map.tilesTactic:get(nil, 0,0,0, 0,0,0, "alt_down_"..map.faction_friend)
				asf_enemy = map.tilesTactic:get(nil, 0,0,0, 0,0,0, "alt_down_"..map.faction_enemy)
				asf_neutral = map.tilesTactic:get(nil, 0,0,0, 0,0,0, "alt_down_"..map.faction_neutral)
			end
			b_self = asf_self
			b_powerful = asf_powerful
			b_danger2 = asf_danger2
			b_danger1 = asf_danger1
			b_friend = asf_friend
			b_enemy = asf_enemy
			b_neutral = asf_neutral
		else
			if not sf_self then
				sf_self = map.tilesTactic:get(nil, 0,0,0, 0,0,0, "small_"..map.faction_self)
				sf_powerful = map.tilesTactic:get(nil, 0,0,0, 0,0,0, "small_"..map.faction_powerful)
				sf_danger2 = map.tilesTactic:get(nil, 0,0,0, 0,0,0, "small_"..map.faction_danger2)
				sf_danger1 = map.tilesTactic:get(nil, 0,0,0, 0,0,0, "small_"..map.faction_danger1)
				sf_friend = map.tilesTactic:get(nil, 0,0,0, 0,0,0, "small_"..map.faction_friend)
				sf_enemy = map.tilesTactic:get(nil, 0,0,0, 0,0,0, "small_"..map.faction_enemy)
				sf_neutral = map.tilesTactic:get(nil, 0,0,0, 0,0,0, "small_"..map.faction_neutral)
			end
			b_self = sf_self
			b_powerful = sf_powerful
			b_danger2 = sf_danger2
			b_danger1 = sf_danger1
			b_friend = sf_friend
			b_enemy = sf_enemy
			b_neutral = sf_neutral
		end

		if self.faction then
			local friend
			if not map.actor_player then friend = Faction:factionReaction(map.view_faction, self.faction)
			else friend = map.actor_player:reactionToward(self) end

			if self == map.actor_player then
				b_self:toScreen(x, y, w, h)
			elseif map:faction_danger_check(self) then
				if friend >= 0 then b_powerful:toScreen(x, y, w, h)
				else
					if map:faction_danger_check(self, true) then
						b_danger2:toScreen(x, y, w, h)
					else
						b_danger1:toScreen(x, y, w, h)
					end
				end
			elseif friend > 0 then
				b_friend:toScreen(x, y, w, h)
			elseif friend < 0 then
				b_enemy:toScreen(x, y, w, h)
			else
				b_neutral:toScreen(x, y, w, h)
			end
		end
	end
end

function _M:bigTacticalFrame(x, y, w, h, zoom, on_map, tlx, tly)
	-- Tactical info
	if game.level and game.always_target then
		-- Tactical life info
		if on_map then
			if config.settings.tome.small_frame_side then
				local dw = w * 0.1
				local lp = math.max(0, self.life) / self.max_life + 0.0001
				if lp > .75 then -- green
					core.display.drawQuad(x + 3, y + 3, dw, h - 6, 129, 180, 57, 128)
					core.display.drawQuad(x + 3, y + 3 + (h - 6) * (1 - lp), dw, (h - 6) * lp, 50, 220, 77, 255)
				elseif lp > .5 then -- yellow
					core.display.drawQuad(x + 3, y + 3, dw, h - 6, 175, 175, 10, 128)
					core.display.drawQuad(x + 3, y + 3 + (h - 6) * (1 - lp), dw, (h - 6) * lp, 240, 252, 35, 255)
				elseif lp > .25 then -- orange
					core.display.drawQuad(x + 3, y + 3, dw, h - 6, 185, 88, 0, 128)
					core.display.drawQuad(x + 3, y + 3 + (h - 6) * (1 - lp), dw, (h - 6) * lp, 255, 156, 21, 255)
				else -- red
					core.display.drawQuad(x + 3, y + 3, dw, h - 6, 167, 55, 39, 128)
					core.display.drawQuad(x + 3, y + 3 + (h - 6) * (1 - lp), dw, (h - 6) * lp, 235, 0, 0, 255)
				end
			else
				local dh = h * 0.1
				local lp = math.max(0, self.life) / self.max_life + 0.0001
				if lp > .75 then -- green
					core.display.drawQuad(x + 3, y + h - dh, w - 6, dh, 129, 180, 57, 128)
					core.display.drawQuad(x + 3, y + h - dh, (w - 6) * lp, dh, 50, 220, 77, 255)
				elseif lp > .5 then -- yellow
					core.display.drawQuad(x + 3, y + h - dh, w - 6, dh, 175, 175, 10, 128)
					core.display.drawQuad(x + 3, y + h - dh, (w - 6) * lp, dh, 240, 252, 35, 255)
				elseif lp > .25 then -- orange
					core.display.drawQuad(x + 3, y + h - dh, w - 6, dh, 185, 88, 0, 128)
					core.display.drawQuad(x + 3, y + h - dh, (w - 6) * lp, dh, 255, 156, 21, 255)
				else -- red
					core.display.drawQuad(x + 3, y + h - dh, w - 6, dh, 167, 55, 39, 128)
					core.display.drawQuad(x + 3, y + h - dh, (w - 6) * lp, dh, 235, 0, 0, 255)
				end
			end
		end
	end

	-- Tactical info
	if game.level and game.level.map.view_faction then
		local map = game.level.map
		if on_map then
			if not f_self then
				f_self = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, map.faction_self)
				f_powerful = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, map.faction_powerful)
				f_danger2 = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, map.faction_danger2)
				f_danger1 = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, map.faction_danger1)
				f_friend = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, map.faction_friend)
				f_enemy = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, map.faction_enemy)
				f_neutral = game.level.map.tilesTactic:get(nil, 0,0,0, 0,0,0, map.faction_neutral)
			end

			if self.faction then
				local friend
				if not map.actor_player then friend = Faction:factionReaction(map.view_faction, self.faction)
				else friend = map.actor_player:reactionToward(self) end

				if self == map.actor_player then
					f_self:toScreen(x, y, w, h)
				elseif map:faction_danger_check(self) then
					if friend >= 0 then f_powerful:toScreen(x, y, w, h)
					else
						if map:faction_danger_check(self, true) then
							f_danger2:toScreen(x, y, w, h)
						else
							f_danger1:toScreen(x, y, w, h)
						end
					end
				elseif friend > 0 then
					f_friend:toScreen(x, y, w, h)
				elseif friend < 0 then
					f_enemy:toScreen(x, y, w, h)
				else
					f_neutral:toScreen(x, y, w, h)
				end
			end
		end
	end
end

--- Attach or remove a display callback
-- Defines particles to display
function _M:defineDisplayCallback()
	if not self._mo then return end

	local backps = self:getParticlesList(true)
	local ps = self:getParticlesList()

	local function tactical(x, y, w, h, zoom, on_map, tlx, tly)
		if game.level and game.level.map.view_faction and game.always_target and game.always_target ~= "old" then
			if on_map then
				self:smallTacticalFrame(game.level.map, x, y, w, h, zoom, on_map, tlx, tly)
			end
		else
			self:bigTacticalFrame(x, y, w, h, zoom, on_map, tlx, tly)
		end

		-- Chat
		if game.level and self.can_talk then
			local map = game.level.map
			if not ichat then
				ichat = game.level.map.tilesTactic:get('', 0,0,0, 0,0,0, "speak_bubble.png")
			end

			ichat:toScreen(x + w - 8, y, 8, 8)
		end
	end

	local function particles(x, y, w, h, zoom, on_map)
		local e
		local dy = 0
		if h > w then dy = (h - w) / 2 end
		for i = 1, #ps do
			e = ps[i]
			e:checkDisplay()
			if e.ps:isAlive() then e.ps:toScreen(x + w / 2, y + dy + h / 2, true, w / (game.level and game.level.map.tile_w or w))
			else self:removeParticles(e)
			end
		end
	end

	local function backparticles(x, y, w, h, zoom, on_map)
		local e
		local dy = 0
		if h > w then dy = (h - w) / 2 end
		for i = 1, #backps do
			e = backps[i]
			e:checkDisplay()
			if e.ps:isAlive() then e.ps:toScreen(x + w / 2, y + dy + h / 2, true, w / (game.level and game.level.map.tile_w or w))
			else self:removeParticles(e)
			end
		end
	end

	if self._mo == self._last_mo or not self._last_mo then
		self._mo:displayCallback(function(x, y, w, h, zoom, on_map, tlx, tly)
			tactical(tlx or x, tly or y, w, h, zoom, on_map)
			backparticles(x, y, w, h, zoom, on_map)
			particles(x, y, w, h, zoom, on_map)
			return true
		end)
	else
		self._mo:displayCallback(function(x, y, w, h, zoom, on_map, tlx, tly)
			tactical(tlx or x, tly or y, w, h, zoom, on_map)
			backparticles(x, y, w, h, zoom, on_map)
			return true
		end)
		self._last_mo:displayCallback(function(x, y, w, h, zoom, on_map)
			particles(x, y, w, h, zoom, on_map)
			return true
		end)
	end
end

function _M:move(x, y, force)
	local moved = false
	local ox, oy = self.x, self.y

	if force or self:enoughEnergy() then

		-- Confused ?
		if not force and self:attr("confused") then
			if rng.percent(self:attr("confused")) then
				x, y = self.x + rng.range(-1, 1), self.y + rng.range(-1, 1)
			end
		end

		-- Encased in ice, attack the ice
		if not force and self:attr("encased_in_ice") then
			self:attackTarget(self)
			moved = true
		-- Should we prob travel through walls ?
		elseif not force and self:attr("prob_travel") and not self:attr("prob_travel_deny") and game.level.map:checkEntity(x, y, Map.TERRAIN, "block_move", self) then
			moved = self:probabilityTravel(x, y, self:attr("prob_travel"))
			if self:attr("prob_travel_penalty") then
				local d = core.fov.distance(ox, oy, self.x, self.y)
				self:setEffect(self.EFF_PROB_TRAVEL_UNSTABLE, d * self:attr("prob_travel_penalty"), {})
			end
		-- Never move but tries to attack ? ok
		elseif not force and self:attr("never_move") then
			-- A bit weird, but this simple asks the collision code to detect an attack
			if not game.level.map:checkAllEntities(x, y, "block_move", self, true) then
				game.logPlayer(self, "You are unable to move!")
			end
		else
			moved = engine.Actor.move(self, x, y, force)
		end
		if not force and moved and (self.x ~= ox or self.y ~= oy) and not self.did_energy then
			local eff = self:hasEffect(self.EFF_CURSE_OF_SHROUDS)
			if eff then eff.moved = true end

			if self:attr("move_stamina_instead_of_energy") and self:getStamina() > self:attr("move_stamina_instead_of_energy") then
				self:incStamina(-self:attr("move_stamina_instead_of_energy"))
			else
				local speed = self:combatMovementSpeed(x, y)
				local use_energy = true
				if self:attr("walk_sun_path") then
					for i, e in ipairs(game.level.map.effects) do if e.damtype == DamageType.SUN_PATH and e.grids[x] and e.grids[x][y] then use_energy = false break end end
				end

				if use_energy then
					self:useEnergy(game.energy_to_act * speed)

					if self.reload then
						local reloaded = self:reload()
						if not reloaded and self.reloadQS then
							self:reloadQS()
						end
					end
				end

				if speed <= 0.125 and self:knowTalent(self.T_FAST_AS_LIGHTNING) then
					local t = self:getTalentFromId(self.T_FAST_AS_LIGHTNING)
					t.trigger(self, t, ox, oy)
				end
			end
		end
	end
	self.did_energy = nil

	-- Try to detect traps
	if self:knowTalent(self.T_HEIGHTENED_SENSES) then
		local power = self:callTalent(self.T_HEIGHTENED_SENSES,"trapPower")
		local grids = core.fov.circle_grids(self.x, self.y, 1, true)
		for x, yy in pairs(grids) do for y, _ in pairs(yy) do
			local trap = game.level.map(x, y, Map.TRAP)
			if trap and not trap:knownBy(self) and self:canSee(trap) and self:checkHit(power, trap.detect_power) then
				trap:setKnown(self, true)
				game.level.map:updateMap(x, y)
				game.logPlayer(self, "You have found a trap (%s)!", trap:getName())
			end
		end end
	end

	-- chooseCursedAuraTree allows you to get the Cursed Aura tree
	if moved and self.chooseCursedAuraTree then
		if self.player then
			-- function placed in defiling touch where cursing logic exists
			local t = self:getTalentFromId(self.T_DEFILING_TOUCH)
			t.chooseCursedAuraTree(self, t)
		end
	end

	if moved and self:knowTalent(self.T_DEFILING_TOUCH) then
		local t = self:getTalentFromId(self.T_DEFILING_TOUCH)
		t.curseFloor(self, t, x, y)
	end

	if moved and self:isTalentActive(self.T_BODY_OF_STONE) and not self:attr("preserve_body_of_stone") then
		self:forceUseTalent(self.T_BODY_OF_STONE, {ignore_energy=true})
	end

	if moved then
		self:breakPsionicChannel()
	end

	if not force and moved and ox and oy and (ox ~= self.x or oy ~= self.y) and self:knowTalent(self.T_LIGHT_OF_FOOT) then
		self:incStamina(self:getTalentLevelRaw(self.T_LIGHT_OF_FOOT) * 0.2)
	end

	if moved and not force and ox and oy and (ox ~= self.x or oy ~= self.y) and config.settings.tome.smooth_move > 0 then
		local blur = 0
		if game.level.data.zero_gravity or self:hasEffect(self.EFF_HASTE) then blur = 2 end
		if self:attr("lightning_speed") or self:attr("step_up") or self:attr("wild_speed") then blur = 3 end
		self:setMoveAnim(ox, oy, config.settings.tome.smooth_move, blur, 8, config.settings.tome.twitch_move and 0.15 or 0)
	end

	if moved and not force and self:knowTalent(self.T_HASTE) and self:hasEffect(self.EFF_HASTE) then
		local t = self:getTalentFromId(self.T_HASTE)
		t.do_haste_double(self, t, ox, oy)
	end

	if moved and not force and ox and oy and (ox ~= self.x or oy ~= self.y) and self:hasEffect(self.EFF_RAMPAGE) then
		local eff = self:hasEffect(self.EFF_RAMPAGE)
		if not eff.moved and eff.actualDuration < eff.maxDuration then
			game.logPlayer(self, "#F53CBE#Your movements fuel your rampage! (+1 duration)")
			eff.moved = true
			eff.actualDuration = eff.actualDuration + 1
			eff.dur = eff.dur + 1
		end
	end

	self:fireTalentCheck("callbackOnMove", moved, force, ox, oy)

	self:triggerHook{"Actor:move", moved=moved, force=force, ox=ox, oy=oy}

	return moved
end

--- Just wait a turn
function _M:waitTurn()
	if self.reload then
		local reloaded = self:reload()
		if not reloaded and self.reloadQS then
			self:reloadQS()
		end
	end

	self:useEnergy()
end

--- Knock back the actor
-- Overloaded to add move anim
function _M:knockback(srcx, srcy, dist, recursive, on_terrain)
	local ox, oy = self.x, self.y
	engine.Actor.knockback(self, srcx, srcy, dist, recursive, on_terrain)
	if config.settings.tome.smooth_move > 0 then
		self:resetMoveAnim()
		self:setMoveAnim(ox, oy, 9, 5)
	end

	self:attr("knockback_times", 1)
end

--- Pull in the actor
-- Overloaded to add move anim
function _M:pull(srcx, srcy, dist, recursive)
	local ox, oy = self.x, self.y
	engine.Actor.pull(self, srcx, srcy, dist, recursive)
	if config.settings.tome.smooth_move > 0 then
		self:resetMoveAnim()
		self:setMoveAnim(ox, oy, 9, 5)
	end
end

--- Get the "path string" for this actor
-- See Map:addPathString() for more info
function _M:getPathString()
	local ps = self.open_door and "return {open_door=true,can_pass={" or "return {can_pass={"
	for what, check in pairs(self.can_pass) do
		ps = ps .. what.."="..check..","
	end
	ps = ps.."}}"
--	print("[PATH STRING] for", self.name, " :=: ", ps)
	return ps
end

--- Drop no-teleport items
function _M:dropNoTeleportObjects()
	for inven_id, inven in pairs(self.inven) do
		for item = #inven, 1, -1 do
			local o = inven[item]
			if o.no_teleport then
				self:dropFloor(inven, item, false, true)
				game.logPlayer(self, "#LIGHT_RED#Your %s is immune to the teleportation and drops to the floor!", o:getName{do_color=true})
			end
		end
	end
end

--- Blink through walls
function _M:probabilityTravel(x, y, dist)
	if game.zone.wilderness then return true end
	if self:attr("encased_in_ice") then return end

	local dirx, diry = x - self.x, y - self.y
	local tx, ty = x, y
	while game.level.map:isBound(tx, ty) and game.level.map:checkAllEntities(tx, ty, "block_move", self) and dist > 0 do
		if game.level.map.attrs(tx, ty, "no_teleport") then break end
		if game.level.map:checkAllEntities(tx, ty, "no_prob_travel", self) then break end
		tx = tx + dirx
		ty = ty + diry
		dist = dist - 1
	end
	if game.level.map:isBound(tx, ty) and not game.level.map:checkAllEntities(tx, ty, "block_move", self) and not game.level.map.attrs(tx, ty, "no_teleport") then
		self:dropNoTeleportObjects()
		return engine.Actor.move(self, tx, ty, false)
	end
	return true
end

--- Teleports randomly to a passable grid
-- This simply calls the default actor teleportRandom but first checks for space-time stability
-- @param x the coord of the teleportation
-- @param y the coord of the teleportation
-- @param dist the radius of the random effect, if set to 0 it is a precise teleport
-- @param min_dist the minimum radius of of the effect, will never teleport closer. Defaults to 0 if not set
-- @return true if the teleport worked
function _M:teleportRandom(x, y, dist, min_dist)
	if self:attr("encased_in_ice") then return end
	if self:attr("cant_teleport") then return end
	if game.level.data.no_teleport_south and y + dist > self.y then
		y = self.y - dist
	end
	local ox, oy = self.x, self.y
	local ret = engine.Actor.teleportRandom(self, x, y, dist, min_dist)
	if self.x ~= ox or self.y ~= oy then
		self.x, self.y, ox, oy = ox, oy, self.x, self.y
		self:dropNoTeleportObjects()
		if self:attr("defense_on_teleport") or self:attr("resist_all_on_teleport") or self:attr("effect_reduction_on_teleport") then
			self:setEffect(self.EFF_OUT_OF_PHASE, 5, {defense=self:attr("defense_on_teleport") or 0, resists=self:attr("resist_all_on_teleport") or 0, effect_reduction=self:attr("effect_reduction_on_teleport") or 0})
		end
		self.x, self.y, ox, oy = ox, oy, self.x, self.y
	end
	return ret
end

--- Quake a zone
-- Moves randomly each grid to an other grid
function _M:doQuake(tg, x, y)
	local typ = require("engine.Target"):getType(tg)
	return game.zone:doQuake(typ.ball or 1, x, y, function(tx, ty