hi
hab letztens auf unseren cs (1.6) (linux) server ein sound plugin hochgeladen dass auf chateingaben reagiert und halt sounds abspielt ! klappt alles wunderbar aber wenn jemadn frühzeitig stirbt oder so dann spamt er damit dumm rum !
1.) kann man bei dem ein limit setzen oder so , gibt es dafür zusätzliche plugins ? wo einer beim spammen gekickt wird ?
2.) hab ein plugin gefunden wo der plugin auf tote leute nicht reagiert aber es ist eine sma und wenn ich es zu einer amx machen will kommt ein "errror 100 concole" hab kp
helft mir bitte hier mal der plugin also der wo tote leute keine sounds abspielen:
Code:
/***************************************************************************
* plugin_sank_sounds.sma
* Author: Luke Sankey
* Date: March 21, 2001 - Original hard-coded version
* Date: July 2, 2001 - Rewrote to be text file configurable
* Last Updated: July 8, 2001
*
* This plugin will read from a text file keyword/wav file combinations
* and when a player says one of the keywords, it will trigger HL to play
* that wav file to all players. It allows reloading of the file without
* restarting the current level, as well as adding keyword/wav combinations
* from the console during gameplay. If it finds it can't read the file, it
* will automagically set file_access_read to 1 and then set it back to 0
* when it's done.
*
* My most deepest thanks goes to William Bateman (aka HunteR)
* http://thepit.shacknet.nu
* huntercc@hotmail.com
* For he was the one who got me motivated once again to write this plugin
* since I don't run a server anymore. And besides that, he helped write
* parts of it.
*
* For technical assistance with this plugin, please see the README.TXT file
* that was bundled in the zip file. When that fails (and it will, because
* I'm the one who wrote it) then please see the adminmod forums at
* http://www.adminmod.org If they still fail you, email Bill Bateman.
* As a very last final resort, email me: sank@spu.edu
*
* I hope you enjoy this new functionality on the old plugin_sank_sounds!
*
* Luke Sankey
* sank@spu.edu
***************************************************************************/
// Functions included in this plugin
// admin_sound_add "<keyword>;<dir\wav>"
// admin_sound_help
// admin_sound_off
// admin_sound_on
// admin_sound_reload [filename]
// admin_sound_remove "<keyword>;[dir\wav]"
// admin_sound_write <filename>
#include <core>
#include <string>
#include <admin>
#include <adminlib>
#include <sound>
#include <dead>
#define ACCESS_SOUND 512+64 // Access level for advanced sound commands.
new FILENAME[MAX_DATA_LENGTH] = "SND-LIST.CFG"; // Name of file to parse.
#define MAX_KEYWORDS 40 // Maximum number of keywords
#define MAX_RANDOM 10 // Maximum number of wavs per keyword
#define TOK_LENGTH 40 // Maximum length of keyword and wav file strings
#define NUM_PER_LINE 4 // Number of words per line from admin_sound_help
//#define DEBUG 1
/****************************************************************************/
/****************************************************************************/
/************** DO NOT MODIFY CONTENTS BELOW THIS LINE !!! ******************/
/************** DO NOT MODIFY CONTENTS BELOW THIS LINE !!! ******************/
/************** DO NOT MODIFY CONTENTS BELOW THIS LINE !!! ******************/
/****************************************************************************/
/****************************************************************************/
new STRING_VERSION[MAX_DATA_LENGTH] = "2.50.e";
/****************************************************************************/
/* Holds the number telling how many sounds a player has played */
new SndCount[MAX_PLAYERS] = {0,...};
/* The number at which a player will get warned for playing too many sounds */
new SND_WARN = 0;
/* The number at which a player will get kicked for playing too many sounds */
new SND_KICK = 0;
/* The wav to play when a person joins the game */
new SND_JOIN[TOK_LENGTH] = "";
/* The wav to play when a person exits the game */
new SND_EXIT[TOK_LENGTH] = "";
/****************************************************************************/
/****************************************************************************/
/* First column is the indentifier of the Word-Wav Combination */
/* Second column is the token identifier */
/* Third column is the token (string) */
/* Empty tokens are delimited by empty strings */
/****************************************************************************/
/*
[0] [TOK_LENGTH*0] ["crap"]
[0] [TOK_LENGTH*1] ["misc/awwcrap.wav"]
[0] [TOK_LENGTH*2] ["misc/awwcrap2.wav"]
[0] [TOK_LENGTH*3] [""]
[1] [TOK_LENGTH*0] ["woohoo"]
[1] [TOK_LENGTH*1] ["misc/woohoo.wav"]
[1] [TOK_LENGTH*2] [""]
[2] [TOK_LENGTH*0] ["ha ha"]
[2] [TOK_LENGTH*1] ["misc/haha.wav"]
[2] [TOK_LENGTH*2] [""]
[3] [TOK_LENGTH*0] ["doh"]
[3] [TOK_LENGTH*1] ["misc/doh.wav"]
[3] [TOK_LENGTH*2] ["misc/doh2.wav"]
[3] [TOK_LENGTH*3] ["misc/doh3.wav"]
[3] [TOK_LENGTH*4] ["misc/doh4.wav"]
[3] [TOK_LENGTH*5] [""]
[4] [TOK_LENGTH*0] [""]
...
*/
new WordWavCombo[MAX_KEYWORDS][TOK_LENGTH*(MAX_RANDOM+1)];
/****************************************************************************/
new LastSoundTime = 0; // Used for very limited spam protection
new bSoundsEnabled = 1; // Used for admin_sound_on and admin_sound_off
/****************************************************************************/
/****************************************************************************/
/****************************************************************************/
public plugin_init()
{
plugin_registerinfo("Sank Sounds Plugin", "Responds to certain chat messages by playing a sound.", STRING_VERSION);
plugin_registercmd("say", "HandleSay", ACCESS_ALL);
plugin_registercmd("admin_sound_add", "admin_sound_add", ACCESS_SOUND, "admin_sound_add ^"<keyword>;<dir\wav>^" : Adds a word/wav combo for the duration of the level.");
plugin_registercmd("admin_sound_help", "admin_sound_help", ACCESS_ALL, "admin_sound_help: Lists all sounds associated with say command");
plugin_registercmd("admin_sound_off", "admin_sound_off", ACCESS_SOUND, "admin_sound_off: Turns off sounds.");
plugin_registercmd("admin_sound_on", "admin_sound_on", ACCESS_SOUND, "admin_sound_on: Turns on sounds.");
plugin_registercmd("admin_sound_reload", "admin_sound_reload", ACCESS_SOUND, "admin_sound_reload: Re-parses sound list config file.");
plugin_registercmd("admin_sound_remove", "admin_sound_remove", ACCESS_SOUND, "admin_sound_remove ^"<keyword>;[dir\wav]^" : Adds a word/wav combo for the duration of the level.");
plugin_registercmd("admin_sound_write", "admin_sound_write", ACCESS_SOUND, "admin_sound_write: Writes current sound configuration to file.");
#if defined (DEBUG)
plugin_registercmd("admin_sound_debug", "print_matrix", ACCESS_SOUND, "admin_sound_debug");
#endif
parse_sound_file(FILENAME);
return PLUGIN_CONTINUE;
}
public plugin_connect(HLUserName, HLIP, UserIndex)
{
playsoundall(SND_JOIN);
if (UserIndex >= 1 && UserIndex <= MAX_PLAYERS)
SndCount[UserIndex] = 0;
return PLUGIN_CONTINUE;
}
public plugin_disconnect(HLUserName, UserIndex)
{
if (UserIndex >= 1 && UserIndex <= MAX_PLAYERS)
SndCount[UserIndex] = 0;
playsoundall(SND_EXIT);
return PLUGIN_CONTINUE;
}
/****************************************************************************/
/****************************************************************************/
/****************************************************************************/
//////////////////////////////////////////////////////////////////////////////
// Adds a Word/Wav combo to the list. If it is a valid line in the config
// file, then it is a valid parameter here. The only difference is you can
// only specify one .wav file at a time with this command.
//
// Usage: admin_sound_add "<keyword>;<dir\wav>"
// Usage: admin_sound_add "<setting>;<value>"
//////////////////////////////////////////////////////////////////////////////
public admin_sound_add(HLCommand, HLData, HLUserName, UserIndex)
{
new Data[MAX_DATA_LENGTH];
new User[MAX_NAME_LENGTH];
new Word[TOK_LENGTH];
new Wav[TOK_LENGTH];
new Text[MAX_TEXT_LENGTH];
new i;
new j;
convert_string(HLData, Data, MAX_DATA_LENGTH);
convert_string(HLUserName, User, MAX_NAME_LENGTH);
// Parse command line
strsplit(Data, ";", Word, TOK_LENGTH, Wav, TOK_LENGTH);
// Remove whitespace
strtrim(Word, " ^t");
strtrim(Wav, " ^t");
if(strlen(Data) == 0 || strlen(Wav) == 0)
{
selfmessage("Invalid format.");
selfmessage("USAGE: admin_sound_add ^"<keyword>;<dir\wav>^"");
return PLUGIN_HANDLED;
}
// First look for special parameters
if (!strcasecmp(Data, "SND_KICK"))
SND_KICK = strtonum(Wav);
else if (!strcasecmp(Data, "SND_WARN"))
SND_WARN = strtonum(Wav);
else if (!strcasecmp(Data, "SND_JOIN"))
strcpy(SND_JOIN, Wav, TOK_LENGTH);
else if (!strcasecmp(Data, "SND_EXIT"))
strcpy(SND_EXIT, Wav, TOK_LENGTH);
// Loop once for each keyword
for(i=0; i<MAX_KEYWORDS; i++)
{
// If an empty string, then break this loop
if(strlen(WordWavCombo[i]) == 0)
break;
// If we find a match, then add on the new wav data
if(strncmp(Word, WordWavCombo[i], TOK_LENGTH) == 0)
{
// See if the wav already exists
for(j=1; j<=MAX_RANDOM; j++)
{
// If an empty string, then break this loop
if (strlen(WordWavCombo[i][TOK_LENGTH*j]) == 0)
break;
// See if this is the same as the new wav
if(strncmp(Wav, WordWavCombo[i][TOK_LENGTH*j], TOK_LENGTH) == 0)
{
snprintf(Text, MAX_TEXT_LENGTH, "%s; %s already exists.", Word, Wav);
selfmessage(Text);
return PLUGIN_HANDLED;
}
}
// If we reached the end, then there is no room
if(j == MAX_RANDOM)
selfmessage("No room for new wav. Increase MAX_RANDOM.");
else
{
// Word exists, but Wav is new to the list, so add entry
strcpy(WordWavCombo[i][TOK_LENGTH*j], Wav, TOK_LENGTH);
snprintf(Text, MAX_TEXT_LENGTH, "%s successfully added to %s", Wav, Word);
selfmessage(Text);
}
return PLUGIN_HANDLED;
}
}
// If we reached the end, then there is no room
if(i == MAX_KEYWORDS)
selfmessage("No room for new Word/Wav combo. Increase MAX_KEYWORDS");
else
{
// Word/Wav combo is new to the list, so make a new entry
strcpy(WordWavCombo[i][TOK_LENGTH*0], Word, TOK_LENGTH);
strcpy(WordWavCombo[i][TOK_LENGTH*1], Wav, TOK_LENGTH);
snprintf(Text, MAX_TEXT_LENGTH, "%s; %s successfully added.", Word, Wav);
selfmessage(Text);
}
return PLUGIN_HANDLED;
}
//////////////////////////////////////////////////////////////////////////////
// Instead of using admin_help, which uses static data, admin_sound_help
// always lists the most up-to-date information because the Word/Wav list can
// change the middle of gameplay. admin_sound_help lists all admin_sound
// commands and keywords to the user.
//
// Usage: admin_sound_help
//////////////////////////////////////////////////////////////////////////////
public admin_sound_help(HLCommand,HLData,HLUserName,UserIndex)
{
new User[MAX_NAME_LENGTH];
new Text[MAX_TEXT_LENGTH] = "";
new i = 0;
convert_string(HLUserName,User,MAX_NAME_LENGTH);
selfmessage("admin_sound_help: Shows this text.");
selfmessage("admin_sound_on: Turns on playing of wav files with this plugin.");
selfmessage("admin_sound_off: Turns off playing of wav files with this plugin.");
selfmessage("admin_sound_reload [filename] : Reloads config file. Filename is optional.");
selfmessage("admin_sound_add ^"<keyword>;<dir\wav>^" : Adds a Word/Wav combo to the sound list. Must use quotes");
selfmessage("admin_sound_remove ^"<keyword>;[dir\wav]^" : Removes a Word/Wav combo from the list. Must use quotes");
selfmessage("say <keyword>: Plays a sound. Keywords are listed below:");
// Loop once for each keyword
for(i=0; i<MAX_KEYWORDS; i++)
{
// If an invalid string, then break this loop
if( (strlen(WordWavCombo[i]) == 0) || (strlen(WordWavCombo[i]) > TOK_LENGTH) )
break;
strcat(Text, WordWavCombo[i], MAX_TEXT_LENGTH);
strcat(Text, " ^t ^t", MAX_TEXT_LENGTH);
if(i % NUM_PER_LINE == NUM_PER_LINE - 1)
{
// We got NUM_PER_LINE on this line,
// so print it and start on the next line
selfmessage(Text);
Text[0] = 0;
}
}
if(strlen(Text) != 0)
selfmessage(Text);
return PLUGIN_HANDLED;
}
//////////////////////////////////////////////////////////////////////////////
// Turns off the playing of the wav files for this plugin only.
//
// Usage: admin_sound_off
//////////////////////////////////////////////////////////////////////////////
public admin_sound_off(HLCommand, HLData, HLUserName, UserIndex)
{
bSoundsEnabled = 0;
say("Sank Sounds Plugin has been disabled!");
playsoundall("misc\awwcrap.wav");
return PLUGIN_HANDLED;
}
//////////////////////////////////////////////////////////////////////////////
// Turns on the playing of the wav files for this plugin only.
//
// Usage: admin_sound_on
//////////////////////////////////////////////////////////////////////////////
public admin_sound_on(HLCommand, HLData, HLUserName, UserIndex)
{
bSoundsEnabled = 1;
say("Sank Sounds Plugin has been enabled!");
playsoundall("misc\woohoo.wav");
return PLUGIN_HANDLED;
}
//////////////////////////////////////////////////////////////////////////////
// Reloads the Word/Wav combos from filename.
//
// Usage: admin_sound_reload [filename]
//////////////////////////////////////////////////////////////////////////////
public admin_sound_reload(HLCommand, HLData, HLUserName, UserIndex)
{
new parsefile[MAX_DATA_LENGTH];
convert_string(HLData, parsefile, MAX_DATA_LENGTH);
// Initialize WordWavCombo[][][] array
new i;
for(i = 0; i < MAX_KEYWORDS; i++)
WordWavCombo[i][0] = 0;
parse_sound_file(parsefile);
return PLUGIN_HANDLED;
}
//////////////////////////////////////////////////////////////////////////////
// Removes a Word/Wav combo from the list. You must specify a keyword, but it
// is not necessary to specify a wav if you want to remove all wavs associated
// with that keyword. Surrounding quotes are required.
//
// Usage: admin_sound_remove "<keyword>;[wav]"
//////////////////////////////////////////////////////////////////////////////
public admin_sound_remove(HLCommand, HLData, HLUserName, UserIndex)
{
new Data[MAX_DATA_LENGTH];
new User[MAX_NAME_LENGTH];
new Word[TOK_LENGTH];
new Wav[TOK_LENGTH];
new Text[MAX_TEXT_LENGTH];
new iCurWord;
new jCurWav;
convert_string(HLData, Data, MAX_DATA_LENGTH);
convert_string(HLUserName, User, MAX_NAME_LENGTH);
// Parse command line
strsplit(Data, ";", Word, TOK_LENGTH, Wav, TOK_LENGTH);
// Remove whitespace
strtrim(Word, " ^t");
strtrim(Wav, " ^t");
if(strlen(Data) == 0)
{
selfmessage("Invalid format.");
selfmessage("USAGE: admin_sound_remove ^"<keyword>;[dir\wav]^"");
return PLUGIN_HANDLED;
}
// Loop once for each keyword
for(iCurWord=0; iCurWord<MAX_KEYWORDS; iCurWord++)
{
// If an empty string, then break this loop, we're at the end
if(strlen(WordWavCombo[iCurWord]) == 0)
break;
// Look for a Word match
if(strncmp(Word, WordWavCombo[iCurWord], TOK_LENGTH) == 0)
{
// If no wav was specified, then remove the whole word's entry
if(strlen(Wav) == 0)
{
// Keep looping i, copying the next into the current
for(; iCurWord<MAX_KEYWORDS; iCurWord++)
{
// If we're about to copy a string that doesn't exist,
// then just erase the last string instead of copying.
if (iCurWord >= MAX_KEYWORDS-1)
{
// Delete the last word string
WordWavCombo[iCurWord][0] = 0;
// We reached the end
snprintf(Text, MAX_TEXT_LENGTH, "%s successfully removed.", Word);
selfmessage(Text);
return PLUGIN_HANDLED;
}
else
{
// Copy the next string over the current string
for(jCurWav=0; jCurWav<TOK_LENGTH*(MAX_RANDOM+1); jCurWav++)
WordWavCombo[iCurWord][jCurWav] = WordWavCombo[iCurWord+1][jCurWav];
}
}
}
else
{
// Just remove the one wav, if it exists
for(jCurWav=1; jCurWav<=MAX_RANDOM; jCurWav++)
{
// If an empty string, then break this loop, we're at the end
if (strlen(WordWavCombo[iCurWord][TOK_LENGTH*jCurWav]) == 0)
break;
// Look for a Wav match
if(strncmp(Wav, WordWavCombo[iCurWord][TOK_LENGTH*jCurWav], TOK_LENGTH) == 0)
{
for(; jCurWav<=MAX_RANDOM; jCurWav++)
{
// If this is the only wav entry, then remove the entry altogether
if ( (jCurWav == 1) && (strlen(WordWavCombo[iCurWord][TOK_LENGTH*(jCurWav+1)]) == 0) )
{
// Keep looping i, copying the next into the current
for(; iCurWord<MAX_KEYWORDS; iCurWord++)
{
// If we're about to copy a string that doesn't exist,
// then just erase the last string instead of copying.
if (iCurWord >= MAX_KEYWORDS-1)
{
// Delete the last word string
WordWavCombo[iCurWord][0] = 0;
// We reached the end
snprintf(Text, MAX_TEXT_LENGTH, "%s successfully removed.", Word);
selfmessage(Text);
return PLUGIN_HANDLED;
}
else
{
// Copy the next string over the current string
for(jCurWav=0; jCurWav<TOK_LENGTH*(MAX_RANDOM+1); jCurWav++)
WordWavCombo[iCurWord][jCurWav] = WordWavCombo[iCurWord+1][jCurWav];
}
}
}
// If we're about to copy a string that doesn't exist,
// then just erase the last string instead of copying.
if(jCurWav >= MAX_RANDOM)
{
// Delete the last wav string
WordWavCombo[iCurWord][TOK_LENGTH*jCurWav] = 0;
// We reached the end
snprintf(Text, MAX_TEXT_LENGTH, "%s successfully removed from %s.", Wav, Word);
selfmessage(Text);
return PLUGIN_HANDLED;
}
else
{
// Copy the next string over the current string
strcpy(WordWavCombo[iCurWord][TOK_LENGTH*jCurWav], WordWavCombo[iCurWord][TOK_LENGTH*(jCurWav+1)], TOK_LENGTH);
}
}
}
}
// We reached the end for this word, and the wav didn't exist
snprintf(Text, MAX_TEXT_LENGTH, "%s not found.", Wav);
selfmessage(Text);
return PLUGIN_HANDLED;
}
}
}
// We reached the end, and the word didn't exist
snprintf(Text, MAX_TEXT_LENGTH, "%s not found.", Word);
selfmessage(Text);
return PLUGIN_HANDLED;
}
//////////////////////////////////////////////////////////////////////////////
// Saves the current configuration of Word/Wav combos to filename for possible
// reloading at a later time. You cannot overwrite the default file.
//
// Usage: admin_sound_write <filename>
//////////////////////////////////////////////////////////////////////////////
public admin_sound_write(HLCommand, HLData, HLUserName, UserIndex)
{
new savefile[MAX_DATA_LENGTH];
new User[MAX_NAME_LENGTH];
new Text[MAX_TEXT_LENGTH];
new TimeStamp[MAX_TEXT_LENGTH];
new bSuccess = 1;
new i;
new j;
convert_string(HLData, savefile, MAX_DATA_LENGTH);
convert_string(HLUserName, User, MAX_NAME_LENGTH);
servertime(TimeStamp, MAX_NUMBER_LENGTH, "%H:%M %B %d, %Y");
// If the filename is NULL, then that's bad.
if (strlen(savefile) == 0)
{
selfmessage("Sound Plugin >> You must specify a filename.");
return PLUGIN_HANDLED;
}
// If the filename is the same as the default FILENAME, then that's bad.
if (strcasecmp(savefile, FILENAME) == 0)
{
selfmessage("Sound Plugin >> Illegal write to default sound config file.");
selfmessage("Sound Plugin >> Specify a different filename.");
return PLUGIN_HANDLED;
}
/************ File should have the following format: **************
# TimeStamp: 07:15 January 15, 2001
# File created by: [SPU]Crazy_Chevy
# Important parameters:
SND_KICK; 30
SND_WARN; 17
SND_JOIN;
SND_EXIT; misc\comeagain.wav
# Word/Wav combinations:
crap; misc\awwcrap.wav;misc\awwcrap2.wav
woohoo; misc\woohoo.wav
ha ha; misc\haha.wav
doh; misc\doh.wav;misc\doh2.wav;misc\doh3.wav
******************************************************************/
// See if we have file_access_write
if (!resetfile(savefile))
{
snprintf(Text, MAX_TEXT_LENGTH, "Sound Plugin >> Cannot write to %s", savefile);
selfmessage(Text);
selfmessage("Sound Plugin >> Make sure file_access_write is set to 1.");
return PLUGIN_HANDLED;
}
// We now assume that we can write to the file, so here we go!
snprintf(Text, MAX_TEXT_LENGTH, "# TimeStamp:^t^t%s", TimeStamp);
writefile(savefile, Text);
snprintf(Text, MAX_TEXT_LENGTH, "# File created by:^t%s", User);
writefile(savefile, Text);
writefile(savefile, ""); // blank line
writefile(savefile, "# Important parameters:");
snprintf(Text, MAX_TEXT_LENGTH, "SND_KICK;^t%d", SND_KICK);
writefile(savefile, Text);
snprintf(Text, MAX_TEXT_LENGTH, "SND_WARN;^t%d", SND_WARN);
writefile(savefile, Text);
snprintf(Text, MAX_TEXT_LENGTH, "SND_JOIN;^t%s", SND_JOIN);
writefile(savefile, Text);
snprintf(Text, MAX_TEXT_LENGTH, "SND_EXIT;^t%s", SND_EXIT);
writefile(savefile, Text);
writefile(savefile, ""); // blank line
writefile(savefile, "# Word/Wav combinations:");
for (i = 0; i < MAX_KEYWORDS && bSuccess; i++)
{
// See if we reached the end
if (strlen(WordWavCombo[i]) == 0)
break;
// I guess not, so format up a string to write
// First, add the keyword
snprintf(Text, MAX_TEXT_LENGTH, "%s;^t", WordWavCombo[i]);
// Then add all the wavs
for (j = 0; j < MAX_RANDOM && strlen(WordWavCombo[i][TOK_LENGTH*j]); j++)
snprintf(Text, MAX_TEXT_LENGTH, "%s%s;", Text, WordWavCombo[i][TOK_LENGTH*j]);
// Now write the formatted string to the file
bSuccess = writefile(savefile, Text);
// And loop for the next wav
}
snprintf(Text, MAX_TEXT_LENGTH, "Sound Plugin >> Configuration successfully written to %s.", savefile);
selfmessage(Text);
return PLUGIN_HANDLED;
}
//////////////////////////////////////////////////////////////////////////////
// This function exists in order to call parse_sound_file from a timer, which
// becomes necessary when file_access_read is set to 0.
//////////////////////////////////////////////////////////////////////////////
public parse_file_timer(Timer, Repeat, HLUser, HLParam)
{
new param[MAX_TEXT_LENGTH];
convert_string(HLParam, param, MAX_TEXT_LENGTH);
parse_sound_file(param);
return PLUGIN_HANDLED;
}
//////////////////////////////////////////////////////////////////////////////
// Parses the sound file specified by loadfile. If loadfile is empty, then
// it parses the default FILENAME.
//
// Returns 0 if parsing was successful
// Returns 1 if parsing failed
// Returns -1 otherwise
//
// Usage: admin_sound_reload <filename>
//////////////////////////////////////////////////////////////////////////////
parse_sound_file(loadfile[] = "")
{
new bGotLine;
new iLineNum = 0;
new strLineBuf[MAX_TEXT_LENGTH];
new WadOstrings[MAX_RANDOM*TOK_LENGTH]; // same as [MAX_RANDOM][TOK_LENGTH]
new ListIndex = 0;
new Text[MAX_TEXT_LENGTH];
/************ File should have the following format: **************
# Set the necessary variables
SND_KICK; 20
SND_WARN; 17
SND_EXIT; misc\comeagain.wav
# Now give the sound list
crap; misc\awwcrap.wav;misc\awwcrap2.wav
woohoo; misc\woohoo.wav
ha ha; misc\haha.wav
doh; misc\doh.wav;misc\doh2.wav;misc\doh3.wav
******************************************************************/
if (strlen(loadfile) == 0)
strcpy(loadfile, FILENAME, MAX_TEXT_LENGTH);
if (fileexists(loadfile) > 0)
{
new i;
bGotLine = readfile(loadfile, strLineBuf, iLineNum, MAX_TEXT_LENGTH);
if (!bGotLine)
{
// If file access is already set correctly...
if (getvar("file_access_read") == 1)
{
snprintf(Text, MAX_TEXT_LENGTH, "Sound Plugin >> Unable to read from %s file.", loadfile);
selfmessage(Text);
// If we set the file access last time, then set it back
get_serverinfo("SNDSetAccess", Text, MAX_TEXT_LENGTH);
if(strncmp(Text, "1", MAX_TEXT_LENGTH) == 0)
exec("file_access_read 0");
set_serverinfo("SNDSetAccess", "0");
return 1;
}
// else set it correctly and try again
exec("file_access_read 1");
// flag ourselves to set it back later
set_serverinfo("SNDSetAccess", "1");
set_timer("parse_file_timer", 1, 0, loadfile);
return -1;
}
// Initialize WordWavCombo[][][] array before using it
for(i = 0; i < MAX_KEYWORDS; i++)
WordWavCombo[i][0] = 0;
while (bGotLine)
{
if (ListIndex >= MAX_KEYWORDS)
{
log("Sound Plugin >> Sound list truncated. Increase MAX_KEYWORDS.");
printf("Sound Plugin >> Stopped parsing %s file.^n", loadfile);
break;
}
// As long as the line isn't commented out, and isn't blank, then process it.
if ((strncmp(strLineBuf, "#", 1) != 0) && (strncmp(strLineBuf, "//", 2) != 0) && (strlen(strLineBuf) != 0))
{
// Take up to MAX_RANDOM wav files for each keyword, each separated by a ';'
// Right now we fill the big WadOstrings[] with the information from the file.
for(i=0; i<=MAX_RANDOM; i++)
{
strsep(strLineBuf, ";", WadOstrings[TOK_LENGTH*i], TOK_LENGTH, strLineBuf, MAX_TEXT_LENGTH);
}
// If we finished MAX_RANDOM times, and strRest still has contents
// then we should have a bigger MAX_RANDOM
if(strlen(strLineBuf) != 0)
{
log("Sound Plugin >> Sound list partially truncated. Increase MAX_RANDOM.");
printf("Sound Plugin >> Continuing to parse %s file.^n", loadfile);
}
// Now remove any spaces or tabs from around the strings -- clean them up
for(i=0; i<MAX_RANDOM; i++)
{
strtrim(WadOstrings[TOK_LENGTH*i], " ^t");
}
// First look for special parameters
if (!strcasecmp(WadOstrings, "SND_KICK"))
SND_KICK = strtonum(WadOstrings[TOK_LENGTH*1]);
else if (!strcasecmp(WadOstrings, "SND_WARN"))
SND_WARN = strtonum(WadOstrings[TOK_LENGTH*1]);
else if (!strcasecmp(WadOstrings, "SND_JOIN"))
strcpy(SND_JOIN, WadOstrings[TOK_LENGTH*1], TOK_LENGTH);
else if (!strcasecmp(WadOstrings, "SND_EXIT"))
strcpy(SND_EXIT, WadOstrings[TOK_LENGTH*1], TOK_LENGTH);
// If it wasn't one of those essential parameters, then it should be
// a Keyword/Wav combo, so we'll treat it as such by copying it from our
// temporary structure into our global structure, WordWavCombo[][][]
else
{
// Now we must transfer the contents of WadOstrings[] to
// our global data structure, WordWavCombo[Index][]
// with a really tricky "string copy"
for(i=0; i<MAX_RANDOM*TOK_LENGTH; i++)
{
WordWavCombo[ListIndex][i] = WadOstrings[i];
}
ListIndex++;
}
}
// Initialize variables for next time by clearing all the
// strings in the WadOstrings[]
for(i = 0; i < MAX_RANDOM; i++)
{
WadOstrings[i*TOK_LENGTH] = 0;
}
// Read in the next line from the file
bGotLine = readfile(loadfile, strLineBuf, ++iLineNum, MAX_TEXT_LENGTH);
// This is pretty gay hacking, but here goes. The readfile API function here
// has a static buffer that is 100 chars long in AM version 2.50.e and previous.
// A line longer than 100 chars in length looks like 2 lines to us in the script,
// with the first 'line' being the first 100 chars and the second 'line' being
// the rest of the line (given it is shorter than 100 as well). So in order to
// fix this, we have to read in two lines, but only if the first has filled the
// first 100 chars completely. Then we add the second string to the end of the
// first and we get what we should've gotten the first time we did readline().
// In AM versions later than 2.50.e, this should be removed, because I'm told
// the static buffer will be increased to 200, which is the MAX_TEXT_LENGTH for
// us anyway.
if (strlen(strLineBuf) == 99)
{
bGotLine = readfile(loadfile, Text, ++iLineNum, MAX_TEXT_LENGTH);
strcat(strLineBuf, Text, MAX_TEXT_LENGTH);
}
}
// Now we have all of the data from the text file in our data structures.
// Next we do some error checking, some setup, and we're done parsing!
// Do some error checking on the user-input numbers
// If SND_KICK is zero, then sounds quota is disabled.
if (SND_KICK <= 0)
{
SND_KICK = 0; // in case it was negative
log("Sound quota disabled.");
}
// If SND_WARN is zero, then we can't have warning every
// time a keyword is said, so we default to 3 less than max
else if (SND_WARN <= 0)
{
if (SND_KICK > 3)
SND_WARN = SND_KICK - 3;
else
SND_WARN = SND_KICK - 1;
log("Sound Plugin >> SND_WARN cannot be set to zero.");
log(" >> SND_WARN set to default value.");
}
// And finally, if they want to warn after a person has been
// kicked, that's silly, so we'll fix it.
else if (SND_KICK < SND_WARN)
{
if (SND_KICK > 3)
SND_WARN = SND_KICK - 3;
else
SND_WARN = SND_KICK - 1;
log("Sound Plugin >> SND_WARN cannot be higher than SND_KICK.");
log(" >> SND_WARN set to default value.");
}
// Log some info for the nosey admin
snprintf(Text, MAX_TEXT_LENGTH, "Sound quota set to %i", SND_KICK);
log(Text);
#if defined (DEBUG)
print_matrix();
printf("Sound Plugin >> Done parsing %s file.^n", loadfile);
#endif
}
else // file exists returned false, meaning the file didn't exist
{
snprintf(Text, MAX_TEXT_LENGTH, "Sound Plugin >> Cannot find %s file.", loadfile);
selfmessage(Text);
return 1;
}
// If we set the file access last time, then set it back
get_serverinfo("SNDSetAccess", Text, MAX_TEXT_LENGTH);
if(strncmp(Text, "1", MAX_TEXT_LENGTH) == 0)
{
exec("file_access_read 0");
set_serverinfo("SNDSetAccess", "0");
}
snprintf(Text, MAX_TEXT_LENGTH, "Sound Plugin >> %s successfully loaded.", loadfile);
selfmessage(Text);
return 0;
}
#if defined (DEBUG)
//////////////////////////////////////////////////////////////////////////////
// Prints out word wav combo matrix for debugging purposes. Kinda cool, even
// if you're not really debugging.
//
// Usage: admin_sound_debug
// Usage: admin_sound_reload <filename>
//////////////////////////////////////////////////////////////////////////////
public print_matrix()
{
printf("SND_WARN: %d^n", SND_WARN);
printf("SND_KICK: %d^n", SND_KICK);
printf("SND_JOIN: %s^n", SND_JOIN);
printf("SND_EXIT: %s^n", SND_EXIT);
new i;
new j;
// Print out the matrix of sound data, so we got what we think we did
for(i=0; i<MAX_KEYWORDS; i++)
{
if (strlen(WordWavCombo[i]) != 0)
{
printf("^n");
for(j=0; j<MAX_RANDOM+1; j++)
{
if (strlen(WordWavCombo[i][j*TOK_LENGTH]) != 0)
printf("[%d] [%d] ^"%s^"^n", i, j, WordWavCombo[i][j*TOK_LENGTH]);
}
}
}
return PLUGIN_HANDLED;
}
#endif
//////////////////////////////////////////////////////////////////////////////
// Returns 0 if the user is allowed to say things
// Returns 1 and kicks the user if the quota has been exceeded.
//////////////////////////////////////////////////////////////////////////////
QuotaCheck(User[], UserIndex)
{
// If the sound limitation is disabled, then return happily.
if (SND_KICK == 0)
return 0;
new Text[MAX_TEXT_LENGTH];
new HowManyLeft = SND_KICK - SndCount[UserIndex];
if (check_immunity(User) == 0)
{
if (SndCount[UserIndex] >= SND_KICK)
{
//playsoundall("misc\comeagain.wav"); // moved to the plugin_disconnect function
message(User, "You were warned, but did not quit playing sounds");
snprintf(Text, MAX_TEXT_LENGTH, "Kicked %s for saying too much", User);
say(Text);
kick(User);
return 1;
}
else if (SndCount[UserIndex] >= SND_WARN)
{
messageex(User, "You have almost used up your sound quota. Stop.", print_center);
messageex(User, "You have almost used up your sound quota. Stop.", print_console);
snprintf(Text, MAX_TEXT_LENGTH, "You have %d left before you get kicked.", HowManyLeft);
messageex(User, Text, print_center);
messageex(User, Text, print_console);
}
// Increment their playsound count
SndCount[UserIndex] = SndCount[UserIndex] + 1;
}
return 0;
}
//////////////////////////////////////////////////////////////////////////////
// Everything a person says goes through here, and we determine if we want to
// play a sound or not.
//
// Usage: say <something>
//////////////////////////////////////////////////////////////////////////////
public HandleSay(HLCommand, HLData, HLUserName, UserIndex)
{
// If sounds are not enabled, then skip this whole thing
if (!bSoundsEnabled)
return PLUGIN_CONTINUE;
new i;
new Speech[MAX_DATA_LENGTH];
new User[MAX_NAME_LENGTH];
new Text[MAX_TEXT_LENGTH];
new ListIndex = -1;
convert_string(HLData, Speech, MAX_DATA_LENGTH);
convert_string(HLUserName, User, MAX_NAME_LENGTH);
strstripquotes(Speech);
if (systemtime() == LastSoundTime)
{
// Only one sound per second, please
LastSoundTime = systemtime();
return PLUGIN_CONTINUE;
}
// Check to see if what the player said is a trigger for a sound
for (i=0; i<MAX_KEYWORDS; i++)
{
if (!strcasecmp(Speech, WordWavCombo[i]))
{
ListIndex = i;
}
}
// If what the player said is a sound trigger, then handle it.
if (ListIndex != -1)
{
if (!QuotaCheck(User, UserIndex))
{
new rand = random(MAX_RANDOM);
new timeout = 25;
new playFile[TOK_LENGTH];
// This for loop runs around until it finds a real file to play
for(rand = random(MAX_RANDOM); strlen(playFile) == 0; rand = random(MAX_RANDOM))
{
strcpy(playFile, WordWavCombo[ListIndex][(rand+1)*TOK_LENGTH], TOK_LENGTH);
// If for some reason we never find a file
// then exit this infinite loop
if (!timeout--)
{
printf("Could not find wav to play for %s^n", playFile);
return PLUGIN_CONTINUE;
}
}
snprintf(Text, MAX_TEXT_LENGTH, "%s : %s", User, Speech);
say(Text);
if (am_i_dead(User)) {
/* say("seit wann koennen Tote reden?"); */
playsounddead(playFile);
} else {
playsoundall(playFile);
}
LastSoundTime = systemtime();
return PLUGIN_HANDLED;
}
}
return PLUGIN_CONTINUE;
}
