void		Push( Event *ev );
      virtual void Archive(	Archiver &arc );
      virtual void Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void TriggerPushAny::Archive
	(
	Archiver &arc
	)
   {
   Trigger::Archive( arc );
   arc.WriteFloat( speed );
   arc.WriteVector( pushvelocity );
   }

inline EXPORT_FROM_DLL void TriggerPushAny::Unarchive
	(
	Archiver &arc
	)
   {
   Trigger::Unarchive( arc );
   arc.ReadFloat( &speed );
   arc.ReadVector( &pushvelocity );
   }

class EXPORT_FROM_DLL TriggerPlaySound : public Trigger
	{
	protected:
		int	state;
		float	attenuation;
		float	volume;
      int	channel;
      qboolean ambient;
		float fadetime;
      float timeofs;
      float pitch;

	public:
      CLASS_PROTOTYPE( TriggerPlaySound );

				TriggerPlaySound();
		void	ToggleSound( Event *ev );
		void	SetVolume( Event *ev );
		void	SetAttenuation( Event *ev );
		void	SetChannel( Event *ev );
      virtual void Archive(	Archiver &arc );
      virtual void Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void TriggerPlaySound::Archive
	(
	Archiver &arc
	)
   {
   Trigger::Archive( arc );
   arc.WriteInteger( state );
   arc.WriteFloat( attenuation );
   arc.WriteFloat( volume );
   arc.WriteInteger( channel );
   arc.WriteBoolean( ambient );
   arc.WriteFloat( fadetime );
   arc.WriteFloat( timeofs );
   arc.WriteFloat( pitch );
   }

inline EXPORT_FROM_DLL void TriggerPlaySound::Unarchive
	(
	Archiver &arc
	)
   {
   Trigger::Unarchive( arc );
   arc.ReadInteger( &state );
   arc.ReadFloat( &attenuation );
   arc.ReadFloat( &volume );
   arc.ReadInteger( &channel );
   arc.ReadBoolean( &ambient );
   arc.ReadFloat( &fadetime );
   arc.ReadFloat( &timeofs );
   arc.ReadFloat( &pitch );

   //
   // see if its a toggle sound, if it is, lets start its sound again
   //
   if ( spawnflags & 128 )
      {
      //
      // invert state so that final state will be right
      //
      state = !state;
      ToggleSound( NULL );
      }
   }


class EXPORT_FROM_DLL TriggerSpeaker : public TriggerPlaySound
	{
	public:
      CLASS_PROTOTYPE( TriggerSpeaker );

				TriggerSpeaker();
	};

class EXPORT_FROM_DLL RandomSpeaker : public TriggerSpeaker
	{
	protected:
      float mindelay;
      float maxdelay;

	public:
      CLASS_PROTOTYPE( RandomSpeaker );

				RandomSpeaker();
      void  TriggerSound( Event *ev	);
      void  ScheduleSound( void );
      virtual void Archive(	Archiver &arc );
      virtual void Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void RandomSpeaker::Archive
	(
	Archiver &arc
	)
   {
   TriggerSpeaker::Archive( arc );
   arc.WriteFloat( mindelay );
   arc.WriteFloat( maxdelay );
   }

inline EXPORT_FROM_DLL void RandomSpeaker::Unarchive
	(
	Archiver &arc
	)
   {
   TriggerSpeaker::Unarchive( arc );
   arc.ReadFloat( &mindelay );
   arc.ReadFloat( &maxdelay );
   }

class EXPORT_FROM_DLL TriggerChangeLevel : public Trigger
	{
	protected:
		str			map;
		str			spawnspot;
      str         changethread;

	public:
      CLASS_PROTOTYPE( TriggerChangeLevel );

						TriggerChangeLevel();
		void			ChangeLevel( Event *ev );
		const char	*Map( void );
		const char	*SpawnSpot( void );
      virtual void Archive(	Archiver &arc );
      virtual void Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void TriggerChangeLevel::Archive
	(
	Archiver &arc
	)
   {
   Trigger::Archive( arc );

   arc.WriteString( map );
   arc.WriteString( spawnspot );
   arc.WriteString( changethread );
   }

inline EXPORT_FROM_DLL void TriggerChangeLevel::Unarchive
	(
	Archiver &arc
	)
   {
   Trigger::Unarchive( arc );

   arc.ReadString( &map );
   arc.ReadString( &spawnspot );
   arc.ReadString( &changethread );
   }

class EXPORT_FROM_DLL TriggerExit : public Trigger
	{
	public:
      CLASS_PROTOTYPE( TriggerExit );

			  TriggerExit();
		void DisplayExitSign( Event *ev );
	};


class EXPORT_FROM_DLL TriggerUse : public Trigger
	{
	public:
      CLASS_PROTOTYPE( TriggerUse );
		
		TriggerUse();
	};

class EXPORT_FROM_DLL TriggerUseOnce : public TriggerUse
	{
	public:
      CLASS_PROTOTYPE( TriggerUseOnce );

		TriggerUseOnce();
	};

class EXPORT_FROM_DLL TriggerHurt : public TriggerUse
	{
	protected:
		float		damage;

		void		Hurt( Event *ev );
      void		SetDamage( Event *ev );

	public:
      CLASS_PROTOTYPE( TriggerHurt );

		             TriggerHurt();
      virtual void Archive(	Archiver &arc );
      virtual void Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void TriggerHurt::Archive
	(
	Archiver &arc
	)
   {
   Trigger::Archive( arc );

   arc.WriteFloat( damage );
   }

inline EXPORT_FROM_DLL void TriggerHurt::Unarchive
	(
	Archiver &arc
	)
   {
   Trigger::Unarchive( arc );

   arc.ReadFloat( &damage );
   }

class EXPORT_FROM_DLL TriggerDamageTargets : public Trigger
	{
	protected:
		float		    damage;

		void		    DamageTargets( Event *ev );

	public:
      CLASS_PROTOTYPE( TriggerDamageTargets );

		             TriggerDamageTargets();
		void	       PassDamage( Event *ev );
      virtual void Archive(	Archiver &arc );
      virtual void Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void TriggerDamageTargets::Archive
	(
	Archiver &arc
	)
   {
   Trigger::Archive( arc );

   arc.WriteFloat( damage );
   }

inline EXPORT_FROM_DLL void TriggerDamageTargets::Unarchive
	(
	Archiver &arc
	)
   {
   Trigger::Unarchive( arc );

   arc.ReadFloat( &damage );
   }

class EXPORT_FROM_DLL TriggerFixedDamageTargets : public TriggerDamageTargets
	{
	public:
      CLASS_PROTOTYPE( TriggerFixedDamageTargets );
	};

class EXPORT_FROM_DLL TriggerParticles : public Trigger
	{
	protected:
      Vector   dir;
      int      particlestyle;
      int      count;

	public:
      CLASS_PROTOTYPE( TriggerParticles );

                   TriggerParticles();
      void         SpawnParticles( Event *ev	);
      void         SetDirection( Event *ev );
      virtual void Archive(	Archiver &arc );
      virtual void Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void TriggerParticles::Archive
	(
	Archiver &arc
	)
   {
   Trigger::Archive( arc );
   
   arc.WriteVector( dir );
   arc.WriteInteger( particlestyle );
   arc.WriteInteger( count );
   }

inline EXPORT_FROM_DLL void TriggerParticles::Unarchive
	(
	Archiver &arc
	)
   {
   Trigger::Unarchive( arc );
   
   arc.ReadVector( &dir );
   arc.ReadInteger( &particlestyle );
   arc.ReadInteger( &count );
   }

class EXPORT_FROM_DLL RandomTriggerParticles : public TriggerParticles
	{
	protected:
      int   state;
      float mindelay;
      float maxdelay;

      void  ScheduleParticles( void );
      void  RandomParticles( Event * ev );
      void  ToggleParticles( Event * ev );

	public:
      CLASS_PROTOTYPE( RandomTriggerParticles );

      RandomTriggerParticles();
      virtual void Archive(	Archiver &arc );
      virtual void Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void RandomTriggerParticles::Archive
	(
	Archiver &arc
	)
   {
   TriggerParticles::Archive( arc );

   arc.WriteInteger( state );
   arc.WriteFloat( mindelay );
   arc.WriteFloat( maxdelay );
   }

inline EXPORT_FROM_DLL void RandomTriggerParticles::Unarchive
	(
	Archiver &arc
	)
   {
   TriggerParticles::Unarchive( arc );

   arc.ReadInteger( &state );
   arc.ReadFloat( &mindelay );
   arc.ReadFloat( &maxdelay );
   }

class EXPORT_FROM_DLL TriggerThread : public Trigger
	{
	public:
      CLASS_PROTOTYPE( TriggerThread );

		TriggerThread();
	};

class EXPORT_FROM_DLL TriggerCameraUse : public TriggerUse
	{
	public:
      CLASS_PROTOTYPE( TriggerCameraUse );

		void TriggerCamera( Event * ev );
	};

class EXPORT_FROM_DLL TriggerMutate : public TriggerUse
	{
	protected:
		void		Mutate( Event *ev );

	public:
      CLASS_PROTOTYPE( TriggerMutate );

		TriggerMutate();
	};

class EXPORT_FROM_DLL TriggerBox : public Trigger
	{
	public:
      CLASS_PROTOTYPE( TriggerBox );

		TriggerBox();
	};

#endif /* trigger.h */