/*
 *	effects.h - Special effects.
 *
 *  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 "gamewin.h"
#include "gamemap.h"
#include "gameclk.h"
#include "actors.h"
#include "effects.h"
#include "Zombie.h"
#include "dir.h"
#include "chunks.h"
#include "Audio.h"
#include "Gump_manager.h"
#include "game.h"
#include "Gump.h"
#include "egg.h"

#include "SDL_timer.h"

#ifndef UNDER_CE
using std::cout;
using std::endl;
using std::rand;
using std::string;
using std::strlen;
#endif

int Cloud::randcnt = 0;
int Lightning_effect::active = 0;

/*
 *	Clean up.
 */

Effects_manager::~Effects_manager()
	{ 
	remove_all_effects(false);
	}

/*
 *	Add text over a given item.
 */

void Effects_manager::add_text
	(
	const char *msg,
	Game_object *item		// Item text ID's, or null.
	)
	{
	if (!msg)			// Happens with edited games.
		return;
					// Don't duplicate for item.
	for (Text_effect *each = texts; each; each = each->next)
		if (each->is_text(item))
			return;		// Already have text on this.
	Text_effect *txt = new Text_effect(msg, item);
//	txt->paint(this);		// Draw it.
//	painted = 1;
	add_text_effect(txt);
	}

/*
 *	Add a text object at a given spot.
 */

void Effects_manager::add_text
	(
	const char *msg,
	int x, int y			// Pixel coord. on screen.
	)
	{
	Text_effect *txt = new Text_effect(msg,
		gwin->get_scrolltx() + x/c_tilesize, 
		gwin->get_scrollty() + y/c_tilesize);
	add_text_effect(txt);
	}

/*
 *	Add a text object in the center of the screen
 */

void Effects_manager::center_text
	(
	const char *msg
	)
	{
	remove_text_effects();
	Shape_manager *sman = Shape_manager::get_instance();
	add_text(msg, (gwin->get_width()-sman->get_text_width(0,msg))/2,
			 gwin->get_height()/2);
	}

/*
 *	Add an effect at the start of the chain.
 */

void Effects_manager::add_effect
	(
	Special_effect *effect
	)
	{
	effect->next = effects;		// Insert into chain.
	effect->prev = 0;
	if (effect->next)
		effect->next->prev = effect;
	effects = effect;
	}

/*
 *	Add a text effect at the start of the chain.
 */

void Effects_manager::add_text_effect
	(
	Text_effect *effect
	)
	{
	effect->next = texts;		// Insert into chain.
	effect->prev = 0;
	if (effect->next)
		effect->next->prev = effect;
	texts = effect;
	}

/*
 *	Remove a given object's text effect.
 */

void Effects_manager::remove_text_effect
	(
	Game_object *item		// Item text was added for.
	)
	{
	for (Text_effect *each = texts; each; each = each->next)
		if (each->is_text(item))
			{		// Found it.
			remove_text_effect(each);
			gwin->paint();
			return;
			}
	}

/*
 *	Remove a sprite from the chain and delete it.
 */

void Effects_manager::remove_effect
	(
	Special_effect *effect
	)
	{
	if (effect->in_queue())
		gwin->get_tqueue()->remove(effect);
	if (effect->next)
		effect->next->prev = effect->prev;
	if (effect->prev)
		effect->prev->next = effect->next;
	else				// Head of chain.
		effects = effect->next;
	delete effect;
	}

/*
 *	Remove text from the chain and delete it.
 */

void Effects_manager::remove_text_effect
	(
	Text_effect *txt
	)
	{
	if (txt->in_queue())
		gwin->get_tqueue()->remove(txt);
	if (txt->next)
		txt->next->prev = txt->prev;
	if (txt->prev)
		txt->prev->next = txt->next;
	else				// Head of chain.
		texts = txt->next;
	delete txt;
	}

/*
 *	Remove all text items.
 */

void Effects_manager::remove_all_effects
	(
	 bool repaint
	)
	{
	if (!effects && !texts)
		return;
	while (effects)
		remove_effect(effects);
	while (texts)
		remove_text_effect(texts);
	if (repaint)
		gwin->paint();		// Just paint whole screen.
	}

/*
 *	Remove text effects.
 */

void Effects_manager::remove_text_effects
	(
	)
	{
	while (texts)
		remove_text_effect(texts);
	gwin->set_all_dirty();
	}


/*
 *	Remove weather effects.
 */

void Effects_manager::remove_weather_effects
	(
	int dist			// Only remove those from eggs at
					//   least this far away.
	)
	{
	Actor *main_actor = gwin->get_main_actor();
	Tile_coord apos = main_actor ? main_actor->get_tile()
				: Tile_coord(-1, -1, -1);
	Special_effect *each = effects;
	while (each)
		{
		Special_effect *next = each->next;
					// See if we're far enough away.
		if (each->is_weather() && (!dist ||
		    ((Weather_effect *) each)->out_of_range(apos, dist)))
			remove_effect(each);
		each = next;
		}
	gwin->set_all_dirty();
	}

/*
 *	Find last numbered weather effect added.
 */

int Effects_manager::get_weather
	(
	)
	{
	Special_effect *each = effects;
	while (each)
		{
		Special_effect *next = each->next;
		if (each->is_weather())
			{
			Weather_effect *weather = (Weather_effect *) each;
			if (weather->get_num() >= 0)
				return weather->get_num();
			}
		each = next;
		}
	return 0;
	}

/*
 *	Paint them all.
 */

void Effects_manager::paint
	(
	)
	{
	for (Special_effect *effect = effects; effect; effect = effect->next)
		effect->paint();
	}

/*
 *	Paint all text.
 */

void Effects_manager::paint_text
	(
	)
	{
	for (Text_effect *txt = texts; txt; txt = txt->next)
		txt->paint();
	}

/*
 *	Some special effects may not need painting.
 */

void Special_effect::paint
	(
	)
	{
	}

/*
 *	Create an animation from the 'sprites.vga' file.
 */

Sprites_effect::Sprites_effect
	(
	int num,			// Index.
	Tile_coord p,			// Position within world.
	int dx, int dy,			// Add to offset for each frame.
	int delay			// Delay (msecs) before starting.
	) : sprite(num, 0, SF_SPRITES_VGA), item(0), pos(p), xoff(0), yoff(0),
						deltax(dx), deltay(dy)
	{
	Game_window *gwin = Game_window::get_instance();
	frames = sprite.get_num_frames();
					// Start.
	gwin->get_tqueue()->add(Game::get_ticks() + delay, this, 0L);
	}

/*
 *	Create an animation on an object.
 */

Sprites_effect::Sprites_effect
	(
	int num,			// Index.
	Game_object *it,		// Item to put effect by.
	int xf, int yf,			// Offset from actor in pixels.
	int dx, int dy			// Add to offset on each frame.
	) : sprite(num, 0, SF_SPRITES_VGA), item(it), xoff(xf), 
					yoff(yf), deltax(dx), deltay(dy)
	{
	pos = item->get_tile();
	Game_window *gwin = Game_window::get_instance();
	frames = sprite.get_num_frames();
					// Start immediately.
	gwin->get_tqueue()->add(Game::get_ticks(), this, 0L);
	}

/*
 *	Add a dirty rectangle for the current position and frame.
 */

inline void Sprites_effect::add_dirty
	(
	int frnum
	)
	{
	if (pos.tx == -1 || frnum == -1)
		return;			// Already at destination.
	Shape_frame *shape = sprite.get_shape();
	int lp = pos.tz/2;

	gwin->add_dirty(gwin->clip_to_win(gwin->get_shape_rect(shape,
		xoff + (pos.tx - lp - gwin->get_scrolltx())*c_tilesize,
	    	yoff + (pos.ty - lp - 
			gwin->get_scrollty())*c_tilesize).enlarge(12)));
	}

/*
 *	Animation.
 */

void Sprites_effect::handle_event
	(
	unsigned long curtime,		// Current time of day.
	long udata
	)
	{
	int frame_num = sprite.get_framenum();
	Game_window *gwin = Game_window::get_instance();
	int delay = gwin->get_std_delay();// Delay between frames.  Needs to
					//   match usecode animations.
	if (frame_num == frames)	// At end?
		{			// Remove & delete this.
		eman->remove_effect(this);
		gwin->set_all_dirty();
		return;
		}
	add_dirty(frame_num);		// Clear out old.
	gwin->set_painted();
	if (item)			// Following actor?
		pos = item->get_tile();
	xoff += deltax;			// Add deltas.
	yoff += deltay;
	frame_num++;			// Next frame.
	add_dirty(frame_num);		// Want to paint new frame.
	sprite.set_frame(frame_num);
					// Add back to queue for next time.
	gwin->get_tqueue()->add(curtime + delay, this, udata);
	}

/*
 *	Render.
 */

void Sprites_effect::paint
	(
	)
	{
	if (sprite.get_framenum() >= frames)
		return;
	int lp = pos.tz/2;		// Account for lift.
	sprite.paint_shape(
		xoff + (pos.tx - lp - gwin->get_scrolltx())*c_tilesize,
		yoff + (pos.ty - lp - gwin->get_scrollty())*c_tilesize);
	}

/*
 *	Start explosion.
 */

Explosion_effect::Explosion_effect
	(
	Tile_coord p, 
	Game_object *exp,
	int delay,			// Delay before starting (msecs).
	int weap			// Weapon to use for damage calcs., or
					//   -1 for default(704 = poweder keg).
	) : Sprites_effect(1, p, 0, 0, delay), explode(exp),
		weapon(weap >= 0 ? weap : 704)
{
	if (exp && exp->get_shapenum() == 704) { // powderkeg
		exp->set_quality(1); // mark as detonating
	}
}


void Explosion_effect::handle_event
	(
	unsigned long curtime,		// Current time of day.
	long udata
	)
	{
	int frnum = sprite.get_framenum();
	if (!frnum)			// Max. volume, with stereo position.
		{
		Tile_coord apos = gwin->get_main_actor()->get_tile();
		int dir = Get_direction16(apos.ty - pos.ty, pos.tx - apos.tx);

		Audio::get_ptr()->play_sound_effect(
				Audio::game_sfx(9), SDL_MIX_MAXVOLUME, dir);
		}
	if (frnum == frames/4) {
		// this was in ~Explosion_effect before
		if (explode && !explode->is_pos_invalid())
			{
			Game_window::get_instance()->add_dirty(explode);
			explode->remove_this();
			explode = 0;
			}
		Game_object_vector vec;	// Find objects near explosion.
		Game_object::find_nearby(vec, pos, c_any_shapenum, 5, 0);
		for (Game_object_vector::const_iterator it = vec.begin(); it != vec.end(); ++it)
			{
				(**it).attacked(0, -704, 0);
			}
	}
	Sprites_effect::handle_event(curtime, udata);
}

/*
 *	Get direction in 1/16's starting from North.
 */

inline int Get_dir16
	(
	Tile_coord& t1,
	Tile_coord& t2
	)
	{
					// Treat as cartesian coords.
	return Get_direction16(t1.ty - t2.ty, t2.tx - t1.tx);
	}

/*
 *	Initialize path & add to time queue.
 */

void Projectile_effect::init
	(
	Tile_coord s,			// Source,
	Tile_coord d			// Destination.
	)
	{
	no_blocking = false;		// We'll check the ammo & weapon.
	Game_window *gwin = Game_window::get_instance();
	Shape_info& info = ShapeID::get_info(projectile_shape);
	Weapon_info *winfo = info.get_weapon_info();
	if (winfo)
		{
		if (winfo->get_projectile())	// Different sprite to show?
			sprite.set_shape(winfo->get_projectile());
		no_blocking = no_blocking || winfo->no_blocking();
		}
	Ammo_info *ainfo = info.get_ammo_info();
	if (ainfo)
		no_blocking = no_blocking || ainfo->no_blocking();
	frames = sprite.get_num_frames();
	pos = s;			// Get starting position.
	if (attacker)			// Try to set start better.
		{
		Shape_info& info = attacker->get_info();
					// Try for around the heat.
		pos.tz += info.get_3d_height() - 1;
		if (d.tx < pos.tx)	// Start on proper side.
			pos.tx -= info.get_3d_xtiles();
		else
			pos.tx++;
		if (d.ty < pos.ty)
			pos.ty -= info.get_3d_ytiles();
		else
			pos.ty++;
		}
	path = new Zombie();		// Create simple pathfinder.
					// Find path.  Should never fail.
	path->NewPath(pos, d, 0);
	if (frames >= 24)		// Use frames 8-23, for direction
		{			//   going clockwise from North.
		int dir = Get_dir16(s, d);
		sprite.set_frame(8 + dir);
		}
	else if (frames == 1 && sprite.get_shapenum() != 704)
		sprite.set_frame(0);	// (Don't show powder keg!)
	else
		sprite.set_frame(-1);	// We just won't show it.
					// Start immediately.
	gwin->get_tqueue()->add(Game::get_ticks(), this, 0L);
	}


/*
 *	Create a projectile animation.
 */

Projectile_effect::Projectile_effect
	(
	Actor *att,			// Source of spell/attack.
	Game_object *to,		// End here, 'attack' it with shape.
	int shnum,			// Projectile shape # in 'shapes.vga'.
	int weap			// Weapon (bow, gun, etc.) shape, or 0.
	) : attacker(att), target(to), projectile_shape(shnum),
	    sprite(shnum, 0), weapon(weap),
	    return_path(false)
	{
	init(attacker->get_tile(), to->get_tile());
	}

/*
 *	Constructor used by missile eggs.
 */

Projectile_effect::Projectile_effect
	(
	Tile_coord s,			// Start here.
	Tile_coord d,			// End here.
	int shnum,			// Projectile shape
	int weap			// Weapon (bow, gun, etc.) shape, or 0.
	) : attacker(0), target(0), projectile_shape(shnum),
	    sprite(shnum, 0), weapon(weap),
	    return_path(false)
	{
	init(s, d);
	}

/* 
 *	Another used by missile eggs.
 */

Projectile_effect::Projectile_effect
	(
	Tile_coord s,			// Start here.
	Game_object *to,		// End here, 'attack' it with shape.
	int shnum,			// Projectile shape
	int weap,			// Weapon (bow, gun, etc.) shape, or 0.
	bool retpath			// Return of a boomerang.
	) : attacker(0), target(to), projectile_shape(shnum),
	    sprite(shnum, 0), weapon(weap),
	    return_path(retpath)
	{
	init(s, to->get_tile());
	}

/*
 *	Delete.
 */

Projectile_effect::~Projectile_effect
	(
	)
	{
	delete path;
	}

/*
 *	Add a dirty rectangle for the current position and frame.
 */

inline void Projectile_effect::add_dirty
	(
	)
	{
	if (pos.tx == -1 || sprite.get_framenum() == -1)
		return;			// Already at destination.
	Shape_frame *shape = sprite.get_shape();
					// Force repaint of prev. position.
	int liftpix = pos.tz*c_tilesize/2;
	gwin->add_dirty(gwin->clip_to_win(gwin->get_shape_rect(shape,
			(pos.tx - gwin->get_scrolltx())*c_tilesize - liftpix,
	    (pos.ty - gwin->get_scrollty())*c_tilesize - liftpix).enlarge(4)));
	}

/*
 *	See if something was hit.
 *
 *	Output:	->target hit, or 0.
 */

inline Game_object *Find_target
	(
	Game_window *gwin,
	Tile_coord pos
	)
	{
	if (pos.tz%5 == 0)		// On floor?
		pos.tz++;		// Look up 1 tile.
	Tile_coord dest = pos;		// This gets modified.
	if (!Map_chunk::is_blocked(pos, 1, MOVE_FLY, 0) &&
	    dest == pos)
		return (0);
	return Game_object::find_blocking(pos);
	}

/*
 *	Animation.
 */

void Projectile_effect::handle_event
	(
	unsigned long curtime,		// Current time of day.
	long udata
	)
	{
	Game_window *gwin = Game_window::get_instance();
	int delay = gwin->get_std_delay()/2;
	add_dirty();			// Force repaint of old pos.
	Tile_coord epos = pos;		// Save pos.
	if (!path->GetNextStep(pos) ||	// Get next spot.
					// If missile egg, detect target.
	  (!target && !no_blocking && (target = Find_target(gwin, pos)) != 0))
		{			// Done? 
		int delay = 0;		// For explosions.
		switch (projectile_shape)
			{
		case 287:		// Swordstrike.
			eman->add_effect(new Sprites_effect(23, epos));
			break;
		case 554:		// Burst arrow.
			eman->add_effect(new Sprites_effect(19, epos));
			break;
		case 565:		// Starburst.
			eman->add_effect(new Sprites_effect(18, epos));
			break;
		case 639:		// Death Vortex.
			eman->add_effect(new Death_vortex(target, epos));
			target = 0;	// Takes care of attack.
			break;
		case 82:		// Delayed explosion.
		case 621:		//    "       "
			delay = 3000;	// Wait 3 secs.  FALL THROUGH!
		case 78:		// Explosion.
		case 702:		// Cannon.
		case 704:		// Powder keg.
			eman->add_effect(new Explosion_effect(epos, 0, delay));
			target = 0;	// Takes care of attack.
			break;
			}
		if (return_path)	// Returned a boomerang?
			target->add(gmap->create_ireg_object(weapon, 0));
		else
			{		// Not teleported away ?
			if (target && epos.distance(target->get_tile()) < 50)
				target->attacked(attacker, weapon, 
							projectile_shape);
			if (attacker && // Check for `boomerangs'
			    weapon == projectile_shape && 
			    epos.distance(attacker->get_tile() ) < 50)
				{ 	// not teleported away
				Weapon_info *winf = 
				   ShapeID::get_info(weapon).get_weapon_info();
				if (winf && winf->returns())
					eman->add_effect(new Projectile_effect(
						pos, attacker, weapon, weapon,
									true));
				}
			}
		add_dirty();
		pos.tx = -1;		// Signal we're done.
		eman->remove_effect(this);
		return;
		}
	add_dirty();			// Paint new spot/frame.
					// Add back to queue for next time.
	gwin->get_tqueue()->add(curtime + delay, this, udata);
	}

/*
 *	Render.
 */

void Projectile_effect::paint
	(
	)
	{
	if (pos.tx == -1 || sprite.get_framenum() == -1)
		return;			// Already at destination.
	int liftpix = pos.tz*c_tilesize/2;
	sprite.paint_shape(
		(pos.tx - gwin->get_scrolltx())*c_tilesize - liftpix,
		(pos.ty - gwin->get_scrollty())*c_tilesize - liftpix);
	}

/*
 *	Create a 'death vortex'.
 */

Death_vortex::Death_vortex
	(
	Game_object *trg,		// What to aim for.
	Tile_coord tp			// Target pos, if trg==0.
	) : vortex(8, 0, SF_SPRITES_VGA), next_damage_time(0)
	{
	pos = trg ? trg->get_tile() : tp;
	target = trg ? trg->as_actor() : 0;
	Game_window *gwin = Game_window::get_instance();
	frames = vortex.get_num_frames();
					// Go for 20 seconds.
	stop_time = Game::get_ticks() + 20*1000;
					// Start immediately.
	gwin->get_tqueue()->add(Game::get_ticks(), this, 0L);
	}

/*
 *	Add a dirty rectangle for the current position and frame.
 *
 *	Output:	Width in pixels.
 */

inline int Death_vortex::add_dirty
	(
	)
	{
	Shape_frame *shape = vortex.get_shape();
	int liftpix = pos.tz*c_tilesize/2;
	gwin->add_dirty(gwin->clip_to_win(gwin->get_shape_rect(shape,
		(pos.tx - gwin->get_scrolltx())*c_tilesize - liftpix,
	    (pos.ty - gwin->get_scrollty())*c_tilesize - liftpix).enlarge(4)));
	return shape->get_width();
	}

/*
 *	Animation.
 */

void Death_vortex::handle_event
	(
	unsigned long curtime,		// Current time of day.
	long udata
	)
	{
	Game_window *gwin = Game_window::get_instance();
	int width = add_dirty();	// Repaint old area.
	if (target && !target->is_dead())	// Follow target.
		{
		Tile_coord tpos = target->get_tile();
		int deltax = tpos.tx - pos.tx, deltay = tpos.ty - pos.ty;
		int absx = deltax >= 0 ? deltax : -deltax;
		int absy = deltay >= 0 ? deltay : -deltay;
		if (absx > 2 || absy > 2)
			{
			if (deltax)
				pos.tx += deltax/absx;
			if (deltay)
				pos.ty += deltay/absy;
			}
		}
	if (curtime > next_damage_time)	// Time to cause damage.
		{			// Do it every second.
		next_damage_time = curtime + 1000;
		Actor_vector npcs;	// Find NPC's.
		Game_object::find_nearby(npcs, pos, -1, width/(2*c_tilesize), 
									8);
		for (Actor_vector::const_iterator it = npcs.begin();
							it != npcs.end(); ++it)
			{
			Actor *npc = *it;
			if (!npc->is_in_party())
				npc->reduce_health(40);
			}
		}
	vortex.set_frame((vortex.get_framenum() + 1)%frames);
	add_dirty();			// Paint new.
	if (curtime < stop_time)	// Keep going?
		gwin->get_tqueue()->add(curtime + 100, this, udata);
	else
		{
		gwin->set_all_dirty();
		eman->remove_effect(this);
		}
	}

/*
 *	Render.
 */

void Death_vortex::paint
	(
	)
	{
	int liftpix = pos.tz*c_tilesize/2;
	vortex.paint_shape(
		(pos.tx - gwin->get_scrolltx())*c_tilesize - liftpix,
		(pos.ty - gwin->get_scrollty())*c_tilesize - liftpix);
	}

/*
 *	Figure text position.
 */

static inline Tile_coord Figure_text_pos
	(
	Game_object *item
	)
	{
	Game_window *gwin = Game_window::get_instance();
	Gump_manager *gumpman = gwin->get_gump_man();
	Rectangle box;
					// See if it's in a gump.
	Gump *gump = gumpman->find_gump(item);
	if (gump)
		box = gump->get_shape_rect(item);
	else
		box = gwin->get_shape_rect(item->get_outermost());
	return Tile_coord(gwin->get_scrolltx() + box.x/c_tilesize, 
			  gwin->get_scrollty() + box.y/c_tilesize, 0);
	}

/*
 *	Add dirty rectangle for current position.
 */

void Text_effect::add_dirty
	(
	)
	{
	Game_window *gwin = Game_window::get_instance();
					// Repaint slightly bigger rectangle.
	Rectangle rect((pos.tx - gwin->get_scrolltx() - 1)*c_tilesize,
		       (pos.ty - gwin->get_scrollty() - 1)*c_tilesize,
			width + 2*c_tilesize, height + 2*c_tilesize);
	gwin->add_dirty(gwin->clip_to_win(rect));
	}

/*
 *	Initialize.
 */

void Text_effect::init
	(
	)
	{
	set_always(true);		// Always execute in time queue, even
					//   when paused.
	Game_window *gwin = Game_window::get_instance();
	width = 8 + sman->get_text_width(0, msg.c_str());
	height = 8 + sman->get_text_height(0);
	add_dirty();			// Force first paint.
					// Start immediately.
	gwin->get_tqueue()->add(Game::get_ticks(), this, 0L);
	if (msg[0] == '@')
		msg[0] = '"';
	int len = msg.size();
	if (msg[len - 1] == '@')
		msg[len - 1] = '"';
	}

/*
 *	Create a text effect for a given object.
 */

Text_effect::Text_effect
	(
	const string &m, 		// A copy is made.
	Game_object *it			// Item text is on, or null.
	) : msg(m), item(it), pos(Figure_text_pos(it)), num_ticks(0)
	{
	init();
	}

/*
 *	Create a text object.
 */

Text_effect::Text_effect
	(
	const string &m, 		// A copy is made.
	int t_x, int t_y		// Abs. tile coords.
	) : msg(m), item(0), pos(t_x, t_y, 0), num_ticks(0)
	{
	init();
	}

/*
 *	Reposition if necessary.
 */

void Text_effect::handle_event
	(
	unsigned long curtime,		// Current time of day.
	long udata			// Ignored.
	)
	{
	Game_window *gwin = Game_window::get_instance();
	if (++num_ticks == 10)		// About 1-2 seconds.
		{			// All done.
		add_dirty();
		eman->remove_text_effect(this);
		return;
		}
					// Back into queue.
	gwin->get_tqueue()->add(Game::get_ticks() + gwin->get_std_delay(), 
								this, 0L);
	if (!item)			// Nothing to move?
		return;
					// See if moved.
	Tile_coord npos = Figure_text_pos(item);
	if (npos == pos)		// No change?
		return;
	add_dirty();			// Force repaint of old area.
	pos = npos;			// Then set to repaint new.
	add_dirty();
	}

/*
 *	Render.
 */

void Text_effect::paint
	(
	)
	{
	const char *ptr = msg.c_str();
	int len = strlen(ptr);
	sman->paint_text(0, ptr, len, 
		(pos.tx - gwin->get_scrolltx())*c_tilesize,
				(pos.ty - gwin->get_scrollty())*c_tilesize);
	}

/*
 *	Init. a weather effect.
 */

Weather_effect::Weather_effect
	(
	int duration,			// Length in game minutes.
	int delay,			// Delay before starting.
	int n,				// Weather number.
	Game_object *egg		// Egg that started it, or null.
	) : num(n)
	{
	Game_window *gwin = Game_window::get_instance();
	if (egg)
		eggloc = egg->get_tile();
	else
		eggloc = Tile_coord(-1, -1, -1);
	stop_time = Game::get_ticks() + delay + 1000*((duration*60)/time_factor);
					// Start immediately.
	gwin->get_tqueue()->add(Game::get_ticks() + delay, this, 0L);
	}

/*
 *	Are we far enough away from this to cancel it?
 */

int Weather_effect::out_of_range
	(
	Tile_coord& avpos,		// Avatar's position.
	int dist			// Distance in tiles to cancel at.
	)
	{
	if (eggloc.tx == -1)		// Not created by an egg?
		return 0;
	return eggloc.distance(avpos) >= dist;
	}

/*
 *	Paint raindrop.
 */

inline void Raindrop::paint
	(
	Image_window8 *iwin,		// Where to draw.
	int scrolltx, int scrollty,	// Tile at top-left corner.
	Xform_palette& xform		// Transform array.
	)
	{
	uint32 ascrollx = scrolltx*(uint32)c_tilesize,
		      ascrolly = scrollty*(uint32)c_tilesize;
	int x = ax - ascrollx, y = ay - ascrolly;
	if (x < 0 || y < 0 || 
			x >= iwin->get_width() || y >= iwin->get_height())
		return;
	if (oldpix == 255)
		oldpix = iwin->get_pixel8(x, y);	// Get pixel.
	iwin->put_pixel8(xform[oldpix], x, y);
	}

/*
 *	Move raindrop.
 */

inline void Raindrop::next
	(
	Image_window8 *iwin,		// Where to draw.	
	int scrolltx, int scrollty,	// Tile at top-left corner.
	Xform_palette& xform,		// Transform array.
	int w, int h			// Dims. of window.
	)
	{
	uint32 ascrollx = scrolltx*(uint32)c_tilesize,
		      ascrolly = scrollty*(uint32)c_tilesize;
	int x = ax - ascrollx, y = ay - ascrolly;
					// Still on screen?  Restore pix.
	if (x >= 0 && y >= 0 && x < w && y < h && oldpix != 255)
		iwin->put_pixel8(oldpix, x, y);
	oldpix = 255;

					// Time to restart?
	if (x < 0 || x >= w || y < 0 || y >= h)
		{			
		int r = rand();
					// Have a few fall faster.
		yperx = (r%4) ? 1 : 2;
		ax = ascrollx + r%(w - w/8);
		ay = ascrolly + r%(h - h/4);
		}
	else				// Next spot.
		{
		int delta = 1 + rand()%4;
		ax += delta;
		ay += delta + yperx;
		}
					// Save old pixel & paint new.
	paint(iwin, scrolltx, scrollty, xform);
	}

/*
 *	Move raindrop.
 */

inline void Raindrop::next_random
	(
	Image_window8 *iwin,		// Where to draw.	
	int scrolltx, int scrollty,	// Tile at top-left corner.
	Xform_palette& xform,		// Transform array.
	int w, int h			// Dims. of window.
	)
	{
	uint32 ascrollx = scrolltx*(uint32)c_tilesize,
		      ascrolly = scrollty*(uint32)c_tilesize;
	int x = ax - ascrollx, y = ay - ascrolly;
					// Still on screen?  Restore pix.
	if (x >= 0 && y >= 0 && x < w && y < h && oldpix != 255)
		iwin->put_pixel8(oldpix, x, y);
	oldpix = 255;
					// Pick new spot randomly.
	int newx = rand()%w, newy = rand()%h;
	ax = ascrollx + newx;
	ay = ascrolly + newy;
					// Save old pixel & paint new.
	paint(iwin, scrolltx, scrollty, xform);
	}

/*
 *	Rain.
 */

void Rain_effect::handle_event
	(
	unsigned long curtime,		// Current time of day.
	long udata
	)
	{
	Game_window *gwin = Game_window::get_instance();
	if (!gwin->is_main_actor_inside() &&
	    !gumpman->showing_gumps(true))
		{			// Don't show rain inside buildings!
		Image_window8 *win = gwin->get_win();
		int w = win->get_width(), h = win->get_height();
					// Get transform table.
		Xform_palette& xform = sman->get_xform(8);//++++Experiment.
		int scrolltx = gwin->get_scrolltx(),
		    scrollty = gwin->get_scrollty();
					// Move drops.
		for (int i = 0; i < num_drops; i++)
			drops[i].next(win, scrolltx, scrollty, xform, w, h);
		gwin->set_painted();
		}
	if (curtime < stop_time)	// Keep going?
		gwin->get_tqueue()->add(curtime + 100, this, udata);
	else
		{
		gwin->set_all_dirty();
		eman->remove_effect(this);
		}
	}

/*
 *	Paint rain.
 */

void Rain_effect::paint
	(
	)
	{
	if (gwin->is_main_actor_inside())
		return;			// Inside.
					// Get transform table.
	Xform_palette& xform = sman->get_xform(8);//++++Experiment.
	int scrolltx = gwin->get_scrolltx(),
	    scrollty = gwin->get_scrollty();
	Image_window8 *win = gwin->get_win();
	for (int i = 0; i < num_drops; i++)
		drops[i].paint(win, scrolltx, scrollty, xform);
	gwin->set_painted();
	}

/*
 *	End of lightning.
 */

Lightning_effect::~Lightning_effect
	(
	)
	{
	if (flashing)			// Be sure palette is restored.
		Game_window::get_instance()->get_clock()->set_palette();
	}

/*
 *	Lightning.
 */

void Lightning_effect::handle_event
	(
	unsigned long curtime,		// Current time of day.
	long udata
	)
	{
	Game_window *gwin = Game_window::get_instance();
	int r = rand();			// Get a random #.
	int delay = 100;		// Delay for next time.
	if (flashing)			// Just turned white?  Restore.
		{
		gclock->set_palette();
		flashing = false;
		active = false;
		if (curtime >= stop_time)
			{		// Time to stop.
			eman->remove_effect(this);
			return;
			}
		if (r%5 == 0)		// Occassionally flash again.
			delay = (1 + r%7)*40;
		else			// Otherwise, wait several secs.
			delay = (4000 + r%3000);
		}
	else if (!gwin->is_in_dungeon() && !active)// Time to flash.
		{
					// Play thunder.
		Audio::get_ptr()->play_sound_effect(Audio::game_sfx(62));
		active = true;
		flashing = true;
		gwin->get_pal()->set(PALETTE_LIGHTNING);
		delay = (1 + r%2)*25;
		}
	gwin->get_tqueue()->add(curtime + delay, this, udata);
	}

/*
 *	Start a storm.
 */

Storm_effect::Storm_effect
	(
	int duration,			// In game minutes.
	int delay,			// In msecs.
	Game_object *egg		// Egg that caused it, or null.
	) : Weather_effect(duration, delay, 2, egg), start(1)
	{
	Game_window *gwin = Game_window::get_instance();
					// Start raining soon.
	int rain_delay = 20 + rand()%1000;
	eman->add_effect(new Rain_effect(duration - 1, rain_delay));
	int lightning_delay = rain_delay + rand()%500;
	eman->add_effect(new Lightning_effect(duration - 1, lightning_delay));
	}

/*
 *	Start/end of storm.
 */
void Storm_effect::handle_event
	(
	unsigned long curtime,		// Current time of day.
	long udata
	)
	{
	Game_window *gwin = Game_window::get_instance();
	if (start)
		{
		start = 0;
					// Darken sky.
		gwin->get_clock()->set_storm(true);
					// Nothing more to do but end.
		gwin->get_tqueue()->add(stop_time, this, udata);
		}
	else				// Must be time to stop.
		eman->remove_effect(this);
	}

/*
 *	Storm ended.
 */

Storm_effect::~Storm_effect
	(
	)
	{
	Game_window *gwin = Game_window::get_instance();
					// Restore palette.
	gwin->get_clock()->set_storm(false);
	}

/*
 *	Sparkles (in Ambrosia).
 */

void Sparkle_effect::handle_event
	(
	unsigned long curtime,		// Current time of day.
	long udata
	)
	{
	Game_window *gwin = Game_window::get_instance();
	if (!gwin->is_main_actor_inside())
		{			// Don't show rain inside buildings!
		Image_window8 *win = gwin->get_win();
		int w = win->get_width(), h = win->get_height();
					// Get transform table.
		Xform_palette& xform = sman->get_xform(8);
		int scrolltx = gwin->get_scrolltx(),
		    scrollty = gwin->get_scrollty();
					// Move drops to random spots.
		for (int i = 0; i < num_drops; i++)
			drops[i].next_random(win, scrolltx, scrollty, 
								xform, w, h);
		gwin->set_painted();
		}
	if (curtime < stop_time)	// Keep going?
		gwin->get_tqueue()->add(curtime + 100, this, udata);
	else
		{
		gwin->set_all_dirty();
		eman->remove_effect(this);
		}
	}

/*
 *	Create a cloud.
 */

const int CLOUD = 2;		// Shape #.

Cloud::Cloud
	(
	short dx, short dy		// Deltas for movement.
	) : cloud(CLOUD, 0, SF_SPRITES_VGA), wx(0), wy(0), deltax(dx), deltay(dy), count(-1)
	{
	Game_window *gwin = Game_window::get_instance();
					// Get abs. values.
	int adx = deltax > 0 ? deltax : -deltax;
	int ady = deltay > 0 ? deltay : -deltay;
	if (adx < ady)
		max_count = 2*gwin->get_height()/ady;
	else
		max_count = 2*gwin->get_width()/adx;
	start_time = 0;
	}

/*
 *	Set starting screen position according to direction.
 */

void Cloud::set_start_pos
	(
	Shape_frame *shape,
	int w, int h,			// Dims. of window.
	int& x, int& y			// Screen pos. returned.
	)
	{
	if (!deltax)			// Special cases first.
		{
		x = rand()%w;
		y = deltay > 0 ? -shape->get_ybelow() : 
						h + shape->get_yabove();
		return;
		}
	if (!deltay)
		{
		y = rand()%h;
		x = deltax > 0 ? -shape->get_xright() : w + shape->get_xleft();
		return;
		}
	int halfp = w + h;		// 1/2 perimeter.
	int r = rand()%halfp;		// Start on one of two sides.
	if (r > h)			// Start on top/bottom.
		{
		x = r - h;
		y = deltay > 0 ? -shape->get_ybelow() : 
						h + shape->get_yabove();
		return;
		}
	y = r;				// On left or right side.
	if (deltax > 0)			// Going right?
		x = -shape->get_xright();
	else				// Going left?
		x = w + shape->get_xleft();
	}

/*
 *	Move cloud
 */

inline void Cloud::next
	(
	Game_window *gwin,		// Game window.
	unsigned long curtime,		// Current time of day.
	int w, int h			// Dims. of window.
	)
	{
	if (curtime < start_time)
		return;			// Not yet.
					// Get top-left world pos.
	long scrollx = gwin->get_scrolltx()*c_tilesize;
	long scrolly = gwin->get_scrollty()*c_tilesize;
	Shape_frame *shape = cloud.get_shape();
	gwin->add_dirty(gwin->clip_to_win(gwin->get_shape_rect(
			shape, wx - scrollx, wy - scrolly).enlarge(4)));
	if (count <= 0)			// Time to restart?
		{
					// Set start time randomly.
		start_time = curtime + 2000*randcnt + rand()%2000;
		randcnt = (randcnt + 1)%4;
		start_time = Game::get_ticks() + 2000*randcnt + rand()%500;
cout << "Cloud: start_time = " << start_time << endl;
		count = max_count;
		cloud.set_frame(rand()%cloud.get_num_frames());
		int x, y;		// Get screen pos.
		set_start_pos(shape, w, h, x, y);
		wx = x + scrollx;
		wy = y + scrolly;
		}
	else
		{
		wx += deltax;
		wy += deltay;
		count--;
		}
	gwin->add_dirty(gwin->clip_to_win(gwin->get_shape_rect(
			shape, wx - scrollx, wy - scrolly).enlarge(4)));
	}

/*
 *	Paint cloud.
 */

void Cloud::paint
	(
	)
	{
	Game_window *gwin = Game_window::get_instance();
	if (count > 0)			// Might not have been started.
		cloud.paint_shape(wx - gwin->get_scrolltx()*c_tilesize, 
			wy - gwin->get_scrollty()*c_tilesize);
	}

/*
 *	Create a few clouds to float across the screen.
 */

Clouds_effect::Clouds_effect
	(
	int duration,			// In game minutes.
	int delay,			// In msecs.
	Game_object *egg		// Egg that caused it, or null.
	) : Weather_effect(duration, delay, 6, egg)
	{
	num_clouds = 2 + rand()%5;	// Pick #.
	clouds = new Cloud *[num_clouds];
					// Figure wind direction.
	int dx = rand()%5 - 2;
	int dy = rand()%5 - 2;
	if (!dx && !dy)
		{
		dx = 1 + rand()%2;
		dy = 1 - rand()%3;
		}
	for (int i = 0; i < num_clouds; i++)
		{			// Modify speed of some.
		int deltax = dx, deltay = dy;
		if (rand()%2 == 0)
			{
			deltax += deltax/2;
			deltay += deltay/2;
			}
		clouds[i] = new Cloud(deltax, deltay);
		}
	}

/*
 *	Cloud drift.
 */

void Clouds_effect::handle_event
	(
	unsigned long curtime,		// Current time of day.
	long udata
	)
	{
	const int delay = 100;
	Game_window *gwin = Game_window::get_instance();
	if (curtime >= stop_time)
		{			// Time to stop.
		eman->remove_effect(this);
		gwin->set_all_dirty();
		return;
		}
	int w = gwin->get_width(), h = gwin->get_height();
	for (int i = 0; i < num_clouds; i++)
		clouds[i]->next(gwin, curtime, w, h);
	gwin->get_tqueue()->add(curtime + delay, this, udata);
	}

/*
 *	Render.
 */

void Clouds_effect::paint
	(
	)
	{
	if (!gwin->is_main_actor_inside())
		for (int i = 0; i < num_clouds; i++)
			clouds[i]->paint();
	}

/*
 *	Shake the screen.
 */

void Earthquake::handle_event
	(
	unsigned long curtime,		// Current time of day.
	long udata
	)
	{
	static int eqsoundonce;

	if(eqsoundonce != 1)
	{
		eqsoundonce = 1;
		// Play earthquake SFX once
  		Audio::get_ptr()->play_sound_effect(Audio::game_sfx(60));
	}

	Game_window *gwin = Game_window::get_instance();
	Image_window *win = gwin->get_win();
	int w = win->get_width(), h = win->get_height();
	int sx = 0, sy = 0;
	int dx = rand()%9 - 4;
	int dy = rand()%9 - 4;
	if (dx > 0)
		w -= dx;
	else
		{
		w += dx;
		sx -= dx;
		dx = 0;
		}
	if (dy > 0)
		h -= dy;
	else
		{
		h += dy;
		sy -= dy;
		dy = 0;
		}
	win->copy(sx, sy, w, h, dx, dy);
	gwin->set_painted();
	gwin->show();
					// Shake back.
	win->copy(dx, dy, w, h, sx, sy);
	if (++i < len)			// More to do?  Put back in queue.
		gwin->get_tqueue()->add(curtime + 100, this, udata);
	else
		{
		eqsoundonce = 0;	
		delete this;
		}

	}

/*
 *	Create a fire field that will last for about 4 seconds.
 */

Fire_field_effect::Fire_field_effect
	(
	Tile_coord t			// Where to create it.
	)
	{
	field = gmap->create_ireg_object(895, 0);
	field->set_flag(Obj_flags::is_temporary);
	field->move(t.tx, t.ty, t.tz);
	gwin->get_tqueue()->add(Game::get_ticks() + 3000 + rand()%2000, this,
								0L);
	}

/*
 *	Remove the field.
 */

void Fire_field_effect::handle_event
	(
	unsigned long curtime,		// Current time of day.
	long udata
	)
	{
	int frnum = field->get_framenum();
	if (frnum == 0)			// All done?
		{
		field->remove_this();
		eman->remove_effect(this);
		}
	else
		{
		if (frnum > 3)		// Starting to wind down?
			{
			((Animated_egg_object *) field)->stop_animation();
			frnum = 3;
			}
		else
			frnum--;
		gwin->add_dirty(field);
		field->set_frame(frnum);
		gwin->get_tqueue()->add(curtime + gwin->get_std_delay(), 
								this, udata);
		}
	}