/*
 *	gamewin.h - X-windows Ultima7 map browser.
 *
 *  Copyright (C) 1998-1999  Jeffrey S. Freedman
 *  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.
 */

#ifndef GAMEWIN_H
#define GAMEWIN_H

#include "flags.h"
#include "iwin8.h"
#include "lists.h"
#include "rect.h"
#include "tiles.h"
#include "vgafile.h"

#include <string>	// STL string
#include "vec.h"

#define RED_PLASMA	1

#ifdef RED_PLASMA
#define	CYCLE_RED_PLASMA()	cycle_load_palette()
#else
#define	CYCLE_RED_PLASMA()
#endif

class Actor;
class Barge_object;
class Map_chunk;
class Chunk_terrain;
class Egg_object;
class Font;
class Game_object;
class Game_clock;
class Time_sensitive;
class Gump;
class Gump_button;
class Ireg_game_object;
class Dead_body;
class Main_actor;
class Npc_actor;
class Npc_face_info;
class Npc_proximity_handler;
class Palette;
class Time_queue;
class Usecode_machine;
class Deleted_objects;
class Gump_manager;
struct SaveGame_Details;
struct SaveGame_Party;
class Map_patch_collection;
class Dragging_info;
class Game_map;
class Shape_manager;
class Party_manager;
class ShapeID;
class Shape_info;
class Game_render;
class Effects_manager;

/*
 *	The main game window:
 */
class Game_window
	{
	static Game_window *game_window;// There's just one.
		// Game component classes:
	Dragging_info *dragging;	// Dragging info:
	Effects_manager *effects;	// Manages special effects.
	Game_clock *clock;		// Keeps track of time.
	Game_map *map;			// Holds all terrain.
	Game_render *render;		// Helps with rendering.
	Gump_manager *gump_man;		// Open containers on screen.
	Party_manager *party_man;	// Keeps party list.
	Image_window8 *win;		// Window to display into.
	Npc_proximity_handler *npc_prox;// Handles nearby NPC's.
	Palette *pal;
	Shape_manager *shape_man;	// Manages shape file.
	Time_queue *tqueue;		// Time-based queue.
	Time_sensitive *background_noise;
	Usecode_machine *usecode;	// Drives game plot.
		// Game state flags:
	bool combat;			// true if in combat.
	bool focus;			// Do we have focus?
	bool ice_dungeon;		// true if inside ice dungeon
	bool painted;			// true if we updated image buffer.
		// Game state values:
	int skip_above_actor;		// Level above actor to skip rendering.
	unsigned int in_dungeon;	// true if inside a dungeon.
	int num_npcs1;			// Number of type1 NPC's.
	int std_delay;			// Standard delay between frames.
	long time_stopped;		// For 'stop time' spell.
	unsigned long special_light;	// Game minute when light spell ends.
	int theft_warnings;		// # times warned in current chunk.
	short theft_cx, theft_cy;	// Chunk where warnings occurred.
		// Gameplay objects:
	Barge_object *moving_barge;	// ->cart/ship that's moving, or 0.
	Main_actor *main_actor;		// Main sprite to move around.
	Actor *camera_actor;		// What to center view around.
	Actor_vector npcs;		// Array of NPC's + the Avatar.
	Exult_vector<Dead_body*> bodies;// Corresponding Dead_body's.
	Deleted_objects *removed;	// List of 'removed' objects.
		// Rendering info:
	int scrolltx, scrollty;		// Top-left tile of screen.
	Rectangle scroll_bounds;	// Walking outside this scrolls.
	Rectangle dirty;		// Dirty rectangle.
		// Savegames:
	char *save_names[10];		// Names of saved games.
		// Options:
	bool mouse3rd;			// use third (middle) mouse button
	bool fastmouse;
	bool double_click_closes_gumps;
	int text_bg;			// draw a dark background behind text
	int	step_tile_delta;	// multiplier for the delta in start_actor_alt
	bool allow_double_right_move;	// If moving with right click is allowed

		// Private methods:
	void set_scrolls(Tile_coord cent);
	void clear_world();		// Clear out world's contents.
	void read_save_names();		// Read in saved-game names.
	long check_time_stopped();

#ifdef RED_PLASMA
	// Red plasma animation during game load
	uint32 load_palette_timer;
    int plasma_start_color, plasma_cycle_range;
#endif
	
public:
	friend class Game_render;
	/*
	 *	Public flags and gameplay options:
	 */
	int skip_lift;			// Skip objects with lift >= this.  0
					//   means 'terrain-editing' mode.
	bool paint_eggs;
	bool armageddon;		// Spell was cast.
	bool walk_in_formation;		// Use Party_manager for walking.
	int debug;
	/*
	 *	Class maintenance:
	 */
	Game_window(int width = 0, int height = 0, int scale = 1, 
							int scaler = 0);
	~Game_window();
					// Get the one game window.
	static Game_window *get_instance()
		{ return game_window; }
	void abort(const char *msg, ...);	// Fatal error.
	/*
 	 *	Display:
	 */
	void clear_screen(bool update = false);
	int get_width() const
		{ return win->get_width(); }
	int get_height() const
		{ return win->get_height(); }
	inline int get_scrolltx() const		// Get window offsets in tiles.
		{ return scrolltx; }
	inline int get_scrollty() const
		{ return scrollty; }
	inline Rectangle get_win_rect() const	// Get window's rectangle.
		{ return Rectangle(0, 0, win->get_width(), win->get_height());}
	Rectangle get_win_tile_rect()	// Get it in tiles, rounding up.
		{ return Rectangle(get_scrolltx(), get_scrollty(),
			(get_width() + c_tilesize - 1)/c_tilesize,
			(get_height() + c_tilesize - 1)/c_tilesize); }
					// Clip rectangle to window's.
	Rectangle clip_to_win(Rectangle r)
		{
		Rectangle wr = get_win_rect();
		return (r.intersect(wr));
		}
					// Resize event occurred.
	void resized(unsigned int neww, unsigned int newh,
				unsigned int newsc, unsigned int newsclr);
	void get_focus();		// Get/lose focus.
	void lose_focus();
	inline bool have_focus() const
		{ return focus; }
	/*
	 *	Game options:
	 */
	bool get_mouse3rd() const
		{ return mouse3rd; }
	void set_mouse3rd(bool m)
		{ mouse3rd = m; }
	bool get_fastmouse() const
		{ return get_win()->is_fullscreen() ? fastmouse : false; }
	void set_fastmouse(bool f)
		{ fastmouse = f; }
	bool get_double_click_closes_gumps() const
		{ return double_click_closes_gumps; }
	void set_double_click_closes_gumps(bool d)
		{ double_click_closes_gumps = d; }
	int get_text_bg() const
		{ return text_bg; }
	void set_text_bg(int t)
		{ text_bg = t; }
	/*
	 *	Game components:
	 */
	inline Game_map *get_map() const
		{ return map; }
	inline Usecode_machine *get_usecode() const
		{ return usecode; }
	inline Image_window8 *get_win() const
		{ return win; }
	inline Time_queue *get_tqueue() const
		{ return tqueue; }
	Palette *get_pal()
		{ return pal; }
	Effects_manager *get_effects()
		{ return effects; }
	inline Gump_manager *get_gump_man() { return gump_man; }
	inline Party_manager *get_party_man() { return party_man; }
	inline Npc_proximity_handler *get_npc_prox()  { return npc_prox; }
	Game_clock *get_clock () { return clock; }
	/*
	 *	ExultStudio support:
	 */
	Map_patch_collection *get_map_patches();
					// Locate shape (for EStudio).
	bool locate_shape(int shapenum, bool upwards);
	void send_location();		// Send our location to EStudio.
	/*
	 *	Gameplay data:
	 */
	inline Barge_object *get_moving_barge() const
		{ return moving_barge; }
	void set_moving_barge(Barge_object *b);
	bool is_moving();		// Is Avatar (or barge) moving?
	inline Main_actor *get_main_actor() const
		{ return main_actor; }
	bool is_main_actor_inside()
		{ return skip_above_actor < 31 ; }
					// Returns if skip_above_actor changed!
	bool set_above_main_actor(int lift)
		{
		if (skip_above_actor == lift) return false;
		skip_above_actor = lift;
		return true;
		}
	int get_render_skip_lift() const	// Skip rendering here.
		{ return skip_above_actor < skip_lift ?
					skip_above_actor : skip_lift; }
	bool main_actor_dont_move();
	inline bool set_in_dungeon(unsigned int lift)
		{ 
		if (in_dungeon == lift)
			return false;
		in_dungeon = lift;
		return true;
		}
	inline void set_ice_dungeon(bool ice) { ice_dungeon = ice; }
	inline unsigned int is_in_dungeon()
		{ return in_dungeon; }
	inline bool is_special_light()	// Light spell in effect?
		{ return special_light != 0; }
					// Light spell.
	void add_special_light(int minutes);
					// Handle 'stop time' spell.
	void set_time_stopped(long ticks);
	long is_time_stopped()
		{ return !time_stopped ? 0 : check_time_stopped(); }
	int get_std_delay() const	// Get/set animation frame delay.
		{ return std_delay; }
	void set_std_delay(int msecs)
		{ std_delay = msecs; }
	inline Actor *get_npc(long npc_num) const
		{ return (npc_num >= 0 && npc_num < (int)npcs.size()) ? 
				npcs[npc_num] : 0; }
	void set_body(int npc_num, Dead_body *body)
		{ bodies.put(npc_num, body); }
	Dead_body *get_body(int npc_num)
		{ return bodies[npc_num]; }
	int get_num_npcs()
		{ return npcs.size(); }
	int get_unused_npc();		// Find first unused NPC #.
	void add_npc(Actor *npc, int num);	// Add new one.
	inline int in_combat()		// In combat mode?
		{ return combat; }
	void toggle_combat();
	inline bool get_frame_skipping()	// This needs doing
		{ return true; }
					// Get ->party members.
	int get_party(Actor **list, int avatar_too = 0);
					// Add npc to 'nearby' list.
	void add_nearby_npc(Npc_actor *npc);
	void remove_nearby_npc(Npc_actor *npc);
					// Get all nearby NPC's.
	void get_nearby_npcs(Actor_queue& list);
					// Update NPCs' schedules.
	void schedule_npcs(int hour3, int backwards = 0, bool repaint = true);
	void mend_npcs();		// Restore HP's each hour.
					// Find witness to Avatar's 'crime'.
	Actor *find_witness(Actor *& closest_npc);
	void theft();			// Handle thievery.
	void call_guards(Actor *witness = 0);
	void attack_avatar(int num_guards = 0);
	/*
	 *	Rendering:
	 */
	inline void set_painted()	// Force blit.
		{ painted = 1; }
	inline bool was_painted()
		{ return painted; }
	bool show(bool force = false)	// Returns true if blit occurred.
		{
		if (painted || force)
			{
			win->show();
			painted = false;
			return true;
			}
		return false;
		}
	void clear_dirty()		// Clear dirty rectangle.
		{ dirty.w = 0; }
					// Paint scene at given tile.
	void paint_map_at_tile(int x, int y, int w, int h,
				int toptx, int topty, int skip_above = 31);
					// Paint area of image.
	void paint(int x, int y, int w, int h);
	void paint(Rectangle& r)
		{ paint(r.x, r.y, r.w, r.h); }
	void paint();			// Paint whole image.
					// Paint 'dirty' rectangle.
	void paint_dirty();
	void set_all_dirty()		// Whole window.
		{ dirty = Rectangle(0, 0, get_width(), get_height()); }
	void add_dirty(Rectangle r)	// Add rectangle to dirty area.
		{ dirty = dirty.w > 0 ? dirty.add(r) : r; }
					// Add dirty rect. for obj. Rets. false
					//   if not on screen.
	bool add_dirty(Game_object *obj)
		{
		Rectangle rect = get_shape_rect(obj);
		rect.enlarge(5);
		rect = clip_to_win(rect);
		if (rect.w > 0 && rect.h > 0)
			{
			add_dirty(rect);
			return true;
			}
		else
			return false;
		}
					// Set view (upper-left).
	void set_scrolls(int newscrolltx, int newscrollty);
	void center_view(Tile_coord t);	// Center view around t.
	void set_camera_actor(Actor *a);
	Actor *get_camera_actor()
		{ return camera_actor; }
					// Scroll if necessary.
	bool scroll_if_needed(Tile_coord t);
	bool scroll_if_needed(Actor *a, Tile_coord t)
		{ if (a == camera_actor) return scroll_if_needed(t); 
							else return false; }
#if 1
					// Show abs. location of mouse.
	void show_game_location(int x, int y);
#endif
					// Get screen area of shape at pt.
	Rectangle get_shape_rect(const Shape_frame *s, int x, int y) const
		{
		return Rectangle(x - s->xleft, y - s->yabove,
				s->get_width(), s->get_height());
		}
					// Get screen area used by object.
	Rectangle get_shape_rect(Game_object *obj);
					// Get screen loc. of object.
	void get_shape_location(Game_object *obj, int& x, int& y);
	void get_shape_location(Tile_coord t, int& x, int& y);
	void plasma(int w, int h, int x, int y, int startc, int endc);
	/*
	 *	Save/restore/startup:
	 */
	void write();			// Write out to 'gamedat'.
	void read();			// Read in 'gamedat'.
	void write_gwin();		// Write gamedat/gamewin.dat.
	void read_gwin();		// Read gamedat/gamewin.dat.
	void write_map();		// Write map data to <PATCH> dir.
	void read_map();		// Reread initial game map.
	void reload_usecode();		// Reread (patched) usecode.
	void init_actors();		// Place actors in the world.
	void init_files(bool cycle=true);	// Load all files

		// From Gamedat
	void get_saveinfo( Shape_file *&map,
			SaveGame_Details *&details,
			SaveGame_Party *& party);
		// From Savegame
	bool get_saveinfo(int num, char *&name,
			Shape_file *&map,
			SaveGame_Details *&details,
			SaveGame_Party *& party);
	void read_saveinfo(DataSource *in,
			SaveGame_Details *&details,
			SaveGame_Party *& party);
#ifdef HAVE_ZIP_SUPPORT
private:
	bool get_saveinfo_zip(const char *fname, char *&name,
			Shape_file *&map,
			SaveGame_Details *&details,
			SaveGame_Party *& party);
public:
#endif
	void write_saveinfo();		// Write the save info to gamedat
	inline char *get_save_name(int i) const	// Get ->saved-game name.
		{ return save_names[i]; }
	void setup_game();		// Prepare for game
	void read_npcs();		// Read in npc's.
	void write_npcs();		// Write them back.
	void read_schedules();		// Read npc's schedules.
	void write_schedules();		// Write npc's schedules.
	void revert_schedules(Actor *);	// Reset a npc's schedule.
					// Explode a savegame into "gamedat".
	void restore_gamedat(const char *fname);
	void restore_gamedat(int num);
					// Save "gamedat".
	void save_gamedat(const char *fname, const char *savename);
	void save_gamedat(int num, const char *savename);
					// Get IDENTITY string.
	static char *get_game_identity(const char *savename);
	bool init_gamedat(bool create); // Initialize gamedat directory
#ifdef HAVE_ZIP_SUPPORT
private:
	bool save_gamedat_zip(const char *fname, const char *savename);
	bool Restore_level2 (void *unzipfile);
	bool restore_gamedat_zip(const char *fname);
	static char *get_game_identity_zip(const char *savename);
public:
#endif
	/*
	 *	Game control:
	 */
	void view_right();		// Move view 1 chunk to right.
	void view_left();		// Move view left by 1 chunk.
	void view_down();		// Move view down.
	void view_up();			// Move view up.
					// Start moving actor.
	void start_actor_alt (int winx, int winy, int speed);
	void start_actor(int winx, int winy, int speed = 125);
	void start_actor_along_path(int winx, int winy, int speed = 125);
	void stop_actor();		// Stop main actor.
	inline void set_step_tile_delta(int size) { step_tile_delta = size; }
	inline int get_step_tile_delta() { return step_tile_delta; };
	inline void set_allow_double_right_move(bool a) { allow_double_right_move = a; }
	inline bool get_allow_double_right_move() { return allow_double_right_move; }
	void teleport_party(Tile_coord t, bool skip_eggs = false);
	bool activate_item(int shnum, int frnum=c_any_framenum,
			   int qual=c_any_qual); // Activate item in party.
					// Find object (x, y) is in.
	Game_object *find_object(int x, int y);
					// Show names of items clicked on.
	void show_items(int x, int y, bool ctrl = false);
					// Right-click while combat paused.
	void paused_combat_select(int x, int y);
	ShapeID get_flat(int x, int y);	// Return terrain (x, y) is in.
					// Schedule object for deletion.
	void delete_object(Game_object *obj);
					// Handle a double-click in window.
	void double_clicked(int x, int y);
	bool start_dragging(int x, int y);
	bool drag(int x, int y);	// During dragging.
	bool drop_dragged(int x, int y, bool moved);// Done dragging.
	bool is_dragging() const { return dragging != 0; }
	bool drop_at_lift(Game_object *to_drop, int x, int y, int at_lift);
	Gump *get_dragging_gump();
	// Create a mini-screenshot (96x60)
	Shape_file* create_mini_screenshot ();
	/*
	 *	Chunk-caching:
	 */
	// Old Style Caching Emulation. Called if player has changed chunks
	void emulate_cache(int oldx, int oldy, int newx, int newy);
	// Is a specific move by a monster or item allowed
	bool emulate_is_move_allowed(int tx, int ty);
	// Swapping a superchunk to disk emulation
	void emulate_swapout (int scx, int scy);


#ifdef RED_PLASMA
	void setup_load_palette();
	void cycle_load_palette();
#endif
	};
#endif