combat.h

/*
 *	combat.h - Combat scheduling.
 *
 *  Copyright (C) 2000-2011  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 COMBAT_H
#define COMBAT_H	1

#include "schedule.h"
#include <list>

class Actor;
class Game_object;
class Spellbook_object;

/*
 *	Combat schedule:
 */
class Combat_schedule : public Schedule
	{
public:
	enum Phase			// We'll be a finite-state-machine.
		{
		initial = 0,		// Just constructed.
		approach = 1,		// Approaching a foe to attack.
		retreat = 2,		// Avoiding a foe.
		flee = 3,		// Run away!
		strike = 4,		// In the process of striking.
		fire = 5,		// In process of firing range weapon.
		parry = 6,		// In the process of parrying a blow.
		stunned = 7,		// Just been hit.
		wait_return = 8		// Wait for boomerang.
		};
protected:
	static unsigned long battle_time;// Time when battle started.
	static unsigned long battle_end_time;	// And when it ended.
	Phase state;
	Schedule_types prev_schedule;	// Before going into combat.
	std::list<Actor*> opponents;	// Possible opponents.
	Game_object *practice_target;	// Only for duel schedule.
	Game_object *weapon;
	int weapon_shape;		// Weapon's shape in shapes.vga.
	Spellbook_object *spellbook;	// If readied.
					// Ranges in tiles.  
					//   0 means not applicable.
	bool no_blocking;		// Weapon/ammo goes through walls.
	unsigned char yelled;		// Yell when first opponent targeted.
	bool started_battle;		// 1st opponent targeted.
	unsigned char fleed;		// Incremented when fleeing.
	bool can_yell;
	int failures;			// # failures to find opponent.
	unsigned int teleport_time;	// Next time we can teleport.
	unsigned int summon_time;
	unsigned int invisible_time;
	unsigned int dex_points;	// Need these to attack.
	int alignment;			// So we can tell if it changed.

	void start_battle();		// Play music at start of battle.
	bool teleport();		// For monsters that can.
	bool summon();
	bool be_invisible();
	virtual void find_opponents();
					// Find attacker of protected member.
	std::list<Actor*>::iterator find_protected_attacker();
	Game_object *find_foe(int mode);// Find a new opponent.
	Game_object *find_foe();
	void approach_foe(bool for_projectile = false);		// Approach foe.
	void start_strike();
	void run_away();
	Spellbook_object *readied_spellbook();
public:
	Combat_schedule(Actor *n, Schedule_types prev_sched);
	static void monster_died();	// Checks for victory.
	static void stop_attacking_npc(Game_object *npc);
	static void stop_attacking_invisible(Game_object *npc);
	virtual void now_what();	// Npc calls this when it's done
	virtual void im_dormant();	// Npc calls this when it goes dormant.
	virtual void ending(int newtype);// Switching to another schedule.
	virtual void set_weapon(bool removed = false);	// Set weapon info.
	void set_hand_to_hand();
	bool has_started_battle() const
		{ return started_battle; }
	void set_state(Phase s)
		{ state = s; }
	static bool attack_target(Game_object *attacker,
			Game_object *target, Tile_coord tile, int weapon, bool combat = false);
	};

/*
 *	Dueling is like combat, but nobody gets hurt.
 */

class Duel_schedule : public Combat_schedule
	{
	Tile_coord start;		// Starting position.
	int attacks;			// Count strikes.
	virtual void find_opponents();
public:
	Duel_schedule(Actor *n);
	virtual void now_what();
	};

bool In_ammo_family(int shnum, int family);// Yow, a global function.

#endif