/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

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/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
//class plAvBrainStaticNPC : public plAvBrain
//{
//	
//};
//
///** \class plAvBrain
//	Virtual base class for the modular avatar & creature brains.
//	A brain is a modular object which can be installed into a plArmatureMod
//	to drive it around in the scene. Some brains are for creature ai;
//	others intepret user input. The most interesting brain for reference is
//	probably plAvBrainHuman, which implements the control system for the
//	user's avatar.
//	/sa plAvBrainHuman, plArmatureMod
//*/
//class plAvBrainStaticNPC : public plAvBrainStaticNPC
//{
//public:
//	/** Default constructor - constructs the brain but does not attach it.
//		Brains are always constructed before being Pushed onto the armature
//		they seek to control. */
//	plAvBrain();
//	
//	/** Destructor. Automatically called on a brain when it is popped from the armature. */
//	virtual ~plAvBrain();
//
//	// BRAIN PROTOCOL
//	/** This brain has just been freshly pushed onto an armature and is now
//		in primary control. Note that brains beneath it on the stack may
//		still have effect on the armature; any messages which the top
//		brain doesn't handle will propagate down to the next brain in line.
//	*/
//	virtual hsBool Activate(plArmatureMod *avMod);
//
//	/** Has the brain resolved all its load-time dependencies? This is a mechanism
//		to allow newly loading creatures to reach a known state before they
//		are asked to load secondary state or to interact with the environment.
//	*/
//	virtual hsBool IsReady();
//
//	/** This brain has just been removed from its armature and is about to be destructed. */
//	virtual hsBool Deactivate();
//
//	/** This is the top brain and it's time for it to evaluate. Called during eval
//		time for the armature modifier. Only the topmost brain gets an apply
//		call; others must do any necessary background work during MsgReceive. */
//	virtual hsBool Apply(double timeNow, hsScalar elapsed);
//
//	/** Another brain has been pushed atop this brain. Drop into the background.
//		We'll still receive any messages that the upper brain doesn't eat. */
//	virtual hsBool Suspend();
//
//	/** We were suspended, but now we're on top of the brain stack again. */
//	virtual hsBool Resume();
//
//	// \name Spawning \{
//	/** Do any necessary custom action upon spawning afresh in a new age.
//		For the human brain, this simply consists of noting that we have
//		spawned and we can stop trying to do so. */
//	virtual void Spawn(double timeNow) {};
//
//	/** Custom behavior for entering an age. Binding the camera, audio source, etc. */
//	virtual void EnterAge(hsBool reSpawn) {};
//
//	/** Custom behavior for leaving an age. Free any attachments to camera, audio, etc. */
//	virtual void LeaveAge() {};
//
//	// TASKS
//	// tasks are operations that must be done in sequence.
//	/** Push a new task onto the end of our FIFO task queue. Will not 
//		run until all the tasks ahead of it have run. 
//		\sa plAvTask
//	*/
//	virtual void QueueTask(plAvTask *task);
//
//
//	virtual void DumpToDebugDisplay(int &x, int &y, int lineHeight, char *strBuf, plDebugText &debugTxt);
//
//
//	// PLASMOTICS
//	CLASSNAME_REGISTER( plAvBrain );
//	GETINTERFACE_ANY( plAvBrain, plCreatable );
//
//	virtual void Write(hsStream *stream, hsResMgr *mgr);
//	virtual void Read(hsStream *stream, hsResMgr *mgr);
//
//	virtual void SaveAux(hsStream *stream, hsResMgr *mgr);
//	virtual void LoadAux(hsStream *stream, hsResMgr *mgr, double time);
//
//	virtual hsBool MsgReceive(plMessage *msg);
//
//
//protected:
//	plArmatureMod	*fAvMod;			// the avatar we're controlling
//
//	// TASKS
//	// -- variables
//	typedef std::deque<plAvTask *> plAvTaskQueue;
//	plAvTaskQueue			fTaskQueue;						// FIFO queue of tasks we're working on
//	plAvTask				*fCurTask;						// the task we're working on right now
//	// -- methods
//	virtual hsBool IHandleTaskMsg(plAvTaskMsg *msg);	// respond to a task scheduling message
//	void IProcessTasks(double time, hsScalar elapsed);	// process current task and start new one if necessary
//	
//	hsBool	fSuspended;
//};
//