spells.cpp

// START A3HEADER
//
// This source file is part of the Atlantis PBM game program.
// Copyright (C) 1995-1999 Geoff Dunbar
//
// 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 2
// 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, in the file license.txt. If not, write
// to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
// Boston, MA 02111-1307, USA.
//
// See the Atlantis Project web page for details:
// http://www.prankster.com/project
//
// END A3HEADER
#include "game.h"
#include "faction.h"
#include "unit.h"
#include "gamedata.h"
#include "object.h"
#include "orders.h"
#include "gameio.h"

struct SpellMechanic
{
	enum Type
	{
		SUMMON
	};
	const Type t;
	const char *summon_abbr;
	const int max_summon;
	const int level_scale;
	const int constant;
	const char *activity_abbr;
	const bool random;
};

UnitId* ParseUnit(AString *s);

void Game::ProcessCastOrder(Unit *u, AString *o, OrdersCheck *pCheck)
{
	AString *token = o->gettoken();
	if (!token) {
		ParseError(pCheck, u, 0, "CAST: No skill given.");
		return;
	}

	const int sk = ParseSkill(token);
	delete token;

	if (sk == -1) {
		ParseError(pCheck, u, 0, "CAST: Invalid skill.");
		return;
	}

	if(!(SkillDefs[sk].flags & SkillType::MAGIC)) {
		ParseError(pCheck, u, 0, "CAST: That is not a magic skill.");
		return;
	}
	if(!(SkillDefs[sk].flags & SkillType::CAST)) {
		ParseError(pCheck, u, 0, "CAST: That skill cannot be CAST.");
		return;
	}

	switch(sk)
	{
	case S_GATE_LORE:
		ProcessCastGateLore(u, o, pCheck);
		break;

	case S_FARSIGHT:
	case S_TELEPORTATION:
	case S_WEATHER_LORE:
		ProcessRegionSpell(u, o, sk, pCheck);
		break;

	case S_PORTAL_LORE:
		ProcessCastPortalLore(u, o, pCheck);
		break;

	case S_MIND_READING:
		ProcessMindReading(u, o, pCheck);
		break;

	case S_CLEAR_SKIES:
		if(SkillDefs[S_CLEAR_SKIES].rangeIndex != -1)
			ProcessRegionSpell(u, o, sk, pCheck);
		else
			ProcessGenericSpell(u, sk, pCheck);
		break;

	case S_CONSTRUCT_PORTAL:
	case S_CONSTRUCT_GATE:
	case S_ENGRAVE_RUNES_OF_WARDING:
	case S_SUMMON_IMPS:
	case S_SUMMON_DEMON:
	case S_SUMMON_BALROG:
	case S_SUMMON_SKELETONS:
	case S_RAISE_UNDEAD:
	case S_SUMMON_LICH:
	case S_DRAGON_LORE:
	case S_WOLF_LORE:
	case S_EARTH_LORE:
	case S_CREATE_RING_OF_INVISIBILITY:
	case S_CREATE_CLOAK_OF_INVULNERABILITY:
	case S_CREATE_STAFF_OF_FIRE:
	case S_CREATE_STAFF_OF_LIGHTNING:
	case S_CREATE_AMULET_OF_TRUE_SEEING:
	case S_CREATE_AMULET_OF_PROTECTION:
	case S_CREATE_RUNESWORD:
	case S_CREATE_SHIELDSTONE:
	case S_CREATE_MAGIC_CARPET:
	case S_CREATE_FOOD:
		ProcessGenericSpell(u, sk, pCheck);
		break;

	case S_BIRD_LORE:
		ProcessBirdLore(u, o, pCheck);
		break;

	case S_CREATE_PHANTASMAL_BEASTS:
		ProcessPhanBeasts(u, o, pCheck);
		break;

	case S_CREATE_PHANTASMAL_UNDEAD:
		ProcessPhanUndead(u, o, pCheck);
		break;

	case S_CREATE_PHANTASMAL_DEMONS:
		ProcessPhanDemons(u, o, pCheck);
		break;

	case S_INVISIBILITY:
		ProcessInvisibility(u, o, pCheck);
		break;

	case S_ENCHANT_SWORDS:
	case S_ENCHANT_ARMOR:
		ProcessEnchantSpell(u, o, sk, pCheck);
		break;
	}
}

void Game::ProcessMindReading(Unit *u, AString *o, OrdersCheck *pCheck)
{
	UnitId *id = ParseUnit(o);
	if (!id) {
		ParseError(pCheck, u, 0, "CAST: No unit specified.");
		return;
	}

	CastMindOrder *order = new CastMindOrder;
	order->id = id;
	order->spell = S_MIND_READING;
	order->level = 1;

	u->ClearCastOrders();
	u->castorders = order;
}

void Game::ProcessBirdLore(Unit *u, AString *o, OrdersCheck *pCheck)
{
	AString *token = o->gettoken();
	if (!token) {
		ParseError(pCheck, u, 0, "CAST: Missing arguments.");
		return;
	}

	if (*token == "eagle")
	{
		CastIntOrder *order = new CastIntOrder;
		order->spell = S_BIRD_LORE;
		order->level = 3;
		u->ClearCastOrders();
		u->castorders = order;
		return;
	}

	if (*token == "direction")
	{
		delete token;
		token = o->gettoken();

		if (!token) {
			ParseError(pCheck, u, 0, "CAST: Missing arguments.");
			return;
		}

		const int dir = ParseDir(token);
		delete token;
		if (dir == -1 || dir > NDIRS) {
			ParseError(pCheck, u, 0, "CAST: Invalid direction.");
			return;
		}

		CastIntOrder *order = new CastIntOrder;
		order->spell = S_BIRD_LORE;
		order->level = 1;
		order->target = dir;
		u->ClearCastOrders();
		u->castorders = order;

		return;
	}

	ParseError(pCheck, u, 0, "CAST: Invalid arguments.");
	delete token;
}

void Game::ProcessInvisibility(Unit *u, AString *o, OrdersCheck *pCheck)
{
	AString *token = o->gettoken();
	if (!token || !(*token == "units")) {
		ParseError(pCheck, u, 0, "CAST: Must specify units to render invisible.");
		return;
	}
	delete token;

	CastUnitsOrder *order;
	if (u->castorders && u->castorders->type == O_CAST &&
	    u->castorders->spell == S_INVISIBILITY &&
	    u->castorders->level == 1)
	{
		order = (CastUnitsOrder*)u->castorders;
	}
	else
	{
		order = new CastUnitsOrder;
		order->spell = S_INVISIBILITY;
		order->level = 1; // level required to cast
		u->ClearCastOrders();
		u->castorders = order;
	}

	UnitId *id = ParseUnit(o);
	while (id)
	{
		order->units.Add(id);
		id = ParseUnit(o);
	}
}

void Game::ProcessPhanDemons(Unit *u, AString *o, OrdersCheck *pCheck)
{
	AString *token = o->gettoken();
	if (!token) {
		ParseError(pCheck, u, 0, "CAST: Illusion to summon must be given.");
		return;
	}

	CastIntOrder *order = new CastIntOrder;
	order->spell = S_CREATE_PHANTASMAL_DEMONS;
	order->level = 0;
	order->target = 1;

	if (*token == "imp" || *token == "imps") {
		order->level = 1;
	}

	if (*token == "demon" || *token == "demons") {
		order->level = 3;
	}

	if (*token == "balrog" || *token == "balrogs") {
		order->level = 5;
	}

	delete token;

	if (!order->level) {
		ParseError(pCheck, u, 0, "CAST: Can't summon that illusion.");
		delete order;
		return;
	}

	token = o->gettoken();

	if (!token) {
		order->target = 1;
	}
	else {
		order->target = token->value();
		delete token;
	}

	u->ClearCastOrders();
	u->castorders = order;
}

void Game::ProcessPhanUndead(Unit *u, AString *o, OrdersCheck *pCheck)
{
	AString *token = o->gettoken();
	if (!token) {
		ParseError(pCheck, u, 0, "CAST: Must specify which illusion to summon.");
		return;
	}

	CastIntOrder *order = new CastIntOrder;
	order->spell = S_CREATE_PHANTASMAL_UNDEAD;
	order->level = 0;
	order->target = 1;

	if (*token == "skeleton" || *token == "skeletons") {
		order->level = 1;
	}

	if (*token == "undead") {
		order->level = 3;
	}

	if (*token == "lich" || *token == "liches") {
		order->level = 5;
	}

	delete token;

	if (!order->level) {
		ParseError(pCheck, u, 0, "CAST: Must specify which illusion to summon.");
		delete order;
		return;
	}

	token = o->gettoken();

	if (token) {
		order->target = token->value();
		delete token;
	}
	else {
		order->target = 1;
	}

	u->ClearCastOrders();
	u->castorders = order;
}

void Game::ProcessPhanBeasts(Unit *u, AString *o, OrdersCheck *pCheck)
{
	AString *token = o->gettoken();
	if (!token) {
		ParseError(pCheck, u, 0, "CAST: Must specify which illusion to summon.");
		return;
	}

	CastIntOrder *order = new CastIntOrder;
	order->spell = S_CREATE_PHANTASMAL_BEASTS;
	order->level = 0;
	order->target = 1;

	if (*token == "wolf" || *token == "wolves") {
		order->level = 1;
	}
	if (*token == "eagle" || *token == "eagles") {
		order->level = 3;
	}
	if (*token == "dragon" || *token == "dragon") {
		order->level = 5;
	}

	delete token;
	if (!order->level) {
		delete order;
		ParseError(pCheck, u, 0, "CAST: Must specify which illusion to summon.");
		return;
	}

	token = o->gettoken();
	if (token) {
		order->target = token->value();
		delete token;
	}

	u->ClearCastOrders();
	u->castorders = order;
}

void Game::ProcessGenericSpell(Unit *u, int spell, OrdersCheck *pCheck)
{
	CastOrder *orders = new CastOrder;
	orders->spell = spell;
	orders->level = 1;

	u->ClearCastOrders();
	u->castorders = orders;
}

void Game::ProcessEnchantSpell(Unit *u, AString *o, int spell, OrdersCheck *pCheck)
{
	AString *token = o->gettoken();
	if (!token)
	{
		ParseError(pCheck, u, 0, "CAST Enchant: Must specify which item to create.");
		return;
	}

	const int item = ParseEnabledItem(*token);
	if (item == -1)
	{
		ParseError(pCheck, u, 0, AString("CAST Enchant: Unknown item '") + *token + "'.");
		return;
	}

	CastEnchantOrder *orders = new CastEnchantOrder;
	orders->spell = spell;
	orders->level = 1;
	orders->output_item = item;

	u->ClearCastOrders();
	u->castorders = orders;
}

void Game::ProcessRegionSpell(Unit *u, AString *o, int spell, OrdersCheck *pCheck)
{
	AString *token = o->gettoken();
	int x = -1;
	int y = -1;
	int z = -1;

	int val = SkillDefs[spell].rangeIndex;
	RangeType *range = NULL;
	if (val != -1)
		range = &RangeDefs[val];

	if (token)
	{
		if(*token == "region")
		{
			delete token;
			token = o->gettoken();
			if(!token) {
				ParseError(pCheck, u, 0, "CAST: Region X coordinate not specified.");
				return;
			}
			x = token->value();
			delete token;

			token = o->gettoken();
			if(!token) {
				ParseError(pCheck, u, 0, "CAST: Region Y coordinate not specified.");
				return;
			}
			y = token->value();
			delete token;

			if(range && (range->flags & RangeType::RNG_CROSS_LEVELS)) {
				token = o->gettoken();
				if(token) {
					z = token->value();
					delete token;
					if(z < 0 || (z >= Globals->UNDERWORLD_LEVELS +
								Globals->UNDERDEEP_LEVELS +
								Globals->ABYSS_LEVEL + 2)) {
						ParseError(pCheck, u, 0, "CAST: Invalid Z coordinate specified.");
						return;
					}
				}
			}
		}
		else {
			ParseError(pCheck, u, 0, "CAST: Region spell without region keyword will use current region");
			delete token;
		}
	}

	if (pCheck) {
		return;
	}

	if(x == -1) x = u->object->region->xloc;
	if(y == -1) y = u->object->region->yloc;
	if(z == -1) z = u->object->region->zloc;

	// Teleports happen late in the turn!
	u->ClearCastOrders();
	CastRegionOrder *order;
	if(spell == S_TELEPORTATION)
	{
		u->teleportorders = new TeleportOrder;
		order = u->teleportorders;
	}
	else
	{
		order = new CastRegionOrder;
		u->castorders = order;
	}

	order->spell = spell;
	order->level = 1;
	order->xloc = x;
	order->yloc = y;
	order->zloc = z;
}

void Game::ProcessCastPortalLore(Unit *u, AString *o, OrdersCheck *pCheck)
{
	AString *token = o->gettoken();
	if (!token) {
		ParseError(pCheck, u, 0, "CAST: Requires a target mage.");
		return;
	}
	const int gate = token->value(); // actually unit with portal stone
	delete token;

	token = o->gettoken();
	if (!token) {
		ParseError(pCheck, u, 0, "CAST: No units to teleport.");
		return;
	}

	if (!(*token == "units")) {
		ParseError(pCheck, u, 0, "CAST: No units to teleport.");
		delete token;
		return;
	}

	TeleportOrder *order;
	if (u->teleportorders && u->teleportorders->spell == S_PORTAL_LORE) {
		order = u->teleportorders;
	}
	else {
		order = new TeleportOrder;
		u->ClearCastOrders();
		u->teleportorders = order;
	}

	order->gate = gate;
	order->spell = S_PORTAL_LORE;
	order->level = 1;

	UnitId *id = ParseUnit(o);
	while(id) {
		order->units.Add(id);
		id = ParseUnit(o);
	}
}

void Game::ProcessCastGateLore(Unit *u, AString *o, OrdersCheck *pCheck)
{
	AString *token = o->gettoken();
	if (!token) {
		ParseError(pCheck, u, 0, "CAST: Missing argument.");
		return;
	}

	if ((*token) == "gate")
	{
		// CAST Gate_Lore GATE <n>
		delete token;
		token = o->gettoken();

		if (!token) {
			ParseError(pCheck, u, 0, "CAST: Requires a target gate.");
			return;
		}
		const int target_gate = token->value();

		TeleportOrder *order;

		// check for adding onto existing order
		if (u->teleportorders && u->teleportorders->spell == S_GATE_LORE &&
		    u->teleportorders->gate == target_gate)
		{
			order = u->teleportorders;
		}
		else // new order
		{
			order = new TeleportOrder;
			u->ClearCastOrders();
			u->teleportorders = order;
		}

		order->gate = target_gate;
		order->spell = S_GATE_LORE;
		order->level = 3;

		// check for extra args
		delete token;
		token = o->gettoken();

		if (!token) return;
		if (!(*token == "units")) {
			delete token;
			return;
		}

		UnitId *id = ParseUnit(o);
		while (id) {
			order->units.Add(id);
			id = ParseUnit(o);
		}
		return;
	}

	if ((*token) == "random")
	{
		// CAST GATE RANDOM
		TeleportOrder *order;

		if (u->teleportorders && u->teleportorders->spell == S_GATE_LORE &&
		    u->teleportorders->gate == -1)
		{
			order = u->teleportorders;
		}
		else
		{
			order = new TeleportOrder;
			u->ClearCastOrders();
			u->teleportorders = order;
		}

		order->gate = -1;
		order->spell = S_GATE_LORE;
		order->level = 1;

		delete token;
		token = o->gettoken();

		if (!token) return;
		if (!(*token == "units")) {
			ParseError(pCheck, u, 0, AString("CAST GATE RANDOM: Invalid argument: ") + *token);
			delete token;
			return;
		}

		UnitId *id = ParseUnit(o);
		while (id) {
			order->units.Add(id);
			id = ParseUnit(o);
		}
		return;
	}

	if (*token == "alignment" || *token == "align")
	{
		// CAST GATE ALIGNMENT
		TeleportOrder *order;

		if (u->teleportorders && u->teleportorders->spell == S_GATE_LORE &&
		    u->teleportorders->gate == -1)
		{
			order = u->teleportorders;
		}
		else
		{
			order = new TeleportOrder;
			u->ClearCastOrders();
			u->teleportorders = order;
		}

		order->gate = -1;
		order->spell = S_GATE_LORE;
		order->level = 1;
		order->alignment_ = true;

		delete token;
		token = o->gettoken();
		if (!token)
			return;

		if (!(*token == "units")) {
			ParseError(pCheck, u, 0, AString("CAST GATE ALIGN: Invalid argument: ") + *token);
			delete token;
			return;
		}

		UnitId *id = ParseUnit(o);
		while (id) {
			order->units.Add(id);
			id = ParseUnit(o);
		}
		return;
	}

	if ((*token) == "detect")
	{
		// CAST GATE DETECT
		delete token;
		u->ClearCastOrders();
		CastOrder *to = new CastOrder;
		to->spell = S_GATE_LORE;
		to->level = 2;
		u->castorders = to;
		return;
	}

	ParseError(pCheck, u, nullptr, AString("CAST GATE: Invalid argument: ") + *token + ".");
	delete token;
}

void Game::RunACastOrder(ARegion *r, Object *o, Unit *u)
{
	if (u->type != U_MAGE) {
		u->Error("CAST: Unit is not a mage.");
		return;
	}

	if (u->castorders->level == 0) {
		u->castorders->level = u->GetSkill(u->castorders->spell);
	}

	if (u->GetSkill(u->castorders->spell) < u->castorders->level ||
	    u->castorders->level == 0)
 	{
		u->Error("CAST: Skill level isn't that high.");
		return;
	}

	const int sk = u->castorders->spell;
	switch (sk)
	{
	case S_MIND_READING:
		RunMindReading(r, u);
		break;

	case S_ENCHANT_ARMOR:
	case S_ENCHANT_SWORDS:
		RunEnchantItem(r, u);
		break;

	case S_CONSTRUCT_GATE:
		RunConstructGate(r, u, sk);
		break;

	case S_ENGRAVE_RUNES_OF_WARDING:
		RunEngraveRunes(r, o, u);
		break;

	case S_CONSTRUCT_PORTAL:
	case S_CREATE_RING_OF_INVISIBILITY:
	case S_CREATE_CLOAK_OF_INVULNERABILITY:
	case S_CREATE_STAFF_OF_FIRE:
	case S_CREATE_STAFF_OF_LIGHTNING:
	case S_CREATE_AMULET_OF_TRUE_SEEING:
	case S_CREATE_AMULET_OF_PROTECTION:
	case S_CREATE_RUNESWORD:
	case S_CREATE_SHIELDSTONE:
	case S_CREATE_MAGIC_CARPET:
	case S_CREATE_FLAMING_SWORD:
	{
		const int item_idx = itemForSkill(sk);
		RunCreateArtifact(r, u, sk, item_idx);
		break;
	}

	case S_SUMMON_IMPS:
		RunSummonImps(r, u);
		break;

	case S_SUMMON_DEMON:
		RunSummonDemon(r, u);
		break;

	case S_SUMMON_BALROG:
		RunSummonBalrog(r, u);
		break;

	case S_SUMMON_LICH:
		RunSummonLich(r, u);
		break;

	case S_RAISE_UNDEAD:
		RunRaiseUndead(r, u);
		break;

	case S_SUMMON_SKELETONS:
		RunSummonSkeletons(r, u);
		break;

	case S_DRAGON_LORE:
		RunDragonLore(r, u);
		break;

	case S_BIRD_LORE:
		RunBirdLore(r, u);
		break;

	case S_WOLF_LORE:
		RunWolfLore(r, u);
		break;

	case S_INVISIBILITY:
		RunInvisibility(r, u);
		break;

	case S_CREATE_PHANTASMAL_DEMONS:
		RunPhanDemons(r, u);
		break;

	case S_CREATE_PHANTASMAL_UNDEAD:
		RunPhanUndead(r, u);
		break;

	case S_CREATE_PHANTASMAL_BEASTS:
		RunPhanBeasts(r, u);
		break;

	case S_GATE_LORE:
		RunDetectGates(r, o, u);
		break;

	case S_FARSIGHT:
		RunFarsight(r, u);
		break;

	case S_EARTH_LORE:
		RunEarthLore(r, u);
		break;

	case S_WEATHER_LORE:
		RunWeatherLore(r, u);
		break;

	case S_CLEAR_SKIES:
		RunClearSkies(r, u);
		break;

	case S_CREATE_FOOD:
		RunCreateFood(r, u);
		break;
	}

}

int Game::GetRegionInRange(ARegion *r, ARegion *tar, Unit *u, int spell)
{
	int level = u->GetSkill(spell);
	if(!level) {
		u->Error("CAST: You don't know that spell.");
		return 0;
	}

	int val = SkillDefs[spell].rangeIndex;
	if(val == -1) {
		u->Error("CAST: Spell is not castable at range.");
		return 0;
	}

	RangeType *range = &RangeDefs[val];

	int rtype = regions.GetRegionArray(r->zloc)->levelType;
	if((rtype == ARegionArray::LEVEL_NEXUS) &&
			!(range->flags & RangeType::RNG_NEXUS_SOURCE)) {
		u->Error("CAST: Spell does not work from the Nexus.");
		return 0;
	}

	if(!tar) {
		u->Error("CAST: No such region.");
		return 0;
	}

	rtype = regions.GetRegionArray(tar->zloc)->levelType;
	if((rtype == ARegionArray::LEVEL_NEXUS) &&
			!(range->flags & RangeType::RNG_NEXUS_TARGET)) {
		u->Error("CAST: Spell does not work to the Nexus.");
		return 0;
	}

	if((rtype != ARegionArray::LEVEL_SURFACE) &&
			(range->flags & RangeType::RNG_SURFACE_ONLY)) {
		u->Error("CAST: Spell can only target regions on the surface.");
		return 0;
	}
	if(!(range->flags&RangeType::RNG_CROSS_LEVELS) && (r->zloc != tar->zloc)) {
		u->Error("CAST: Spell is not able to work across levels.");
		return 0;
	}

	int maxdist;
	switch(range->rangeClass) {
		default:
		case RangeType::RNG_ABSOLUTE:
			maxdist = 1;
			break;
		case RangeType::RNG_LEVEL:
			maxdist = level;
			break;
		case RangeType::RNG_LEVEL2:
			maxdist = level * level;
			break;
		case RangeType::RNG_LEVEL3:
			maxdist = level * level * level;
			break;
	}
	maxdist *= range->rangeMult;

	int dist;
	if(range->flags & RangeType::RNG_CROSS_LEVELS)
		dist = regions.GetPlanarDistance(tar, r, range->crossLevelPenalty);
	else
		dist = regions.GetDistance(tar, r);
	if(dist > maxdist) {
		u->Error("CAST: Target region out of range.");
		return 0;
	}
	return 1;
}

void Game::RunMindReading(ARegion *r, Unit *u)
{
	CastMindOrder *order = (CastMindOrder *) u->castorders;
	int level = u->GetSkill(S_MIND_READING);

	Unit *tar = r->GetUnitId(order->id, u->faction->num);
	if (!tar) {
		u->Error("No such unit.");
		return;
	}

	AString temp = AString("Casts Mind Reading: ") + *(tar->name) + ", " +
		tar->faction->name();
	u->Practise(S_MIND_READING);

	if (level < 4) {
		u->Event(temp + ".");
		return;
	}

	temp += tar->items.Report(2, 5, 0) + ". Skills: ";
	temp += tar->skills.Report(tar->GetMen()) + ".";

	u->Event(temp);
}

void Game::RunEnchantItem(ARegion *r, Unit *u)
{
	CastEnchantOrder *order = (CastEnchantOrder*)u->castorders;

	// figure out how many input components are required
	int count = 0;
	for (unsigned c = 0; c < ItemDefs[order->output_item].mInput.size(); ++c)
	{
		if (ItemDefs[order->output_item].mInput[c].item != -1)
			++count;
	}

	const int level = u->GetSkill(order->spell);

	int num = 0; // how many we can actually make
	int max = ItemDefs[order->output_item].mOut * level;
	while (max)
	{
		// see if we have enough of all items
		int found = 0;
		for (unsigned c = 0; c < ItemDefs[order->output_item].mInput.size(); ++c)
		{
			const int i = ItemDefs[order->output_item].mInput[c].item;
			const int a = ItemDefs[order->output_item].mInput[c].amt;
			if (i != -1)
			{
				if (u->items.GetNum(i) >= a)
					++found;
			}
		}

		// if not, break
		if (found != count)
			break;

		// decrement inputs
		for (unsigned c = 0; c < ItemDefs[order->output_item].mInput.size(); ++c)
		{
			const int i = ItemDefs[order->output_item].mInput[c].item;
			const int a = ItemDefs[order->output_item].mInput[c].amt;
			if (i != -1)
			{
				u->items.SetNum(i, u->items.GetNum(i) - a);
			}
		}

		// we've made one
		++num;
		--max;
	}

	u->items.SetNum(order->output_item, u->items.GetNum(order->output_item) + num);
	u->Event(AString("Enchants ") + num + " " + (num > 1 ? ItemDefs[order->output_item].names : ItemDefs[order->output_item].name) + ".");
	u->Practise(order->spell);
	r->NotifySpell(u, S_ARTIFACT_LORE, &regions );
}

void Game::RunCreateFood(ARegion *r, Unit *u)
{
	int level = u->GetSkill(S_CREATE_FOOD);
	int max = ItemDefs[I_FOOD].mOut * level;
	int num = 0;
	int count = 0;
	unsigned int c;
	int found;

	// Figure out how many components there are
	for (c = 0; c < ItemDefs[I_FOOD].mInput.size(); ++c) {
		if (ItemDefs[I_FOOD].mInput[c].item != -1) count++;
	}

	while(max) {
		int i, a;
		found = 0;
		// See if we have enough of all items
		for (c = 0; c < ItemDefs[I_FOOD].mInput.size(); ++c) {
			i = ItemDefs[I_FOOD].mInput[c].item;
			a = ItemDefs[I_FOOD].mInput[c].amt;
			if(i != -1) {
				if(u->items.GetNum(i) >= a) found++;
			}
		}
		// We do not, break.
		if(found != count) break;

		// Decrement our inputs
		for (c = 0; c < ItemDefs[I_FOOD].mInput.size(); ++c)
		{
			i = ItemDefs[I_FOOD].mInput[c].item;
			a = ItemDefs[I_FOOD].mInput[c].amt;
			if(i != -1) {
				u->items.SetNum(i, u->items.GetNum(i) - a);
			}
		}
		// We've made one.
		num++;
		max--;
	}

	u->items.SetNum(I_FOOD, u->items.GetNum(I_FOOD) + num);
	u->Event(AString("Creates ") + num + " food.");
	u->Practise(S_CREATE_FOOD);
	r->NotifySpell(u, S_EARTH_LORE, &regions );
}

void Game::RunConstructGate(ARegion *r, Unit *u, int spell)
{
	if (TerrainDefs[r->type].similar_type == R_OCEAN) {
		u->Error("Gates may not be constructed at sea.");
		return;
	}

	if (r->gate) {
		u->Error("There is already a gate in that region.");
		return;
	}

	if (u->GetMoney() < 1000) {
		u->Error("Can't afford to construct a Gate.");
		return;
	}
	u->SetMoney(u->GetMoney() - 1000);

	int level = u->GetSkill(spell);
	int chance = level * 20;
	if (getrandom(100) >= chance) {
		u->Event("Attempts to construct a gate, but fails.");
		return;
	}

	u->Event(AString("Constructs a Gate in ")+r->ShortPrint( &regions )+".");
	u->Practise(S_CONSTRUCT_GATE);
	regions.numberofgates++;
	r->gate = regions.numberofgates;
	r->NotifySpell(u, S_ARTIFACT_LORE, &regions );
}

void Game::RunEngraveRunes(ARegion *r, Object *o, Unit *u)
{
	if (!o->IsBuilding()) {
		u->Error("Runes of Warding may only be engraved on a building.");
		return;
	}

	if (o->incomplete > 0) {
		u->Error("Runes of Warding may only be engraved on a completed building.");
		return;
	}

	int level = u->GetSkill(S_ENGRAVE_RUNES_OF_WARDING);

	switch (level) {
		case 5:
			if (o->type == O_MFORTRESS) break;
		case 4:
			if (o->type == O_CITADEL) break;
		case 3:
			if (o->type == O_CASTLE) break;
		case 2:
			if (o->type == O_FORT) break;
			if (o->type == O_MTOWER) break;
		case 1:
			if (o->type == O_TOWER) break;
		default:
			u->Error("Not high enough level to engrave Runes of Warding on that building.");
			return;
	}

	if (u->GetMoney() < 600) {
		u->Error("Can't afford to engrave Runes of Warding.");
		return;
	}

	u->SetMoney(u->GetMoney() - 600);
	if( o->type == O_MFORTRESS ) {
		o->runes = 5;
	} else if(o->type == O_MTOWER) {
		o->runes = 4;
	} else {
		o->runes = 3;
	}
	u->Event(AString("Engraves Runes of Warding on ") + *(o->name) + ".");
	u->Practise(S_ENGRAVE_RUNES_OF_WARDING);
	r->NotifySpell(u, S_ARTIFACT_LORE, &regions );
}

void Game::RunSummonImps(ARegion *r, Unit *u)
{
	const int skill = S_SUMMON_IMPS;

	SpellMechanic m{SpellMechanic::SUMMON, "IMP", -1, 1, 0, "DEMO", false};
	const int item = ParseEnabledItem(m.summon_abbr);
	AString act_str(m.activity_abbr);
	const int act_skill = ParseSkill(&act_str);
	if (item == -1 || act_skill == -1)
	{
		std::cerr << "Bad configuration for " << SkillDefs[skill].name << std::endl;
		return;
	}

	const int level = u->GetSkill(skill);
	const int current = u->items.GetNum(item);

	const int count = m.level_scale * level + m.constant;
	const int eff_ct = m.max_summon == -1 || (count + current <= m.max_summon) ? count : m.max_summon - current;
	if (count != 0 && eff_ct == 0)
	{
		u->Error(AString("Can't control more than ") + ItemString(item, m.max_summon) + ".");
		return;
	}

	u->items.SetNum(item, current + eff_ct);
	u->Event(AString("Summons ") + ItemString(item, eff_ct) + ".");
	u->Practise(skill);
	r->NotifySpell(u, act_skill, &regions);
}

void Game::RunSummonDemon(ARegion *r, Unit *u)
{
	const int skill = S_SUMMON_DEMON;

	SpellMechanic m{SpellMechanic::SUMMON, "DEMO", -1, 0, 1, "DEMO", false};
	const int item = ParseEnabledItem(m.summon_abbr);
	AString act_str(m.activity_abbr);
	const int act_skill = ParseSkill(&act_str);
	if (item == -1 || act_skill == -1)
	{
		std::cerr << "Bad configuration for " << SkillDefs[skill].name << std::endl;
		return;
	}

	const int level = u->GetSkill(skill);
	const int current = u->items.GetNum(item);

	const int count = m.level_scale * level + m.constant;
	const int eff_ct = m.max_summon == -1 || (count + current <= m.max_summon) ? count : m.max_summon - current;
	if (count != 0 && eff_ct == 0)
	{
		u->Error(AString("Can't control more than ") + ItemString(item, m.max_summon) + ".");
		return;
	}

	u->items.SetNum(item, current + eff_ct);
	u->Event(AString("Summons ") + ItemString(item, count) + ".");
	u->Practise(skill);
	r->NotifySpell(u, act_skill, &regions);
}

void Game::RunSummonBalrog(ARegion *r, Unit *u)
{
	const int skill = S_SUMMON_BALROG;

	SpellMechanic m{SpellMechanic::SUMMON, "BALR", 1, 20, 0, "DEMO", true};
	const int item = ParseEnabledItem(m.summon_abbr);
	AString act_str(m.activity_abbr);
	const int act_skill = ParseSkill(&act_str);
	if (item == -1 || act_skill == -1)
	{
		std::cerr << "Bad configuration for " << SkillDefs[skill].name << std::endl;
		return;
	}

	const int level = u->GetSkill(skill);
	const int current = u->items.GetNum(item);

	const int count = m.random ? (level * 20 + getrandom(100)) / 100 :
	 m.level_scale * level + m.constant;
	const int eff_ct = m.max_summon == -1 || (count + current <= m.max_summon) ? count : m.max_summon - current;
	if (count != 0 && eff_ct == 0)
	{
		u->Error(AString("Can't control more than ") + ItemString(item, m.max_summon) + ".");
		return;
	}

	u->items.SetNum(item, current + eff_ct);
	u->Event(AString("Summons ") + ItemString(item, count) + ".");
	u->Practise(skill);
	r->NotifySpell(u, act_skill, &regions);
}

void Game::RunSummonLich(ARegion *r, Unit *u)
{
	const int level = u->GetSkill(S_SUMMON_LICH);
	const int num = ((2 * level * level) + getrandom(100))/100;

	u->items.SetNum(I_LICH, u->items.GetNum(I_LICH) + num);
	u->Event(AString("Summons ") + ItemString(I_LICH, num) + ".");
	u->Practise(S_SUMMON_LICH);
	r->NotifySpell(u, S_NECROMANCY, &regions );
}

void Game::RunRaiseUndead(ARegion *r, Unit *u)
{
	const int level = u->GetSkill(S_RAISE_UNDEAD);
	const int num = ((10 * level * level) + getrandom(100))/100;

	u->items.SetNum(I_UNDEAD, u->items.GetNum(I_UNDEAD) + num);
	u->Event(AString("Raises ") + ItemString(I_UNDEAD, num) + ".");
	u->Practise(S_RAISE_UNDEAD);
	r->NotifySpell(u, S_NECROMANCY, &regions );
}

void Game::RunSummonSkeletons(ARegion *r, Unit *u)
{
	int level = u->GetSkill(S_SUMMON_SKELETONS);

	int num = ((40 * level * level) + getrandom(100))/100;

	u->items.SetNum(I_SKELETON, u->items.GetNum(I_SKELETON) + num);
	u->Event(AString("Summons ") + ItemString(I_SKELETON, num) + ".");
	u->Practise(S_SUMMON_SKELETONS);
	r->NotifySpell(u, S_NECROMANCY, &regions );
}

void Game::RunDragonLore(ARegion *r, Unit *u)
{
	if (u->items.GetNum(I_DRAGON)) {
		u->Error("Can't summon more than one dragon.");
		return;
	}

	int level = u->GetSkill(S_DRAGON_LORE);
	int chance = level * level * 4;

	if (getrandom(100) < chance) {
		u->items.SetNum(I_DRAGON, 1);
		u->Event("Summons a dragon.");
	} else {
		u->Event("Attempts to summon a dragon, but fails.");
	}
	u->Practise(S_DRAGON_LORE);
	r->NotifySpell(u, S_EARTH_LORE, &regions );
}

void Game::RunCreateArtifact(ARegion *r, Unit *u, int skill, int item)
{
	int level = u->GetSkill(skill);
	unsigned int c;
	for (c = 0; c < ItemDefs[item].mInput.size(); ++c)
	{
		if(ItemDefs[item].mInput[c].item == -1) continue;
		int amt = u->items.GetNum(ItemDefs[item].mInput[c].item);
		int cost = ItemDefs[item].mInput[c].amt;
		if(amt < cost) {
			u->Error(AString("Doesn't have sufficient ") +
					ItemDefs[ItemDefs[item].mInput[c].item].name +
					" to create that.");
			return;
		}
	}

	// Deduct the costs
	for (c = 0; c < ItemDefs[item].mInput.size(); ++c)
	{
		if(ItemDefs[item].mInput[c].item == -1) continue;
		int amt = u->items.GetNum(ItemDefs[item].mInput[c].item);
		int cost = ItemDefs[item].mInput[c].amt;
		u->items.SetNum(ItemDefs[item].mInput[c].item, amt-cost);
	}

	int num = (level * ItemDefs[item].mOut + getrandom(100))/100;

	u->items.SetNum(item, u->items.GetNum(item) + num);
	u->Event(AString("Creates ") + ItemString(item, num) + ".");
	u->Practise(skill);
	r->NotifySpell(u, S_ARTIFACT_LORE, &regions );
}

void Game::RunBirdLore(ARegion *r, Unit *u)
{
	const int type = regions.GetRegionArray(r->zloc)->levelType;
	if(type != ARegionArray::LEVEL_SURFACE)
	{
		AString error = "CAST: Bird Lore may only be cast on the surface of ";
		error += Globals->WORLD_NAME;
		error += ".";
		u->Error(error.Str());
		return;
	}

	CastIntOrder *order = (CastIntOrder*)u->castorders;
	// if basic usage
	if (order->level < 3)
	{
		const int dir = order->target;
		ARegion *tar = r->neighbors[dir];
		if (!tar) {
			u->Error("CAST: No such region.");
			return;
		}

		Farsight *f = new Farsight;
		f->faction = u->faction;
		f->level = u->GetSkill(S_BIRD_LORE);
		tar->farsees.Add(f);
		u->Event(AString("Sends birds to spy on ") +
				tar->Print( &regions ) + ".");
		u->Practise(S_BIRD_LORE);
		r->NotifySpell(u, S_EARTH_LORE, &regions );
		return;
	}
	//else summon eagle

	const int level = u->GetSkill(S_BIRD_LORE);
	const int max = (level - 2) * (level - 2);

	if (u->items.GetNum(I_EAGLE) >= max) {
		u->Error("CAST: Mage can't summon more eagles.");
		return;
	}

	u->items.SetNum(I_EAGLE, u->items.GetNum(I_EAGLE) + 1);
	u->Event("Summons an eagle.");
	u->Practise(S_BIRD_LORE);
	r->NotifySpell(u, S_EARTH_LORE, &regions);
}

void Game::RunWolfLore(ARegion *r, Unit *u)
{
	if (TerrainDefs[r->type].similar_type != R_MOUNTAIN &&
	    TerrainDefs[r->type].similar_type != R_FOREST &&
	    TerrainDefs[r->type].similar_type != R_CERAN_HILL)
	{
		u->Error("CAST: Can only summon wolves in mountain, hill and forest regions.");
		return;
	}

	const int level = u->GetSkill(S_WOLF_LORE);
	const int max = level * level * 4;

	const int num = u->items.GetNum(I_WOLF);

	int summon = max - num;
	if (summon > level) summon = level;
	if (summon < 0) summon = 0;

	u->Event(AString("Casts Wolf Lore, summoning ") +
	    ItemString(I_WOLF, summon) + ".");
	u->items.SetNum(I_WOLF, num + summon);
	u->Practise(S_WOLF_LORE);
	r->NotifySpell(u, S_EARTH_LORE, &regions );
}

void Game::RunInvisibility(ARegion *r, Unit *u)
{
	CastUnitsOrder *order = (CastUnitsOrder*)u->castorders;
	int max = u->GetSkill(S_INVISIBILITY);
	max = max * max;

	int num = 0;
	forlist (&(order->units))
	{
		Unit *tar = r->GetUnitId((UnitId*)elem, u->faction->num);
		if (!tar) continue;
		if (tar->GetAttitude(r, u) < A_FRIENDLY) continue;
		num += tar->GetSoldiers();
	}

	if (num > max) {
		u->Error("CAST: Can't render that many men invisible.");
		return;
	}

	if (!num) {
		u->Error("CAST: No valid targets to turn invisible.");
		return;
	}

	{
		forlist (&(order->units)) {
			Unit *tar = r->GetUnitId((UnitId*)elem, u->faction->num);
			if (!tar) continue;
			if (tar->GetAttitude(r, u) < A_FRIENDLY) continue;
			tar->SetFlag(FLAG_INVIS, 1);
			tar->Event(AString("Is rendered invisible by ") +
					*(u->name) + ".");
		}
	}

	r->NotifySpell(u, S_ILLUSION, &regions );
	u->Practise(S_INVISIBILITY);
	u->Event("Casts invisibility.");
}

void Game::RunPhanDemons(ARegion *r, Unit *u)
{
	CastIntOrder *order = (CastIntOrder*)u->castorders;
	const int level = u->GetSkill(S_CREATE_PHANTASMAL_DEMONS);
	int create, max;

	if (order->level < 3)
	{
		create = I_IIMP;
		max = level * level * 4;
	}
	else
	{
		if (order->level < 5)
		{
			create = I_IDEMON;
			max = (level - 2) * (level - 2);
		}
		else
		{
			create = I_IBALROG;
			max = 1;
		}
	}

	if (order->target > max || order->target < 0) {
		u->Error("CAST: Can't create that many Phantasmal Demons.");
		return;
	}

	u->items.SetNum(create, order->target);
	u->Event("Casts Create Phantasmal Demons.");
	u->Practise(S_CREATE_PHANTASMAL_DEMONS);
	r->NotifySpell(u, S_ILLUSION, &regions);
}

void Game::RunPhanUndead(ARegion *r, Unit *u)
{
	CastIntOrder *order = (CastIntOrder*)u->castorders;
	const int level = u->GetSkill(S_CREATE_PHANTASMAL_UNDEAD);
	int create, max;

	if (order->level < 3)
	{
		create = I_ISKELETON;
		max = level * level * 4;
	}
	else
	{
		if (order->level < 5)
		{
			create = I_IUNDEAD;
			max = (level - 2) * (level - 2);
		}
		else
		{
			create = I_ILICH;
			max = 1;
		}
	}

	if (order->target > max || order->target < 0) {
		u->Error("CAST: Can't create that many Phantasmal Undead.");
		return;
	}

	u->items.SetNum(create, order->target);
	u->Event("Casts Create Phantasmal Undead.");
	u->Practise(S_CREATE_PHANTASMAL_UNDEAD);
	r->NotifySpell(u, S_ILLUSION, &regions);
}

void Game::RunPhanBeasts(ARegion *r, Unit *u)
{
	CastIntOrder *order = (CastIntOrder*)u->castorders;
	int level = u->GetSkill(S_CREATE_PHANTASMAL_BEASTS);
	int create, max;

	if (order->level < 3)
	{
		create = I_IWOLF;
		max = level * level * 4;
	}
	else
	{
		if (order->level < 5)
		{
			create = I_IEAGLE;
			max = (level - 2) * (level - 2);
		}
		else
		{
			create = I_IDRAGON;
			max = 1;
		}
	}

	if (order->target > max || order->target < 0) {
		u->Error("CAST: Can't create that many Phantasmal Beasts.");
		return;
	}

	u->items.SetNum(create, order->target);
	u->Event("Casts Create Phantasmal Beasts.");
	u->Practise(S_CREATE_PHANTASMAL_BEASTS);
	r->NotifySpell(u, S_ILLUSION, &regions);
}

void Game::RunEarthLore(ARegion *r, Unit *u)
{
	const int level = u->GetSkill(S_EARTH_LORE);

	if (level > r->earthlore) r->earthlore = level;
	int amt = r->Wages() * level * 2;

	u->items.SetNum(I_SILVER, u->items.GetNum(I_SILVER) + amt);
	u->Event(AString("Casts Earth Lore, raising ") + amt + " silver.");
	u->Practise(S_EARTH_LORE);
	r->NotifySpell(u, S_EARTH_LORE, &regions);
}

void Game::RunClearSkies(ARegion *r, Unit *u)
{
	CastRegionOrder *order = (CastRegionOrder*)u->castorders;

	ARegion *tar = r;
	AString temp = "Casts Clear Skies";

	int val = SkillDefs[S_CLEAR_SKIES].rangeIndex;
	if(val != -1)
	{
		tar = regions.GetRegion(order->xloc, order->yloc, order->zloc);
		val = GetRegionInRange(r, tar, u, S_CLEAR_SKIES);
		if(!val) return;
		temp += " on ";
		temp += tar->ShortPrint(&regions);
	}
	temp += ".";
	u->Event(temp);

	// update region clear skies
	const int level = u->GetSkill(S_CLEAR_SKIES);
	if (level > r->clearskies) r->clearskies = level;

	u->Practise(S_CLEAR_SKIES);
	r->NotifySpell(u, S_WEATHER_LORE, &regions);
}

void Game::RunWeatherLore(ARegion *r, Unit *u)
{
	CastRegionOrder *const order = (CastRegionOrder*)u->castorders;

	ARegion *const tar = regions.GetRegion(order->xloc, order->yloc, order->zloc);
	const int val = GetRegionInRange(r, tar, u, S_WEATHER_LORE);
	if (!val) return;

	const int level = u->GetSkill(S_WEATHER_LORE);
	int months = 3;
	if (level >= 5) months = 12;
	else if (level >= 3) months = 6;

	AString temp = "Casts Weather Lore on ";
	temp += tar->ShortPrint(&regions);
	temp += ". It will be ";

	for (int i = 0; i <= months; i++)
	{
		const int futuremonth = (month + i) % 12;
		const int weather = regions.GetWeather(tar, futuremonth);

		temp += SeasonNames[weather];
		temp += " in ";
		temp += MonthNames[futuremonth];

		if (i < (months-1))
			temp += ", ";
		else if (i == (months-1))
			temp += " and ";
		else
			temp += ".";
	}

	u->Event(temp);
	u->Practise(S_WEATHER_LORE);
	r->NotifySpell(u, S_WEATHER_LORE, &regions);
}

void Game::RunFarsight(ARegion *r, Unit *u)
{
	CastRegionOrder *order = (CastRegionOrder*)u->castorders;

	ARegion *tar = regions.GetRegion(order->xloc, order->yloc, order->zloc);

	const int val = GetRegionInRange(r, tar, u, S_FARSIGHT);
	if(!val) return;

	Farsight *f = new Farsight;
	f->faction = u->faction;
	f->level = u->GetSkill(S_FARSIGHT);
	f->unit = u;
	tar->farsees.Add(f);

	AString temp = "Casts Farsight on ";
	temp += tar->ShortPrint(&regions);
	temp += ".";
	u->Event(temp);

	u->Practise(S_FARSIGHT);
}

void Game::RunDetectGates(ARegion *r, Object *o, Unit *u)
{
	const int level = u->GetSkill(S_GATE_LORE);
	if (level == 1) {
		u->Error("CAST: Casting Gate Lore at level 1 has no effect.");
		return;
	}

	u->Event("Casts Gate Lore, detecting nearby Gates:");

	bool found = false;
	for (int i = 0; i < NDIRS; ++i)
	{
		ARegion *tar = r->neighbors[i];
		if (tar)
		{
			if (tar->gate)
			{
				if(Globals->DETECT_GATE_NUMBERS)
				{
					u->Event(tar->Print(&regions) + " contains Gate " + tar->gate + ".");
				}
				else
				{
					u->Event(tar->Print(&regions) + " contains a Gate.");
				}
				found = true;
			}
		}
	}

	if (!found)
		u->Event("There are no nearby Gates.");
	u->Practise(S_GATE_LORE);
}

void Game::RunTeleport(ARegion *r, Object *o, Unit *u)
{
	CastRegionOrder *order = (CastRegionOrder*)u->teleportorders;

	ARegion *tar = regions.GetRegion(order->xloc, order->yloc, order->zloc);

	const int val = GetRegionInRange(r, tar, u, S_TELEPORTATION);
	if(!val) return;

	const int level = u->GetSkill(S_TELEPORTATION);
	const int maxweight = level * 15;

	if (u->Weight() > maxweight) {
		u->Error("CAST: Can't carry that much when teleporting.");
		return;
	}

	// Presume they had to open the portal to see if target is ocean
	u->Practise(S_TELEPORTATION);

	if (TerrainDefs[tar->type].similar_type == R_OCEAN) {
		u->Error(AString("CAST: ") + tar->Print(&regions) + " is an ocean.");
		return;
	}

	// Mage cannot instantly guard the destination
	u->guard = GUARD_NONE;

	u->Event(AString("Teleports to ") + tar->Print(&regions) + ".");
	u->MoveUnit(tar->GetDummy());
}

ARegion* Game::getAlignmentGate(Unit *u)
{
	const ManType::Alignment tgt_align = ManType::Alignment(u->faction->alignments_);
	std::vector<ARegion*> candidate_regions;

	// foreach region
	forlist(&regions)
	{
		ARegion *r = (ARegion*)elem;
		if (r->type == R_NEXUS)
			continue;
		// check surface
		if (r->zloc != ARegionArray::LEVEL_SURFACE)
			continue;

		if (r->population == 0 || r->race == -1)
			continue; // no people

		// check alignment
		const ManType &mt = ManDefs[ItemDefs[r->race].index];
		if (mt.align != ManType::NEUTRAL && mt.align != tgt_align)
			continue;

		// make sure no one is here
		bool all_empty = true;
		forlist(&r->objects)
		{
			Object *o = (Object*)elem;
			if (o->getUnits().empty())
			{
				all_empty = false;
				break;
			}
		}

		if (all_empty)
			candidate_regions.push_back(r);
	}

	if (candidate_regions.empty())
		return nullptr;

	return candidate_regions[getrandom(candidate_regions.size())];
}

ARegion* Game::getRandomGate(int zloc, bool leaving_nexus)
{
	// pick a random gate
	int gatenum = getrandom(regions.numberofgates);
	ARegion *tar = regions.FindGate(gatenum+1);

	bool good = false;
	if (tar && tar->zloc == zloc)
		good = true;
	if (tar && leaving_nexus && tar->zloc == ARegionArray::LEVEL_SURFACE)
		good = true;

	while (!good)
	{
		gatenum = getrandom(regions.numberofgates);
		tar = regions.FindGate(gatenum+1);
		if (tar && tar->zloc == zloc) good = true;
		if (tar && leaving_nexus && tar->zloc == ARegionArray::LEVEL_SURFACE)
			good = true;
	}
	return tar;
}

void Game::RunGateJump(ARegion *r, Object *o, Unit *u)
{
	// pull skill level
	int level = u->GetSkill(S_GATE_LORE);
	if (!level) {
		u->Error("CAST: Unit doesn't have that skill.");
		return;
	}

	TeleportOrder *order = u->teleportorders;

	// need level 3 for anything other than random (or detect)
	if (order->gate != -1 && level < 3) {
		u->Error("CAST: Unit Doesn't know Gate Lore at that level.");
		return;
	}

	// are we gating out of the nexus?
	const bool nexgate = Globals->NEXUS_GATE_OUT && (TerrainDefs[r->type].similar_type == R_NEXUS);
	if (!r->gate && !nexgate) {
		u->Error("CAST: There is no gate in this region.");
		return;
	}

	// calculate max weight
	int maxweight = 10;
	//-- non-random jump is harder
	if (order->gate != -1)
		level -= 2;
	switch (level)
	{
	case 1: maxweight =  35; break;
	case 2: maxweight = 150; break;

	case 3:
	case 4:
	case 5:
		maxweight = 1000;
		break;
	}

	// sum weight of everyone jumping
	int weight = u->Weight();

	forlist (&order->units)
	{
		Unit *taru = r->GetUnitId((UnitId*)elem, u->faction->num);
		// if target and it's not the caster, and (not leaving the nexus or the same faction)
		if (taru && taru != u && (!nexgate || taru->faction == u->faction))
			weight += taru->Weight();
	}

	if (weight > maxweight) {
		u->Error("CAST: Mage cannot carry that much weight through a Gate.");
		return;
	}

	ARegion *tar;
	// if random
	if (order->gate == -1)
	{
		if (order->alignment_)
		{
			if (!nexgate)
			{
				u->Error("CAST GATE ALIGNMENT: Only works from the nexus.");
				return;
			}
			if (u->faction->alignments_ == Faction::ALL_NEUTRAL)
			{
				u->Error("CAST GATE ALIGNMENT: Must choose good or evil before casting.");
				return;
			}

			tar = getAlignmentGate(u);
			if (!tar)
			{
				u->Error("CAST GATE ALIGNMENT: The world is full!");
				// reset alignment
				u->faction->alignments_ = Faction::ALL_NEUTRAL;
				return;
			}
		}
		else
		{
			tar = getRandomGate(r->zloc, nexgate);
		}

		u->Event("Casts Random Gate Jump.");
		u->Practise(S_GATE_LORE);
	}
	else
	{
		if (order->gate < 1 || order->gate > regions.numberofgates) {
			u->Error("CAST: No such target gate.");
			return;
		}

		tar = regions.FindGate(order->gate);
		if (!tar) {
			u->Error("CAST: No such target gate.");
			return;
		}

		u->Event("Casts Gate Jump.");
		u->Practise(S_GATE_LORE);
	}

	bool comma = false;
	AString unitlist;
	{
		forlist(&(order->units))
		{
			Location *loc = r->GetLocation((UnitId*)elem, u->faction->num);
			if (!loc)
			{
				u->Error("CAST GATE: No such unit.");
				continue;
			}

			// Don't do the casting unit yet
			if (loc->unit == u) {
				delete loc;
				continue;
			}

			if (nexgate && loc->unit->faction != u->faction)
			{
				u->Error("CAST: Only units from the same faction can exit the nexus together.");
			}
			else if (loc->unit->GetAttitude(r, u) < A_ALLY) {
				u->Error("CAST: Unit is not allied.");
			}
			else
			{
				if (comma) {
					unitlist += AString(", ") + AString(loc->unit->num);
				}
				else {
					unitlist += AString(loc->unit->num);
					comma = true;
				}

				// Unit cannot instantly guard the destination
				loc->unit->guard = GUARD_NONE;

				loc->unit->Event(AString("Is teleported through a ") +
				      "Gate to " + tar->Print(&regions) + " by " +
				      *u->name + ".");
				loc->unit->MoveUnit( tar->GetDummy() );
				if (loc->unit != u)
					loc->unit->ClearCastOrders();
			}
			delete loc;
		}
	}

	// Mage cannot instantly guard the destination
	u->guard = GUARD_NONE;

	u->Event(AString("Jumps through a Gate to ") + tar->Print(&regions) + ".");
	u->Practise(S_GATE_LORE);
	if (comma) {
		u->Event(unitlist + " follow through the Gate.");
	}
	u->MoveUnit( tar->GetDummy() );
}

void Game::RunPortalLore(ARegion *r, Object *o, Unit *u)
{
	const int level = u->GetSkill(S_PORTAL_LORE);
	if (!level) {
		u->Error("CAST: Doesn't know Portal Lore.");
		return;
	}

	if (!u->items.GetNum(I_PORTAL)) {
		u->Error("CAST: Unit doesn't have a Portal.");
		return;
	}

	// check weight limit
	const int maxweight = 50 * level;

	int weight = 0;

	TeleportOrder *const order = u->teleportorders;
	forlist (&order->units) {
		Unit *taru = r->GetUnitId((UnitId*)elem, u->faction->num);
		if (taru) weight += taru->Weight();
	}

	if (weight > maxweight) {
		u->Error("CAST: That mage cannot teleport that much weight through a Portal.");
		return;
	}

	// gate is actually a unit num
	Location *tar = regions.FindUnit(order->gate);
	if (!tar) {
		u->Error("CAST: No such target mage.");
		return;
	}

	// check target unit
	if (tar->unit->faction->GetAttitude(u->faction->num) < A_FRIENDLY) {
		u->Error("CAST: Target mage is not friendly.");
		return;
	}

	if (tar->unit->type != U_MAGE && tar->unit->type != U_APPRENTICE) {
		u->Error("CAST: Target is not a mage.");
		return;
	}

	if (!tar->unit->items.GetNum(I_PORTAL)) {
		u->Error("CAST: Target does not have a Portal.");
		return;
	}

	const int maxdist = 2 * level * level;
	if (regions.GetDistance(r, tar->region) > maxdist) {
		u->Error("CAST: Can't Portal Jump that far.");
		return;
	}

	u->Event("Casts Portal Jump.");
	u->Practise(S_PORTAL_LORE);

	{
		// move the units
		forlist(&(order->units))
		{
			Location *loc = r->GetLocation((UnitId*)elem, u->faction->num);
			if (!loc)
			{
				u->Error("CAST: No such unit.");
				continue;
			}

			if (loc->unit->GetAttitude(r, u) < A_ALLY)
			{
				u->Error("CAST: Unit is not allied.");
			}
			else
			{
				loc->unit->Event(AString("Is teleported to ") +
						tar->region->Print( &regions ) +
						" by " + *u->name + ".");

				// Unit cannot instantly guard the destination
				loc->unit->guard = GUARD_NONE;
				loc->unit->MoveUnit( tar->obj );

				if (loc->unit != u)
					loc->unit->ClearCastOrders();
			}

			delete loc;
		}
	}

	delete tar;
}

void Game::RunTeleportOrders()
{
	forlist(&regions) {
		ARegion * r = (ARegion *) elem;
		forlist(&r->objects) {
			Object * o = (Object *) elem;
			int foundone = 1;
			while (foundone) {
				foundone = 0;
				for (auto &u : o->getUnits())
				{
					if (u->teleportorders)
					{
						foundone = 1;
						switch (u->teleportorders->spell)
						{
							case S_GATE_LORE:
								RunGateJump(r, o, u);
								break;
							case S_TELEPORTATION:
								RunTeleport(r, o, u);
								break;
							case S_PORTAL_LORE:
								RunPortalLore(r, o, u);
								break;
						}
						delete u->teleportorders;
						u->teleportorders = 0;
						break;
					}
				}
			}
		}
	}
}