/*
 *  Copyright (C) 2000-2001  The Exult Team
 *
 *  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; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include "Audio.h"
#include "Book_gump.h"
#include "Gump.h"
#include "Gump_manager.h"
#include "Scroll_gump.h"
#include "Sign_gump.h"
#include "items.h"
#include "barge.h"
#include "bodies.h"
#include "cheat.h"
#include "chunks.h"
#include "conversation.h"
#include "effects.h"
#include "exult.h"
#include "game.h"
#include "gamewin.h"
#include "gamemap.h"
#include "gameclk.h"
#include "keyring.h"
#include "mouse.h"
#include "rect.h"
#include "schedule.h"
#include "spellbook.h"
#include "ucinternal.h"
#include "ucsched.h"
#include "useval.h"
#include "virstone.h"
#include "monsters.h"
#include "egg.h"
#include "monstinf.h"
#include "actions.h"
#include "ucscriptop.h"
#include "ucfunction.h"
#include "palette.h"
#include "stackframe.h"
#include "party.h"

#ifndef UNDER_CE
using std::cerr;
using std::cout;
using std::endl;
using std::rand;
using std::strchr;
#endif

Barge_object *Get_barge	(Game_object *obj);
extern Usecode_value no_ret;

static Game_object *sailor = 0;		// The current barge captain.  Maybe
					//   this needs to be saved/restored.

#define PARTY_MAX (sizeof(party)/sizeof(party[0]))

#define	USECODE_INTRINSIC(NAME)	Usecode_value	Usecode_internal:: UI_## NAME (int event,int intrinsic,int num_parms,Usecode_value parms[12])

USECODE_INTRINSIC(NOP)
{
	return(no_ret);
}

USECODE_INTRINSIC(UNKNOWN)
{
//	Unhandled(intrinsic, num_parms, parms);
	return(no_ret);
}

USECODE_INTRINSIC(get_random)
{
	int range = parms[0].get_int_value();
	if (range == 0)
		{
		Usecode_value u(0);
		return(u);
		}
	Usecode_value u=(1 + (rand() % range));
	return(u);
}

USECODE_INTRINSIC(execute_usecode_array)
{
	COUT("Executing intrinsic 1");
					// Start on next tick.
	create_script(parms[0], parms[1], 1);

	Usecode_value u(1);
	return(u);
}

USECODE_INTRINSIC(delayed_execute_usecode_array)
{
	// Delay = .20 sec.?
					// +++++Special problem with inf. loop:
	if (Game::get_game_type() == BLACK_GATE &&
	    event == internal_exec && parms[1].get_array_size() == 3 &&
	    parms[1].get_elem(2).get_int_value() == 0x6f7)
		return(no_ret);
	int delay = parms[2].get_int_value();
	create_script(parms[0], parms[1], delay*gwin->get_std_delay());
	COUT("Executing intrinsic 2");

	Usecode_value u(1);
	return(u);
}

USECODE_INTRINSIC(show_npc_face)
{
	show_npc_face(parms[0], parms[1]);
	return(no_ret);
}

USECODE_INTRINSIC(remove_npc_face)
{
	remove_npc_face(parms[0]);
	return(no_ret);
}

USECODE_INTRINSIC(add_answer)
{
	conv->add_answer(parms[0]);
	//	user_choice = 0;
	return(no_ret);
}

USECODE_INTRINSIC(remove_answer)
{
	conv->remove_answer(parms[0]);
// Commented out 'user_choice = 0' 8/3/00 for Tseramed conversation.
//	user_choice = 0;
	return(no_ret);
}

USECODE_INTRINSIC(push_answers)
{
	conv->push_answers();
	return(no_ret);
}

USECODE_INTRINSIC(pop_answers)
{
	if(!conv->stack_empty())
	{
		conv->pop_answers();
		user_choice = 0;	// Added 7/24/2000.
	}
	return(no_ret);
}

USECODE_INTRINSIC(clear_answers)
{
	conv->clear_answers();
	return(no_ret);
}

USECODE_INTRINSIC(select_from_menu)
{
	user_choice = 0;
	const char *choice = get_user_choice();
	user_choice = 0;
	Usecode_value u(choice);
	return(u);
}

USECODE_INTRINSIC(select_from_menu2)
{
	// Return index (1-n) of choice.
	user_choice = 0;
	Usecode_value val(get_user_choice_num() + 1);
	user_choice = 0;
	return(val);
}

USECODE_INTRINSIC(input_numeric_value)
{
	// Ask for # (min, max, step, default).  Be sure to show conversation.
	Usecode_value ret(gumpman->prompt_for_number(
		parms[0].get_int_value(), parms[1].get_int_value(),
		parms[2].get_int_value(), parms[3].get_int_value(), conv));
	conv->clear_text_pending();	// Answered a question.
	return(ret);
}

USECODE_INTRINSIC(set_item_shape)
{
	// Set item shape.
	set_item_shape(parms[0], parms[1]);
	return(no_ret);
}

USECODE_INTRINSIC(find_nearest)
{
	// Think it rets. nearest obj. near parm0.
	Usecode_value u(find_nearest(parms[0], parms[1], parms[2]));
	return(u);
}

USECODE_INTRINSIC(die_roll)
{
	// Rand. # within range.
	int low = parms[0].get_int_value();
	int high = parms[1].get_int_value();
	if (low > high)
		{
		int tmp = low;
		low = high;
		high = tmp;
		}
	int val = (rand() % (high - low + 1)) + low;
	Usecode_value u(val);
	return(u);
}

USECODE_INTRINSIC(get_item_shape)
{
	Game_object *item = get_item(parms[0]);
					// Want the actual, not polymorph'd.
	Actor *act = as_actor(item);
	return Usecode_value(item == 0 ? 0 : 
		(act ? act->get_shape_real() : item->get_shapenum()));
}

USECODE_INTRINSIC(get_item_frame)
{
	// Returns frame without rotated bit.
	Game_object *item = get_item(parms[0]);
					// Don't count rotated frames.
	return Usecode_value(item == 0 ? 0 : item->get_framenum()&31);
}

USECODE_INTRINSIC(set_item_frame)
{	// Set frame, but don't change rotated bit.
//++++++++Seems like in BG, this should be the same as set_item_frame_rot()??
	set_item_frame(get_item(parms[0]), parms[1].get_int_value());
	return(no_ret);
}

USECODE_INTRINSIC(get_item_quality)
{
	Game_object *obj = get_item(parms[0]);
	if (!obj)
		return Usecode_value(0);
	Shape_info& info = obj->get_info();
	return Usecode_value(info.has_quality() ? obj->get_quality() : 0);
}

USECODE_INTRINSIC(set_item_quality)
{
	// Guessing it's 
	//  set_quality(item, value).
	int qual = parms[1].get_int_value();
	if (qual == c_any_qual)		// Leave alone (happens in SI)?
		return Usecode_value(1);
	Game_object *obj = get_item(parms[0]);
	if (obj)
		{
		Shape_info& info = obj->get_info();
		if (info.has_quality())
			{
			obj->set_quality((unsigned int) qual);
			return Usecode_value(1);
			}
		}
	return Usecode_value(0);
}

USECODE_INTRINSIC(get_item_quantity)
{
	// Get quantity of an item.
	//   Get_quantity(item, mystery).
	Usecode_value ret(0);
	Game_object *obj = get_item(parms[0]);
	if (obj)
		ret = Usecode_value(obj->get_quantity());
	return(ret);
}

USECODE_INTRINSIC(set_item_quantity)
{
	// Set_quantity (item, newcount).  Rets 1 iff item.has_quantity().
	Usecode_value ret(0);
	Game_object *obj = get_item(parms[0]);
	int newquant = parms[1].get_int_value();
	if (obj && obj->get_info().has_quantity())
		{
		ret = Usecode_value(1);
					// If not in world, don't delete!
		if (newquant == 0 && obj->get_cx() == 255)
			return ret;
		int oldquant = obj->get_quantity();
		int delta = newquant - oldquant;
					// Note:  This can delete the obj.
		int newdelta = obj->modify_quantity(delta);
		}
	return(ret);
}

USECODE_INTRINSIC(get_object_position)
{
	// Takes itemref.  ?Think it rets.
	//  hotspot coords: (x, y, z).
	Game_object *obj = get_item(parms[0]);
	Tile_coord c(0, 0, 0);
	if (obj)		// (Watch for animated objs' wiggles.)
		c = obj->get_outermost()->get_original_tile_coord();
	Usecode_value vx(c.tx), vy(c.ty), vz(c.tz);
	Usecode_value arr(3, &vx);
	arr.put_elem(1, vy);
	arr.put_elem(2, vz);
	return(arr);
}

USECODE_INTRINSIC(get_distance)
{
	// Distance from parm[0] -> parm[1].  Guessing how it's computed.
	Game_object *obj0 = get_item(parms[0]);
	Game_object *obj1 = get_item(parms[1]);
	Usecode_value u((obj0 && obj1) ? 
		obj0->get_outermost()->get_tile().distance(
				obj1->get_outermost()->get_tile()) : 0);
	return(u);
}

USECODE_INTRINSIC(find_direction)
{
	// Direction from parm[0] -> parm[1].
	// Rets. 0-7.  Is 0 east?
	Usecode_value u=find_direction(parms[0], parms[1]);
	return(u);
}

USECODE_INTRINSIC(get_npc_object)
{
	// Takes -npc.  Returns object, or array of objects.
	Usecode_value& v = parms[0];
	if (v.is_array())		// Do it for each element of array.
		{
		int sz = v.get_array_size();
		Usecode_value ret(sz, 0);
		for (int i = 0; i < sz; i++)
			{
			Usecode_value elem(get_item(v.get_elem(i)));
			ret.put_elem(i, elem);
			}
		return ret;
		}
	Game_object *obj = get_item(parms[0]);
	Usecode_value u(obj);
	return(u);
}

USECODE_INTRINSIC(get_schedule_type)
{
	// GetSchedule(npc).  Rets. schedtype.
	Actor *npc = as_actor(get_item(parms[0]));
	if (!npc)
		return Usecode_value(0);
	Schedule *schedule = npc->get_schedule();
	int sched = schedule ? schedule->get_actual_type(npc) 
			     : npc->get_schedule_type();
					// Path_run_usecode?  (This is to fix
					//   a bug in the Fawn Trial.)
					//+++++Should be a better way to check.
	if (Game::get_game_type() == SERPENT_ISLE &&
	    npc->get_action() && npc->get_action()->as_usecode_path())
					// Give a 'fake' schedule.
		sched = Schedule::walk_to_schedule;
	Usecode_value u(sched);
	return(u);
}

USECODE_INTRINSIC(set_schedule_type)
{
	// SetSchedule?(npc, schedtype).
	// Looks like 15=wait here, 11=go home, 0=train/fight... This is the
	// 'bNum' field in schedules.
	Actor *npc = as_actor(get_item(parms[0]));
	if (npc)
		{
		int newsched = parms[1].get_int_value();
		npc->set_schedule_type(newsched);
					// Taking Avatar out of combat?
		if (npc == gwin->get_main_actor() && gwin->in_combat() &&
		    newsched != Schedule::combat)
					// End combat mode (for L.Field).
			{
			Audio::get_ptr()->stop_music();
			gwin->toggle_combat();
			}
		}
	return(no_ret);
}

USECODE_INTRINSIC(add_to_party)
{
	// NPC joins party.
	Actor *npc = as_actor(get_item(parms[0]));
	if (!partyman->add_to_party(npc))
		return no_ret;		// Can't add.
	npc->set_schedule_type(Schedule::follow_avatar);
// cout << "NPC " << npc->get_npc_num() << " added to party." << endl;
	return no_ret;
}

USECODE_INTRINSIC(remove_from_party)
{
	// NPC leaves party.
	Game_object *npc = get_item(parms[0]);
	partyman->remove_from_party(as_actor(npc));
	return no_ret;
}

USECODE_INTRINSIC(get_npc_prop)
{
	// Get NPC prop (item, prop_id).
	//   (9 is food level).
	Actor *npc = as_actor(get_item(parms[0]));
	Usecode_value u(npc ? 
		npc->get_property(parms[1].get_int_value()) : 0);
	return(u);
}

USECODE_INTRINSIC(set_npc_prop)
{
	// Set NPC prop (item, prop_id, delta_value).
	Actor *npc = as_actor(get_item(parms[0]));
	if (npc)
		{			// NOTE: 3rd parm. is a delta!
		int prop = parms[1].get_int_value();
		npc->set_property(prop, npc->get_property(prop) +
						parms[2].get_int_value());
		return Usecode_value(1);// SI needs return.
		}
	return Usecode_value(0);
}

USECODE_INTRINSIC(get_avatar_ref)
{
	// Guessing it's Avatar's itemref.
	Usecode_value u(gwin->get_main_actor());
	return(u);
}

USECODE_INTRINSIC(get_party_list)
{
	// Return array with party members.
	Usecode_value u(get_party());
	return(u);
}

USECODE_INTRINSIC(create_new_object)
{
	// create_new_object(shapenum).   Stores it in 'last_created' (which
	//   maybe should be a stack.
	int shapenum = parms[0].get_int_value();

	Game_object *obj;		// Create to be written to Ireg.
	Shape_info& info = ShapeID::get_info(shapenum);
	modified_map = true;
					// +++Not sure if 1st test is needed.
	if (info.get_monster_info() || info.is_npc())
	{
					// (Wait sched. added for FOV.)
		// don't add equipment (Erethian's transform sequence)
		Monster_actor *monster = Monster_actor::create(shapenum,
			Tile_coord(-1, -1, -1), Schedule::wait, 
					(int) Actor::neutral, true, false);
					// FORCE it to be neutral (dec04,01).
		monster->set_alignment((int) Actor::neutral);
		gwin->add_dirty(monster);
		gwin->add_nearby_npc(monster);
		gwin->show();
		last_created.push_back(monster);
		return Usecode_value(monster);
	}
	else
	{
		if (Is_body(shapenum))
		{
			obj = new Dead_body(shapenum, 0, 0, 0, 0, -1);
		}
		else
		{
			obj = gmap->create_ireg_object(shapenum, 0);
					// Be liberal about taking stuff.
			obj->set_flag(Obj_flags::okay_to_take);
		}
	}
	obj->set_invalid();		// Not in world yet.
	obj->set_flag(Obj_flags::okay_to_take);
	last_created.push_back(obj);
	Usecode_value u(obj);
	return(u);
}

USECODE_INTRINSIC(create_new_object2)
{
	// create_new_object(shapenum, loc).
	Usecode_value ret = UI_create_new_object(event, intrinsic, 1, parms);
	if (ret == 0)
		return ret;		// Failed.
	UI_update_last_created(event, intrinsic, 1, &parms[1]);
	return ret;
}

USECODE_INTRINSIC(set_last_created)
{
	// Take itemref off map and set last_created to it.
	Game_object *obj = get_item(parms[0]);
	modified_map = true;
	if (obj)
		{
		add_dirty(obj);		// Set to repaint area.
		last_created.push_back(obj);
		obj->remove_this(1);	// Remove, but don't delete.
		}
	Usecode_value u(obj);
	return(u);
}

USECODE_INTRINSIC(update_last_created)
{
	// Think it takes array from 0x18,
	//   updates last-created object.
	//   ??guessing??
	modified_map = true;
	if (last_created.empty())
		{
		Usecode_value u((Game_object*) NULL);
		return(u);
		}
	Game_object *obj = last_created.back();
	last_created.pop_back();
	obj->set_invalid();		// It's already been removed.
	Usecode_value& arr = parms[0];
	int sz = arr.get_array_size();
	if (sz == 3 || sz == 2)
		{
		Tile_coord dest(arr.get_elem(0).get_int_value(),
			  arr.get_elem(1).get_int_value(),
			  sz == 3 ? arr.get_elem(2).get_int_value() : 0);
		obj->move(dest.tx, dest.ty, dest.tz);
		if (GAME_BG) {
			Usecode_value u(1);
			return u;
		} else {
			Usecode_value u(obj);
			return u;
		}
					// Taking a guess here:
	} else if (sz == 1)
		{
		obj->remove_this();
		}
#ifdef DEBUG
	else
		{
		cout << " { Intrinsic 0x26:  "; arr.print(cout); cout << endl << "} ";
		}
#endif
//	gwin->paint_dirty();	// Problems in conversations.
//	gwin->show();		// ??
	Usecode_value u(1);
	return(u);
}

USECODE_INTRINSIC(get_npc_name)
{
	// Get NPC name(s).  Works on arrays, too.
	static const char *unknown = "??name??";
	Actor *npc;
	int cnt = parms[0].get_array_size();
	if (cnt)
		{			// Do array.
		Usecode_value arr(cnt, 0);
		for (int i = 0; i < cnt; i++)
			{
			Game_object *obj = get_item(parms[0].get_elem(i));
			npc = as_actor(obj);
			std::string namestr = npc ? npc->get_npc_name()
						  : obj->get_name();
			Usecode_value v(namestr.c_str());
			arr.put_elem(i, v);
			}
		return(arr);
		}
	Game_object *obj = get_item(parms[0]);
	std::string namestr;
	if (obj)
		{
		npc = as_actor(obj);
		namestr = npc ? npc->get_npc_name() : obj->get_name();
		}
	else
		namestr = unknown;
	Usecode_value u(namestr.c_str());
	return(u);
}

USECODE_INTRINSIC(count_objects)
{
	// How many?
	// ((npc?-357==party, -356=avatar), 
	//   item, quality, frame (c_any_framenum = any)).
	// Quality/frame -359 means any.
	Usecode_value u(count_objects(parms[0], parms[1], parms[2], parms[3]));
	return(u);
}

USECODE_INTRINSIC(find_object)
{
	// Find_object(container(-357=party) OR loc, shapenum, qual?? (-359=any), 
	//						frame??(-359=any)).
	int shnum = parms[1].get_int_value(),
	    qual  = parms[2].get_int_value(),
	    frnum = parms[3].get_int_value();
	if (parms[0].get_array_size() == 3)
		{			// Location (x, y).
		Game_object_vector vec;
		Game_object::find_nearby(vec,
			Tile_coord(parms[0].get_elem(0).get_int_value(),
				   parms[0].get_elem(1).get_int_value(),
				   parms[0].get_elem(2).get_int_value()),
			shnum, 1, 0, qual, frnum);
		if (vec.empty())
			return Usecode_value((Game_object *) 0);
		else
			return Usecode_value(vec.front());
		}
	int oval  = parms[0].get_int_value();
	if (oval != -357)		// Not the whole party?
		{			// Find inside owner.
		Game_object *obj = get_item(parms[0]);
		if (!obj)
			return Usecode_value((Game_object*) NULL);
		Game_object *f = obj->find_item(shnum, qual, frnum);
		return Usecode_value(f);
		}
					// Look through whole party.
	Usecode_value party = get_party();
	int cnt = party.get_array_size();
	for (int i = 0; i < cnt; i++)
		{
		Game_object *obj = get_item(party.get_elem(i));
		if (obj)
			{
			Game_object *f = obj->find_item(shnum, qual, frnum);
			if (f)
				return Usecode_value(f);
			}
		}
	return Usecode_value((Game_object*) NULL);
}

USECODE_INTRINSIC(get_cont_items)
{
	// Get cont. items(container, shape, qual, frame).
	// recursively find items in container
	Usecode_value u(get_objects(parms[0], parms[1], parms[2], parms[3]));
	return(u);
}


USECODE_INTRINSIC(remove_party_items)
{
	// Remove items(quantity, item, ??quality?? (-359), frame(-359), T/F).
	return remove_party_items(parms[0], parms[1], parms[2],
						parms[3], parms[4]);
}

USECODE_INTRINSIC(add_party_items)
{
	// Add items(num, item, ??quality?? (-359), frame (or -359), T/F).
	// Returns array of NPC's (->'s) who got the items.
	Usecode_value u(add_party_items(parms[0], parms[1], parms[2],
						parms[3], parms[4]));
	return(u);
}

USECODE_INTRINSIC(play_music)
{
	// Play music(songnum, item).
	// ??Show notes by item?
#ifdef DEBUG
	cout << "Music request in usecode" << endl;
	cout << "Parameter data follows" << endl;
	cout << "0: " << ((parms[0].get_int_value()>>8)&0xff) << " " <<  ((parms[0].get_int_value())&0xff) << endl;
	cout << "1: " << ((parms[1].get_int_value()>>8)&0x01) << " " <<  ((parms[1].get_int_value())&0x01) << endl;
#endif
	int track = parms[0].get_int_value()&0xff;
	if (track == 0xff)		// I think this is right:
		Audio::get_ptr()->cancel_streams();	// Stop playing.
	else
		{
		Audio::get_ptr()->start_music(track, 
					(parms[0].get_int_value()>>8)&0x01);
					// Show notes.
		Game_object *obj = get_item(parms[1]);
		if (obj)
			gwin->get_effects()->add_effect(
				new Sprites_effect(24, obj, 0, 0, -2, -2));
		}
	return(no_ret);
}

USECODE_INTRINSIC(npc_nearby)
{
	// NPC nearby? (item).
	Game_object *npc = get_item(parms[0]);
	int is_near = (npc != 0 && 
		npc->get_tile().distance(gwin->get_main_actor()->get_tile()) 
								< 12 &&
					// FALSE if asleep.
		!npc->get_flag(Obj_flags::asleep));
	Usecode_value u(is_near);
	return(u);
}

USECODE_INTRINSIC(npc_nearby2)
{	// Guessing wildly (SI).  Handles start of Moonshade trial where
	//   companions are a fair distance away.

	Game_object *npc = get_item(parms[0]);
	int is_near = (npc != 0 && 
		npc->get_tile().distance(gwin->get_main_actor()->get_tile()) 
								< 40 &&
					// FALSE if asleep.
		!npc->get_flag(Obj_flags::asleep));
	Usecode_value u(is_near);
	return(u);
}

USECODE_INTRINSIC(find_nearby_avatar)
{
	// Find objs. with given shape near Avatar?
	Usecode_value av(gwin->get_main_actor());
					// Try bigger # for Test of Love tree.
	Usecode_value dist(/* 64 */ 192), mask(0);
	Usecode_value u(find_nearby(av, parms[0], dist, mask));
	return(u);
}

USECODE_INTRINSIC(is_npc)
{
	// Is item an NPC?
	Actor *npc = as_actor(get_item(parms[0]));
	Usecode_value u(npc != 0);
	return(u);
}

USECODE_INTRINSIC(display_runes)
{
	// Render text into runes for signs, tombstones, plaques and the like
	// Display sign (gump #, array_of_text).
	int cnt = parms[1].get_array_size();
	if (!cnt)
		cnt = 1;		// Try with 1 element.
	Sign_gump *sign = new Sign_gump(parms[0].get_int_value(), cnt);
	bool si = Game::get_game_type()== SERPENT_ISLE;
	for (int i = 0; i < cnt; i++)
		{			// Paint each line.
		Usecode_value& lval = !i ? parms[1].get_elem0() 
					: parms[1].get_elem(i);
		const char *str = lval.get_str_value();
#if 0	/* ++++Not sure about this yet.  Compare with orig. */
		if (si)			// SI:  Add 0x20 to each chr.
			{
			char *newstr = strdup(str);
			for (char *ptr = newstr; *ptr; ptr++)
				if (*ptr >= 'A' && *ptr <= 'Z')
					*ptr += 0x20;
			sign->add_text(i, newstr);
			delete newstr;
			}
		else
#endif
			sign->add_text(i, str);
		}
	int x, y;			// Paint it, and wait for click.
	Get_click(x, y, Mouse::hand, 0, false, sign);
	delete sign;
	gwin->paint();
	return(no_ret);
}

USECODE_INTRINSIC(click_on_item)
{
	// Doesn't ret. until user single-
	//   clicks on an item.  Rets. item.
	Game_object *obj;
	Tile_coord t;

	// intercept this click?
	if (intercept_item) {
		obj = intercept_item;
		intercept_item = 0;
		t = obj->get_tile();

					// Special case for weapon hit:
	} else if (event == weapon && caller_item)
	{
        // if caller_item is the Avatar, return the Avatar's target
        // instead. This makes combat spellcasting work

        // if caller_item is not the Avatar return caller_item itself
        // this is needed for hitting Draygan with sleep arrows (SI)
		Actor *npc = as_actor(caller_item);
		if (npc == gwin->get_main_actor() && npc->get_target())
			obj = npc->get_target();
		else
			obj = caller_item;
		t = obj->get_tile();
		}
	else
		{
		int x, y;		// Allow dragging while here:
		if (!Get_click(x, y, Mouse::greenselect, 0, true))
			return Usecode_value(0);
					// Get abs. tile coords. clicked on.
		t = Tile_coord(gwin->get_scrolltx() + x/c_tilesize,
				gwin->get_scrollty() + y/c_tilesize, 0);
					// Look for obj. in open gump.
		Gump *gump = gumpman->find_gump(x, y);
		if (gump)
		{
			obj = gump->find_object(x, y);
			if (!obj) obj = gump->find_actor(x, y);
		}
		else			// Search rest of world.
			{
			obj = gwin->find_object(x, y);
			if (obj)	// Found object?  Use its coords.
				t = obj->get_tile();
			}
		}
	Usecode_value oval(obj);	// Ret. array with obj as 1st elem.
	Usecode_value ret(4, &oval);
	Usecode_value xval(t.tx), yval(t.ty), zval(t.tz);
	ret.put_elem(1, xval);
	ret.put_elem(2, yval);
	ret.put_elem(3, zval);
	return (ret);
}

/*	Set item to be returned by next call to click_on_item().
 *	Added for Exult.
 */
USECODE_INTRINSIC(set_intercept_item)
{
	intercept_item = get_item(parms[0]);
	return no_ret;
}

USECODE_INTRINSIC(find_nearby)
{
	// Think it rets. objs. near parm0.
	Usecode_value u(find_nearby(parms[0], parms[1], parms[2], parms[3]));
	return(u);
}

USECODE_INTRINSIC(give_last_created)
{
	// Think it's give_last_created(container).
	Game_object *cont = get_item(parms[0]);
	int ret = 0;
	if (cont && !last_created.empty())
		{
					// Get object, but don't pop yet.
		Game_object *obj = last_created.back();
					// Don't check vol.  Causes failures.
		ret = cont->add(obj, 1);
		if (ret)		// Pop only if added.  Fixes chest/
					//   tooth bug in SI.
			last_created.pop_back();
		}
	Usecode_value u(ret);
	return(u);
}

USECODE_INTRINSIC(is_dead)
{
	// Return 1 if parm0 is a dead NPC.
	Actor *npc = as_actor(get_item(parms[0]));
	Usecode_value u(npc && npc->is_dead());
	return(u);
}

USECODE_INTRINSIC(game_hour)
{
	// Return. game time hour (0-23).
	Usecode_value u(gclock->get_hour());
	return(u);
}

USECODE_INTRINSIC(game_minute)
{
	// Return minute (0-59).
	Usecode_value u(gclock->get_minute());
	return(u);
}

USECODE_INTRINSIC(get_npc_number)
{
	// Returns NPC# of item. (-356 =
	//   avatar).
	Actor *npc = as_actor(get_item(parms[0]));
	if (npc == gwin->get_main_actor())
		{
		Usecode_value u(-356);
		return(u);
		}
	int num = npc ? npc->get_npc_num() : 0;
	Usecode_value u(-num);
	return(u);
}

USECODE_INTRINSIC(part_of_day)
{
	// Return 3-hour # (0-7, 0=midnight).
	Usecode_value u(gclock->get_hour()/3);
	return(u);
}

USECODE_INTRINSIC(get_alignment)
{
	// Get npc's alignment.
	Actor *npc = as_actor(get_item(parms[0]));
	Usecode_value u(npc ? npc->get_alignment() : 0);
	return(u);
}

USECODE_INTRINSIC(set_alignment)
{
	// Set npc's alignment.
	// 2,3==bad towards Ava. 0==good.
	Actor *npc = as_actor(get_item(parms[0]));
	int val = parms[1].get_int_value();
	if (npc)
		{
		int oldalign = npc->get_alignment();
		npc->set_alignment(val);
		if (oldalign != val)	// Changed?  Force search for new opp.
			npc->set_target(0);
					// For fixing List Field fleeing:
		if (npc->get_attack_mode() == Actor::flee)
			npc->set_attack_mode(Actor::nearest);
		}
	return(no_ret);
}

USECODE_INTRINSIC(move_object)
{
	// move_object(obj(-357=party), (tx, ty, tz)).
	Usecode_value& p = parms[1];
	Tile_coord tile(p.get_elem(0).get_int_value(),
			p.get_elem(1).get_int_value(),
			p.get_elem(2).get_int_value());
	Actor *ava = gwin->get_main_actor();
	modified_map = true;
	if (parms[0].get_int_value() == -357)
		{			// Move whole party.
					// If Freedom exit teleport, don't ac-
					//   tivate eggs when you arrive.
		gwin->teleport_party(tile, Game::get_game_type() ==
			SERPENT_ISLE && frame->function->id == 0x7df && 
				caller_item->get_quality() == 0xcf);
		return (no_ret);
		}
	Game_object *obj = get_item(parms[0]);
	if (!obj)
		return (no_ret);
	Tile_coord oldpos = obj->get_tile();
	obj->move(tile.tx, tile.ty, tile.tz);
	Actor *act = as_actor(obj);
	if (act)
		{
		act->set_action(0);
		if (act == ava)
			{		// Teleported Avatar?
					// Make new loc. visible, test eggs.
			gwin->center_view(tile);
			Map_chunk::try_all_eggs(ava, tile.tx, 
				tile.ty, tile.tz, oldpos.tx, oldpos.ty);
			}
					// Close?  Add to 'nearby' list.
		else if (ava->distance(act) < gwin->get_width()/c_tilesize)
			{
			Npc_actor *npc = act->as_npc();
			if (npc) gwin->add_nearby_npc(npc);
			}
		}
	return(no_ret);
}

USECODE_INTRINSIC(remove_npc)
{
	// Remove_npc(npc) - Remove npc from world.
	Actor *npc = as_actor(get_item(parms[0]));
	if (npc)
		{
		modified_map = true;
					// Don't want him/her coming back!
		npc->set_schedule_type(Schedule::wait);
		gwin->add_dirty(npc);
		npc->remove_this(1);	// Remove, but don't delete.
		}
	return (no_ret);
}

USECODE_INTRINSIC(item_say)
{
	// Show str. near item (item, str).
	if (!conv->is_npc_text_pending())
		item_say(parms[0], parms[1]);	// Do it now.
	return(no_ret);
}

USECODE_INTRINSIC(clear_item_say)
{
	// Clear str. near item (item).
	Game_object *item = get_item(parms[0]);
	if (item)
		gwin->get_effects()->remove_text_effect(item);
	return(no_ret);
}

USECODE_INTRINSIC(projectile_effect)
{
	// animate(fromitem, toitem, anim_shape_in_shapesdotvga).
	// ???? When it reaches toitem, toitem is 'attacked' by anim_shape.
	//   Returns??}
	Game_object *from = get_item(parms[0]),
		    *to = get_item(parms[1]);
	if (!from || !to)
		return Usecode_value(0);
	Actor *attacker = as_actor(from);
	if (!attacker)
		return Usecode_value(0);
	int shnum = parms[2].get_int_value();
	gwin->get_effects()->add_effect(
				new Projectile_effect(attacker, to, shnum));

	return Usecode_value(0);	// Not sure what this should be.
}

USECODE_INTRINSIC(get_lift)
{
	// ?? Guessing rets. lift(item).
	Game_object *obj = get_item(parms[0]);
	Usecode_value u(obj ? Usecode_value(obj->get_lift())
					: Usecode_value(0));
	return(u);
}

USECODE_INTRINSIC(set_lift)
{
	// ?? Guessing setlift(item, lift).
	Game_object *obj = get_item(parms[0]);
	if (obj)
		{
		Tile_coord t = obj->get_tile();
		int lift = parms[1].get_int_value();
		if (lift >= 0 && lift < 20)
			obj->move(t.tx, t.ty, lift);
		gwin->paint();
		gwin->show();
		modified_map = true;
		}
	return(no_ret);
}

USECODE_INTRINSIC(get_weather)
{
	// Get_weather()
	return Usecode_value(gwin->get_effects()->get_weather());
}

USECODE_INTRINSIC(set_weather)
{
	// Set_weather(i)
	Egg_object::set_weather(parms[0].get_int_value());
	return no_ret;
}


USECODE_INTRINSIC(sit_down)
{
	// Sit_down(npc, chair).
	Game_object *nobj = get_item(parms[0]);
	Actor *npc = as_actor(nobj);
	if (!npc)
		return (no_ret);	// Doesn't look like an NPC.
	Game_object *chair = get_item(parms[1]);
	if (!chair)
		return (no_ret);
	npc->set_schedule_type(Schedule::sit, new Sit_schedule(npc, chair));
	return(no_ret);
}

USECODE_INTRINSIC(summon)
{
	// summon(shape, flag??).  Create monster of desired shape.

	int shapenum = parms[0].get_int_value();
	Monster_info *info = ShapeID::get_info(shapenum).get_monster_info();
	if (!info)
		return Usecode_value(0);
	Tile_coord start = gwin->get_main_actor()->get_tile();
	Tile_coord dest = Map_chunk::find_spot(start, 5, shapenum, 0, 1,
			-1, gwin->is_main_actor_inside() ?
				Map_chunk::inside : Map_chunk::outside);
	if (dest.tx == -1)
		return Usecode_value(0);
	Monster_actor *monst = Monster_actor::create(shapenum, dest,
					Schedule::combat, Actor::friendly);
	return Usecode_value(monst);
}

/*
 *	Class to paint a shape centered.
 */
class Paint_centered : public Paintable, public Game_singletons
	{
protected:
	ShapeID *sid;			// ->shape.
	int x, y;			// Where to paint.
public:
	Paint_centered(ShapeID *si) : sid(si)
		{
		Shape_frame *s = sid->get_shape();
					// Get coords. for centered view.
		x = (gwin->get_width() - s->get_width())/2 + s->get_xleft();
		y = (gwin->get_height() - s->get_height())/2 + s->get_yabove();
		}
	virtual void paint()
		{
		sid->paint_shape(x, y);
		}
	};
/*
 *	Paint map.
 */
class Paint_map : public Paint_centered
	{
	bool show_loc;
public:
	Paint_map(ShapeID *s, bool loc) : Paint_centered(s), show_loc(loc)
		{  }
	virtual void paint()
		{
		Paint_centered::paint();
		if (show_loc)
			{		// mark location
			int xx, yy;
			Tile_coord t = gwin->get_main_actor()->get_tile();
			if (Game::get_game_type()==BLACK_GATE) {
				xx = (int)(t.tx/16.05 + 5 + 0.5);
				yy = (int)(t.ty/15.95 + 4 + 0.5);
			} else if (Game::get_game_type()==SERPENT_ISLE) {
				xx = (int)(t.tx/16.0 + 18 + 0.5);
				yy = (int)(t.ty/16.0 + 9.4 + 0.5);
			}
			Shape_frame *s = sid->get_shape();
			xx += x - s->get_xleft();
			yy += y - s->get_yabove();
			gwin->get_win()->fill8(255, 1, 5, xx, yy - 2);
			gwin->get_win()->fill8(255, 5, 1, xx - 2, yy);
			}
		}
	};

USECODE_INTRINSIC(display_map)
{

	//count all sextants in party
	Usecode_value v_357(-357), v650(650), v_359(-359);
	long sextants=count_objects(v_357, v650, v_359, v_359).get_int_value();
	bool loc = !gwin->is_main_actor_inside() && (sextants > 0);
	// Display map.
	ShapeID msid(game->get_shape("sprites/map"), 0, SF_SPRITES_VGA);
	Paint_map map(&msid, loc);

	int xx, yy;
	Get_click(xx, yy, Mouse::hand, 0, false, &map);
	gwin->paint();
	return(no_ret);
}

USECODE_INTRINSIC(si_display_map)
{
	int mapnum = parms[0].get_int_value();
	int shapenum;

	switch (mapnum) {
		case 0:	return UI_display_map(event,intrinsic,num_parms,parms);
		case 1:	shapenum = 57; break;
		case 2: shapenum = 58; break;
		case 3: shapenum = 59; break;
		case 4: shapenum = 60; break;
		case 5: shapenum = 52; break;
		default: return no_ret;
	}
			
	// Display map.
	
	// Display map.
	ShapeID msid(shapenum, 0, SF_SPRITES_VGA);
	Paint_centered map(&msid);
	int xx, yy;
	Get_click(xx, yy, Mouse::hand, 0, false, &map);
	gwin->paint();

	return no_ret;
}

USECODE_INTRINSIC(kill_npc)
{
	// kill_npc(npc).
	Game_object *item = get_item(parms[0]);
	Actor *npc = as_actor(item);
	if (npc)
		npc->die(0);
	modified_map = true;
	return (no_ret);
}

USECODE_INTRINSIC(roll_to_win)
{
	// roll_to_win(attackpts, defendpts)
	int attack = parms[0].get_int_value();
	int defend = parms[1].get_int_value();
	return Usecode_value((int) Actor::roll_to_win(attack, defend));
}

USECODE_INTRINSIC(set_attack_mode)
{
	// set_attack_mode(npc, mode).
	Actor *npc = as_actor(get_item(parms[0]));
	if (npc)
		npc->set_attack_mode((Actor::Attack_mode) 
					parms[1].need_int_value());
	return (no_ret);
}

USECODE_INTRINSIC(get_attack_mode)
{
	// get_attack_mode(npc).
	Actor *npc = as_actor(get_item(parms[0]));
	if (npc)
		return Usecode_value((int) npc->get_attack_mode());
	return Usecode_value(0);
}

USECODE_INTRINSIC(set_opponent)
{
	// set_opponent(npc, new_opponent).
	Actor *npc = as_actor(get_item(parms[0]));
	Game_object *opponent = get_item(parms[1]);
	if (npc && opponent)
		npc->set_target(opponent);
	return (no_ret);
}

USECODE_INTRINSIC(clone)
{
	// clone(npc)
	Actor *npc = as_actor(get_item(parms[0]));
	if (npc)
		{
		modified_map = true;
		npc->set_alignment(Actor::friendly);
		npc->set_schedule_type(Schedule::combat);
		return Usecode_value(npc->clone());
		}
	return Usecode_value(0);
}

USECODE_INTRINSIC(get_oppressor)
{
	// get_oppressor(npc) Returns 0-n, NPC # (0=avatar).
	Actor *npc = as_actor(get_item(parms[0]));
	return Usecode_value(npc ? npc->get_oppressor() : 0);
}

USECODE_INTRINSIC(set_oppressor)
{
	// set_oppressor(npc, opp)
	Actor *npc = as_actor(get_item(parms[0]));
	Actor *opp = as_actor(get_item(parms[1]));
	if (npc && opp)
		{
		if (opp == gwin->get_main_actor())
			npc->set_oppressor(0);
		else
			npc->set_oppressor(opp->get_npc_num());
					// Need this for SI ListField training:
		npc->set_target(opp);
		}
	return no_ret;
}

USECODE_INTRINSIC(get_weapon)
{
	// get_weapon(npc).  Returns shape.
	Actor *npc = as_actor(get_item(parms[0]));
	if (npc)
		{
		int shape, points;
		if (npc->get_weapon(points, shape))
			return Usecode_value(shape);
		}
	return Usecode_value(0);
}

USECODE_INTRINSIC(display_area)
{
	// display_area(tilepos) - used for crystal balls.
	int size = parms[0].get_array_size();
	if (size >= 3)
		{
		int tx = parms[0].get_elem(0).get_int_value();
		int ty = parms[0].get_elem(1).get_int_value();
		int unknown = parms[0].get_elem(2).get_int_value();
					// Figure in tiles.
		int tw = gwin->get_width()/c_tilesize, 
		    th = gwin->get_height()/c_tilesize;
		gwin->clear_screen();	// Fill with black.
		Shape_frame *sprite = ShapeID(10, 0, SF_SPRITES_VGA).get_shape();
					// Center it.
		int topx = (gwin->get_width() - sprite->get_width())/2,
		    topy = (gwin->get_height() - sprite->get_height())/2;
					// Get area to fill.
		int x = topx, y = topy, w = sprite->get_width(),
					h = sprite->get_height();
		if (w > gwin->get_width())
			{ x = 0; w = gwin->get_width(); }
		if (h > gwin->get_height())
			{ y = 0; h = gwin->get_height(); }
		int save_dungeon = gwin->is_in_dungeon();
		gwin->set_in_dungeon(0);	// Disable dungeon.
					// Paint game area.
		gwin->paint_map_at_tile(x, y, w, h, tx - tw/2, ty - th/2, 4);
					// Paint sprite #10 (black gate!)
					//   over it, transparently.
		sman->paint_shape(topx + sprite->get_xleft(),
				topy + sprite->get_yabove(), sprite, 1);
		gwin->set_in_dungeon(save_dungeon);
		gwin->show();
					// Wait for click.
		Get_click(x, y, Mouse::hand);
		gwin->paint();		// Repaint normal area.
		}
	return (no_ret);
}

USECODE_INTRINSIC(wizard_eye)
{
	// wizard_eye(#ticks, ??);
	extern void Wizard_eye(long);
					// Let's give 50% longer.
	Wizard_eye(parms[0].get_int_value()*(3*gwin->get_std_delay())/2);
	return no_ret;
}

USECODE_INTRINSIC(resurrect)
{
	// resurrect(body).  Returns actor if successful.
	Game_object *body = get_item(parms[0]);
	int npc_num = body ? body->get_live_npc_num() : -1;
	if (npc_num < 0)
		return Usecode_value((Game_object*) NULL);
	Actor *actor = gwin->get_npc(npc_num);
	if (actor)
		{			// Want to resurrect after returning.
		Usecode_script *scr = new Usecode_script(body);
		(*scr) << Ucscript::resurrect;
		scr->start();
		modified_map = true;
		}
	return Usecode_value(actor);
}

USECODE_INTRINSIC(get_body_npc)
{
	// get_body_npc(body).  Returns npc # (negative).
	Game_object *obj = get_item(parms[0]);
	int num = obj ? obj->get_live_npc_num() : -1;
	return Usecode_value(num > 0 ? -num : 0);
}

USECODE_INTRINSIC(add_spell)
{
	// add_spell(spell# (0-71), ??, spoolbook).
	// Returns 0 if book already has that spell.
	Game_object *obj = get_item(parms[2]);
	if (!obj || obj->get_info().get_shape_class() != Shape_info::spellbook)
		return Usecode_value(0);
	Spellbook_object *book = (Spellbook_object *) (obj);
	if (!book)
		{
		cout << "Add_spell - Not a spellbook!" << endl;
		return Usecode_value(0);
		}
	return Usecode_value(book->add_spell(parms[0].get_int_value()));
}

USECODE_INTRINSIC(sprite_effect)
{
	// Display animation from sprites.vga.
	// show_sprite(sprite#, tx, ty, dx, dy, frame, length??);
					// ++++++Pass frame, length+++++++
	gwin->get_effects()->add_effect(
		new Sprites_effect(parms[0].get_int_value(),
		Tile_coord(parms[1].get_int_value(), parms[2].get_int_value(),
									0),
			parms[3].get_int_value(), parms[4].get_int_value()));
	return(no_ret);
}

USECODE_INTRINSIC(obj_sprite_effect)
{
	// obj_sprite_effect(obj, sprite#, -xoff, -yoff, dx, dy, 
	//						frame, length??)
	Game_object *obj = get_item(parms[0]);
	if (obj)
					// ++++++Pass frame, length+++++++
		gwin->get_effects()->add_effect(
			new Sprites_effect(parms[1].get_int_value(), obj,
			-parms[2].get_int_value(), -parms[3].get_int_value(),
			parms[4].get_int_value(), parms[5].get_int_value()));
	return(no_ret);
}

USECODE_INTRINSIC(explode)
{
	// Explode(obj??, item-to-explode, powder-keg-shape).
	Game_object *exp = get_item(parms[1]);
	if (!exp)
		return Usecode_value(0);
					// Use container if it's in one.
	Tile_coord pos = exp->get_outermost()->get_tile();
					// Sprite 1,4,5 look like explosions.
	gwin->get_effects()->add_effect(new Explosion_effect(pos, exp));
	return Usecode_value(1);
}

USECODE_INTRINSIC(book_mode)
{
	// Display book or scroll.
	Text_gump *gump;
	Game_object *obj = get_item(parms[0]);
	if (!obj)
		{
		return(no_ret);
		}

	// check for avatar read here
	bool do_serp = gwin->get_main_actor()->get_flag(Obj_flags::read) == false;
	
	if (obj->get_shapenum() == 707)		// Serpentine Scroll - Make SI only???
		gump = new Scroll_gump(do_serp);
	else if (obj->get_shapenum() == 705)	// Serpentine Book - Make SI only???
		gump = new Book_gump(do_serp);
	else if (obj->get_shapenum() == 797)
		gump = new Scroll_gump();
	else
		gump = new Book_gump();
	set_book(gump);
	return(no_ret);
}

USECODE_INTRINSIC(stop_time)
{	// stop_time(.25 secs).

	int length = parms[0].get_int_value();
	gwin->set_time_stopped(length*250);
	return no_ret;
}

USECODE_INTRINSIC(cause_light)
{
	// Cause_light(game_minutes??)

	gwin->add_special_light(parms[0].get_int_value());
	return no_ret;
}

USECODE_INTRINSIC(get_barge)
{
	// get_barge(obj) - returns barge object is part of or lying on.

	Game_object *obj = get_item(parms[0]);
	if (!obj)
		return Usecode_value((Game_object*) NULL);
	return Usecode_value(Get_barge(obj));
}

USECODE_INTRINSIC(earthquake)
{
	int len = parms[0].get_int_value();
	gwin->get_tqueue()->add(Game::get_ticks() + 10,
		new Earthquake(len), (long) this);
	return(no_ret);
}

USECODE_INTRINSIC(is_pc_female)
{
	// Is player female?
	Usecode_value u(gwin->get_main_actor()->get_type_flag(Actor::tf_sex));
	return(u);
}

USECODE_INTRINSIC(armageddon)
{
	int cnt = gwin->get_num_npcs();
	Rectangle screen = gwin->get_win_tile_rect();
	for (int i = 1; i < cnt; i++)	// Most everyone dies.
		{			// Leave LB, Batlin, Hook.
		Actor *npc = gwin->get_npc(i);
		if (npc && i != 26 && i != 23 && npc->get_shapenum() != 506 &&
		    !npc->is_dead())
			{
			const char *text[] = {"Aiiiieee!", "Noooo!", "#!?*#%!"};
			const int numtext = sizeof(text)/sizeof(text[0]);
			Tile_coord loc = npc->get_tile();
			if (screen.has_point(loc.tx, loc.ty))
				npc->say(text[rand()%numtext]);
			npc->die(0);
			}
		}
	Actor_vector vec;		// Get any monsters nearby.
	gwin->get_main_actor()->find_nearby_actors(vec, c_any_shapenum, 40);
	for (Actor_vector::const_iterator it = vec.begin(); it != vec.end();
									++it)
		{
		Actor *act = *it;
		if (act->is_monster())	// Assume only Avatar can cast this.
			act->die(gwin->get_main_actor());
		}
	gwin->armageddon = true;
	return no_ret;
}

USECODE_INTRINSIC(halt_scheduled)
{
	// Halt_scheduled(item)
	Game_object *obj = get_item(parms[0]);
	if (obj)
		Usecode_script::terminate(obj);
	return(no_ret);
}

USECODE_INTRINSIC(lightning)
{
					// 1 sec. is long enough for 1 flash.
	gwin->get_effects()->add_effect(new Lightning_effect(1000));
	return no_ret;
}

USECODE_INTRINSIC(get_array_size)
{
	int cnt;
	if (parms[0].is_array())	// An array?  We might return 0.
		cnt = parms[0].get_array_size();
	else				// Not an array?  Usecode wants a 1.
		cnt = 1;
	Usecode_value u(cnt);
	return(u);
}

USECODE_INTRINSIC(mark_virtue_stone)
{
	Game_object *obj = get_item(parms[0]);
	if (obj->get_info().get_shape_class() == Shape_info::virtue_stone)
		{
		Virtue_stone_object *vs = (Virtue_stone_object *) (obj);
		vs->set_pos(obj->get_outermost()->get_tile());
		}
	return no_ret;
}

USECODE_INTRINSIC(recall_virtue_stone)
{
	Game_object *obj = get_item(parms[0]);
	if (obj->get_info().get_shape_class() == Shape_info::virtue_stone)
		{
		Virtue_stone_object *vs = (Virtue_stone_object *) (obj);
		gumpman->close_all_gumps();
					// Pick it up if necessary.
		if (!obj->get_owner())
			{		// Go through whole party.
			obj->remove_this(1);
			Usecode_value party = get_party();
			int cnt = party.get_array_size();
			int i;
			for (i = 0; i < cnt; i++)
				{
				Game_object *npc = get_item(party.get_elem(i));
				if (npc && npc->add(obj))
					break;
				}
			if (i == cnt)	// Failed?  Force it on Avatar.
				gwin->get_main_actor()->add(obj, 1);
			}
		Tile_coord t = vs->get_pos();
		if (t.tx > 0 || t.ty > 0)
			gwin->teleport_party(t);
		}
	return no_ret;
}

USECODE_INTRINSIC(apply_damage)
{
	// apply_damage(??str?, hps, ??type?, NPC);
	int hps = parms[1].get_int_value();
	Actor *npc = as_actor(get_item(parms[3]));
	if (npc)
		npc->reduce_health(hps);
	return Usecode_value(1);	// ?? Guessing.
}

USECODE_INTRINSIC(is_pc_inside)
{
	Usecode_value u(gwin->is_main_actor_inside());
	return(u);
}

USECODE_INTRINSIC(get_timer)
{
	int tnum = parms[0].get_int_value();
	int ret;
	if (tnum >= 0 && tnum < (int)(sizeof(timers)/sizeof(timers[0])))
					// Return 0 if not set.
		ret = timers[tnum] > 0 ?
			(gclock->get_total_hours() - timers[tnum]) : 0;
	else
		{
		cerr << "Attempt to use invalid timer " << tnum << endl;
		ret = 0;
		}
	return Usecode_value(ret);
}

USECODE_INTRINSIC(set_timer)
{
	int tnum = parms[0].get_int_value();
	if (tnum >= 0 && tnum < (int)(sizeof(timers)/sizeof(timers[0])))
		timers[tnum] = gclock->get_total_hours();
	else
		cerr << "Attempt to use invalid timer " << tnum << endl;
	return(no_ret);
}

USECODE_INTRINSIC(wearing_fellowship)
{
	Game_object *obj = gwin->get_main_actor()->get_readied(Actor::neck);
	if (obj && obj->get_shapenum() == 955 && obj->get_framenum() == 1)
		return Usecode_value(1);
	else
		return Usecode_value(0);
}

USECODE_INTRINSIC(mouse_exists)
{
	Usecode_value u(1);
	return(u);
}

USECODE_INTRINSIC(get_speech_track)
{
	// Get speech track set by 0x74 or 0x8f.
	return Usecode_value(speech_track);
}

USECODE_INTRINSIC(flash_mouse)
{
	// flash_mouse(code)
	Mouse::Mouse_shapes shape;
	switch (parms[0].need_int_value())
		{
	case 2:
		shape = Mouse::outofrange; break;
	case 3:
		shape = Mouse::outofammo; break;
	case 4:
		shape = Mouse::tooheavy; break;
	case 5:
		shape = Mouse::wontfit; break;
	case 0:
	case 1:
	default:
		shape = Mouse::redx; break;
		}
	Mouse::mouse->flash_shape(shape);
	return (no_ret);
}

USECODE_INTRINSIC(get_item_frame_rot)
{
	// Same as get_item_frame, but (guessing!) include rotated bit.
	Game_object *obj = get_item(parms[0]);
	return Usecode_value(obj ? obj->get_framenum() : 0);
}

USECODE_INTRINSIC(set_item_frame_rot)
{	// Set entire frame, including rotated bit.
	set_item_frame(get_item(parms[0]), parms[1].get_int_value(), 0, 1);
	return(no_ret);
}

USECODE_INTRINSIC(on_barge)
{
	// Only used once for BG, in usecode for magic-carpet.
	// For SI, used for turtle.
	// on_barge()
	Barge_object *barge = Get_barge(gwin->get_main_actor());
	if (barge)
		{			// See if party is on barge.
		Rectangle foot = barge->get_tile_footprint();
		Actor *party[9];
		int cnt = gwin->get_party(party, 1);
		for (int i = 0; i < cnt; i++)
			{
			Actor *act = party[i];
			Tile_coord t = act->get_tile();
			if (!foot.has_point(t.tx, t.ty))
				return Usecode_value(0);
			}
					// Force 'gather()' for turtle.
		if (Game::get_game_type() == SERPENT_ISLE)
			barge->done();
		return Usecode_value(1);
		} 
	return Usecode_value(0);
//	return Usecode_value(1);
}

USECODE_INTRINSIC(get_container)
{
	// Takes itemref, returns container.
	Game_object *obj = get_item(parms[0]);
	Usecode_value u((Game_object *) NULL);
	if (obj)
		u = Usecode_value(obj->get_owner());
	return(u);
}

USECODE_INTRINSIC(remove_item)
{
	// Think it's 'delete object'.
	remove_item(get_item(parms[0]));
	modified_map = true;
	return no_ret;
}

USECODE_INTRINSIC(reduce_health)
{
	// Reduce_health(npc, amount, ??property/flags??0?).
	Actor *npc = as_actor(get_item(parms[0]));
	if (npc)			// Dies if health goes too low.
		npc->reduce_health(parms[1].get_int_value());
	return no_ret;
}

/*
 *	Convert Usecode spot # to ours (or -1 if not found).
 */

static int Get_spot(int ucspot)
	{
	int spot;
	switch (ucspot)
		{
	case 1:
		spot = Actor::lhand; break;
	case 2:
		spot = Actor::rhand; break;
	case 3:
		spot = Actor::neck; break;
	case 5:
		spot = Actor::hands2_spot; break;
	case 6:
		spot = Actor::lfinger; break;
	case 7:
		spot = Actor::rfinger; break;
	case 9:
		spot = Actor::head; break; 
	case 11:
		spot = Actor::belt; break;
	default:
		cerr << "Readied: spot #" << ucspot <<
						" not known yet" << endl;
		spot = -1;
		}
	return spot;
	}

USECODE_INTRINSIC(is_readied)
{
	// is_readied(npc, where, itemshape, frame (-359=any)).
	// Where:
	//   1=weapon hand, 
	//   2=other hand,
	//   6=one finger, 
	//   7=other finger,
	//   9=head
	//  20=???

	Actor *npc = as_actor(get_item(parms[0]));
	if (!npc)
		return Usecode_value(0);
	int where = parms[1].get_int_value();
	int shnum = parms[2].get_int_value();
	int frnum = parms[3].get_int_value();
					// Spot defined in Actor class.
	int spot = Get_spot(where);
	if (spot >= 0)
		{			// See if it's the right one.
		Game_object *obj = npc->get_readied(spot);
		if (obj && obj->get_shapenum() == shnum &&
		    (frnum == c_any_framenum || obj->get_framenum() == frnum))
			return Usecode_value(1);
		}
	return Usecode_value(0);
}

USECODE_INTRINSIC(get_readied)
{
	// get_readied(npc, where)
	// Where:
	//   1=weapon hand, 
	//   2=other hand,
	//   6=one finger, 
	//   7=other finger,
	//   9=head
	//  11=belt
	//  20=???

	Actor *npc = as_actor(get_item(parms[0]));
	if (!npc)
		return Usecode_value(0);
	int where = parms[1].get_int_value();
					// Spot defined in Actor class.
	int spot = Get_spot(where);
	if (spot >= 0)
		return Usecode_value(npc->get_readied(spot));
	return Usecode_value(0);
}

USECODE_INTRINSIC(restart_game)
{
	// Think it's 'restart game'.  
	// Happens if you die before leaving trinsic.
	Audio::get_ptr()->stop_music();
	quitting_time = QUIT_TIME_RESTART;		// Quit & restart.
	return(no_ret);
}

USECODE_INTRINSIC(start_speech)
{
	// Start_speech(num).  Also sets speech_track.
	bool okay = false;
	speech_track = parms[0].get_int_value();
	if (speech_track >= 0)
		okay = Audio::get_ptr()->start_speech(speech_track);
	if (!okay)			// Failed?  Clear faces.  (Fixes SI).
		init_conversation();
	return(Usecode_value(okay ? 1 : 0));
}

USECODE_INTRINSIC(is_water)
{
	// Is_water(pos).
	int size = parms[0].get_array_size();
	if (size >= 3)
		{
		Tile_coord t(parms[0].get_elem(0).get_int_value(),
			     parms[0].get_elem(1).get_int_value(),
			     parms[0].get_elem(2).get_int_value());
					// Didn't click on an object?
		int x = (t.tx - gwin->get_scrolltx())*c_tilesize,
		    y = (t.ty - gwin->get_scrollty())*c_tilesize;
		if (t.tz != 0 || gwin->find_object(x, y))
			return Usecode_value(0);
		ShapeID sid = gwin->get_flat(x, y);
		if (sid.is_invalid())
			return Usecode_value(0);
		Shape_info& info = sid.get_info();
		return Usecode_value(info.is_water());
		}
	return Usecode_value(0);
}

USECODE_INTRINSIC(run_endgame)
{
	Audio::get_ptr()->stop_sound_effects();
	game->end_game(parms[0].get_int_value() != 0);
	// If successful enable menu entry and play credits afterwards
	if(parms[0].get_int_value() != 0) {
		std::ofstream endgameflg;
                U7open(endgameflg, "<SAVEGAME>/endgame.flg");
                endgameflg.close();
		game->show_credits();
	}
	quitting_time = QUIT_TIME_YES;
	return(no_ret);
}

USECODE_INTRINSIC(fire_cannon)
{
	// fire_cannon(cannon, dir, ballshape, dist?, cannonshape, cannonshape)

	Game_object *cannon = get_item(parms[0]);
					// Get direction (0,2,4, or 6).
	int dir = parms[1].get_int_value();
	dir = dir/2;			// 0, 1, 2, 3.
	int ball = parms[2].get_int_value();
	int dist = parms[3].get_int_value();
	int cshape = parms[4].get_int_value();
	Tile_coord pos = cannon->get_tile();
	short blastoff[8] = {-2, -5, 1, -2, -2, 1, -5, -2};
	Tile_coord blastpos = pos + Tile_coord(
				blastoff[2*dir], blastoff[2*dir + 1], 0);
					// Sprite 5 is a small explosion.
	gwin->get_effects()->add_effect(new Sprites_effect(5, blastpos));
	Tile_coord dest = pos;
	switch (dir)			// Figure where to aim.
		{
	case 0:	dest.ty -= dist; break;
	case 1: dest.tx += dist; break;
	case 2: dest.ty += dist; break;
	case 3: dest.tx -= dist; break;
		}
					// Shoot cannonball.
	gwin->get_effects()->add_effect(
			new Projectile_effect(blastpos, dest, ball, cshape));
	return no_ret;
}

USECODE_INTRINSIC(nap_time)
{
	// nap_time(bed)
	Game_object *bed = get_item(parms[0]);
	if (!bed)
		return no_ret;
					// !!! Seems 622 handles sleeping.
	Actor_vector npcs;		// See if bed is occupied by an NPC.
	int cnt = bed->find_nearby_actors(npcs, c_any_shapenum, 0);
	if (cnt > 0)
		{
		Actor_vector::const_iterator it;
		for (it = npcs.begin(); it != npcs.end(); ++it)
			{
			Game_object *npc = *it;
			int zdiff = npc->get_lift() - bed->get_lift();
			if (npc != gwin->get_main_actor() &&
			    (npc->get_framenum()&0xf) == Actor::sleep_frame &&
						zdiff <= 2 && zdiff >= -2)
				break;	// Found one.
			}
		if (it != npcs.end())
			{		// Show party member's face.
			int party_cnt = partyman->get_count();
			int npcnum = party_cnt ? partyman->get_member(
						rand()%party_cnt) : 356;
			Usecode_value actval(-npcnum), frval(0);
			show_npc_face(actval, frval);
			conv->show_npc_message(item_names[first_bed_occupied +
						rand()%num_bed_occupied]);
			remove_npc_face(actval);
			gwin->get_main_actor()->set_schedule_type(
						Schedule::follow_avatar);
			return no_ret;
			}
		}
	Schedule *sched = gwin->get_main_actor()->get_schedule();
	if (sched)			// Tell (sleep) sched. to use bed.
		sched->set_bed(bed);
					// Give him a chance to get there (at
					//   most 5 seconds.)
	Wait_for_arrival(gwin->get_main_actor(), bed->get_tile(),
								5000);
	call_usecode(0x622, bed, double_click);
	return(no_ret);
}

USECODE_INTRINSIC(advance_time)
{
	// Incr. clock by (parm[0]*.04min.).
	gclock->increment(parms[0].get_int_value()/25);
	return(no_ret);
}

USECODE_INTRINSIC(in_usecode)
{
	// in_usecode(item):  Return 1 if executing usecode on parms[0].

	Game_object *obj = get_item(parms[0]);
	if (!obj)
		return Usecode_value(0);
	return Usecode_value(Usecode_script::find(obj) != 0);
}

USECODE_INTRINSIC(call_guards)
{
	// Attack thieving Avatar.
	gwin->call_guards();
	return no_ret;
}

USECODE_INTRINSIC(attack_avatar)
{
	// Attack thieving Avatar.
	gwin->attack_avatar();
	return no_ret;
}

USECODE_INTRINSIC(path_run_usecode)
{
	// exec(loc(x,y,z)?, usecode#, itemref, eventid).
	// Think it should have Avatar walk path to loc, return 0
	//  if he can't get there (and return), 1 if he can.
	Usecode_value ava(gwin->get_main_actor());
	return Usecode_value(path_run_usecode(ava, parms[0], parms[1],
				parms[2], parms[3],
					// SI:  Look for free spot. (Guess).
			Game::get_game_type() == SERPENT_ISLE));
}

USECODE_INTRINSIC(close_gumps)
{
	if (!gwin->is_dragging())	// NOT while dragging stuff.
		gumpman->close_all_gumps();
	return(no_ret);
}

USECODE_INTRINSIC(in_gump_mode)
{
								// No persistent
	return Usecode_value(gumpman->showing_gumps(true));
}

USECODE_INTRINSIC(is_not_blocked)
{
	// Is_not_blocked(tile, shape, frame (or -359).
	Usecode_value fail(0);
					// Parm. 0 should be tile coords.
	Usecode_value& pval = parms[0];
	if (pval.get_array_size() < 3)
		return fail;
	Tile_coord tile(pval.get_elem(0).get_int_value(),
			pval.get_elem(1).get_int_value(),
			pval.get_elem(2).get_int_value());
	int shapenum = parms[1].get_int_value();
	int framenum = parms[2].get_int_value();
					// Find out about given shape.
	Shape_info& info = ShapeID::get_info(shapenum);
	Rectangle footprint(
		tile.tx - info.get_3d_xtiles(framenum) + 1,
		tile.ty - info.get_3d_ytiles(framenum) + 1,
		info.get_3d_xtiles(framenum), info.get_3d_ytiles(framenum));
	int new_lift;
	int blocked = Map_chunk::is_blocked(
		info.get_3d_height(), tile.tz, 
		footprint.x, footprint.y, footprint.w, footprint.h,
		new_lift, MOVE_ALL_TERRAIN, 1);
					// Okay?
	if (!blocked && new_lift == tile.tz)
		return Usecode_value(1);
	else
		return Usecode_value(0);
}

USECODE_INTRINSIC(direction_from)
{
	// ?Direction from parm[0] -> parm[1].
	// Rets. 0-7, with 0 = North, 1 = Northeast, etc.
	// Same as 0x1a??
	Usecode_value u=find_direction(parms[0], parms[1]);
	return(u);
}

/*
 *	Test for a 'moving barge' flag.
 */

static int Is_moving_barge_flag
	(
	int fnum
	)
	{
	if (Game::get_game_type() == BLACK_GATE)
		{
		return fnum == (int) Obj_flags::on_moving_barge ||
			fnum == (int) Obj_flags::in_motion;
		}
	else				// SI.
		{
		return fnum == (int) Obj_flags::si_on_moving_barge ||
					// Ice raft needs this one:
			fnum == (int) Obj_flags::on_moving_barge ||
			fnum == (int) Obj_flags::in_motion;
		}
	}

USECODE_INTRINSIC(get_item_flag)
{
	// Get npc flag(item, flag#).
	Game_object *obj = get_item(parms[0]);
	if (!obj)
		return Usecode_value(0);
	int fnum = parms[1].get_int_value();
					// Special cases:
	if (Is_moving_barge_flag(fnum))
		{			// Test for moving barge.
		Barge_object *barge;
		if (!gwin->get_moving_barge() || !(barge = Get_barge(obj)))
			return Usecode_value(0);
		return Usecode_value(barge == gwin->get_moving_barge());
		}
	else if (fnum == (int) Obj_flags::okay_to_land)
		{			// Okay to land flying carpet?
		Barge_object *barge = Get_barge(obj);
		if (!barge)
			return Usecode_value(0);
		return Usecode_value(barge->okay_to_land());
		}
	else if (fnum == (int) Obj_flags::cant_die)
		{
		Monster_info *inf = obj->get_info().get_monster_info();
		return Usecode_value(inf != 0 && inf->cant_die());
		}
					// +++++0x18 is used in testing for
					//   blocked gangplank. What is it?????
	else if (fnum == 0x18 && Game::get_game_type() == BLACK_GATE)
		return Usecode_value(1);
	else if (fnum == (int) Obj_flags::in_dungeon)
		return Usecode_value(obj == gwin->get_main_actor() &&
					gwin->is_in_dungeon());
	else if (fnum == 0x14)		// Must be the sailor, as this is used
					//   to check for Ferryman.
		return Usecode_value(sailor);
	Usecode_value u(obj->get_flag(fnum) != 0);
	return(u);
}

USECODE_INTRINSIC(set_item_flag)
{
	// Set npc flag(item, flag#).
	Game_object *obj = get_item(parms[0]);
	int flag = parms[1].get_int_value();
	if (!obj)
		return no_ret;
	switch (flag)
		{
	case Obj_flags::dont_move:
		obj->set_flag(flag);
					// Get out of combat mode.
		if (obj == gwin->get_main_actor() && 
			Game::get_game_type() == SERPENT_ISLE &&
							gwin->in_combat())
			gwin->toggle_combat();
					// Show change in status.
		gwin->set_all_dirty();
		break;
	case Obj_flags::invisible:
		if (as_actor(obj))	// Only NPC's for now.
			{
			obj->set_flag(flag);
			gwin->add_dirty(obj);
			}
		break;
	case 0x14:			// The sailor (Ferryman).
		sailor = obj;
	default:
		obj->set_flag(flag);
		if (Is_moving_barge_flag(flag))
			{		// Set barge in motion.
			Barge_object *barge = Get_barge(obj);
			if (barge)
				gwin->set_moving_barge(barge);
			}
			break;
		}
	return(no_ret);
}

USECODE_INTRINSIC(clear_item_flag)
{
	// Clear npc flag(item, flag#).
	Game_object *obj = get_item(parms[0]);
	int flag = parms[1].get_int_value();
	if (obj)
		{
		obj->clear_flag(flag);
		if (flag == Obj_flags::dont_move)
			{	// Show change in status.
			show_pending_text();	// Fixes Lydia-tatoo.
			gwin->set_all_dirty();
			}
		else if (Is_moving_barge_flag(flag))
			{	// Stop barge object is on or part of.
			Barge_object *barge = Get_barge(obj);
			if (barge && barge == gwin->get_moving_barge())
				gwin->set_moving_barge(0);
			}
		else if (flag == 0x14)		// Handles Ferryman
			sailor = 0;
		}
	return(no_ret);
}

USECODE_INTRINSIC(set_path_failure)
{
	// set_path_failure(fun, itemref, eventid) for the last NPC in
	//  a path_run_usecode() call.

	int fun = parms[0].get_int_value(),
	    eventid = parms[2].get_int_value();
	Game_object *item = get_item(parms[1]);
	if (path_npc && item)		// Set in path_run_usecode().
		{
		If_else_path_actor_action *action = 
			path_npc->get_action() ?
			path_npc->get_action()->as_usecode_path() : 0;
		if (action)		// Set in in path action.
			action->set_failure(
				new Usecode_actor_action(fun, item, eventid));
		}
	return no_ret;
}

USECODE_INTRINSIC(fade_palette)
{
	// Fade(cycles?, ??(always 1), in_out (0=fade to black, 1=fade in)).
	int cycles = parms[0].get_int_value();
	int inout = parms[2].get_int_value();
	if (inout == 0)
		show_pending_text();	// Make sure prev. text was seen.
	gwin->get_pal()->fade(cycles, inout);
	return(no_ret);
}

USECODE_INTRINSIC(get_party_list2)
{
	// Return party.  Same as 0x23
	// Probably returns a list of everyone with (or without) some flag
	// List of live chars? Dead chars?
	Usecode_value u(get_party());
	return(u);
}

USECODE_INTRINSIC(set_camera)
{
	// Set_camera(actor)
	Actor *actor = as_actor(get_item(parms[0]));
	if (actor)
		gwin->set_camera_actor(actor);
	return no_ret;
}

USECODE_INTRINSIC(in_combat)
{
	// Are we in combat mode?
	return Usecode_value(gwin->in_combat());
}

USECODE_INTRINSIC(center_view)
{
	// Center view around given item.
	Game_object *obj = get_item(parms[0]);
	if (obj)
		{
		Tile_coord t = obj->get_tile();
		gwin->center_view(t);
		activate_cached(t);	// Mar-10-01 - For Test of Love.
		}
	return no_ret;
}

USECODE_INTRINSIC(get_dead_party)
{
	// Return list of dead companions' bodies.
	int cnt = partyman->get_dead_count();
	Usecode_value ret(cnt, 0);
	for (int i = 0; i < cnt; i++)
		{
		Game_object *body = gwin->get_body(
					partyman->get_dead_member(i));
					// Body within 50 tiles (a guess)?
		if (body && body->distance(gwin->get_main_actor()) < 50)
			{
			Usecode_value v(body);
			ret.put_elem(i, v);
			}
		}
	return ret;
}

USECODE_INTRINSIC(play_sound_effect)
{
	if (num_parms < 1) return(no_ret);
	// Play music(isongnum).
	COUT("Sound effect " << parms[0].get_int_value() << " request in usecode");

	Audio::get_ptr()->play_sound_effect (parms[0].get_int_value());
	return(no_ret);
}

USECODE_INTRINSIC(play_sound_effect2)
{
	if (num_parms < 2) return(no_ret);
	// Play music(songnum, item).
	Game_object *obj = get_item(parms[1]);
	int volume = SDL_MIX_MAXVOLUME;	// Set volume based on distance.
	int dir = 0;
	if (obj)
		{
		Tile_coord apos = gwin->get_main_actor()->get_tile();
		Tile_coord opos = obj->get_tile();
		int dist = apos.distance(opos);
		if (dist)
			{		// 160/8 = 20 tiles. 20*20=400.
			volume = (SDL_MIX_MAXVOLUME*64)/(dist*dist);
			if (volume < 8)
				volume = 8;
			else if (volume > SDL_MIX_MAXVOLUME)
				volume = SDL_MIX_MAXVOLUME;
			dir = Get_direction16(apos.ty - opos.ty,
						opos.tx - apos.tx);
			}
		}
#ifdef DEBUG
	cout << "Sound effect(2) " << parms[0].get_int_value() << 
		" request in usecode with volume = " << volume 
		<< ", dir = " << dir << endl;
#endif
	Audio::get_ptr()->play_sound_effect (parms[0].get_int_value(), volume,
									dir);
	return(no_ret);
}

USECODE_INTRINSIC(get_npc_id)
{
	Actor *actor = as_actor(get_item(parms[0]));
	if (!actor) return(no_ret);
	return Usecode_value (actor->get_ident());
}

USECODE_INTRINSIC(set_npc_id)
{
	Actor *actor = as_actor(get_item(parms[0]));
	if (actor) actor->set_ident(parms[1].get_int_value());
	return(no_ret);
}


USECODE_INTRINSIC(add_cont_items)
{
	// Add items(num, item, ??quality?? (-359), frame (or -359), T/F).
	return add_cont_items(parms[0], parms[1], parms[2],
					parms[3], parms[4], parms[5]);
}

// Is this SI Only
USECODE_INTRINSIC(remove_cont_items)
{
	// Add items(num, item, ??quality?? (-359), frame (or -359), T/F).
	return remove_cont_items(parms[0], parms[1], parms[2],
					parms[3], parms[4], parms[5]);
}

/*
 *	SI-specific functions.
 */

USECODE_INTRINSIC(show_npc_face0)
{
	// Show_npc_face0(npc, frame).  Show in position 0.
	show_npc_face(parms[0], parms[1], 0);
	return no_ret;
}

USECODE_INTRINSIC(show_npc_face1)
{
	// Show_npc_face1(npc, frame).  Show in position 1.
	show_npc_face(parms[0], parms[1], 1);
	return no_ret;
}

USECODE_INTRINSIC(remove_npc_face0)
{
	show_pending_text();
	conv->remove_slot_face(0);
	return no_ret;
}

USECODE_INTRINSIC(remove_npc_face1)
{
	show_pending_text();
	conv->remove_slot_face(1);
	return no_ret;
}

USECODE_INTRINSIC(set_conversation_slot)
{
	// set_conversation_slot(0 or 1) - Choose which face is talking.
	conv->set_slot(parms[0].get_int_value());
	return no_ret;
}

USECODE_INTRINSIC(init_conversation)
{
	init_conversation();
	return no_ret;
}

USECODE_INTRINSIC(end_conversation)
{
	show_pending_text();		// Wait for click if needed.
	conv->init_faces();		// Removes faces from screen.
	gwin->set_all_dirty();
	return no_ret;
}

USECODE_INTRINSIC(si_path_run_usecode)
{
	// exec(npc, loc(x,y,z)?, eventid, itemref, usecode#, ??true/false).
	// Schedule Npc to walk to loc and then execute usecode.
					// Guessing:
	int always = parms[5].get_int_value();
	path_run_usecode(parms[0], parms[1], parms[4], parms[3], parms[2], 1,
							always);
	return no_ret;
}

USECODE_INTRINSIC(error_message)
{
	// exec(array)
	// Output everything to stdout

	for (int i = 0; i < num_parms; i++)
	{
		if (parms[i].is_int()) std::cout << parms[i].get_int_value() ;
		else if (parms[i].is_ptr()) std::cout << parms[i].get_ptr_value();
		else if (!parms[i].is_array()) std::cout << parms[i].get_str_value();
		else for (int j = 0; j < parms[i].get_array_size(); j++)
		{
			if (parms[i].get_elem(j).is_int()) std::cout << parms[i].get_elem(j).get_int_value() ;
			else if (parms[i].get_elem(j).is_ptr()) std::cout << parms[i].get_elem(j).get_ptr_value();
			else if (!parms[i].get_elem(j).is_array()) std::cout << parms[i].get_elem(j).get_str_value();
		}
	}

	std::cout << std::endl;
	return no_ret;
}

USECODE_INTRINSIC(set_polymorph)
{
	// exec(npc, shape).
	// Npc's shape is change to shape.
	Actor *actor = as_actor(get_item(parms[0]));
	if (actor) actor->set_polymorph(parms[1].get_int_value());
	return no_ret;
}

USECODE_INTRINSIC(set_new_schedules)
{
	// set_new_schedules ( npc, time, activity, [x, y] )
	//
	// or
	//
	// set_new_schedules ( npc, [	time1, time2, ...],
	//			[activity1, activity2, ...],
	//			[x1,y1, x2, y2, ...] )
	//

	Actor *actor = as_actor(get_item(parms[0]));

	// If no actor return
	if (!actor) return no_ret;

	int count = parms[1].is_array()?parms[1].get_array_size():1;
	Schedule_change *list = new Schedule_change[count];

	if (!parms[1].is_array())
	{
		int time = parms[1].get_int_value();
		int sched = parms[2].get_int_value();
		int tx = parms[3].get_elem(0).get_int_value();
		int ty = parms[3].get_elem(1).get_int_value();
		list[0].set(tx, ty, sched, time);
	}
	else for (int i = 0; i < count; i++)
	{
		int time = parms[1].get_elem(i).get_int_value();
		int sched = parms[2].get_elem(i).get_int_value();
		int tx = parms[3].get_elem(i*2).get_int_value();
		int ty = parms[3].get_elem(i*2+1).get_int_value();
		list[i].set(tx, ty, sched, time);
	}

	actor->set_schedules(list, count);

	return no_ret;
}

USECODE_INTRINSIC(revert_schedule)
{
	// revert_schedule(npc)
	// Reverts the schedule of the npc to the saved state in
	// <STATIC>/schedule.dat

	Actor *actor = as_actor(get_item(parms[0]));
	if (actor) gwin->revert_schedules(actor);

	return no_ret;
}

USECODE_INTRINSIC(run_schedule)
{
	// run_schedule(npc)
	// I think this is actually reset activity to current
	// scheduled activity - Colourless
	Actor *actor = as_actor(get_item(parms[0]));
	
	if (actor)
	{
		actor->update_schedule(gclock->get_hour()/3, 7);

	}

	return no_ret;
}

USECODE_INTRINSIC(modify_schedule)
{
	// modify_schedule ( npc, time, activity, [x, y] )

	Actor *actor = as_actor(get_item(parms[0]));

	// If no actor return
	if (!actor) return no_ret;

	int time = parms[1].get_int_value();
	int sched = parms[2].get_int_value();
	int tx = parms[3].get_elem(0).get_int_value();
	int ty = parms[3].get_elem(1).get_int_value();

	actor->set_schedule_time_type(time, sched);
	actor->set_schedule_time_location(time, tx, ty);

	return no_ret;
}

USECODE_INTRINSIC(get_temperature)
{
	Actor *npc = as_actor(get_item(parms[0]));
	return Usecode_value(npc ? npc->get_temperature() : 0);
}

USECODE_INTRINSIC(set_temperature)
{
	// set_temperature(npc, value (0-63)).
	Actor *npc = as_actor(get_item(parms[0]));
	if (npc)
		npc->set_temperature(parms[1].get_int_value());
	return no_ret;
}

#if 0	/* +++++Not used at the moment. */
USECODE_INTRINSIC(add_removed_npc)
{
	// move_offscreen(npc, x, y) - I think (seems good) I think
	//
	// returns false if not moved
	// else, moves the object to the closest position off 

	// Actor we want to move
	Actor *actor = as_actor(get_item(parms[0]));

	// Need to check superchunk
	int cx = actor->get_cx();
	int cy = actor->get_cx();
	int scx = cx / c_chunks_per_schunk;
	int scy = cy / c_chunks_per_schunk;
	int scx2 = parms[1].get_int_value() / c_tiles_per_schunk;
	int scy2 = parms[2].get_int_value() / c_tiles_per_schunk;

	// Are the coords are good
	if ( (cx == 0xff && scx2) || (cx != 0xff && scx != scx2) ||
		(cy == 0xff && scy2) || (cy != 0xff && scy != scy2) ) 
		return (Usecode_value(false));


	// Ok they were good, now move it


	// Get the tiles around the edge of the screen
	Rectangle rect = gwin->get_win_tile_rect();

	int sx = rect.x;		// Tile coord of x start
	int ex = rect.x + rect.w;	// Tile coord of x end
	int sy = rect.y;		// y start
	int ey = rect.y + rect.h;	// x end

	// The height of the Actor we are checking
	int height = actor->get_info().get_3d_height();

	int i = 0, nlift = 0;
	int tx, ty;

	// Avatars coords
	Tile_coord av = gwin->get_main_actor()->get_tile();;

	Tile_coord close;	// The tile coords of the closest tile
	int dist = -1;		// The distance

	cy = sy/c_tiles_per_chunk;
	ty = sy%c_tiles_per_chunk;
	cout << "1" << endl;
	for (i = 0; i < rect.w; i++)
	{
		cx = (sx+i)/c_tiles_per_chunk;
		tx = (sx+i)%c_tiles_per_chunk;

		Map_chunk *clist = gmap->get_chunk_safely(cx, cy);
		clist->setup_cache();
		if (!clist->is_blocked (height, 0, tx, ty, nlift, actor->get_type_flags(), 1))
		{
			Tile_coord cur(tx+cx*c_tiles_per_chunk, ty+cy*c_tiles_per_chunk, nlift);
			if (cur.distance(av) < dist || dist == -1)
			{
				dist = cur.distance(av);
				cout << "(" << cur.tx << ", " << cur.ty << ") " << dist << endl;
				close = cur;
			}
		}
	}

	cx = ex/c_tiles_per_chunk;
	tx = ex%c_tiles_per_chunk;
	cout << "2" << endl;
	for (i = 0; i < rect.h; i++)
	{
		cy = (sy+i)/c_tiles_per_chunk;
		ty = (sy+i)%c_tiles_per_chunk;

		Map_chunk *clist = gmap->get_chunk_safely(cx, cy);
		clist->setup_cache();
		if (!clist->is_blocked (height, 0, tx, ty, nlift, actor->get_type_flags(), 1))
		{
			Tile_coord cur(tx+cx*c_tiles_per_chunk, ty+cy*c_tiles_per_chunk, nlift);
			if (cur.distance(av) < dist || dist == -1)
			{
				dist = cur.distance(av);
				cout << "(" << cur.tx << ", " << cur.ty << ") " << dist << endl;
				close = cur;
			}
		}
	}

	cy = ey/c_tiles_per_chunk;
	ty = ey%c_tiles_per_chunk;
	cout << "3" << endl;
	for (i = 0; i < rect.w; i++)
	{
		cx = (ex-i)/c_tiles_per_chunk;
		tx = (ex-i)%c_tiles_per_chunk;

		Map_chunk *clist = gmap->get_chunk_safely(cx, cy);
		clist->setup_cache();
		if (!clist->is_blocked (height, 0, tx, ty, nlift, actor->get_type_flags(), 1))
		{
			Tile_coord cur(tx+cx*c_tiles_per_chunk, ty+cy*c_tiles_per_chunk, nlift);
			if (cur.distance(av) < dist || dist == -1)
			{
				dist = cur.distance(av);
				cout << "(" << cur.tx << ", " << cur.ty << ") " << dist << endl;
				close = cur;
			}
		}
	}

	cx = sx/c_tiles_per_chunk;
	tx = sx%c_tiles_per_chunk;
	cout << "4" << endl;
	for (i = 0; i < rect.h; i++)
	{
		cy = (ey-i)/c_tiles_per_chunk;
		ty = (ey-i)%c_tiles_per_chunk;

		Map_chunk *clist = gmap->get_chunk_safely(cx, cy);
		clist->setup_cache();
		if (!clist->is_blocked (height, 0, tx, ty, nlift, actor->get_type_flags(), 1))
		{
			Tile_coord cur(tx+cx*c_tiles_per_chunk, ty+cy*c_tiles_per_chunk, nlift);
			if (cur.distance(av) < dist || dist == -1)
			{
				dist = cur.distance(av);
				cout << "(" << cur.tx << ", " << cur.ty << ") " << dist << endl;
				close = cur;
			}
		}
	}

	if (dist != -1)
	{
		actor->move(close);
		return (Usecode_value(true));
	}

	return (Usecode_value(false));
}
#endif

USECODE_INTRINSIC(approach_avatar)
{
	// Approach_avatar(npc, ?, ?).
	// Actor we want to move
	Actor *actor = as_actor(get_item(parms[0]));
	if (!actor || actor->is_dead())
		return Usecode_value(0);
					// Guessing!! If already close...
	if (actor->distance(gwin->get_main_actor()) < 10)
		return Usecode_value(1);
					// Approach, and wait.
	if (!actor->approach_another(gwin->get_main_actor(), true))
		return Usecode_value(0);
	return Usecode_value(1);
	}

USECODE_INTRINSIC(set_barge_dir)
{
	// set_barge_dir(barge, dir (0-7)).
	Game_object *obj = get_item(parms[0]);
	int dir = parms[1].get_int_value();
	Barge_object *barge = obj ? obj->as_barge() : 0;
	if (barge)
		barge->face_direction(dir);
	return no_ret;
}

USECODE_INTRINSIC(telekenesis)
{
	// telekenesis(fun#) - Save item for executing Usecode on.
	telekenesis_fun = parms[0].get_int_value();
	return no_ret;
}

USECODE_INTRINSIC(a_or_an)
{
	// a_or_an (word)
	// return a/an depending on 'word'

	if (strchr("aeiouyAEIOUY", (parms[0].get_str_value())[0]) == 0)
		return (Usecode_value("a"));
	else
		return (Usecode_value("an"));

}

USECODE_INTRINSIC(remove_from_area)
{
	// Remove_from_area(shapenum, framenum, [x,y]from, [x,y]to).
	int shnum = parms[0].get_int_value(), frnum = parms[1].get_int_value();
	int fromx = parms[2].get_elem(0).get_int_value(),
	    fromy = parms[2].get_elem(1).get_int_value(),
	    tox   = parms[3].get_elem(0).get_int_value(),
	    toy   = parms[3].get_elem(1).get_int_value();
	Rectangle area(fromx, fromy, tox - fromx + 1, toy - fromy + 1);
	if (area.w <= 0 || area.h <= 0)
		return no_ret;
	Game_object_vector vec;		// Find objects.
	Map_chunk::find_in_area(vec, area, shnum, frnum);
					// Remove them.
	for (Game_object_vector::iterator it = vec.begin(); it != vec.end();
								it++)
		{
		Game_object *obj = *it;
		gwin->add_dirty(obj);
		obj->remove_this(0);
		}
	return no_ret;
}

USECODE_INTRINSIC(infravision)
{
	// infravision(npc, onoff)
	Actor *npc = as_actor(get_item(parms[0]));
	if (npc && npc->is_in_party())
		{
		if (parms[1].get_int_value())
			{		// On?
			cheat.set_infravision(true);
			gwin->get_pal()->set(0);
			}
		else
			{
			cheat.set_infravision(false);
			gclock->set_palette();
			}
		}
	return no_ret;
}

// parms[0] = quality of key to be added
USECODE_INTRINSIC(add_to_keyring)
{
	getKeyring()->addkey(parms[0].get_int_value());

	return no_ret;
}

// parms[0] = quality of key to check
// returns true if key is on keyring

USECODE_INTRINSIC(is_on_keyring)
{
	if (getKeyring()->checkkey(parms[0].get_int_value()))
		return Usecode_value(true);
	else
		return Usecode_value(false);
}

USECODE_INTRINSIC(save_pos)
{
	// save_pos(item).
	Game_object *item = get_item(parms[0]);
	if (item)
		saved_pos = item->get_tile();
	return no_ret;
}

USECODE_INTRINSIC(teleport_to_saved_pos)
{
	// teleport_to_saved_pos(actor).  Only supported for Avatar for now.
	Actor *npc = as_actor(get_item(parms[0]));
	if (npc == gwin->get_main_actor())
		{			// Bad value?
		if (saved_pos.tx < 0 || saved_pos.tx >= c_num_tiles)
					// Fix old games.  Send to Monitor.
			saved_pos = Tile_coord(719, 2608, 1);
		gwin->teleport_party(saved_pos);
		}
	return no_ret;
}

USECODE_INTRINSIC(get_item_usability)
{
	// Complete guess:  Returns 1 for grabbable items (for fetch spell).
	Game_object *obj = get_item(parms[0]);
	if (!obj || !obj->is_dragable())
		return Usecode_value(0);
	else
		return Usecode_value(1);// Only 1 I'm pretty sure of.
}

USECODE_INTRINSIC(get_skin_colour)
{
	// Gets skin colour of avatar. 0 (wh), 1 (br) or 2 (bl)
	Main_actor *av = gwin->get_main_actor();
	return Usecode_value(av->get_skin_color());
}

/*
 *	This is like the C version, but only '%s' is supported, and all the
 *	parms should be packed into one array.
 *	Added for Exult.
 */
USECODE_INTRINSIC(printf)
{
	Usecode_value ret("");
	const char *fmt = parms[0].get_elem0().get_str_value();
	int count;
	cout << endl;			// For now...
	if (!fmt || (count = parms[0].get_array_size()) <= 1)
		{
		parms[0].print(cout);
		return ret;
		}
	int i = 1;			// Parm. #.
	while (*fmt)
		{
		const char *spec = strchr(fmt, '%');
		if (!spec)
			spec = fmt + std::strlen(fmt);
		cout.write(fmt, spec - fmt);
		if (*spec == '%')
			{
			if (spec[1] == 's')
				{
				Usecode_value p = i < count ? parms[0][i]
							: Usecode_value(0);
				if (p.get_type() == Usecode_value::int_type)
					cout << p.get_int_value();
				else
					p.print(cout);
				spec += 2;
				}
			else
				{
				cout << '%';
				spec++;
				}
			}
		fmt = spec;
		}
	return ret;
}