Archive/openmohaa
0
0
Fork 0
mirror of https://github.com/openmoh/openmohaa.git synced 2025-05-09 20:18:17 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Formatted document

Browse source
This commit is contained in:
smallmodel 2023-08-08 23:46:45 +02:00
parent 484b2a8900
commit 94c501e71b
No known key found for this signature in database
GPG key ID: A96F163ED4891440
2 changed files with 2232 additions and 2978 deletions
Download patch file Download diff file Expand all files Collapse all files

2659
code/fgame/trigger.cpp
View file

File diff suppressed because it is too large Load diff

729
code/fgame/trigger.h
View file

@ -51,8 +51,8 @@ extern Event EV_Trigger_SetNotTriggerable;
#define TRIGGER_PROJECTILES 16 #define TRIGGER_PROJECTILES 16
class Trigger : public Animate class Trigger : public Animate
{ {
protected: protected:
float wait; float wait;
float delay; float delay;
float trigger_time; float trigger_time;
@ -73,94 +73,90 @@ class Trigger : public Animate
qboolean edgeTriggered; // if true, trigger only triggers when entering trigger, not when standing in it qboolean edgeTriggered; // if true, trigger only triggers when entering trigger, not when standing in it
int multiFaceted; // if 0, it isn't. if 1 it is N/S oriented, if 2 it is E/W oriented int multiFaceted; // if 0, it isn't. if 1 it is N/S oriented, if 2 it is E/W oriented
public: public:
CLASS_PROTOTYPE( Trigger ); CLASS_PROTOTYPE(Trigger);
Trigger(); Trigger();
virtual ~Trigger(); virtual ~Trigger();
// override this to allow objects other than players, projectiles, and monsters to activate the trigger // override this to allow objects other than players, projectiles, and monsters to activate the trigger
virtual qboolean respondTo( Entity *other ); virtual qboolean respondTo(Entity *other);
// override this to redirect messages to an entity other than the one who triggered it // override this to redirect messages to an entity other than the one who triggered it
virtual Entity *getActivator( Entity *other ); virtual Entity *getActivator(Entity *other);
void SetModelEvent( Event *ev ); void SetModelEvent(Event *ev);
void Touch( Event *ev ); void Touch(Event *ev);
void EventSetWait( Event *ev ); void EventSetWait(Event *ev);
void EventSetDelay( Event *ev ); void EventSetDelay(Event *ev);
void EventSetCount( Event *ev ); void EventSetCount(Event *ev);
void EventSetKey( Event *ev ); void EventSetKey(Event *ev);
void EventSetHealth( Event *ev ); void EventSetHealth(Event *ev);
void EventSetThread( Event *ev ); void EventSetThread(Event *ev);
void SetTriggerDir( Event *ev ); void SetTriggerDir(Event *ev);
void SetTriggerable( Event *ev ); void SetTriggerable(Event *ev);
void SetNotTriggerable( Event *ev ); void SetNotTriggerable(Event *ev);
void SetMultiFaceted( Event *ev ); void SetMultiFaceted(Event *ev);
void SetEdgeTriggered( Event *ev ); void SetEdgeTriggered(Event *ev);
void SetTriggerCone( Event *ev ); void SetTriggerCone(Event *ev);
void EventSetMessage( Event *ev ); void EventSetMessage(Event *ev);
void SetMessage( const char *message ); void SetMessage(const char *message);
str &Message( void ); str& Message(void);
void EventSetNoise( Event *ev ); void EventSetNoise(Event *ev);
void SetNoise( const char *text ); void SetNoise(const char *text);
str &Noise( void ); str& Noise(void);
void SetTriggerDir( float angle ); void SetTriggerDir(float angle);
Vector GetTriggerDir( void ); Vector GetTriggerDir(void);
qboolean UsingTriggerDir( void ); qboolean UsingTriggerDir(void);
void SetMultiFaceted( int newFacet ); void SetMultiFaceted(int newFacet);
void SetEdgeTriggered( qboolean newEdge ); void SetEdgeTriggered(qboolean newEdge);
int GetMultiFaceted( void ); int GetMultiFaceted(void);
qboolean GetEdgeTriggered( void ); qboolean GetEdgeTriggered(void);
void StartThread( Event *ev ); void StartThread(Event *ev);
void TriggerStuff( Event *ev ); void TriggerStuff(Event *ev);
void ActivateTargets( Event *ev ); void ActivateTargets(Event *ev);
void Archive( Archiver &arc ) override; void Archive(Archiver& arc) override;
}; };
inline void Trigger::Archive inline void Trigger::Archive(Archiver& arc)
( {
Archiver &arc Animate::Archive(arc);
)
{
Animate::Archive( arc );
arc.ArchiveFloat( &wait ); arc.ArchiveFloat(&wait);
arc.ArchiveFloat( &delay ); arc.ArchiveFloat(&delay);
arc.ArchiveFloat( &trigger_time ); arc.ArchiveFloat(&trigger_time);
arc.ArchiveBoolean( &triggerActivated ); arc.ArchiveBoolean(&triggerActivated);
arc.ArchiveInteger( &count ); arc.ArchiveInteger(&count);
arc.ArchiveString( &noise ); arc.ArchiveString(&noise);
if ( arc.Loading() ) if (arc.Loading()) {
{ SetNoise(noise.c_str());
SetNoise( noise.c_str() );
}
arc.ArchiveString( &message );
arc.ArchiveString( &key );
arc.ArchiveSafePointer( &activator );
arc.ArchiveInteger( &respondto );
arc.ArchiveBoolean( &useTriggerDir );
arc.ArchiveFloat( &triggerCone );
arc.ArchiveVector( &triggerDir );
arc.ArchiveFloat( &triggerDirYaw );
arc.ArchiveBoolean( &triggerable );
arc.ArchiveBoolean( &removable );
arc.ArchiveBoolean( &edgeTriggered );
arc.ArchiveInteger( &multiFaceted );
} }
arc.ArchiveString(&message);
arc.ArchiveString(&key);
arc.ArchiveSafePointer(&activator);
arc.ArchiveInteger(&respondto);
arc.ArchiveBoolean(&useTriggerDir);
arc.ArchiveFloat(&triggerCone);
arc.ArchiveVector(&triggerDir);
arc.ArchiveFloat(&triggerDirYaw);
arc.ArchiveBoolean(&triggerable);
arc.ArchiveBoolean(&removable);
arc.ArchiveBoolean(&edgeTriggered);
arc.ArchiveInteger(&multiFaceted);
}
class TriggerVehicle : public Trigger class TriggerVehicle : public Trigger
{ {
public: public:
CLASS_PROTOTYPE( TriggerVehicle ); CLASS_PROTOTYPE(TriggerVehicle);
qboolean respondTo( Entity *other ) override; qboolean respondTo(Entity *other) override;
}; };
class TriggerAllEntry class TriggerAllEntry
@ -170,68 +166,62 @@ public:
float time; float time;
public: public:
static void Archive( Archiver& arc, TriggerAllEntry *obj ); static void Archive(Archiver& arc, TriggerAllEntry *obj);
}; };
class TriggerAll : public Trigger class TriggerAll : public Trigger
{ {
private: private:
Container< TriggerAllEntry > entries; Container<TriggerAllEntry> entries;
public: public:
CLASS_PROTOTYPE( TriggerAll ); CLASS_PROTOTYPE(TriggerAll);
void Archive( Archiver& arc ) override; void Archive(Archiver& arc) override;
void TriggerStuff( Event *ev ); void TriggerStuff(Event *ev);
bool IsTriggerable( Entity *other ); bool IsTriggerable(Entity *other);
void SetTriggerTime( Entity *other, float time ); void SetTriggerTime(Entity *other, float time);
}; };
inline void TriggerAll::Archive inline void TriggerAll::Archive(Archiver& arc)
(
Archiver& arc
)
{ {
Trigger::Archive( arc ); Trigger::Archive(arc);
entries.Archive( arc, &TriggerAllEntry::Archive ); entries.Archive(arc, &TriggerAllEntry::Archive);
} }
class TouchField : public Trigger class TouchField : public Trigger
{ {
private: private:
Event *ontouch; Event *ontouch;
EntityPtr owner; EntityPtr owner;
public: public:
CLASS_PROTOTYPE( TouchField ); CLASS_PROTOTYPE(TouchField);
TouchField(); TouchField();
virtual void Setup( Entity *ownerentity, Event &ontouch, Vector min, Vector max, int respondto ); virtual void Setup(Entity *ownerentity, Event& ontouch, Vector min, Vector max, int respondto);
void SendEvent( Event *ev ); void SendEvent(Event *ev);
void Archive( Archiver &arc ) override; void Archive(Archiver &arc) override;
}; };
inline void TouchField::Archive inline void TouchField::Archive(Archiver& arc)
( {
Archiver &arc Trigger::Archive(arc);
)
{
Trigger::Archive( arc );
arc.ArchiveEventPointer( &ontouch ); arc.ArchiveEventPointer(&ontouch);
arc.ArchiveSafePointer( &owner ); arc.ArchiveSafePointer(&owner);
} }
typedef SafePtr<TouchField> TouchFieldPtr; typedef SafePtr<TouchField> TouchFieldPtr;
class TriggerOnce : public Trigger class TriggerOnce : public Trigger
{ {
public: public:
CLASS_PROTOTYPE( TriggerOnce ); CLASS_PROTOTYPE(TriggerOnce);
TriggerOnce(); TriggerOnce();
}; };
class TriggerSave : public Trigger class TriggerSave : public Trigger
{ {
@ -239,96 +229,87 @@ private:
str m_sSaveName; str m_sSaveName;
public: public:
CLASS_PROTOTYPE( TriggerSave ); CLASS_PROTOTYPE(TriggerSave);
void SaveGame( Event *ev ); void SaveGame(Event *ev);
void EventSaveName( Event *ev ); void EventSaveName(Event *ev);
void Archive( Archiver& arc ) override; void Archive(Archiver& arc) override;
}; };
inline void TriggerSave::Archive inline void TriggerSave::Archive(Archiver& arc)
(
Archiver &arc
)
{ {
Trigger::Archive( arc ); Trigger::Archive(arc);
arc.ArchiveString( &m_sSaveName ); arc.ArchiveString(&m_sSaveName);
} }
class TriggerRelay : public Trigger class TriggerRelay : public Trigger
{ {
public: public:
CLASS_PROTOTYPE( TriggerRelay ); CLASS_PROTOTYPE(TriggerRelay);
TriggerRelay(); TriggerRelay();
}; };
class TriggerSecret : public TriggerOnce class TriggerSecret : public TriggerOnce
{ {
public: public:
CLASS_PROTOTYPE( TriggerSecret ); CLASS_PROTOTYPE(TriggerSecret);
TriggerSecret(); TriggerSecret();
void FoundSecret( Event *ev ); void FoundSecret(Event *ev);
void Activate( Event *ev ); void Activate(Event *ev);
}; };
class TriggerPush : public Trigger class TriggerPush : public Trigger
{ {
protected: protected:
float speed; float speed;
public: public:
CLASS_PROTOTYPE( TriggerPush ); CLASS_PROTOTYPE(TriggerPush);
TriggerPush(); TriggerPush();
void Push( Event *ev ); void Push(Event *ev);
void SetPushDir( Event *ev ); void SetPushDir(Event *ev);
void SetPushSpeed( Event *ev ); void SetPushSpeed(Event *ev);
void Archive( Archiver &arc ) override; void Archive(Archiver& arc) override;
}; };
inline void TriggerPush::Archive inline void TriggerPush::Archive(Archiver& arc)
( {
Archiver &arc Trigger::Archive(arc);
)
{
Trigger::Archive( arc );
arc.ArchiveFloat( &speed ); arc.ArchiveFloat(&speed);
} }
class TriggerPushAny : public Trigger class TriggerPushAny : public Trigger
{ {
protected: protected:
float speed; float speed;
public: public:
CLASS_PROTOTYPE( TriggerPushAny ); CLASS_PROTOTYPE(TriggerPushAny);
TriggerPushAny(); TriggerPushAny();
void Push( Event *ev ); void Push(Event *ev);
void SetSpeed( Event *ev ); void SetSpeed(Event *ev);
void Archive( Archiver &arc ) override; void Archive(Archiver& arc) override;
}; };
inline void TriggerPushAny::Archive inline void TriggerPushAny::Archive(Archiver& arc)
( {
Archiver &arc Trigger::Archive(arc);
)
{
Trigger::Archive( arc );
arc.ArchiveFloat( &speed ); arc.ArchiveFloat(&speed);
} }
#define AMBIENT_ON ( 1 << 0 ) #define AMBIENT_ON (1 << 0)
#define AMBIENT_OFF ( 1 << 1 ) #define AMBIENT_OFF (1 << 1)
#define TOGGLESOUND ( 1 << 5 ) #define TOGGLESOUND (1 << 5)
class TriggerPlaySound : public Trigger class TriggerPlaySound : public Trigger
{ {
protected: protected:
friend class SoundManager; friend class SoundManager;
int state; int state;
@ -337,95 +318,87 @@ class TriggerPlaySound : public Trigger
int channel; int channel;
qboolean ambient; qboolean ambient;
public: public:
CLASS_PROTOTYPE( TriggerPlaySound ); CLASS_PROTOTYPE(TriggerPlaySound);
TriggerPlaySound(); TriggerPlaySound();
void ToggleSound( Event *ev ); void ToggleSound(Event *ev);
void SetVolume( Event *ev ); void SetVolume(Event *ev);
void SetMinDist( Event *ev ); void SetMinDist(Event *ev);
void SetChannel( Event *ev ); void SetChannel(Event *ev);
void StartSound( void ); void StartSound(void);
void SetVolume( float vol ); void SetVolume(float vol);
void SetMinDist( float dist ); void SetMinDist(float dist);
void Archive( Archiver &arc ) override; void Archive(Archiver& arc) override;
}; };
inline void TriggerPlaySound::Archive inline void TriggerPlaySound::Archive(Archiver& arc)
( {
Archiver &arc Trigger::Archive(arc);
)
{
Trigger::Archive( arc );
arc.ArchiveInteger( &state ); arc.ArchiveInteger(&state);
arc.ArchiveFloat( &min_dist ); arc.ArchiveFloat(&min_dist);
arc.ArchiveFloat( &volume ); arc.ArchiveFloat(&volume);
arc.ArchiveInteger( &channel ); arc.ArchiveInteger(&channel);
arc.ArchiveBoolean( &ambient ); arc.ArchiveBoolean(&ambient);
if ( arc.Loading() ) if (arc.Loading()) {
{
// //
// see if its a toggle sound, if it is, lets start its sound again // see if its a toggle sound, if it is, lets start its sound again
// //
if ( spawnflags & TOGGLESOUND ) if (spawnflags & TOGGLESOUND) {
{
// //
// invert state so that final state will be right // invert state so that final state will be right
// //
state = !state; state = !state;
PostEvent( EV_Trigger_Effect, EV_POSTSPAWN ); PostEvent(EV_Trigger_Effect, EV_POSTSPAWN);
}
} }
} }
}
class TriggerSpeaker : public TriggerPlaySound class TriggerSpeaker : public TriggerPlaySound
{ {
public: public:
CLASS_PROTOTYPE( TriggerSpeaker ); CLASS_PROTOTYPE(TriggerSpeaker);
TriggerSpeaker(); TriggerSpeaker();
}; };
class RandomSpeaker : public TriggerSpeaker class RandomSpeaker : public TriggerSpeaker
{ {
protected: protected:
friend class SoundManager; friend class SoundManager;
float chance; float chance;
float mindelay; float mindelay;
float maxdelay; float maxdelay;
public: public:
CLASS_PROTOTYPE( RandomSpeaker ); CLASS_PROTOTYPE(RandomSpeaker);
RandomSpeaker(); RandomSpeaker();
void TriggerSound( Event *ev ); void TriggerSound(Event *ev);
void SetMinDelay( Event *ev ); void SetMinDelay(Event *ev);
void SetMaxDelay( Event *ev ); void SetMaxDelay(Event *ev);
void SetChance( Event *ev ); void SetChance(Event *ev);
void SetMinDelay( float value ); void SetMinDelay(float value);
void SetMaxDelay( float value ); void SetMaxDelay(float value);
void SetChance( float value ); void SetChance(float value);
void ScheduleSound( void ); void ScheduleSound(void);
void Archive( Archiver &arc ) override; void Archive(Archiver& arc) override;
}; };
inline void RandomSpeaker::Archive inline void RandomSpeaker::Archive(Archiver& arc)
( {
Archiver &arc TriggerSpeaker::Archive(arc);
)
{
TriggerSpeaker::Archive( arc );
arc.ArchiveFloat( &chance ); arc.ArchiveFloat(&chance);
arc.ArchiveFloat( &mindelay ); arc.ArchiveFloat(&mindelay);
arc.ArchiveFloat( &maxdelay ); arc.ArchiveFloat(&maxdelay);
} }
class TriggerChangeLevel : public Trigger class TriggerChangeLevel : public Trigger
{ {
@ -437,113 +410,106 @@ public:
CLASS_PROTOTYPE(TriggerChangeLevel); CLASS_PROTOTYPE(TriggerChangeLevel);
TriggerChangeLevel(); TriggerChangeLevel();
void SetMap(Event* ev); void SetMap(Event *ev);
void SetSpawnSpot(Event* ev); void SetSpawnSpot(Event *ev);
void ChangeLevel(Event* ev); void ChangeLevel(Event *ev);
const char* Map(void); const char *Map(void);
const char* SpawnSpot(void); const char *SpawnSpot(void);
void Archive(Archiver& arc) override; void Archive(Archiver &arc) override;
}; };
class TriggerExit : public Trigger class TriggerExit : public Trigger
{ {
public: public:
CLASS_PROTOTYPE( TriggerExit ); CLASS_PROTOTYPE(TriggerExit);
TriggerExit(); TriggerExit();
void DisplayExitSign( Event *ev ); void DisplayExitSign(Event *ev);
void TurnExitSignOff( Event *ev ); void TurnExitSignOff(Event *ev);
}; };
class TriggerUse : public Trigger class TriggerUse : public Trigger
{ {
public: public:
CLASS_PROTOTYPE( TriggerUse ); CLASS_PROTOTYPE(TriggerUse);
TriggerUse(); TriggerUse();
}; };
class TriggerUseOnce : public TriggerUse class TriggerUseOnce : public TriggerUse
{ {
public: public:
CLASS_PROTOTYPE( TriggerUseOnce ); CLASS_PROTOTYPE(TriggerUseOnce);
TriggerUseOnce(); TriggerUseOnce();
}; };
class TriggerHurt : public TriggerUse class TriggerHurt : public TriggerUse
{ {
protected: protected:
float damage; float damage;
void Hurt( Event *ev ); void Hurt(Event *ev);
void SetDamage( Event *ev ); void SetDamage(Event *ev);
public: public:
CLASS_PROTOTYPE( TriggerHurt ); CLASS_PROTOTYPE(TriggerHurt);
TriggerHurt(); TriggerHurt();
void Archive( Archiver &arc ) override; void Archive(Archiver& arc) override;
}; };
inline void TriggerHurt::Archive inline void TriggerHurt::Archive(Archiver& arc)
( {
Archiver &arc TriggerUse::Archive(arc);
)
{
TriggerUse::Archive( arc );
arc.ArchiveFloat( &damage ); arc.ArchiveFloat(&damage);
} }
class TriggerDamageTargets : public Trigger class TriggerDamageTargets : public Trigger
{ {
protected: protected:
float damage; float damage;
void DamageTargets( Event *ev ); void DamageTargets(Event *ev);
void SetDamage( Event *ev ); void SetDamage(Event *ev);
public: public:
CLASS_PROTOTYPE( TriggerDamageTargets ); CLASS_PROTOTYPE(TriggerDamageTargets);
TriggerDamageTargets(); TriggerDamageTargets();
void PassDamage( Event *ev ); void PassDamage(Event *ev);
void Archive( Archiver &arc ) override; void Archive(Archiver& arc) override;
}; };
inline void TriggerDamageTargets::Archive inline void TriggerDamageTargets::Archive(Archiver& arc)
(
Archiver &arc
)
{ {
Trigger::Archive( arc ); Trigger::Archive(arc);
arc.ArchiveFloat( &damage ); arc.ArchiveFloat(&damage);
} }
class TriggerCameraUse : public TriggerUse class TriggerCameraUse : public TriggerUse
{ {
public: public:
CLASS_PROTOTYPE( TriggerCameraUse ); CLASS_PROTOTYPE(TriggerCameraUse);
void TriggerCamera( Event * ev ); void TriggerCamera(Event *ev);
}; };
class TriggerBox : public Trigger class TriggerBox : public Trigger
{ {
public: public:
CLASS_PROTOTYPE( TriggerBox ); CLASS_PROTOTYPE(TriggerBox);
void SetMins( Event *ev ); void SetMins(Event *ev);
void SetMaxs( Event *ev ); void SetMaxs(Event *ev);
}; };
class TriggerMusic : public Trigger class TriggerMusic : public Trigger
{ {
private: private:
friend class SoundManager; friend class SoundManager;
qboolean oneshot; qboolean oneshot;
@ -551,43 +517,41 @@ class TriggerMusic : public Trigger
str fallback; str fallback;
str altcurrent; str altcurrent;
str altfallback; str altfallback;
public:
CLASS_PROTOTYPE( TriggerMusic ); public:
CLASS_PROTOTYPE(TriggerMusic);
TriggerMusic(); TriggerMusic();
void SetCurrentMood( Event *ev ); void SetCurrentMood(Event *ev);
void SetFallbackMood( Event *ev ); void SetFallbackMood(Event *ev);
void SetAltCurrentMood( Event *ev ); void SetAltCurrentMood(Event *ev);
void SetAltFallbackMood( Event *ev ); void SetAltFallbackMood(Event *ev);
void ChangeMood( Event *ev ); void ChangeMood(Event *ev);
void AltChangeMood( Event *ev ); void AltChangeMood(Event *ev);
void SetOneShot( Event *ev ); void SetOneShot(Event *ev);
void SetMood( str crnt, str fback ); void SetMood(str crnt, str fback);
void SetAltMood( str crnt, str fback ); void SetAltMood(str crnt, str fback);
void SetOneShot( qboolean once ); void SetOneShot(qboolean once);
void Archive( Archiver &arc ) override; void Archive(Archiver& arc) override;
}; };
inline void TriggerMusic::Archive inline void TriggerMusic::Archive(Archiver& arc)
(
Archiver &arc
)
{ {
Trigger::Archive( arc ); Trigger::Archive(arc);
arc.ArchiveBoolean( &oneshot ); arc.ArchiveBoolean(&oneshot);
arc.ArchiveString( &current ); arc.ArchiveString(&current);
arc.ArchiveString( &fallback ); arc.ArchiveString(&fallback);
arc.ArchiveString( &altcurrent ); arc.ArchiveString(&altcurrent);
arc.ArchiveString( &altfallback ); arc.ArchiveString(&altfallback);
} }
class TriggerReverb : public Trigger class TriggerReverb : public Trigger
{ {
private: private:
friend class SoundManager; friend class SoundManager;
qboolean oneshot; qboolean oneshot;
@ -595,138 +559,131 @@ class TriggerReverb : public Trigger
int altreverbtype; int altreverbtype;
float reverblevel; float reverblevel;
float altreverblevel; float altreverblevel;
public:
CLASS_PROTOTYPE( TriggerReverb ); public:
CLASS_PROTOTYPE(TriggerReverb);
TriggerReverb(); TriggerReverb();
void SetReverbLevel( Event *ev ); void SetReverbLevel(Event *ev);
void SetReverbType( Event *ev ); void SetReverbType(Event *ev);
void SetAltReverbType( Event *ev ); void SetAltReverbType(Event *ev);
void SetAltReverbLevel( Event *ev ); void SetAltReverbLevel(Event *ev);
void ChangeReverb( Event *ev ); void ChangeReverb(Event *ev);
void AltChangeReverb( Event *ev ); void AltChangeReverb(Event *ev);
void SetOneShot( Event *ev ); void SetOneShot(Event *ev);
void SetReverb( int type, float level ); void SetReverb(int type, float level);
void SetAltReverb( int type, float level ); void SetAltReverb(int type, float level);
void SetOneShot( qboolean once ); void SetOneShot(qboolean once);
void Archive( Archiver &arc ) override; void Archive(Archiver& arc) override;
}; };
inline void TriggerReverb::Archive inline void TriggerReverb::Archive(Archiver& arc)
(
Archiver &arc
)
{ {
Trigger::Archive( arc ); Trigger::Archive(arc);
arc.ArchiveBoolean( &oneshot ); arc.ArchiveBoolean(&oneshot);
arc.ArchiveInteger( &reverbtype ); arc.ArchiveInteger(&reverbtype);
arc.ArchiveInteger( &altreverbtype ); arc.ArchiveInteger(&altreverbtype);
arc.ArchiveFloat( &reverblevel ); arc.ArchiveFloat(&reverblevel);
arc.ArchiveFloat( &altreverblevel ); arc.ArchiveFloat(&altreverblevel);
} }
class TriggerByPushObject : public TriggerOnce class TriggerByPushObject : public TriggerOnce
{ {
private: private:
str triggername; str triggername;
void setTriggerName( Event *event ); void setTriggerName(Event *event);
public: public:
CLASS_PROTOTYPE( TriggerByPushObject ); CLASS_PROTOTYPE(TriggerByPushObject);
qboolean respondTo( Entity *other ) override; qboolean respondTo(Entity *other) override;
Entity *getActivator( Entity *other ) override; Entity *getActivator(Entity *other) override;
void Archive( Archiver &arc ) override; void Archive(Archiver& arc) override;
}; };
inline void TriggerByPushObject::Archive inline void TriggerByPushObject::Archive(Archiver& arc)
(
Archiver &arc
)
{ {
TriggerOnce::Archive( arc ); TriggerOnce::Archive(arc);
arc.ArchiveString( &triggername ); arc.ArchiveString(&triggername);
} }
class TriggerGivePowerup : public Trigger class TriggerGivePowerup : public Trigger
{ {
private: private:
qboolean oneshot; qboolean oneshot;
str powerup_name; str powerup_name;
public:
CLASS_PROTOTYPE( TriggerGivePowerup ); public:
CLASS_PROTOTYPE(TriggerGivePowerup);
TriggerGivePowerup(); TriggerGivePowerup();
void SetOneShot( Event *ev ); void SetOneShot(Event *ev);
void SetPowerupName( Event *ev ); void SetPowerupName(Event *ev);
void GivePowerup( Event *ev ); void GivePowerup(Event *ev);
void Archive( Archiver &arc ) override; void Archive(Archiver& arc) override;
}; };
inline void TriggerGivePowerup::Archive inline void TriggerGivePowerup::Archive(Archiver& arc)
(
Archiver &arc
)
{ {
Trigger::Archive( arc ); Trigger::Archive(arc);
arc.ArchiveBoolean( &oneshot ); arc.ArchiveBoolean(&oneshot);
arc.ArchiveString( &powerup_name ); arc.ArchiveString(&powerup_name);
} }
class TriggerClickItem : public Trigger class TriggerClickItem : public Trigger
{ {
public: public:
CLASS_PROTOTYPE( TriggerClickItem ); CLASS_PROTOTYPE(TriggerClickItem);
TriggerClickItem(); TriggerClickItem();
void SetClickItemModelEvent( Event *ev ); void SetClickItemModelEvent(Event *ev);
void Archive( Archiver& arc ) override; void Archive(Archiver& arc) override;
}; };
inline void TriggerClickItem::Archive inline void TriggerClickItem::Archive(Archiver& arc)
(
Archiver &arc
)
{ {
Trigger::Archive( arc ); Trigger::Archive(arc);
} }
class TriggerNoDamage : public TriggerUse { class TriggerNoDamage : public TriggerUse
{
public: public:
CLASS_PROTOTYPE(TriggerNoDamage); CLASS_PROTOTYPE(TriggerNoDamage);
public: public:
void TakeNoDamage(Event* ev); void TakeNoDamage(Event *ev);
}; };
class TriggerEntity : public Trigger { class TriggerEntity : public Trigger
{
public: public:
CLASS_PROTOTYPE(TriggerEntity); CLASS_PROTOTYPE(TriggerEntity);
}; };
class TriggerLandmine : public TriggerEntity { class TriggerLandmine : public TriggerEntity
{
public: public:
CLASS_PROTOTYPE(TriggerLandmine); CLASS_PROTOTYPE(TriggerLandmine);
TriggerLandmine(); TriggerLandmine();
void Archive(Archiver& arc) override; void Archive(Archiver& arc) override;
void EventIsAbandoned(Event* ev); void EventIsAbandoned(Event *ev);
void EventIsImmune(Event* ev); void EventIsImmune(Event *ev);
void EventSetDamageable(Event* ev); void EventSetDamageable(Event *ev);
void SetDamageable(qboolean damageable); void SetDamageable(qboolean damageable);
qboolean IsImmune(Entity* other) const; qboolean IsImmune(Entity *other) const;
void SetTeam(int team); void SetTeam(int team);
private: private: