Descent3/scripts/generic.cpp

// generic.cpp
// 0.1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include "osiris_import.h"
#include "osiris_common.h"

#ifdef _MSC_VER		//Visual C++ Build
#define STDCALL		__stdcall
#define STDCALLPTR	*STDCALL
#else				//Non-Visual C++ Build
#define STDCALL __attribute__((stdcall))
#define STDCALLPTR	STDCALL*
#endif

#ifdef __cplusplus
extern "C"{
#endif
char	STDCALL InitializeDLL(tOSIRISModuleInit *func_list);
void	STDCALL ShutdownDLL(void);
int     STDCALL GetGOScriptID(char *name,ubyte isdoor);
void	STDCALLPTR CreateInstance(int id);
void	STDCALL DestroyInstance(int id,void *ptr);
short	STDCALL CallInstanceEvent(int id,void *ptr,int event,tOSIRISEventInfo *data);
int		STDCALL SaveRestoreState( void *file_ptr, ubyte saving_state );
#ifdef __cplusplus
}
#endif

int String_table_size = 0;
char **String_table = NULL;
static char *_Error_string = "!!ERROR MISSING STRING!!";
static char *_Empty_string = "";
char *GetStringFromTable(int index)
{
	if( (index<0) || (index>=String_table_size) )
		return _Error_string;
	if(!String_table[index])
		return _Empty_string;
		return String_table[index];
}
#define TXT(x) GetStringFromTable(x)
#define TXT_DOORLOCKED	TXT(0)			//"Door Locked!"
#define TXT_RAPIDFIRE	TXT(1)			//"Rapid Fire!"
#define TXT_FORCEWALL	TXT(2)			//"Force Wall!"
#define TXT_FORCEWALLEJECT TXT(3)		//"Force Wall Ejected!"
#define TXT_FORCEWALLDONE	TXT(4)		//"Force Wall Done!"
#define TXT_WINGNUT			TXT(5)		//"WingNut!"
#define TXT_RAPIDFIREOFF	TXT(6)		//"Rapid Fire Off!"
// ================
// Helper Functions
// ================
void AddHudMessage(int player_objhandle,int color,char *format,...);

#define ID_RAPIDFIRE				0
#define ID_FORCEWALL				1
#define ID_WINGNUT					2
#define NUM_IDS						3

// Common Powerups
// Weapon Powerups
// Ammo Powerups
#define GENERIC_POWERUP_SCRIPTID	NUM_IDS
//	Generic Door Script
#define GENERIC_DOOR_SCRIPTID		NUM_IDS+1

typedef struct{
	int id;
	char *name;
}tScriptIDInfo;

tScriptIDInfo ScriptIDInfo[NUM_IDS] = {
	{ID_RAPIDFIRE,"RapidFire"},
	{ID_FORCEWALL,"Forcewall"},
	{ID_WINGNUT,"GoWingNut"}
};

class GenericScript
{
public:
	GenericScript(){}
	virtual short CallEvent(int event,tOSIRISEventInfo *data);
protected:
};

class GenericDoor : public GenericScript
{
public:
	GenericDoor(){}
	short CallEvent(int event,tOSIRISEventInfo *data);
};

typedef struct
{
	int object_handle;
}forcewallmemory;

class ForceWallScript : public GenericScript
{
public:
	ForceWallScript();
	short CallEvent(int event,tOSIRISEventInfo *data);
	forcewallmemory *memory;
};

class WingNutScript : public GenericScript
{
public:
	WingNutScript(){}
	short CallEvent(int event,tOSIRISEventInfo *data);
};


typedef struct{
	int timer_handle;
}tPlayerTimerInfo;
tPlayerTimerInfo RapidFirePlayerTimers[MAX_PLAYERS];

typedef struct
{
	int collided_object;
	ubyte collided_pnum;
}rapidfirememory;

class RapidFireScript : public GenericScript
{
public:
	RapidFireScript();

	short CallEvent(int event,tOSIRISEventInfo *data);
	rapidfirememory *memory;
};


//	InitializeDLL
//	Purpose:
//		This function gets called when the DLL first gets loaded.  It will only be called once (until the
//	DLL is unloaded).  Passed in is a struct of data passed from the game needed for the DLL to interact
//	with D3.  Usually this function will just call osicommon_Initialize(), which sets up the imported
//	functions.  However, you can alloc some memory or whatever in this function, and free it in ShutdownDLL().
//	Note: You cannot call any imported functions until osicommon_Initialize() is called.
//	Returns 1 if initialization went ok, 0 if there was an error and the DLL should not be loaded.
char STDCALL InitializeDLL(tOSIRISModuleInit *func_list)
{
	osicommon_Initialize((tOSIRISModuleInit *)func_list);
	if(func_list->game_checksum!=CHECKSUM)
	{ 
		mprintf(0,"Game-Checksum FAIL!!! (%ul!=%ul)\n",func_list->game_checksum,CHECKSUM);
		mprintf(0,"RECOMPILE YOUR SCRIPTS!!!\n");
		return 0;
	}

	String_table_size = func_list->string_count;
	String_table = func_list->string_table;

	int i;

	//initialize rapid fire script data
	for(i=0;i<MAX_PLAYERS;i++){
		RapidFirePlayerTimers[i].timer_handle = -1;
	}

	return 1;
}

//	ShutdownDLL
//	Purpose:
//		This function is called right before a DLL is about to be unloaded from memory.  You can free
//	any unfree'd memory, or anything else you need to do.  Don't worry about destroying any instances
//	of scripts, as they will all be automatically destroyed before this function is called.  The
//	same goes for any memory allocated with Scrpt_MemAlloc(), as this will automatically be freed
//	when a scripts instance is destroyed.
void STDCALL ShutdownDLL(void)
{
}

//	GetGOScriptID
//	Purpose:
//		Given the name of the object (from it's pagename), this function will search through it's
//	list of General Object Scripts for a script with a matching name (to see if there is a script
//	for that type/id of object within this DLL).  If a matching scriptname is found, a UNIQUE ID
//	is to be returned back to Descent 3.  This ID will be used from here on out for all future
//	interaction with the DLL.  Since doors are not part of the generic object's, it's possible
//	for a door to have the same name as a generic object (OBJ_POWERUP, OBJ_BUILDING, OBJ_CLUTTER
//	or OBJ_ROBOT), therefore, a 1 is passed in for isdoor if the given object name refers to a
//	door, else it is a 0.  The return value is the unique identifier, else -1 if the script
//	does not exist in the DLL.
int STDCALL GetGOScriptID(char *name,ubyte isdoor)
{
	if(!isdoor){
		for(int i=0;i<NUM_IDS;i++){
			if(!stricmp(ScriptIDInfo[i].name,name))
				return ScriptIDInfo[i].id;
		}
	}

	return (isdoor)?GENERIC_DOOR_SCRIPTID:GENERIC_POWERUP_SCRIPTID;
}

//	CreateInstance
//	Purpose:
//		Given an ID from a call to GetGOScriptID(), this function will create a new instance for that
//	particular script (by allocating and initializing memory, etc.).  A pointer to this instance
//	is to be returned back to Descent 3.  This pointer will be passed around, along with the ID
//	for CallInstanceEvent() and DestroyInstance().  Return NULL if there was an error.
void STDCALLPTR CreateInstance(int id)
{
	switch(id){
	case GENERIC_POWERUP_SCRIPTID:
		return new GenericScript;
		break;
	case GENERIC_DOOR_SCRIPTID:
		return new GenericDoor;		
		break;
	case ID_RAPIDFIRE:
		return new RapidFireScript;
		break;
	case ID_WINGNUT:
		return new WingNutScript;
		break;
	case ID_FORCEWALL:
		return new ForceWallScript;
		break;
	};

	return NULL;
}

//	DestroyInstance
//	Purpose:
//		Given an ID, and a pointer to a particular instance of a script, this function will delete and
//	destruct all information associated with that script, so it will no longer exist.
void STDCALL DestroyInstance(int id,void *ptr)
{
	switch(id){
	case GENERIC_POWERUP_SCRIPTID:
		delete ((GenericScript *)ptr);
		break;
	case GENERIC_DOOR_SCRIPTID:
		delete ((GenericDoor *)ptr);
		break;
	case ID_RAPIDFIRE:
		delete ((RapidFireScript *)ptr);
		break;
	case ID_WINGNUT:
		delete ((WingNutScript *)ptr);
		break;
	case ID_FORCEWALL:
		delete ((ForceWallScript *)ptr);
		break;
	};
}

//	CallInstanceEvent
//	Purpose:
//		Given an ID, a pointer to a script instance, an event and a pointer to the struct of
//	information about the event, this function will translate who this event belongs to and
//	passes the event to that instance of the script to be handled.  Return a combination of
//	CONTINUE_CHAIN and CONTINUE_DEFAULT, to give instructions on what to do based on the
//	event. CONTINUE_CHAIN means to continue through the chain of scripts (custom script, level
//	script, mission script, and finally default script).  If CONTINUE_CHAIN is not specified,
//	than the chain is broken and those scripts of lower priority will never get the event.  Return
//	CONTINUE_DEFAULT in order to tell D3 if you want process the normal action that is built into
//	the game for that event.  This only pertains to certain events.  If the chain continues
//	after this script, than the CONTINUE_DEFAULT setting will be overridden by lower priority
//	scripts return value.
short STDCALL CallInstanceEvent(int id,void *ptr,int event,tOSIRISEventInfo *data)
{
	switch(id){
	case GENERIC_POWERUP_SCRIPTID: 
	case GENERIC_DOOR_SCRIPTID:
	case ID_RAPIDFIRE:
	case ID_FORCEWALL:
	case ID_WINGNUT:
		return ((GenericScript *)ptr)->CallEvent(event,data);
		break;
	};

	return CONTINUE_CHAIN|CONTINUE_DEFAULT;
}

//	SaveRestoreState
//	Purpose:
//		This function is called when Descent 3 is saving or restoring the game state.  In this function
//	you should save/restore any global data that you want preserved through load/save (which includes
//	demos).  You must be very careful with this function, corrupting the file (reading or writing too
//	much or too little) may be hazardous to the game (possibly making it impossible to restore the
//	state).  It would be best to use version information to keep older versions of saved states still
//	able to be used.  IT IS VERY IMPORTANT WHEN SAVING THE STATE TO RETURN THE NUMBER OF _BYTES_ WROTE
//	TO THE FILE.  When restoring the data, the return value is ignored.  saving_state is 1 when you should
//	write data to the file_ptr, 0 when you should read in the data.
#define VERSION 0x01
int STDCALL SaveRestoreState( void *file_ptr, ubyte saving_state )
{
	int size = 0;

	int i;
	int version = VERSION;

	if(saving_state){
		File_WriteByte(VERSION,file_ptr);	size++;

		//save out rapid fire data
		for(i=0;i<MAX_PLAYERS;i++){
			File_WriteInt(RapidFirePlayerTimers[i].timer_handle,file_ptr);
			size += sizeof(int);
		}
	}else{
		version = File_ReadByte(file_ptr);	size++;

		//restore rapid fire data
		for(i=0;i<MAX_PLAYERS;i++){
			RapidFirePlayerTimers[i].timer_handle = File_ReadInt(file_ptr);
			size += sizeof(int);
		}
	}

	return size;
}


short GenericScript::CallEvent(int event,tOSIRISEventInfo *data)
{
	switch(event){
	case EVT_COLLIDE:
		{
			msafe_struct ms;
			ms.objhandle = data->evt_collide.it_handle;
			MSafe_GetValue(MSAFE_OBJECT_TYPE,&ms);
			if(ms.type==OBJ_PLAYER){
				ms.objhandle = data->me_handle;
				ms.ithandle = data->evt_collide.it_handle;
				ms.playsound = 1;
				MSafe_DoPowerup(&ms);
				return CONTINUE_CHAIN|CONTINUE_DEFAULT;
			}
		}break;
	}
	return CONTINUE_CHAIN|CONTINUE_DEFAULT;
}

short GenericDoor::CallEvent(int event,tOSIRISEventInfo *data)
{
	switch(event){
	case EVT_COLLIDE:
		{
			msafe_struct ms;
			ms.objhandle = data->me_handle;
			MSafe_GetValue(MSAFE_OBJECT_TYPE,&ms);
			if(ms.type == OBJ_DOOR){
				msafe_struct mit;

				mit.objhandle = data->evt_collide.it_handle;
				MSafe_GetValue(MSAFE_OBJECT_TYPE,&mit);

				if(mit.type == OBJ_CLUTTER)
				{
					break;
				}

				//See if door is openable 
				ms.ithandle = data->evt_collide.it_handle;
				MSafe_GetValue(MSAFE_DOOR_OPENABLE,&ms);

				if(ms.state){
					//openable door
					MSafe_CallFunction(MSAFE_DOOR_ACTIVATE,&ms);
				}else{
					//non-openable door.  If locked, give a message
					MSafe_GetValue(MSAFE_DOOR_LOCK_STATE,&ms);
					if (ms.state) {		//locked!
						ms.objhandle = data->evt_collide.it_handle;

						MSafe_GetValue (MSAFE_OBJECT_PARENT,&ms);
						MSafe_GetValue (MSAFE_OBJECT_TYPE,&ms);

						if (ms.type==OBJ_PLAYER)
						{
							strcpy(ms.message,TXT_DOORLOCKED);
							ms.color = GR_RGB(0,255,0);
							MSafe_CallFunction(MSAFE_MISC_FILTERED_HUD_MESSAGE,&ms);

							ms.state = 1;		//specific player
							ms.index = Scrpt_FindSoundName("DoorIsLocked");
							ms.volume = 0.80f;
							if(ms.index!=-1)
								MSafe_CallFunction(MSAFE_SOUND_2D,&ms);
						}
					}
				}
			}				
		}break;
	}
	return CONTINUE_CHAIN|CONTINUE_DEFAULT;
}

RapidFireScript::RapidFireScript()
{
	memory = NULL;
}

#define RAPIDFIRE_RECHARGE	0.7f
short RapidFireScript::CallEvent(int event,tOSIRISEventInfo *data)
{
	switch(event){
	case EVT_CREATED:
		{
			tOSIRISMEMCHUNK ch;
			ch.id = 4;
			ch.size = sizeof(rapidfirememory);
			ch.my_id.type = OBJECT_SCRIPT;
			ch.my_id.objhandle = data->me_handle;

			memory = (rapidfirememory *)Scrpt_MemAlloc(&ch);
			memory->collided_pnum = 255;
			memory->collided_object = OBJECT_HANDLE_NONE;

		}break;

	case EVT_MEMRESTORE:
		{
			memory = (rapidfirememory *)data->evt_memrestore.memory_ptr;
		}break;

	case EVT_COLLIDE:
		{
			if(!memory)
				break;

			msafe_struct ms;
			ms.objhandle = data->evt_collide.it_handle;
			MSafe_GetValue(MSAFE_OBJECT_TYPE,&ms);

			if(ms.type==OBJ_PLAYER){
				
				AddHudMessage(data->evt_collide.it_handle,GR_RGB(0,255,0),TXT_RAPIDFIRE);
				int sound_id = Sound_FindId("RapidFireOn");
				Sound_Play3d(data->me_handle, sound_id);


				MSafe_GetValue(MSAFE_OBJECT_ID,&ms);
				memory->collided_pnum = ms.id;
				memory->collided_object = data->evt_collide.it_handle;

				if(RapidFirePlayerTimers[memory->collided_pnum].timer_handle!=-1){

					//check to see if the player currently has rapid fire
					MSafe_GetValue(MSAFE_OBJECT_RECHARGE_SCALAR,&ms);
					if(ms.scalar==RAPIDFIRE_RECHARGE){
						//the player currently has rapid fire
						//the player possibly has rapid fire set, check to make sure
						if(Scrpt_TimerExists(RapidFirePlayerTimers[memory->collided_pnum].timer_handle)){
							//cancel the old timer so we can create a new timer (give them more time)
							Scrpt_CancelTimer(RapidFirePlayerTimers[memory->collided_pnum].timer_handle);
						}

						RapidFirePlayerTimers[memory->collided_pnum].timer_handle = -1;
					}else{
						//rapid fire was stolen from the player

					}
				}

				memory->collided_pnum = ms.id;
				tOSIRISTIMER ti;
				ti.flags					= OTF_CANCELONDEAD;
				ti.id						= 31;
				ti.object_handle			= data->me_handle;
				ti.object_handle_detonator	= data->evt_collide.it_handle;
				ti.timer_interval			= 30;
				RapidFirePlayerTimers[memory->collided_pnum].timer_handle = Scrpt_CreateTimer(&ti);

				//ghost the object
				ms.objhandle = data->me_handle;
				MSafe_CallFunction(MSAFE_OBJECT_GHOST,&ms);

				//set player scalar
				ms.objhandle = data->evt_collide.it_handle;
				ms.scalar = RAPIDFIRE_RECHARGE;
				MSafe_CallFunction(	MSAFE_OBJECT_RECHARGE_SCALAR, &ms);
			}

		}break;
	case EVT_TIMER:
		{
			if(!memory)
				break;

			msafe_struct ms;
			ms.objhandle = memory->collided_object;
			MSafe_GetValue(MSAFE_OBJECT_RECHARGE_SCALAR,&ms);

			if(ms.scalar==RAPIDFIRE_RECHARGE){
				//reset recharge scalar
				ms.objhandle = memory->collided_object;
				ms.scalar = 1.0f;
				MSafe_CallFunction(	MSAFE_OBJECT_RECHARGE_SCALAR, &ms);
				RapidFirePlayerTimers[memory->collided_pnum].timer_handle = -1;
			}

			AddHudMessage(memory->collided_object,GR_RGB(0,255,0),TXT_RAPIDFIREOFF);
			int sound_id = Sound_FindId("RapidFireOff");
			Sound_Play3d(memory->collided_object, sound_id);					
	
			//destroy the powerup
			ms.objhandle = data->me_handle;
			ms.playsound = 0;
			MSafe_CallFunction(MSAFE_OBJECT_REMOVE,&ms);			
			
		}break;
	case EVT_TIMERCANCEL:
		{
			msafe_struct ms;

			//destroy the powerup
			ms.playsound = 0;
			ms.objhandle = data->me_handle;
			MSafe_CallFunction(MSAFE_OBJECT_REMOVE,&ms);
		}break;
	case EVT_INTERVAL:
		{
			//check (if we are ghosted...meaning picked up) if the player
			//that picked us up still has rapid fire
			if( memory && memory->collided_pnum!=255)
			{
				//check the player to make sure he is still charged up
				msafe_struct ms;
				ms.objhandle = memory->collided_object;
				MSafe_GetValue(MSAFE_OBJECT_RECHARGE_SCALAR,&ms);

				if(ms.scalar!=RAPIDFIRE_RECHARGE){
					//player no longer recharged! cancel timer
					if(Scrpt_TimerExists(RapidFirePlayerTimers[memory->collided_pnum].timer_handle)){
						//cancel the timer
						mprintf(0,"CANCELING RAPID FIRE TIMER FOR PLAYER %d\n",memory->collided_pnum);
						Scrpt_CancelTimer(RapidFirePlayerTimers[memory->collided_pnum].timer_handle);

						AddHudMessage(memory->collided_object,GR_RGB(0,255,0),TXT_RAPIDFIREOFF);
						int sound_id = Sound_FindId("RapidFireOff");
						Sound_Play3d(memory->collided_object, sound_id);					
					}

					RapidFirePlayerTimers[memory->collided_pnum].timer_handle = -1;
					memory->collided_pnum = 255;
					memory->collided_object = OBJECT_HANDLE_NONE;
				}
			}

		}break;
	}

	return CONTINUE_CHAIN|CONTINUE_DEFAULT;
}

ForceWallScript::ForceWallScript()
{
	memory = NULL;
}

short ForceWallScript::CallEvent(int event,tOSIRISEventInfo *data)
{
	switch(event){

	case EVT_CREATED:
		{
			tOSIRISMEMCHUNK ch;
			ch.id = 4;
			ch.size = sizeof(forcewallmemory);
			ch.my_id.type = OBJECT_SCRIPT;
			ch.my_id.objhandle = data->me_handle;

			memory = (forcewallmemory *)Scrpt_MemAlloc(&ch);
			memory->object_handle = OBJECT_HANDLE_NONE;

		}break;

	case EVT_MEMRESTORE:
		{
			memory = (forcewallmemory *)data->evt_memrestore.memory_ptr;
		}break;

	case EVT_COLLIDE:
		{
			if(!memory)
				break;

			msafe_struct ms;
			ms.objhandle = data->evt_collide.it_handle;
			MSafe_GetValue(MSAFE_OBJECT_TYPE,&ms);
			int pnum;

			if(ms.type==OBJ_PLAYER){
				MSafe_GetValue(MSAFE_OBJECT_ID,&ms);
				pnum = ms.id;

				AddHudMessage(data->evt_collide.it_handle,GR_RGB(0,255,0),TXT_FORCEWALL);

				//add a force wall to the inventory
				ms.objhandle = data->me_handle;
				MSafe_GetValue(MSAFE_OBJECT_ID,&ms);
				ms.slot = pnum;
				ms.type = OBJ_POWERUP;		
				ms.flags = INVAF_TIMEOUTONSPEW;
				MSafe_CallFunction(MSAFE_INVEN_ADD_TYPE_ID,&ms);

				//pickit up
				ms.playsound = 1;
				MSafe_CallFunction(MSAFE_OBJECT_REMOVE,&ms);
			}
		}break;
	case EVT_USE:
		{
			if(!memory)
				break;

			msafe_struct ms;

			//Eject a ForceWall and make it last for 60 seconds
			memory->object_handle = data->evt_use.it_handle; //save the player for when the timer is up

			AddHudMessage(memory->object_handle,GR_RGB(0,255,0),TXT_FORCEWALLEJECT);

			//ghost the object and set a timer
			tOSIRISTIMER ti;
			ti.flags					= 0;	//not a volatile object when dropped
			ti.id						= 32;
			ti.object_handle			= data->me_handle;
			ti.timer_interval			= 60;
			Scrpt_CreateTimer(&ti);

			//ghost the object
			ms.objhandle = data->me_handle;
			MSafe_CallFunction(MSAFE_OBJECT_GHOST,&ms);

			// Do the Force Wall stuff here
			
		}break;
	case EVT_TIMER:
		{
			if(!memory)
				break;

			msafe_struct ms;

			// End Force Wall stuff here


			AddHudMessage(memory->object_handle,GR_RGB(0,255,0),TXT_FORCEWALLDONE);

			//UnGhost the object
			ms.objhandle = data->me_handle;
			//@@MSafe_CallFunction(MSAFE_OBJECT_UNGHOST,&ms);

			//destroy the powerup
			ms.playsound = 0;
			MSafe_CallFunction(MSAFE_OBJECT_REMOVE,&ms);

		}break;
	}

	return CONTINUE_CHAIN|CONTINUE_DEFAULT;
}

short WingNutScript::CallEvent(int event,tOSIRISEventInfo *data)
{
	switch(event){
	case EVT_COLLIDE:
		{
			msafe_struct ms;
			ms.objhandle = data->evt_collide.it_handle;
			MSafe_GetValue(MSAFE_OBJECT_TYPE,&ms);
			int pnum;

			if(ms.type==OBJ_PLAYER){
				MSafe_GetValue(MSAFE_OBJECT_ID,&ms);
				pnum = ms.id;

				AddHudMessage(data->evt_collide.it_handle,GR_RGB(0,255,0),TXT_WINGNUT);

				//add a wing nut to the inventory
				ms.objhandle = data->me_handle;
				MSafe_GetValue(MSAFE_OBJECT_ID,&ms);
				ms.slot = pnum;
				ms.type = OBJ_POWERUP;
				ms.flags = INVAF_TIMEOUTONSPEW;
				MSafe_CallFunction(MSAFE_INVEN_ADD_TYPE_ID,&ms);

				//pickit up
				ms.playsound = 1;
				MSafe_CallFunction(MSAFE_OBJECT_REMOVE,&ms);
			}
		}break;
	case EVT_USE:
		{
		}break;
	}

	return CONTINUE_CHAIN|CONTINUE_DEFAULT;
}



void AddHudMessage(int player_objhandle,int color,char *format,...)
{
	msafe_struct ms;
	ms.objhandle = player_objhandle;
	MSafe_GetValue(MSAFE_OBJECT_TYPE,&ms);
	if(ms.type==OBJ_PLAYER){
		MSafe_GetValue(MSAFE_OBJECT_ID,&ms);
		ms.slot = ms.id;
		ms.color = color;
		char big_buffer[1024];
		va_list marker;
		va_start(marker,format);
		vsprintf(big_buffer,format,marker);
		va_end(marker);
		strncpy(ms.message,big_buffer,MSAFE_MESSAGE_LENGTH-1);
		ms.message[MSAFE_MESSAGE_LENGTH-1] = '\0';

		MSafe_CallFunction(MSAFE_MISC_FILTERED_HUD_MESSAGE,&ms);
	}
}