//-----------------------------------------------------------------------------
//
//  $Logfile:: /Quake 2 Engine/Sin/code/game/spidermine.h                        $
// $Revision:: 15                                                             $
//   $Author:: Aldie                                                          $
//     $Date:: 11/11/98 5:46p                                                 $
//
// Copyright (C) 1998 by Ritual Entertainment, Inc.
// All rights reserved.
//
// This source is may not be distributed and/or modified without
// expressly written permission by Ritual Entertainment, Inc.
//
// $Log:: /Quake 2 Engine/Sin/code/game/spidermine.h                             $
// 
// 15    11/11/98 5:46p Aldie
// Don't drop spidermines
// 
// 14    11/09/98 12:13a Aldie
// Made it so you can reclaim your mines when you die in deathmatch
// 
// 13    10/25/98 11:53p Jimdose
// added EXPORT_TEMPLATE
// 
// 12    10/22/98 5:01p Aldie
// Fixed some spidermine bugs
// 
// 11    10/08/98 12:03a Jimdose
// Got rid of unused variables speed and direction from Mine
// Added archive functions for Detonator
// 
// 10    9/21/98 4:50p Markd
// Fixed projectile owner
// 
// 9     9/21/98 4:21p Markd
// Put in archive functions and rewrote all archive routines
// 
// 8     9/13/98 8:36p Aldie
// Don't autoswitch to detonator
// 
// 7     8/29/98 5:27p Markd
// added specialfx, replaced misc with specialfx where appropriate
// 
// 6     8/25/98 5:30p Aldie
// New version of the spidermine which uses cameras
// 
// 5     6/08/98 9:04p Aldie
// Added ReadyToUse support
// 
// 4     6/08/98 8:21p Aldie
// Updated mines with new anim and logic
// 
// 3     6/08/98 11:49a Aldie
// New version of spidermine.
// 
// 2     5/11/98 11:25a Markd
// First time
// 
// 1     5/11/98 11:10a Markd
// 
// 1     5/11/98 10:24a Markd
// 
// 1     5/11/98 10:20a Markd
// 
// 1     5/11/98 10:18a Markd
// 
// 1     5/11/98 9:55a Markd
// 
// DESCRIPTION:
// Spider Mines
// 

#ifndef __SPIDERMINE_H__
#define __SPIDERMINE_H__

#include "g_local.h"
#include "item.h"
#include "weapon.h"
#include "specialfx.h"

class Detonator;

typedef SafePtr<Detonator> DetonatorPtr;
#ifdef EXPORT_TEMPLATE
template class SafePtr<Detonator>;
#endif

class Mine : public Projectile
	{
   private:
      DetonatorPtr      detonator;
      qboolean          detonate;
      qboolean          sticky;

	public:
		CLASS_PROTOTYPE( Mine );

		void					Explode( Event *ev );
		void					Setup( Entity *owner, Vector pos, Vector dir );
      void              SlideOrStick( Event *ev );
      void              CheckForTargets( Event *ev );
      void              Run( Event *ev );
      void              SetDetonator( Detonator *det );
      qboolean          IsOwner( Sentient *sent );
      virtual void Archive( Archiver &arc );
      virtual void Unarchive( Archiver &arc );
	};

#ifdef EXPORT_TEMPLATE
template class SafePtr<Mine>;
#endif

typedef SafePtr<Mine> MinePtr;

#ifdef EXPORT_TEMPLATE
template class Container<MinePtr>;
#endif

class Detonator : public Weapon
	{
   private: 
   public:
      Container<MinePtr>	 mineList;
      int                   currentMine;

      CLASS_PROTOTYPE( Detonator );
		
                            Detonator::Detonator();
      virtual void		    Shoot( Event *ev );
      virtual void		    DoneFiring( Event *ev );
              void          AddMine( Mine *mine );
              void          RemoveMine( Mine *mine );
              void          CycleCamera( Event *ev );
      virtual qboolean      AutoChange( void );
              qboolean      IsDroppable( void );
      virtual void          Archive( Archiver &arc );
      virtual void          Unarchive( Archiver &arc );
	};

inline void Mine::Archive
	(
	Archiver &arc
	)
   {
   Projectile::Archive( arc );
   arc.WriteSafePointer( detonator );
   arc.WriteBoolean( detonate );
   arc.WriteBoolean( sticky );
   }

inline void Mine::Unarchive
	(
	Archiver &arc
	)
   {
   Projectile::Unarchive( arc );
   arc.ReadSafePointer( &detonator );
   arc.ReadBoolean( &detonate );
   arc.ReadBoolean( &sticky );
   }

inline void Detonator::Archive
	(
	Archiver &arc
	)

   {
   int i;
   int num;

   Weapon::Archive( arc );
   
   arc.WriteInteger( currentMine );

   num = mineList.NumObjects();
   arc.WriteInteger( num );
   for( i = 1; i <= num; i++ )
      {
      arc.WriteSafePointer( mineList.ObjectAt( i ) );
      }
   }

inline void Detonator::Unarchive
	(
	Archiver &arc
	)

   {
   int i;
   int num;

   mineList.FreeObjectList();

   Weapon::Unarchive( arc );

   arc.ReadInteger( &currentMine );

   arc.ReadInteger( &num );
   mineList.Resize( num );
   for( i = 1; i <= num; i++ )
      {
      arc.ReadSafePointer( mineList.AddressOfObjectAt( i ) );
      }
   }

class SpiderMine : public Weapon
	{
   private:
      MinePtr           currentMine;
      DetonatorPtr      detonator;
	public:
		CLASS_PROTOTYPE( SpiderMine );
		
								SpiderMine::SpiderMine();
		virtual void		Shoot( Event *ev );
      virtual void		DoneFiring( Event *ev );
      virtual qboolean  ReadyToUse( void );
              void      ChangeToDetonator( Event *ev ); 
              void      SetDetonator( Detonator *det );
      virtual void      SetOwner( Sentient *sent );
              qboolean  IsDroppable( void );
      virtual void Archive( Archiver &arc );
      virtual void Unarchive( Archiver &arc );
	};

inline void SpiderMine::Archive
	(
	Archiver &arc
	)
   {
   Weapon::Archive( arc );
   arc.WriteSafePointer( currentMine );
   arc.WriteSafePointer( detonator );
   }

inline void SpiderMine::Unarchive
	(
	Archiver &arc
	)
   {
   Weapon::Unarchive( arc );
   arc.ReadSafePointer( &currentMine );
   arc.ReadSafePointer( &detonator );
   }


#endif /* SpiderMine.h */
