AdminMod.de
https://www.adminmod.de/

sank_sounds.sma???
https://www.adminmod.de/viewtopic.php?t=3825		 Seite 1 von 1
Autor:  -=L=o=D|Satyr=- [ 10.08.2002, 13:07 ]
Betreff des Beitrags:  sank_sounds.sma???
Hi ho.
ich hab mir das sank_sounds plugin auf dieser HP gezogen doch ich wollte die sma von 40 auf 60 abspielbaren sounds umschreiben. Doch beim um convertieren in amx kommt immer eine fehlermeldung. Scheint als wäre die Quelldatei (sma) beschädigt. kann mir jemand eine funktionierende sma davon schicken oder posten wo ich sie herbekomme?

danke :D
Autor:  redfield82 [ 10.08.2002, 13:52 ]
Betreff des Beitrags: 
Poste auch mal die Errormeldung und die sma ;)
Autor:  -=L=o=D|Satyr=- [ 10.08.2002, 14:09 ]
Betreff des Beitrags:  ok
ok hier di Fehlermeldung:

plugin_sank_sounds.sma(49) Fatal [100]: cannot read from file: "..\include\sound.inc"

Und hier der sma Inhalt:


/***************************************************************************
* 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 <console>
#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]^" : Removes 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); /* moeglicher Bot-Crash */

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) == 0)
break;

// If we find a match, then add on the new wav data
if(strncmp(Word, WordWavCombo, 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[TOK_LENGTH*j]) == 0)
break;

// See if this is the same as the new wav
if(strncmp(Wav, WordWavCombo[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[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[TOK_LENGTH*0], Word, TOK_LENGTH);
strcpy(WordWavCombo[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) == 0) || (strlen(WordWavCombo) > TOK_LENGTH) )
break;

strcat(Text, WordWavCombo, 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"); /* moeglicher Bot-Crash */

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"); /* moeglicher Bot-Crash */

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;
}
Autor:  [WING] Black Knight [ 10.08.2002, 14:21 ]
Betreff des Beitrags: 
1. RTFR (= Read the fucking Readme) und zwar die, die dem Plugin beiliegt.
2. Codetags benutzen, wenn Du Quelcode postest.
Autor:  -=L=o=D|Satyr=- [ 10.08.2002, 14:56 ]
Betreff des Beitrags: 
Codetags? Keine Ahnung. Aber was bringt mir die plugin readme wenn die sma Datei kaputt ist????? Ich will nur eine sma des plugin_sank_sounds haben die auf jeden Fall in Ordnung ist. ist das denn so schwer zu verstehen???????
Autor:  redfield82 [ 10.08.2002, 16:10 ]
Betreff des Beitrags: 
Bei Plugins die manual lesen wenn man sich mit scripten nich auskennt und die sma schon original Fehlerhaft ist? Ihr seit lustig :roll:
Autor:  [WING] Black Knight [ 10.08.2002, 22:55 ]
Betreff des Beitrags: 
Die sma ist nach der Fehlermeldung vollkommen in Ordnung. Er hat nur etwas vergessen. Schau mal nach, ob da nicht noch eine Datei mit Namen "sound.inc" beiliegt. Die Fehlermeldung ist ja wohl eindeutig!! Das ist ein zusätzliches Include, das nicht zu AM gehört!! Informationen dazu findet man meistens in der Readme!

Code-Tags kann man bequem über den Button "Code" produzieren. Der ist ja nun wirklich nicht zu übersehen.

Ich werde einfach das Gefühl nicht los, dass es sich um eine Hopplahopp-Aktion handelt. Wenn man einen Server betreiben will, ist auch eine gewisse Sorgfalt und ein gewisser Aufwand notwendig.

Sorry, wenn das jetzt etwas hart klingt, aber der Fehler ist nun wirklich trivial und kann selbst von einem Laien mit ein wenig Nachdenken gelöst werden.
Autor:  -=L=o=D|Satyr=- [ 11.08.2002, 11:45 ]
Betreff des Beitrags: 
Ich weiß nicht was Dein Problem ist? ic will lediglich eine funktionierende sma Datei von dem Plugin. es gibt keine verdammte sound.inc dabei. Aber anscheinend sind hier nur eingebildete Serveradmins im Forum. Dann werd ich eben wo anders um Hilfe fragen.
Sorgfalt? Was weißt Du denn. Du weißt ja einen Scheiss.
Tolles Forum hir echt. Bisher nur klugscheisser Antworten bekommen. Echt super.
cu, Satyr.
Autor:  [WING] Black Knight [ 11.08.2002, 13:30 ]
Betreff des Beitrags: 
Also, alles was ich erwarte ist, dass man auf Grund der Fehlermeldung überprüft, ob die Datei überhaupt vorhanden ist, aus der gelesen werden sollte.
OK, sie ist nicht da. Sie liegt auch nicht bei. Dann hast Du eine fehlerhafte Distribution geladen. Versuch mal die hier:

http://www.adminmod.org/ascript/downloa ... rea=plugin

Bei der Version braucht man keine sound.inc. Bei mir ist sie jedenfalls ohne Fehlermeldung durch den Compiler gelaufen.

Gerade habe ich mir mal die Version angesehen, die Du heruntergeladen hast. Und wenn in diesem Zipfile keine "sound.inc" drin ist, wo dann?
Und da wunderst Du Dich, dass ich mich aufrege. Das hat weder mit klugscheißen noch mit Arroganz zu tun. Wir helfen hier gerne solange die Antworten nicht offensichtlich sind, im Handbuch stehen oder gegen die Etiquette verstoßen.
Und Du hast gegen alle 3 gleichzeitig verstoßen. Was erwartest Du?

Kleiner Tip: Bei Deiner Version liegt noch eine MODIFICATION.TXT bei. Da steht was interessantes drin.
Autor:  -=L=o=D|Satyr=- [ 11.08.2002, 13:49 ]
Betreff des Beitrags: 
Sorry das ich so schroff war aber in meiner zip war keine sound.inc oder dead.inc
Komischer weise in der die ich mir dann gezogen hab. Ich werd aber trotzdem deinen anderen Link benutzen.
Auf jeden fall ist as keine holla hopp aktion gewesen. ich mach unseren servr schon mit Sorgfalt. Deswegen war ich auch n bischen angepisst. Das lass ich mir nämlich nicht sagen. Das ar schon fast ne beleidigung.

Das ende vom Lied mir wurde ja nun der Link gepostet den ich haben wollte. geht doch.
thx noch mal.
Autor:  Smudo [ 12.08.2002, 13:18 ]
Betreff des Beitrags: 
Ich bewundere dich [WING]Black Knight. Das du Leuten, die sich so saumässig aufführen und dich auch noch beleidigen auch noch hilfst. Und da er ja des lesens scheinbar nicht mächtig oder nicht willig ist, ist dein Versuch ihm zu helfen sowieso vergebene Liebesmüh.
Autor:  -=L=o=D|Satyr=- [ 12.08.2002, 15:25 ]
Betreff des Beitrags: 
:roll: Also um Deine Frage zu beantworten. Er hat mir geholfen. Und es funtzt. Erstmal wurde ich beleidigt, zumindest fühlte ich mich beleidigt, und dann hab ich ne Frage gestellt die mir nicht wirklich geholfen hat. Ihr müsst nicht davon ausgehen das hier nur Programmierer rein posten. Ich bin nun mal Servernewbie. Jeder fängt mal an. Oder nicht. Und, schau in die readme ist ja nun wirklich nicht ne optimale Antwort, oder?
Außerdem: Lesen kann ich. Nur um dich zu beruhigen.

:-? Satyr :D
Autor:  Warhead [ 12.08.2002, 16:46 ]
Betreff des Beitrags: 
"Schau in die Readme" war auch in diesem Fall die perfekte Antwort.

Du kannst Dir sicher sein, Newbiefragen werden in der Doku immer beantwortet.
Seite 1 von 1 Alle Zeiten sind UTC+01:00
Powered by phpBB® Forum Software © phpBB Limited
https://www.phpbb.com/