#include <iostream>

#include "boe.global.hpp"

#include <array>
#include <map>

#include "universe.hpp"

#include "boe.fileio.hpp"
#include "boe.graphics.hpp"
#include "boe.graphutil.hpp"
#include "boe.newgraph.hpp"
#include "boe.specials.hpp"
#include "boe.infodlg.hpp"
#include "boe.items.hpp"
#include "boe.actions.hpp"
#include <cstring>
#include <queue>
#include "boe.party.hpp"
#include "boe.monster.hpp"
#include "boe.town.hpp"
#include "boe.combat.hpp"
#include "boe.locutils.hpp"
#include "boe.combat.hpp"
#include "boe.text.hpp"
#include "sounds.hpp"
#include "boe.main.hpp"
#include "utility.hpp"
#include "mathutil.hpp"
#include "strdlog.hpp"
#include "choicedlog.hpp"
#include "pictchoice.hpp"
#include "winutil.hpp"
#include "fileio.hpp"
#include "boe.menus.hpp"
#include <boost/lexical_cast.hpp>
#include "button.hpp"
#include "spell.hpp"
#include "cursors.hpp"
#include "render_shapes.hpp" // for colour constants

extern short skill_bonus[21];

// TODO: Use magic-names.txt instead of these arrays
bool get_mage[30] = {1,1,1,1,1,1,0,1,1,0, 1,1,1,1,1,1,0,0,1,1, 1,1,1,1,1,0,0,0,1,1};
bool get_priest[30] = {1,1,1,1,1,1,0,0,0,1, 1,1,1,1,1,0,0,0,1,1, 1,0,1,1,0,0,0,1,0,0};
short combat_percent[20] = {
	150,120,100,90,80,80,80,70,70,70,
	70,70,67,62,57,52,47,42,40,40};

short who_cast,which_pc_displayed;
eSpell town_spell;
extern bool spell_freebie;
extern eSpecCtxType spec_target_type;
extern short spec_target_fail, spec_target_options;
bool spell_button_active[90];

extern bool end_scenario;
extern short fast_bang;
extern bool flushingInput;
extern eItemWinMode stat_window;
extern eGameMode overall_mode;
extern fs::path progDir;
extern location center;
extern sf::RenderWindow mainPtr;
extern bool spell_forced,boom_anim_active;
extern eSpell store_mage, store_priest;
extern short store_mage_lev, store_priest_lev;
extern short store_spell_target,pc_casting;
extern short store_item_spell_level;
extern eStatMode stat_screen_mode;
extern effect_pat_type null_pat,single,t,square,radius2,radius3,small_square,open_square;
extern effect_pat_type current_pat;
extern short current_spell_range;
extern std::array<short, 51> hit_chance;
extern short combat_active_pc;
extern std::map<eDamageType,int> boom_gr;
extern short current_ground;
extern location golem_m_locs[16];
extern cUniverse univ;
extern sf::Texture pc_gworld;
extern std::queue<pending_special_type> special_queue;

// First icon is displayed for positive values, second for negative, if -1 no negative icon.
// This omits two special cases - major poison, and normal speed; they are hard-coded.
std::map<eStatus, std::pair<short, short>> statIcons = {
	{eStatus::POISONED_WEAPON, {4,-1}}, {eStatus::BLESS_CURSE, {2,3}}, {eStatus::POISON, {0,-1}},
	{eStatus::HASTE_SLOW, {6,8}}, {eStatus::INVULNERABLE, {5,-1}}, {eStatus::MAGIC_RESISTANCE, {9,19}},
	{eStatus::WEBS, {10,-1}}, {eStatus::DISEASE, {11,-1}}, {eStatus::INVISIBLE, {12,-1}},
	{eStatus::DUMB, {13,18}}, {eStatus::MARTYRS_SHIELD, {14,-1}}, {eStatus::ASLEEP, {15,21}},
	{eStatus::PARALYZED, {16,-1}}, {eStatus::ACID, {17,-1}}, {eStatus::FORCECAGE, {20,-1}},
};

// Variables for spell selection
short on_which_spell_page = 0;
short store_last_cast_mage = 6,store_last_cast_priest = 6;
short buttons_on[38] = {1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0};
// buttons_on determines which buttons can be hit when on the second spell page
short spell_index[38] = {38,39,40,41,42,43,44,45,90,90,46,47,48,49,50,51,52,53,90,90,
	54,55,56,57,58,59,60,61,90,90, 90,90,90,90,90,90,90,90};
// Says which buttons hit which spells on second spell page, 90 means no button
bool can_choose_caster;

// Dialog vars
short store_graphic_pc_num ;
short store_graphic_mode ;
short store_pc_graphic;

// When the party is placed into a scen from the starting screen, this is called to put the game into game
// mode and load in the scen and init the party info
// party record already contains scen name
void put_party_in_scen(std::string scen_name) {
	bool item_took = false;
	
	// Drop debug mode
	univ.debug_mode = false;
	univ.ghost_mode = false;
	univ.node_step_through = false;
	
	for(short j = 0; j < 6; j++)
		for(short i = 23; i >= 0; i--) {
			cItem& thisItem = univ.party[j].items[i];
			thisItem.special_class = 0;
			if(thisItem.ability == eItemAbil::CALL_SPECIAL) {
				univ.party[j].take_item(i);
				item_took = true;
			} else if(thisItem.ability == eItemAbil::WEAPON_CALL_SPECIAL) {
				univ.party[j].take_item(i);
				item_took = true;
			} else if(thisItem.ability == eItemAbil::HIT_CALL_SPECIAL) {
				univ.party[j].take_item(i);
				item_took = true;
			} else if(thisItem.ability == eItemAbil::DROP_CALL_SPECIAL) {
				univ.party[j].take_item(i);
				item_took = true;
			} else if(thisItem.ability == eItemAbil::PROTECT_FROM_SPECIES && thisItem.abil_data[1] == int(eRace::IMPORTANT)) {
				univ.party[j].take_item(i);
				item_took = true;
			} else if(thisItem.ability == eItemAbil::SLAYER_WEAPON && thisItem.abil_data[1] == int(eRace::IMPORTANT)) {
				univ.party[j].take_item(i);
				item_took = true;
			}
		}
	if(item_took)
		cChoiceDlog("removed-special-items").show();
	
	fs::path path = locate_scenario(scen_name);
	if(path.empty()) {
		showError("Could not find scenario!");
		return;
	}
	set_cursor(watch_curs);
	end_scenario=false;
	if(!load_scenario(path, univ.scenario))
		return;
	bool stored_item = false;
	for(auto& store : univ.party.stored_items)
		stored_item = stored_item || std::any_of(store.begin(), store.end(), [](const cItem& item) {
			return item.variety != eItemType::NO_ITEM;
		});
	if(stored_item)
		if(cChoiceDlog("keep-stored-items", {"yes", "no"}).show() == "yes") {
			std::vector<cItem*> saved_item_refs;
			for(short i = 0; i < 3;i++)
				for(short j = 0; j < univ.party.stored_items[i].size(); j++)
					if(univ.party.stored_items[i][j].variety != eItemType::NO_ITEM)
						saved_item_refs.push_back(&univ.party.stored_items[i][j]);
			short pc = 0;
			while(univ.party[pc].main_status != eMainStatus::ALIVE && pc < 6) pc++;
			show_get_items("Choose stored items to keep:", saved_item_refs, pc, true);
		}
	
	univ.enter_scenario(scen_name);
	
	// if at this point, startup must be over, so make this call to make sure we're ready,
	// graphics wise
	end_startup();
	
	stat_screen_mode = MODE_INVEN;
	build_outdoors();
	erase_out_specials();
	
	univ.cur_pc = first_active_pc();
	force_town_enter(univ.scenario.which_town_start,univ.scenario.where_start);
	start_town_mode(univ.scenario.which_town_start,9);
	while(!special_queue.empty())
		special_queue.pop(); // Preserve legacy behaviour of not calling the "enter town" node at scenario start
	center = univ.scenario.where_start;
	update_explored(univ.scenario.where_start);
	overall_mode = MODE_TOWN;
	redraw_screen(REFRESH_ALL);
	set_stat_window(ITEM_WIN_PC1);
	adjust_spell_menus();
	adjust_monst_menu();
	
	// Throw up intro dialog
	for(short j = 0; j < univ.scenario.intro_strs.size(); j++)
		if(!univ.scenario.intro_strs[j].empty()) {
			std::array<short, 3> buttons = {0,-1,-1};
			custom_choice_dialog(univ.scenario.intro_strs, univ.scenario.intro_mess_pic, PIC_SCEN, buttons);
			j = 6;
		}
	run_special(eSpecCtx::STARTUP, eSpecCtxType::SCEN, univ.scenario.init_spec, loc(0,0));
	give_help(1,2);
	
	// Compatibility flags
	if(univ.scenario.format.prog_make_ver[0] < 2){
		univ.scenario.is_legacy = true;
	}
}

//spot; // if spot is 6, find one
bool create_pc(short spot,cDialog* parent) {
	bool still_ok = true;
	
	if(spot == 6) spot = univ.party.free_space();
	if(spot == 6) return false;
	univ.party.new_pc(spot);
	
	pick_race_abil(spot,0,parent);
	
	still_ok = spend_xp(spot,0,parent);
	if(!still_ok)
		return false;
	
	pick_pc_graphic(spot,0,parent);
	pick_pc_name(spot,parent);
	
	univ.party[spot].main_status = eMainStatus::ALIVE;
	
	if(overall_mode != MODE_STARTUP) {
		// If this is called while in startup mode, it means we're in the middle of building a party.
		// Thus, the PC should not be finalized yet.
		// However, if we're not in startup mode, it means we're adding a new PC to an existing party.
		// Thus, we must finalize the PC now.
		univ.party[spot].finish_create();
	}
	univ.party[spot].cur_health = univ.party[spot].max_health;
	univ.party[spot].cur_sp = univ.party[spot].max_sp;
	
	return true;
}

bool take_sp(short pc_num,short amt) {
	if(univ.party[pc_num].cur_sp < amt)
		return false;
	univ.party[pc_num].cur_sp -= amt;
	return true;
}

void increase_light(short amt) {
	location where;
	
	univ.party.light_level += amt;
	if(univ.party.light_level < 0)
		univ.party.light_level = 0;
	if(is_combat()) {
		for(short i = 0; i < 6; i++)
			if(univ.party[i].main_status == eMainStatus::ALIVE) {
				update_explored(univ.party[i].combat_pos);
			}
	}
	else {
		where = get_cur_loc();
		update_explored(where);
	}
	put_pc_screen();
}

void award_party_xp(short amt) {
	for(short i = 0; i < 6; i++)
		if(univ.party[i].main_status == eMainStatus::ALIVE)
			award_xp(i,amt);
}

void award_xp(short pc_num,short amt,bool force) {
	short adjust,add_hp;
	short xp_percent[30] = {
		150,120,100,90,80,70,60,50,50,50,
		45,40,40,40,40,35,30,25,23,20,
		15,15,15,15,15,15,15,15,15,15};
	if(univ.party[pc_num].level > 49) {
		univ.party[pc_num].level = 50;
		return;
	}
	if(!force && amt > 200) { // debug
		beep();
		ASB("Oops! Too much xp!");
		ASB("Report this!");
		return;
	}
	if(amt < 0) { // debug
		beep();
		ASB("Oops! Negative xp!");
		ASB("Report this!");
		return;
	}
	if(univ.party[pc_num].main_status != eMainStatus::ALIVE)
		return;
	
	if(univ.party[pc_num].level >= 40)
		adjust = 15;
	else adjust = xp_percent[univ.party[pc_num].level / 2];
	
	if((amt > 0) && (univ.party[pc_num].level > 7)) {
		if(get_ran(1,1,100) < xp_percent[univ.party[pc_num].level / 2])
			amt--;
	}
	if(amt <= 0)
		return;
	
	
//	univ.party[pc_num].experience += (max(((amt * adjust) / 100), 0) * univ.party[pc_num].exp_adj) / 100;
//	univ.party.total_xp_gained += (max(((amt * adjust) / 100), 0) * univ.party[pc_num].exp_adj) / 100;
	univ.party[pc_num].experience += (max(((amt * adjust) / 100), 0) * 100) / 100;
	univ.party.total_xp_gained += (max(((amt * adjust) / 100), 0) * 100) / 100;
	
	
	
//	if(univ.party[pc_num].experience < 0) {
//		SysBeep(50); SysBeep(50);
//		ASB("Oops! Xp became negative somehow!");
//		ASB("Report this!");
//		univ.party[pc_num].experience = univ.party[pc_num].level * (univ.party[pc_num].get_tnl()) - 1;
//		return;
//		}
	if(univ.party[pc_num].experience > 15000) {
		univ.party[pc_num].experience = 15000;
		return;
	}
	
	while(univ.party[pc_num].experience >= (univ.party[pc_num].level * (univ.party[pc_num].get_tnl()))) {
		play_sound(7);
		univ.party[pc_num].level++;
		std::string level = std::to_string(univ.party[pc_num].level);
		add_string_to_buf("  " + univ.party[pc_num].name + " is level " + level + "!");
		univ.party[pc_num].skill_pts += (univ.party[pc_num].level < 20) ? 5 : 4;
		add_hp = (univ.party[pc_num].level < 26) ? get_ran(1,2,6) + skill_bonus[univ.party[pc_num].skills[eSkill::STRENGTH]]
			: max (skill_bonus[univ.party[pc_num].skills[eSkill::STRENGTH]],0);
		if(add_hp < 0)
			add_hp = 0;
		univ.party[pc_num].max_health += add_hp;
		if(univ.party[pc_num].max_health > 250)
			univ.party[pc_num].max_health = 250;
		univ.party[pc_num].cur_health += add_hp;
		if(univ.party[pc_num].cur_health > 250)
			univ.party[pc_num].cur_health = 250;
		put_pc_screen();
		
	}
}

void drain_pc(cPlayer& which_pc,short how_much) {
	if(which_pc.main_status == eMainStatus::ALIVE) {
		which_pc.experience = max(which_pc.experience - how_much,0);
		add_string_to_buf("  " + which_pc.name + " drained.");
	}
}

static short check_party_stat_get(short pc, eSkill which_stat) {
	switch(which_stat) {
		case eSkill::MAX_HP:
			return univ.party[pc].max_health;
		case eSkill::MAX_SP:
			return univ.party[pc].max_sp;
		case eSkill::CUR_HP:
			return univ.party[pc].cur_health;
		case eSkill::CUR_SP:
			return univ.party[pc].cur_sp;
		case eSkill::CUR_XP:
			return univ.party[pc].experience;
		case eSkill::CUR_SKILL:
			return univ.party[pc].skill_pts;
		case eSkill::CUR_LEVEL:
			return univ.party[pc].level;
		default:
			return univ.party[pc].skill(which_stat);
	}
	return 0;
}

// mode: 0 = total, 1 = mean, 2 = min, 3 = max, 10+i = just PC i
short check_party_stat(eSkill which_stat, short mode) {
	if(mode >= 10) return check_party_stat_get(mode - 10, which_stat);
	
	short total = mode == 2 ? std::numeric_limits<short>::max() : 0, num_pcs = 0;
	
	for(short i = 0; i < 6; i++)
		if(univ.party[i].main_status == eMainStatus::ALIVE) {
			num_pcs++;
			if(mode < 2)
				total += check_party_stat_get(i,which_stat);
			else if(mode == 3)
				total = max(check_party_stat_get(i,which_stat), total);
			else if(mode == 2)
				total = min(check_party_stat_get(i,which_stat), total);
		}
	
	if(mode == 1 && num_pcs > 0)
		total /= num_pcs;
	
	return total;
}

bool poison_weapon(short pc_num, short how_much,bool safe) {
	short p_level,r1;
	short p_chance[21] = {
		40,72,81,85,88,89,90,
		91,92,93,94,94,95,95,96,97,98,100,100,100,100};
	// TODO: This doesn't allow you to choose between poisoning a melee weapon and poisoning arrows, except by temporarily dequipping one
	
	auto weap = univ.party[pc_num].items.begin();
	do {
		weap = std::find_if(weap, univ.party[pc_num].items.end(), is_poisonable_weap);
		
		if(!univ.party[pc_num].equip[weap - univ.party[pc_num].items.begin()]) {
			weap++;
			continue;
		}
		
		p_level = how_much;
		add_string_to_buf("  You poison your weapon.");
		r1 = get_ran(1,1,100);
		// Nimble?
		if(univ.party[pc_num].traits[eTrait::NIMBLE])
			r1 -= 6;
		if(r1 > p_chance[univ.party[pc_num].skill(eSkill::POISON)] && !safe) {
			add_string_to_buf("  Poison put on badly.");
			p_level = p_level / 2;
			r1 = get_ran(1,1,100);
			if(r1 > p_chance[univ.party[pc_num].skill(eSkill::POISON)] + 10) {
				add_string_to_buf("  You nick yourself.");
				univ.party[pc_num].status[eStatus::POISON] += p_level;
			}
		}
		if(!safe)
			play_sound(55);
		univ.party[pc_num].weap_poisoned.slot = weap - univ.party[pc_num].items.begin();
		univ.party[pc_num].status[eStatus::POISONED_WEAPON] = max(univ.party[pc_num].status[eStatus::POISONED_WEAPON], p_level);
		
		return true;
	} while(weap != univ.party[pc_num].items.end());
	
	add_string_to_buf("  No weapon equipped.");
	return false;
}

bool is_poisonable_weap(cItem& weap) {
	if(weap.variety == eItemType::ONE_HANDED || weap.variety == eItemType::TWO_HANDED ||
		weap.variety == eItemType::ARROW || weap.variety == eItemType::BOLTS)
		return true;
	else return false;
	
}

//short type; // 0 - mage  1 - priest
void cast_spell(eSkill type) {
	eSpell spell;
	
	if((is_town()) && (univ.town.is_antimagic(univ.party.town_loc.x,univ.party.town_loc.y))) {
		add_string_to_buf("  Not in antimagic field.");
		return;
	}
	
	if(!spell_forced)
		spell = pick_spell(6, type);
	else {
		if(!repeat_cast_ok(type))
			return;
		spell = type == eSkill::MAGE_SPELLS ? store_mage : store_priest;
	}
	if(spell != eSpell::NONE) {
		print_spell_cast(spell,type);
		
		if(type == eSkill::MAGE_SPELLS)
			do_mage_spell(pc_casting,spell);
		else do_priest_spell(pc_casting,spell);
		put_pc_screen();
		
	}
}

bool repeat_cast_ok(eSkill type) {
	short who_would_cast;
	eSpellSelect store_select;
	eSpell what_spell;
	
	if(!prime_time()) return false;
	else if(overall_mode == MODE_COMBAT)
		who_would_cast = univ.cur_pc;
	else who_would_cast = pc_casting;
	
	if(is_combat())
		what_spell = univ.party[who_would_cast].last_cast[type];
	else what_spell = type == eSkill::MAGE_SPELLS ? store_mage : store_priest;
	
	if(!pc_can_cast_spell(univ.party[who_would_cast],what_spell)) {
		add_string_to_buf("Repeat cast: Can't cast.");
		return false;
	}
	store_select = (*what_spell).need_select;
	if(store_select != SELECT_NO && store_spell_target == 6) {
		add_string_to_buf("Repeat cast: No target stored.");
		return false;
	}
	if(store_select == SELECT_ANY &&
			isAbsent(univ.party[store_spell_target].main_status)) {
		add_string_to_buf("Repeat cast: No target stored.");
		return false;
	}
	if(store_select == SELECT_ACTIVE &&
	   univ.party[store_spell_target].main_status != eMainStatus::ALIVE) {
		add_string_to_buf("Repeat cast: No target stored.");
		return false;
	}
	
	return true;
	
}

//which; // 100 + x : priest spell x
void give_party_spell(short which) {
	bool sound_done = false;
	
	if((which < 0) || (which > 161) || ((which > 61) && (which < 100))) {
		showError("The scenario has tried to give you a non-existant spell.");
		return;}
	
	// TODO: This seems like the wrong sounds
	// TODO: The order of checking seems wrong here; why check for alive after checking for the spell?
	if(which < 100)
		for(short i = 0; i < 6; i++)
			if(!univ.party[i].mage_spells[which]) {
				univ.party[i].mage_spells[which] = true;
				if(univ.party[i].main_status == eMainStatus::ALIVE)
					add_string_to_buf(univ.party[i].name + " learns spell.");
				give_help(41,0);
				if(!sound_done) {
					sound_done = true;
					play_sound(62);
				};
			}
	if(which >= 100)
		for(short i = 0; i < 6; i++)
			if(!univ.party[i].priest_spells[which - 100]) {
				univ.party[i].priest_spells[which - 100] = true;
				if(univ.party[i].main_status == eMainStatus::ALIVE)
					add_string_to_buf(univ.party[i].name + " learns spell.");
				give_help(41,0);
				if(!sound_done) {
					sound_done = true;
					play_sound(62);
				}
			}
}

void do_mage_spell(short pc_num,eSpell spell_num,bool freebie) {
	short target,r1,adj,store;
	location where;
	if (univ.scenario.is_legacy) freebie=false;
	if(univ.party[pc_num].traits[eTrait::ANAMA]) {
		add_string_to_buf("Cast: You're an Anama!");
		return;
	}
	if(univ.party[pc_num].traits[eTrait::PACIFIST] && !(*spell_num).peaceful) {
		add_string_to_buf("Cast: You're a pacifist!");
		return;
	}
	
	where = univ.party.town_loc;
	play_sound(25);
	current_spell_range = 8;
	store_mage = spell_num;
	
	adj = freebie ? 1 : univ.party[pc_num].stat_adj(eSkill::INTELLIGENCE);
	short level = freebie ? store_item_spell_level : univ.party[pc_num].level;
	if(!freebie && (*spell_num).level <= univ.party[pc_num].get_prot_level(eItemAbil::MAGERY))
		level++;
	
	switch(spell_num) {
		case eSpell::LIGHT:
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			increase_light(50);
			break;
			
		case eSpell::IDENTIFY:
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			ASB("All of your items are identified.");
			for(cPlayer& pc : univ.party)
				for(cItem& item : pc.items)
					item.ident = true;
			break;
			
		case eSpell::TRUE_SIGHT:
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			for(where.x = 0; where.x < 64; where.x++)
				for(where.y = 0; where.y < 64; where.y++)
					if(dist(where,univ.party.town_loc) <= 2)
						make_explored(where.x,where.y);
			clear_map();
			break;
			
		case eSpell::SUMMON_BEAST:
			r1 = get_summon_monster(1);
			if(r1 < 0) break;
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			store = get_ran(3,1,4) + adj;
			if(!summon_monster(r1,where,store,eAttitude::FRIENDLY,true))
				add_string_to_buf("  Summon failed.");
			break;
		case eSpell::SUMMON_WEAK:
			store = level / 5 + adj / 3 + get_ran(1,0,2);
			r1 = get_summon_monster(1); ////
			if(r1 < 0) break;
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			store = get_ran(4,1,4) + adj;
			for(short i = 0; i < minmax(1,7,store); i++)
				if(!summon_monster(r1,where,store,eAttitude::FRIENDLY,true))
					add_string_to_buf("  Summon failed.");
			break;
		case eSpell::SUMMON:
			store = level / 7 + adj / 3 + get_ran(1,0,1);
			r1 = get_summon_monster(2); ////
			if(r1 < 0) break;
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			store = get_ran(5,1,4) + adj;
			for(short i = 0; i < minmax(1,6,store); i++)
				if(!summon_monster(r1,where,store,eAttitude::FRIENDLY,true))
					add_string_to_buf("  Summon failed.");
			break;
		case eSpell::SUMMON_AID:
			r1 = get_summon_monster(2);
			if(r1 < 0) break;
			store = get_ran(5,1,4) + adj;
			if(!summon_monster(r1,where,store,eAttitude::FRIENDLY,true))
				add_string_to_buf("  Summon failed.");
			break;
		case eSpell::SUMMON_MAJOR:
			store = level / 10 + adj / 3 + get_ran(1,0,1);
			r1 = get_summon_monster(3); ////
			if(r1 < 0) break;
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			store = get_ran(7,1,4) + adj;
			for(short i = 0; i < minmax(1,5,store); i++)
				if(!summon_monster(r1,where,store,eAttitude::FRIENDLY,true))
					add_string_to_buf("  Summon failed.");
			break;
		case eSpell::SUMMON_AID_MAJOR:
			r1 = get_summon_monster(3);
			if(r1 < 0) break;
			store = get_ran(7,1,4) + adj;
			if(!summon_monster(r1,where,store,eAttitude::FRIENDLY,true))
				add_string_to_buf("  Summon failed.");
			break;
		case eSpell::DEMON:
			store = get_ran(5,1,4) + 2 * adj;
			if(!summon_monster(85,where,store,eAttitude::FRIENDLY,true))
				add_string_to_buf("  Summon failed.");
			else if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			break;
		case eSpell::SUMMON_RAT:
			store = get_ran(5,1,4) + 2 * adj;
			if(!summon_monster(80,where,store,eAttitude::FRIENDLY,true))
				add_string_to_buf("  Summon failed.");
			break;
			
		case eSpell::DISPEL_SQUARE:
			start_town_targeting(spell_num,pc_num,freebie,PAT_SQ);
			break;
			
		case eSpell::LIGHT_LONG:
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			increase_light(200);
			break;
			
		case eSpell::MAGIC_MAP:
		{
			cInvenSlot item = univ.party[pc_num].has_abil(eItemAbil::SAPPHIRE);
			if(!item && !freebie)
				add_string_to_buf("  You need a sapphire.");
			else if(univ.town->defy_scrying || univ.town->defy_mapping)
				add_string_to_buf("  The spell fails.");
			else {
				if(freebie) add_string_to_buf("  You have a vision.");
				else {
					univ.party[pc_num].remove_charge(item.slot);
					if(stat_window == pc_num)
						put_item_screen(stat_window);
					univ.party[pc_num].cur_sp -= (*spell_num).cost;
					add_string_to_buf("  As the sapphire dissolves, you have a vision.", 2);
				}
				for(short i = 0; i < 64; i++)
					for(short j = 0; j < 64; j++)
						make_explored(i,j);
				clear_map();
			}
			break;
		}
			
			
		case eSpell::STEALTH:
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			univ.party.status[ePartyStatus::STEALTH] += max(6,level * 2);
			break;
			
			
		case eSpell::SCRY_MONSTER: case eSpell::UNLOCK: case eSpell::CAPTURE_SOUL: case eSpell::DISPEL_BARRIER:
		case eSpell::BARRIER_FIRE: case eSpell::BARRIER_FORCE: case eSpell::QUICKFIRE:
			start_town_targeting(spell_num,pc_num,freebie);
			break;
			
		case eSpell::ANTIMAGIC:
			start_town_targeting(spell_num,pc_num,freebie,PAT_RAD2);
			break;
			
		case eSpell::FLIGHT:
			if(univ.party.status[ePartyStatus::FLIGHT] > 0) {
				add_string_to_buf("  Not while already flying.");
				return;
			}
			if(univ.party.in_boat >= 0)
				add_string_to_buf("  Leave boat first.");
			else if(univ.party.in_horse >= 0) ////
				add_string_to_buf("  Leave horse first.");
			else {
				if(!freebie)
					univ.party[pc_num].cur_sp -= (*spell_num).cost;
				add_string_to_buf("  You start flying!");
				univ.party.status[ePartyStatus::FLIGHT] = 3;
			}
			break;
			
		case eSpell::RESIST_MAGIC: case eSpell::PROTECTION:
			target = store_spell_target;
			if(target < 6 && !freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			if(spell_num == eSpell::PROTECTION && target < 6) {
				univ.party[target].status[eStatus::INVULNERABLE] += 2 + adj + get_ran(2,1,2);
				for(short i = 0; i < 6; i++)
					if(univ.party[i].main_status == eMainStatus::ALIVE) {
						univ.party[i].status[eStatus::MAGIC_RESISTANCE] += 4 + level / 3 + adj;
					}
				add_string_to_buf("  Party protected.");
			}
			if(spell_num == eSpell::RESIST_MAGIC && target < 6) {
				univ.party[target].status[eStatus::MAGIC_RESISTANCE] += 2 + adj + get_ran(2,1,2);
				add_string_to_buf("  " + univ.party[target].name + " protected.");
			}
			break;
		default:
			add_string_to_buf("  Error: Mage spell " + (*spell_num).name() + " not implemented for town mode.", 4);
			break;
	}
}

void do_priest_spell(short pc_num,eSpell spell_num,bool freebie) {
	short r1,r2, target,store,adj,x,y;
	location loc;
	location where;
	
	if (univ.scenario.is_legacy) freebie=false;
	if(univ.party[pc_num].traits[eTrait::PACIFIST] && !(*spell_num).peaceful) {
		add_string_to_buf("Cast: You're a pacifist!");
		return;
	}
	
	short store_victim_health,store_caster_health,targ_damaged; // for symbiosis
	
	where = univ.party.town_loc;
	
	adj = freebie ? 1 : univ.party[pc_num].stat_adj(eSkill::INTELLIGENCE);
	short level = freebie ? store_item_spell_level : univ.party[pc_num].level;
	if(!freebie && univ.current_pc().traits[eTrait::ANAMA])
		level++;
	
	play_sound(24);
	current_spell_range = 8;
	store_priest = spell_num;
	std::ostringstream loc_str;
	
	switch(spell_num) {
		case eSpell::LOCATION:
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			
			if(is_town()) {
				loc = (overall_mode == MODE_OUTDOORS) ? univ.party.out_loc : univ.party.town_loc;
				loc_str <<  "  You're at: x " << loc.x << "  y " << loc.y << '.';
			}
			if(is_out()) {
				loc = (overall_mode == MODE_OUTDOORS) ? univ.party.out_loc : univ.party.town_loc;
				x = loc.x; y = loc.y;
				x += 48 * univ.party.outdoor_corner.x; y += 48 * univ.party.outdoor_corner.y;
				loc_str << "  You're outside at: x " << x << "  y " << y << '.';
				
			}
			add_string_to_buf(loc_str.str());
			break;
			
		case eSpell::MANNA_MINOR: case eSpell::MANNA:
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			store = level / 3 + 2 * adj + get_ran(2,1,4);
			r1 = max(0,store);
			if(spell_num == eSpell::MANNA_MINOR)
				r1 = r1 / 3;
			add_string_to_buf("  You gain " + std::to_string(r1) + " food.   ");
			give_food(r1,true);
			break;
			
		case eSpell::RITUAL_SANCTIFY:
			add_string_to_buf("  Sanctify which space?");
			start_town_targeting(spell_num,pc_num,freebie);
			break;
			
		case eSpell::LIGHT_DIVINE:
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			increase_light(210);
			break;
			
		case eSpell::SUMMON_SPIRIT:
			if(!summon_monster(125,where,get_ran(2,1,4) + adj,eAttitude::FRIENDLY,true))
				add_string_to_buf("  Summon failed.");
			else if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			break;
		case eSpell::STICKS_TO_SNAKES:
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			r1 = level / 6 + adj / 3 + get_ran(1,0,1);
			for(int i = 0; i < r1; i++) {
				r2 = get_ran(1,0,7);
				store = get_ran(2,1,5) + adj;
				if(!summon_monster((r2 == 1) ? 100 : 99,where,store,eAttitude::FRIENDLY,true))
					add_string_to_buf("  Summon failed.");
			}
			break;
		case eSpell::SUMMON_HOST:
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			store = get_ran(2,1,4) + adj;
			if(!summon_monster(126,where,store,eAttitude::FRIENDLY,true))
				add_string_to_buf("  Summon failed.");
			for(int i = 0; i < 4; i++)	{
				store = get_ran(2,1,4) + adj;
				if(!summon_monster(125,where,store,eAttitude::FRIENDLY,true))
					add_string_to_buf("  Summon failed.");
			}
			break;
		case eSpell::SUMMON_GUARDIAN:
			store = get_ran(6,1,4) + adj;
			if(!summon_monster(122,where,store,eAttitude::FRIENDLY,true))
				add_string_to_buf("  Summon failed.");
			else if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			break;
			
		case eSpell::MOVE_MOUNTAINS: case eSpell::MOVE_MOUNTAINS_MASS:
			add_string_to_buf("  Destroy what?");
			start_town_targeting(spell_num,pc_num,freebie, spell_num == eSpell::MOVE_MOUNTAINS ? PAT_SINGLE : PAT_SQ);
			break;
			
		case eSpell::DISPEL_SPHERE: case eSpell::DISPEL_FIELD:
			start_town_targeting(spell_num,pc_num,freebie, spell_num == eSpell::DISPEL_SPHERE ? PAT_RAD2 : PAT_SINGLE);
			break;
			
		case eSpell::DETECT_LIFE:
			add_string_to_buf("  Monsters now on map.");
			univ.party.status[ePartyStatus::DETECT_LIFE] += 6 + get_ran(1,0,6);
			clear_map();
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			break;
		case eSpell::FIREWALK:
			add_string_to_buf("  You are now firewalking.");
			univ.party.status[ePartyStatus::FIREWALK] += level / 12 + 2;
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			break;
			
		case eSpell::SHATTER:
			add_string_to_buf("  You send out a burst of energy.");
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			for(loc.x = where.x - 1;loc.x < where.x + 2; loc.x++)
				for(loc.y = where.y - 1;loc.y < where.y + 2; loc.y++)
					crumble_wall(loc);
			update_explored(univ.party.town_loc);
			break;
			
		case eSpell::WORD_RECALL:
			if(!is_out()) {
				add_string_to_buf("  Can only cast outdoors.");
				return;
			}
			if(univ.party.in_boat >= 0) {
				add_string_to_buf("  Not while in boat.");
				return;
			}
			if(univ.party.in_horse >= 0) {////
				add_string_to_buf("  Not while on horseback.");
				return;
			}
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			// Clear forcecage status
			for(int i = 0; i < 6; i++)
				univ.party[i].status[eStatus::FORCECAGE] = 0;
			add_string_to_buf("  You are moved... ");
			force_town_enter(univ.scenario.which_town_start,univ.scenario.where_start);
			start_town_mode(univ.scenario.which_town_start,9);
			position_party(univ.scenario.out_sec_start.x,univ.scenario.out_sec_start.y,
						   univ.scenario.out_start.x,univ.scenario.out_start.y);
			center = univ.party.town_loc = univ.scenario.where_start;
//			overall_mode = MODE_OUTDOORS;
//			center = univ.party.p_loc;
//			update_explored(univ.party.p_loc);
			redraw_screen(REFRESH_ALL);
			break;
			
		case eSpell::HEAL_MINOR: case eSpell::HEAL: case eSpell::HEAL_MAJOR:
		case eSpell::POISON_WEAKEN: case eSpell::POISON_CURE: case eSpell::DISEASE_CURE:
		case eSpell::RESTORE_MIND: case eSpell::CLEANSE: case eSpell::AWAKEN: case eSpell::PARALYSIS_CURE:
//			target = select_pc(11,0);
			target = store_spell_target;
			if(target < 6) {
				if(!freebie)
					univ.party[pc_num].cur_sp -= (*spell_num).cost;
				std::ostringstream sout;
				sout << "  " << univ.party[target].name;
				switch(spell_num) {
					case eSpell::HEAL_MINOR: case eSpell::HEAL: case eSpell::HEAL_MAJOR:
						if(spell_num == eSpell::HEAL_MINOR)
							r1 = get_ran(2, 1, 4);
						else r1 = get_ran(2 + (spell_num == eSpell::HEAL ? 6 : 12), 1, 4);
						sout << " healed " << r1 << '.';
						univ.party[target].heal(r1);
						one_sound(52);
						break;
						
					case eSpell::POISON_WEAKEN: case eSpell::POISON_CURE:
						sout << " cured.";
						r1 = ((spell_num == eSpell::POISON_WEAKEN) ? 1 : 3) + get_ran(1,0,2) + adj / 2;
						univ.party[target].cure(r1);
						break;
						
					case eSpell::AWAKEN:
						if(univ.party[target].status[eStatus::ASLEEP] <= 0) {
							sout << " is already awake!";
							break;
						}
						sout << " wakes up.";
						univ.party[target].status[eStatus::ASLEEP] = 0;
						break;
					case eSpell::PARALYSIS_CURE:
						if(univ.party[target].status[eStatus::PARALYZED] <= 0) {
							sout << " isn't paralyzed!";
							break;
						}
						sout << " can move now.";
						univ.party[target].status[eStatus::PARALYZED] = 0;
						break;
						
					case eSpell::DISEASE_CURE:
						sout << " recovers.";
						r1 = 2 + get_ran(1,0,2) + adj / 2;
						univ.party[target].status[eStatus::DISEASE] = max(0,univ.party[target].status[eStatus::DISEASE] - r1);
						break;
						
					case eSpell::RESTORE_MIND:
						if(univ.party[target].status[eStatus::DUMB] <= 0) {
							sout << " isn't dumbfounded!";
							break;
						}
						sout << " restored.";
						r1 = 1 + get_ran(1,0,2) + adj / 2;
						univ.party[target].status[eStatus::DUMB] = max(0,univ.party[target].status[eStatus::DUMB] - r1);
						break;
						
					case eSpell::CLEANSE:
						sout << " cleansed.";
						univ.party[target].status[eStatus::DISEASE] = 0;
						univ.party[target].status[eStatus::WEBS] = 0;
						break;
					default:
						add_string_to_buf("  Error: Healing spell " + (*spell_num).name() + " not implemented for town mode.", 4);
						break;
				}
				add_string_to_buf(sout.str());
			}
			put_pc_screen();
			break;
			
		case eSpell::REVIVE: case eSpell::DESTONE: case eSpell::RAISE_DEAD: case eSpell::RESURRECT:
		case eSpell::CURSE_REMOVE: case eSpell::SANCTUARY: case eSpell::SYMBIOSIS: case eSpell::MARTYRS_SHIELD:
			target = store_spell_target;
			
			if(target < 6) {
				if(spell_num == eSpell::SYMBIOSIS && target == pc_num) {
					add_string_to_buf("  Can't cast on self.");
					return;
				}
				
				if(!freebie)
					univ.party[pc_num].cur_sp -= (*spell_num).cost;
				std::ostringstream sout;
				sout << "  " << univ.party[target].name;
				if(spell_num == eSpell::MARTYRS_SHIELD) {
					sout << " shielded.";
					r1 = max(1,get_ran((level + 5) / 5,1,3) + adj);
					univ.party[target].status[eStatus::MARTYRS_SHIELD] += r1;
				} else if(spell_num == eSpell::SANCTUARY) {
					sout << " hidden.";
					r1 = max(0,get_ran(0,1,3) + level / 4 + adj);
					univ.party[target].status[eStatus::INVISIBLE] += r1;
				} else if(spell_num == eSpell::SYMBIOSIS) {
					store_victim_health = univ.party[target].cur_health;
					store_caster_health = univ.party[pc_num].cur_health;
					targ_damaged = univ.party[target].max_health - univ.party[target].cur_health;
					while((targ_damaged > 0) && (univ.party[pc_num].cur_health > 0)) {
						univ.party[target].cur_health++;
						r1 = get_ran(1,1,100) + level / 2 + 3 * adj;
						if(r1 < 100)
							univ.party[pc_num].cur_health--;
						if(r1 < 50)
							move_to_zero(univ.party[pc_num].cur_health);
						targ_damaged = univ.party[target].max_health - univ.party[target].cur_health;
					}
					add_string_to_buf("  You absorb damage.");
					sout << " healed " << univ.party[target].cur_health - store_victim_health << '.';
					add_string_to_buf(sout.str());
					sout.str("");
					sout << " takes " << store_caster_health - univ.party[pc_num].cur_health << '.';
				} else if(spell_num == eSpell::REVIVE) {
					sout << " healed.";
					univ.party[target].heal(250);
					univ.party[target].status[eStatus::POISON] = 0;
					one_sound(-53); one_sound(52);
				} else if(spell_num == eSpell::DESTONE) {
					if(univ.party[target].main_status == eMainStatus::STONE) {
						univ.party[target].main_status = eMainStatus::ALIVE;
						sout << " destoned.";
						play_sound(53);
					}
					else sout << " wasn't stoned.";
				} else if(spell_num == eSpell::CURSE_REMOVE) {
					for(cItem& item : univ.party[target].items)
						if(item.cursed){
							r1 = get_ran(1,0,200) - 10 * adj;
							if(r1 < 60) {
								item.cursed = item.unsellable = false;
							}
						}
					play_sound(52);
					sout.str("  Your items glow.");
				} else {
					
					if(!univ.scenario.is_legacy) {
						if(cInvenSlot item = univ.party[pc_num].has_abil(eItemAbil::RESURRECTION_BALM)) {
							univ.party[pc_num].take_item(item.slot);
						} else {
							add_string_to_buf("  Need resurrection balm.");
							break;
						}
					}
					if(spell_num == eSpell::RAISE_DEAD) {
						if(univ.party[target].main_status == eMainStatus::DEAD)
							if(get_ran(1,1,level / 2) == 1) {
								sout << " now dust.";
								play_sound(5);
								univ.party[target].main_status = eMainStatus::DUST;
							}
							else {
								univ.party[target].main_status = eMainStatus::ALIVE;
								for(int i = 0; i < 3; i++)
									if(get_ran(1,0,2) < 2) {
										eSkill skill = eSkill(i);
										univ.party[target].skills[skill] -= (univ.party[target].skills[skill] > 1) ? 1 : 0;
									}
								univ.party[target].cur_health = 1;
								sout << " raised.";
								play_sound(52);
							}
						else if(univ.party[target].main_status != eMainStatus::ALIVE)
							sout.str("  Didn't work.");
						else sout << " was OK.";
					} else if(spell_num == eSpell::RESURRECT) {
						if(univ.party[target].main_status != eMainStatus::ALIVE) {
							univ.party[target].main_status = eMainStatus::ALIVE;
							for(int i = 0; i < 3; i++)
								if(get_ran(1,0,2) < 1) {
									eSkill skill = eSkill(i);
									univ.party[target].skills[skill] -= (univ.party[target].skills[skill] > 1) ? 1 : 0;
								}
							univ.party[target].cur_health = 1;
							sout << " raised.";
							play_sound(52);
						}
						else sout << " was OK.";
					}
				}
				add_string_to_buf(sout.str());
				put_pc_screen();
			}
			break;
			
		case eSpell::HEAL_ALL_LIGHT: case eSpell::HEAL_ALL: case eSpell::REVIVE_ALL:
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			if(spell_num != eSpell::REVIVE_ALL) {
				r1 = get_ran((spell_num == eSpell::HEAL_ALL ? 6 : 3) + adj, 1, 4);
				add_string_to_buf("  Party healed " + std::to_string(r1) + ".");
				univ.party.heal(r1);
				play_sound(52);
			} else {
				r1 = get_ran(7 + adj, 1, 4);
				add_string_to_buf("  Party revived.");
				r1 = r1 * 2;
				univ.party.heal(r1);
				play_sound(-53);
				play_sound(-52);
				univ.party.cure(3 + adj);
			}
			break;
			
		case eSpell::POISON_CURE_ALL:
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			add_string_to_buf("  Party cured.");
			univ.party.cure(3 + adj);
			break;
			
		case eSpell::SANCTUARY_MASS: case eSpell::CLEANSE_MAJOR: case eSpell::HYPERACTIVITY:
			if(!freebie)
				univ.party[pc_num].cur_sp -= (*spell_num).cost;
			switch(spell_num) {
				case eSpell::SANCTUARY_MASS: add_string_to_buf("  Party hidden.");break;
				case eSpell::CLEANSE_MAJOR: add_string_to_buf("  Party cleansed.");break;
				case eSpell::HYPERACTIVITY: add_string_to_buf("  Party is now really, REALLY awake.");break;
				default:
					add_string_to_buf("  Error: Priest group spell " + (*spell_num).name() + " not implemented for town mode.", 4);
					break;
			}
			
			for(int i = 0; i < 6; i++)
				if(univ.party[i].main_status == eMainStatus::ALIVE) {
					if(spell_num == eSpell::SANCTUARY_MASS) {
						store = get_ran(0,1,3) + level / 6 + adj;
						r1 = max(0,store);
						univ.party[i].status[eStatus::INVISIBLE] += r1;
					}
					if(spell_num == eSpell::CLEANSE_MAJOR) {
						univ.party[i].status[eStatus::WEBS] = 0;
						univ.party[i].status[eStatus::DISEASE] = 0;
					}
					if(spell_num == eSpell::HYPERACTIVITY) {
						univ.party[i].status[eStatus::ASLEEP] -= 6 + 2 * adj;
						univ.party[i].status[eStatus::HASTE_SLOW] = max(0,univ.party[i].status[eStatus::HASTE_SLOW]);
					}
				}
			break;
			
		case eSpell::AVATAR:
			univ.party[pc_num].avatar();
			break;
			
		default:
			add_string_to_buf("  Error: Priest spell " + (*spell_num).name() + " not implemented for town mode.", 4);
			break;
	}
}

extern short spell_caster;
void cast_town_spell(location where) {
	short r1,store;
	bool need_redraw = false;
	location loc;
	ter_num_t ter;
	
	if((where.x <= univ.town->in_town_rect.left) ||
		(where.x >= univ.town->in_town_rect.right) ||
		(where.y <= univ.town->in_town_rect.top) ||
		(where.y >= univ.town->in_town_rect.bottom)) {
		add_string_to_buf("  Can't target outside town.");
		if(town_spell == eSpell::NONE)
			run_special(eSpecCtx::TARGET, spec_target_type, spec_target_fail, where);
		return;
	}
	
	short adjust = can_see_light(univ.party.town_loc,where,sight_obscurity);
	if(!spell_freebie)
		univ.party[who_cast].cur_sp -= (*town_spell).cost;
	ter = univ.town->terrain(where.x,where.y);
	short adj = spell_freebie ? 1 : univ.party[who_cast].stat_adj(eSkill::INTELLIGENCE);
	short level = spell_freebie ? store_item_spell_level : univ.party[who_cast].level;
	if(!spell_freebie && (*town_spell).level <= univ.party[who_cast].get_prot_level(eItemAbil::MAGERY) && !(*town_spell).is_priest())
		level++;
	if(!spell_freebie && univ.party[who_cast].traits[eTrait::ANAMA] && (*town_spell).is_priest())
		level++;
	
	// TODO: Should we do this here? Or in the handling of targeting modes?
	// (It really depends whether we want to be able to trigger it for targeting something other than a spell.)
	if(adjust <= 4 && !cast_spell_on_space(where, town_spell)) {
		// The special node intercepted and cancelled regular spell behaviour.
		queue_special(eSpecCtx::TARGET, spec_target_type, spec_target_fail, where);
		return;
	}
	if(spec_target_options / 10 == 1 && univ.town.is_antimagic(where.x,where.y)) {
		add_string_to_buf("  Target in antimagic field.");
		queue_special(eSpecCtx::TARGET, spec_target_type, spec_target_fail, where);
		return;
	}
	
	bool failed = town_spell == eSpell::NONE && adjust > 4;
	
	if(adjust > 4)
		add_string_to_buf("  Can't see target.");
	else switch(town_spell) {
		case eSpell::NONE: // Not a spell but a special node targeting
			run_special(eSpecCtx::TARGET, spec_target_type, spell_caster, where, nullptr, nullptr, &need_redraw);
			if(need_redraw) redraw_screen(REFRESH_ALL);
			break;
		case eSpell::SCRY_MONSTER: case eSpell::CAPTURE_SOUL:
			if(iLiving* targ = univ.target_there(where, TARG_MONST)) {
				cCreature* monst = dynamic_cast<cCreature*>(targ);
				if(town_spell == eSpell::SCRY_MONSTER) {
					univ.party.m_noted.insert(monst->number);
					adjust_monst_menu();
					display_monst(0,monst,0);
				}
				else record_monst(monst);
			}
			else add_string_to_buf("  No monster there.");
			break;
			
		case eSpell::DISPEL_FIELD: case eSpell::DISPEL_SPHERE: case eSpell::DISPEL_SQUARE:
			add_string_to_buf("  You attempt to dispel.");
			place_spell_pattern(current_pat,where,FIELD_DISPEL,7);
			break;
		case eSpell::MOVE_MOUNTAINS:
		case eSpell::MOVE_MOUNTAINS_MASS:
			add_string_to_buf("  You blast the area.");
			place_spell_pattern(current_pat, where, FIELD_SMASH, 7);
			update_explored(univ.party.town_loc);
			break;
		case eSpell::BARRIER_FIRE:
			if(sight_obscurity(where.x,where.y) == 5 || univ.target_there(where, TARG_MONST)) {
				add_string_to_buf("  Target space obstructed.");
				break;
			}
			univ.town.set_fire_barr(where.x,where.y,true);
			if(univ.town.is_fire_barr(where.x,where.y))
				add_string_to_buf("  You create the barrier.");
			else add_string_to_buf("  Failed.");
			break;
		case eSpell::BARRIER_FORCE:
			if(sight_obscurity(where.x,where.y) == 5 || univ.target_there(where, TARG_MONST)) {
				add_string_to_buf("  Target space obstructed.");
				break;
			}
			univ.town.set_force_barr(where.x,where.y,true);
			if(univ.town.is_force_barr(where.x,where.y))
				add_string_to_buf("  You create the barrier.");
			else add_string_to_buf("  Failed.");
			break;
		case eSpell::QUICKFIRE:
			univ.town.set_quickfire(where.x,where.y,true);
			if(univ.town.is_quickfire(where.x,where.y))
				add_string_to_buf("  You create quickfire.");
			else add_string_to_buf("  Failed.");
			break;
			
		case eSpell::ANTIMAGIC:
			add_string_to_buf("  You create an antimagic cloud.");
			for(loc.x = 0; loc.x < univ.town->max_dim; loc.x++)
				for(loc.y = 0; loc.y < univ.town->max_dim; loc.y++)
					if(dist(where,loc) <= 2 && can_see(where,loc,sight_obscurity) < 5 &&
					   ((abs(loc.x - where.x) < 2) || (abs(loc.y - where.y) < 2)))
						univ.town.set_antimagic(loc.x,loc.y,true);
			break;
			
		case eSpell::RITUAL_SANCTIFY:
			// Nothing to do here anymore; the code that used to be here is now just above the switch statement.
			break;
			
		case eSpell::UNLOCK:
			// TODO: Is the unlock spell supposed to have a max range?
			if(univ.scenario.ter_types[ter].special == eTerSpec::UNLOCKABLE){
				if(univ.scenario.ter_types[ter].flag2 == 10)
					r1 = 10000;
				else{
					r1 = get_ran(1,1,100) - 5 * adj + 5 * univ.town.difficulty;
					r1 += univ.scenario.ter_types[ter].flag2 * 7;
				}
				if(r1 < (135 - combat_percent[min(19,level)])) {
					add_string_to_buf("  Door unlocked.");
					play_sound(9);
					univ.town->terrain(where.x,where.y) = univ.scenario.ter_types[ter].flag1;
				}
				else {
					play_sound(41);
					add_string_to_buf("  Didn't work.");
				}
			}else
				add_string_to_buf("  Wrong terrain type.");
			break;
			
		case eSpell::DISPEL_BARRIER:
			if((univ.town.is_fire_barr(where.x,where.y)) || (univ.town.is_force_barr(where.x,where.y))) {
				r1 = get_ran(1,1,100) - 5 * adj + 5 * (univ.town.difficulty / 10) + 25 * univ.town->strong_barriers;
				if(univ.town.is_fire_barr(where.x,where.y))
					r1 -= 8;
				if(r1 < (120 - combat_percent[min(19,level)])) {
					add_string_to_buf("  Barrier broken.");
					univ.town.set_fire_barr(where.x,where.y,false);
					univ.town.set_force_barr(where.x,where.y,false);
					
					// Now, show party new things
					update_explored(univ.party.town_loc);
				}
				else {
					store = get_ran(1,0,1);
					play_sound(41);
					add_string_to_buf("  Didn't work.");
				}
			} else if(univ.town.is_force_cage(where.x,where.y)) {
				add_string_to_buf("  Cage broken.");
				break_force_cage(where);
			}
			
			else add_string_to_buf("  No barrier there.");
			
			break;
		default:
			add_string_to_buf("  Error: Spell " + (*town_spell).name() + " not implemented for town mode.", 4);
			break;
			
	}
	if(failed)
		queue_special(eSpecCtx::TARGET, spec_target_type, spec_target_fail, where);
}

// TODO: Currently, the node is called before any spell-specific behaviour (eg missiles) occurs.
bool cast_spell_on_space(location where, eSpell spell) {
	short s1 = 0;
	
	for(size_t i = 0; i < univ.town->special_locs.size(); i++)
		if(where == univ.town->special_locs[i]) {
			bool need_redraw = false;
			// TODO: Is there a way to skip this condition without breaking compatibility?
			if(univ.town->specials[univ.town->special_locs[i].spec].type == eSpecType::IF_CONTEXT)
				run_special(eSpecCtx::TARGET, eSpecCtxType::TOWN, univ.town->special_locs[i].spec, where, &s1, nullptr, &need_redraw);
			if(need_redraw) redraw_terrain();
			return !s1;
		}
	if(spell == eSpell::RITUAL_SANCTIFY)
		add_string_to_buf("  Nothing happens.");
	return true;
}

void crumble_wall(location where) {
	ter_num_t ter;
	
	if(loc_off_act_area(where))
		return;
	ter = univ.town->terrain(where.x,where.y);
	if(univ.scenario.ter_types[ter].special == eTerSpec::CRUMBLING && univ.scenario.ter_types[ter].flag2 < 2) {
		// TODO: This seems like the wrong sound
		play_sound(60);
		univ.town->terrain(where.x,where.y) = univ.scenario.ter_types[ter].flag1;
		add_string_to_buf("  Barrier crumbles.");
	}
	
}

void do_mindduel(short pc_num,cCreature *monst) {
	short i = 0,adjust,r1,r2,balance = 0;
	
	adjust = (univ.party[pc_num].level + univ.party[pc_num].skill(eSkill::INTELLIGENCE)) / 2 - monst->level * 2;
	adjust += univ.party[pc_num].get_prot_level(eItemAbil::WILL) * 5;
	if(monst->is_friendly()) {
		make_town_hostile();
		monst->attitude = eAttitude::HOSTILE_A;
	}
	
	std::ostringstream sout;
	add_string_to_buf("Mindduel!");
	while(univ.party[pc_num].main_status == eMainStatus::ALIVE && monst->active > 0 && i < 10) {
		play_sound(1);
		r1 = get_ran(1,1,100) + adjust;
		r1 += 5 * (monst->status[eStatus::DUMB] - univ.party[pc_num].status[eStatus::DUMB]);
		r1 += 5 * balance;
		r2 = get_ran(1,1,6);
		if(r1 < 30) {
			sout << "  " << univ.party[pc_num].name << " is drained " << r2 << '.';
			add_string_to_buf(sout.str());
			monst->mp += r2;
			balance++;
			if(univ.party[pc_num].cur_sp == 0) {
				univ.party[pc_num].status[eStatus::DUMB] += 2;
				sout.str("");
				sout << "  " << univ.party[pc_num].name << " is dumbfounded.";
				add_string_to_buf(sout.str());
				if(univ.party[pc_num].status[eStatus::DUMB] > 7) {
					sout.str("");
					sout << "  " << univ.party[pc_num].name << " is killed!";
					add_string_to_buf(sout.str());
					kill_pc(univ.party[pc_num],eMainStatus::DEAD);
				}
				
			}
			else {
				univ.party[pc_num].cur_sp = max(0,univ.party[pc_num].cur_sp - r2);
			}
		}
		if(r1 > 70) {
			sout << "  " << univ.party[pc_num].name << " drains " << r2 << '.';
			add_string_to_buf(sout.str());
			univ.party[pc_num].cur_sp += r2;
			balance--;
			if(monst->mp == 0) {
				monst->status[eStatus::DUMB] += 2;
				monst->spell_note(22);
				if(monst->status[eStatus::DUMB] > 7) {
					kill_monst(*monst,pc_num);
				}
				
			}
			else {
				monst->mp = max(0,monst->mp - r2);
			}
			
			
		}
		print_buf();
		i++;
	}
}

// mode 0 - dispel spell, 1 - always take  2 - always take and take fire and force too
void dispel_fields(short i,short j,short mode) {
	short r1;
	
	if(mode == 2) {
		univ.town.set_fire_barr(i,j,false);
		univ.town.set_force_barr(i,j,false);
		univ.town.set_barrel(i,j,false);
		univ.town.set_crate(i,j,false);
		univ.town.set_web(i,j,false);
	}
	if(mode >= 1)
		mode = -10;
	univ.town.set_fire_wall(i,j,false);
	univ.town.set_force_wall(i,j,false);
	univ.town.set_scloud(i,j,false);
	r1 = get_ran(1,1,6) + mode;
	if(r1 <= 1)
		univ.town.set_web(i,j,false);
	r1 = get_ran(1,1,6) + mode;
	if(r1 < 6)
		univ.town.set_ice_wall(i,j,false);
	r1 = get_ran(1,1,6) + mode;
	if(r1 < 5)
		univ.town.set_sleep_cloud(i,j,false);
	r1 = get_ran(1,1,8) + mode;
	if(r1 <= 1)
		univ.town.set_quickfire(i,j,false);
	r1 = get_ran(1,1,7) + mode;
	if(r1 < 5)
		univ.town.set_blade_wall(i,j,false);
	r1 = get_ran(1,1,12) + mode;
	if(r1 < 3)
		break_force_cage(loc(i,j));
}

bool pc_can_cast_spell(const cPlayer& pc,eSkill type) {
	if(type == eSkill::MAGE_SPELLS && pc_can_cast_spell(pc, eSpell::LIGHT))
		return true;
	if(type == eSkill::PRIEST_SPELLS && pc_can_cast_spell(pc, eSpell::HEAL_MINOR))
		return true;
	
	// If they can't cast the most basic level 1 spell, let's just make sure they can't cast any spells.
	// Find a spell they definitely know, and see if they can cast that.
	if(type == eSkill::MAGE_SPELLS && pc.mage_spells.any()) {
		for(int i = 0; i < 62; i++)
			if(pc.mage_spells[i])
				return pc_can_cast_spell(pc, eSpell(i));
	}
	if(type == eSkill::PRIEST_SPELLS && pc.priest_spells.any()) {
		for(int i = 0; i < 62; i++)
			if(pc.priest_spells[i])
				return pc_can_cast_spell(pc, eSpell(i + 100));
	}
	// If we get this far, either they don't know any spells (very unlikely) or they can't cast any of the spells they know.
	return false;
}

bool pc_can_cast_spell(const cPlayer& pc,eSpell spell_num) {
	short level,store_w_cast;
	eSkill type = (*spell_num).type;
	
	level = (*spell_num).level;
	int effective_skill = pc.skill(type);
	if(pc.status[eStatus::DUMB] < 0)
		effective_skill -= pc.status[eStatus::DUMB];
	
	if(overall_mode >= MODE_TALKING)
		return false; // From Windows version. It does kinda make sense, though this function shouldn't even be called in these modes.
	if(!isMage(spell_num) && !isPriest(spell_num))
		return false;
	if(effective_skill < level)
		return false;
	if(pc.main_status != eMainStatus::ALIVE)
		return false;
	if(pc.cur_sp < (*spell_num).cost)
		return false;
	// TODO: Maybe get rid of the casts here?
	if(type == eSkill::MAGE_SPELLS && !pc.mage_spells[int(spell_num)])
		return false;
	if(type == eSkill::PRIEST_SPELLS && !pc.priest_spells[int(spell_num) - 100])
		return false;
	if(pc.status[eStatus::DUMB] >= 8 - level)
		return false;
	if(pc.status[eStatus::PARALYZED] != 0)
		return false;
	if(pc.status[eStatus::ASLEEP] > 0)
		return false;
	
	store_w_cast = (*spell_num).when_cast;
	if(is_out() && WHEN_OUTDOORS &~ store_w_cast)
		return false;
	if(is_town() && WHEN_TOWN &~ store_w_cast)
		return false;
	if(is_combat() &&  WHEN_COMBAT &~ store_w_cast)
		return false;
	return true;
}

// MARK: Begin spellcasting dialog

static void draw_caster_buttons(cDialog& me, const eSkill store_situation) {
	for(short i = 0; i < 6; i++) {
		std::string id = "caster" + std::to_string(i + 1);
		if(!can_choose_caster) {
			if(i == pc_casting) {
				me[id].show();
			}
			else {
				me[id].hide();
			}
		}
		else {
			if(pc_can_cast_spell(univ.party[i],store_situation)) {
				me[id].show();
			}
			else {
				me[id].hide();
			}
		}
	}
}

static void draw_spell_info(cDialog& me, const eSkill store_situation, const short store_spell) {
	
	
	if(store_spell == 70) { // No spell selected
		for(int i = 0; i < 6; i++) {
			std::string id = "target" + std::to_string(i + 1);
			me[id].hide();
		}
		
	}
	else { // Spell selected
		
		for(int i = 0; i < 6; i++) {
			std::string id = "target" + std::to_string(i + 1);
			switch((*cSpell::fromNum(store_situation,store_spell)).need_select) {
				case SELECT_NO:
					me[id].hide();
					break;
				case SELECT_ACTIVE:
					if(univ.party[i].main_status != eMainStatus::ALIVE) {
						me[id].hide();
					}
					else {
						me[id].show();
					}
					break;
				case SELECT_ANY:
					// TODO: Split off party members should probably be excluded too?
					if(univ.party[i].main_status != eMainStatus::ABSENT) {
						me[id].show();
					}
					else {
						me[id].hide();
					}
					break;
					
			}
		}
	}
}

static void put_target_status_graphics(cDialog& me, short for_pc) {
	bool isAlive = univ.party[for_pc].main_status == eMainStatus::ALIVE;
	univ.party[for_pc].status[eStatus::HASTE_SLOW]; // This just makes sure it exists in the map, without changing its value if it does
	std::string id = "pc" + std::to_string(for_pc + 1);
	int slot = 0;
	for(auto next : univ.party[for_pc].status) {
		std::string id2 = id + "-stat" + std::to_string(slot + 1);
		cPict& pic = dynamic_cast<cPict&>(me[id2]);
		pic.setFormat(TXT_FRAME, FRM_NONE);
		if(isAlive) {
			short placedIcon = -1;
			if(next.first == eStatus::POISON && next.second > 4) placedIcon = 1;
			else if(next.second > 0) placedIcon = statIcons[next.first].first;
			else if(next.second < 0) placedIcon = statIcons[next.first].second;
			else if(next.first == eStatus::HASTE_SLOW) placedIcon = 7;
			if(placedIcon >= 0) {
				pic.show();
				pic.setPict(placedIcon);
				slot++;
			} else pic.hide();
		} else pic.hide();
	}
	while(slot < 15) {
		std::string id2 = id + "-stat" + std::to_string(slot + 1);
		me[id2].hide();
		slot++;
	}
}

static void draw_spell_pc_info(cDialog& me) {
	for(short i = 0; i < 6; i++) {
		std::string n = std::to_string(i + 1);
		if(univ.party[i].main_status != eMainStatus::ABSENT) {
			me["pc" + n].setText(univ.party[i].name);
			
			if(univ.party[i].main_status == eMainStatus::ALIVE) {
				me["hp" + n].setTextToNum(univ.party[i].cur_health);
				me["sp" + n].setTextToNum(univ.party[i].cur_sp);
			}
			put_target_status_graphics(me, i);
		}
	}
}


static void put_pc_caster_buttons(cDialog& me) {
	for(short i = 0; i < 6; i++) {
		std::string n = std::to_string(i + 1);
		if(me["caster" + n].isVisible()) {
			if(i == pc_casting)
				me["pc" + n].setColour(Colours::RED);
			else me["pc" + n].setColour(me.getDefTextClr());
		}
	}
}

static void put_pc_target_buttons(cDialog& me, short& store_last_target_darkened) {
	
	if(store_spell_target < 6) {
		std::string n = std::to_string(store_spell_target + 1);
		me["hp" + n].setColour(Colours::RED);
		me["sp" + n].setColour(Colours::RED);
	}
	if((store_last_target_darkened < 6) && (store_last_target_darkened != store_spell_target)) {
		std::string n = std::to_string(store_last_target_darkened + 1);
		me["hp" + n].setColour(me.getDefTextClr());
		me["sp" + n].setColour(me.getDefTextClr());
	}
	store_last_target_darkened = store_spell_target;
}

// TODO: This stuff may be better handled by using an LED group with a custom focus handler
static void put_spell_led_buttons(cDialog& me, const eSkill store_situation,const short store_spell) {
	short spell_for_this_button;
	
	for(short i = 0; i < 38; i++) {
		spell_for_this_button = (on_which_spell_page == 0) ? i : spell_index[i];
		std::string id = "spell" + std::to_string(i + 1);
		cLed& led = dynamic_cast<cLed&>(me[id]);
		
		if(spell_for_this_button < 90) {
			eSpell spell = cSpell::fromNum(store_situation, spell_for_this_button);
			if(store_spell == spell_for_this_button) {
				led.setState(led_green);
			}
			else if(pc_can_cast_spell(univ.party[pc_casting],spell)) {
				led.setState(led_red);
			}
			else {
				led.setState(led_off);
			}
		}
	}
}

static void put_spell_list(cDialog& me, const eSkill store_situation) {
	if(on_which_spell_page == 0) {
		me["col1"].setText("Level 1:");
		me["col2"].setText("Level 2:");
		me["col3"].setText("Level 3:");
		me["col4"].setText("Level 4:");
		for(short i = 0; i < 38; i++) {
			std::ostringstream name;
			std::string id = "spell" + std::to_string(i + 1);
			name << get_str("magic-names", i + (store_situation == eSkill::MAGE_SPELLS ? 1 : 101));
			name << " (";
			if((*cSpell::fromNum(store_situation,i)).cost < 0) { // Simulacrum, which has a variable cost
				name << '?';
			} else name << (*cSpell::fromNum(store_situation,i)).cost;
			name << ")";
			me[id].setText(name.str());
			if(spell_index[i] == 90)
				me[id].show();
		}
	}
	else {
		me["col1"].setText("Level 5:");
		me["col2"].setText("Level 6:");
		me["col3"].setText("Level 7:");
		me["col4"].setText("");
		for(short i = 0; i < 38; i++) {
			std::ostringstream name;
			std::string id = "spell" + std::to_string(i + 1);
			if(spell_index[i] < 90) {
				name << get_str("magic-names", spell_index[i] + (store_situation == eSkill::MAGE_SPELLS ? 1 : 101));
				name << " (";
				if((*cSpell::fromNum(store_situation,spell_index[i])).cost < 0) {
					name << '?';
				} else name << (*cSpell::fromNum(store_situation,spell_index[i])).cost;
				name << ")";
				me[id].setText(name.str());
			}
			else me[id].hide();
		}
	}
}

static bool pick_spell_caster(cDialog& me, std::string id, const eSkill store_situation, short& last_darkened, short& store_spell) {
	short item_hit = id[id.length() - 1] - '1';
	// TODO: This visibility check is probably not needed; wouldn't the dialog framework only trigger on visible elements?
	if(me[id].isVisible()) {
		pc_casting = item_hit;
		if(!pc_can_cast_spell(univ.party[pc_casting],cSpell::fromNum(store_situation,store_spell))) {
			if(store_situation == eSkill::MAGE_SPELLS)
				store_spell = 70;
			else store_spell = 70;
			store_spell_target = 6;
		}
		draw_spell_info(me, store_situation,store_spell);
		draw_spell_pc_info(me);
		put_spell_led_buttons(me, store_situation,store_spell);
		put_pc_caster_buttons(me);
		put_pc_target_buttons(me, last_darkened);
	}
	return true;
}

static bool pick_spell_target(cDialog& me, std::string id, const eSkill store_situation, short& last_darkened, const short store_spell) {
	static const char*const no_target = " No target needed.";
	static const char*const bad_target = " Can't cast on him/her.";
	static const char*const got_target = " Target selected.";
	short item_hit = id[id.length() - 1] - '1';
	std::string casting = id;
	casting[casting.length() - 1] = pc_casting + '1';
	if(!me[casting].isVisible()) {
		me["feedback"].setText(no_target);
	} else if(!me[id].isVisible()) {
		me["feedback"].setText(bad_target);
	} else {
		me["feedback"].setText(got_target);
		store_spell_target = item_hit;
		draw_spell_info(me, store_situation, store_spell);
		put_pc_target_buttons(me, last_darkened);
	}
	return true;
}

static bool pick_spell_event_filter(cDialog& me, std::string item_hit, const eSkill store_situation, const short store_spell) {
	if(item_hit == "other") {
		on_which_spell_page = 1 - on_which_spell_page;
		put_spell_list(me, store_situation);
		put_spell_led_buttons(me, store_situation, store_spell);
	} else if(item_hit == "help") {
		give_help(207,8,me);
	}
	return true;
}

static bool pick_spell_select_led(cDialog& me, std::string id, eKeyMod mods, const eSkill store_situation, short& last_darkened, short& store_spell) {
	static const char*const choose_target = " Now pick a target.";
	static const char*const bad_spell = " Spell not available.";
	short item_hit = boost::lexical_cast<short>(id.substr(5)) - 1;
	if(mod_contains(mods, mod_alt)) {
		int i = (on_which_spell_page == 0) ? item_hit : spell_index[item_hit];
		display_spells(store_situation,i,&me);
	}
	else if(dynamic_cast<cLed&>(me[id]).getState() == led_off) {
		me["feedback"].setText(bad_spell);
	}
	else {
		if(store_situation == eSkill::MAGE_SPELLS)
			store_spell = (on_which_spell_page == 0) ? item_hit : spell_index[item_hit];
		else store_spell = (on_which_spell_page == 0) ? item_hit : spell_index[item_hit];
		draw_spell_info(me, store_situation, store_spell);
		put_spell_led_buttons(me, store_situation, store_spell);
		
		if(store_spell_target < 6) {
			std::string targ = "target" + std::to_string(store_spell_target + 1);
			if(!me[targ].isVisible()) {
				store_spell_target = 6;
				draw_spell_info(me, store_situation, store_spell);
				put_pc_target_buttons(me, last_darkened);
			}
		}
		// Cute trick now... if a target is needed, caster can always be picked
		std::string targ = "target" + std::to_string(pc_casting + 1);
		if((store_spell_target == 6) && me[targ].isVisible()) {
			me["feedback"].setText(choose_target);
			draw_spell_info(me, store_situation, store_spell);
			play_sound(45); // formerly force_play_sound
		}
		else if(!me[targ].isVisible()) {
			store_spell_target = 6;
			put_pc_target_buttons(me, last_darkened);
		}
		
	}
	return true;
}

static bool finish_pick_spell(cDialog& me, bool spell_toast, const short store_store_target, const short& store_spell, const eSkill store_situation) {
	if(spell_toast) {
		store_spell_target = store_store_target ;
		if(store_situation == eSkill::MAGE_SPELLS)
			store_last_cast_mage = pc_casting;
		else store_last_cast_priest = pc_casting;
		me.toast(false);
		me.setResult<short>(70);
		return true;
	}
	
	eSpell picked_spell = cSpell::fromNum(store_situation,store_spell);
	if(store_spell == 70) {
		add_string_to_buf("Cast: No spell selected.");
		store_spell_target = store_store_target ;
		me.toast(false);
		me.setResult<short>(70);
		return true;
	}
	if(store_situation == eSkill::MAGE_SPELLS && (*picked_spell).need_select == SELECT_NO) {
		store_last_cast_mage = pc_casting;
		univ.party[pc_casting].last_cast[store_situation] = picked_spell;
		me.toast(false);
		me.setResult<short>(store_spell);
		return true;
	}
	if(store_situation == eSkill::PRIEST_SPELLS && (*picked_spell).need_select == SELECT_NO) {
		store_last_cast_priest = pc_casting;
		univ.party[pc_casting].last_cast[store_situation] = picked_spell;
		me.toast(false);
		me.setResult<short>(store_spell);
		return true;
	}
	if(store_spell_target == 6) {
		add_string_to_buf("Cast: Need to select target.");
		store_spell_target = store_store_target ;
		me.toast(false);
		give_help(39,0,me);
		me.setResult<short>(70);
		return true;
	}
	me.setResult<short>((store_situation == eSkill::MAGE_SPELLS) ? store_spell : store_spell);
	if(store_situation == eSkill::MAGE_SPELLS)
		store_last_cast_mage = pc_casting;
	else store_last_cast_priest = pc_casting;
	univ.party[pc_casting].last_cast[store_situation] = picked_spell;
	me.toast(true);
	return true;
}

//short pc_num; // if 6, anyone
//short type; // 0 - mage   1 - priest
//short situation; // 0 - out  1 - town  2 - combat
eSpell pick_spell(short pc_num,eSkill type) { // 70 - no spell OW spell num
	using namespace std::placeholders;
	eSpell store_spell = type == eSkill::MAGE_SPELLS ? store_mage : store_priest;
	short former_target = store_spell_target;
	short dark = 6;
	
	pc_casting = type == eSkill::MAGE_SPELLS ? store_last_cast_mage : store_last_cast_priest;
	if(pc_casting == 6)
		pc_casting = univ.cur_pc;
	
	if(type == eSkill::MAGE_SPELLS && univ.party[pc_casting].traits[eTrait::ANAMA]) {
		add_string_to_buf("Cast: You're an Anama!");
		return eSpell::NONE;
	}
	
	if(pc_num == 6) { // See if can keep same caster
		can_choose_caster = true;
		if(!pc_can_cast_spell(univ.party[pc_casting],type)) {
			using namespace std::placeholders;
			auto iter = std::find_if(univ.party.begin(), univ.party.end(), [type](const cPlayer& who) {
				return pc_can_cast_spell(who, type);
			});
			if(iter == univ.party.end()) {
				add_string_to_buf("Cast: Nobody can.");
				return eSpell::NONE;
			}
			pc_casting = iter - univ.party.begin();
		}
	}
	else {
		can_choose_caster = false;
		pc_casting = pc_num;
	}
	
	if(!can_choose_caster) {
		if(univ.party[pc_num].skill(type) == 0) {
			if(type == eSkill::MAGE_SPELLS) add_string_to_buf("Cast: No mage skill.");
			else add_string_to_buf("Cast: No priest skill.");
			return eSpell::NONE;
		}
		if(univ.party[pc_casting].cur_sp == 0) {
			add_string_to_buf("Cast: No spell points.");
			return eSpell::NONE;
		}
		
	}
	
	// If in combat, make the spell being cast this PCs most recent spell
	if(is_combat()) {
		if(type == eSkill::MAGE_SPELLS)
			store_spell = univ.party[pc_casting].last_cast[eSkill::MAGE_SPELLS];
		else store_spell = univ.party[pc_casting].last_cast[eSkill::PRIEST_SPELLS];
	}
	
	// Keep the stored spell, if it's still castable
	if(!pc_can_cast_spell(univ.party[pc_casting],store_spell)) {
		if(type == eSkill::MAGE_SPELLS) {
			store_spell = eSpell::LIGHT;
		}
		else {
			store_spell = eSpell::HEAL_MINOR;
		}
	}
	
	// If a target is needed, keep the same target if that PC still targetable
	if(store_spell_target < 6) {
		if((*store_spell).need_select != SELECT_NO) {
			if(univ.party[store_spell_target].main_status != eMainStatus::ALIVE)
				store_spell_target = 6;
		} else store_spell_target = 6;
	}
	
	short former_spell = int(store_spell) % 100;
	// Set the spell page, based on starting spell
	if(former_spell >= 38) on_which_spell_page = 1;
	else on_which_spell_page = 0;
	
	set_cursor(sword_curs);
	
	cDialog castSpell("cast-spell");
	
	castSpell.attachClickHandlers(std::bind(pick_spell_caster, _1, _2, type, std::ref(dark), std::ref(former_spell)), {"caster1","caster2","caster3","caster4","caster5","caster6"});
	castSpell.attachClickHandlers(std::bind(pick_spell_target,_1,_2, type, std::ref(dark), former_spell), {"target1","target2","target3","target4","target5","target6"});
	castSpell.attachClickHandlers(std::bind(pick_spell_event_filter, _1, _2, type, former_spell), {"other", "help"});
	castSpell["cast"].attachClickHandler(std::bind(finish_pick_spell, _1, false, former_target, std::ref(former_spell), type));
	castSpell["cancel"].attachClickHandler(std::bind(finish_pick_spell, _1, true, former_target, std::ref(former_spell), type));
	
	dynamic_cast<cPict&>(castSpell["pic"]).setPict(14 + (type == eSkill::PRIEST_SPELLS),PIC_DLOG);
	for(int i = 0; i < 38; i++) {
		std::string id = "spell" + std::to_string(i + 1);
		cKey key;
		if(i > 25)
			key = {false, static_cast<unsigned char>('a' + i - 26), mod_shift};
		else key = {false, static_cast<unsigned char>('a' + i), mod_none};
		cLed& led = dynamic_cast<cLed&>(castSpell[id]);
		led.attachKey(key);
		castSpell.addLabelFor(id, {static_cast<char>(i > 25 ? toupper(key.c) : key.c)}, LABEL_LEFT, 8, true);
		led.setState((pc_can_cast_spell(univ.party[pc_casting],cSpell::fromNum(type,on_which_spell_page == 0 ? i : spell_index[i])))
					 ? led_red : led_green);
		led.attachClickHandler(std::bind(pick_spell_select_led, _1, _2, _3, type, std::ref(dark), std::ref(former_spell)));
	}
	
	put_spell_list(castSpell, type);
	draw_spell_info(castSpell, type, former_spell);
	put_pc_caster_buttons(castSpell);
	draw_spell_pc_info(castSpell);
	draw_caster_buttons(castSpell, type);
	put_spell_led_buttons(castSpell, type, former_spell);
	
	void (*give_help)(short,short,cDialog&) = ::give_help;
	
	castSpell.run(std::bind(give_help, 7, 8, _1));
	
	return cSpell::fromNum(type, castSpell.getResult<short>());
}


//short which; // 0 - mage  1 - priest
void print_spell_cast(eSpell spell,eSkill which) {
	short spell_num = (which == eSkill::PRIEST_SPELLS ? int(spell) - 100 : int(spell));
	std::string name = get_str("magic-names", spell_num + (which == eSkill::MAGE_SPELLS ? 1 : 101));
	add_string_to_buf("Spell: " + name);
}

void start_town_targeting(eSpell s_num,short who_c,bool freebie,eSpellPat pat) {
	add_string_to_buf("  Target spell.");
	overall_mode = MODE_TOWN_TARGET;
	town_spell = s_num;
	who_cast = who_c;
	if (univ.scenario.is_legacy) freebie=false;
	spell_freebie = freebie;
	switch(pat) {
		case PAT_SINGLE: current_pat = single; break;
		case PAT_SQ: current_pat = square; break;
		case PAT_SMSQ: current_pat = small_square; break;
		case PAT_OPENSQ: current_pat = open_square; break;
		case PAT_PLUS: current_pat = t; break;
		case PAT_RAD2: current_pat = radius2; break;
		case PAT_RAD3: current_pat = radius3; break;
		case PAT_WALL: current_pat = single; break; // Rotateable wall not supported by town targeting
	}
}

//
// do alchemy
//

extern const short alch_difficulty[20];
extern const eItemAbil alch_ingred1[20];
extern const eItemAbil alch_ingred2[20];

static void display_alchemy_graphics(cDialog& me, short &pc_num);

static bool alch_potion_event_filter(cDialog&me, short &pc_num, std::string item_hit, eKeyMod) {
	int potion_id = boost::lexical_cast<int>(item_hit.substr(6))-1;
	if(!univ.party[pc_num].has_space()) {
		me["result"].setColour(sf::Color::Red);
		me["result"].setText("Alchemy: Can't carry another item.");
		return false;
	}
	
	cInvenSlot which_item = univ.party[pc_num].has_abil(alch_ingred1[potion_id]);
	if(alch_ingred2[potion_id] != eItemAbil::NONE) {
		cInvenSlot which_item2 = univ.party[pc_num].has_abil(alch_ingred2[potion_id]);
		// Take care with the order of removal so that remove_charge does not change the index of the second item removed
		if(which_item.slot < which_item2.slot) {
			univ.party[pc_num].remove_charge(which_item2.slot);
			univ.party[pc_num].remove_charge(which_item.slot);
		} else {
			univ.party[pc_num].remove_charge(which_item.slot);
			univ.party[pc_num].remove_charge(which_item2.slot);
		}
	} else univ.party[pc_num].remove_charge(which_item.slot);
	
	play_sound(8);
	
	static const short fail_chance[20] = {
		50,40,30,20,10,
		8,6,4,2,0,
		0,0,0,0,0,
		0,0,0,0,0
	};
	int r1 = get_ran(1,1,100);
	if(r1 < fail_chance[univ.party[pc_num].skill(eSkill::ALCHEMY) - alch_difficulty[potion_id]]) {
		me["result"].setColour(sf::Color::Red);
		me["result"].setText("Alchemy: Failed.");
		r1 = get_ran(1,0,1);
		play_sound(41 );
	}
	else {
		cItem store_i((eAlchemy)potion_id);
		if(univ.party[pc_num].skill(eSkill::ALCHEMY) - alch_difficulty[potion_id] >= 5)
			store_i.charges++;
		if(univ.party[pc_num].skill(eSkill::ALCHEMY) - alch_difficulty[potion_id] >= 11)
			store_i.charges++;
		store_i.graphic_num += get_ran(1,0,2);
		if(!univ.party[pc_num].give_item(store_i,false)) {
			me["result"].setColour(sf::Color::Red);
			me["result"].setText("No room in inventory.\nPotion placed on floor.");
			place_item(store_i,univ.party.town_loc);
			redraw_terrain();
		}
		else {
			me["result"].setColour(sf::Color::White);
			me["result"].setText("Alchemy: Successful.");
		}
	}
	put_item_screen(stat_window);
	display_alchemy_graphics(me, pc_num);
	return true;
}

void display_alchemy_graphics(cDialog& me, short &pc_num) {
	using namespace std::placeholders;
	short const difficulty[20] = {1,1,1,3,3, 4,5,5,7,9, 9,10,12,12,9, 14,19,10,16,20};
	for(short i = 0; i < 20; i++) {
		std::string n = std::to_string(i + 1);
		me["label" + n].setText(get_str("magic-names", i + 200));
		if(univ.party[pc_num].skill(eSkill::ALCHEMY) < difficulty[i] || !univ.party.alchemy[i] ||
		   !univ.party[pc_num].has_abil(alch_ingred1[i]) ||
		   (alch_ingred2[i] != eItemAbil::NONE && !univ.party[pc_num].has_abil(alch_ingred2[i])))
			me["potion" + n].hide();
		else {
			me["potion" + n].attachClickHandler(std::bind(alch_potion_event_filter, _1, std::ref(pc_num), _2, _3));
			me["potion" + n].show();
		}
	}
	std::ostringstream sout;
	sout << univ.party[pc_num].name;
	sout << " (skill " << univ.party[pc_num].skill(eSkill::ALCHEMY) << ")";
	me["mixer"].setText(sout.str());
}

static bool alch_choice_event_filter(cDialog& me, short &pc_num, std::string item_hit, eKeyMod) {
	if(item_hit == "help") {
		give_help(220,21,me);
		return true;
	}
	if (item_hit == "left") {
		do {
			pc_num = (pc_num + 5) % 6;
		} while(univ.party[pc_num].main_status != eMainStatus::ALIVE);
		display_alchemy_graphics(me, pc_num);
		return true;
	} else if (item_hit == "right") {
		do {
			pc_num = (pc_num + 1) % 6;
		} while(univ.party[pc_num].main_status != eMainStatus::ALIVE);
		display_alchemy_graphics(me, pc_num);
		return true;
	}
	// cancel
	me.toast(true);
	return true;
}

void do_alchemy() {
	using namespace std::placeholders;

	if(univ.cur_pc == 6) {
		add_string_to_buf("Alchemy: No pc selected.");
		return;
	}

	set_cursor(sword_curs);
	short pc_num = univ.cur_pc;
	
	cDialog chooseAlchemy("pick-potion");
	chooseAlchemy.attachClickHandlers(std::bind(alch_choice_event_filter, _1, std::ref(pc_num), _2, _3), {"cancel", "left", "right", "help"});
	display_alchemy_graphics(chooseAlchemy, pc_num);
	
	void (*give_help)(short,short,cDialog&) = ::give_help;
	chooseAlchemy.run(std::bind(give_help, 20, 21, std::ref(chooseAlchemy)));
}

//
// pick pc, ...
//

// mode ... 0 - create  1 - created
bool pick_pc_graphic(short pc_num,short mode,cDialog* parent) {
	store_graphic_pc_num = pc_num;
	store_graphic_mode = mode;
	
	set_cursor(sword_curs);
	
	cPictChoice pcPic(0,36,PIC_PC,parent);
	// Customize it for this special case of choosing a PC graphic
	dynamic_cast<cPict&>(pcPic->getControl("mainpic")).setPict(7);
	pcPic->getControl("prompt").setText("Select a graphic for your PC:");
	pcPic->getControl("help").setText("Click button to left of graphic to select.");
	
	bool madeChoice = pcPic.show(univ.party[pc_num].which_graphic);
	if(mode == 0 && !madeChoice && univ.party[pc_num].main_status < eMainStatus::ABSENT)
		univ.party[pc_num].main_status = eMainStatus::ABSENT;
	else if(madeChoice)
		univ.party[pc_num].which_graphic = pcPic.getPicChosen();
	
	return madeChoice;
}

static bool pc_name_event_filter(cDialog& me, short store_train_pc) {
	std::string pcName = me["name"].getText();
	
	if(!isalpha(pcName[0])) {
		me["error"].setText("Must begin with a letter.");
	}
	else {
		// TODO: This was originally truncated to 18 characters; is that really necessary?
		univ.party[store_train_pc].name = pcName;
		me.toast(true);
	}
	return true;
}

bool pick_pc_name(short pc_num,cDialog* parent) {
	using namespace std::placeholders;
	set_cursor(sword_curs);
	
	cDialog pcPickName("pick-pc-name", parent);
	pcPickName["name"].setText(univ.party[pc_num].name);
	pcPickName["okay"].attachClickHandler(std::bind(pc_name_event_filter, _1, pc_num));
	
	pcPickName.run();
	
	return 1;
}

mon_num_t pick_trapped_monst() {
	short i = 0;
	std::string sp;
	cMonster get_monst;
	
	set_cursor(sword_curs);
	
	cChoiceDlog soulCrystal("soul-crystal",{"cancel","pick1","pick2","pick3","pick4"});
	
	for(mon_num_t which : univ.party.imprisoned_monst) {
		std::string n = std::to_string(i + 1);
		if(which == 0) {
			soulCrystal->getControl("pick" + n).hide();
		}
		else {
			sp = get_m_name(which);
			soulCrystal->getControl("slot" + n).setText(sp);
			get_monst = which >= 10000 ? univ.party.summons[which - 10000] : univ.scenario.scen_monsters[which];
			soulCrystal->getControl("lvl" + n).setTextToNum(get_monst.level);
		}
	}
	
	
	std::string result = soulCrystal.show();
	
	if(result == "cancel")
		return 0;
	else return univ.party.imprisoned_monst[result[4] - '1'];
}


bool flying() {
	if(univ.party.status[ePartyStatus::FLIGHT] == 0)
		return false;
	else return true;
}

void hit_party(short how_much,eDamageType damage_type,short snd_type) {
	for(short i = 0; i < 6; i++)
		if(univ.party[i].main_status == eMainStatus::ALIVE)
			damage_pc(univ.party[i],how_much,damage_type,eRace::UNKNOWN,snd_type);
	put_pc_screen();
}

void slay_party(eMainStatus mode) {
	boom_anim_active = false;
	for(short i = 0; i < 6; i++)
		if(univ.party[i].main_status == eMainStatus::ALIVE)
			univ.party[i].main_status = mode;
	put_pc_screen();
}

short damage_pc(cPlayer& which_pc,short how_much,eDamageType damage_type,eRace type_of_attacker, short sound_type,bool do_print) {
	short r1,level;
	
	if(which_pc.main_status != eMainStatus::ALIVE)
		return false;
	
	// TODO: I think there should be a way to force sound_type = 0 for UNBLOCKABLE
	if(sound_type == 0) {
		if(damage_type == eDamageType::FIRE || damage_type == eDamageType::UNBLOCKABLE)
			sound_type = 5;
		if(damage_type == eDamageType::MAGIC)
			sound_type = 12;
		if(damage_type == eDamageType::COLD)
			sound_type = 7;
		if(damage_type == eDamageType::POISON)
			sound_type = 11;
	}
	
	// armor
	if(damage_type == eDamageType::WEAPON || damage_type == eDamageType::UNDEAD || damage_type == eDamageType::DEMON) {
		how_much -= minmax(-5,5,which_pc.status[eStatus::BLESS_CURSE]);
		for(short i = 0; i < which_pc.items.size(); i++) {
			const cItem& item = which_pc.items[i];
			if(item.variety != eItemType::NO_ITEM && which_pc.equip[i]) {
				if((*item.variety).is_armour) {
					r1 = get_ran(1,1,item.item_level);
					how_much -= r1;
					
					// bonus for magical items
					if(item.bonus > 0) {
						r1 = get_ran(1,1,item.bonus);
						how_much -= r1;
						how_much -= item.bonus / 2;
					}
					if(item.bonus < 0) {
						how_much = how_much - item.bonus;
					}
					r1 = get_ran(1,1,100);
					if(r1 < hit_chance[which_pc.skill(eSkill::DEFENSE)] - 20)
						how_much -= 1;
				}
				if(item.protection > 0) {
					r1 = get_ran(1,1,item.protection);
					how_much -= r1;
				}
				if(item.protection < 0) {
					r1 = get_ran(1,1,-1 * item.protection);
					how_much += r1;
				}
			}
		}
	}
	
	// parry
	// TODO: Used to also apply this to fire damage; is that correct?
	if(damage_type == eDamageType::WEAPON && which_pc.parry < 100)
		how_much -= which_pc.parry / 4;
	
	if(damage_type != eDamageType::MARKED) {
		if(univ.party.easy_mode)
			how_much -= 3;
		// toughness
		if(which_pc.traits[eTrait::TOUGHNESS])
			how_much--;
		// luck
		if(get_ran(1,1,100) < 2 * (hit_chance[which_pc.skill(eSkill::LUCK)] - 20))
			how_much -= 1;
	}
	
	if((level = which_pc.get_prot_level(eItemAbil::DAMAGE_PROTECTION,int(damage_type))) > 0) {
		// TODO: Why does this not depend on the ability strength if it's not weapon damage?
		if(damage_type == eDamageType::WEAPON) how_much -= level;
		else how_much = how_much / 2;
	}
	
	// TODO: Do these perhaps depend on the ability strength less than they should?
	if((level = which_pc.get_prot_level(eItemAbil::PROTECT_FROM_SPECIES,int(type_of_attacker))) > 0)
		how_much = how_much / 2;
		
	if(isHumanoid(type_of_attacker) && !isHuman(type_of_attacker) && type_of_attacker != eRace::HUMANOID) {
		// If it's a slith, nephil, vahnatai, or goblin, Protection from Humanoids also helps
		// Humanoid is explicitly excluded here because otherwise it would help twice.
		if((level = which_pc.get_prot_level(eItemAbil::PROTECT_FROM_SPECIES,int(eRace::HUMANOID))) > 0)
			how_much = how_much / 2;
	}
	
	if(type_of_attacker == eRace::SKELETAL) {
		// Protection from Undead helps with both types of undead
		if((level = which_pc.get_prot_level(eItemAbil::PROTECT_FROM_SPECIES,int(eRace::UNDEAD))) > 0)
			how_much = how_much / 2;
	}
	
	// invuln
	if(damage_type != eDamageType::SPECIAL && which_pc.status[eStatus::INVULNERABLE] > 0)
		how_much = 0;
	
	// Mag. res helps w. fire and cold
	// TODO: Why doesn't this help with magic damage!?
	if(damage_type == eDamageType::FIRE || damage_type == eDamageType::COLD) {
		int magic_res = which_pc.status[eStatus::MAGIC_RESISTANCE];
		if(magic_res > 0)
			how_much /= 2;
		else if(magic_res < 0)
			how_much *= 2;
	}
	
	// major resistance
	if((damage_type == eDamageType::FIRE || damage_type == eDamageType::POISON || damage_type == eDamageType::MAGIC || damage_type == eDamageType::COLD)
	   && ((level = which_pc.get_prot_level(eItemAbil::FULL_PROTECTION)) > 0))
		how_much = how_much / ((level >= 7) ? 4 : 2);
	
	if(boom_anim_active) {
		if(how_much < 0)
			how_much = 0;
		which_pc.marked_damage += how_much;
		// It would also be nice to have a special boom type for cold.
		short boom_type = 2;
		if(damage_type == eDamageType::FIRE)
			boom_type = 0;
		else if(damage_type == eDamageType::UNBLOCKABLE)
			boom_type = 4;
		else if(damage_type == eDamageType::COLD)
			boom_type = 5;
		if(is_town())
			add_explosion(univ.party.town_loc,how_much,0,boom_type,0,0);
		else add_explosion(which_pc.combat_pos,how_much,0,boom_type,0,0);
		if(how_much == 0)
			return false;
		else return true;
	}
	
	if(how_much <= 0) {
		if(damage_type == eDamageType::WEAPON || damage_type == eDamageType::UNDEAD || damage_type == eDamageType::DEMON)
			play_sound(2);
		add_string_to_buf ("  No damage.");
		return false;
	}
	else {
		// if asleep, get bonus
		if(which_pc.status[eStatus::ASLEEP] > 0)
			which_pc.status[eStatus::ASLEEP]--;
		
		if(do_print)
			add_string_to_buf("  " + which_pc.name + " takes " + std::to_string(how_much) + '.');
		if(damage_type != eDamageType::MARKED) {
			if(is_combat())
				boom_space(which_pc.combat_pos,overall_mode,boom_gr[damage_type],how_much,sound_type);
			else if(is_town())
				boom_space(univ.party.town_loc,overall_mode,boom_gr[damage_type],how_much,sound_type);
			else boom_space(univ.party.town_loc,100,boom_gr[damage_type],how_much,sound_type);
		}
		// TODO: When outdoors it flushed only key events, not mouse events. Why?
		flushingInput = true;
	}
	
	univ.party.total_dam_taken += how_much;
	
	if(which_pc.cur_health >= how_much)
		which_pc.cur_health = which_pc.cur_health - how_much;
	else if(which_pc.cur_health > 0)
		which_pc.cur_health = 0;
	else // Check if PC can die
		if(how_much > 25) {
			add_string_to_buf("  " + which_pc.name + " is obliterated.");
			kill_pc(which_pc, eMainStatus::DUST);
		}
		else {
			add_string_to_buf("  " + which_pc.name + " is killed.");
			kill_pc(which_pc,eMainStatus::DEAD);
		}
	if(which_pc.cur_health == 0 && which_pc.main_status == eMainStatus::ALIVE)
		play_sound(3);
	put_pc_screen();
	
	return how_much;
}

void petrify_pc(cPlayer& which_pc,int strength) {
	std::ostringstream create_line;
	short r1 = get_ran(1,0,20);
	r1 += which_pc.level / 4;
	r1 += which_pc.status[eStatus::BLESS_CURSE];
	r1 -= strength;
	
	if(which_pc.has_abil_equip(eItemAbil::PROTECT_FROM_PETRIFY))
		r1 = 20;
	
	if(r1 > 14) {
		create_line << "  " << which_pc.name << "resists.";
	} else {
		create_line << "  " << which_pc.name << "is turned to stone.";
		kill_pc(which_pc,eMainStatus::STONE);
	}
	add_string_to_buf(create_line.str());
}

void kill_pc(cPlayer& which_pc,eMainStatus type) {
	bool dummy,no_save = false;
	location item_loc;
	
	if(isSplit(type)) {
		type -= eMainStatus::SPLIT;
		no_save = true;
	}
	
	cInvenSlot weap = type == eMainStatus::STONE
		? cInvenSlot(which_pc) // Life-saving doesn't protect from petrification
		: which_pc.has_abil_equip(eItemAbil::LIFE_SAVING);
	
	int luck = which_pc.skill(eSkill::LUCK);
	if(!no_save && type != eMainStatus::ABSENT && luck > 0 &&
	   get_ran(1,1,100) < hit_chance[luck]) {
		add_string_to_buf("  But you luck out!");
		which_pc.cur_health = 0;
	} else if(!weap || type == eMainStatus::ABSENT) {
		if(combat_active_pc < 6 && &which_pc == &univ.party[combat_active_pc])
			combat_active_pc = 6;
		
		for(short i = 0; i < which_pc.items.size(); i++)
			which_pc.equip[i] = false;
		
		item_loc = is_combat() ? which_pc.combat_pos : univ.party.town_loc;
		
		if(!is_out()) {
			if(type == eMainStatus::DUST)
				univ.town.set_ash(item_loc.x,item_loc.y,true);
			else if(type == eMainStatus::ABSENT);
			else switch(which_pc.race) {
				case eRace::DEMON:
					univ.town.set_ash(item_loc.x,item_loc.y,true);
					break;
				case eRace::UNDEAD:
					break;
				case eRace::SKELETAL:
					univ.town.set_bones(item_loc.x,item_loc.y,true);
					break;
				case eRace::SLIME: case eRace::PLANT: case eRace::BUG:
					univ.town.set_lg_slime(item_loc.x,item_loc.y,true);
					break;
				case eRace::STONE:
					univ.town.set_rubble(item_loc.x,item_loc.y,true);
					break;
				default:
					univ.town.set_lg_blood(item_loc.x,item_loc.y,true);
					break;
			}
		}
		
		if(overall_mode != MODE_OUTDOORS)
			for(cItem& item : which_pc.items)
				if(item.variety != eItemType::NO_ITEM) {
					dummy = place_item(item,item_loc);
					item.variety = eItemType::NO_ITEM;
				}
		if(type == eMainStatus::DEAD || type == eMainStatus::DUST)
			play_sound(21);
		which_pc.main_status = type;
		which_pc.ap = 0;
	}
	else {
		add_string_to_buf("  Life saved!");
		which_pc.take_item(weap.slot);
		which_pc.heal(200);
	}
	if(univ.current_pc().main_status != eMainStatus::ALIVE)
		univ.cur_pc = first_active_pc();
	put_pc_screen();
	set_stat_window_for_pc(univ.cur_pc);
}

void set_pc_moves() {
	for(short i = 0; i < 6; i++)
		if(univ.party[i].main_status != eMainStatus::ALIVE)
			univ.party[i].ap = 0;
		else {
			univ.party[i].ap = univ.party[i].traits[eTrait::SLUGGISH] ? 3 : 4;
			short r = univ.party[i].total_encumbrance(hit_chance);
			univ.party[i].ap = minmax(1,8,univ.party[i].ap - (r / 3));
			
			if(int speed = univ.party[i].get_prot_level(eItemAbil::SPEED))
				univ.party[i].ap += speed;
			univ.party[i].ap -= univ.party[i].get_prot_level(eItemAbil::SLOW_WEARER);
			
			if(univ.party[i].status[eStatus::HASTE_SLOW] < 0 && univ.party.age % 2 == 1) // slowed?
				univ.party[i].ap = 0;
			else { // do webs
				univ.party[i].ap = max(0,univ.party[i].ap - univ.party[i].status[eStatus::WEBS] / 2);
				if(univ.party[i].ap == 0) {
					add_string_to_buf(univ.party[i].name + " must clean webs.");
					univ.party[i].status[eStatus::WEBS] = max(0,univ.party[i].status[eStatus::WEBS] - 3);
				}
			}
			if(univ.party[i].status[eStatus::HASTE_SLOW] > 7)
				univ.party[i].ap = univ.party[i].ap * 3;
			else if(univ.party[i].status[eStatus::HASTE_SLOW] > 0)
				univ.party[i].ap = univ.party[i].ap * 2;
			if(univ.party[i].status[eStatus::ASLEEP] > 0 || univ.party[i].status[eStatus::PARALYZED] > 0)
				univ.party[i].ap = 0;
			
		}
	
}

void take_ap(short num) {
	univ.current_pc().ap = max(0,univ.current_pc().ap - num);
}

short trait_present(eTrait which_trait) {
	short ret = 0;
	for(short i = 0; i < 6; i++)
		if(univ.party[i].main_status == eMainStatus::ALIVE && univ.party[i].traits[which_trait])
			ret += 1;
	return ret;
}

short race_present(eRace which_race) {
	short ret = 0;
	for(short i = 0; i < 6; i++)
		if(univ.party[i].main_status == eMainStatus::ALIVE && univ.party[i].race == which_race)
			ret += 1;
	return ret;
}

short wilderness_lore_present(ter_num_t ter_type) {
	cTerrain& ter = univ.scenario.ter_types[ter_type];
	if(ter.special == eTerSpec::WILDERNESS_CAVE || ter.special == eTerSpec::WATERFALL_CAVE)
		return trait_present(eTrait::CAVE_LORE);
	else if(ter.special == eTerSpec::WILDERNESS_SURFACE || ter.special == eTerSpec::WATERFALL_SURFACE)
		return trait_present(eTrait::WOODSMAN);
	return false;
}

short party_size(bool only_living) {
	short num_pcs = 0;
	for(short i = 0; i < 6; i++) {
		if(!only_living) {
			if(univ.party[i].main_status != eMainStatus::ABSENT)
				num_pcs++;
		}
		else {
			if(univ.party[i].main_status == eMainStatus::ALIVE)
				num_pcs++;		
		}
	}
	
	return num_pcs;
	
}