SpellcastingManager.cpp

#include "StdAfx.h"
#include "SpellcastingManager.h"
#include "WeenieObject.h"
#include "World.h"
#include "SpellProjectile.h"
#include "WeenieFactory.h"
#include "InferredPortalData.h"
#include "WClassID.h"
#include "Container.h"
#include "Player.h"

const float MAX_HEADING_TO_TARGET_FOR_CAST = 45.0f;
const float MAX_TURN_TIME_FOR_CAST = 8.0f;
const float MAX_MOTION_TIME_FOR_CAST = 4.0f;
const float MAX_PROJECTILE_CAST_RANGE = 100.0;

CSpellcastingManager::CSpellcastingManager(CWeenieObject *pWeenie)
{
	m_pWeenie = pWeenie;
}

CSpellcastingManager::~CSpellcastingManager()
{

}

void CSpellcastingManager::EndCast(int error)
{
	m_pWeenie->DoForcedStopCompletely();
	m_pWeenie->NotifyUseDone(error);
	m_bCasting = false;
	m_SpellCastData = SpellCastData();
	m_PendingMotions.clear();
	m_bTurningToObject = false;
}

bool CSpellcastingManager::ResolveSpellBeingCasted()
{
	if (!m_SpellCastData.spell_id)
		return false;

	CSpellTable *pSpellTable = MagicSystem::GetSpellTable();
	if (!pSpellTable)
		return false;

	m_SpellCastData.spell = pSpellTable->GetSpellBase(m_SpellCastData.spell_id);
	if (!m_SpellCastData.spell)
		return false;

	CSpellTableEx *pSpellTableEx = g_pPortalDataEx->GetSpellTableEx();
	if (pSpellTableEx)
		m_SpellCastData.spellEx = pSpellTableEx->GetSpellBase(m_SpellCastData.spell_id);

	m_SpellCastData.spell_formula = m_SpellCastData.spell->InqSpellFormula();
	m_SpellCastData.power_level_of_power_component = m_SpellCastData.spell_formula.GetPowerLevelOfPowerComponent();
	m_SpellCastData.current_skill = DetermineSkillLevelForSpell();
	m_SpellCastData.max_range = DetermineSpellRange();

	if (m_SpellCastData.spell->_bitfield & SelfTargeted_SpellIndex)
	{
		m_SpellCastData.target_id = m_SpellCastData.source_id;
	}

	if (m_SpellCastData.equipped && m_SpellCastData.spell->InqTargetType() == ITEM_TYPE::TYPE_ITEM_ENCHANTABLE_TARGET)
	{
		m_SpellCastData.target_id = m_SpellCastData.caster_id;
	}

	// item enchantment
	if (m_SpellCastData.equipped && (m_SpellCastData.spell->_school == 3) && (m_SpellCastData.spell->_bitfield & SelfTargeted_SpellIndex))
	{
		m_SpellCastData.target_id = m_SpellCastData.caster_id;
	}

	return true;
}

std::string appendSpellText(std::string text, std::string newText, SpellComponentType componentType, SpellComponentType lastComponentType)
{
	if (!newText.size())
		return text;

	switch (componentType)
	{
	default:
	case SpellComponentType::Undef_SpellComponentType:
	case SpellComponentType::Action_SpellComponentType:
	case SpellComponentType::ConceptPrefix_SpellComponentType:
		{
			if (!text.empty())
				text += " ";
			text += newText;
			break;
		}
	case SpellComponentType::ConceptSuffix_SpellComponentType:
		{
			switch (lastComponentType)
			{
			default:
			case SpellComponentType::Undef_SpellComponentType:
			case SpellComponentType::Action_SpellComponentType:
				if (!text.empty())
					text += " ";
				text += newText;
				break;

			case SpellComponentType::ConceptPrefix_SpellComponentType:
			case SpellComponentType::ConceptSuffix_SpellComponentType:
				newText[0] = ::tolower(newText[0]);
				text += newText;
				break;
			}

			break;
		}
	}

	return text;
}

bool CSpellcastingManager::AddMotionsForSpell()
{
	SpellComponentTable *pSpellComponents = MagicSystem::GetSpellComponentTable();
	if (!pSpellComponents)
		return false;
	
	std::string spellWords;
	SpellComponentType lastComponentType = Undef_SpellComponentType;

	bool firstMotion = true;

	for (DWORD i = 0; i < SPELLFORMULA_MAX_COMPS; i++)
	{
		DWORD comp = m_SpellCastData.spell_formula._comps[i];
		if (!comp)
			break;

		const SpellComponentBase *pSpellComponent = pSpellComponents->InqSpellComponentBase(comp);
		if (!pSpellComponent)
			return false;

		if (pSpellComponent->_category == Scarab_SpellComponentCategory && m_SpellCastData.spell->_bitfield & FastCast_SpellIndex)
			continue;

		DWORD gesture = pSpellComponent->_gesture;
		if (gesture && (gesture & 0xFFFF) != 0)
		{
			if (gesture == 0x1000012F)
				gesture = 0x13000132; // level 7's are wrong for some reason

			// m_pWeenie->SendText(csprintf("Component \"%s\": %s %f %f 0x%08X (%u)", pSpellComponent->_name.c_str(), pSpellComponent->_text.c_str(), pSpellComponent->_time, pSpellComponent->_CDM, pSpellComponent->_gesture, pSpellComponent->_gesture & 0xFFFF), 1);
			m_PendingMotions.push_back(SpellCastingMotion(gesture, 2.0f, firstMotion, firstMotion, pSpellComponent->_time));
			firstMotion = false;
		}

		if (!pSpellComponent->_text.empty())
		{
			spellWords = appendSpellText(spellWords, pSpellComponent->_text, pSpellComponent->_type, lastComponentType);
			lastComponentType = pSpellComponent->_type;
		}
	}

	if (!spellWords.empty())
	{
		m_pWeenie->SpeakLocal(spellWords.c_str(), LTT_MAGIC_CASTING_CHANNEL);
	}

	m_SpellCastData.power_level_of_power_component = m_SpellCastData.spell_formula.GetPowerLevelOfPowerComponent();
	return true;
}

void CSpellcastingManager::BeginCast()
{
	m_bCasting = true;
	m_PendingMotions.clear();
	m_bTurningToObject = false;

	AddMotionsForSpell();

	BeginNextMotion();
}

CWeenieObject *CSpellcastingManager::GetCastTarget()
{
	if (!m_bCasting || !m_SpellCastData.target_id)
		return NULL;

	return g_pWorld->FindObject(m_SpellCastData.target_id);
}

CWeenieObject *CSpellcastingManager::GetCastCaster()
{
	// could be a contained item casting a spell on the player
	return g_pWorld->FindObject(m_SpellCastData.caster_id);
}

CWeenieObject *CSpellcastingManager::GetCastSource()
{
	return g_pWorld->FindObject(m_SpellCastData.source_id);
}

float CSpellcastingManager::HeadingToTarget()
{
	if (!m_SpellCastData.target_id)
	{
		// Untargeted spell
		return 0.0;
	}

	CWeenieObject *pTarget = GetCastTarget();
	if (!pTarget)
	{
		// Don't know where the target is
		EndCast(WERROR_OBJECT_GONE);
		return 0.0;
	}

	if (pTarget->parent) 
	{
		// Target has a parent (in inventory?)
		// This needs additional logic
		return 0.0;
	}

	// Return difference in heading.
	float fHeadingToTarget = m_pWeenie->m_Position.heading_diff(pTarget->m_Position);

	fHeadingToTarget = fabs(fHeadingToTarget);

	if (fHeadingToTarget >= 180.0)
		fHeadingToTarget = 360.0 - fHeadingToTarget;

	return fHeadingToTarget;
}

bool CSpellcastingManager::MotionRequiresHeading()
{
	if (!m_SpellCastData.target_id || m_SpellCastData.target_id == m_SpellCastData.caster_id || m_SpellCastData.target_id == m_SpellCastData.source_id)
		return false;

	if (CWeenieObject *target = g_pWorld->FindObject(m_SpellCastData.target_id))
	{
		if (CWeenieObject *owner = target->GetWorldTopLevelOwner())
		{
			if (owner->GetID() == m_SpellCastData.source_id)
				return false;
		}
	}

	if (m_PendingMotions.empty())
		return true; // last motion requires heading

	return m_PendingMotions.begin()->requiresHeading;
}

void CSpellcastingManager::BeginNextMotion()
{
	if (m_pWeenie->IsDead())
	{
		EndCast(0);
		return;
	}

	bool bNeedsTurnToObject = false;

	if (MotionRequiresHeading() && HeadingToTarget() > MAX_HEADING_TO_TARGET_FOR_CAST)
	{
		bNeedsTurnToObject = true;
	}

	if (!m_bCasting)
	{
		// Must have errored...
		return;
	}

	if (bNeedsTurnToObject)
	{
		m_bTurningToObject = true;

		MovementParameters params;
		params.speed = 1.0f;
		params.action_stamp = ++m_pWeenie->m_wAnimSequence;
		params.modify_interpreted_state = 0;
		m_pWeenie->last_move_was_autonomous = false;

		m_pWeenie->cancel_moveto();
		m_pWeenie->TurnToObject(m_SpellCastData.target_id, &params);

		m_SpellCastData.cast_timeout = Timer::cur_time + MAX_TURN_TIME_FOR_CAST;
	}
	else
	{
		m_bTurningToObject = false;

		if (m_PendingMotions.empty())
		{
			int error = LaunchSpellEffect();
			EndCast(error);
		}
		else
		{
			m_SpellCastData.cast_timeout = Timer::cur_time + MAX_MOTION_TIME_FOR_CAST;

			m_pWeenie->StopCompletely(0);

			SpellCastingMotion &cast_motion = *m_PendingMotions.begin();

			MovementParameters params;
			params.action_stamp = ++m_pWeenie->m_wAnimSequence;
			params.speed = cast_motion.speed;

			MovementStruct mvs;
			mvs.type = MovementTypes::RawCommand;
			mvs.motion = cast_motion.motion;
			mvs.params = &params;

			m_pWeenie->last_move_was_autonomous = false;

			int errorCode;
			if (!(errorCode = m_pWeenie->PerformMovement(mvs)))
			{
				m_fNextCastTime = Timer::cur_time + (cast_motion.min_time * 0.5f);
				m_pWeenie->_server_control_timestamp++;
				m_pWeenie->Animation_Update();
			}
			else
			{
				// m_pWeenie->PerformMovement(mvs);
				EndCast(WERROR_MAGIC_GENERAL_FAILURE);
			}
		}
	}
}

Position CSpellcastingManager::GetSpellProjectileSpawnPosition(CSpellProjectile *pProjectile, CWeenieObject *pTarget, float *pDistToTarget)
{
	bool bArc = pProjectile->InqBoolQuality(GRAVITY_STATUS_BOOL, FALSE) ? true : false;

	CWeenieObject *pSource = GetCastSource();
	Position spawnPosition = pSource->m_Position.add_offset(Vector(0, 0, pSource->GetHeight() * (bArc ? 1.0 : (2.0 / 3.0))));

	Vector targetOffset = spawnPosition.get_offset(pTarget->m_Position.add_offset(Vector(0, 0, pTarget->GetHeight() * (bArc ? (5.0 / 6.0) : (0.5)))));
	Vector targetDir = targetOffset;

	if (targetDir.normalize_check_small())
	{
		targetDir = spawnPosition.frame.get_vector_heading();

		// spawnPosition.frame.m_origin += targetDir * minSpawnDist;
		spawnPosition.frame.set_vector_heading(targetDir);

		*pDistToTarget = 0.0f;
	}
	else
	{
		float minSpawnDist = (pSource->GetRadius() + pProjectile->GetRadius()) + 0.1f;

		spawnPosition.frame.m_origin += targetDir * minSpawnDist;
		spawnPosition.frame.set_vector_heading(targetDir);

		*pDistToTarget = targetOffset.magnitude();
	}

	return spawnPosition;
}

Vector CSpellcastingManager::GetSpellProjectileSpawnVelocity(Position *pSpawnPosition, CWeenieObject *pTarget, float speed, bool tracked, bool gravity, Vector *pTargetDir)
{
	Vector targetOffset = pSpawnPosition->get_offset(pTarget->m_Position.add_offset(Vector(0, 0, pTarget->GetHeight() * 0.5f)));
	double targetDist = targetOffset.magnitude();

	if (!tracked)
	{
		double t = targetDist / speed;
		Vector v = targetOffset / t;

		if (gravity)
			v.z += (9.8*t) / 2.0f;
		
		Vector targetDir = v;
		targetDir.normalize();

		if (pTargetDir)
			*pTargetDir = targetDir;

		return v;
	}

	Vector P0 = targetOffset;
	Vector P1(0, 0, 0);

	float s0 = pTarget->get_velocity().magnitude();
	Vector V0 = pTarget->get_velocity();
	if (V0.normalize_check_small())
		V0 = Vector(0, 0, 0);

	float s1 = speed;

	double a = (V0.x * V0.x) + (V0.y * V0.y) - (s1 * s1);
	double b = 2 * ((P0.x * V0.x) + (P0.y * V0.y) - (P1.x * V0.x) - (P1.y * V0.y));
	double c = (P0.x * P0.x) + (P0.y * P0.y) + (P1.x * P1.x) + (P1.y * P1.y) - (2 * P1.x * P0.x) - (2 * P1.y * P0.y);

	double t1 = (-b + sqrt((b * b) - (4 * a * c))) / (2 * a);
	double t2 = (-b - sqrt((b * b) - (4 * a * c))) / (2 * a);

	if (t1 < 0)
		t1 = FLT_MAX;
	if (t2 < 0)
		t2 = FLT_MAX;

	double t = min(t1, t2);
	if (t >= 100.0)
	{
		return GetSpellProjectileSpawnVelocity(pSpawnPosition, pTarget, speed, false, gravity, pTargetDir);
	}

	Vector v;
	v.x = (P0.x + (t * s0 * V0.x)) / (t); // * s1);
	v.y = (P0.y + (t * s0 * V0.y)) / (t); // * s1);
	v.z = (P0.z + (t * s0 * V0.z)) / (t); // * s1);

	if (gravity)
	{
		v.z += (9.8*t) / 2.0f;
	}

	if (pTargetDir)
	{
		Vector targetDir = v;
		if (targetDir.normalize_check_small())
			targetDir = Vector(0, 0, 0);

		*pTargetDir = targetDir;
	}

	return v;
}

const double MIN_BOLT_VELOCITY = 5.0;
const double MAX_BOLT_VELOCITY = 20.0;
double CalculateBoltVelocityByDistance(double distance)
{
	return MIN_BOLT_VELOCITY + ((MAX_BOLT_VELOCITY-MIN_BOLT_VELOCITY) * min(1.0, max(0.0, (distance / 15.0))));
}

int CSpellcastingManager::LaunchRingProjectiles(DWORD wcid)
{
	DWORD damage = 0;

	switch (m_SpellCastData.power_level_of_power_component)
	{
	case 1: damage = Random::GenUInt(16, 31); break;
	case 2: damage = Random::GenUInt(18, 35); break;
	case 3: damage = Random::GenUInt(21, 42); break;
	case 4: damage = Random::GenUInt(25, 50); break;
	case 5: damage = Random::GenUInt(29, 59); break;
	case 6: damage = Random::GenUInt(36, 71); break;
	case 7:
	case 8: damage = Random::GenUInt(42, 84); break;
	case 9:
	case 10: damage = Random::GenUInt(47, 94); break;
	}

	float velocity = 1.0f;
	bool tracking = true;
	bool gravity = false;

	const int NUM_RING_PROJECTILES = 4;

	for (int i = 0; i < NUM_RING_PROJECTILES; i++)
	{
		CSpellProjectile *pProjectile = new CSpellProjectile(m_SpellCastData, m_SpellCastData.target_id, damage);

		// spawn default object properties
		g_pWeenieFactory->ApplyWeenieDefaults(pProjectile, wcid);

		// set spell id (is this even needed?)
		pProjectile->SetSpellID(m_SpellCastData.spell_id);

		double rads = ((i * 2) / (double)NUM_RING_PROJECTILES) * PI;
		Vector dir(sin(rads), cos(rads), 0.0f);

		float velocity = 2.0f;

		// create the initial object
		Position projSpawnPos = GetCastSource()->m_Position;
		projSpawnPos.frame.set_heading(rads);

		pProjectile->SetInitialPosition(projSpawnPos);		
		pProjectile->InitPhysicsObj();

		pProjectile->m_Position = pProjectile->m_Position.add_offset(Vector(
			(GetCastSource()->GetRadius() + pProjectile->GetRadius() + F_EPSILON) * dir.x,
			(GetCastSource()->GetRadius() + pProjectile->GetRadius() + F_EPSILON) * dir.y, /*1.223465f*/0.8f));

		/*
		m_pWeenie->SendText(
			csprintf("DEBUG: WeenieHeight/Radius: %f %f ProjHeight/Radius: %f %f",
				m_pWeenie->GetHeight(), m_pWeenie->GetRadius(), pProjectile->GetHeight(), pProjectile->GetRadius()), LTT_ALL_CHANNELS);
				*/

		// set velocity
		pProjectile->set_velocity(dir * velocity, 0);

		// insert the object into the world
		g_pWorld->CreateEntity(pProjectile);

		// launch particle effect
		pProjectile->EmitEffect(PS_Launch, 0.4f);
	}

	return WERROR_NONE;
}

bool CSpellcastingManager::LaunchProjectileSpell(ProjectileSpellEx *meta)
{
	if (!meta)
		return false;

	CWeenieObject *pTarget = GetCastTarget();
	if (!pTarget || !pTarget->InValidCell())
	{
		// Don't know where the target is
		return false;
	}

	int numX = (int)(meta->_dims.x + 0.5f);
	int numY = (int)(meta->_dims.y + 0.5f);
	int numZ = (int)(meta->_dims.z + 0.5f);

	for (int x = 0; x < numX; x++)
	{
		for (int y = 0; y < numY; y++)
		{
			for (int z = 0; z < numZ; z++)
			{
				DWORD damage = Random::GenUInt(meta->_baseIntensity, meta->_baseIntensity + meta->_variance);

				CSpellProjectile *pProjectile = new CSpellProjectile( // revise me
					m_SpellCastData, meta->_numProjectiles > 1 ? 0 : m_SpellCastData.target_id, damage);

				// create the initial object
				float distToTarget;
				
				// spawn default object properties
				g_pWeenieFactory->ApplyWeenieDefaults(pProjectile, meta->_wcid);
				
				pProjectile->m_Qualities.SetInt(DAMAGE_TYPE_INT, meta->_etype);

				// set spell id (is this even needed?)
				pProjectile->SetSpellID(m_SpellCastData.spell_id);
				pProjectile->SetInitialPosition(GetCastSource()->m_Position);
				pProjectile->InitPhysicsObj();

				pProjectile->m_PhysicsState |= MISSILE_PS|REPORT_COLLISIONS_PS;
				pProjectile->m_PhysicsState &= ~IGNORE_COLLISIONS_PS;
				
				Position projSpawnPos = GetSpellProjectileSpawnPosition(pProjectile, pTarget, &distToTarget);

				Vector createOffset = projSpawnPos.localtoglobalvec(meta->_createOffset);

				projSpawnPos = projSpawnPos.add_offset(
					Vector(
						Random::GenFloat(-1.0, 1.0) * meta->_peturbation.x * meta->_padding.x,
						Random::GenFloat(-1.0, 1.0) * meta->_peturbation.y * meta->_padding.y,
						Random::GenFloat(-1.0, 1.0) * meta->_peturbation.z * meta->_padding.z));

				projSpawnPos = projSpawnPos.add_offset(createOffset);

				Position spawnSourcePosition = projSpawnPos;

				float radius = pProjectile->GetRadius();

				Vector sizePerProjectile = meta->_padding; // * radius;
				
				Vector projectileGroupOffset(x, y, z);
				projectileGroupOffset.x *= sizePerProjectile.x;
				projectileGroupOffset.y *= sizePerProjectile.y;
				projectileGroupOffset.z *= sizePerProjectile.z;

				projectileGroupOffset.x -= sizePerProjectile.x * ((meta->_dims.x - 1.0) / 2.0);
				projectileGroupOffset.y -= sizePerProjectile.y * ((meta->_dims.y - 1.0) / 2.0);
				projectileGroupOffset.z -= sizePerProjectile.z * ((meta->_dims.z - 1.0) / 2.0);

				projectileGroupOffset = projSpawnPos.localtoglobalvec(projectileGroupOffset);
				projSpawnPos = projSpawnPos.add_offset(projectileGroupOffset);

				// set spell id (is this even needed?)
				pProjectile->m_Position = projSpawnPos;

				double maxVelocity = 5.0;

				pProjectile->m_Qualities.InqFloat(MAXIMUM_VELOCITY_FLOAT, maxVelocity);

				bool bGravity = false;
				bool bTracking = !meta->_bNonTracking;

				if (pProjectile->InqBoolQuality(GRAVITY_STATUS_BOOL, FALSE))
				{
					pProjectile->m_PhysicsState |= GRAVITY_PS;
					bGravity = true;
				}

				if (pProjectile->InqBoolQuality(INELASTIC_BOOL, FALSE))
					pProjectile->m_PhysicsState |= INELASTIC_PS;
				if (pProjectile->InqBoolQuality(SCRIPTED_COLLISION_BOOL, FALSE))
					pProjectile->m_PhysicsState |= SCRIPTED_COLLISION_PS;
				if (pProjectile->InqBoolQuality(LIGHTS_STATUS_BOOL, FALSE))
					pProjectile->m_PhysicsState |= LIGHTING_ON_PS;

				// pProjectile->m_PhysicsState |= ETHEREAL_PS;

				// set velocity
				Vector spawnVelocity = GetSpellProjectileSpawnVelocity(&spawnSourcePosition, pTarget, maxVelocity, bTracking, bGravity, NULL);

				if (meta->_spreadAngle > 0)
				{
					if (numX > 1)
					{
						double xRatio = x / (double)(numX - 1);
						double theta = DEG2RAD((xRatio - 0.5) * meta->_spreadAngle);
						double cs = cos(theta);
						double sn = sin(theta);
						double px = spawnVelocity.x * cs - spawnVelocity.y * sn;
						double py = spawnVelocity.x * sn + spawnVelocity.y * cs;

						spawnVelocity.x = px;
						spawnVelocity.y = py;
					}
				}

				pProjectile->set_velocity(spawnVelocity, 0);

				// insert the object into the world
				if (g_pWorld->CreateEntity(pProjectile))
				{
					// launch particle effect
					pProjectile->EmitEffect(4, 0.8f);

					/*
					LOG(Temp, Normal, "Projectile Offset @ %.3f %.3f %.3f %f\n",
						createOffset.x + projectileGroupOffset.x,
						createOffset.y + projectileGroupOffset.y,
						createOffset.z + projectileGroupOffset.z, pProjectile->m_velocityVector.magnitude());
						*/
				}
			}
		}
	}

	// LOG(Temp, Normal, "-\n");

	return true;
}

void CSpellcastingManager::PerformCastParticleEffects()
{
	if (!m_bCasting)
		return;

	// self effect
	if (m_SpellCastData.spell->_caster_effect)
	{
		GetCastSource()->EmitEffect(m_SpellCastData.spell->_caster_effect, max(0.0, min(1.0, (m_SpellCastData.power_level_of_power_component - 1.0) / 7.0)));
	}
	
	// target effect
	if (m_SpellCastData.spell->_target_effect)
	{
		if (CWeenieObject *pTarget = GetCastTarget())
			pTarget->EmitEffect(m_SpellCastData.spell->_target_effect, max(0.0, min(1.0, (m_SpellCastData.power_level_of_power_component - 1.0) / 7.0)));
	}
}

void CSpellcastingManager::BeginPortalSend(const Position &targetPos)
{
	if (CPlayerWeenie *player = m_pWeenie->AsPlayer())
	{
		if (!player->IsRecalling())
		{
			player->BeginRecall(targetPos);
		}
	}
	else
	{
		m_pWeenie->Movement_Teleport(targetPos, false);
	}
}

int CSpellcastingManager::LaunchSpellEffect()
{
	if (int targetError = CheckTargetValidity() && m_SpellCastData.range_check)
	{
		switch (targetError)
		{
		case WERROR_MAGIC_TARGET_OUT_OF_RANGE:
			{
				CWeenieObject *pTarget = GetCastTarget();
				if (pTarget)
					pTarget->SendText(csprintf("%s tried to cast a spell on you, but was too far away!", m_pWeenie->GetName().c_str()), LTT_MAGIC);

				m_pWeenie->SendText("That target is too far away!", LTT_MAGIC);
				break;
			}
		}

		return targetError;
	}

	// cast source is assumed to be valid at this point

	if (m_pWeenie->AsPlayer() && m_SpellCastData.uses_mana)
	{
		double chance = GetMagicSkillChance(m_SpellCastData.current_skill, m_SpellCastData.spell->_power);
		if (chance < Random::RollDice(0.0, 1.0))
		{
			// fizzle
			m_pWeenie->EmitEffect(PS_Fizzle, 0.542734265f);
			m_pWeenie->AdjustMana(-5);
			return WERROR_MAGIC_FIZZLE;
		}

		if (m_pWeenie->m_Position.distance(m_SpellCastData.initial_cast_position) >= 6.0)
		{
			// fizzle
			m_pWeenie->EmitEffect(PS_Fizzle, 0.542734265f);
			m_pWeenie->AdjustMana(-5);
			m_pWeenie->SendText("Your movement disrupted spell casting!", LTT_MAGIC);

			return WERROR_MAGIC_FIZZLE;
		}

		m_pWeenie->AdjustMana(-GenerateManaCost());
	}

	bool bSpellPerformed = false;

	if (m_SpellCastData.spellEx && m_SpellCastData.spellEx->_meta_spell._spell)
	{
		switch (m_SpellCastData.spellEx->_meta_spell._sp_type)
		{
		case SpellType::Transfer_SpellType:
			{
				TransferSpellEx *meta = (TransferSpellEx *)m_SpellCastData.spellEx->_meta_spell._spell;
				bSpellPerformed = DoTransferSpell(GetCastTarget(), meta);
				break;
			}
		case SpellType::Boost_SpellType:
			{
				BoostSpellEx *meta = (BoostSpellEx *)m_SpellCastData.spellEx->_meta_spell._spell;

				int boostMin = meta->_boost;
				int boostMax = meta->_boost + meta->_boostVariance;
				if (boostMin > boostMax)
				{
					int swapper = boostMin;
					boostMin = boostMax;
					boostMax = swapper;
				}

				bSpellPerformed = AdjustVital(GetCastTarget(), Random::GenInt(boostMin, boostMax), meta->_dt);
				break;
			}
		case SpellType::Dispel_SpellType:
			{
				DispelSpellEx *meta = (DispelSpellEx *)m_SpellCastData.spellEx->_meta_spell._spell;

				int minNum = (int) ((meta->_number * meta->_number_variance) + F_EPSILON);
				int maxNum = (int) ((meta->_number * (1.0 / meta->_number_variance)) + F_EPSILON);

				int numToDispel = Random::GenInt(minNum, maxNum);

				CWeenieObject *pTarget = GetCastTarget();
				if (pTarget)
				{
					if (!(m_SpellCastData.spell->_bitfield & Beneficial_SpellIndex))
					{
						if (pTarget->GetWorldTopLevelOwner()->ImmuneToDamage(m_pWeenie))
						{
							break;
						}
					}

					PackableListWithJson<DWORD> possibleToDispel;

					if (pTarget->m_Qualities._enchantment_reg)
					{
						if (pTarget->m_Qualities._enchantment_reg->_add_list)
						{
							for (auto &entry : *pTarget->m_Qualities._enchantment_reg->_add_list)
							{
								if (entry._power_level > meta->_max_power)
									continue;
								if (entry._power_level < meta->_min_power)
									continue;
								if (entry._duration <= 0.0)
									continue;
								if ((entry._id & 0xFFFF) == 666) // vitae
									continue;
								
								if (CSpellTableEx *pSpellTableEx = g_pPortalDataEx->GetSpellTableEx())
								{
									if (const CSpellBaseEx *spellBaseEx = pSpellTableEx->GetSpellBase(entry._id & 0xFFFF))
									{
										if (meta->_school && meta->_school != spellBaseEx->_school)
											continue;

										switch (meta->_align)
										{
										case 0: // neutral
											{
												break;
											}
										case 1: // good only
											{
												if (!(spellBaseEx->_bitfield & Beneficial_SpellIndex))
													continue;

												break;
											}
										case 2: // bad only
											{
												if (spellBaseEx->_bitfield & Beneficial_SpellIndex)
													continue;

												break;
											}
										}

										possibleToDispel.push_back(entry._id);
									}
								}
							}
						}

						if (pTarget->m_Qualities._enchantment_reg->_mult_list)
						{
							for (auto &entry : *pTarget->m_Qualities._enchantment_reg->_mult_list)
							{
								if (entry._power_level > meta->_max_power)
									continue;
								if (entry._power_level < meta->_min_power)
									continue;
								if (entry._duration <= 0.0)
									continue;
								if ((entry._id & 0xFFFF) == 666) // vitae
									continue;

								if (CSpellTableEx *pSpellTableEx = g_pPortalDataEx->GetSpellTableEx())
								{
									if (const CSpellBaseEx *spellBaseEx = pSpellTableEx->GetSpellBase(entry._id & 0xFFFF))
									{
										if (meta->_school && meta->_school != spellBaseEx->_school)
											continue;

										switch (meta->_align)
										{
										case 0: // neutral
											{
												break;
											}
										case 1: // good only
											{
												if (!(spellBaseEx->_bitfield & Beneficial_SpellIndex))
													continue;

												break;
											}
										case 2: // bad only
											{
												if (spellBaseEx->_bitfield & Beneficial_SpellIndex)
													continue;

												break;
											}
										}

										possibleToDispel.push_back(entry._id);
									}
								}
							}
						}
					}
					
					PackableListWithJson<DWORD> listToDispel;

					if (meta->_number < 0)
					{
						// dispel all
						listToDispel = possibleToDispel;
					}
					else
					{
						while (numToDispel > 0 && !possibleToDispel.empty())
						{
							std::list<DWORD>::iterator randomEntry = possibleToDispel.begin();
							std::advance(randomEntry, Random::GenUInt(0, (DWORD)(possibleToDispel.size() - 1)));

							listToDispel.push_back(*randomEntry);
							possibleToDispel.erase(randomEntry);

							numToDispel--;
						}
					}

					std::string spellNames;
					for (auto entry : listToDispel)
					{
						if (CSpellTableEx *pSpellTableEx = g_pPortalDataEx->GetSpellTableEx())
						{
							if (const CSpellBaseEx *spellBaseEx = pSpellTableEx->GetSpellBase(entry & 0xFFFF))
							{
								if (spellNames.empty())
								{
									spellNames = spellBaseEx->_name;
								}
								else
								{
									spellNames += ", ";
									spellNames += spellBaseEx->_name;
								}
							}
						}
					}

					// "You cast Incantation of Nullify All Magic Self on yourself and dispel: ..."
					// "Tusker's Friend casts Nullify All Magic Other on you, but the dispel fails."

					if (listToDispel.size() > 0)
					{
						if (pTarget == m_pWeenie)
						{
							m_pWeenie->SendText(csprintf("You cast %s on yourself and dispel: %s", m_SpellCastData.spell->_name.c_str(), spellNames.c_str()), LTT_MAGIC);
						}
						else
						{
							m_pWeenie->SendText(csprintf("You cast %s on %s and dispel: %s", m_SpellCastData.spell->_name.c_str(), pTarget->GetName().c_str(), spellNames.c_str()), LTT_MAGIC);
							pTarget->SendText(csprintf("%s casts %s on you and dispels: %s", m_pWeenie->GetName().c_str(), m_SpellCastData.spell->_name.c_str(), spellNames.c_str()), LTT_MAGIC);
						}

						if (pTarget->m_Qualities._enchantment_reg)
						{
							pTarget->m_Qualities._enchantment_reg->RemoveEnchantments(&listToDispel);

							BinaryWriter expireMessage;
							expireMessage.Write<DWORD>(0x2C8);
							listToDispel.Pack(&expireMessage);
							pTarget->SendNetMessage(&expireMessage, PRIVATE_MSG, TRUE, FALSE);
						}
					}
					else
					{
						if (pTarget == m_pWeenie)
						{
							m_pWeenie->SendText(csprintf("You cast %s on yourself, but the dispel fails.", m_SpellCastData.spell->_name.c_str()), LTT_MAGIC);
						}
						else
						{
							m_pWeenie->SendText(csprintf("You cast %s on %s, but the dispel fails.", m_SpellCastData.spell->_name.c_str(), pTarget->GetName().c_str()), LTT_MAGIC);
							pTarget->SendText(csprintf("%s casts %s on you, but the dispel fails.", m_pWeenie->GetName().c_str(), m_SpellCastData.spell->_name.c_str()), LTT_MAGIC);
						}
					}

					bSpellPerformed = true;
				}

				break;
			}
		case SpellType::PortalLink_SpellType:
			{
				if (m_pWeenie->HasOwner())
					break;

				PortalLinkSpellEx *meta = (PortalLinkSpellEx *)m_SpellCastData.spellEx->_meta_spell._spell;

				CWeenieObject *pTarget = GetCastTarget();
				if (pTarget)
				{
					// portal bitmask, 0x10 = cannot be summoned
					// portal bitmask, 0x20 = cannot be linked/recalled

					switch (meta->_index)
					{
					case 1:
						if (pTarget->m_Qualities.m_WeenieType == LifeStone_WeenieType)
						{
							m_pWeenie->m_Qualities.SetPosition(LINKED_LIFESTONE_POSITION, m_pWeenie->m_Position);
							bSpellPerformed = true;
						}
						else
						{
							m_pWeenie->SendText("You cannot link that.", LTT_MAGIC);
						}
						break;

					case 2: // primary portal tie
						if (pTarget->m_Qualities.m_WeenieType == Portal_WeenieType &&
							!(pTarget->m_Qualities.GetInt(PORTAL_BITMASK_INT, 0) & 0x20))
						{
							m_pWeenie->m_Qualities.SetDataID(LINKED_PORTAL_ONE_DID, pTarget->m_Qualities.id);
							bSpellPerformed = true;
						}
						else
						{
							m_pWeenie->SendText("You cannot link that portal.", LTT_MAGIC);
						}

						break;

					case 3: // secondary portal tie
						if (pTarget->m_Qualities.m_WeenieType == Portal_WeenieType &&
							!(pTarget->m_Qualities.GetInt(PORTAL_BITMASK_INT, 0) & 0x20))
						{
							m_pWeenie->m_Qualities.SetDataID(LINKED_PORTAL_TWO_DID, pTarget->m_Qualities.id);
							bSpellPerformed = true;
						}
						else
						{
							m_pWeenie->SendText("You cannot link that portal.", LTT_MAGIC);
						}

						break;
					}
				}

				if (m_pWeenie->IsAdmin())
				{
					// lifestone tie = 1
					// primary portal tie = 2
					// secondary portal tie = 3
					// m_pWeenie->SendText(csprintf("Index: %d", meta->_index), LTT_DEFAULT);
				}

				break;
			}
		case SpellType::PortalRecall_SpellType:
			{
				if (m_pWeenie->HasOwner())
					break;

				PortalRecallSpellEx *meta = (PortalRecallSpellEx *)m_SpellCastData.spellEx->_meta_spell._spell;

				switch (meta->_index)
				{
				case 2: // lifestone recall
					{
						Position lifestone;
						if (m_pWeenie->m_Qualities.InqPosition(LINKED_LIFESTONE_POSITION, lifestone) && lifestone.objcell_id != 0)
						{
							BeginPortalSend(lifestone);
						}
						else
						{
							m_pWeenie->SendText("You have no lifestone tied.", LTT_MAGIC);
						}

						bSpellPerformed = true;
						break;
					}

				case 3: // portal recall
					{
						Position lastPortalPos;
						if (m_pWeenie->m_Qualities.InqPosition(LAST_PORTAL_POSITION, lastPortalPos) && lastPortalPos.objcell_id != 0)
						{
							BeginPortalSend(lastPortalPos);
						}
						else
						{
							m_pWeenie->SendText("You have not used a recallable portal yet.", LTT_MAGIC);
						}

						bSpellPerformed = true;
						break;
					}

				case 4: // primary portal recall
					{
						// TODO make sure they meet the portal requirements
						DWORD portalDID = 0;
						if (m_pWeenie->m_Qualities.InqDataID(LINKED_PORTAL_ONE_DID, portalDID) && portalDID != 0)
						{
							CWeenieDefaults *portalDefaults = NULL;

							if (portalDID)
							{
								portalDefaults = g_pWeenieFactory->GetWeenieDefaults(portalDID);
							}

							Position portalDest;
							if (portalDefaults->m_Qualities.InqPosition(DESTINATION_POSITION, portalDest) && portalDest.objcell_id != 0)
							{
								BeginPortalSend(portalDest);
							}
							else
							{
								m_pWeenie->SendText("The primary portal you have tied has no destination set.", LTT_MAGIC);
							}
						}
						else
						{
							m_pWeenie->SendText("You have no primary portal tied.", LTT_MAGIC);
						}

						bSpellPerformed = true;
						break;
					}

					break;

				case 5: // secondary portal recall
					{
						// TODO make sure they meet the portal requirements
						DWORD portalDID = 0;
						if (m_pWeenie->m_Qualities.InqDataID(LINKED_PORTAL_TWO_DID, portalDID) && portalDID != 0)
						{
							CWeenieDefaults *portalDefaults = NULL;

							if (portalDID)
							{
								portalDefaults = g_pWeenieFactory->GetWeenieDefaults(portalDID);
							}

							Position portalDest;
							if (portalDefaults->m_Qualities.InqPosition(DESTINATION_POSITION, portalDest) && portalDest.objcell_id != 0)
							{
								BeginPortalSend(portalDest);
							}
							else
							{
								m_pWeenie->SendText("The secondary portal you have tied has no destination set.", LTT_MAGIC);
							}
						}
						else
						{
							m_pWeenie->SendText("You have no secondary portal tied.", LTT_MAGIC);
						}

						bSpellPerformed = true;
						break;
					}

					break;
				}

				if (m_pWeenie->IsAdmin())
				{
					// lifestone recall = 2
					// portal recall = 3
					// primary portal recall = 4
					// secondary portal recall = 5
					// m_pWeenie->SendText(csprintf("Index: %d", meta->_index), LTT_DEFAULT);
				}

				bSpellPerformed = true;
				break;
			}
		case SpellType::Enchantment_SpellType:
			{
				EnchantmentSpellEx *meta = (EnchantmentSpellEx *)m_SpellCastData.spellEx->_meta_spell._spell;

				Enchantment enchant;
				enchant._id = meta->_spell_id | ((DWORD)m_SpellCastData.serial << (DWORD)16);
				enchant.m_SpellSetID = 0; // ???
				enchant._spell_category = m_SpellCastData.spell->_category; // meta->_spellCategory;
				enchant._power_level = m_SpellCastData.spell->_power;
				enchant._start_time = Timer::cur_time;
				enchant._duration = m_SpellCastData.equipped ? -1.0 : meta->_duration;
				enchant._caster = m_pWeenie->GetID();
				enchant._degrade_modifier = meta->_degrade_modifier;
				enchant._degrade_limit = meta->_degrade_limit;
				enchant._last_time_degraded = -1.0;
				enchant._smod = meta->_smod;

				if (enchant._smod.type & Skill_EnchantmentType)
				{
					enchant._smod.key = (DWORD) SkillTable::OldToNewSkill((STypeSkill) enchant._smod.key);
				}

				std::list<CWeenieObject *> targets;
				
				if (CWeenieObject *castTarget = GetCastTarget())
				{
					if (m_SpellCastData.spell->InqTargetType() != ITEM_TYPE::TYPE_ITEM_ENCHANTABLE_TARGET)
					{
						targets.push_back(castTarget);
					}
					else
					{
						CContainerWeenie *container = castTarget->AsContainer();
						if (container && !container->HasOwner())
						{
							for (auto wielded : container->m_Wielded)
							{
								if (wielded->GetItemType() & m_SpellCastData.spell->_non_component_target_type)
								{
									if (castTarget == m_pWeenie || wielded->parent) // for other targets, only physically wielded allowed
									{
										targets.push_back(wielded);
									}
								}
							}
						}
						else
						{
							if (castTarget->GetItemType() & m_SpellCastData.spell->_non_component_target_type)
							{
								if (castTarget == m_pWeenie || castTarget->parent || !castTarget->HasOwner() || castTarget->GetWorldTopLevelOwner() == m_pWeenie) // for other targets, only physically wielded allowed
								{
									targets.push_back(castTarget);
								}
							}
						}
					}

					for (auto target : targets)
					{
						// You cast Harlune's Blessing on yourself, refreshing Harlune's Blessing
						// You cast Impenetrability III on Pathwarden Robe, surpassing Impenetrability II

						CWeenieObject *topLevelOwner = target->GetWorldTopLevelOwner();

						bool bAlreadyExisted = false;
						if (target->m_Qualities._enchantment_reg && target->m_Qualities._enchantment_reg->IsEnchanted(enchant._id))
							bAlreadyExisted = true;

						if (m_pWeenie != target)
						{
							if (!(m_SpellCastData.spell->_bitfield & Beneficial_SpellIndex))
							{
								if (target->AsPlayer() && target->GetWorldTopLevelOwner()->ImmuneToDamage(m_pWeenie))
								{
									continue;
								}
							}

							if (m_SpellCastData.spell->_bitfield & Resistable_SpellIndex)
							{
								if (topLevelOwner->TryMagicResist(m_SpellCastData.current_skill))
								{
									topLevelOwner->EmitSound(Sound_ResistSpell, 1.0f, false);
									topLevelOwner->SendText(csprintf("You resist the spell cast by %s", m_pWeenie->GetName().c_str()), LTT_MAGIC);
									m_pWeenie->SendText(csprintf("%s resists your spell", target->GetName().c_str()), LTT_MAGIC);
									topLevelOwner->ResistedSpell(m_pWeenie);
									topLevelOwner->ChanceExecuteEmoteSet(m_pWeenie->GetID(), ResistSpell_EmoteCategory);
									continue;
								}
							}

							if (int resistMagic = target->InqIntQuality(RESIST_MAGIC_INT, 0, FALSE))
							{
								if (resistMagic >= 9999 || ::TryMagicResist(m_SpellCastData.current_skill, (DWORD) resistMagic))
								{
									target->EmitSound(Sound_ResistSpell, 1.0f, false);

									if (m_pWeenie != topLevelOwner)
									{
										topLevelOwner->SendText(csprintf("%s resists the spell cast by %s", m_pWeenie->GetName().c_str(), m_pWeenie->GetName().c_str()), LTT_MAGIC);
									}

									m_pWeenie->SendText(csprintf("%s resists your spell", target->GetName().c_str()), LTT_MAGIC);
									target->ResistedSpell(m_pWeenie);
									target->ChanceExecuteEmoteSet(m_pWeenie->GetID(), ResistSpell_EmoteCategory);
									continue;
								}
							}
						}

						topLevelOwner->HandleAggro(m_pWeenie);

						target->m_Qualities.UpdateEnchantment(&enchant);
						target->NotifyEnchantmentUpdated(&enchant);

						target->CheckVitalRanges();

						if (m_pWeenie == target)
						{
							m_pWeenie->SendText(csprintf("You cast %s on yourself", m_SpellCastData.spell->_name.c_str()), LTT_MAGIC);
						}
						else
						{
							m_pWeenie->SendText(csprintf("You cast %s on %s", m_SpellCastData.spell->_name.c_str(), target->GetName().c_str()), LTT_MAGIC);

							if (target == topLevelOwner)
							{
								target->SendText(csprintf("%s cast %s on you", m_pWeenie->GetName().c_str(), m_SpellCastData.spell->_name.c_str()), LTT_MAGIC);
							}
							else
							{
								topLevelOwner->SendText(csprintf("%s cast %s on %s", m_pWeenie->GetName().c_str(), m_SpellCastData.spell->_name.c_str(), target->GetName().c_str()), LTT_MAGIC);
							}
						}

						bSpellPerformed = true;
					}
				}

				break;
			}

		case SpellType::PortalSummon_SpellType:
			{
				PortalSummonSpellEx *meta = (PortalSummonSpellEx *)m_SpellCastData.spellEx->_meta_spell._spell;
				if (!meta && (meta->_link == 1 || meta->_link == 2))
					break;

				Position spawnPos;
				if (!m_pWeenie->m_Qualities.InqPosition(PORTAL_SUMMON_LOC_POSITION, spawnPos))
				{
					spawnPos = GetCastSource()->m_Position;
					spawnPos.frame.m_origin += spawnPos.localtoglobalvec(Vector(0, 7, 0));
				}

				DWORD portalDID = 0;

				Position dummyPos;
				bool bNoLink = false;

				switch (meta->_link)
				{
				case 1:
					portalDID = m_pWeenie->InqDIDQuality(LINKED_PORTAL_ONE_DID, 0);

					if (!portalDID && !m_pWeenie->m_Qualities.InqPosition(LINKED_PORTAL_ONE_POSITION, dummyPos))
					{
						m_pWeenie->SendText("You do not have a primary portal tied.", LTT_MAGIC);
						bNoLink = true;
					}

					break;

				case 2:
					portalDID = m_pWeenie->InqDIDQuality(LINKED_PORTAL_TWO_DID, 0);

					if (!portalDID && !m_pWeenie->m_Qualities.InqPosition(LINKED_PORTAL_TWO_POSITION, dummyPos))
					{
						m_pWeenie->SendText("You do not have a secondary portal tied.", LTT_MAGIC);
						bNoLink = true;
					}

					break;
				}

				if (bNoLink)
				{
					break;
				}

				CWeenieDefaults *portalDefaults = NULL;

				if (portalDID)
				{
					portalDefaults = g_pWeenieFactory->GetWeenieDefaults(portalDID);

					if ((portalDefaults->m_Qualities.GetInt(PORTAL_BITMASK_INT, 0) & 0x10) && m_pWeenie->AsPlayer())
					{
						m_pWeenie->SendText("That portal may not be summoned.", LTT_MAGIC);
						break;
					}
				}

				CWeenieObject *weenie = g_pWeenieFactory->CreateWeenieByClassID(W_PORTALGATEWAY_CLASS, &spawnPos, false);

				if (weenie)
				{
					weenie->_timeToRot = Timer::cur_time + meta->_portal_lifetime;
					weenie->_beganRot = false;
					weenie->m_Qualities.SetFloat(TIME_TO_ROT_FLOAT, weenie->_timeToRot);

					bool bHasDestination = false;

					if (portalDefaults)
					{
						weenie->CopyPositionStat(DESTINATION_POSITION, &portalDefaults->m_Qualities);
						weenie->CopyIntStat(MIN_LEVEL_INT, &portalDefaults->m_Qualities);
						weenie->CopyIntStat(MAX_LEVEL_INT, &portalDefaults->m_Qualities);
						weenie->CopyIntStat(PORTAL_BITMASK_INT, &portalDefaults->m_Qualities);
					}
					else
					{
						switch (meta->_link)
						{
						case 1:
							weenie->m_Qualities.SetPosition(DESTINATION_POSITION, m_pWeenie->InqPositionQuality(LINKED_PORTAL_ONE_POSITION, Position()));
							break;

						case 2:
							weenie->m_Qualities.SetPosition(DESTINATION_POSITION, m_pWeenie->InqPositionQuality(LINKED_PORTAL_TWO_POSITION, Position()));
							break;
						}
					}

					g_pWorld->CreateEntity(weenie);

					bSpellPerformed = true;
				}

				break;
			}

		case SpellType::PortalSending_SpellType:
			{
				PortalSendingSpellEx *meta = (PortalSendingSpellEx *)m_SpellCastData.spellEx->_meta_spell._spell;

				CWeenieObject *target = GetCastTarget();

				if (target)
				{
					PerformCastParticleEffects(); // perform particle effects early because teleporting will cancel it
					target->Movement_Teleport(meta->_pos, false);
					target->SendText("You have been teleported.", LTT_MAGIC);
				}

				break;
			}

		case SpellType::Projectile_SpellType:
			{
				ProjectileSpellEx *meta = (ProjectileSpellEx *)m_SpellCastData.spellEx->_meta_spell._spell;
				bSpellPerformed = LaunchProjectileSpell(meta);
				break;
			}
		}
	}

	if (bSpellPerformed)
	{
		PerformCastParticleEffects();
	}

	return WERROR_NONE;
}

// You gain 37 points of health due to casting Drain Health Other I on Gelidite Lord
void CSpellcastingManager::TransferVitalPercent(CWeenieObject *target, float drainPercent, float infusePercent, STypeAttribute2nd attribute)
{
	if (!target || target->IsDead())
		return;

	bool reversed = (m_SpellCastData.spell->_bitfield & Reversed_SpellIndex) ? true : false;

	int targetAdjust;
	int selfAdjust;

	if (reversed)
	{
		// draining target, infusing self
		targetAdjust = -(int)ceil(target->GetHealth() * drainPercent);
		if (targetAdjust < -50)
			targetAdjust = -50;

		selfAdjust = (int)floor(-targetAdjust * infusePercent);
	}
	else
	{
		// draining self, infusing target
		selfAdjust = -(int)ceil(m_pWeenie->GetHealth() * drainPercent);
		targetAdjust = (int)floor(-selfAdjust * infusePercent);
	}

	if (targetAdjust < 0 && target->ImmuneToDamage(m_pWeenie))
	{
		// send notice they are immune?
		return;
	}

	const char *vitalName;
	switch (attribute)
	{
	case HEALTH_ATTRIBUTE_2ND:
		{
			selfAdjust = m_pWeenie->AdjustHealth(selfAdjust);
			targetAdjust = target->AdjustHealth(targetAdjust);
			vitalName = "health";
			break;
		}
	case STAMINA_ATTRIBUTE_2ND:
		{
			selfAdjust = m_pWeenie->AdjustStamina(selfAdjust);
			targetAdjust = target->AdjustStamina(targetAdjust);
			vitalName = "stamina";
			break;
		}
	case MANA_ATTRIBUTE_2ND:
		{
			selfAdjust = m_pWeenie->AdjustMana(selfAdjust);
			targetAdjust = target->AdjustMana(targetAdjust);
			vitalName = "mana";
			break;
		}
	default:
		return;
	}

	SendTransferVitalPercentText(target, reversed ? targetAdjust : selfAdjust, reversed ? selfAdjust : targetAdjust, reversed, vitalName);

	if (target->IsDead())
	{
		if (m_pWeenie == target)
		{
			target->NotifyVictimEvent("You died!");

			if (target->_IsPlayer())
			{
				target->NotifyDeathMessage(m_pWeenie->GetID(), csprintf("%s died!", target->GetName().c_str()));
			}
		}
		else
		{
			target->NotifyVictimEvent(csprintf("You were killed by %s!", m_pWeenie->GetName().c_str()));
			m_pWeenie->NotifyKillerEvent(csprintf("You killed %s!", target->GetName().c_str()));

			if (target->_IsPlayer())
			{
				target->NotifyDeathMessage(m_pWeenie->GetID(), csprintf("%s killed %s!", m_pWeenie->GetName().c_str(), target->GetName().c_str()));
			}
		}

		target->OnDeath(m_pWeenie->GetID());
	}

	if (m_pWeenie != target && m_pWeenie->IsDead())
	{
		m_pWeenie->NotifyVictimEvent("You died!");

		if (m_pWeenie->_IsPlayer())
		{
			m_pWeenie->NotifyDeathMessage(m_pWeenie->GetID(), csprintf("%s died!", m_pWeenie->GetName().c_str()));
		}

		m_pWeenie->OnDeath(m_pWeenie->GetID());
	}
}

void CSpellcastingManager::SendTransferVitalPercentText(CWeenieObject *target, int drained, int infused, bool reversed, const char *vitalName)
{
	// You gain 37 points of health due to casting Drain Health Other I on Gelidite Lord

	m_pWeenie->SendText(csprintf("You %s %d points of %s due to casting %s on %s",
		reversed ? "gain" : "lose", reversed ? infused : -drained, vitalName, m_SpellCastData.spell->_name.c_str(), target->GetName().c_str()), LTT_MAGIC);

	if (target != m_pWeenie)
	{
		target->SendText(csprintf("You %s %d points of %s due to %s casting %s on you",
			!reversed ? "gain" : "lose", !reversed ? infused : -drained, vitalName, m_SpellCastData.spell->_name.c_str(), m_pWeenie->GetName().c_str()), LTT_MAGIC);
	}
}

std::string GetAttribute2ndName(STypeAttribute2nd attribute2nd)
{
	switch (attribute2nd)
	{
	case MAX_HEALTH_ATTRIBUTE_2ND:
		return "maximum health";
	case HEALTH_ATTRIBUTE_2ND:
		return "health";
	case MAX_STAMINA_ATTRIBUTE_2ND:
		return "maximum stamina";
	case STAMINA_ATTRIBUTE_2ND:
		return "stamina";
	case MAX_MANA_ATTRIBUTE_2ND:
		return "maximum mana";
	case MANA_ATTRIBUTE_2ND:
		return "mana";
	}

	return "";
}

bool CSpellcastingManager::DoTransferSpell(CWeenieObject *other, const TransferSpellEx *meta)
{
	// Calculate source amount
	CWeenieObject *source = NULL;
	if (meta->_bitfield & TransferSpellEx::SourceSelf)
		source = GetCastSource();
	else if (meta->_bitfield & TransferSpellEx::SourceOther)
		source = other;

	CWeenieObject *dest = NULL;
	if (meta->_bitfield & TransferSpellEx::DestinationSelf)
		dest = GetCastSource();
	else if (meta->_bitfield & TransferSpellEx::DestinationOther)
		dest = other;

	if (!source || !dest)
		return false;

	double drainResistMod = 1.0;
	double boostResistMod = 1.0;

	if (m_pWeenie != source)
	{
		// negative spell
		if (source->ImmuneToDamage(m_pWeenie))
		{
			return false;
		}
		
		// try to resist
		if (m_SpellCastData.spell->_bitfield & Resistable_SpellIndex)
		{
			if (source->TryMagicResist(m_SpellCastData.current_skill))
			{
				source->EmitSound(Sound_ResistSpell, 1.0f, false);
				source->SendText(csprintf("You resist the spell cast by %s", m_pWeenie->GetName().c_str()), LTT_MAGIC);
				m_pWeenie->SendText(csprintf("%s resists your spell", source->GetName().c_str()), LTT_MAGIC);
				source->ResistedSpell(m_pWeenie);
				source->ChanceExecuteEmoteSet(m_pWeenie->GetID(), ResistSpell_EmoteCategory);
				return false;
			}
		}

		source->HandleAggro(m_pWeenie);

		switch (meta->_src)
		{
		case HEALTH_ATTRIBUTE_2ND:
			source->m_Qualities.InqFloat(RESIST_HEALTH_DRAIN_FLOAT, drainResistMod);
			break;
		case STAMINA_ATTRIBUTE_2ND:
			source->m_Qualities.InqFloat(RESIST_STAMINA_DRAIN_FLOAT, drainResistMod);
			break;
		case MANA_ATTRIBUTE_2ND:
			source->m_Qualities.InqFloat(RESIST_MANA_DRAIN_FLOAT, drainResistMod);
			break;
		}
	}

	if (m_pWeenie != dest)
	{
		switch (meta->_src)
		{
		case HEALTH_ATTRIBUTE_2ND:
			dest->m_Qualities.InqFloat(RESIST_HEALTH_BOOST_FLOAT, boostResistMod);
			break;
		case STAMINA_ATTRIBUTE_2ND:
			dest->m_Qualities.InqFloat(RESIST_STAMINA_DRAIN_FLOAT, boostResistMod);
			break;
		case MANA_ATTRIBUTE_2ND:
			dest->m_Qualities.InqFloat(RESIST_MANA_DRAIN_FLOAT, boostResistMod);
			break;
		}
	}

	DWORD sourceStartValue = 0;
	DWORD sourceMinValue = 0;
	DWORD sourceMaxValue = 0;
	source->m_Qualities.InqAttribute2nd(meta->_src, sourceStartValue, FALSE);
	source->m_Qualities.InqAttribute2nd((STypeAttribute2nd)((int)meta->_src - 1), sourceMaxValue, FALSE);

	DWORD destStartValue = 0;
	DWORD destMinValue = 0;
	DWORD destMaxValue = 0;
	dest->m_Qualities.InqAttribute2nd(meta->_dest, destStartValue, FALSE);
	dest->m_Qualities.InqAttribute2nd((STypeAttribute2nd)((int)meta->_dest - 1), destMaxValue, FALSE);

	int sourceTakeAmount = (int)(sourceStartValue * meta->_proportion * drainResistMod);
	if (meta->_transferCap && sourceTakeAmount > meta->_transferCap)
		sourceTakeAmount = meta->_transferCap;

	int destGiveAmount = (int)(sourceTakeAmount * (1.0 - meta->_lossPercent) * boostResistMod);

	int destResultValue = destStartValue + destGiveAmount;
	if (destResultValue > destMaxValue)
	{
		destResultValue = destMaxValue;
		destGiveAmount = destMaxValue - destStartValue;
		sourceTakeAmount = (int)(destGiveAmount / (1.0 - meta->_lossPercent));
	}
	int sourceResultValue = sourceStartValue - sourceTakeAmount;
	
	if (sourceResultValue != sourceStartValue)
	{
		source->m_Qualities.SetAttribute2nd(meta->_src, sourceResultValue);
		source->NotifyAttribute2ndStatUpdated(meta->_src);
	}

	if (destResultValue != destStartValue)
	{
		dest->m_Qualities.SetAttribute2nd(meta->_dest, destResultValue);
		dest->NotifyAttribute2ndStatUpdated(meta->_dest);
	}

	if (source == dest)
	{
		// You cast Stamina to Mana Self III on yourself and lose 78 points of stamina and also gain 86 points of mana
		if (m_pWeenie == source)
		{
			source->SendText(csprintf(
				"You cast %s on yourself and lose %d points of %s and also gain %d points of %s",
				m_SpellCastData.spell->_name.c_str(), sourceTakeAmount, GetAttribute2ndName(meta->_src).c_str(), destGiveAmount, GetAttribute2ndName(meta->_dest).c_str()
				), LTT_MAGIC);
		}
		else
		{
			source->SendText(csprintf(
				"You lose %d points of %s and also gain %d points of %s due to %s casting %s on you",
				sourceTakeAmount, GetAttribute2ndName(meta->_src).c_str(), destGiveAmount, GetAttribute2ndName(meta->_dest).c_str(), m_pWeenie->GetName().c_str(), m_SpellCastData.spell->_name.c_str()
			), LTT_MAGIC);
		}
	}
	else
	{
		if (m_pWeenie == source)
		{
			source->SendText(csprintf("You lose %d points of %s due to casting %s on %s",
				sourceTakeAmount, GetAttribute2ndName(meta->_src).c_str(), m_SpellCastData.spell->_name.c_str(), dest->GetName().c_str()), LTT_MAGIC);
			dest->SendText(csprintf("You gain %d points of %s due to %s casting %s on you",
				destGiveAmount, GetAttribute2ndName(meta->_dest).c_str(), m_pWeenie->GetName().c_str(), m_SpellCastData.spell->_name.c_str()), LTT_MAGIC);
		}
		else if (m_pWeenie == dest)
		{
			dest->SendText(csprintf("You gain %d points of %s due to casting %s on %s",
				destGiveAmount, GetAttribute2ndName(meta->_dest).c_str(), m_SpellCastData.spell->_name.c_str(), source->GetName().c_str()), LTT_MAGIC);
			source->SendText(csprintf("You lose %d points of %s due to %s casting %s on you",
				sourceTakeAmount, GetAttribute2ndName(meta->_src).c_str(), m_pWeenie->GetName().c_str(), m_SpellCastData.spell->_name.c_str()), LTT_MAGIC);
		}
		else
		{
			// should never happen
		}
	}

	if (meta->_src == HEALTH_ATTRIBUTE_2ND)
		source->CheckDeath(m_pWeenie, DAMAGE_TYPE::HEALTH_DAMAGE_TYPE);

	return true;
}

bool CSpellcastingManager::AdjustVital(CWeenieObject *target, int amount, DAMAGE_TYPE dt)
{
	if (!target || target->IsDead())
		return false;

	// negative spell
	if (amount < 0)
	{
		if (target->ImmuneToDamage(m_pWeenie))
		{
			return false;
		}

		// try to resist
		if (m_SpellCastData.spell->_bitfield & Resistable_SpellIndex)
		{
			if (target->TryMagicResist(m_SpellCastData.current_skill))
			{
				target->EmitSound(Sound_ResistSpell, 1.0f, false);
				target->SendText(csprintf("You resist the spell cast by %s", m_pWeenie->GetName().c_str()), LTT_MAGIC);
				m_pWeenie->SendText(csprintf("%s resists your spell", target->GetName().c_str()), LTT_MAGIC);
				target->ResistedSpell(m_pWeenie);
				target->ChanceExecuteEmoteSet(m_pWeenie->GetID(), ResistSpell_EmoteCategory);
				return false;
			}
		}
	}

	target->HandleAggro(m_pWeenie);

	const char *vitalName;
	switch (dt)
	{
	case HEALTH_DAMAGE_TYPE:
		{
			amount = target->AdjustHealth(amount);
			vitalName = "health";
			break;
		}
	case STAMINA_DAMAGE_TYPE:
		{
			amount = target->AdjustStamina(amount);
			vitalName = "stamina";
			break;
		}
	case MANA_DAMAGE_TYPE:
		{
			amount = target->AdjustMana(amount);
			vitalName = "mana";
			break;
		}
	default:
		return false;
	}

	SendAdjustVitalText(target, amount, vitalName);

	target->CheckDeath(GetCastSource(), dt);

	return true;
}

void CSpellcastingManager::SendAdjustVitalText(CWeenieObject *target, int amount, const char *vitalName)
{
	bool bRestore = true;
	if (amount < 0 || (amount == 0 && !(m_SpellCastData.spell->_bitfield & Beneficial_SpellIndex)))
	{
		bRestore = false;
		amount = -amount;
	}
	
	if (m_pWeenie != target)
	{
		m_pWeenie->SendText(csprintf("With %s you %s %d points of %s %s %s.",
			m_SpellCastData.spell->_name.c_str(), bRestore ? "restore" : "drain", amount, vitalName, bRestore ? "to" : "from", target->GetName().c_str()), LTT_MAGIC);

		target->SendText(csprintf("%s casts %s and %s %d points of your %s.",
			m_pWeenie->GetName().c_str(), m_SpellCastData.spell->_name.c_str(), bRestore ? "restores" : "drains", amount, vitalName), LTT_MAGIC);
	}
	else
	{
		m_pWeenie->SendText(csprintf("You cast %s and %s %d points of your %s.",
			m_SpellCastData.spell->_name.c_str(), bRestore ? "restore" : "drain", amount, vitalName), LTT_MAGIC);
	}
}

int CSpellcastingManager::CreatureBeginCast(DWORD target_id, DWORD spell_id)
{
	if (m_bCasting)
		return WERROR_ACTIONS_LOCKED;

	m_SpellCastData = SpellCastData();
	m_SpellCastData.caster_id = m_pWeenie->GetID();
	m_SpellCastData.source_id = m_pWeenie->GetTopLevelID();
	m_SpellCastData.target_id = target_id;
	m_SpellCastData.spell_id = spell_id;
	m_SpellCastData.wand_id = m_pWeenie->GetWieldedCasterID();

	m_SpellCastData.cast_timeout = Timer::cur_time + 10.0f;
	m_SpellCastData.initial_cast_position = m_pWeenie->m_Position;

	if (!ResolveSpellBeingCasted())
	{
		LOG(Temp, Normal, "Player trying to cast unknown spell?\n");
		return WERROR_MAGIC_GENERAL_FAILURE;
	}

	m_bCasting = true;
	m_PendingMotions.clear();
	m_bTurningToObject = false;
	
	m_PendingMotions.push_back(SpellCastingMotion(Motion_CastSpell, 2.0f, true, true, 2.0f));
	m_SpellCastData.power_level_of_power_component = m_SpellCastData.spell_formula.GetPowerLevelOfPowerComponent();

	BeginNextMotion();

	return WERROR_NONE;
}


int CSpellcastingManager::CastSpellInstant(DWORD target_id, DWORD spell_id)
{
	int error = WERROR_NONE;

	// incase we are interrupting a cast
	SpellCastData oldData = m_SpellCastData;
	bool bOldCasting = m_bCasting;
	
	m_bCasting = true;
	m_SpellCastData = SpellCastData();
	m_SpellCastData.caster_id = m_pWeenie->GetID();
	m_SpellCastData.source_id = m_pWeenie->GetTopLevelID();
	m_SpellCastData.target_id = target_id;
	m_SpellCastData.spell_id = spell_id;
	m_SpellCastData.wand_id = m_pWeenie->GetWieldedCasterID();
	m_SpellCastData.cast_timeout = Timer::cur_time + 10.0f;
	m_SpellCastData.power_level_of_power_component = m_SpellCastData.spell_formula.GetPowerLevelOfPowerComponent();
	m_SpellCastData.initial_cast_position = m_pWeenie->m_Position;
	m_SpellCastData.uses_mana = false;

	if (ResolveSpellBeingCasted())
	{
		LaunchSpellEffect();		
	}
	else
	{
		error = WERROR_MAGIC_GENERAL_FAILURE;
	}

	m_SpellCastData = oldData;
	m_bCasting = bOldCasting;

	return error;
}


int CSpellcastingManager::CastSpellEquipped(DWORD target_id, DWORD spell_id, WORD serial)
{
	int error = WERROR_NONE;

	// incase we are interrupting a cast
	SpellCastData oldData = m_SpellCastData;
	bool bOldCasting = m_bCasting;

	m_bCasting = true;
	m_SpellCastData = SpellCastData();
	m_SpellCastData.caster_id = m_pWeenie->GetID();
	m_SpellCastData.source_id = m_pWeenie->GetTopLevelID();
	m_SpellCastData.target_id = target_id;
	m_SpellCastData.spell_id = spell_id;
	m_SpellCastData.wand_id = m_pWeenie->GetWieldedCasterID();
	m_SpellCastData.cast_timeout = Timer::cur_time + 10.0f;
	m_SpellCastData.power_level_of_power_component = m_SpellCastData.spell_formula.GetPowerLevelOfPowerComponent();
	m_SpellCastData.initial_cast_position = m_pWeenie->m_Position;
	m_SpellCastData.uses_mana = false;
	m_SpellCastData.equipped = true;
	m_SpellCastData.serial = serial;

	if (ResolveSpellBeingCasted())
	{
		LaunchSpellEffect();
	}
	else
	{
		error = WERROR_MAGIC_GENERAL_FAILURE;
	}

	m_SpellCastData = oldData;
	m_bCasting = bOldCasting;

	return error;
}

DWORD CSpellcastingManager::DetermineSkillLevelForSpell()
{
	int spellcraft = 0;
	if (m_pWeenie->m_Qualities.InqInt(ITEM_SPELLCRAFT_INT, spellcraft, FALSE, FALSE))
		return (DWORD)spellcraft;

	if (!m_SpellCastData.spell)
		return 0;

	DWORD skillLevel = 0;
	STypeSkill skill = m_SpellCastData.spell->InqSkillForSpell();

	if (skill)
	{
		m_pWeenie->InqSkill(skill, skillLevel, FALSE);
	}
	else
	{
		DWORD creatureEnch = 0, itemEnch = 0, life = 0, war = 0, voidMagic = 0;
		m_pWeenie->InqSkill(CREATURE_ENCHANTMENT_SKILL, creatureEnch, FALSE);
		m_pWeenie->InqSkill(ITEM_ENCHANTMENT_SKILL, itemEnch, FALSE);
		m_pWeenie->InqSkill(LIFE_MAGIC_SKILL, life, FALSE);
		m_pWeenie->InqSkill(WAR_MAGIC_SKILL, war, FALSE);
		m_pWeenie->InqSkill(VOID_MAGIC_SKILL, voidMagic, FALSE);

		DWORD highestSkill = 0;

		highestSkill = max(highestSkill, creatureEnch);
		highestSkill = max(highestSkill, itemEnch);
		highestSkill = max(highestSkill, life);
		highestSkill = max(highestSkill, war);
		highestSkill = max(highestSkill, voidMagic);

		skillLevel = highestSkill;
	}
	return skillLevel;
}

double CSpellcastingManager::DetermineSpellRange()
{
	if (!m_SpellCastData.spell)
		return 0.0;

	double range = m_SpellCastData.spell->_base_range_constant + m_SpellCastData.spell->_base_range_mod * m_SpellCastData.current_skill;

	const float RADAR_OUTDOOR_RADIUS = 75.0f;
	if (range > RADAR_OUTDOOR_RADIUS)
		range = RADAR_OUTDOOR_RADIUS;

	return range;
}

int CSpellcastingManager::CheckTargetValidity()
{
	if (!m_SpellCastData.spell)
		return WERROR_MAGIC_GENERAL_FAILURE;

	CWeenieObject *pCastSource = GetCastSource();
	if (!pCastSource)
		return WERROR_OBJECT_GONE;

	CWeenieObject *pTarget = g_pWorld->FindWithinPVS(pCastSource, m_SpellCastData.target_id);

	if (!(m_SpellCastData.spell->_bitfield & SelfTargeted_SpellIndex))
	{
		if (!pTarget)
			return WERROR_OBJECT_GONE;

		if (!pTarget->HasOwner() || !pCastSource->FindContainedItem(pTarget->GetID()))
		{
			if (pCastSource && m_SpellCastData.range_check)
			{
				if (pCastSource->DistanceTo(pTarget, true) > m_SpellCastData.max_range)
					return WERROR_MAGIC_TARGET_OUT_OF_RANGE;
			}
		}
	}

	int targetType = m_SpellCastData.spell->InqTargetType();
	if (targetType != ITEM_TYPE::TYPE_UNDEF)
	{
		if (!pTarget)
			return WERROR_OBJECT_GONE;

		if (targetType == ITEM_TYPE::TYPE_ITEM_ENCHANTABLE_TARGET && !m_SpellCastData.equipped)
		{
			targetType |= TYPE_CREATURE;
		}

		if (!(pTarget->GetItemType() & targetType))
		{
			if (m_SpellCastData.equipped && (m_SpellCastData.spell->_school == 3) && (m_SpellCastData.spell->_bitfield & SelfTargeted_SpellIndex))
			{
			}
			else
			{
				return WERROR_MAGIC_BAD_TARGET_TYPE;
			}
		}
	}

	if (pTarget->IsCreature())
	{
		if (pTarget->IsVendor())
			return WERROR_MAGIC_BAD_TARGET_TYPE;
	}

	return WERROR_NONE;
}

int CSpellcastingManager::GenerateManaCost()
{
	DWORD manaConvSkill = m_pWeenie->GetEffectiveManaConversionSkill();

	return GetManaCost(m_SpellCastData.current_skill, m_SpellCastData.spell->_power, m_SpellCastData.spell->_base_mana, manaConvSkill);
}

int CSpellcastingManager::TryBeginCast(DWORD target_id, DWORD spell_id)
{
	if (m_bCasting)
	{
		// m_pWeenie->SendText(csprintf("DEBUG: Actions Locked, Casting = true, Turning = %s", m_bTurningToObject ? "true" : "false"), LTT_ALL_CHANNELS);
		return WERROR_ACTIONS_LOCKED;
	}

	if (m_pWeenie->get_minterp()->interpreted_state.actions.size())
	{
		// m_pWeenie->SendText(csprintf("DEBUG: Actions Locked, Interp state has %d actions.", m_pWeenie->get_minterp()->interpreted_state.actions.size()), LTT_ALL_CHANNELS);
		return WERROR_ACTIONS_LOCKED;
	}

	if (m_pWeenie->get_minterp()->interpreted_state.forward_command != 0x41000003)
	{
		// m_pWeenie->SendText(csprintf("DEBUG: Unprepared, Interp state forward command is 0x%08X, not idle.", m_pWeenie->get_minterp()->interpreted_state.forward_command), LTT_ALL_CHANNELS);
		return WERROR_MAGIC_UNPREPARED;
	}

	if (!m_pWeenie->m_Qualities.IsSpellKnown(spell_id))
	{
		// m_pWeenie->SendText(csprintf("DEBUG: Unlearned spell %d.", spell_id), LTT_ALL_CHANNELS);
		return WERROR_MAGIC_UNLEARNED_SPELL;
	}

	if (Timer::cur_time < m_fNextCastTime)
	{
		// m_pWeenie->SendText(csprintf("DEBUG: Actions Locked, Can't cast for %.3f more seconds.", Timer::cur_time - m_fNextCastTime), LTT_ALL_CHANNELS);
		return WERROR_ACTIONS_LOCKED;
	}

	m_SpellCastData = SpellCastData(); // reset
	m_SpellCastData.caster_id = m_pWeenie->GetID();
	m_SpellCastData.source_id = m_pWeenie->GetTopLevelID();
	m_SpellCastData.target_id = target_id;
	m_SpellCastData.spell_id = spell_id;
	m_SpellCastData.wand_id = m_pWeenie->GetWieldedCasterID();
	m_SpellCastData.cast_timeout = Timer::cur_time + 10.0f;
	m_SpellCastData.initial_cast_position = m_pWeenie->m_Position;

	if (!ResolveSpellBeingCasted())
	{
		LOG(Temp, Normal, "Player trying to cast unknown spell?\n"); 
		return WERROR_MAGIC_GENERAL_FAILURE;
	}

	if (!m_SpellCastData.current_skill)
	{
		m_pWeenie->SendText("You are not trained in that skill!", LTT_MAGIC);
		return WERROR_MAGIC_INVALID_SPELL_TYPE;
	}

	// m_pWeenie->SendText(csprintf("Casting %d", m_SpellCastData.spell_id), LTT_DEFAULT);

	if (int targetError = CheckTargetValidity())
		return targetError;

	if (m_pWeenie->GetMana() < GenerateManaCost())
		return WERROR_MAGIC_INSUFFICIENT_MANA;

	BeginCast();
	return WERROR_NONE;
}

void CSpellcastingManager::Update()
{
	if (!m_bCasting)
	{
		return;
	}

	if (m_SpellCastData.cast_timeout <= Timer::cur_time)
	{
		EndCast(WERROR_MAGIC_GENERAL_FAILURE);
		m_bCasting = false;
	}

	if (m_bTurningToObject)
	{
		if (m_pWeenie->movement_manager->moveto_manager->movement_type != MovementTypes::TurnToObject)
		{
			if (HeadingToTarget() <= MAX_HEADING_TO_TARGET_FOR_CAST)
			{
				// if (!m_pWeenie->get_minterp()->interpreted_state.turn_command)
				{
					BeginNextMotion();
				}
			}
			else
			{
				if (!m_pWeenie->get_minterp()->interpreted_state.turn_command)
				{
					MovementParameters params;
					params.speed = 1.0f;
					params.action_stamp = ++m_pWeenie->m_wAnimSequence;
					m_pWeenie->last_move_was_autonomous = false;
					m_pWeenie->TurnToObject(m_SpellCastData.target_id, &params);
					//m_bTurningToObject = true;
					//m_fCastTimeout = Timer::cur_time + MAX_TURN_TIME_FOR_CAST;
				}
			}
		}
		else
		{
			/*
			CWeenieObject *pTarget = g_pWorld->FindWithinPVS(m_pWeenie, m_TargetID);
			if (pTarget)
			{
				LOG(Temp, Normal, "%f (%f %f) %08X %f %f %f\n",
					HeadingToTarget(),
					m_pWeenie->m_Position.heading(pTarget->m_Position),
					m_pWeenie->m_Position.frame.get_heading(),
					m_pWeenie->get_minterp()->interpreted_state.turn_command,
					m_pWeenie->movement_manager->moveto_manager->sought_position.frame.get_heading(),
					m_pWeenie->get_heading(),
					m_pWeenie->get_heading() - m_pWeenie->movement_manager->moveto_manager->sought_position.frame.get_heading());
			}
			*/
		}
	}
}

void CSpellcastingManager::Cancel()
{
	if (!m_bCasting)
	{
		return;
	}

	EndCast(WErrorType::WERROR_MAGIC_UNPREPARED);
	m_bCasting = false;
}

void CSpellcastingManager::OnDeath(DWORD killer_id)
{
	Cancel();
}

void CSpellcastingManager::HandleMotionDone(DWORD motion, BOOL success)
{
	if (!m_bCasting)
		return;

	if (m_bTurningToObject)
		return;

	if (m_PendingMotions.empty() || m_PendingMotions.begin()->motion != motion)
		return;

	if (!success)
	{
		EndCast(WERROR_MAGIC_GENERAL_FAILURE);
		return;
	}

	m_PendingMotions.pop_front();
	BeginNextMotion();
}