scummvm-cursorfix/engines/ultima/nuvie/core/effect.cpp

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#include "ultima/nuvie/core/nuvie_defs.h"
#include "ultima/nuvie/core/game.h"
#include "ultima/nuvie/actors/actor.h"
#include "ultima/nuvie/core/map.h"
#include "ultima/nuvie/core/party.h"
#include "ultima/nuvie/script/script.h"
#include "ultima/nuvie/core/anim_manager.h"
#include "ultima/nuvie/gui/widgets/map_window.h"
#include "ultima/nuvie/core/tile_manager.h"
#include "ultima/nuvie/core/game_clock.h"
#include "ultima/nuvie/core/effect_manager.h"
#include "ultima/nuvie/usecode/usecode.h"
#include "ultima/nuvie/gui/widgets/msg_scroll.h"
#include "ultima/nuvie/actors/actor_manager.h"
#include "ultima/nuvie/sound/sound_manager.h"
#include "ultima/nuvie/core/u6_objects.h"
#include "ultima/nuvie/core/effect.h"
#include "ultima/nuvie/core/player.h"

#include "backends/keymapper/keymapper.h"

namespace Ultima {
namespace Nuvie {

#define MESG_ANIM_HIT_WORLD  ANIM_CB_HIT_WORLD
#define MESG_ANIM_HIT        ANIM_CB_HIT
#define MESG_ANIM_DONE       ANIM_CB_DONE
#define MESG_EFFECT_COMPLETE EFFECT_CB_COMPLETE
//#define MESG_INPUT_READY     EVENT_CB_INPUT_READY
#define MESG_INPUT_READY     MSGSCROLL_CB_TEXT_READY

#define TRANSPARENT_COLOR 0xFF /* transparent pixel color */

static const int EXP_EFFECT_TILE_NUM = 382;

QuakeEffect *QuakeEffect::current_quake = nullptr;
FadeEffect *FadeEffect::current_fade = nullptr;


/* Add self to effect list (for future deletion).
 */
Effect::Effect() : defunct(false), retain_count(0) {
	game = Game::get_game();
	effect_manager = game->get_effect_manager();
	effect_manager->add_effect(this);
}


Effect::~Effect() {
	// FIXME: should we remove self from Callbacks' default targets?
}


/* Start managing new animation. (AnimMgr will do that actually, but we point to
 * it and can stop it when necessary)
 */
void Effect::add_anim(NuvieAnim *anim) {
	anim->set_target(this); // add self as callback target for anim
	game->get_map_window()->get_anim_manager()->new_anim(anim);
}


static const int CANNON_SPEED = 320;

/* Fire from a cannon in direction: 0=north, 1=east, 2=south, 3=west,
 *                                 -1=use cannon frame
 */
CannonballEffect::CannonballEffect(Obj *src_obj, sint8 direction)
	: obj(src_obj) {
	usecode = game->get_usecode();
	target_loc = MapCoord(obj->x, obj->y, obj->z);

	if (direction == -1)
		direction = obj->frame_n;

	uint8 target_dist = 5; // distance that cannonball will fly
	if (direction == NUVIE_DIR_N)
		target_loc.y -= target_dist;
	else if (direction == NUVIE_DIR_E)
		target_loc.x += target_dist;
	else if (direction == NUVIE_DIR_S)
		target_loc.y += target_dist;
	else if (direction == NUVIE_DIR_W)
		target_loc.x -= target_dist;

	start_anim();
}


/* Pause world & start animation. */
void CannonballEffect::start_anim() {
	MapCoord obj_loc(obj->x, obj->y, obj->z);

	game->pause_world();
	game->pause_anims();
	game->pause_user();

	anim = new TossAnim(game->get_tile_manager()->get_tile(399),
	                    obj_loc, target_loc, CANNON_SPEED, TOSS_TO_BLOCKING | TOSS_TO_ACTOR | TOSS_TO_OBJECT);
	add_anim(anim);
}


/* Handle messages from animation. Hit actors & walls. */
uint16 CannonballEffect::callback(uint16 msg, CallBack *caller, void *msg_data) {
	bool stop_effect = false;
	Actor *hit_actor = nullptr;

	switch (msg) {
	case MESG_ANIM_HIT_WORLD: {
		const MapCoord *hit_loc = static_cast<const MapCoord *>(msg_data);
		const Tile *obj_tile = game->get_obj_manager()->get_obj_tile(hit_loc->x, hit_loc->y, hit_loc->z);
		const Tile *tile = game->get_game_map()->get_tile(hit_loc->x, hit_loc->y,
		             hit_loc->z);

		if ((tile->flags2 & TILEFLAG_MISSILE_BOUNDARY)
		        || (obj_tile && (obj_tile->flags2 & TILEFLAG_MISSILE_BOUNDARY))) {
			//new ExplosiveEffect(hit_loc->x, hit_loc->y, 2);
			new ExpEffect(EXP_EFFECT_TILE_NUM, *hit_loc);
			stop_effect = true;
		}
		break;
	}
	case MESG_ANIM_HIT: {
		MapEntity *hit_ent = static_cast<MapEntity *>(msg_data);
		if (hit_ent->entity_type == ENT_ACTOR) {
			//hit_ent->actor->hit(32);
			hit_actor = hit_ent->actor;
			stop_effect = true;
		}
		if (hit_ent->entity_type == ENT_OBJ) {
			DEBUG(0, LEVEL_DEBUGGING, "hit object %d at %x,%x,%x\n", hit_ent->obj->obj_n, hit_ent->obj->x, hit_ent->obj->y, hit_ent->obj->z);
			// FIX: U6 specific
			// FIX: hit any part of ship, and reduce qty of center
			if (hit_ent->obj->obj_n == 412) {
				uint8 f = hit_ent->obj->frame_n;
				if (f == 9 || f == 15 || f == 11 || f == 13) { // directions
					if (hit_ent->obj->qty < 20) hit_ent->obj->qty = 0;
					else                      hit_ent->obj->qty -= 20;
					if (hit_ent->obj->qty == 0)
						game->get_scroll()->display_string("Ship broke!\n");
					stop_effect = true;
				}
			}
		}
		break;
	}
	case MESG_ANIM_DONE:
		//new ExplosiveEffect(target_loc.x, target_loc.y, 3);
		new ExpEffect(EXP_EFFECT_TILE_NUM, MapCoord(target_loc.x, target_loc.y, target_loc.z));
		stop_effect = true;
		break;
	}

	if (stop_effect) {
		if (hit_actor) {
			anim->pause(); //pause to avoid recursive problems when animations are called from actor_hit() lua script.
			Game::get_game()->get_script()->call_actor_hit(hit_actor, 32, true);
		}
		if (msg != MESG_ANIM_DONE) // this msg means anim stopped itself
			anim->stop();
		game->unpause_all();
		usecode->message_obj(obj, MESG_EFFECT_COMPLETE, this);
		delete_self();
	}
	return 0;
}

#define EXP_EFFECT_SPEED 3


ExpEffect::ExpEffect(uint16 tileNum, const MapCoord &location) : ProjectileEffect(),
		exp_tile_num(tileNum) {
	start_loc = location;
	start_anim();
}


/* Pause world & start animation. */
void ExpEffect::start_anim() {
	game->pause_world();
	game->pause_anims();
	game->pause_user();

	targets.resize(16);

	targets[0] = MapCoord(start_loc.x + 2, start_loc.y - 1, start_loc.z);
	targets[1] = MapCoord(start_loc.x + 1, start_loc.y + 2, start_loc.z);
	targets[2] = MapCoord(start_loc.x, start_loc.y - 2, start_loc.z);

	targets[3] = MapCoord(start_loc.x + 1, start_loc.y - 1, start_loc.z);
	targets[4] = MapCoord(start_loc.x - 1, start_loc.y + 2, start_loc.z);
	targets[5] = MapCoord(start_loc.x - 1, start_loc.y - 1, start_loc.z);

	targets[6] = MapCoord(start_loc.x - 2, start_loc.y, start_loc.z);
	targets[7] = MapCoord(start_loc.x - 1, start_loc.y + 1, start_loc.z);
	targets[8] = MapCoord(start_loc.x, start_loc.y + 2, start_loc.z);

	targets[9] = MapCoord(start_loc.x - 1, start_loc.y - 2, start_loc.z);
	targets[10] = MapCoord(start_loc.x - 2, start_loc.y - 1, start_loc.z);
	targets[11] = MapCoord(start_loc.x - 2, start_loc.y + 1, start_loc.z);

	targets[12] = MapCoord(start_loc.x + 2, start_loc.y + 1, start_loc.z);
	targets[13] = MapCoord(start_loc.x + 2, start_loc.y, start_loc.z);
	targets[14] = MapCoord(start_loc.x + 1, start_loc.y + 1, start_loc.z);
	targets[15] = MapCoord(start_loc.x + 1, start_loc.y - 2, start_loc.z);


	anim = new ProjectileAnim(exp_tile_num, &start_loc, targets, EXP_EFFECT_SPEED, true);
	add_anim(anim);

}

ProjectileEffect::ProjectileEffect(uint16 tileNum, MapCoord start, MapCoord target, uint8 speed, bool trailFlag, uint16 initialTileRotation, uint16 rotationAmount, uint8 src_y_offset) {
	vector<MapCoord> t;
	t.push_back(target);

	init(tileNum, start, t, speed, trailFlag, initialTileRotation, rotationAmount, src_y_offset);
}

ProjectileEffect::ProjectileEffect(uint16 tileNum, MapCoord start, const vector<MapCoord> &t, uint8 speed, bool trailFlag, uint16 initialTileRotation) {
	init(tileNum, start, t, speed, trailFlag, initialTileRotation, 0, 0);
}

void ProjectileEffect::init(uint16 tileNum, MapCoord start, const vector<MapCoord> &t, uint8 speed, bool trailFlag, uint16 initialTileRotation, uint16 rotationAmount, uint8 src_y_offset) {
	finished_tiles = 0;

	tile_num = tileNum;
	start_loc = start;
	anim_speed = speed;
	trail = trailFlag;
	initial_tile_rotation = initialTileRotation;
	rotation_amount = rotationAmount;

	src_tile_y_offset = src_y_offset;
	targets = t;

	start_anim();
}

/* Pause world & start animation. */
void ProjectileEffect::start_anim() {
	game->pause_world();
	//game->pause_anims();
	game->pause_user();

	add_anim(new ProjectileAnim(tile_num, &start_loc, targets, anim_speed, trail, initial_tile_rotation, rotation_amount, src_tile_y_offset));

}
/* Handle messages from animation. Hit actors & walls. */
uint16 ProjectileEffect::callback(uint16 msg, CallBack *caller, void *msg_data) {
	bool stop_effect = false;
	switch (msg) {
	case MESG_ANIM_HIT_WORLD: {
		MapCoord *hit_loc = static_cast<MapCoord *>(msg_data);
		const Tile *tile = game->get_game_map()->get_tile(hit_loc->x, hit_loc->y,
		             hit_loc->z);
		if (tile->flags1 & TILEFLAG_WALL) {
			//new ExplosiveEffect(hit_loc->x, hit_loc->y, 2);
			stop_effect = true;
		}
		break;
	}
	case MESG_ANIM_HIT: {
		MapEntity *hit_ent = static_cast<MapEntity *>(msg_data);
		hit_entities.push_back(*hit_ent);
		break;
	}
	case MESG_ANIM_DONE:
		//new ExplosiveEffect(target_loc.x, target_loc.y, 3);
		stop_effect = true;
		break;
	}

	if (stop_effect) {
		//finished_tiles++;

		if (msg != MESG_ANIM_DONE) // this msg means anim stopped itself
			((NuvieAnim *)caller)->stop();
		//if(finished_tiles == 16)
		// {
		game->unpause_world();
		game->unpause_user();
		game->unpause_anims();
		//usecode->message_obj(obj, MESG_EFFECT_COMPLETE, this);
		delete_self();
		// }
	}
	return 0;
}


/*** TimedEffect ***/
void TimedEffect::start_timer(uint32 delay) {
	if (!timer)
		timer = new TimedCallback(this, nullptr, delay, true);
}


void TimedEffect::stop_timer() {
	if (timer) {
		timer->clear_target();
		timer = nullptr;
	}
}


/*** QuakeEffect ***/
/* Shake the visible play area around for `duration' milliseconds. Magnitude
 * determines the speed of movement. An actor may be selected to keep the
 * MapWindow centered on after the Quake.
 */
QuakeEffect::QuakeEffect(uint8 magnitude, uint32 duration, Actor *keep_on)
		: strength(magnitude), orig_actor(keep_on), sx(0), sy(0),
		  map_window(nullptr), stop_time(0) {
	// single use only, so MapWindow doesn't keep moving away from center
	// ...and do nothing if magnitude isn't usable
	if (current_quake || magnitude == 0) {
		delete_self();
		return;
	}
	current_quake = this; // cleared in timer function

	map_window = game->get_map_window();
	stop_time = game->get_clock()->get_ticks() + duration;

	// get random direction (always move left-right more than up-down)
	init_directions();

	map_window->get_pos(&orig.x, &orig.y);
	map_window->get_level(&orig.z);
	map_window->set_freeze_blacking_location(true);

	start_timer(strength * 5);
}


QuakeEffect::~QuakeEffect() {
}


/* On TIMED: Move map.
 */
uint16 QuakeEffect::callback(uint16 msg, CallBack *caller, void *msg_data) {
	//  uint8 twice_strength = strength * 2;
	if (msg != MESG_TIMED)
		return 0;
	if (game->get_clock()->get_ticks() >= stop_time) {
		stop_quake();
		return 0;
	}
	recenter_map();
	map_window->shiftMapRelative(sx, sy);

	// move in opposite direction on next call
	if (sx == -(4 * strength) || sx == (4 * strength))
		sx = (sx == -(4 * strength)) ? (2 * strength) : -(2 * strength);
	else if (sx == -(2 * strength) || sx == (2 * strength))
		sx = 0;

	if (sy == -(2 * strength) || sy == (2 * strength))
		sy = 0;

	if (sx == 0 && sy == 0)
		init_directions();
	return 0;
}


/* Finish effect. Move map back to initial position.
 */
void QuakeEffect::stop_quake() {
	current_quake = nullptr;
	map_window->set_freeze_blacking_location(false);
	recenter_map();
	delete_self();
}


/* Set sx,sy to a random direction. (always move left-right more than up-down)
 */
void QuakeEffect::init_directions() {
	NuvieDir dir = static_cast<NuvieDir>(NUVIE_RAND() % 8);
	sx = 0;
	sy = 0;

	switch (dir) {
	default: // can't happen, but make the analyzer happy.
	case NUVIE_DIR_N :
		sy = -(strength * 2);
		break;
	case NUVIE_DIR_NE :
		sx = (strength * 4);
		sy = -(strength * 2);
		break;
	case NUVIE_DIR_E :
		sx = (strength * 4);
		break;
	case NUVIE_DIR_SE :
		sx = (strength * 4);
		sy = (strength * 2);
		break;
	case NUVIE_DIR_S :
		sy = (strength * 2);
		break;
	case NUVIE_DIR_SW :
		sx = -(strength * 4);
		sy = (strength * 2);
		break;
	case NUVIE_DIR_W :
		sx = -(strength * 4);
		break;
	case NUVIE_DIR_NW :
		sx = -(strength * 4);
		sy = -(strength * 2);
		break;
	}
}


/* Center map on original actor or move to original location.
 */
void QuakeEffect::recenter_map() {
	if (orig_actor)
		map_window->centerMapOnActor(orig_actor);
	else
		map_window->moveMap(orig.x, orig.y, orig.z);
}


/*** HitEffect ***/
/* Hit target actor. FIXME: implement duration and hitting a location
 */
HitEffect::HitEffect(Actor *target, uint32 duration) {
	game->pause_user();
	add_anim(new HitAnim(target));
	Game::get_game()->get_sound_manager()->playSfx(NUVIE_SFX_HIT); //FIXME use NUVIE_SFX_SAMPLE defines here.
}

HitEffect::HitEffect(const MapCoord &location) {
	game->pause_user();
	add_anim(new HitAnim(location));
	Game::get_game()->get_sound_manager()->playSfx(NUVIE_SFX_HIT); //FIXME use NUVIE_SFX_SAMPLE defines here.
}

/* On ANIM_DONE: end
 */
uint16 HitEffect::callback(uint16 msg, CallBack *caller, void *msg_data) {
	if (msg == MESG_ANIM_DONE) {
		game->unpause_user();
		delete_self();
	}
	return 0;
}

TextEffect::TextEffect(Std::string text) { // default somewhat centered on player for cheat messages
	const MapWindow *map_window = game->get_map_window();
	if (!map_window || map_window->Status() != WIDGET_VISIBLE) // scripted sequence like intro and intro menu
		return;
	MapCoord loc = game->get_player()->get_actor()->get_location();
	loc.x = (loc.x - map_window->get_cur_x() - 2) * 16;
	loc.y = (loc.y - map_window->get_cur_y() - 1) * 16;

	add_anim(new TextAnim(text, loc, 1500));
}

/*** TextEffect ***/
/* Print Text to MapWindow for duration
 */
TextEffect::TextEffect(Std::string text, const MapCoord &location) {
	add_anim(new TextAnim(text, location, 1500));
}

/* On ANIM_DONE: end
 */
uint16 TextEffect::callback(uint16 msg, CallBack *caller, void *msg_data) {
	if (msg == MESG_ANIM_DONE) {
		delete_self();
	}
	return 0;
}

/*** ExplosiveEffect ***/
ExplosiveEffect::ExplosiveEffect(uint16 x, uint16 y, uint32 size, uint16 dmg)
	: start_at(), anim(nullptr) {
	start_at.x = x;
	start_at.y = y;
	radius = size;
	hit_damage = dmg;

	start_anim();
}


/* Pause world & start animation.
 */
void ExplosiveEffect::start_anim() {
	game->pause_world();
	game->pause_user();
	add_anim(new ExplosiveAnim(start_at, radius));
}


/* Handle messages from animation. Hit actors & objects.
 */
uint16 ExplosiveEffect::callback(uint16 msg, CallBack *caller, void *msg_data) {
	bool stop_effect = false;
	switch (msg) {
	case MESG_ANIM_HIT: {
		MapEntity *hit_ent = static_cast<MapEntity *>(msg_data);
		if (hit_ent->entity_type == ENT_ACTOR) {
			if (hit_damage != 0) // hit actor if effect causes damage
				hit_ent->actor->hit(hit_damage);
		} else if (hit_ent->entity_type == ENT_OBJ) {
			DEBUG(0, LEVEL_DEBUGGING, "Explosion hit object %d (%x,%x)\n", hit_ent->obj->obj_n, hit_ent->obj->x, hit_ent->obj->y);
			stop_effect = hit_object(hit_ent->obj);
		}
		break;
	}
	case MESG_ANIM_DONE:
		stop_effect = true;
		break;
	}

	if (stop_effect) {
		if (msg != MESG_ANIM_DONE)
			anim->stop();
		game->unpause_world();
		game->unpause_user();
		delete_self();
	}
	return 0;
}


/* UseCodeExplosiveEffect: before deleting send message to source object
 */
void UseCodeExplosiveEffect::delete_self() {
	if (obj)
		game->get_usecode()->message_obj(obj, MESG_EFFECT_COMPLETE, this);
	Effect::delete_self();
}


/* The explosion hit an object.
 * Returns true if the effect should end, false to continue.
 */
bool UseCodeExplosiveEffect::hit_object(Obj *hit_obj) {
	// ignite & destroy powder kegs (U6)
	if (hit_obj->obj_n == 223 && hit_obj != original_obj) {
		// FIXME: this doesn't belong here (U6/obj specific)
		uint16 x = hit_obj->x, y = hit_obj->y;
		game->get_obj_manager()->remove_obj_from_map(hit_obj);
		delete_obj(hit_obj);
		if (obj) // pass our source obj on to next effect as original_obj
			new UseCodeExplosiveEffect(nullptr, x, y, 2, hit_damage, obj);
		else // pass original_obj on to next effect
			new UseCodeExplosiveEffect(nullptr, x, y, 2, hit_damage, original_obj);
	}
	return false;
}


/*** ThrowObjectEffect ***/
ThrowObjectEffect::ThrowObjectEffect() {
	obj_manager = game->get_obj_manager();

	anim = nullptr;
	throw_obj = nullptr;
	throw_tile = nullptr;
	throw_speed = 0;
	degrees = 0;
	stop_flags = 0;
}


void ThrowObjectEffect::start_anim() {
	game->pause_anims();
	game->pause_world();
	game->pause_user();

	assert(throw_tile || throw_obj); // make sure it was properly initialized
	assert(throw_speed != 0);

	if (throw_obj)
		anim = new TossAnim(throw_obj, degrees, start_at, stop_at, throw_speed, stop_flags);
	else
		anim = new TossAnim(throw_tile, start_at, stop_at, throw_speed, stop_flags);
	add_anim(anim);
}


/* Object has stopped. */
void ThrowObjectEffect::hit_target() {
	if (anim)
		anim->stop();
	game->unpause_all();
	delete_self();
}


/* The animation will travel from original object location to drop location if
 * nullptr actor is specified.
 */
DropEffect::DropEffect(Obj *obj, uint16 qty, Actor *actor, MapCoord *drop_loc) {
	drop_from_actor = actor;
	start_at = drop_from_actor ? drop_from_actor->get_location() : MapCoord(obj->x, obj->y, obj->z);
	stop_at = *drop_loc;
	degrees = 90;

	get_obj(obj, qty); // remove from actor, set throw_obj

	if (start_at != stop_at) {
		throw_speed = 192; // animation speed
		start_anim();
	} else
		hit_target(); // done already? why bother calling DropEffect? :p
}


/* Take `qty' objects of a stack if necessary, and remove from the actor's
 * inventory. Set `throw_obj'.
 */
void DropEffect::get_obj(Obj *obj, uint16 qty) {
	throw_obj = obj_manager->get_obj_from_stack(obj, qty);
	if (drop_from_actor)
		drop_from_actor->inventory_remove_obj(throw_obj);
}


/* On ANIM_HIT_WORLD: end at hit location
 * On ANIM_DONE: end
 */
uint16 DropEffect::callback(uint16 msg, CallBack *caller, void *msg_data) {
	// if throw_obj is nullptr, object already hit target
	if (!throw_obj || (msg != MESG_ANIM_DONE && msg != MESG_ANIM_HIT_WORLD))
		return 0;

	if (msg == MESG_ANIM_HIT_WORLD && stop_at == *(MapCoord *)msg_data
	        && anim)
		anim->stop();

	hit_target();
	return 0;
}


/* Add object to map. (call before completing effect) */
void DropEffect::hit_target() {
	throw_obj->x = stop_at.x;
	throw_obj->y = stop_at.y;
	throw_obj->z = stop_at.z;

	//FIXME drop logic should probably be in lua script.
	if (drop_from_actor && obj_manager->is_breakable(throw_obj) && start_at.distance(stop_at) > 1) {
		nuvie_game_t game_type = game->get_game_type();
		if (game_type == NUVIE_GAME_U6 && throw_obj->obj_n == OBJ_U6_DRAGON_EGG) {
			throw_obj->frame_n = 1; //brake egg.
			obj_manager->add_obj(throw_obj, OBJ_ADD_TOP);
		} else if (game_type == NUVIE_GAME_U6 && throw_obj->obj_n == OBJ_U6_MIRROR) {
			throw_obj->frame_n = 2; //break mirror.
			obj_manager->add_obj(throw_obj, OBJ_ADD_TOP);
		} else {
			// remove items from container if there is one
			if (game->get_usecode()->is_container(throw_obj)) {
				U6Link *link = throw_obj->container->start();
				for (; link != nullptr; link = throw_obj->container->start()) {
					Obj *obj = (Obj *)link->data;
					obj_manager->moveto_map(obj, stop_at);
				}
			}
			obj_manager->unlink_from_engine(throw_obj);
			delete_obj(throw_obj);
		}

		Game::get_game()->get_scroll()->display_string("\nIt broke!\n");
		Game::get_game()->get_sound_manager()->playSfx(NUVIE_SFX_BROKEN_GLASS);
	} else {
		Obj *dest_obj = obj_manager->get_obj(stop_at.x, stop_at.y, stop_at.z);
		if (obj_manager->can_store_obj(dest_obj, throw_obj))
			obj_manager->moveto_container(throw_obj, dest_obj);
		else
			obj_manager->add_obj(throw_obj, OBJ_ADD_TOP);
	}
	throw_obj = nullptr; // set as dropped

	// not appropriate to do "Events::endAction(true)" from here to display
	// prompt, as we MUST unpause_user() in ThrowObjectEffect::hit_target, and
	// that would be redundant and may not unpause everything if wait mode was
	// already cancelled... so just prompt
	game->get_scroll()->display_string("\n");
	game->get_scroll()->display_prompt();

	game->get_map_window()->updateBlacking();
	ThrowObjectEffect::hit_target(); // calls delete_self()
}


/*** MissileEffect ***/
MissileEffect::MissileEffect(uint16 tile_num, uint16 obj_n, const MapCoord &source,
							 const MapCoord &target, uint8 dmg,
							 uint8 intercept, uint16 speed) {
	actor_manager = game->get_actor_manager();
	hit_actor = 0;
	hit_obj = 0;

	init(tile_num, obj_n, source, target, dmg, intercept, speed);
}

/* Start effect. If target is unset then the actor is the target. */
void MissileEffect::init(uint16 tile_num, uint16 obj_n,
						 const MapCoord &source, const MapCoord &target,
						 uint32 dmg, uint8 intercept, uint32 speed) {
	assert(tile_num || obj_n); // at least obj_n must be set
	// (although it might work if throw_obj is already set)
	assert(speed != 0);
	assert(intercept != 0); // must hit target

	if (obj_n != 0)
		throw_obj = new_obj(obj_n, 0, 0, 0, 0);
	if (tile_num != 0)
		throw_tile = game->get_tile_manager()->get_tile(tile_num);
	else if (throw_obj != 0)
		throw_tile = obj_manager->get_obj_tile(throw_obj->obj_n, 0);
	throw_speed = speed;
	hit_damage = dmg;

	start_at = source;
	stop_at = target;
	stop_flags = intercept;
	assert(stop_at != start_at); // Hmm, can't attack self with boomerang then
//    if (stop_at != start_at) {
//      start_at.x=WRAPPED_COORD(start_at.x+1,start_at.z);
//      start_at.y=WRAPPED_COORD(start_at.y-1,start_at.z);
//    }

	// set tile rotation here based on obj_num
	if (throw_obj != 0) {
		if (throw_obj->obj_n == OBJ_U6_SPEAR)
			degrees = 315;
		if (throw_obj->obj_n == OBJ_U6_THROWING_AXE)
			degrees = 0;
		if (throw_obj->obj_n == OBJ_U6_DAGGER)
			degrees = 315;
		if (throw_obj->obj_n == OBJ_U6_ARROW)
			degrees = 270;
		if (throw_obj->obj_n == OBJ_U6_BOLT)
			degrees = 270;
	}
	start_anim();
}

/* On HIT: hit Actor or Obj and end
 * On HIT_WORLD: end at hit location, hit Actor or Obj, else place obj
 * On DONE: end
 */
uint16 MissileEffect::callback(uint16 msg, CallBack *caller, void *msg_data) {
	if (msg != MESG_ANIM_DONE && msg != MESG_ANIM_HIT_WORLD && msg != MESG_ANIM_HIT)
		return 0;

	if (msg == MESG_ANIM_DONE) {
		// will always hit anything at the target
		// FIXME: only hit breakable objects like doors
//        hit_obj = obj_manager->get_obj(stop_at.x,stop_at.y,stop_at.z);
		hit_actor = actor_manager->get_actor(stop_at.x, stop_at.y, stop_at.z);
		hit_target();
	} else if (msg == MESG_ANIM_HIT && ((MapEntity *)msg_data)->entity_type == ENT_ACTOR) {
		if (hit_damage != 0)
			hit_actor = ((MapEntity *)msg_data)->actor;
		hit_target();
	} else if (msg == MESG_ANIM_HIT && ((MapEntity *)msg_data)->entity_type == ENT_OBJ) {
		// FIXME: only hit breakable objects like doors
		/*        if(hit_damage != 0)
		            hit_obj = ((MapEntity*)msg_data)->obj;
		        hit_target();*/
	}
	// MESG_ANIM_HIT_WORLD
	hit_blocking();
	return 0;
}

/* Hit target or add object to map. (call before completing effect) */
void MissileEffect::hit_target() {
	if (hit_actor) {
		hit_actor->hit(hit_damage, ACTOR_FORCE_HIT);
		delete_obj(throw_obj);
		throw_obj = 0; // don't drop
	} else if (hit_obj) {
		if (hit_obj->qty < hit_damage)
			hit_obj->qty = 0;
		else hit_obj->qty -= hit_damage;
		delete_obj(throw_obj);
		throw_obj = 0; // don't drop
	}
	if (throw_obj != 0) {
		throw_obj->x = stop_at.x;
		throw_obj->y = stop_at.y;
		throw_obj->z = stop_at.z;
		throw_obj->status |= OBJ_STATUS_OK_TO_TAKE | OBJ_STATUS_TEMPORARY;
		if (obj_manager->is_stackable(throw_obj))
			throw_obj->qty = 1; // stackable objects must have a quantity
		obj_manager->add_obj(throw_obj, OBJ_ADD_TOP);
		throw_obj = 0;
	}

	ThrowObjectEffect::hit_target(); // calls delete_self()
}

void MissileEffect::hit_blocking() {
	delete_obj(throw_obj);
	ThrowObjectEffect::hit_target();
}


/*** SleepEffect ***/
/* The TimedAdvance is started after the fade-out completes. */
SleepEffect::SleepEffect(Std::string until)
	: timer(nullptr),
	  stop_hour(0),
	  stop_minute(0),
	  stop_time("") {
	stop_time = until;
	game->pause_user();
	effect_manager->watch_effect(this, new FadeEffect(FADE_PIXELATED, FADE_OUT));
}


SleepEffect::SleepEffect(uint8 to_hour)
	: timer(nullptr),
	  stop_hour(to_hour),
	  stop_minute(0),
	  stop_time("") {
	game->pause_user();
	effect_manager->watch_effect(this, new FadeEffect(FADE_PIXELATED, FADE_OUT));
}


SleepEffect::~SleepEffect() {
	//if(timer) // make sure it doesn't try to call us again
	//    timer->clear_target();
}


/* As with TimedEffect, make sure the timer doesn't try to use callback again.
 */
void SleepEffect::delete_self() {
	//timer->clear_target(); // this will also stop/delete the TimedAdvance
	//timer = nullptr;
	Effect::delete_self();
}


/* Resume normal play when requested time has been reached.
 */
//FIXME: need to handle TimedAdvance() errors and fade-in
uint16 SleepEffect::callback(uint16 msg, CallBack *caller, void *data) {
	uint8 hour = Game::get_game()->get_clock()->get_hour();
	uint8 minute = Game::get_game()->get_clock()->get_minute();

	// waited for FadeEffect
	if (msg == MESG_EFFECT_COMPLETE) {
		if (timer == nullptr) { // starting
			if (stop_time != "") { // advance to start time
				timer = new TimedAdvance(stop_time, 360); // 6 hours per second FIXME: it isn't going anywhere near that fast
				timer->set_target(this);
				timer->get_time_from_string(stop_hour, stop_minute, stop_time);
				// stop_hour & stop_minute are checked each hour
			} else { // advance a number of hours
				uint16 advance_h = (hour == stop_hour) ? 24
				                   : (hour < stop_hour) ? (stop_hour - hour)
				                   : (24 - (hour - stop_hour));
				timer = new TimedAdvance(advance_h, 360);
				timer->set_target(this);
				stop_minute = minute;
			}
		} else { // stopping
			Party *party = game->get_party();
			for (int s = 0; s < party->get_party_size(); s++) {
				Actor *actor = party->get_actor(s);

				//heal actors.
				uint8 hp_diff = actor->get_maxhp() - actor->get_hp();
				if (hp_diff > 0) {
					if (hp_diff == 1)
						hp_diff = 2;
					actor->set_hp(actor->get_hp() + NUVIE_RAND() % (hp_diff / 2) + hp_diff / 2);
				}
			}
			game->unpause_user();
			delete_self();
		}
		return 0;
	}
	// assume msg == MESG_TIMED; will stop after effect completes
	if (hour == stop_hour && minute >= stop_minute)
		effect_manager->watch_effect(this, new FadeEffect(FADE_PIXELATED, FADE_IN));

	return 0;
}


/*** FadeEffect ***/
static const int FADE_EFFECT_MAX_ITERATIONS = 20;

FadeEffect::FadeEffect(FadeType fade, FadeDirection dir, uint32 color, uint32 speed) {
	speed = speed ? speed : game->get_map_window()->get_win_area() * 2116; // was 256000
	init(fade, dir, color, nullptr, 0, 0, speed);
}

/* Takes an image to fade from/to. */
FadeEffect::FadeEffect(FadeType fade, FadeDirection dir, Graphics::ManagedSurface *capture, uint32 speed) {
	speed = speed ? speed : game->get_map_window()->get_win_area() * 1620; // was 196000
	init(fade, dir, 0, capture, 0, 0, speed); // color=black
}

/* Localizes effect to specific coordinates. The size of the effect is determined
 * by the size of the image. */
FadeEffect::FadeEffect(FadeType fade, FadeDirection dir, Graphics::ManagedSurface *capture, uint16 x, uint16 y, uint32 speed) {
	speed = speed ? speed : 1024;
	init(fade, dir, 0, capture, x, y, speed); // color=black
}


void FadeEffect::init(FadeType fade, FadeDirection dir, uint32 color, Graphics::ManagedSurface *capture, uint16 x, uint16 y, uint32 speed) {
	if (current_fade) {
		delete_self();
		return;
	}
	current_fade = this; // cleared in dtor

	screen = game->get_screen();
	map_window = game->get_map_window();
	viewport = new Common::Rect(map_window->GetRect());

	fade_type = fade;
	fade_dir = dir;
	fade_speed = speed; // pixels-per-second (to check, not draw)

	evtime = prev_evtime = 0;
	fade_x = x;
	fade_y = y;
	fade_from = nullptr;
	fade_iterations = 0;
	if (capture) {
		fade_from = new Graphics::ManagedSurface(capture->w, capture->h, capture->format);
		fade_from->blitFrom(*capture);
	}

	if (fade_type == FADE_PIXELATED || fade_type == FADE_PIXELATED_ONTOP) {
		pixelated_color = color;
		init_pixelated_fade();
	} else
		init_circle_fade();
}


FadeEffect::~FadeEffect() {
	//moved to delete_self
}

void FadeEffect::delete_self() {
	if (current_fade == this) { // these weren't init. if FadeEffect didn't start
		delete viewport;
		if (fade_dir == FADE_IN) // overlay should be empty now, so just delete it
			map_window->set_overlay(nullptr);
		if (fade_from) {
			delete fade_from;
			fade_from = nullptr;
		}

		current_fade = nullptr;
	}

	TimedEffect::delete_self();
}

/* Start effect. */
void FadeEffect::init_pixelated_fade() {
	int fillret = -1; // check error
	overlay = map_window->get_overlay();
	if (overlay != nullptr) {
		pixel_count = fade_from ? (fade_from->w) * (fade_from->h)
		              : (overlay->w - fade_x) * (overlay->h - fade_y);
		// clear overlay to fill color or transparent
		if (fade_dir == FADE_OUT) {
			if (fade_from) { // fade from captured surface to transparent
				// put surface on transparent background (not checked)
				fillret = SDL_FillRect(overlay, nullptr, uint32(TRANSPARENT_COLOR));
				Common::Rect overlay_rect(fade_x, fade_y, fade_x, fade_y);
				fillret = SDL_BlitSurface(fade_from, nullptr, overlay, &overlay_rect);
			} else // fade from transparent to color
				fillret = SDL_FillRect(overlay, nullptr, uint32(TRANSPARENT_COLOR));
		} else {
			if (fade_from) // fade from transparent to captured surface
				fillret = SDL_FillRect(overlay, nullptr, uint32(TRANSPARENT_COLOR));
			else // fade from color to transparent
				fillret = SDL_FillRect(overlay, nullptr, uint32(pixelated_color));
		}
	}
	if (fillret == -1) {
		DEBUG(0, LEVEL_DEBUGGING, "FadeEffect: error creating overlay surface\n");
		delete_self();
		return;
	}

	// if FADE_PIXELATED_ONTOP is set, place the effect layer above the map border
	map_window->set_overlay_level((fade_type == FADE_PIXELATED)
	                              ? MAP_OVERLAY_DEFAULT : MAP_OVERLAY_ONTOP);
	colored_total = 0;
	start_timer(1); // fire timer continuously
}


/* Start effect.
 */
void FadeEffect::init_circle_fade() {
	delete_self(); // FIXME
}


/* Called by the timer as frequently as possible. Do the appropriate
 * fade method and stop when the effect is complete.
 */
uint16 FadeEffect::callback(uint16 msg, CallBack *caller, void *data) {
	bool fade_complete = false;

	// warning: msg is assumed to be CB_TIMED and data is set
	evtime = *(uint32 *)(data);

	// do effect
	if (fade_type == FADE_PIXELATED || fade_type == FADE_PIXELATED_ONTOP)
		fade_complete = (fade_dir == FADE_OUT) ? pixelated_fade_out() : pixelated_fade_in();
	else /* CIRCLE */
		fade_complete = (fade_dir == FADE_OUT) ? circle_fade_out() : circle_fade_in();

	// done
	if (fade_complete == true) {
		delete_self();
		return 1;
	}
	return 0;
}


/* Scan the overlay, starting at pixel rnum, for a transparent pixel if fading
 * out, and a colored pixel if fading in.
 * Returns true if a free pixel was found and set as rnum.
 */
// FIXME: this probably doesn't work because it only handles 8bpp
inline bool FadeEffect::find_free_pixel(uint32 &rnum, uint32 pixelCount) {
	uint8 scan_color = (fade_dir == FADE_OUT) ? TRANSPARENT_COLOR
	                   : pixelated_color;
	const uint8 *pixels = (const uint8 *)(overlay->getPixels());

	for (uint32 p = rnum; p < pixelCount; p++) // check all pixels after rnum
		if (pixels[p] == scan_color) {
			rnum = p;
			return true;
		}
	for (uint32 q = 0; q < rnum; q++) // check all pixels before rnum
		if (pixels[q] == scan_color) {
			rnum = q;
			return true;
		}
	return false;
}


/* Returns the next pixel to check/colorize. */
#if 0
#warning this crashes if x,y is near boundary
#warning make sure center_thresh does not go over boundary
inline uint32 FadeEffect::get_random_pixel(uint16 center_thresh) {
	if (center_x == -1 || center_y == -1)
		return (NUVIE_RAND() % pixel_count);

	uint16 x = center_x, y = center_y;
	if (center_thresh == 0)
		center_thresh = overlay->w / 2;
	x += (NUVIE_RAND() % (center_thresh * 2)) - center_thresh,
	     y += (NUVIE_RAND() % (center_thresh * 2)) - center_thresh;
	return ((y * overlay->w) + x);
}
#endif

/* Randomly add pixels of the appropriate color to the overlay. If the color
 * is -1, it will be taken from the "fade_from" surface.
 * Returns true when the overlay is completely colored.
 */
bool FadeEffect::pixelated_fade_core(uint32 pixels_to_check, sint16 fade_to) {
	Graphics::Surface s = overlay->getSubArea(Common::Rect(0, 0, overlay->w, overlay->h));
	uint8 *pixels = (uint8 *)s.getPixels();
	const uint8 *from_pixels = fade_from ? (const uint8 *)(fade_from->getPixels()) : nullptr;
	uint32 p = 0; // scan counter
	uint32 rnum = 0; // pixel index
	uint32 colored = 0; // number of pixels that get colored
	uint16 fade_width = fade_from ? fade_from->w : overlay->w - fade_x;
	uint16 fade_height = fade_from ? fade_from->h : overlay->h - fade_y;
	uint8 color = fade_to;

	if (fade_to == -1 && fade_from == nullptr) {
		return false;
	}

	while (p < pixels_to_check) {
		uint16 x = uint16(float(NUVIE_RAND()) * (fade_width - 1) / NUVIE_RAND_MAX) + fade_x,
		       y = uint16(float(NUVIE_RAND()) * (fade_height - 1) / NUVIE_RAND_MAX) + fade_y;
		if (x >= overlay->w) x = overlay->w - 1; // prevent overflow if fade_from is too big
		if (y >= overlay->h) y = overlay->h - 1;
		rnum = y * overlay->w + x;
//ERIC        rnum = y*overlay->pitch + x;

		if (fade_to == -1) { // get color from "fade_from"
			x -= fade_x;
			y -= fade_y;
			color = from_pixels[y * fade_from->w + x];
		}
		if (pixels[rnum] != color) {
			pixels[rnum] = color;
			++colored;
			++colored_total; // another pixel was set
		}
		++p;
	}
	(void)colored; // Fix warning about unused variable
	// all but two lines colored
	if (colored_total >= (pixel_count - fade_width * 2) || fade_iterations > FADE_EFFECT_MAX_ITERATIONS) { // fill the rest
		if (fade_to >= 0)
			SDL_FillRect(overlay, nullptr, (uint32)fade_to);
		else { // Note: assert(fade_from) if(fade_to < 0)
			Common::Rect fade_from_rect(fade_from->w, (int16)fade_from->h);
			Common::Rect overlay_rect(fade_x, fade_y, fade_x + fade_from->w, fade_y + fade_from->h);
			SDL_BlitSurface(fade_from, &fade_from_rect, overlay, &overlay_rect);
		}
		return true;
	} else return false;
}


/* Color some of the mapwindow.
 * Returns true when all pixels have been filled, and nothing is visible.
 */
bool FadeEffect::pixelated_fade_out() {
	if (fade_from)
		return (pixelated_fade_core(pixels_to_check(), TRANSPARENT_COLOR));
	return (pixelated_fade_core(pixels_to_check(), pixelated_color));
}


/* Clear some of the mapwindow.
 * Returns true when all colored pixels have been removed, and the MapWindow
 * is visible.
 */
bool FadeEffect::pixelated_fade_in() {
	if (fade_from)
		return (pixelated_fade_core(pixels_to_check(), -1));
	return (pixelated_fade_core(pixels_to_check(), TRANSPARENT_COLOR));
}


/* Returns the number of pixels that should be checked/colored (based on speed)
 * since the previous call.
 */
uint32 FadeEffect::pixels_to_check() {
	uint32 time_passed = (prev_evtime == 0) ? 0 : evtime - prev_evtime;
	uint32 fraction = 1000 / (time_passed > 0 ? time_passed : 1); // % of second passed, in milliseconds
	uint32 pixels_per_fraction = fade_speed / (fraction > 0 ? fraction : 1);
	prev_evtime = evtime;
	fade_iterations++;
	return pixels_per_fraction;
}


/* Reduce the MapWindow's ambient light level, according to the set speed.
 * Returns true when nothing is visible.
 */
bool FadeEffect::circle_fade_out() {
// FIXME
	return false;
}


/* Add to the MapWindow's ambient light level, according to the set speed.
 * Returns true when the light level has returned to normal.
 */
bool FadeEffect::circle_fade_in() {
// FIXME
	return false;
}


/* Pause game and do FadeEffect.
 */
GameFadeInEffect::GameFadeInEffect(uint32 color)
	: FadeEffect(FADE_PIXELATED_ONTOP, FADE_IN, color) {
	game->pause_user();
}


GameFadeInEffect::~GameFadeInEffect() {
}


/* Identical to FadeEffect, but unpause game when finished.
 */
uint16 GameFadeInEffect::callback(uint16 msg, CallBack *caller, void *data) {
	// done
	if (FadeEffect::callback(msg, caller, data) != 0)
		game->unpause_user();
	return 0;
}


FadeObjectEffect::FadeObjectEffect(Obj *obj, FadeDirection dir) {
	obj_manager = game->get_obj_manager();
	fade_obj = obj;
	fade_dir = dir;

	Graphics::ManagedSurface *capture = game->get_map_window()->get_sdl_surface();
	if (fade_dir == FADE_IN) { // fading IN to object, so fade OUT from capture
		effect_manager->watch_effect(this, /* call me */
		                             new FadeEffect(FADE_PIXELATED, FADE_OUT, capture));
		obj_manager->add_obj(fade_obj, OBJ_ADD_TOP);
		game->get_map_window()->updateBlacking(); // object is likely a moongate
	} else if (fade_dir == FADE_OUT) {
		effect_manager->watch_effect(this, /* call me */
		                             new FadeEffect(FADE_PIXELATED, FADE_OUT, capture, 0, 0, game->get_map_window()->get_win_area() * 1058)); //was 128000
//        obj_manager->remove_obj(fade_obj);
		game->get_map_window()->updateBlacking();
	}
	delete capture;

	game->pause_user();
}

FadeObjectEffect::~FadeObjectEffect() {
	game->unpause_user();
}

/* Assume FadeEffect is complete. */
uint16 FadeObjectEffect::callback(uint16 msg, CallBack *caller, void *data) {
	delete_self();
	return 0;
}


/* These types of local/vanish effects are slightly longer than a normal Fade.
 * FIXME: FadeEffect should take local effect area, or change speed to time.
 */
VanishEffect::VanishEffect(bool pause_user)
	: input_blocked(pause_user) {
	Graphics::ManagedSurface *capture = game->get_map_window()->get_sdl_surface();
//    effect_manager->watch_effect(this, /* call me */
//                                 new FadeEffect(FADE_PIXELATED, FADE_OUT, capture, 0, 0, 128000));
	effect_manager->watch_effect(this, /* call me */
	                             new FadeEffect(FADE_PIXELATED, FADE_OUT, capture));
	delete capture;

	if (input_blocked == VANISH_WAIT)
		game->pause_user();
	game->pause_anims();
}

VanishEffect::~VanishEffect() {
	game->unpause_anims();
	if (input_blocked == VANISH_WAIT)
		game->unpause_user();
}

/* Assume FadeEffect is complete. */
uint16 VanishEffect::callback(uint16 msg, CallBack *caller, void *data) {
	delete_self();
	return 0;
}


/* TileFadeEffect */
TileFadeEffect::TileFadeEffect(const MapCoord &loc, Tile *from, Tile *to, FadeType type, uint16 speed)
		: actor(nullptr), inc_reverse(false), spd(0) {
	add_anim(new TileFadeAnim(loc, from, to, speed));
	num_anim_running = 1;
}

//Fade out actor.
TileFadeEffect::TileFadeEffect(Actor *a, uint16 speed)
		: actor(a), inc_reverse(false), spd(speed), num_anim_running(0) {
	add_actor_anim();
	actor->hide();
}

TileFadeEffect::~TileFadeEffect() {

}

void TileFadeEffect::add_actor_anim() {
	MapCoord loc = actor->get_location();
	Tile *from = actor->get_tile();
	add_tile_anim(loc, from);

	const Std::list<Obj *> &surrounding_objs = actor->get_surrounding_obj_list();
	for (Obj *obj : surrounding_objs)
		add_obj_anim(obj);
}

void TileFadeEffect::add_obj_anim(Obj *obj) {
	ObjManager *obj_manager = Game::get_game()->get_obj_manager();
	MapCoord loc(obj->x, obj->y, obj->z);
	add_tile_anim(loc, obj_manager->get_obj_tile(obj->obj_n, obj->frame_n));
}

void TileFadeEffect::add_fade_anim(const MapCoord &loc, Tile *tile) {
	add_anim(new TileFadeAnim(loc, tile, nullptr, spd));
	num_anim_running++;
}

void TileFadeEffect::add_tile_anim(const MapCoord &loc_, Tile *tile) {
	MapCoord loc = loc_;
	TileManager *tile_manager = Game::get_game()->get_tile_manager();
	uint16 tile_num = tile->tile_num;

	add_fade_anim(loc, tile);

	if (tile->dbl_width) {
		tile_num--;
		loc.x -= 1;
		add_fade_anim(loc, tile_manager->get_tile(tile_num));
		loc.x += 1;
	}

	if (tile->dbl_height) {
		tile_num--;
		loc.y -= 1;
		add_fade_anim(loc, tile_manager->get_tile(tile_num));
		loc.y += 1;
	}

	if (tile->dbl_width && tile->dbl_height) {
		tile_num--;
		loc.x -= 1;
		loc.y -= 1;
		add_fade_anim(loc, tile_manager->get_tile(tile_num));
		loc.x += 1;
		loc.y += 1;
	}
}

uint16 TileFadeEffect::callback(uint16 msg, CallBack *caller, void *data) {
	if (msg == MESG_ANIM_DONE) {
		num_anim_running--;
	}

	if (num_anim_running == 0) {
		if (inc_reverse) {
			inc_reverse = false;
			add_actor_anim();
			return 0;
		}

		if (actor)
			actor->show();

		delete_self();
	}

	return 0;
}


TileBlackFadeEffect::TileBlackFadeEffect(Actor *a, uint8 fade_color, uint16 speed) {
	init(fade_color, speed);
	actor = a;
	actor->hide();
	add_actor_anim();
}

TileBlackFadeEffect::TileBlackFadeEffect(Obj *o, uint8 fade_color, uint16 speed) {
	init(fade_color, speed);
	obj = o;
	obj->set_invisible(true);
	add_obj_anim(obj);
}

void TileBlackFadeEffect::init(uint8 fade_color, uint16 speed) {
	fade_speed = speed;
	color = fade_color;
	actor = nullptr;
	obj = nullptr;
	reverse = false;

	num_anim_running = 0;
}
TileBlackFadeEffect::~TileBlackFadeEffect() {

}

void TileBlackFadeEffect::add_actor_anim() {
	MapCoord loc = actor->get_location();
	Tile *from = actor->get_tile();
	add_tile_anim(loc, from);

	const Std::list<Obj *> &surrounding_objs = actor->get_surrounding_obj_list();
	for (Obj *o : surrounding_objs)
		add_obj_anim(o);
}

void TileBlackFadeEffect::add_obj_anim(Obj *o) {
	MapCoord loc(o);
	Tile *from = Game::get_game()->get_obj_manager()->get_obj_tile(o->obj_n, o->frame_n);
	add_tile_anim(loc, from);
}

void TileBlackFadeEffect::add_tile_anim(const MapCoord &loc_, Tile *tile) {
	TileManager *tile_manager = Game::get_game()->get_tile_manager();
	uint16 tile_num = tile->tile_num;

	add_anim(new TileFadeAnim(loc_, tile, 0, color, reverse, fade_speed));
	num_anim_running++;

	MapCoord loc = loc_;
	if (tile->dbl_width) {
		tile_num--;
		loc.x -= 1;
		add_anim(new TileFadeAnim(loc, tile_manager->get_tile(tile_num), 0, color, reverse, fade_speed));
		num_anim_running++;
		loc.x += 1;
	}

	if (tile->dbl_height) {
		tile_num--;
		loc.y -= 1;
		add_anim(new TileFadeAnim(loc, tile_manager->get_tile(tile_num), 0, color, reverse, fade_speed));
		num_anim_running++;
		loc.y += 1;
	}

	if (tile->dbl_width && tile->dbl_height) {
		tile_num--;
		loc.x -= 1;
		loc.y -= 1;
		add_anim(new TileFadeAnim(loc, tile_manager->get_tile(tile_num), 0, color, reverse, fade_speed));
		num_anim_running++;
		loc.x += 1;
		loc.y += 1;
	}
}

uint16 TileBlackFadeEffect::callback(uint16 msg, CallBack *caller, void *data) {
	if (msg == MESG_ANIM_DONE) {
		num_anim_running--;
	}

	if (num_anim_running == 0) {
		if (reverse == false) {
			reverse = true;
			if (actor)
				add_actor_anim();
			else
				add_obj_anim(obj);

			return 0;
		}

		if (actor)
			actor->show();
		else
			obj->set_invisible(false);

		delete_self();
	}

	return 0;
}

XorEffect::XorEffect(uint32 eff_ms)
	: map_window(game->get_map_window()),
	  length(eff_ms) {
	game->pause_user();
	game->pause_anims();

	init_effect();
}

void XorEffect::init_effect() {
	capture = map_window->get_sdl_surface();
	map_window->set_overlay_level(MAP_OVERLAY_DEFAULT);
	map_window->set_overlay(capture);

	xor_capture(0xd); // changes black to pink
	start_timer(length);
}

/* Timer finished. Cleanup. */
uint16 XorEffect::callback(uint16 msg, CallBack *caller, void *data) {
	if (msg == MESG_TIMED) {
		stop_timer();
		game->unpause_anims();
		game->unpause_user();
		map_window->set_overlay(nullptr);
		delete_self();
	}
	return 0;
}

/* Do binary-xor on each pixel of the mapwindow image.*/
void XorEffect::xor_capture(uint8 mod) {
	Graphics::Surface s = capture->getSubArea(Common::Rect(0, 0, capture->w, capture->h));

	uint8 *pixels = (uint8 *)s.getPixels();
	for (int p = 0; p < (capture->w * capture->h); p++)
		pixels[p] ^= mod;
}


U6WhitePotionEffect::U6WhitePotionEffect(uint32 eff_ms, uint32 delay_ms, Obj *callback_obj)
	: map_window(game->get_map_window()),
	  state(0), start_length(1000),
	  eff1_length(eff_ms), eff2_length(800),
	  xray_length(delay_ms), capture(0),
	  potion(callback_obj) {
	game->pause_user();
	game->pause_anims();

	init_effect();
}

void U6WhitePotionEffect::init_effect() {
	// FIXME: play sound, and change state to 1 when sound is complete
	capture = map_window->get_sdl_surface();
	map_window->set_overlay_level(MAP_OVERLAY_DEFAULT);
	map_window->set_overlay(capture);
	start_timer(start_length);
}

/* The state is changed from current to next when this is called. */
uint16 U6WhitePotionEffect::callback(uint16 msg, CallBack *caller, void *data) {
	if (msg == MESG_TIMED) {
		stop_timer();

		if (state == 0) { // start/sound effect
			// FIXME: make start_length a timeout, force sound to stop
			xor_capture(0xd); // changes black to pink
			start_timer(eff1_length);
			state = 1;
		} else if (state == 1) { // xor-effect
			map_window->set_overlay(nullptr);
			start_timer(eff2_length);
			state = 2;
		} else if (state == 2) { // character outline
			game->unpause_anims();
			map_window->set_x_ray_view(X_RAY_ON);
			map_window->updateBlacking();
			start_timer(xray_length);
			state = 3;
		} else if (state == 3) { // x-ray
			map_window->set_x_ray_view(X_RAY_OFF);
			map_window->updateBlacking();
			game->unpause_user();
			if (potion)
				game->get_usecode()->message_obj(potion, MESG_EFFECT_COMPLETE, this);
			state = 4; // finished
			delete_self();
		}
	}
	return 0;
}

/* Do binary-xor on each pixel of the mapwindow image.*/
void U6WhitePotionEffect::xor_capture(uint8 mod) {
	Graphics::Surface s = capture->getSubArea(Common::Rect(0, 0, capture->w, capture->h));
	uint8 *pixels = (uint8 *)s.getPixels();
	for (int p = 0; p < (capture->w * capture->h); p++)
		pixels[p] ^= mod;
}


XRayEffect::XRayEffect(uint32 eff_ms) {
	xray_length = eff_ms;
	init_effect();
}

void XRayEffect::init_effect() {
	Game::get_game()->get_map_window()->set_x_ray_view(X_RAY_ON);
	start_timer(xray_length);
}

uint16 XRayEffect::callback(uint16 msg, CallBack *caller, void *data) {
	if (msg == MESG_TIMED) {
		stop_timer();
		Game::get_game()->get_map_window()->set_x_ray_view(X_RAY_OFF);
		delete_self();
	}

	return 0;
}

PauseEffect::PauseEffect() {
	game->pause_world();
	// FIXME: need a way to detect any keyboard/mouse input
	game->get_scroll()->set_input_mode(true, "\n", true);
	game->get_scroll()->request_input(this, 0);
}

/* The effect ends when this is called. (if input is correct) */
uint16 PauseEffect::callback(uint16 msg, CallBack *caller, void *data) {
	if (msg == MESG_INPUT_READY) {
		game->unpause_world();
		delete_self();
	}
	return 0;
}

WizardEyeEffect::WizardEyeEffect(const MapCoord &location, uint16 duration) {
	// Disable keymapper so Wizard Eye can receive keyboard input.
	// FIXME: Remove this once the effect can use keymapper-bound keys.
	g_system->getEventManager()->getKeymapper()->setEnabled(false);
	game->get_map_window()->wizard_eye_start(location, duration, this);
}

uint16 WizardEyeEffect::callback(uint16 msg, CallBack *caller, void *data) {
	if (msg == MESG_EFFECT_COMPLETE) {
		delete_self();
		// FIXME: Remove this once the effect can use keymapper-bound keys.
		g_system->getEventManager()->getKeymapper()->setEnabled(true);
	}

	return 0;
}

TextInputEffect::TextInputEffect(const char *allowed_chars, bool can_escape) {
	game->pause_world();
	// FIXME: need a way to detect any keyboard/mouse input
	game->get_gui()->unblock();
	game->get_scroll()->set_input_mode(true, allowed_chars, can_escape);
	game->get_scroll()->request_input(this, 0);
}

/* The effect ends when this is called. (if input is correct) */
uint16 TextInputEffect::callback(uint16 msg, CallBack *caller, void *data) {
	if (msg == MESG_INPUT_READY) {
		input = *(Std::string *)data;
		game->unpause_world();
		delete_self();
	}
	return 0;
}


PeerEffect::PeerEffect(uint16 x, uint16 y, uint8 z, Obj *callback_obj)
	: map_window(game->get_map_window()), overlay(0),
	  gem(callback_obj), area(x, y, z), tile_trans(0),
	  map_pitch(0) {
	uint8 lvl = 0;
	map_window->get_level(&lvl);
	map_pitch = (lvl == 0) ? 1024 : 256;

	init_effect();
}

void PeerEffect::init_effect() {
	overlay = map_window->get_sdl_surface();
	map_window->set_overlay_level(MAP_OVERLAY_DEFAULT);
	map_window->set_overlay(overlay);
	assert(overlay->w % PEER_TILEW == 0); // overlay must be a multiple of tile size
	SDL_FillRect(overlay, nullptr, 0);

	peer();
}

void PeerEffect::delete_self() {
	map_window->set_overlay(nullptr);
	if (gem)
		game->get_usecode()->message_obj(gem, MESG_EFFECT_COMPLETE, this);
	else // FIXME: I don't want prompt display here, so it's also in UseCode,
		// but it has to be here if no object was set. (until we have another
		// way to tell caller effect is complete, and return to player)
	{
		game->get_scroll()->display_string("\n");
		game->get_scroll()->display_prompt();
	}
	Effect::delete_self();
}

void PeerEffect::peer() {
	uint16 w = overlay->w, h = overlay->h;
	// effect is limited to 48x48 area
	if (overlay->w > 48 * PEER_TILEW) w = 48 * PEER_TILEW;
	if (overlay->h > 48 * PEER_TILEW) h = 48 * PEER_TILEW;

	MapCoord player_loc = game->get_player()->get_actor()->get_location();
	uint16 cx = player_loc.x - area.x; // rough center of area
	uint16 cy = player_loc.y - area.y;
	area.x %= map_pitch; // we have to wrap here because we use a map buffer
	area.y %= map_pitch;
	uint8 *mapbuffer = new uint8[48 * 48]; // array of tile types/colors
	memset(mapbuffer, 0x00, sizeof(uint8) * 48 * 48); // fill with black
	fill_buffer(mapbuffer, cx, cy);

	for (int x = 0; x < w; x += PEER_TILEW)
		for (int y = 0; y < h; y += PEER_TILEW) {
			uint16 wx = area.x + x / PEER_TILEW, wy = area.y + y / PEER_TILEW;
			uint8 tile_type = mapbuffer[(wy - area.y) * 48 + (wx - area.x)];
			blit_tile(x, y, tile_type);
			if (tile_type != 0x00) {
				Actor *actor = game->get_actor_manager()->get_actor(wx, wy, area.z);
				if (actor)
					blit_actor(actor);
			}
		}

	delete [] mapbuffer;
}

void PeerEffect::fill_buffer(uint8 *mapbuffer, uint16 x, uint16 y) {
	uint16 wx = area.x + x, wy = area.y + y;
	uint8 *tile = &mapbuffer[y * 48 + x];

	if (*tile != 0x00)
		return; // already filled

	wx %= map_pitch; // we have to wrap here because we use a map buffer
	wy %= map_pitch;
	*tile = get_tilemap_type(wx, wy, area.z);

	// stop at unpassable tiles
	// FIXME: stop at Nothing/black tiles
	if (*tile != peer_tilemap[2]
	        || game->get_game_map()->get_tile(wx, wy, area.z, true)->passable) {
		if (y > 0) {
			if (x > 0) fill_buffer(mapbuffer, x - 1, y - 1); // +-+-+
			if (y > 0) fill_buffer(mapbuffer, x,  y - 1); // |\|/|
			if (x + 1 < 48) fill_buffer(mapbuffer, x + 1, y - 1);
		}

		if (x > 0)     fill_buffer(mapbuffer, x - 1, y); // +-+-+
		if (x + 1 < 48)  fill_buffer(mapbuffer, x + 1, y);

		if (y + 1 < 48) {
			if (x > 0) fill_buffer(mapbuffer, x - 1, y + 1); // |/|\|
			fill_buffer(mapbuffer, x,  y + 1); // +-+-+
			if (x + 1 < 48) fill_buffer(mapbuffer, x + 1, y + 1);
		}
	}
}

inline void PeerEffect::blit_tile(uint16 x, uint16 y, uint8 c) {
	Graphics::Surface s = overlay->getSubArea(Common::Rect(0, 0, overlay->w, overlay->h));
	uint8 *pixels = (uint8 *)s.getPixels();
	for (int j = 0; j < PEER_TILEW && j < overlay->h; j++)
		for (int i = 0; i < PEER_TILEW && i < overlay->w; i++) {
			if (peer_tile[i * PEER_TILEW + j] != tile_trans)
				pixels[overlay->w * (y + j) + (x + i)] = c;
		}
}

inline void PeerEffect::blit_actor(Actor *actor) {
	tile_trans = 1;
	blit_tile((actor->get_location().x - area.x)*PEER_TILEW,
	          (actor->get_location().y - area.y)*PEER_TILEW, 0x0F);
	tile_trans = 0;
	if (game->get_player()->get_actor() == actor)
		blit_tile((actor->get_location().x - area.x)*PEER_TILEW,
		          (actor->get_location().y - area.y)*PEER_TILEW, 0x0F);
}

inline uint8 PeerEffect::get_tilemap_type(uint16 wx, uint16 wy, uint8 wz) {
	Map *map = game->get_game_map();
	// ignore objects (bridges and docks), and show coasts as land
	if (map->is_water(wx, wy, wz, true) && !map->get_tile(wx, wy, wz, true)->passable)
		return peer_tilemap[1];
	if (!map->is_passable(wx, wy, wz))
		return peer_tilemap[2];
	if (map->is_damaging(wx, wy, wz))
		return peer_tilemap[3];
	return peer_tilemap[0]; // ground/passable
}

WingStrikeEffect::WingStrikeEffect(Actor *target_actor) {
	actor = target_actor;

	add_anim(new WingAnim(actor->get_location()));
}

uint16 WingStrikeEffect::callback(uint16 msg, CallBack *caller, void *data) {
	switch (msg) {
	case MESG_ANIM_HIT :
		DEBUG(0, LEVEL_DEBUGGING, "hit target!\n");
		Game::get_game()->get_script()->call_actor_hit(actor, (NUVIE_RAND() % 20) + 1);
		break;
	case MESG_ANIM_DONE :
		delete_self();
		break;
	}
	return 0;
}

HailStormEffect::HailStormEffect(const MapCoord &target) {
	add_anim(new HailstormAnim(target));
}

uint16 HailStormEffect::callback(uint16 msg, CallBack *caller, void *data) {
	switch (msg) {
	case MESG_ANIM_HIT :
		DEBUG(0, LEVEL_DEBUGGING, "hit target!\n");
		Game::get_game()->get_script()->call_actor_hit((Actor *)data, 1);
		break;
	case MESG_ANIM_DONE :
		delete_self();
		break;
	}
	return 0;
}

/*** AsyncEffect ***/
AsyncEffect::AsyncEffect(Effect *e) {
	effect_complete = false;
	effect = e;
	effect->retain();
	effect_manager->watch_effect(this, effect);
}

AsyncEffect::~AsyncEffect() {
	effect->release();
}

/* The effect is marked as defunct after run finishes and will be removed from the system.*/
void AsyncEffect::run(bool process_gui_input) {
	if (!process_gui_input)
		Game::get_game()->pause_user();
	for (; effect_complete == false;) {
		//spin world
		Game::get_game()->update_once(process_gui_input);
		if (!effect_complete)
			Game::get_game()->update_once_display();
	}
	if (!process_gui_input)
		Game::get_game()->unpause_user();
	delete_self();
}

uint16 AsyncEffect::callback(uint16 msg, CallBack *caller, void *data) {

	// effect complete
	if (msg == MESG_EFFECT_COMPLETE) {
		effect_complete = true;
	}

	return 0;
}

} // End of namespace Nuvie
} // End of namespace Ultima