Flummi/amxmodx
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Initial revision

Browse Source
This commit is contained in:
Felix Geyer 2004-01-31 20:56:22 +00:00
parent 88eadb34bc
commit 9e999a0ba6
106 changed files with 24019 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

278
amxmodx/CCmd.cpp Executable file
View File

@ -0,0 +1,278 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
#include "CCmd.h"
// *****************************************************
// class CmdMngr
// *****************************************************
CmdMngr::CmdMngr() {
memset(sortedlists,0,sizeof(sortedlists));
srvcmdlist = 0;
clcmdlist = 0;
prefixHead = 0;
buf_type = -1;
buf_access = 0;
buf_id = -1;
buf_cmdid = -1;
buf_cmdtype = -1;
buf_cmdaccess = 0;
}
CmdMngr::Command::Command( CPluginMngr::CPlugin* pplugin,const char* pcmd,
const char* pinfo , int pflags , int pfunc,
bool pviewable, CmdMngr* pparent ) : commandline(pcmd) , info(pinfo) {
char szCmd[64], szArg[64];
*szCmd = 0; *szArg=0;
sscanf(pcmd,"%s %s",szCmd,szArg);
command.set(szCmd);
argument.set(szArg);
plugin = pplugin;
flags = pflags;
cmdtype = 0;
prefix = 0;
function = pfunc;
listable = pviewable;
parent = pparent;
id = --uniqueid;
}
CmdMngr::Command::~Command()
{
++uniqueid;
}
CmdMngr::Command* CmdMngr::registerCommand( CPluginMngr::CPlugin* plugin , int func , char* cmd , char* info , int level , bool listable )
{
Command* b = new Command( plugin , cmd , info , level , func , listable, this );
if ( b == 0 ) return 0;
setCmdLink( &sortedlists[0] , b );
return b;
}
CmdMngr::Command* CmdMngr::getCmd( long int id ,int type, int access )
{
//if ( id >= 1024 || id < 0 ) return (Command*)id;
if ( id < 0 ){
for (CmdMngr::iterator a = begin( type ); a ; ++a){
if ( (*a).id == id )
return &(*a);
}
return 0;
}
if ( (id < buf_cmdid) || (access != buf_cmdaccess) || (type != buf_cmdtype) )
{
buf_cmdptr = begin( type );
buf_cmdaccess = access;
buf_cmdtype = type;
buf_cmdid = id;
}
else
{
int a = id;
id -= buf_cmdid;
buf_cmdid = a;
}
while ( buf_cmdptr )
{
if ( (*buf_cmdptr).gotAccess( access ) &&
(*buf_cmdptr).getPlugin()->isExecutable( (*buf_cmdptr).getFunction() )
&& (*buf_cmdptr).isViewable() )
{
if ( id-- == 0 )
return &(*buf_cmdptr);
}
++buf_cmdptr;
}
return 0;
}
int CmdMngr::getCmdNum( int type, int access )
{
if ( (access == buf_access) && (type == buf_type) )
return buf_num; // once calculated don't have to be done again
buf_access = access;
buf_type = type;
buf_num = 0;
CmdMngr::iterator a = begin( type );
while ( a )
{
if ( (*a).gotAccess( access ) &&
(*a).getPlugin()->isExecutable( (*a).getFunction() )
&& (*a).isViewable() )
++buf_num;
++a;
}
return buf_num;
}
void CmdMngr::setCmdLink( CmdLink** a , Command* c, bool sorted )
{
CmdLink* np = new CmdLink( c );
if ( np == 0 ) return;
if ( sorted )
{
while( *a )
{
int i = strcmp(c->getCommand(),(*a)->cmd->getCommand() );
if ( (i<0) || (i==0) && ( strcmp( c->getArgument() , (*a)->cmd->getArgument() ) < 0 ) )
break;
a = &(*a)->next;
}
np->next = *a;
*a = np;
}
else
{
while ( *a ) a = &(*a)->next;
*a = np;
}
}
void CmdMngr::clearCmdLink( CmdLink** phead, bool pclear )
{
while( *phead ){
CmdLink* pp = (*phead)->next;
if ( pclear ) delete (*phead)->cmd;
delete *phead;
*phead = pp;
}
}
void CmdMngr::Command::setCmdType( int a )
{
switch(a){
case CMD_ConsoleCommand: cmdtype |= 3; break;
case CMD_ClientCommand: cmdtype |= 1; break;
case CMD_ServerCommand: cmdtype |= 2; break;
}
if ( cmdtype & 1 ) { // ClientCommand
parent->setCmdLink( &parent->sortedlists[1] , this );
if ( !parent->registerCmdPrefix( this ) )
parent->setCmdLink( &parent->clcmdlist , this , false );
}
if ( cmdtype & 2 ) { // ServerCommand
parent->setCmdLink( &parent->sortedlists[2] , this );
parent->setCmdLink( &parent->srvcmdlist , this , false );
}
}
const char* CmdMngr::Command::getCmdType() const {
switch( cmdtype ){
case 1: return"client";
case 2: return "server";
case 3: return "console";
}
return "unknown";
}
bool CmdMngr::registerCmdPrefix( Command* cc )
{
CmdPrefix** b = findPrefix( cc->getCommand() );
if (*b){
setCmdLink( &(*b)->list , cc , false );
cc->prefix = (*b)->name.size();
return true;
}
return false;
}
void CmdMngr::registerPrefix( const char* nn )
{
if ( *nn == 0 ) return;
CmdPrefix** b = findPrefix( nn );
if (*b) return;
*b = new CmdPrefix( nn , this );
}
CmdMngr::CmdPrefix** CmdMngr::findPrefix( const char* nn ){
CmdPrefix** aa = &prefixHead;
while(*aa){
if ( !strncmp( (*aa)->name.str(), nn, (*aa)->name.size() ) )
break;
aa=&(*aa)->next;
}
return aa;
}
void CmdMngr::clearPrefix(){
while(prefixHead){
CmdPrefix* a = prefixHead->next;
delete prefixHead;
prefixHead = a;
}
}
void CmdMngr::clear()
{
clearCmdLink(&sortedlists[0], true);
clearCmdLink(&sortedlists[1]);
clearCmdLink(&sortedlists[2]);
clearCmdLink(&srvcmdlist);
clearCmdLink(&clcmdlist);
clearPrefix();
clearBufforedInfo();
}
void CmdMngr::clearBufforedInfo() {
buf_type = -1;
buf_access = 0;
buf_id = -1;
buf_cmdid = -1;
buf_cmdtype = -1;
buf_cmdaccess = 0;
}
int CmdMngr::Command::uniqueid = 0;

165
amxmodx/CCmd.h Executable file
View File

@ -0,0 +1,165 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#ifndef COMMANDS_H
#define COMMANDS_H
// *****************************************************
// class CmdMngr
// *****************************************************
enum {
CMD_ConsoleCommand,
CMD_ClientCommand,
CMD_ServerCommand
};
class CmdMngr
{
public:
class Command;
friend class Command;
class Command {
friend class CmdMngr;
CPluginMngr::CPlugin* plugin;
CmdMngr* parent;
String command;
String argument;
String commandline;
String info;
bool listable;
int function;
int flags;
int id;
int cmdtype;
int prefix;
static int uniqueid;
Command( CPluginMngr::CPlugin* pplugin,const char* pcmd, const char* pinfo , int pflags , int pfunc, bool pviewable, CmdMngr* pparent );
~Command();
public:
inline const char* getCommand() const{ return command.str(); }
inline const char* getArgument() const{ return argument.str(); }
inline const char* getCmdInfo() const{ return info.str(); }
inline const char* getCmdLine() const{ return commandline.str(); }
inline bool matchCommandLine(const char* cmd, const char* arg) { return (!stricmp(command.str()+prefix, cmd+prefix ) && (argument.empty() || !stricmp(argument.str() , arg ))); }
inline bool matchCommand(const char* cmd) { return (!strcmp(command.str(), cmd )); }
inline int getFunction() const { return function; }
inline bool gotAccess(int f) const { return (!flags||((flags & f)==flags)); }
inline CPluginMngr::CPlugin* getPlugin() { return plugin; }
inline bool isViewable() const { return listable; }
inline int getFlags() const { return flags; }
inline long int getId() const { return (long int)id; }
const char* getCmdType() const;
void setCmdType( int a );
};
private:
struct CmdPrefix;
friend struct CmdPrefix;
struct CmdLink {
Command* cmd;
CmdLink* next;
CmdLink(Command* c): cmd(c), next(0) {}
};
CmdLink* sortedlists[3];
CmdLink* srvcmdlist;
CmdLink* clcmdlist;
struct CmdPrefix {
CmdMngr* parent;
String name;
CmdLink* list;
CmdPrefix* next;
CmdPrefix( const char* nn , CmdMngr* pp) : name(nn),parent(pp),list(0),next(0){}
~CmdPrefix(){ parent->clearCmdLink(&list); }
} *prefixHead;
bool registerCmdPrefix( Command* cc );
CmdPrefix** findPrefix( const char* nn );
void clearPrefix();
void setCmdLink( CmdLink** a , Command* c, bool sorted = true );
void clearCmdLink( CmdLink** phead, bool pclear = false );
public:
CmdMngr();
~CmdMngr() {clear();}
// Interface
void registerPrefix( const char* nn );
Command* registerCommand( CPluginMngr::CPlugin* plugin , int func , char* cmd , char* info , int level , bool listable );
Command* getCmd( long int id ,int type, int access);
int getCmdNum( int type, int access );
void clearBufforedInfo();
void clear();
class iterator {
CmdLink *a;
public:
iterator(CmdLink*aa = 0) : a(aa) {}
iterator& operator++() { a = a->next; return *this; }
bool operator==(const iterator& b) const { return a == b.a; }
bool operator!=(const iterator& b) const { return !operator==(b); }
operator bool () const { return a ? true : false; }
Command& operator*() { return *a->cmd; }
};
inline iterator clcmdprefixbegin(const char* nn){
CmdPrefix* a = *findPrefix(nn);
return iterator( a ? a->list : 0 );
}
inline iterator clcmdbegin() const {return iterator(clcmdlist);}
inline iterator srvcmdbegin() const {return iterator(srvcmdlist);}
inline iterator begin( int type ) const { return iterator(sortedlists[type]); }
inline iterator end() const { return iterator(0); }
private:
int buf_cmdid;
int buf_cmdtype;
int buf_cmdaccess;
iterator buf_cmdptr;
int buf_id;
int buf_type;
int buf_access;
int buf_num;
};
#endif

337
amxmodx/CEvent.cpp Executable file
View File

@ -0,0 +1,337 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
#include "CEvent.h"
// *****************************************************
// class EventsMngr
// *****************************************************
EventsMngr::EventsMngr()
{
memset( modMsgsFunCall, 0 , sizeof(modMsgsFunCall) );
}
EventsMngr::~EventsMngr()
{
clearEvents();
}
EventsMngr::ClEvent::ClEvent( CPluginMngr::CPlugin* amxplugin, int function, int flags )
{
plugin = amxplugin;
func = function;
stamp = 0.0;
next = 0;
done = false;
alive=true;
dead=true;
if ( flags & 24 ){
alive=(flags&16)?true:false; //e
dead=(flags&8)?true:false; //d
}
world=(flags&1)?true:false; //a
player=(flags&2)?true:false; //b
once=(flags&4)?true:false; //c
memset(cond,0,sizeof(cond));
}
void EventsMngr::ClEvent::registerFilter( char* filter )
{
if ( filter == 0 ) return;
char* value = filter;
while ( isdigit(*value) )
++value;
if ( *value == 0 ) return;
cond_t* b = new cond_t;
if ( b == 0 ) return;
b->type = *value;
*value++ = 0;
b->sValue.set(value);
b->fValue = atof(value);
b->iValue = atoi(value);
int i = atoi(filter);
if (i >= 0 && i < MAX_PARSE_VALUES) {
b->next = cond[i];
cond[i] = b;
}
else delete b;
}
EventsMngr::ClEvent* EventsMngr::registerEvent( CPluginMngr::CPlugin* p, int f, int flags, int pos )
{
ClEvent* a = new ClEvent( p , f , flags );
if ( a == 0 ) return 0;
ClEvent** end = &modMsgsFunCall[pos];
while( *end ) end = &(*end)->next;
return *end = a;
}
void EventsMngr::parserInit(int msg_type, float* tim, CPlayer *pPlayer, int index) {
parseNotDone = false;
timer = tim;
if ( (parseFun = modMsgsFunCall[msg_type]) == 0 ) return;
for(EventsMngr::ClEvent*p=parseFun;p;p=p->next){
if ( p->done ) continue;
if ( !p->plugin->isExecutable(p->func) ){
p->done = true;
continue;
}
if ( pPlayer ) {
if ( !p->player || ( pPlayer->IsAlive() ? !p->alive : !p->dead ) ) {
p->done = true;
continue;
}
}
else if ( !p->world ){
p->done = true;
continue;
}
if ( p->once && p->stamp == (float)(*timer) ){
p->done = true;
continue;
}
parseNotDone = true;
}
if ( parseNotDone ) {
parseVault[parsePos = 0].type = MSG_INTEGER;
parseVault[parsePos].iValue = index;
}
}
const char* EventsMngr::getArgString(int a)
{
if ( a < 0 || a > parsePos ) return "";
static char var[32];
switch(parseVault[a].type){
case MSG_INTEGER:
sprintf( var, "%d", parseVault[a].iValue );
return var;
case MSG_STRING:
return parseVault[a].sValue;
default:
sprintf( var, "%g", parseVault[a].fValue );
return var;
}
}
int EventsMngr::getArgInteger(int a)
{
if ( a < 0 || a > parsePos ) return 0;
switch(parseVault[a].type){
case MSG_INTEGER: return parseVault[a].iValue;
case MSG_STRING: return atoi(parseVault[a].sValue);
default: return (int)parseVault[a].fValue;
}
}
float EventsMngr::getArgFloat(int a)
{
if ( a < 0 || a > parsePos ) return 0.0f;
switch(parseVault[a].type){
case MSG_INTEGER: return parseVault[a].iValue;
case MSG_STRING: return atof(parseVault[a].sValue);
default: return parseVault[a].fValue;
}
}
void EventsMngr::executeEvents() {
int err;
#ifdef ENABLEEXEPTIONS
try
{
#endif
for ( ClEvent*p = parseFun ; p ; p = p->next )
{
if ( p->done )
{
p->done = false;
continue;
}
p->stamp = *timer;
if ((err = amx_Exec(p->plugin->getAMX(), NULL , p->func , 1,parseVault[0].iValue)) != AMX_ERR_NONE)
print_srvconsole("[AMX] Run time error %d on line %ld (plugin \"%s\")\n",err,p->plugin->getAMX()->curline,p->plugin->getName());
}
#ifdef ENABLEEXEPTIONS
}
catch( ... )
{
print_srvconsole( "[AMX] fatal error at event execution\n");
}
#endif
}
void EventsMngr::parseValue(int iValue) {
if ( !parseNotDone ) return;
parseVault[++parsePos].type = MSG_INTEGER;
parseVault[parsePos].iValue = iValue;
bool skip;
for (ClEvent*p=parseFun;p;p=p->next){
if ( p->done || !p->cond[parsePos] ) continue;
skip = false;
ClEvent::cond_t* a = p->cond[parsePos];
do {
switch(a->type){
case '=': if (a->iValue == iValue) skip=true; break;
case '!': if (a->iValue != iValue) skip=true; break;
case '&': if (iValue & a->iValue) skip=true; break;
case '<': if (iValue < a->iValue) skip=true; break;
case '>': if (iValue > a->iValue) skip=true; break;
}
if (skip) break;
} while ( a = a->next );
if (skip) continue;
p->done = true;
}
}
void EventsMngr::parseValue(float flValue) {
if ( !parseNotDone ) return;
parseVault[++parsePos].type = MSG_FLOAT;
parseVault[parsePos].fValue = flValue;
bool skip;
for (ClEvent*p=parseFun;p;p=p->next){
if ( p->done || !p->cond[parsePos] ) continue;
skip = false;
ClEvent::cond_t* a = p->cond[parsePos];
do {
switch(a->type){
case '=': if (a->fValue == flValue) skip=true; break;
case '!': if (a->fValue != flValue) skip=true; break;
case '<': if (flValue < a->fValue) skip=true; break;
case '>': if (flValue > a->fValue) skip=true; break;
}
if (skip) break;
} while ( a = a->next );
if (skip) continue;
p->done = true;
}
}
void EventsMngr::parseValue(const char *sz) {
if ( !parseNotDone ) return;
parseVault[++parsePos].type = MSG_STRING;
parseVault[parsePos].sValue = sz;
bool skip;
for (ClEvent*p=parseFun;p;p=p->next){
if ( p->done || !p->cond[parsePos] ) continue;
skip = false;
ClEvent::cond_t* a = p->cond[parsePos];
do {
switch(a->type){
case '=': if (!strcmp(sz,a->sValue.str())) skip=true; break;
case '!': if (strcmp(sz,a->sValue.str())) skip=true; break;
case '&': if (strstr(sz,a->sValue.str())) skip=true; break;
}
if (skip) break;
} while ( a = a->next );
if (skip) continue;
p->done = true;
}
}
void EventsMngr::clearEvents()
{
for(int i=0;i<MAX_AMX_REG_MSG;++i){
ClEvent**b = &modMsgsFunCall[i];
while (*b){
ClEvent*aa = (*b)->next;
delete *b;
*b = aa;
}
}
}
EventsMngr::ClEvent::~ClEvent(){
for(int a = 0; a < MAX_PARSE_VALUES; ++a){
cond_t** b = &cond[a];
while(*b){
cond_t* nn = (*b)->next;
delete *b;
*b = nn;
}
}
}
EventsMngr::ClEvent* EventsMngr::getValidEvent(ClEvent* a ) {
while(a){
if ( a->done ) {
a->done = false;
a = a->next;
continue;
}
a->stamp = *timer;
return a;
}
return 0;
}
int EventsMngr::getEventId( const char* msg ){
struct CS_Events {
const char* name;
CS_EventsIds id;
} table[] = {
{ "CS_DeathMsg" , CS_DeathMsg },
// { "CS_RoundEnd" , CS_RoundEnd },
// { "CS_RoundStart" , CS_RoundStart },
// { "CS_Restart" , CS_Restart },
{ "" , CS_Null }
};
int pos;
if ( (pos = atoi( msg )) != 0 )
return pos;
for (pos = 0; table[ pos ].id != CS_Null; ++pos )
if ( !strcmp( table[ pos ].name , msg ) )
return table[ pos ].id;
return pos = GET_USER_MSG_ID(PLID, msg , 0 );
}

154
amxmodx/CEvent.h Executable file
View File

@ -0,0 +1,154 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#ifndef EVENTS_H
#define EVENTS_H
#define MAX_PARSE_VALUES 32
#define MAX_AMX_REG_MSG MAX_REG_MSGS+16
enum {
CS_DEATHMSG = MAX_REG_MSGS,
// CS_ROUNDEND,
// CS_ROUNDSTART,
// CS_RESTART,
};
// *****************************************************
// class EventsMngr
// *****************************************************
class EventsMngr {
enum MsgValueType{
MSG_INTEGER,
MSG_FLOAT,
MSG_STRING,
};
public:
enum CS_EventsIds {
CS_Null = 0,
CS_DeathMsg = MAX_REG_MSGS, // start from last element
// CS_RoundEnd,
// CS_RoundStart,
// CS_Restart,
};
class iterator;
friend class iterator;
class ClEvent {
friend class EventsMngr;
friend class iterator;
CPluginMngr::CPlugin* plugin;
int func;
bool player;
bool world;
bool once;
bool done;
bool dead;
bool alive;
float stamp;
struct cond_t {
String sValue;
float fValue;
int iValue;
int type;
cond_t* next;
} *cond[MAX_PARSE_VALUES];
ClEvent* next;
ClEvent( CPluginMngr::CPlugin* p, int f, int flags );
~ClEvent();
public:
inline CPluginMngr::CPlugin* getPlugin() { return plugin; }
inline int getFunction() { return func; }
void registerFilter( char* filter );
};
private:
struct MsgDataVault {
float fValue;
int iValue;
const char* sValue;
MsgValueType type;
} parseVault[MAX_PARSE_VALUES];
ClEvent* modMsgsFunCall[MAX_AMX_REG_MSG];
ClEvent* parseFun;
bool parseNotDone;
int parsePos; // is -1 less then args. num.
float* timer;
ClEvent* getValidEvent(ClEvent* a );
public:
EventsMngr();
~EventsMngr();
// Interface
ClEvent* registerEvent( CPluginMngr::CPlugin* p, int f, int flags, int pos );
void parserInit(int msg_type, float* timer , CPlayer* target = 0, int index = 0);
void parseValue(int iValue);
void parseValue(float fValue);
void parseValue(const char *sz);
void executeEvents();
inline int getArgNum() { return (parsePos+1); }
const char* getArgString(int a);
int getArgInteger(int a);
float getArgFloat(int a);
void clearEvents(void);
static int getEventId( const char* msg );
class iterator {
EventsMngr* b;
ClEvent* a;
public:
inline iterator(ClEvent*aa,EventsMngr* bb) : a(aa), b(bb) {}
inline iterator& operator++() {
a = b->getValidEvent( a->next );
return *this;
}
inline bool operator==(const iterator& c) const { return a == c.a; }
inline bool operator!=(const iterator& c) const { return !operator==(c); }
ClEvent& operator*() { return *a; }
operator bool ( ) const { return a ? true : false; }
};
inline iterator begin() { return iterator(getValidEvent(parseFun),this); }
inline iterator end() { return iterator(0,this); }
};
#endif

115
amxmodx/CFile.cpp Executable file
View File

@ -0,0 +1,115 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include "CFile.h"
#include <ctype.h>
// *****************************************************
// class File
// *****************************************************
File::File( const char* n, const char* m )
{
fp = fopen( n , m );
}
File::~File( )
{
if ( fp )
fclose( fp );
}
File::operator bool ( ) const
{
return fp && !feof(fp);
}
File& operator<<( File& f, const String& n )
{
if ( f ) fputs( n.str() , f.fp ) ;
return f;
}
File& operator<<( File& f, const char* n )
{
if ( f ) fputs( n , f.fp ) ;
return f;
}
File& operator<<( File& f, int n )
{
if ( f ) fprintf( f.fp , "%d" , n ) ;
return f;
}
File& operator<<( File& f, const char& c )
{
if ( f ) fputc( c , f.fp ) ;
return f;
}
File& operator>>( File& f, String& n )
{
if ( !f ) return f;
char temp[1024];
fscanf( f.fp , "%s", temp );
n.set(temp);
return f;
}
File& operator>>( File& f, char* n )
{
if ( f ) fscanf( f.fp , "%s", n );
return f;
}
int File::getline( char* buf, int sz )
{
int a = sz;
if ( *this )
{
int c;
while ( sz-- && (c = getc( (*this).fp)) && c != EOF && c != '\n' )
*buf++ = c;
*buf = 0;
}
return a - sz;
}
File& File::skipWs( )
{
if ( !*this ) return *this;
int c;
while( isspace( c = getc( fp ) ) ){};
ungetc( c , fp );
return *this;
}

58
amxmodx/CFile.h Executable file
View File

@ -0,0 +1,58 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include "CString.h"
#include <stdio.h>
// *****************************************************
// class File
// *****************************************************
class File
{
FILE* fp;
public:
File( const char* n, const char* m );
~File( );
operator bool ( ) const;
friend File& operator<<( File& f, const String& n );
friend File& operator<<( File& f, const char* n );
friend File& operator<<( File& f, const char& c );
friend File& operator<<( File& f, int n );
friend File& operator>>( File& f, String& n );
friend File& operator>>( File& f, char* n );
int getline( char* buf, int sz );
File& skipWs( );
};

80
amxmodx/CForward.cpp Executable file
View File

@ -0,0 +1,80 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
#include "CForward.h"
void CForwardMngr::registerForward( CPluginMngr::CPlugin* p, int func , int type ){
CForward** a = &head[ type ];
while(*a) a = &(*a)->next;
*a = new CForward( p , func );
}
void CForwardMngr::clearForwards( CForward** a ){
while( *a ) {
CForward* b = (*a)->next;
delete *a;
*a = b;
}
}
void CForwardMngr::clear()
{
for ( int a = 0; a < FORWARD_NUM; ++a )
clearForwards( &head[ a ] );
}
void CForwardMngr::executeForwards( int type , int num , int player ) {
cell ret = 0;
int err;
CForward* a = head[ type ];
while ( a )
{
if ( a->getPlugin()->isExecutable( a->getFunction() ) )
{
if ((err = amx_Exec(a->getPlugin()->getAMX(), &ret, a->getFunction() , num, player)) != AMX_ERR_NONE)
print_srvconsole("[AMX] Run time error %d on line %ld (plugin \"%s\")\n", err,a->getPlugin()->getAMX()->curline,a->getPlugin()->getName());
if ( ret )
break;
}
a = a->next;
}
}

115
amxmodx/CForward.h Executable file
View File

@ -0,0 +1,115 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#ifndef FORWARD_H
#define FORWARD_H
// *****************************************************
// class CmdMngr
// *****************************************************
#define FORWARD_NUM 12
enum {
FF_ClientCommand,
FF_ClientConnect,
FF_ClientDisconnect,
FF_ClientInfoChanged,
FF_ClientPutInServer,
FF_PluginInit,
FF_PluginCfg,
FF_PluginPrecache,
FF_PluginLog,
FF_PluginEnd,
FF_InconsistentFile,
FF_ClientAuthorized,
};
class CForwardMngr
{
public:
class iterator;
class CForward
{
friend class iterator;
friend class CForwardMngr;
CPluginMngr::CPlugin* plugin;
int function;
CForward* next;
CForward( CPluginMngr::CPlugin* p, int func ) : plugin(p) , function(func) {next=0;}
public:
inline CPluginMngr::CPlugin* getPlugin() { return plugin; }
inline int getFunction() { return function; }
};
private:
CForward *head[ FORWARD_NUM ];
void clearForwards( CForward** a );
public:
CForwardMngr() {memset( head, 0, sizeof(head));}
~CForwardMngr() { clear(); }
// Interface
void registerForward( CPluginMngr::CPlugin* p, int func , int type );
void executeForwards( int type , int num = 0, int player = 0 );
void clear();
class iterator {
CForward *a;
public:
iterator(CForward*aa) : a(aa) {}
iterator& operator++() { a = a->next; return *this; }
bool operator==(const iterator& b) const { return a == b.a; }
bool operator!=(const iterator& b) const { return !operator==(b); }
operator bool () const { return a ? true : false; }
CForward& operator*() { return *a; }
};
inline iterator begin( int type ) const { return iterator(head[(int)type]); }
inline iterator end() const { return iterator(0); }
inline bool forwardsExist( int type ) {return head[(int)type]?true:false;}
};
#endif

104
amxmodx/CList.h Executable file
View File

@ -0,0 +1,104 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#ifndef CLIST_H
#define CLIST_H
// *****************************************************
// class CList
// *****************************************************
template <typename T, typename F = char* >
class CList {
public:
class iterator;
class CListEle {
friend class CList<T,F>;
friend class iterator;
T* obj;
CListEle* next;
CListEle( T* a , CListEle* nn ) : obj(a) , next(nn) {}
public:
T& operator* () { return *obj; }
};
private:
CListEle *head;
public:
CList<T,F>() { head = 0; }
~CList<T,F>() { clear(); }
void clear() {
iterator a = begin();
while( a ) a.remove();
}
void put( T* a ) {
head = new CListEle( a , head );
}
class iterator {
CListEle** a;
public:
iterator(CListEle** i=0) : a(i){}
T& operator*() const { return *(*a)->obj;}
inline operator bool () const { return (a && *a); }
inline iterator& operator++() {
a = &(*a)->next;
return *this;
}
inline iterator operator++(int) {
iterator tmp(a);
a = &(*a)->next;
return tmp;
}
iterator& remove(){
CListEle* aa = (*a)->next;
delete (*a)->obj;
delete *a;
*a = aa;
return *this;
}
iterator& put( T* aa ){
*a = new CListEle( aa , *a );
return *this;
}
};
inline iterator begin() { return iterator(&head); }
iterator find( F a ){
iterator cc = begin();
while(cc){
if ( *cc == a )
break;
++cc;
}
return cc;
}
};
#endif

253
amxmodx/CLogEvent.cpp Executable file
View File

@ -0,0 +1,253 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
#include "CLogEvent.h"
// *****************************************************
// class LogEventsMngr
// *****************************************************
LogEventsMngr::LogEventsMngr() {
logCurrent = logCounter = 0;
logcmplist = 0;
arelogevents = false;
memset( logevents, 0, sizeof(logevents) );
}
LogEventsMngr::~LogEventsMngr() {
clearLogEvents();
}
int LogEventsMngr::CLogCmp::compareCondition(const char* string){
if ( logid == parent->logCounter )
return result;
logid = parent->logCounter;
if ( in ) return result = strstr( string , text.str() ) ? 0 : 1;
return result = strcmp(string,text.str());
}
LogEventsMngr::CLogCmp* LogEventsMngr::registerCondition(char* filter){
char* temp = filter;
// expand "1=message"
while ( isdigit(*filter) )
++filter;
bool in = (*filter=='&');
*filter++ = 0;
int pos = atoi(temp);
if ( pos < 0 || pos >= MAX_LOGARGS) pos = 0;
CLogCmp* c = logcmplist;
while( c ) {
if ( (c->pos==pos) && (c->in==in) && !strcmp(c->text.str(), filter))
return c;
c = c->next;
}
return logcmplist = new CLogCmp( filter , in , pos , logcmplist,this );
}
void LogEventsMngr::CLogEvent::registerFilter( char* filter ){
CLogCmp *cmp = parent->registerCondition( filter );
if ( cmp == 0 ) return;
for(LogCond* c = filters; c ; c = c->next){
if ( c->argnum == cmp->pos ){
c->list = new LogCondEle( cmp , c->list );
return;
}
}
LogCondEle* aa = new LogCondEle( cmp , 0 );
if ( aa == 0 ) return;
filters = new LogCond( cmp->pos , aa , filters );
}
void LogEventsMngr::setLogString( char* frmt, va_list& vaptr ) {
++logCounter;
int len = vsnprintf (logString, 255 , frmt, vaptr );
if ( len == - 1) {
len = 255;
logString[len] = 0;
}
if ( len ) logString[--len] = 0;
logArgc = 0;
}
void LogEventsMngr::setLogString( char* frmt, ... ) {
++logCounter;
va_list logArgPtr;
va_start ( logArgPtr , frmt );
int len = vsnprintf(logString, 255 , frmt, logArgPtr );
if ( len == - 1) {
len = 255;
logString[len] = 0;
}
va_end ( logArgPtr );
if ( len ) logString[--len] = 0;
logArgc = 0;
}
void LogEventsMngr::parseLogString( ) {
register const char* b = logString;
register int a;
while( *b && logArgc < MAX_LOGARGS ){
a = 0;
if ( *b == '"' ) {
++b;
while ( *b && *b != '"' && a < 127 )
logArgs[logArgc][a++] = *b++;
logArgs[logArgc++][a] = 0;
if ( *b) b+=2; // thanks to double terminator
}
else if ( *b == '(' ) {
++b;
while ( *b && *b != ')' && a < 127 )
logArgs[logArgc][a++] = *b++;
logArgs[logArgc++][a] = 0;
if ( *b) b+=2;
}
else {
while ( *b && *b != '(' && *b != '"' && a < 127 )
logArgs[logArgc][a++] = *b++;
if ( *b ) --a;
logArgs[logArgc++][a] = 0;
}
}
}
LogEventsMngr::CLogEvent* LogEventsMngr::registerLogEvent( CPluginMngr::CPlugin* plugin, int func, int pos )
{
if ( pos < 1 || pos > MAX_LOGARGS)
return 0;
arelogevents = true;
CLogEvent** d = &logevents[pos];
while(*d) d = &(*d)->next;
return *d = new CLogEvent( plugin , func, this );
}
void LogEventsMngr::executeLogEvents()
{
int err;
bool valid;
for(CLogEvent* a = logevents[ logArgc ]; a ; a = a->next){
valid = true;
for( CLogEvent::LogCond* b = a->filters; b ; b = b->next){
valid = false;
for( CLogEvent::LogCondEle* c = b->list; c ; c = c->next) {
if ( c->cmp->compareCondition( logArgs[b->argnum] ) == 0 ){
valid = true;
break;
}
}
if (!valid) break;
}
#ifdef ENABLEEXEPTIONS
try
{
#endif
if (valid){
if ((err = amx_Exec(a->plugin->getAMX(), NULL , a->func , 0)) != AMX_ERR_NONE)
print_srvconsole("[AMX] Run time error %d on line %ld (plugin \"%s\")\n",
err,a->plugin->getAMX()->curline,a->plugin->getName());
}
#ifdef ENABLEEXEPTIONS
}
catch( ... )
{
print_srvconsole( "[AMX] fatal error at log forward function execution\n");
}
#endif
}
}
void LogEventsMngr::clearLogEvents(){
logCurrent = logCounter = 0;
arelogevents = false;
for(int i = 0; i < MAX_LOGARGS + 1; ++i){
CLogEvent **a = &logevents[i];
while(*a){
CLogEvent* bb = (*a)->next;
delete *a;
*a = bb;
}
}
clearConditions();
}
void LogEventsMngr::clearConditions() {
while (logcmplist){
CLogCmp* a = logcmplist->next;
delete logcmplist;
logcmplist = a;
}
}
LogEventsMngr::CLogEvent::LogCond::~LogCond() {
while( list ) {
LogCondEle* cc = list->next;
delete list;
list = cc;
}
}
LogEventsMngr::CLogEvent::~CLogEvent() {
while( filters ) {
LogCond* cc = filters->next;
delete filters;
filters = cc;
}
}
LogEventsMngr::CLogEvent *LogEventsMngr::getValidLogEvent( CLogEvent * a )
{
bool valid;
while(a){
valid = true;
for( CLogEvent::LogCond* b = a->filters; b ; b = b->next){
valid = false;
for( CLogEvent::LogCondEle* c = b->list; c ; c = c->next) {
if ( c->cmp->compareCondition( logArgs[b->argnum] ) == 0 ){
valid = true;
break;
}
}
if (!valid) break;
}
if (!valid){
a = a->next;
continue;
}
return a;
}
return 0;
}

166
amxmodx/CLogEvent.h Executable file
View File

@ -0,0 +1,166 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#ifndef LOGEVENTS_H
#define LOGEVENTS_H
#define MAX_LOGARGS 12
#include <stdarg.h>
// *****************************************************
// class LogEventsMngr
// *****************************************************
class LogEventsMngr {
char logString[256];
char logArgs[MAX_LOGARGS][128];
int logArgc;
int logCounter;
int logCurrent;
bool arelogevents;
public:
class CLogCmp;
class iterator;
class CLogEvent;
friend class CLogEvent;
friend class CLogCmp;
friend class iterator;
class CLogCmp
{
friend class LogEventsMngr;
friend class CLogEvent;
LogEventsMngr* parent;
String text;
int logid;
int pos;
int result;
bool in;
CLogCmp *next;
CLogCmp( const char* s, bool r, int p, CLogCmp *n, LogEventsMngr* mg ) : text(s) {
logid = result = 0;
pos = p;
parent = mg;
in = r;
next = n;
}
public:
int compareCondition(const char* string);
};
private:
CLogCmp *logcmplist;
public:
class CLogEvent {
friend class LogEventsMngr;
friend class iterator;
struct LogCondEle {
CLogCmp *cmp;
LogCondEle *next;
LogCondEle(CLogCmp *c, LogCondEle *n): cmp(c) , next(n) { }
};
struct LogCond {
LogCondEle *list;
int argnum;
LogCond *next;
LogCond( int a , LogCondEle* ee , LogCond* n ) : argnum(a) , list(ee), next(n) {}
~LogCond();
};
CPluginMngr::CPlugin *plugin;
int func;
LogEventsMngr* parent;
LogCond *filters;
CLogEvent *next;
CLogEvent(CPluginMngr::CPlugin *p,int f, LogEventsMngr* ppp) : plugin(p),func(f), filters(0),parent(ppp) ,next(0) { }
~CLogEvent();
public:
void registerFilter( char* filter );
inline CPluginMngr::CPlugin *getPlugin() { return plugin; }
inline int getFunction() { return func; }
};
private:
CLogEvent *logevents[MAX_LOGARGS+1];
CLogEvent *getValidLogEvent( CLogEvent * a );
CLogCmp* registerCondition(char* filter);
void clearConditions();
public:
LogEventsMngr();
~LogEventsMngr();
// Interface
CLogEvent* registerLogEvent( CPluginMngr::CPlugin* plugin, int func, int pos );
inline bool logEventsExist() { return arelogevents; }
void setLogString( char* frmt, va_list& vaptr );
void setLogString( char* frmt , ... );
void parseLogString( );
void executeLogEvents();
inline const char* getLogString() { return logString; }
inline int getLogArgNum() { return logArgc; }
inline const char* getLogArg( int i ) { return ( i < 0 || i >= logArgc ) ? "" : logArgs[ i ]; }
void clearLogEvents();
class iterator {
LogEventsMngr* b;
CLogEvent* a;
public:
inline iterator(CLogEvent*aa,LogEventsMngr* bb) : a(aa), b(bb) {}
inline iterator& operator++() {
a = b->getValidLogEvent( a->next );
return *this;
}
inline bool operator==(const iterator& c) const { return a == c.a; }
inline bool operator!=(const iterator& c) const { return !operator==(c); }
CLogEvent& operator*() { return *a; }
operator bool ( ) const { return a ? true : false; }
};
inline iterator begin() { return iterator(getValidLogEvent(logevents[ logArgc ]),this); }
inline iterator end() { return iterator(0,this); }
};
#endif

94
amxmodx/CMenu.cpp Executable file
View File

@ -0,0 +1,94 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
#include "CMenu.h"
// *****************************************************
// class MenuMngr
// *****************************************************
MenuMngr::MenuCommand::MenuCommand( CPluginMngr::CPlugin *a, int mi, int k, int f ) {
plugin = a;
keys = k;
menuid = mi;
function = f;
next = 0;
}
MenuMngr::~MenuMngr()
{
clear();
}
int MenuMngr::findMenuId(const char* name, AMX* amx)
{
for( MenuIdEle* b = headid; b ; b = b->next) {
if ( (!b->amx || amx == b->amx) && strstr(name,b->name.str()) )
return b->id;
}
return 0;
}
int MenuMngr::registerMenuId(const char* n, AMX* a )
{
int id = findMenuId( n, a );
if (id) return id;
headid = new MenuIdEle( n, a , headid );
return headid->id;
}
void MenuMngr::registerMenuCmd( CPluginMngr::CPlugin *a,int mi, int k , int f )
{
MenuCommand** temp = &headcmd;
while(*temp) temp = &(*temp)->next;
*temp = new MenuCommand(a,mi, k,f);
}
void MenuMngr::clear()
{
while (headid)
{
MenuIdEle* a = headid->next;
delete headid;
headid = a;
}
while (headcmd)
{
MenuCommand* a = headcmd->next;
delete headcmd;
headcmd = a;
}
}
int MenuMngr::MenuIdEle::uniqueid = 0;

107
amxmodx/CMenu.h Executable file
View File

@ -0,0 +1,107 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#ifndef MENUS_H
#define MENUS_H
// *****************************************************
// class MenuMngr
// *****************************************************
class MenuMngr
{
struct MenuIdEle
{
String name;
AMX* amx;
MenuIdEle* next;
int id;
static int uniqueid;
MenuIdEle( const char* n, AMX* a, MenuIdEle* m ) : name( n ) , amx(a) , next( m ) {
id = ++uniqueid;
}
~MenuIdEle() { --uniqueid; }
} *headid;
public:
class iterator;
private:
class MenuCommand
{
friend class iterator;
friend class MenuMngr;
CPluginMngr::CPlugin *plugin;
int menuid;
int keys;
int function;
MenuCommand* next;
MenuCommand( CPluginMngr::CPlugin *a, int mi, int k, int f );
public:
inline int getFunction() { return function; }
inline CPluginMngr::CPlugin* getPlugin() { return plugin; }
inline bool matchCommand( int m, int k ) { return ((m == menuid) && (keys & k)); }
} *headcmd;
public:
MenuMngr() { headid = 0; headcmd = 0; }
~MenuMngr();
// Interface
int findMenuId(const char* name, AMX* a = 0);
int registerMenuId(const char* n, AMX* a );
void registerMenuCmd( CPluginMngr::CPlugin *a,int mi, int k , int f );
void clear();
class iterator {
MenuCommand* a;
public:
iterator(MenuCommand*aa) : a(aa) {}
iterator& operator++() { a = a->next; return *this; }
bool operator==(const iterator& b) const { return a == b.a; }
bool operator!=(const iterator& b) const { return !operator==(b); }
operator bool () const { return a ? true : false; }
MenuCommand& operator*() { return *a; }
};
inline iterator begin() const { return iterator(headcmd); }
inline iterator end() const { return iterator(0); }
};
#endif

232
amxmodx/CMisc.cpp Executable file
View File

@ -0,0 +1,232 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
// *****************************************************
// class CPlayer
// *****************************************************
void CPlayer::Init( edict_t* e , int i )
{
index = i;
pEdict = e;
initialized = false;
ingame = false;
bot = false;
authorized = false;
current = 0;
teamId = -1;
deaths = 0;
aiming = 0;
menu = 0;
keys = 0;
death_weapon.clear();
name.clear();
ip.clear();
team.clear();
}
void CPlayer::Disconnect() {
ingame = false;
initialized = false;
authorized = false;
}
void CPlayer::PutInServer() {
playtime = gpGlobals->time;
ingame = true;
}
bool CPlayer::Connect(const char* connectname,const char* ipaddress) {
name.set(connectname);
ip.set(ipaddress);
time = gpGlobals->time;
bot = IsBot();
death_killer = 0;
memset(flags,0,sizeof(flags));
memset(weapons,0,sizeof(weapons));
initialized = true;
authorized = false;
const char* authid = GETPLAYERAUTHID( pEdict );
if ( (authid == 0) || (*authid == 0)
|| (strcmp( authid , "STEAM_ID_PENDING") == 0) )
return true;
return false;
}
// *****************************************************
// class Grenades
// *****************************************************
void Grenades::put( edict_t* grenade, float time, int type, CPlayer* player )
{
Obj* a = new Obj;
if ( a == 0 ) return;
a->player = player;
a->grenade = grenade;
a->time = gpGlobals->time + time;
a->type = type;
a->next = head;
head = a;
}
bool Grenades::find( edict_t* enemy, CPlayer** p, int& type )
{
bool found = false;
Obj** a = &head;
while ( *a ){
if ( (*a)->time > gpGlobals->time ) {
if ( (*a)->grenade == enemy ) {
found = true;
(*p) = (*a)->player;
type = (*a)->type;
}
}
else {
Obj* b = (*a)->next;
delete *a;
*a = b;
continue;
}
a = &(*a)->next;
}
return found;
}
void Grenades::clear()
{
while(head){
Obj* a = head->next;
delete head;
head = a;
}
}
// *****************************************************
// class XVars
// *****************************************************
void XVars::clear() {
delete[] head;
head = 0;
num = 0;
size = 0;
}
int XVars::put( AMX* p, cell* v )
{
for(int a = 0; a < num; ++a) {
if ( (head[a].amx == p) && (head[a].value == v) )
return a;
}
if ( (num >= size) && realloc_array( size ? (size * 2) : 8 ) )
return -1;
head[num].value = v;
head[num].amx = p;
return num++;
}
int XVars::realloc_array( int nsize )
{
XVarEle* me = new XVarEle[nsize];
if ( me ){
for(int a = 0 ; a < num; ++a)
me[a] = head[a];
delete[] head;
head = me;
size = nsize;
return 0;
}
return 1;
}
// *****************************************************
// class TeamIds
// *****************************************************
TeamIds::TeamIds() { head = 0; newTeam = 0; }
TeamIds::~TeamIds() {
while( head ) {
TeamEle* a = head->next;
delete head;
head = a;
}
}
void TeamIds::registerTeam( const char* n ,int s )
{
TeamEle** a = &head;
while( *a ){
if ( strcmp((*a)->name.str(),n) == 0 ){
if (s != -1){
(*a)->id = s;
newTeam &= ~(1<<(*a)->tid);
}
return;
}
a = &(*a)->next;
}
*a = new TeamEle( n , s );
if ( *a == 0 ) return;
newTeam |= (1<<(*a)->tid);
}
int TeamIds::findTeamId( const char* n )
{
TeamEle* a = head;
while( a ){
if ( !strcmpi(a->name.str(),n) )
return a->id;
a = a->next;
}
return -1;
}
int TeamIds::findTeamIdCase( const char* n)
{
TeamEle* a = head;
while( a ){
if ( !strcmp(a->name.str(), n) )
return a->id;
a = a->next;
}
return -1;
}
char TeamIds::TeamEle::uid = 0;

252
amxmodx/CMisc.h Executable file
View File

@ -0,0 +1,252 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#ifndef CMISC_H
#define CMISC_H
#include "CList.h"
#include "string.h"
// *****************************************************
// class CCVar
// *****************************************************
class CCVar
{
cvar_t cvar;
String name;
String plugin;
public:
CCVar( const char* pname, const char* pplugin,
int pflags, float pvalue ) : name(pname) , plugin(pplugin ) {
cvar.name = (char*)name.str();
cvar.flags = pflags;
cvar.string = "";
cvar.value = pvalue;
}
inline cvar_t* getCvar() { return &cvar; }
inline const char* getPluginName() { return plugin.str(); }
inline const char* getName() { return name.str(); }
inline bool operator == ( const char* string ) const { return (strcmp(name.str(),string)==0); }
};
// *****************************************************
// class CPlayer
// *****************************************************
class CPlayer
{
public:
edict_t* pEdict;
String name;
String ip;
String team;
bool initialized;
bool ingame;
bool bot;
bool authorized;
float time;
float playtime;
struct {
int ammo;
int clip;
} weapons[MAX_WEAPONS];
int current;
int teamId;
int deaths;
int aiming;
int menu;
int keys;
int index;
int flags[32];
int death_headshot;
int death_killer;
int death_victim;
bool death_tk;
String death_weapon;
Vector lastTrace;
Vector thisTrace;
Vector lastHit;
void Init( edict_t* e , int i );
void Disconnect();
void PutInServer();
bool Connect(const char* connectname,const char* ipaddress);
inline bool IsBot(){
const char* auth= (*g_engfuncs.pfnGetPlayerAuthId)(pEdict);
return ( auth && !strcmp( auth , "BOT" ) );
}
inline bool IsAlive(){
return ((pEdict->v.deadflag==DEAD_NO)&&(pEdict->v.health>0));
}
inline void Authorize() { authorized = true; }
};
// *****************************************************
// class Grenades
// *****************************************************
class Grenades
{
struct Obj
{
CPlayer* player;
edict_t* grenade;
float time;
int type;
Obj* next;
} *head;
public:
Grenades() { head = 0; }
~Grenades() { clear(); }
void put( edict_t* grenade, float time, int type, CPlayer* player );
bool find( edict_t* enemy, CPlayer** p, int& type );
void clear();
};
// *****************************************************
// class ForceObject
// *****************************************************
class ForceObject {
AMX* amx;
String filename;
FORCE_TYPE type;
Vector mins;
Vector maxs;
public:
ForceObject(const char* n, FORCE_TYPE c,Vector& mi, Vector& ma, AMX* a) :
filename(n) , type(c), mins(mi), maxs(ma), amx(a) {}
inline const char* getFilename() { return filename.str(); }
inline AMX* getAMX() { return amx; }
Vector& getMin() { return mins; }
Vector& getMax() { return maxs; }
inline FORCE_TYPE getForceType() { return type; }
};
// *****************************************************
// class XVars
// *****************************************************
class XVars
{
struct XVarEle {
AMX* amx;
cell* value;
};
XVarEle* head;
int size;
int num;
int realloc_array( int nsize );
public:
XVars() { num = 0; size = 0; head = 0; }
~XVars() { clear(); }
void clear();
int put( AMX* a, cell* v );
inline cell getValue( int a ) {
return ( a >= 0 && a < num ) ? *(head[a].value) : 0;
}
inline int setValue( int a, cell v ) {
if ( a >= 0 && a < num ){
*(head[a].value) = v;
return 0;
}
return 1;
}
};
// *****************************************************
// class CScript
// *****************************************************
class CScript
{
String filename;
AMX* amx;
void* code;
public:
CScript(AMX* aa, void* cc,const char* ff):filename(ff),amx(aa),code(cc){}
inline AMX* getAMX() { return amx; }
inline const char* getName() { return filename.str(); }
inline bool operator==( void* a ) { return (amx == (AMX*)a); }
inline void* getCode() { return code; }
};
// *****************************************************
// class TeamIds
// *****************************************************
class TeamIds
{
struct TeamEle {
String name;
int id;
char tid;
static char uid;
TeamEle* next;
TeamEle(const char* n, int& i) : name(n) , id(i) , next(0) {
tid = uid++;
};
~TeamEle(){ --uid; }
} *head;
int newTeam;
public:
TeamIds();
~TeamIds();
void registerTeam( const char* n ,int s );
int findTeamId( const char* n);
int findTeamIdCase( const char* n);
inline bool isNewTeam() { return newTeam ? true : false; }
};
#endif

188
amxmodx/CModule.cpp Executable file
View File

@ -0,0 +1,188 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
typedef int (FAR *QUERYMOD)(module_info_s**);
typedef int (FAR *ATTACHMOD)(pfnamx_engine_g*,pfnmodule_engine_g*);
typedef int (FAR *DETACHMOD)(void);
QUERYMOD QueryModule;
ATTACHMOD AttachModule;
DETACHMOD DetachModule;
pfnamx_engine_g engAmxFunc = {
amx_Align16,
amx_Align32,
amx_Allot,
amx_Callback,
amx_Clone,
amx_Debug,
amx_Exec,
amx_Execv,
amx_FindPublic,
amx_FindPubVar,
amx_FindTagId,
amx_Flags,
amx_GetAddr,
amx_GetPublic,
amx_GetPubVar,
amx_GetString,
amx_GetTag,
amx_GetUserData,
amx_Init,
amx_InitJIT,
amx_MemInfo,
amx_NameLength,
amx_NativeInfo,
amx_NumPublics,
amx_NumPubVars,
amx_NumTags,
amx_RaiseError,
amx_Register,
amx_Release,
amx_SetCallback,
amx_SetDebugHook,
amx_SetString,
amx_SetUserData,
amx_StrLen,
};
pfnmodule_engine_g engModuleFunc = {
add_amxnatives,
build_pathname,
copy_amxmemory,
format_amxstring,
get_amxaddr,
get_amxscript,
get_amxscriptname,
get_amxstring,
get_modname,
load_amxscript,
print_srvconsole,
report_error,
set_amxnatives,
set_amxstring,
amxstring_len,
unload_amxscript,
alloc_amxmemory,
free_amxmemory,
};
// *****************************************************
// class CModule
// *****************************************************
CModule::CModule(const char* fname) : filename(fname)
{
metamod = false;
info = 0;
module = 0;
status = MODULE_NONE;
}
CModule::~CModule()
{
if ( module ) DLFREE(module);
natives.clear();
}
bool CModule::attachModule()
{
if ( status != MODULE_QUERY )
return false;
AttachModule = (ATTACHMOD)DLPROC(module,"AMX_Attach");
if ( AttachModule ) (*AttachModule)(&engAmxFunc,&engModuleFunc);
status = MODULE_LOADED;
return true;
}
bool CModule::queryModule()
{
if ( status != MODULE_NONE ) // don't check if already quried
return false;
module = DLLOAD( filename.str() ); // link dll
if ( !module ){
status = MODULE_BADLOAD;
return false;
}
int meta = (int)DLPROC(module,"Meta_Attach"); // check if also MM
if ( meta ) metamod = true;
QueryModule = (QUERYMOD)DLPROC(module,"AMX_Query"); // check what version
if (QueryModule == 0) {
status = MODULE_NOQUERY;
return false;
}
(*QueryModule)( &info );
if ( info == 0 ){
status = MODULE_NOINFO;
return false;
}
if ( info->ivers != AMX_INTERFACE_VERSION ) {
status = MODULE_OLD;
return false;
}
AttachModule = (ATTACHMOD)DLPROC(module,"AMX_Attach"); // check for attach
if ( AttachModule == 0) {
status = MODULE_NOATTACH;
return false;
}
info->serial = (long int)this;
status = MODULE_QUERY;
return true;
}
bool CModule::detachModule()
{
if ( status != MODULE_LOADED )
return false;
DetachModule = (DETACHMOD)DLPROC(module,"AMX_Detach");
if (DetachModule) (*DetachModule)();
DLFREE(module);
module = 0;
natives.clear();
status = MODULE_NONE;
return true;
}
const char* CModule::getStatus() const {
switch(status){
case MODULE_NONE: return "error";
case MODULE_QUERY: return "pending";
case MODULE_BADLOAD:return "bad load";
case MODULE_LOADED:return "running";
case MODULE_NOINFO:return "no info";
case MODULE_NOQUERY:return "no query";
case MODULE_NOATTACH:return "no attach";
case MODULE_OLD:return "old";
}
return "unknown";
}

84
amxmodx/CModule.h Executable file
View File

@ -0,0 +1,84 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
// *****************************************************
// class CModule
// *****************************************************
#ifndef CMODULE_H
#define CMODULE_H
enum MODULE_STATUS {
MODULE_NONE,
MODULE_QUERY,
MODULE_BADLOAD,
MODULE_LOADED,
MODULE_NOINFO,
MODULE_NOQUERY,
MODULE_NOATTACH,
MODULE_OLD
};
class CModule
{
String filename;
bool metamod;
module_info_s* info;
DLHANDLE module;
MODULE_STATUS status;
public:
CModule(const char* fname);
~CModule();
// Interface
bool attachModule();
bool queryModule();
bool detachModule();
const char* getStatus() const;
inline const char* getType() const { return metamod ? "amx&mm" : "amx"; }
inline const char* getAuthor() const { return info ? info->author : "unknown"; }
inline const char* getVersion() const { return info ? info->version : "unknown"; }
inline const char* getName() const { return info ? info->name : "unknown"; }
inline module_info_s* getInfo() const { return info; }
inline int getStatusValue() { return status; }
inline bool operator==( void* fname ) { return !strcmp( filename.str() , (char*)fname ); }
inline bool isReloadable() { return ( (status==MODULE_LOADED) && (info->type==RELOAD_MODULE)); }
CList<AMX_NATIVE_INFO*> natives;
};
#endif

340
amxmodx/COPYING Executable file
View File

@ -0,0 +1,340 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.

207
amxmodx/CPlugin.cpp Executable file
View File

@ -0,0 +1,207 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
#include "CPlugin.h"
#include "CForward.h"
#include "CFile.h"
CPluginMngr::CPlugin* CPluginMngr::loadPlugin(const char* path, const char* name, char* error) {
CPlugin** a = &head;
while( *a ) a = &(*a)->next;
*a = new CPlugin( pCounter++ ,path,name,error);
return *error ? 0 : *a;
}
void CPluginMngr::unloadPlugin( CPlugin** a ) {
CPlugin* next = (*a)->next;
delete *a;
*a = next;
--pCounter;
}
int CPluginMngr::loadPluginsFromFile( const char* filename )
{
File fp( build_pathname("%s",filename) , "r" );
if ( !fp )
{
print_srvconsole( "[AMX] Plugins list not found (file \"%s\")\n",filename);
return 1;
}
// Find now folder
char pluginName[256], line[256], error[256], pluginsDir[256];
strcpy(pluginsDir,filename);
char* ptrEnd = pluginsDir;
for (int i = 0; pluginsDir[i];++i ) {
if (pluginsDir[i] == '/' || pluginsDir[i] == '\\')
ptrEnd = &pluginsDir[i];
}
*ptrEnd = 0;
while ( fp.getline(line , 255 ) )
{
*pluginName = 0;
sscanf(line,"%s",pluginName);
if (!isalnum(*pluginName)) continue;
CPlugin* plugin = loadPlugin( pluginsDir , pluginName , error );
if ( plugin != 0 ) // load_amxscript fills it with info in case of error
{
AMX* amx = plugin->getAMX();
int iFunc;
if(amx_FindPublic(amx, "client_command" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_ClientCommand);
if(amx_FindPublic(amx, "client_connect" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_ClientConnect);
if(amx_FindPublic(amx, "client_disconnect" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_ClientDisconnect);
if(amx_FindPublic(amx, "client_infochanged" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_ClientInfoChanged);
if(amx_FindPublic(amx, "client_putinserver" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_ClientPutInServer);
if(amx_FindPublic(amx, "plugin_init" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_PluginInit);
if(amx_FindPublic(amx, "plugin_cfg" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_PluginCfg);
if(amx_FindPublic(amx, "plugin_precache" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_PluginPrecache);
if(amx_FindPublic(amx, "plugin_log" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_PluginLog);
if(amx_FindPublic(amx, "plugin_end" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_PluginEnd);
if(amx_FindPublic(amx, "inconsistent_file" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_InconsistentFile);
if(amx_FindPublic(amx, "client_authorized" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_ClientAuthorized);
}
else
{
print_srvconsole("[AMX] %s (plugin \"%s\")\n", error, pluginName );
}
}
return pCounter;
}
void CPluginMngr::clear() {
CPlugin**a = &head;
while ( *a )
unloadPlugin(a);
}
CPluginMngr::CPlugin* CPluginMngr::findPluginFast(AMX *amx)
{
return (CPlugin*)(amx->userdata[3]);
/*CPlugin*a = head;
while ( a && &a->amx != amx )
a=a->next;
return a;*/
}
CPluginMngr::CPlugin* CPluginMngr::findPlugin(AMX *amx) {
CPlugin*a = head;
while ( a && &a->amx != amx )
a=a->next;
return a;
}
CPluginMngr::CPlugin* CPluginMngr::findPlugin(int index){
CPlugin*a = head;
while ( a && index--)
a=a->next;
return a;
}
CPluginMngr::CPlugin* CPluginMngr::findPlugin(const char* name) {
if (!name) return 0;
int len = strlen(name);
if (!len) return 0;
CPlugin*a = head;
while( a && strncmp(a->name.str(), name,len) )
a=a->next;
return a;
}
const char* CPluginMngr::CPlugin::getStatus() const {
switch(status){
case ps_running: return "running";
case ps_paused: return "paused";
case ps_bad_load: return "bad load";
case ps_stopped: return "stopped";
case ps_locked: return "locked";
}
return "error";
}
CPluginMngr::CPlugin::CPlugin(int i, const char* p,const char* n, char* e) : name(n), title(n) {
const char* unk = "unknown";
title.set(unk);
author.set(unk);
version.set(unk);
char* path = build_pathname("%s/%s",p,n);
code = 0;
int err = load_amxscript(&amx,&code,path,e );
if ( err == AMX_ERR_NONE ) status = ps_running;
else status = ps_bad_load;
amx.userdata[3] = this;
paused_fun = 0;
next = 0;
id = i;
}
CPluginMngr::CPlugin::~CPlugin( ){
unload_amxscript( &amx, &code );
}
void CPluginMngr::CPlugin::pauseFunction( int id ) {
if (isValid()){
paused_fun |= (1<<id);
g_commands.clearBufforedInfo();
}
}
void CPluginMngr::CPlugin::unpauseFunction( int id ) {
if (isValid()) {
paused_fun &= ~(1<<id);
g_commands.clearBufforedInfo();
}
}
void CPluginMngr::CPlugin::setStatus( int a ) {
status = a;
g_commands.clearBufforedInfo(); // ugly way
}

132
amxmodx/CPlugin.h Executable file
View File

@ -0,0 +1,132 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#ifndef PLUGIN_H
#define PLUGIN_H
// *****************************************************
// class CPluginMngr
// *****************************************************
enum {
ps_bad_load,
ps_error,
ps_paused,
ps_running,
ps_stopped,
ps_locked
};
class CPluginMngr
{
public:
class iterator;
class CPlugin
{
friend class iterator;
friend class CPluginMngr;
AMX amx;
void* code;
String name;
String version;
String title;
String author;
int paused_fun;
int status;
CPlugin* next;
int id;
CPlugin(int i , const char* p,const char* n, char* e);
~CPlugin( );
public:
inline const char* getName() const { return name.str();}
inline const char* getVersion() const { return version.str();}
inline const char* getTitle() const { return title.str();}
inline const char* getAuthor()const { return author.str();}
inline int getId() const { return id; }
inline AMX* getAMX() { return &amx; }
inline void setTitle( const char* n ) { title.set(n); }
inline void setAuthor( const char* n ) { author.set(n); }
inline void setVersion( const char* n ) { version.set(n); }
inline bool isValid() const { return ((status != ps_bad_load) && (status != ps_locked)); }
inline bool isPaused() const { return ( (status == ps_paused) || (status == ps_stopped)); }
inline bool isFunctionPaused( int id ) const { return (paused_fun & (1<<id)) ? true : false; }
inline bool isExecutable(int id) const { return (isValid() && !isPaused() && !isFunctionPaused(id)); }
inline void pausePlugin( ) { if ( isValid() ) setStatus(ps_paused); }
inline void unpausePlugin( ) { if ( isValid() ) setStatus(ps_running); }
void pauseFunction( int id );
void unpauseFunction( int id );
void setStatus( int a );
const char* getStatus() const;
};
private:
CPlugin *head;
int pCounter;
public:
CPluginMngr() { head = 0; pCounter = 0; }
~CPluginMngr() { clear(); }
// Interface
CPlugin* loadPlugin(const char* path, const char* name, char* error);
void unloadPlugin( CPlugin** a );
int loadPluginsFromFile( const char* filename );
CPlugin* findPluginFast(AMX *amx);
CPlugin* findPlugin(AMX *amx);
CPlugin* findPlugin(int index);
CPlugin* findPlugin(const char* name);
inline int getPluginsNum() const { return pCounter; }
void clear();
class iterator {
CPlugin *a;
public:
iterator(CPlugin*aa) : a(aa) {}
iterator& operator++() { a = a->next; return *this; }
bool operator==(const iterator& b) const { return a == b.a; }
bool operator!=(const iterator& b) const { return !operator==(b); }
operator bool () const { return a ? true : false; }
CPlugin& operator*() { return *a; }
};
inline iterator begin() const { return iterator(head); }
inline iterator end() const { return iterator(0); }
};
#endif

69
amxmodx/CString.cpp Executable file
View File

@ -0,0 +1,69 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include "CString.h"
#include "string.h"
#include "CFile.h"
String::String()
{
len = 0;
napis = 0;
}
String::String( const char* n )
{
napis = 0;
set(n);
}
String::~String()
{
clear();
}
void String::set( const char* n )
{
clear();
if ( n != 0 ){
len = strlen( n );
napis = new char[ len + 1 ];
if ( napis ) strcpy( napis , n );
else len = 0;
}
}
void String::clear() {
delete[] napis;
napis = 0;
len = 0;
}

58
amxmodx/CString.h Executable file
View File

@ -0,0 +1,58 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#ifndef STRING_CUSTOM_H
#define STRING_CUSTOM_H
// *****************************************************
// class String
// *****************************************************
class String
{
char* napis;
short int len;
public:
String();
String( const char* n );
~String();
void set( const char* n );
inline bool empty() const { return (len == 0); }
inline const char* str() const { return napis ? napis : "(null)"; }
inline short int size() const { return len; }
void clear();
};
#endif

192
amxmodx/CTask.cpp Executable file
View File

@ -0,0 +1,192 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
#include "CTask.h"
CTaskMngr::CTask::CTask( CPluginMngr::CPlugin* p, int f, int flags,
int i, float base, float exec, int parlen ,
const cell* par, int r){
plugin = p;
func = f;
id = i;
next = 0;
prev = 0;
param_len = 0;
param = 0;
base_time = base;
exec_time = exec;
repeat = (flags & 1) ? r : 0;
loop = (flags & 2) ? true : false;
afterstart = (flags & 4) ? true : false;
beforeend = (flags & 8) ? true : false;
if ( parlen )
{
param = new cell[ parlen + 1 ];
if ( param ){
param_len = parlen + 1;
memcpy( param , par , sizeof( cell ) * parlen );
param[ parlen ] = 0;
}
}
}
CTaskMngr::CTask* CTaskMngr::getFirstValidTask(CTask* h){
CTask* a = h;
while( a ) {
if ( a->isRemoved() ) {
CTask* b = a->next;
unlink( a );
delete a;
a = b;
continue;
}
else if ( a->afterstart ){
if ( *m_timer - *m_timeleft + 1 < a->base_time ) {
a = a->next;
continue;
}
}
else if ( a->beforeend ){
if ( *m_timelimit == 0 ){
a = a->next;
continue;
}
if ( (*m_timeleft + *m_timelimit * 60.0) - *m_timer - 1 >
a->base_time ){
a = a->next;
continue;
}
}
else if ( a->exec_time > *m_timer ) {
a = a->next;
continue;
}
return a;
}
return 0;
}
CTaskMngr::CTask* CTaskMngr::getNextTask(CTask* a) {
if ( a->isRemoved() )
return a->next;
if ( a->loop || a->isToReply() ){
a->exec_time = *m_timer + a->base_time;
return a->next;
}
a->setToRemove();
return a->next;
}
CTaskMngr::CTaskMngr() {
head = 0;
tail = 0;
m_timer = 0;
m_timelimit = 0;
m_timeleft = 0;
}
CTaskMngr::~CTaskMngr() {
clear();
}
void CTaskMngr::clear() {
while ( head ) {
tail = head->next;
delete head;
head = tail;
}
}
void CTaskMngr::registerTimers( float* timer , float* timelimit, float* timeleft ) {
m_timer = timer;
m_timelimit = timelimit;
m_timeleft = timeleft;
}
void CTaskMngr::registerTask( CPluginMngr::CPlugin* plugin, int func,
int flags, int i, float base, float exec,
int parlen , const cell* par, int repeat ){
CTask* a = new CTask(plugin,func,flags,i,base,exec,parlen,par,repeat );
if ( a == 0 ) return;
if ( tail )
{
tail->next = a;
a->prev = tail;
tail = a;
}
else {
head = a;
tail = a;
}
}
CTaskMngr::CTask* CTaskMngr::findTask( int id , AMX* amx )
{
for (CTask* a = head; a ; a = a->next)
{
if ( !a->isRemoved() && (a->getTaskId() == id) && (!amx ||
(a->getPlugin()->getAMX() == amx)) )
return a;
}
return 0;
}
void CTaskMngr::unlink(CTask* a){
if ( a->prev ) a->prev->next = a->next;
else head = a->next;
if ( a->next ) a->next->prev = a->prev;
else tail = a->prev;
}
int CTaskMngr::removeTasks( int id , AMX* amx )
{
CTask* a;
int i = 0;
while ( (a = findTask(id, amx )) != 0 ) {
a->setToRemove();
++i;
}
return i;
}

128
amxmodx/CTask.h Executable file
View File

@ -0,0 +1,128 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#ifndef CTASK_H
#define CTASK_H
// *****************************************************
// class CTaskMngr
// *****************************************************
class CTaskMngr
{
public:
class iterator;
class CTask
{
friend class iterator;
friend class CTaskMngr;
CPluginMngr::CPlugin* plugin;
int id;
int func;
int repeat;
bool loop;
bool afterstart;
bool beforeend;
float base_time;
float exec_time;
int param_len;
cell* param;
CTask* next;
CTask* prev;
inline void setToRemove() { exec_time = -1.0f; }
inline bool isToReply() { return (repeat-- > 0); }
inline bool isRemoved() { return (exec_time == -1.0f); }
CTask( CPluginMngr::CPlugin* p, int f, int flags, int i,
float base, float exec, int parlen , const cell* par, int r );
~CTask() { if ( param_len ) delete[] param; }
public:
inline int getParamLen() { return param_len; }
inline int getTaskId() { return id; }
inline int getFunction() { return func; }
cell* getParam() { return param; }
CPluginMngr::CPlugin* getPlugin() { return plugin; }
};
private:
friend class iterator;
CTask *head;
CTask *tail;
float* m_timer;
float* m_timelimit;
float* m_timeleft;
CTask* getFirstValidTask(CTask* a);
CTask* getNextTask(CTask* a);
CTask* findTask( int id , AMX* amx );
void unlink(CTask* a);
public:
CTaskMngr();
~CTaskMngr();
// Interface
void registerTimers( float* timer , float* timelimit, float* timeleft );
void registerTask( CPluginMngr::CPlugin* plugin, int func, int flags, int i, float base, float exec, int parlen , const cell* par, int repeat );
inline int taskExists( int id ,AMX* amx) { return findTask(id,amx ) ? 1 : 0; }
int removeTasks( int id , AMX* amx );
void clear();
class iterator {
CTaskMngr* b;
CTask* a;
public:
iterator(CTask*aa,CTaskMngr* bb) : a(aa), b(bb) {}
iterator& operator++() {
a = b->getNextTask( a );
a = b->getFirstValidTask( a );
return *this;
}
CTask& operator*() { return *a; }
operator bool ( ) const { return a ? true : false; }
};
inline iterator begin() { return iterator(getFirstValidTask(head),this); }
};
#endif

177
amxmodx/CVault.cpp Executable file
View File

@ -0,0 +1,177 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include "CVault.h"
#include "CFile.h"
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
// *****************************************************
// class Vault
// *****************************************************
bool Vault::exists( const char* k )
{
if ( *k == 0 ) return false;
return *find( k ) != 0;
}
void Vault::put( const char* k, const char* v )
{
if ( *k == 0 ) return;
if ( *v == 0 )
{
remove( k );
return;
}
Obj** a = find( k );
if ( *a )
{
(*a)->value.set(v);
(*a)->number = atoi( v );
}
else
*a = new Obj( k , v );
}
Vault::Obj::Obj( const char* k, const char* v): key(k) , value(v) , next(0) {
number = atoi(v);
}
Vault::Obj** Vault::find( const char* n )
{
Obj** a = &head;
while( *a )
{
if ( strcmp((*a)->key.str(), n) == 0 )
return a;
a = &(*a)->next;
}
return a;
}
int Vault::get_number( const char* n )
{
if ( *n == 0 ) return 0;
Obj* b = *find( n );
if ( b == 0 ) return 0;
return b->number;
}
const char* Vault::get( const char* n )
{
if ( *n == 0 ) return "";
Obj* b = *find( n );
if ( b == 0 ) return "";
return b->value.str();
}
void Vault::clear()
{
while ( head )
{
Obj* a = head->next;
delete head;
head = a;
}
}
void Vault::remove( const char* n )
{
Obj** b = find( n );
if ( *b == 0 ) return;
Obj* a = (*b)->next;
delete *b;
*b = a;
}
void Vault::setSource( const char* n )
{
path.set(n);
}
bool Vault::loadVault( )
{
if ( path.empty() ) return false;
clear();
File a( path.str() , "r" );
if ( !a ) return false;
const int sz = 512;
char value[sz+1];
char key[sz+1];
while ( a >> key && a.skipWs() && a.getline( value , sz ) )
{
if ( isalpha ( *key ) )
put( key, value );
}
return true;
}
bool Vault::saveVault( )
{
if ( path.empty() ) return false;
File a( path.str() , "w" );
if ( !a ) return false;
a << "; Don't modify!" << '\n';
for (Obj* b = head; b ;b = b->next)
a << b->key << '\t' << b->value << '\n';
return true;
}

93
amxmodx/CVault.h Executable file
View File

@ -0,0 +1,93 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#ifndef VAULT_CUSTOM_H
#define VAULT_CUSTOM_H
#include "CString.h"
#include "CList.h"
// *****************************************************
// class Vault
// *****************************************************
class Vault
{
struct Obj
{
String key;
String value;
int number;
Obj *next;
Obj( const char* k, const char* v);
} *head;
String path;
Obj** find( const char* n );
public:
Vault() {head=0;}
~Vault() { clear();}
// Interface
bool exists( const char* k );
void put(const char* k, const char* v);
void remove( const char* k );
const char* get( const char* n );
int get_number( const char* n );
void setSource( const char* n );
bool loadVault( );
bool saveVault( );
void clear();
class iterator {
Obj * a;
public:
iterator(Obj*aa) : a(aa) {}
iterator& operator++() { if ( a ) a = a->next; return *this; }
bool operator==(const iterator& b) const { return a == b.a; }
bool operator!=(const iterator& b) const { return !operator==(b); }
String& key() const { return a->key; }
String& value() const { return a->value; }
};
inline iterator begin() const { return iterator(head); }
inline iterator end() const { return iterator(0); }
};
#endif

116
amxmodx/Makefile Executable file
View File

@ -0,0 +1,116 @@
MODNAME = amx_mm
SRCFILES = meta_api.cpp CFile.cpp CString.cpp CVault.cpp vault.cpp\
float.cpp file.cpp modules.cpp CMisc.cpp CTask.cpp string.cpp\
amxmod.cpp CEvent.cpp CCmd.cpp CLogEvent.cpp srvcmd.cpp strptime.cpp\
CForward.cpp CPlugin.cpp CModule.cpp CMenu.cpp emsg.cpp util.cpp
CSRCFILES = amx.c amxcore.c amxtime.c power.c
EXTRA_LIBS_LINUX =
EXTRA_LIBS_WIN32 =
EXTRA_LIBDIRS_LINUX = -Lextra/lib_linux
EXTRA_LIBDIRS_WIN32 = -Lextra/lib_win32
EXTRA_INCLUDEDIRS = -Iextra/include
EXTRA_FLAGS = -Dstrcmpi=strcasecmp
SDKTOP=../hlsdk
METADIR=../metamod/metamod
SDKSRC=$(SDKTOP)/SourceCode
OBJDIR_LINUX=obj.linux
OBJDIR_WIN32=obj.win32
SRCDIR=.
ifdef windir
OS=WIN32
else
OS=LINUX
endif
CC_LINUX=gcc
ifeq "$(OS)" "WIN32"
CC_WIN32=gcc
LD_WINDLL=dllwrap
DEFAULT=win32
CLEAN=clean_win32
else
CC_WIN32=/usr/local/cross-tools/i386-mingw32msvc/bin/gcc
LD_WINDLL=/usr/local/cross-tools/bin/i386-mingw32msvc-dllwrap
DEFAULT=linux win32
CLEAN=clean_both
endif
LIBFILE_LINUX = $(MODNAME)_i386.so
LIBFILE_WIN32 = $(MODNAME).dll
TARGET_LINUX = $(OBJDIR_LINUX)/$(LIBFILE_LINUX)
TARGET_WIN32 = $(OBJDIR_WIN32)/$(LIBFILE_WIN32)
FILES_ALL = *.cpp *.h [A-Z]* *.rc
ifeq "$(OS)" "LINUX"
ASRCFILES := $(shell ls -t $(SRCFILES))
else
ASRCFILES := $(shell dir /b)
endif
OBJ_LINUX := $(SRCFILES:%.cpp=$(OBJDIR_LINUX)/%.o)
OBJC_LINUX := $(CSRCFILES:%.c=$(OBJDIR_LINUX)/%.o)
OBJ_WIN32 := $(SRCFILES:%.cpp=$(OBJDIR_WIN32)/%.o)
OBJC_WIN32 := $(CSRCFILES:%.c=$(OBJDIR_WIN32)/%.o)
CCOPT = -march=i586 -O6 -ffast-math -funroll-loops \
-fomit-frame-pointer -fexpensive-optimizations -malign-loops=2 \
-malign-jumps=2 -malign-functions=2 -s -DNDEBUG
INCLUDEDIRS=-I../curl/include -I$(SRCDIR) -I$(METADIR) -I$(SDKSRC)/engine -I$(SDKSRC)/common -I$(SDKSRC)/pm_shared -I$(SDKSRC)/dlls -I$(SDKSRC) $(EXTRA_INCLUDEDIRS)
CFLAGS=-Wall -Wno-unknown-pragmas
ODEF = -DOPT_TYPE=\"optimized\"
CFLAGS:=$(CCOPT) $(CFLAGS) $(ODEF) $(EXTRA_FLAGS)
DO_CC_LINUX=$(CC_LINUX) $(CFLAGS) -fPIC $(INCLUDEDIRS) -o $@ -c $<
DO_CC_WIN32=$(CC_WIN32) $(CFLAGS) $(INCLUDEDIRS) -o $@ -c $<
LINK_LINUX=$(CC_LINUX) $(CFLAGS) -shared -ldl -lm $(OBJ_LINUX) $(OBJC_LINUX) $(EXTRA_LIBDIRS_LINUX) $(EXTRA_LIBS_LINUX) -o $@
LINK_WIN32=$(LD_WINDLL) -mwindows --def $(MODNAME).def --add-stdcall-alias $(OBJ_WIN32) $(OBJC_WIN32) $(EXTRA_LIBDIRS_WIN32) $(EXTRA_LIBS_WIN32) -o $@
$(OBJDIR_LINUX)/%.o: $(SRCDIR)/%.c
$(DO_CC_LINUX)
$(OBJDIR_LINUX)/%.o: $(SRCDIR)/%.cpp
$(DO_CC_LINUX)
$(OBJDIR_WIN32)/%.o: $(SRCDIR)/%.c
$(DO_CC_WIN32)
$(OBJDIR_WIN32)/%.o: $(SRCDIR)/%.cpp
$(DO_CC_WIN32)
default: $(DEFAULT)
$(TARGET_LINUX): $(OBJDIR_LINUX) $(OBJ_LINUX) $(OBJC_LINUX)
$(LINK_LINUX)
$(TARGET_WIN32): $(OBJDIR_WIN32) $(OBJ_WIN32) $(OBJC_WIN32)
$(LINK_WIN32)
$(OBJDIR_LINUX):
mkdir $@
$(OBJDIR_WIN32):
mkdir $@
win32: $(TARGET_WIN32)
linux: $(TARGET_LINUX)
clean: $(CLEAN)
clean_both:
-rm -f $(OBJDIR_LINUX)/*
-rm -f $(OBJDIR_WIN32)/*
clean_win32:
del /q $(OBJDIR_WIN32)

3208
amxmodx/amx.c Executable file
View File

File diff suppressed because it is too large Load Diff

271
amxmodx/amx.h Executable file
View File

@ -0,0 +1,271 @@
/* Abstract Machine for the Small compiler
*
* Copyright (c) ITB CompuPhase, 1997-2002
* This file may be freely used. No warranties of any kind.
*
* Version: $Id$
*/
#if defined __linux__
#include <sclinux.h>
#endif
#ifndef __AMX_H
#define __AMX_H
#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
/* The ISO C99 defines the int16_t and int_32t types. If the compiler got
* here, these types are probably undefined.
*/
#if defined __LCC__ || defined __linux__
#include <stdint.h>
#else
typedef short int int16_t;
typedef unsigned short int uint16_t;
#if defined SN_TARGET_PS2
typedef int int32_t;
typedef unsigned int uint32_t;
#else
typedef long int int32_t;
typedef unsigned long int uint32_t;
#endif
#endif
#endif
/* Some compilers do not support the #pragma align, which should be fine. Some
* compilers give a warning on unknown #pragmas, which is not so fine...
*/
#if defined SN_TARGET_PS2
#define AMX_NO_ALIGN
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* calling convention for native functions */
#if !defined AMX_NATIVE_CALL
#define AMX_NATIVE_CALL
#endif
/* calling convention for all interface functions and callback functions */
#if !defined AMXAPI
#define AMXAPI
#endif
/* File format version Required AMX version
* 0 (original version) 0
* 1 (opcodes JUMP.pri, SWITCH and CASETBL) 1
* 2 (compressed files) 2
* 3 (public variables) 2
* 4 (opcodes SWAP.pri/alt and PUSHADDR) 4
* 5 (tagnames table) 4
* 6 (reformatted header) 6
*/
#define MIN_FILE_VERSION 6 /* lowest file format version */
#define CUR_FILE_VERSION 6 /* current AMX version (parallel with file version) */
#if !defined CELL_TYPE
#define CELL_TYPE
#if defined(BIT16)
typedef uint16_t ucell; /* only for type casting */
typedef int16_t cell;
#else
typedef uint32_t ucell;
typedef int32_t cell;
#endif
#endif
struct __amx;
typedef cell (AMX_NATIVE_CALL *AMX_NATIVE)(struct __amx *amx, cell *params);
typedef int (AMXAPI *AMX_CALLBACK)(struct __amx *amx, cell index,
cell *result, cell *params);
typedef int (AMXAPI *AMX_DEBUG)(struct __amx *amx);
#if !defined FAR
#define FAR
#endif
#if defined _MSC_VER
#pragma warning(disable:4103) /* disable warning message 4103 that complains
* about pragma pack in a header file */
#endif
#if !defined AMX_NO_ALIGN
#if defined __linux__
#pragma pack(1) /* structures must be packed (byte-aligned) */
#else
#pragma pack(push)
#pragma pack(1) /* structures must be packed (byte-aligned) */
#if defined __TURBOC__
#pragma option -a- /* "pack" pragma for older Borland compilers */
#endif
#endif
#endif
typedef struct {
char FAR *name;
AMX_NATIVE func;
} AMX_NATIVE_INFO;
#define AMX_USERNUM 4
#define sEXPMAX 19
typedef struct {
uint32_t address;
char name[sEXPMAX+1];
} AMX_FUNCSTUB;
/* The AMX structure is the internal structure for many functions. Not all
* fields are valid at all times; many fields are cached in local variables.
*/
typedef struct __amx {
unsigned char FAR *base; /* points to the AMX header ("amxhdr") plus the code, optionally also the data */
unsigned char FAR *data; /* points to separate data+stack+heap, may be NULL */
AMX_CALLBACK callback;
AMX_DEBUG debug;
/* for external functions a few registers must be accessible from the outside */
cell cip; /* relative to base + amxhdr->cod */
cell frm; /* relative to base + amxhdr->dat */
cell hea, hlw, stk, stp; /* all four are relative to base + amxhdr->dat */
int flags; /* current status, see amx_Flags() */
/* for assertions and debug hook */
cell curline, curfile;
int dbgcode;
cell dbgaddr, dbgparam;
char FAR *dbgname;
/* user data */
long usertags[AMX_USERNUM];
void FAR *userdata[AMX_USERNUM];
/* native functions can raise an error */
int error;
/* the sleep opcode needs to store the full AMX status */
cell pri, alt, reset_stk, reset_hea;
#if defined JIT
/* support variables for the JIT */
int reloc_size; /* required temporary buffer for relocations */
long code_size; /* estimated memory footprint of the native code */
#endif
} AMX;
/* The AMX_HEADER structure is both the memory format as the file format. The
* structure is used internaly.
*/
typedef struct __amx_header {
int32_t size; /* size of the "file" */
uint16_t magic; /* signature */
char file_version; /* file format version */
char amx_version; /* required version of the AMX */
int16_t flags;
int16_t defsize;
int32_t cod; /* initial value of COD - code block */
int32_t dat; /* initial value of DAT - data block */
int32_t hea; /* initial value of HEA - start of the heap */
int32_t stp; /* initial value of STP - stack top */
int32_t cip; /* initial value of CIP - the instruction pointer */
int32_t publics; /* offset to the "public functions" table */
int32_t natives; /* offset to the "native functions" table */
int32_t libraries; /* offset to the table of libraries */
int32_t pubvars; /* the "public variables" table */
int32_t tags; /* the "public tagnames" table */
} AMX_HEADER;
#define AMX_MAGIC 0xf1e0
enum {
AMX_ERR_NONE,
/* reserve the first 15 error codes for exit codes of the abstract machine */
AMX_ERR_EXIT, /* forced exit */
AMX_ERR_ASSERT, /* assertion failed */
AMX_ERR_STACKERR, /* stack/heap collision */
AMX_ERR_BOUNDS, /* index out of bounds */
AMX_ERR_MEMACCESS, /* invalid memory access */
AMX_ERR_INVINSTR, /* invalid instruction */
AMX_ERR_STACKLOW, /* stack underflow */
AMX_ERR_HEAPLOW, /* heap underflow */
AMX_ERR_CALLBACK, /* no callback, or invalid callback */
AMX_ERR_NATIVE, /* native function failed */
AMX_ERR_DIVIDE, /* divide by zero */
AMX_ERR_SLEEP, /* go into sleepmode - code can be restarted */
AMX_ERR_MEMORY = 16, /* out of memory */
AMX_ERR_FORMAT, /* invalid file format */
AMX_ERR_VERSION, /* file is for a newer version of the AMX */
AMX_ERR_NOTFOUND, /* function not found */
AMX_ERR_INDEX, /* invalid index parameter (bad entry point) */
AMX_ERR_DEBUG, /* debugger cannot run */
AMX_ERR_INIT, /* AMX not initialized (or doubly initialized) */
AMX_ERR_USERDATA, /* unable to set user data field (table full) */
AMX_ERR_INIT_JIT, /* cannot initialize the JIT */
AMX_ERR_PARAMS, /* parameter error */
};
enum {
DBG_INIT, /* query/initialize */
DBG_FILE, /* file number in curfile, filename in name */
DBG_LINE, /* line number in curline, file number in curfile */
DBG_SYMBOL, /* address in dbgaddr, class/type in dbgparam */
DBG_CLRSYM, /* stack address below which locals should be removed. stack address in stk */
DBG_CALL, /* function call, address jumped to in dbgaddr */
DBG_RETURN, /* function returns */
DBG_TERMINATE, /* program ends, code address in dbgaddr, reason in dbgparam */
DBG_SRANGE, /* symbol size and dimensions (arrays); level in dbgaddr (!); length in dbgparam */
};
#define AMX_FLAG_CHAR16 0x01 /* characters are 16-bit */
#define AMX_FLAG_DEBUG 0x02 /* symbolic info. available */
#define AMX_FLAG_COMPACT 0x04 /* compact encoding */
#define AMX_FLAG_BIGENDIAN 0x08 /* big endian encoding */
#define AMX_FLAG_BROWSE 0x4000
#define AMX_FLAG_RELOC 0x8000 /* jump/call addresses relocated */
#define AMX_EXEC_MAIN -1 /* start at program entry point */
#define AMX_EXEC_CONT -2 /* continue from last address */
#define AMX_USERTAG(a,b,c,d) ((a) | ((b)<<8) | ((long)(c)<<16) | ((long)(d)<<24))
uint16_t * AMXAPI amx_Align16(uint16_t *v);
uint32_t * AMXAPI amx_Align32(uint32_t *v);
int AMXAPI amx_Allot(AMX *amx, int cells, cell *amx_addr, cell **phys_addr);
int AMXAPI amx_Callback(AMX *amx, cell index, cell *result, cell *params);
int AMXAPI amx_Clone(AMX *amxClone, AMX *amxSource, void *data);
int AMXAPI amx_Debug(AMX *amx); /* default debug procedure, does nothing */
int AMXAPI amx_Exec(AMX *amx, cell *retval, int index, int numparams, ...);
int AMXAPI amx_Execv(AMX *amx, cell *retval, int index, int numparams, cell params[]);
int AMXAPI amx_FindPublic(AMX *amx, char *funcname, int *index);
int AMXAPI amx_FindPubVar(AMX *amx, char *varname, cell *amx_addr);
int AMXAPI amx_FindTagId(AMX *amx, cell tag_id, char *tagname);
int AMXAPI amx_Flags(AMX *amx,uint16_t *flags);
int AMXAPI amx_GetAddr(AMX *amx,cell amx_addr,cell **phys_addr);
int AMXAPI amx_GetPublic(AMX *amx, int index, char *funcname);
int AMXAPI amx_GetPubVar(AMX *amx, int index, char *varname, cell *amx_addr);
int AMXAPI amx_GetString(char *dest,cell *source);
int AMXAPI amx_GetTag(AMX *amx, int index, char *tagname, cell *tag_id);
int AMXAPI amx_GetUserData(AMX *amx, long tag, void **ptr);
int AMXAPI amx_Init(AMX *amx, void *program);
int AMXAPI amx_InitJIT(AMX *amx, void *reloc_table, void *native_code);
int AMXAPI amx_MemInfo(AMX *amx, long *codesize, long *datasize, long *stackheap);
int AMXAPI amx_NameLength(AMX *amx, int *length);
AMX_NATIVE_INFO * AMXAPI amx_NativeInfo(char *name,AMX_NATIVE func);
int AMXAPI amx_NumPublics(AMX *amx, int *number);
int AMXAPI amx_NumPubVars(AMX *amx, int *number);
int AMXAPI amx_NumTags(AMX *amx, int *number);
int AMXAPI amx_RaiseError(AMX *amx, int error);
int AMXAPI amx_Register(AMX *amx, AMX_NATIVE_INFO *nativelist, int number);
int AMXAPI amx_Release(AMX *amx, cell amx_addr);
int AMXAPI amx_SetCallback(AMX *amx, AMX_CALLBACK callback);
int AMXAPI amx_SetDebugHook(AMX *amx, AMX_DEBUG debug);
int AMXAPI amx_SetString(cell *dest, char *source, int pack);
int AMXAPI amx_SetUserData(AMX *amx, long tag, void *ptr);
int AMXAPI amx_StrLen(cell *cstring, int *length);
#if !defined AMX_NO_ALIGN
#if defined __linux__
#pragma pack() /* reset default packing */
#else
#pragma pack(pop) /* reset previous packing */
#endif
#endif
#ifdef __cplusplus
}
#endif
#endif /* __AMX_H */

11
amxmodx/amx_mm.def Executable file
View File

@ -0,0 +1,11 @@
; /usr/local/cross-tools/bin/i386-mingw32msvc-dlltool --base-file /tmp/cc4kB6s0.base --output-exp amx_mm.exp --dllname amx_mm.dll --output-def amx_mm.def --add-stdcall-alias --exclude-symbol=DllMainCRTStartup@12 --def /tmp/ccyI7I7K.def
EXPORTS
GetEngineFunctions @ 1 ;
GetEngineFunctions_Post @ 2 ;
GetEntityAPI2 @ 3 ;
GetEntityAPI2_Post @ 4 ;
GiveFnptrsToDll = GiveFnptrsToDll@8 @ 5 ;
GiveFnptrsToDll@8 @ 6 ;
Meta_Attach @ 7 ;
Meta_Detach @ 8 ;
Meta_Query @ 9 ;

548
amxmodx/amxcore.c Executable file
View File

@ -0,0 +1,548 @@
/* Core module for the Small AMX
*
* Copyright (c) ITB CompuPhase, 1997-2002
* This file may be freely used. No warranties of any kind.
*
* Version: $Id$
*/
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <assert.h>
#include "amx.h"
#define NOPROPLIST
/* A few compilers do not provide the ANSI C standard "time" functions */
#if !defined SN_TARGET_PS2 && !defined _WIN32_WCE
#include <time.h>
#endif
#define CHARBITS (8*sizeof(char))
typedef unsigned char uchar;
#if !defined NOPROPLIST
typedef struct _property_list {
struct _property_list *next;
cell id;
char *name;
cell value;
} proplist;
static proplist proproot = { NULL };
static proplist *list_additem(proplist *root)
{
proplist *item;
assert(root!=NULL);
if ((item=(proplist *)malloc(sizeof(proplist)))==NULL)
return NULL;
item->name=NULL;
item->id=0;
item->value=0;
item->next=root->next;
root->next=item;
return item;
}
static void list_delete(proplist *pred,proplist *item)
{
assert(pred!=NULL);
assert(item!=NULL);
pred->next=item->next;
assert(item->name!=NULL);
free(item->name);
free(item);
}
static void list_setitem(proplist *item,cell id,char *name,cell value)
{
char *ptr;
assert(item!=NULL);
if ((ptr=(char *)malloc(strlen(name)+1))==NULL)
return;
if (item->name!=NULL)
free(item->name);
strcpy(ptr,name);
item->name=ptr;
item->id=id;
item->value=value;
}
static proplist *list_finditem(proplist *root,cell id,char *name,cell value,
proplist **pred)
{
proplist *item=root->next;
proplist *prev=root;
/* check whether to find by name or by value */
assert(name!=NULL);
if (strlen(name)>0) {
/* find by name */
while (item!=NULL && (item->id!=id || stricmp(item->name,name)!=0)) {
prev=item;
item=item->next;
} /* while */
} else {
/* find by value */
while (item!=NULL && (item->id!=id || item->value!=value)) {
prev=item;
item=item->next;
} /* while */
} /* if */
if (pred!=NULL)
*pred=prev;
return item;
}
#endif
#if defined __BORLANDC__ || defined __WATCOMC__
#pragma argsused
#endif
static cell AMX_NATIVE_CALL numargs(AMX *amx, cell *params)
{
AMX_HEADER *hdr;
uchar *data;
cell bytes;
hdr=(AMX_HEADER *)amx->base;
data=amx->base+(int)hdr->dat;
/* the number of bytes is on the stack, at "frm + 2*cell" */
bytes= * (cell *)(data+(int)amx->frm+2*sizeof(cell));
/* the number of arguments is the number of bytes divided
* by the size of a cell */
return bytes/sizeof(cell);
}
static cell AMX_NATIVE_CALL getarg(AMX *amx, cell *params)
{
AMX_HEADER *hdr;
uchar *data;
cell value;
hdr=(AMX_HEADER *)amx->base;
data=amx->base+(int)hdr->dat;
/* get the base value */
value= * (cell *)(data+(int)amx->frm+((int)params[1]+3)*sizeof(cell));
/* adjust the address in "value" in case of an array access */
value+=params[2]*sizeof(cell);
/* get the value indirectly */
value= * (cell *)(data+(int)value);
return value;
}
static cell AMX_NATIVE_CALL setarg(AMX *amx, cell *params)
{
AMX_HEADER *hdr;
uchar *data;
cell value;
hdr=(AMX_HEADER *)amx->base;
data=amx->base+(int)hdr->dat;
/* get the base value */
value= * (cell *)(data+(int)amx->frm+((int)params[1]+3)*sizeof(cell));
/* adjust the address in "value" in case of an array access */
value+=params[2]*sizeof(cell);
/* verify the address */
if (value<0 || value>=amx->hea && value<amx->stk)
return 0;
/* set the value indirectly */
* (cell *)(data+(int)value) = params[3];
return 1;
}
#if defined __BORLANDC__ || defined __WATCOMC__
#pragma argsused
#endif
static cell AMX_NATIVE_CALL heapspace(AMX *amx,cell *params)
{
return amx->stk - amx->hea;
}
static cell AMX_NATIVE_CALL funcidx(AMX *amx,cell *params)
{
char name[64];
cell *cstr;
int index,err,len;
amx_GetAddr(amx,params[1],&cstr);
/* verify string length */
amx_StrLen(cstr,&len);
if (len>=64) {
amx_RaiseError(amx,AMX_ERR_NATIVE);
return 0;
} /* if */
amx_GetString(name,cstr);
err=amx_FindPublic(amx,name,&index);
if (err!=AMX_ERR_NONE)
index=-1; /* this is not considered a fatal error */
return index;
}
int amx_StrPack(cell *dest,cell *source)
{
int len;
amx_StrLen(source,&len);
if ((ucell)*source>UCHAR_MAX) {
/* source string is already packed */
while (len >= 0) {
*dest++ = *source++;
len-=sizeof(cell);
} /* while */
} else {
/* pack string, from bottom up */
cell c;
int i;
for (c=0,i=0; i<len; i++) {
assert((*source & ~0xffL)==0);
c=(c<<CHARBITS) | *source++;
if (i%sizeof(cell) == sizeof(cell)-1) {
*dest++=c;
c=0;
} /* if */
} /* for */
if (i%sizeof(cell) != 0) /* store remaining packed characters */
*dest=c << (sizeof(cell)-i%sizeof(cell))*CHARBITS;
else
*dest=0; /* store full cell of zeros */
} /* if */
return AMX_ERR_NONE;
}
int amx_StrUnpack(cell *dest,cell *source)
{
if ((ucell)*source>UCHAR_MAX) {
/* unpack string, from top down (so string can be unpacked in place) */
cell c;
int i,len;
amx_StrLen(source,&len);
dest[len]=0;
for (i=len-1; i>=0; i--) {
c=source[i/sizeof(cell)] >> (sizeof(cell)-i%sizeof(cell)-1)*CHARBITS;
dest[i]=c & UCHAR_MAX;
} /* for */
} else {
/* source string is already unpacked */
while ((*dest++ = *source++) != 0)
/* nothing */;
} /* if */
return AMX_ERR_NONE;
}
static int verify_addr(AMX *amx,cell addr)
{
int err;
cell *cdest;
err=amx_GetAddr(amx,addr,&cdest);
if (err!=AMX_ERR_NONE)
amx_RaiseError(amx,err);
return err;
}
static cell AMX_NATIVE_CALL core_strlen(AMX *amx,cell *params)
{
cell *cptr;
int len = 0;
if (amx_GetAddr(amx,params[1],&cptr)==AMX_ERR_NONE)
amx_StrLen(cptr,&len);
return len;
}
static cell AMX_NATIVE_CALL strpack(AMX *amx,cell *params)
{
cell *cdest,*csrc;
int len,needed,lastaddr,err;
/* calculate number of cells needed for (packed) destination */
amx_GetAddr(amx,params[2],&csrc);
amx_StrLen(csrc,&len);
needed=(len+sizeof(cell))/sizeof(cell); /* # of cells needed */
assert(needed>0);
lastaddr=params[1]+sizeof(cell)*needed-1;
if (verify_addr(amx,(cell)lastaddr)!=AMX_ERR_NONE)
return 0;
amx_GetAddr(amx,params[1],&cdest);
err=amx_StrPack(cdest,csrc);
if (err!=AMX_ERR_NONE)
return amx_RaiseError(amx,err);
return len;
}
static cell AMX_NATIVE_CALL strunpack(AMX *amx,cell *params)
{
cell *cdest,*csrc;
int len,err,lastaddr;
/* calculate number of cells needed for (packed) destination */
amx_GetAddr(amx,params[2],&csrc);
amx_StrLen(csrc,&len);
assert(len>=0);
lastaddr=params[1]+sizeof(cell)*(len+1)-1;
if (verify_addr(amx,(cell)lastaddr)!=AMX_ERR_NONE)
return 0;
amx_GetAddr(amx,params[1],&cdest);
err=amx_StrUnpack(cdest,csrc);
if (err!=AMX_ERR_NONE)
return amx_RaiseError(amx,err);
return len;
}
#if defined __BORLANDC__ || defined __WATCOMC__
#pragma argsused
#endif
static cell AMX_NATIVE_CALL swapchars(AMX *amx,cell *params)
{
union {
cell c;
#if defined BIT16
uchar b[2];
#else
uchar b[4];
#endif
} value;
uchar t;
assert((size_t)params[0]==sizeof(cell));
value.c = params[1];
#if defined BIT16
t = value.b[0];
value.b[0] = value.b[1];
value.b[1] = t;
#else
t = value.b[0];
value.b[0] = value.b[3];
value.b[3] = t;
t = value.b[1];
value.b[1] = value.b[2];
value.b[2] = t;
#endif
return value.c;
}
#if defined __BORLANDC__ || defined __WATCOMC__
#pragma argsused
#endif
static cell AMX_NATIVE_CALL core_tolower(AMX *amx,cell *params)
{
assert((size_t)params[0]==sizeof(cell));
return tolower((int)params[1]);
}
#if defined __BORLANDC__ || defined __WATCOMC__
#pragma argsused
#endif
static cell AMX_NATIVE_CALL core_toupper(AMX *amx,cell *params)
{
assert((size_t)params[0]==sizeof(cell));
return toupper((int)params[1]);
}
#if defined __BORLANDC__ || defined __WATCOMC__
#pragma argsused
#endif
static cell AMX_NATIVE_CALL core_min(AMX *amx,cell *params)
{
return params[1] <= params[2] ? params[1] : params[2];
}
#if defined __BORLANDC__ || defined __WATCOMC__
#pragma argsused
#endif
static cell AMX_NATIVE_CALL core_max(AMX *amx,cell *params)
{
return params[1] >= params[2] ? params[1] : params[2];
}
static cell AMX_NATIVE_CALL core_clamp(AMX *amx,cell *params)
{
cell value = params[1];
if (params[2] > params[3]) /* minimum value > maximum value ! */
amx_RaiseError(amx,AMX_ERR_NATIVE);
if (value < params[2])
value = params[2];
else if (value > params[3])
value = params[3];
return value;
}
#if !defined NOPROPLIST
static char *MakePackedString(cell *cptr)
{
int len;
char *dest;
amx_StrLen(cptr,&len);
dest=(char *)malloc(len+sizeof(cell));
amx_GetString(dest,cptr);
return dest;
}
static cell AMX_NATIVE_CALL getproperty(AMX *amx,cell *params)
{
cell *cstr;
char *name;
proplist *item;
amx_GetAddr(amx,params[2],&cstr);
name=MakePackedString(cstr);
item=list_finditem(&proproot,params[1],name,params[3],NULL);
/* if list_finditem() found the value, store the name */
if (item!=NULL && item->value==params[3] && strlen(name)==0) {
int needed=(strlen(item->name)+sizeof(cell)-1)/sizeof(cell); /* # of cells needed */
if (verify_addr(amx,(cell)(params[4]+needed))!=AMX_ERR_NONE) {
free(name);
return 0;
} /* if */
amx_GetAddr(amx,params[4],&cstr);
amx_SetString(cstr,item->name,1);
} /* if */
free(name);
return (item!=NULL) ? item->value : 0;
}
static cell AMX_NATIVE_CALL setproperty(AMX *amx,cell *params)
{
cell prev=0;
cell *cstr;
char *name;
proplist *item;
amx_GetAddr(amx,params[2],&cstr);
name=MakePackedString(cstr);
item=list_finditem(&proproot,params[1],name,params[3],NULL);
if (item==NULL)
item=list_additem(&proproot);
if (item==NULL) {
amx_RaiseError(amx,AMX_ERR_MEMORY);
} else {
prev=item->value;
if (strlen(name)==0) {
free(name);
amx_GetAddr(amx,params[4],&cstr);
name=MakePackedString(cstr);
} /* if */
list_setitem(item,params[1],name,params[3]);
} /* if */
free(name);
return prev;
}
static cell AMX_NATIVE_CALL delproperty(AMX *amx,cell *params)
{
cell prev=0;
cell *cstr;
char *name;
proplist *item,*pred;
amx_GetAddr(amx,params[2],&cstr);
name=MakePackedString(cstr);
item=list_finditem(&proproot,params[1],name,params[3],&pred);
if (item!=NULL) {
prev=item->value;
list_delete(pred,item);
} /* if */
free(name);
return prev;
}
static cell AMX_NATIVE_CALL existproperty(AMX *amx,cell *params)
{
cell *cstr;
char *name;
proplist *item;
amx_GetAddr(amx,params[2],&cstr);
name=MakePackedString(cstr);
item=list_finditem(&proproot,params[1],name,params[3],NULL);
free(name);
return (item!=NULL);
}
#endif
/* This routine comes from the book "Inner Loops" by Rick Booth, Addison-Wesley
* (ISBN 0-201-47960-5). This is a "multiplicative congruential random number
* generator" that has been extended to 31-bits (the standard C version returns
* only 15-bits).
*/
static unsigned long IL_StandardRandom_seed = 0L;
#define IL_RMULT 1103515245L
#if defined __BORLANDC__ || defined __WATCOMC__
#pragma argsused
#endif
static cell AMX_NATIVE_CALL core_random(AMX *amx,cell *params)
{
unsigned long lo, hi, ll, lh, hh, hl;
unsigned long result;
/* one-time initialization (or, mostly one-time) */
#if !defined SN_TARGET_PS2 && !defined _WIN32_WCE
if (IL_StandardRandom_seed == 0L)
IL_StandardRandom_seed=(unsigned long)time(NULL);
#endif
lo = IL_StandardRandom_seed & 0xffff;
hi = IL_StandardRandom_seed >> 16;
IL_StandardRandom_seed = IL_StandardRandom_seed * IL_RMULT + 12345;
ll = lo * (IL_RMULT & 0xffff);
lh = lo * (IL_RMULT >> 16 );
hl = hi * (IL_RMULT & 0xffff);
hh = hi * (IL_RMULT >> 16 );
result = ((ll + 12345) >> 16) + lh + hl + (hh << 16);
result &= ~LONG_MIN; /* remove sign bit */
if (params[1]!=0)
result %= params[1];
return (cell)result;
}
#if 0
void core_Init(void)
{
/* reduced to a do-nothing routine */
}
void core_Exit(void)
{
#if !defined NOPROPLIST
while (proproot.next!=NULL)
list_delete(&proproot,proproot.next);
#endif
}
#endif
AMX_NATIVE_INFO core_Natives[] = {
{ "numargs", numargs },
{ "getarg", getarg },
{ "setarg", setarg },
{ "heapspace", heapspace },
{ "funcidx", funcidx },
{ "strlen", core_strlen },
{ "strpack", strpack },
{ "strunpack", strunpack },
{ "swapchars", swapchars },
{ "tolower", core_tolower },
{ "toupper", core_toupper },
{ "random", core_random },
{ "min", core_min },
{ "max", core_max },
{ "clamp", core_clamp },
#if !defined NOPROPLIST
{ "getproperty", getproperty },
{ "setproperty", setproperty },
{ "deleteproperty",delproperty },
{ "existproperty", existproperty },
#endif
{ NULL, NULL } /* terminator */
};

2202
amxmodx/amxmod.cpp Executable file
View File

File diff suppressed because it is too large Load Diff

237
amxmodx/amxmod.h Executable file
View File

@ -0,0 +1,237 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#ifndef AMXMOD_H
#define AMXMOD_H
#include "modules.h"
#include "CString.h"
#include "CList.h"
#include "CPlugin.h"
#include "CMisc.h"
#include "CVault.h"
#include "CModule.h"
#include "CTask.h"
#include "CLogEvent.h"
#include "CForward.h"
#include "CCmd.h"
#include "CMenu.h"
#include "CEvent.h"
#define AMX_VERSION "0.9.7"
#ifdef __cplusplus
extern "C" {
#endif
extern AMX_NATIVE_INFO core_Natives[];
extern AMX_NATIVE_INFO time_Natives[];
extern AMX_NATIVE_INFO power_Natives[];
#ifdef __cplusplus
}
#endif
extern AMX_NATIVE_INFO amxmod_Natives[];
extern AMX_NATIVE_INFO file_Natives[];
extern AMX_NATIVE_INFO float_Natives[];
extern AMX_NATIVE_INFO string_Natives[];
extern AMX_NATIVE_INFO vault_Natives[];
#ifndef __linux__
#define DLLOAD(path) (DLHANDLE)LoadLibrary(path);
#define DLPROC(m,func) GetProcAddress(m,func);
#define DLFREE(m) FreeLibrary(m);
#else
#define DLLOAD(path) (DLHANDLE)dlopen(path, RTLD_NOW);
#define DLPROC(m,func) dlsym(m,func);
#define DLFREE(m) dlclose(m);
#endif
#ifndef __linux__
typedef HINSTANCE DLHANDLE;
#else
typedef void* DLHANDLE;
#endif
#ifndef GETPLAYERAUTHID
#define GETPLAYERAUTHID (*g_engfuncs.pfnGetPlayerAuthId)
#endif
#define ANGLEVECTORS (*g_engfuncs.pfnAngleVectors)
#define CLIENT_PRINT (*g_engfuncs.pfnClientPrintf)
#define CVAR_DIRECTSET (*g_engfuncs.pfnCvar_DirectSet)
#define GETCLIENTLISTENING (*g_engfuncs.pfnVoice_GetClientListening)
#define RUNPLAYERMOVE (*g_engfuncs.pfnRunPlayerMove)
#define SETCLIENTLISTENING (*g_engfuncs.pfnVoice_SetClientListening)
#define SETCLIENTMAXSPEED (*g_engfuncs.pfnSetClientMaxspeed)
char* UTIL_SplitHudMessage(register const char *src);
int UTIL_ReadFlags(const char* c);
void UTIL_ClientPrint( edict_t *pEntity, int msg_dest, char *msg );
void UTIL_FakeClientCommand(edict_t *pEdict, const char *cmd, const char *arg1 = NULL, const char *arg2 = NULL);
void UTIL_GetFlags(char* flags,int flag);
void UTIL_HudMessage(edict_t *pEntity, const hudtextparms_t &textparms, char *pMessage);
void UTIL_IntToString(int value, char *output);
void UTIL_ShowMOTD( edict_t *client , char *motd, int mlen, const char *name);
void UTIL_ShowMenu( edict_t* pEntity, int slots, int time, char *menu, int mlen );
#define GET_PLAYER_POINTER(e) (&g_players[ENTINDEX(e)])
//#define GET_PLAYER_POINTER(e) (&g_players[(((int)e-g_edict_point)/sizeof(edict_t ))])
#define GET_PLAYER_POINTER_I(i) (&g_players[i])
struct WeaponsVault {
String fullName;
short int iId;
short int ammoSlot;
};
struct fakecmd_t {
char args[256];
const char *argv[3];
//char argv[3][128];
int argc;
bool fake;
};
extern CPluginMngr g_plugins;
extern CTaskMngr g_tasksMngr;
extern CPlayer g_players[33];
extern CPlayer* mPlayer;
extern CmdMngr g_commands;
extern CList<CCVar> g_cvars;
extern CList<ForceObject> g_forcemodels;
extern CList<ForceObject> g_forcesounds;
extern CList<ForceObject> g_forcegeneric;
extern CList<CModule> g_modules;
extern CList<CPlayer*> g_auth;
extern EventsMngr g_events;
extern Grenades g_grenades;
extern LogEventsMngr g_logevents;
extern MenuMngr g_menucmds;
extern String g_log_dir;
extern String g_mod_name;
extern TeamIds g_teamsIds;
extern Vault g_vault;
extern CForwardMngr g_forwards;
extern WeaponsVault g_weaponsData[MAX_WEAPONS];
extern XVars g_xvars;
extern bool g_bmod_cstrike;
extern bool g_bmod_dod;
extern bool g_dontprecache;
extern bool g_initialized;
extern int g_srvindex;
extern cvar_t* amx_version;
extern cvar_t* hostname;
extern cvar_t* mp_timelimit;
extern fakecmd_t g_fakecmd;
extern float g_game_restarting;
extern float g_game_timeleft;
extern float g_task_time;
extern float g_auth_time;
extern hudtextparms_t g_hudset;
//extern int g_edict_point;
extern int g_players_num;
extern int mPlayerIndex;
extern int mState;
extern void (*endfunction)(void*);
extern void (*function)(void*);
typedef void (*funEventCall)(void*);
extern funEventCall modMsgsEnd[MAX_REG_MSGS];
extern funEventCall modMsgs[MAX_REG_MSGS];
extern int gmsgAmmoPickup;
extern int gmsgAmmoX;
extern int gmsgBattery;
extern int gmsgCurWeapon;
extern int gmsgDamage;
extern int gmsgDeathMsg;
extern int gmsgHealth;
extern int gmsgMOTD;
extern int gmsgScoreInfo;
extern int gmsgSendAudio;
extern int gmsgServerName;
extern int gmsgShowMenu;
extern int gmsgTeamInfo;
extern int gmsgTextMsg;
extern int gmsgVGUIMenu;
extern int gmsgWeapPickup;
extern int gmsgWeaponList;
extern int gmsgintermission;
extern int gmsgResetHUD;
extern int gmsgRoundTime;
void Client_AmmoPickup(void*);
void Client_AmmoX(void*);
void Client_CurWeapon(void*);
void Client_ScoreInfo(void*);
void Client_ShowMenu(void*);
void Client_TeamInfo(void*);
void Client_TextMsg(void*);
void Client_VGUIMenu(void*);
void Client_WeaponList(void*);
void Client_DamageEnd(void*);
void Client_DeathMsg(void*);
void amx_command();
void plugin_srvcmd();
const char* stristr(const char* a,const char* b);
char *strptime(const char *buf, const char *fmt, struct tm *tm, short addthem);
int loadModules(const char* filename);
void dettachModules();
void dettachReloadModules();
void attachModules();
void attachMetaModModules( const char* filename );
void dettachMetaModModules( const char* filename );
int add_amxnatives(module_info_s* info,AMX_NATIVE_INFO*natives);
cell* get_amxaddr(AMX *amx,cell amx_addr);
char* build_pathname(char *fmt, ... );
char* format_amxstring(AMX *amx, cell *params, int parm,int& len);
AMX* get_amxscript(int, void**,const char**);
const char* get_amxscriptname(AMX* amx);
char* get_amxstring(AMX *amx,cell amx_addr,int id,int& len);
int amxstring_len(cell* cstr);
int load_amxscript(AMX* amx, void** program, const char* path, char error[64]);
int set_amxnatives(AMX* amx,char error[64]);
int set_amxstring(AMX *amx,cell amx_addr,const char *source,int max);
int unload_amxscript(AMX* amx,void** program);
void copy_amxmemory(cell* dest,cell* src,int len);
void get_modname(char*);
void print_srvconsole( char *fmt, ... );
void report_error( int code, char* fmt, ... );
void* alloc_amxmemory(void**, int size);
void free_amxmemory(void **ptr);
#endif // AMXMOD_H

104
amxmodx/amxtime.c Executable file
View File

@ -0,0 +1,104 @@
/* Date/time module for the Small AMX
*
* Copyright (c) ITB CompuPhase, 2001-2002
* This file may be freely used. No warranties of any kind.
*
* Version: $Id$
*/
#include <time.h>
#include <assert.h>
#if defined __WIN32__ || defined _WIN32
#include <windows.h>
#include <mmsystem.h>
#endif
#include "amx.h"
#if defined __BORLANDC__ || defined __WATCOMC__
#pragma argsused
#endif
static cell AMX_NATIVE_CALL _time(AMX *amx, cell *params)
{
time_t sec1970;
struct tm gtm;
cell *cptr;
assert(params[0]==3*sizeof(cell));
time(&sec1970);
/* on DOS/Windows, the timezone is usually not set for the C run-time
* library; in that case gmtime() and localtime() return the same value
*/
gtm=*localtime(&sec1970);
if (amx_GetAddr(amx,params[1],&cptr)==AMX_ERR_NONE)
*cptr=gtm.tm_hour;
if (amx_GetAddr(amx,params[2],&cptr)==AMX_ERR_NONE)
*cptr=gtm.tm_min;
if (amx_GetAddr(amx,params[3],&cptr)==AMX_ERR_NONE)
*cptr=gtm.tm_sec;
/* the time() function returns the number of seconds since January 1 1970
* in Universal Coordinated Time (the successor to Greenwich Mean Time)
*/
return sec1970;
}
#if defined __BORLANDC__ || defined __WATCOMC__
#pragma argsused
#endif
static cell AMX_NATIVE_CALL _date(AMX *amx, cell *params)
{
time_t sec1970;
struct tm gtm;
cell *cptr;
assert(params[0]==3*sizeof(cell));
time(&sec1970);
gtm=*localtime(&sec1970);
if (amx_GetAddr(amx,params[1],&cptr)==AMX_ERR_NONE)
*cptr=gtm.tm_year+1900;
if (amx_GetAddr(amx,params[2],&cptr)==AMX_ERR_NONE)
*cptr=gtm.tm_mon+1;
if (amx_GetAddr(amx,params[3],&cptr)==AMX_ERR_NONE)
*cptr=gtm.tm_mday;
return 0;
}
#if defined __BORLANDC__ || defined __WATCOMC__
#pragma argsused
#endif
static cell AMX_NATIVE_CALL _tickcount(AMX *amx, cell *params)
{
// #if defined __WIN32__ || defined _WIN32
// static int timerset = 0;
// #endif
cell value;
assert(params[0]==sizeof(cell));
//#if defined __WIN32__ || defined _WIN32
// if (!timerset) {
// timeBeginPeriod(1); /* timeGetTime() is more accurate on WindowsNT
// * if timeBeginPeriod(1) is set */
// timerset=1;
// } /* if */
// value=timeGetTime(); /* this value is already in milliseconds */
// #else
value=(cell)clock();
/* convert to milliseconds */
value=(cell)((1000L * (value+CLK_TCK/2)) / CLK_TCK);
//#endif
return value;
}
AMX_NATIVE_INFO time_Natives[] = {
{ "time", _time },
{ "date", _date },
{ "tickcount", _tickcount },
{ NULL, NULL } /* terminator */
};

328
amxmodx/emsg.cpp Executable file
View File

@ -0,0 +1,328 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
int gmsgAmmoPickup;
int gmsgAmmoX;
int gmsgBattery;
int gmsgCurWeapon;
int gmsgDamage;
int gmsgDeathMsg;
int gmsgHealth;
int gmsgMOTD;
int gmsgScoreInfo;
int gmsgSendAudio;
int gmsgServerName;
int gmsgShowMenu;
int gmsgTeamInfo;
int gmsgTextMsg;
int gmsgVGUIMenu;
int gmsgWeapPickup;
int gmsgWeaponList;
int gmsgintermission;
int gmsgResetHUD;
int gmsgRoundTime;
TeamIds g_teamsIds;
WeaponsVault g_weaponsData[MAX_WEAPONS];
void Client_VGUIMenu(void* mValue)
{
if (!mPlayer) return;
switch (mState++){
case 0:
mPlayer->menu = -(*(int*)mValue);
break;
case 1:
mPlayer->keys = *(int*)mValue;
}
}
void Client_ShowMenu(void* mValue)
{
if (!mPlayer) return;
switch (mState++){
case 0:
mPlayer->keys = *(int*)mValue;
break;
case 3:
mPlayer->menu = g_menucmds.findMenuId( (char*)mValue );
}
}
void Client_TeamInfo(void* mValue)
{
if (mPlayer) return;
static int index;
switch (mState++) {
case 0:
index = *(int*)mValue;
break;
case 1:
if ( index < 1 || index > gpGlobals->maxClients ) break;
char* msg = (char*)mValue;
g_players[ index ].team.set( msg );
g_teamsIds.registerTeam( msg , -1 );
}
}
void Client_TextMsg(void* mValue)
{
if ( mPlayer ) return;
switch (mState++) {
case 1:{
char * msg = (char*)mValue;
if (!msg) break;
if ( !strncmp("#Game_C", msg , 7) ) {
g_game_timeleft = g_game_restarting = gpGlobals->time + 3;
// g_endround_time = gpGlobals->time;
// g_newround_time = gpGlobals->time + CVAR_GET_FLOAT("mp_freezetime") + 3;
}
else if (!strncmp("#Game_w", msg , 7) ) {
g_game_timeleft = -2;
}
else if ( !strncmp("#game_clan_s", msg , 12) ){
g_game_timeleft = -3;
}
break;
}
case 2:{
char * msg = (char*)mValue;
if (!msg) break;
if (g_game_timeleft == -2 ){
g_game_timeleft = g_game_restarting = gpGlobals->time + atoi( msg );
// g_newround_time = g_game_timeleft + CVAR_GET_FLOAT("mp_freezetime");
}
else if ( g_game_timeleft == -3 )
g_game_restarting = atoi( msg ) * 60;
break;
}
case 3:{
char * msg = (char*)mValue;
if (!msg) break;
if ( g_game_timeleft != -3 ) break;
g_game_restarting += atoi( msg );
g_game_timeleft = g_game_restarting = gpGlobals->time + g_game_restarting;
break;
}
}
}
void Client_WeaponList(void* mValue)
{
static int wpnList = 0;
//static int wpnList2;
static int iSlot;
static const char* wpnName;
switch (mState++) {
case 0:
wpnName = (char*)mValue;
break;
case 1:
iSlot = *(int*)mValue;
break;
case 7:
int iId = *(int*)mValue;
/*int* blocker;
int iwpn = iId;
if (iId > 31) {
iwpn -= 31;
blocker = &wpnList2;
}
else
blocker = &wpnList;*/
if ( (iId < 0 || iId >= MAX_WEAPONS ) || (wpnList & (1<<iId)) )
break;
wpnList |= (1<<iId);
g_weaponsData[iId].iId = iId;
g_weaponsData[iId].ammoSlot = iSlot;
g_weaponsData[iId].fullName.set(wpnName);
}
}
void Client_CurWeapon(void* mValue)
{
static int iState;
static int iId;
switch (mState++){
case 0:
iState = *(int*)mValue;
break;
case 1:
if (!iState) break;
iId = *(int*)mValue;
break;
case 2:
if (!mPlayer) return;
if (!iState || (iId < 1 || iId >= MAX_WEAPONS ) ) break;
mPlayer->weapons[iId].clip = *(int*)mValue;
mPlayer->current = iId;
mPlayer->lastHit = mPlayer->lastTrace;
}
}
void Client_AmmoX(void* mValue)
{
static int iAmmo;
switch (mState++){
case 0:
iAmmo = *(int*)mValue;
break;
case 1:
if (!mPlayer) return;
for(int i=1;i<MAX_WEAPONS;++i)
if (iAmmo == g_weaponsData[i].ammoSlot)
mPlayer->weapons[i].ammo = *(int*)mValue;
}
}
void Client_AmmoPickup(void* mValue)
{
static int iSlot;
switch (mState++){
case 0:
iSlot = *(int*)mValue;
break;
case 1:
if (!mPlayer) return;
for(int i=1;i<MAX_WEAPONS;++i)
if (g_weaponsData[i].ammoSlot==iSlot)
mPlayer->weapons[i].ammo += *(int*)mValue;
}
}
void Client_ScoreInfo(void* mValue)
{
static int index;
static int deaths;
switch (mState++){
case 0:
index = *(int*)mValue;
break;
case 2:
deaths = *(int*)mValue;
break;
case 4:
if ( index < 1 || index > gpGlobals->maxClients ) break;
CPlayer*pPlayer = GET_PLAYER_POINTER_I( index );
pPlayer->deaths = deaths;
pPlayer->teamId = *(int*)mValue;
if ( g_teamsIds.isNewTeam() )
g_teamsIds.registerTeam( pPlayer->team.str() , pPlayer->teamId );
}
}
void Client_DamageEnd(void* mValue)
{
CPlayer* dead = mPlayer;
if ( dead && dead->death_killer )
{
g_events.parserInit( CS_DEATHMSG , &gpGlobals->time , mPlayer = 0, mPlayerIndex = 0 );
g_events.parseValue( dead->death_killer );
g_events.parseValue( dead->index );
g_events.parseValue( dead->death_headshot );
g_events.parseValue( dead->death_weapon.str() );
g_events.parseValue( dead->death_tk ? 1 : 0 );
g_events.executeEvents();
dead->death_killer = 0;
}
}
void Client_DeathMsg(void* mValue)
{
static CPlayer *killer;
static CPlayer *victim;
static int killer_id;
static int victim_id;
static int hs;
switch (mState++){
case 0:
killer_id = *(int*)mValue;
killer = (killer_id > 0 && killer_id < 33) ?
GET_PLAYER_POINTER_I(killer_id) : 0;
break;
case 1:
victim_id = *(int*)mValue;
victim = (victim_id > 0 && victim_id < 33) ?
GET_PLAYER_POINTER_I(victim_id) : 0;
break;
case 2:
hs = *(int*)mValue;
break;
case 3:
if ( !killer || !victim ) break;
victim->death_killer = killer_id;
victim->death_weapon.set((char*)mValue);
victim->death_headshot = hs;
victim->death_tk = (killer->teamId == victim->teamId);
}
}
/*
void Client_SendAudio(void* mValue)
{
}
void Client_SendAudioEnd(void* mValue)
{
}
void Client_RoundTimeEnd(void* mValue)
{
}
void Client_RoundTime(void* mValue)
{
}
void Client_ResetHUD(void* mValue)
{
}
*/

246
amxmodx/file.cpp Executable file
View File

@ -0,0 +1,246 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
// header file for unlink()
#ifdef __linux__
#include <unistd.h>
#else
#include <io.h>
#endif
#ifdef __GNUC__
//#include <stddef.h>
#include <stdio.h>
#include <sys/types.h>
#include <dirent.h>
#endif
static cell AMX_NATIVE_CALL read_dir(AMX *amx, cell *params)
{
#ifdef __GNUC__
int a;
struct dirent *ep;
DIR *dp;
char* dirname = build_pathname("%s",get_amxstring(amx,params[1],0,a) );
a = params[2];
if ( (dp = opendir (dirname)) == NULL )
return 0;
seekdir( dp , a );
if ( (ep = readdir (dp)) != NULL ) {
cell *length = get_amxaddr(amx,params[5]);
*length = set_amxstring(amx,params[3], ep->d_name ,params[4]);
a = telldir( dp );
}
else
a = 0;
closedir (dp);
return a;
#else
return 0;
#endif
}
static cell AMX_NATIVE_CALL read_file(AMX *amx, cell *params) /* 5 param */
{
int iLen;
char* szFile = get_amxstring(amx,params[1],0,iLen);
FILE*fp;
if ( (fp =fopen(build_pathname("%s",szFile),"r")) == NULL) {
amx_RaiseError(amx,AMX_ERR_NATIVE);
return 0;
}
char buffor[1024];
int i = 0, iLine = params[2];
while((i <= iLine) && fgets(buffor,1023,fp) )
i++;
fclose(fp);
if (i > iLine){
int len = strlen(buffor);
if (buffor[len-1]=='\n')
buffor[--len]=0;
if (buffor[len-1]=='\r')
buffor[--len]=0;
cell *length = get_amxaddr(amx,params[5]);
*length = set_amxstring(amx,params[3],buffor,params[4]);
return i;
}
return 0;
}
static cell AMX_NATIVE_CALL write_file(AMX *amx, cell *params) /* 3 param */
{
int i;
char* sFile = build_pathname("%s", get_amxstring(amx,params[1],0,i) );
char* sText = get_amxstring(amx,params[2],0,i);
FILE* pFile;
int iLine = params[3];
// apending to the end
if (iLine < 0) {
if ( (pFile = fopen( sFile ,"a")) == NULL ){
amx_RaiseError(amx,AMX_ERR_NATIVE);
return 0;
}
fputs( sText , pFile );
fputc( '\n', pFile );
fclose( pFile );
return 1;
}
// creating a new file with a line in a middle
if ( (pFile = fopen(sFile,"r")) == NULL ) {
if ( (pFile = fopen(sFile,"w")) == NULL ){
amx_RaiseError(amx,AMX_ERR_NATIVE);
return 0;
}
for(i=0;i < iLine;++i)
fputc('\n',pFile);
fputs( sText , pFile );
fputc( '\n', pFile );
fclose(pFile);
return 1;
}
// adding a new line in a middle of already existing file
FILE* pTemp;
char buffor[1024];
if ( (pTemp = tmpfile()) == NULL ){
amx_RaiseError(amx,AMX_ERR_NATIVE);
return 0;
}
for(i=0;;++i){
if ( i == iLine ){
fgets(buffor,1023,pFile);
fputs( sText , pTemp );
fputc( '\n', pTemp );
}
else if ( fgets(buffor,1023,pFile) ){
fputs(buffor , pTemp );
}
else if ( i < iLine ) {
fputc( '\n', pTemp );
}
else break;
}
fclose(pFile);
rewind(pTemp);
// now rewrite because file can be now smaller...
if ( (pFile = fopen(sFile,"w")) == NULL ){
amx_RaiseError(amx,AMX_ERR_NATIVE);
return 0;
}
while(fgets(buffor,1023,pTemp))
fputs(buffor,pFile );
fclose(pTemp);
fclose(pFile);
return 1;
}
static cell AMX_NATIVE_CALL delete_file(AMX *amx, cell *params) /* 1 param */
{
int iLen;
char* sFile = get_amxstring(amx,params[1],0,iLen);
return (unlink( build_pathname("%s",sFile) )?0:1);
}
static cell AMX_NATIVE_CALL file_exists(AMX *amx, cell *params) /* 1 param */
{
int iLen;
char* sFile = get_amxstring(amx,params[1],0,iLen);
FILE* fp = fopen(build_pathname("%s",sFile),"r");
if ( fp != NULL) {
fclose(fp);
return 1;
}
return 0;
}
static cell AMX_NATIVE_CALL file_size(AMX *amx, cell *params) /* 1 param */
{
int iLen;
char* sFile = get_amxstring(amx,params[1],0,iLen);
FILE* fp = fopen(build_pathname("%s",sFile),"r");
if ( fp != NULL) {
if ( params[0] < 2 || params[2] == 0 ){
fseek(fp,0,SEEK_END);
int size = ftell(fp);
fclose(fp);
return size;
}
else if ( params[2] == 1 ){
int a = 0,lines = 0;
while( a != EOF ){
++lines;
while ( (a = fgetc(fp)) != '\n' && a != EOF )
;
}
//int a, b = '\n';
//while( (a = fgetc(fp)) != EOF ){
// if ( a == '\n')
// ++lines;
// b = a;
//}
//if ( b != '\n' )
// ++lines;
return lines;
}
else if ( params[2] == 2 ){
fseek(fp,-1,SEEK_END);
if ( fgetc(fp) == '\n' )
return 1;
return 0;
}
}
return -1;
}
AMX_NATIVE_INFO file_Natives[] = {
{ "delete_file", delete_file },
{ "file_exists", file_exists },
{ "file_size", file_size },
{ "read_dir", read_dir },
{ "read_file", read_file },
{ "write_file", write_file },
{ NULL, NULL }
};

96
amxmodx/float.cpp Executable file
View File

@ -0,0 +1,96 @@
/* Float arithmetic for the Small AMX engine
*
* Copyright (c) Artran, Inc. 1999
* Written by Greg Garner (gmg@artran.com)
* This file may be freely used. No warranties of any kind.
*
*/
#include <math.h>
#include <stdlib.h>
#include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
inline cell FloatToCell(float fValue) {
return *(cell *)((void *)&fValue);
}
inline float CellToFloat(cell cellValue){
return *(float *)((void *)&cellValue);
}
static cell _float(AMX *,cell *params){
return FloatToCell((float)params[1]);
}
static cell _floatstr(AMX *amx,cell *params){
int len;
return FloatToCell((float)atof(get_amxstring(amx,params[1],0,len)));
}
static cell _floatmul(AMX *,cell *params){
return FloatToCell(CellToFloat(params[1]) * CellToFloat(params[2]));
}
static cell _floatdiv(AMX *,cell *params){
return FloatToCell(CellToFloat(params[1]) / CellToFloat(params[2]));
}
static cell _floatadd(AMX *,cell *params){
return FloatToCell(CellToFloat(params[1]) + CellToFloat(params[2]));
}
static cell _floatsub(AMX *,cell *params){
return FloatToCell(CellToFloat(params[1]) - CellToFloat(params[2]));
}
static cell _floatfract(AMX *,cell *params){
float fA = CellToFloat(params[1]);
fA -= (float)(floor((double)fA));
return FloatToCell(fA);
}
static cell _floatround(AMX *,cell *params){
float fA = CellToFloat(params[1]);
switch (params[2]) {
case 1:
fA = (float)(floor((double)fA));
break;
case 2:
float fValue;
fValue = (float)(floor((double)fA));
if ( (fA>=0) && ((fA-fValue)!=0) )
fValue++;
fA = fValue;
break;
default:
fA = (float)(floor((double)fA+.5));
break;
}
return (long)fA;
}
static cell _floatcmp(AMX *,cell *params){
float fA = CellToFloat(params[1]);
float fB = CellToFloat(params[2]);
if (fA == fB)
return 0;
else if (fA > fB)
return 1;
else
return -1;
}
AMX_NATIVE_INFO float_Natives[] = {
{ "float", _float },
{ "floatstr", _floatstr },
{ "floatmul", _floatmul },
{ "floatdiv", _floatdiv },
{ "floatadd", _floatadd },
{ "floatsub", _floatsub },
{ "floatfract", _floatfract},
{ "floatround", _floatround},
{ "floatcmp", _floatcmp},
{ NULL, NULL }
};

1096
amxmodx/meta_api.cpp Executable file
View File

File diff suppressed because it is too large Load Diff

526
amxmodx/modules.cpp Executable file
View File

@ -0,0 +1,526 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
#include "osdep.h" // sleep, etc
#include "CFile.h"
CList<CModule> g_modules;
CList<CScript,AMX*> g_loadedscripts;
#ifdef __cplusplus
extern "C" {
#endif
extern const char* no_function; // stupid work around
#ifdef __cplusplus
}
#endif
void report_error( int code, char* fmt, ... )
{
va_list argptr;
char string[256];
*string = 0;
va_start (argptr, fmt);
vsnprintf (string, 255, fmt,argptr);
string[255] = 0;
va_end (argptr);
if ( *string ) {
//File fp( "error_amx.log","a" );
//fp << string;
print_srvconsole( string );
print_srvconsole("[AMX] Make sure that modules are compatible with AMX %s\n" , AMX_VERSION );
print_srvconsole("[AMX] Please fix the problem then start the server again\n" );
}
sleep( 5 );
exit( code );
}
void print_srvconsole( char *fmt, ... )
{
va_list argptr;
char string[256];
va_start (argptr, fmt);
vsnprintf (string, 255, fmt,argptr);
string[255] = 0;
va_end (argptr);
SERVER_PRINT(string);
}
void* alloc_amxmemory(void** p, int size)
{
*p = new unsigned char[ size ];
return *p;
}
void free_amxmemory(void **ptr)
{
delete[] *ptr;
*ptr = 0;
}
int load_amxscript(AMX *amx, void **program, const char *filename, char error[64]){
AMX_HEADER hdr;
int err;
FILE *fp;
memset(amx, 0, sizeof(*amx));
*program = 0;
*error = 0;
if ( (fp = fopen( filename, "rb" )) == NULL)
{
strcpy(error,"Plugin file open error");
return (amx->error = AMX_ERR_NOTFOUND);
}
fread(&hdr, sizeof(hdr), 1, fp);
amx_Align16(&hdr.magic);
if (hdr.magic!=AMX_MAGIC)
{
strcpy(error,"Invalid plugin");
return (amx->error = AMX_ERR_FORMAT);
}
amx_Align32((uint32_t *)&hdr.stp);
amx_Align32((uint32_t *)&hdr.size);
if ( (*program = new unsigned char[ (int)hdr.stp ]) == 0 )
//if ( (*program = malloc( (int)hdr.stp )) == 0 )
{
strcpy(error,"Failed to allocate memory");
return (amx->error = AMX_ERR_MEMORY);
}
rewind(fp);
fread(*program, 1, (size_t)hdr.size, fp);
fclose(fp);
if ((err = amx_Init( amx, *program )) != AMX_ERR_NONE)
{
sprintf(error,"Load error %d (invalid file format or version)", err);
return (amx->error = AMX_ERR_INIT);
}
#ifdef JIT
void *np = new unsigned char[ amx->code_size ];
void *rt = new unsigned char[ amx->reloc_size ];
if ( !np || (!rt && amx->reloc_size > 0) )
{
delete[] np;
delete[] rt;
strcpy(error,"Failed to initialize plugin");
return (amx->error = AMX_ERR_INIT);
}
if (amx_InitJIT(amx, rt, np) == AMX_ERR_NONE)
{
//amx->base = (unsigned char FAR *)realloc( np, amx->code_size );
amx->base = new unsigned char FAR[ amx->code_size ];
if ( amx->base )
memcpy( amx->base , np , amx->code_size );
delete[] np;
delete[] rt;
delete[] *program;
(*program) = amx->base;
if ( *program == 0 ){
strcpy(error,"Failed to allocate memory");
return (amx->error = AMX_ERR_MEMORY);
}
}
else
{
delete[] np;
delete[] rt;
strcpy(error,"Failed to initialize plugin");
return (amx->error = AMX_ERR_INIT_JIT);
}
#endif
CScript* aa = new CScript(amx,*program,filename);
if ( aa == 0 )
{
strcpy(error,"Failed to allocate memory");
return (amx->error = AMX_ERR_MEMORY);
}
g_loadedscripts.put( aa );
return set_amxnatives(amx,error);
}
int set_amxnatives(AMX* amx,char error[64])
{
for ( CList<CModule>::iterator a = g_modules.begin(); a ; ++a )
{
for( CList<AMX_NATIVE_INFO*>::iterator cc =
(*a).natives.begin(); cc; ++cc )
amx_Register(amx, *cc , -1);
}
amx_Register(amx, string_Natives, -1);
amx_Register(amx, float_Natives, -1);
amx_Register(amx, file_Natives, -1);
amx_Register(amx, amxmod_Natives, -1);
amx_Register(amx, power_Natives, -1);
amx_Register(amx, time_Natives, -1);
amx_Register(amx, vault_Natives, -1);
if ( amx_Register(amx, core_Natives, -1) != AMX_ERR_NONE )
{
sprintf(error,"Function not found (name \"%s\")",no_function);
return (amx->error = AMX_ERR_NATIVE);
}
return AMX_ERR_NONE;
}
int unload_amxscript(AMX* amx, void** program)
{
CList<CScript,AMX*>::iterator a = g_loadedscripts.find( amx );
if ( a ) a.remove();
delete[] *program;
//free( *program );
*program = 0;
return AMX_ERR_NONE;
}
AMX* get_amxscript(int id , void** code, const char** filename)
{
CList<CScript,AMX*>::iterator a = g_loadedscripts.begin();
while ( a && id-- )
++a;
if ( a ){
*filename = (*a).getName();
*code = (*a).getCode();
return (*a).getAMX();
}
return 0;
}
const char* get_amxscriptname(AMX* amx)
{
CList<CScript,AMX*>::iterator a = g_loadedscripts.find( amx );
return a ? (*a).getName() : "";
}
void get_modname(char* buffer )
{
strcpy( buffer , g_mod_name.str() );
}
char* build_pathname(char *fmt, ... )
{
static char string[256];
int b;
int a = b = snprintf(string , 255 ,
#ifndef __linux__
"%s\\",
#else
"%s/",
#endif
g_mod_name.str());
va_list argptr;
va_start (argptr, fmt);
a += vsnprintf (&string[a], 255 - a , fmt,argptr);
string[ a ] = 0;
va_end (argptr);
char* path = &string[b];
while (*path)
{
#ifndef __linux__
if (*path == '/') *path = '\\';
#else
if (*path == '\\') *path = '/';
#endif
++path;
}
return string;
}
int add_amxnatives(module_info_s* info,AMX_NATIVE_INFO*natives)
{
CList<CModule>::iterator a = g_modules.begin();
while ( a )
{
if ( (*a).getInfo() == info )
{
AMX_NATIVE_INFO** aa = new AMX_NATIVE_INFO*(natives);
if ( aa == 0 ) return AMX_ERR_NATIVE;
(*a).natives.put( aa );
return AMX_ERR_NONE;
}
++a;
}
return AMX_ERR_NATIVE;
}
bool validFile(const char* file)
{
const char* a = 0;
while(*file)
if (*file++=='.')
a = file;
#ifndef __linux__
return (a && !strcmp(a,"dll"));
#else
return (a && !strcmp(a,"so"));
#endif
}
int loadModules(const char* filename)
{
File fp( build_pathname("%s",filename), "r" );
if ( !fp )
{
print_srvconsole( "[AMX] Modules list not found (file \"%s\")\n",filename);
return 0;
}
char line[256], moduleName[256];
int loaded = 0;
while ( fp.getline( line , 255 ) )
{
*moduleName = 0;
sscanf(line,"%s",moduleName);
if (!isalnum(*moduleName) || !validFile(moduleName) )
continue;
char* pathname = build_pathname("%s",moduleName);
CList<CModule>::iterator a = g_modules.find( pathname );
if ( a ) continue; // already loaded
CModule* cc = new CModule( pathname );
if ( cc == 0 ) return loaded;
cc->queryModule();
switch( cc->getStatusValue() ) {
case MODULE_BADLOAD:
report_error( 1 , "[AMX] Module is not a valid library (file \"%s\")\n",pathname );
break;
case MODULE_NOINFO:
report_error( 1 ,"[AMX] Couldn't find info. about module (file \"%s\")\n",pathname );
break;
case MODULE_NOQUERY:
report_error( 1 , "[AMX] Couldn't find \"AMX_Query\" (file \"%s\")\n", pathname );
break;
case MODULE_NOATTACH:
report_error( 1 , "[AMX] Couldn't find \"AMX_Attach\" (file \"%s\")\n", pathname );
break;
case MODULE_OLD:
report_error( 1 , "[AMX] Module has a different interface version (file \"%s\")\n",pathname );
break;
default:
++loaded;
}
g_modules.put( cc );
}
return loaded;
}
void dettachModules()
{
CList<CModule>::iterator a = g_modules.begin();
while ( a )
{
(*a).detachModule();
a.remove();
}
}
void dettachReloadModules()
{
CList<CModule>::iterator a = g_modules.begin();
while ( a )
{
if ( (*a).isReloadable() )
{
(*a).detachModule();
a.remove();
continue;
}
++a;
}
}
void attachModules()
{
CList<CModule>::iterator a = g_modules.begin();
while ( a )
{
(*a).attachModule();
++a;
}
}
const char* strip_name( const char* a )
{
const char* ret = a;
while(*a){
if ( *a== '/' || *a=='\\' ){
ret = ++a;
continue;
}
++a;
}
return ret;
}
void dettachMetaModModules( const char* filename )
{
File fp( build_pathname("%s",filename), "r" );
if ( !fp )
{
print_srvconsole( "[AMX] Modules list not found (file \"%s\")\n",filename);
return;
}
char line[256], moduleName[256], cmdline[256];
DLHANDLE module;
while ( fp.getline( line , 255 ) )
{
*moduleName = 0;
sscanf(line,"%s",moduleName);
if (!isalnum(*moduleName) || !validFile(moduleName) )
continue;
char* pathname = build_pathname("%s",moduleName);
module = DLLOAD( pathname ); // link dll
if ( module )
{
int a = (int)DLPROC(module,"Meta_Attach");
if ( a )
{
snprintf(cmdline,255, "meta unload %s\n", strip_name(moduleName) );
cmdline[255] = 0;
SERVER_COMMAND( cmdline );
}
DLFREE(module);
}
}
}
void attachMetaModModules( const char* filename )
{
File fp( build_pathname("%s",filename), "r" );
if ( !fp )
{
print_srvconsole( "[AMX] Modules list not found (file \"%s\")\n",filename);
return;
}
char line[256], moduleName[256], cmdline[256];
DLHANDLE module;
int loaded = 0;
while ( fp.getline( line , 255 ) )
{
*moduleName = 0;
sscanf(line,"%s",moduleName);
if (!isalnum(*moduleName) || !validFile(moduleName) )
continue;
char* pathname = build_pathname("%s",moduleName);
module = DLLOAD( pathname ); // link dll
if ( module )
{
int a = (int)DLPROC(module,"Meta_Attach");
if ( a )
{
snprintf(cmdline,255, "meta load %s\n", moduleName );
cmdline[255] = 0;
SERVER_COMMAND( cmdline );
++loaded;
}
DLFREE(module);
}
}
if ( loaded )
{
SERVER_COMMAND( "restart\n" );
/* must be or modules can cause crash
since they were not initialized with all routines (spawn, server active
players think, etc.) and metamod calls other routines
like nothing has never happened. */
}
}

179
amxmodx/modules.h Executable file
View File

@ -0,0 +1,179 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#ifndef __MODULES_H__
#define __MODULES_H__
#include "amx.h"
#undef DLLEXPORT
#ifndef __linux__
#define DLLEXPORT __declspec(dllexport)
#else
#define DLLEXPORT
#define WINAPI
#endif
#undef C_DLLEXPORT
#define C_DLLEXPORT extern "C" DLLEXPORT
#define AMX_INTERFACE_VERSION 6
#define RELOAD_MODULE 0
#define STATIC_MODULE 1
struct module_info_s {
const char* name;
const char* author;
const char* version;
int ivers;
int type;
long int serial;
};
// Small scripting language
struct pfnamx_engine_g {
uint16_t* (*pfnamx_Align16)(uint16_t *); // value
uint32_t* (*pfnamx_Align32)(uint32_t *); // value
int (*pfnamx_Allot)(AMX*, int, cell*, cell**); // amx, length, amx_addr, phys_addr
int (*pfnamx_Callback)(AMX*, cell , cell*, cell*); // amx, index,result,params
int (*pfnamx_Clone)(AMX*, AMX*, void*); // amxClone, amxSrc, data
int (*pfnamx_Debug)(AMX*); // default debug procedure, does nothing // amx
int (*pfnamx_Exec)(AMX*, cell*, int , int , ...); // amx, return val, index, num_params, ...
int (*pfnamx_Execv)(AMX*, cell*, int , int, cell[]); // amx, return val, index, num_params, param[]
int (*pfnamx_FindPublic)(AMX*, char*, int*); // amx, func name, index
int (*pfnamx_FindPubVar)(AMX*, char*, cell*); // anx, var name, amx_addr
int (*pfnamx_FindTagId)(AMX*, cell , char*); // amx. tag_id, tagname
int (*pfnamx_Flags)(AMX*,uint16_t *); // amx, flags
int (*pfnamx_GetAddr)(AMX*,cell ,cell**); // amx, amx_addr, phys_addr
int (*pfnamx_GetPublic)(AMX*, int , char*); // amx, index, funcname
int (*pfnamx_GetPubVar)(AMX*, int , char*, cell*); // amx, index, varname, amx_addr
int (*pfnamx_GetString)(char*dest,cell*); // dest, source
int (*pfnamx_GetTag)(AMX*, int , char*, cell*); // amx, index, tagname, tag_id
int (*pfnamx_GetUserData)(AMX*, long , void **); // amx, tag, ptr
int (*pfnamx_Init)(AMX*, void *); // amx, program
int (*pfnamx_InitJIT)(AMX*, void *, void *); // amx, reloc_table, native_code
int (*pfnamx_MemInfo)(AMX*, long*, long*, long*); // amx, codesize, datasize, stackheap
int (*pfnamx_NameLength)(AMX*, int*); // amx, length
AMX_NATIVE_INFO * (*pfnamx_NativeInfo)(char*,AMX_NATIVE ); // name, func
int (*pfnamx_NumPublics)(AMX*, int*); // amx, number
int (*pfnamx_NumPubVars)(AMX*, int*); // amx, number
int (*pfnamx_NumTags)(AMX*, int*); // amx, number
int (*pfnamx_RaiseError)(AMX*, int ); // amx, error
int (*pfnamx_Register)(AMX*, AMX_NATIVE_INFO*, int ); // amx, nativelist, number
int (*pfnamx_Release)(AMX*, cell ); // amx, amx_addr
int (*pfnamx_SetCallback)(AMX*, AMX_CALLBACK ); // amx, callback
int (*pfnamx_SetDebugHook)(AMX*, AMX_DEBUG ); // amx, debug
int (*pfnamx_SetString)(cell*, char*, int ); // dest, source, pack
int (*pfnamx_SetUserData)(AMX*, long , void*); // amx, tag, prt
int (*pfnamx_StrLen)(cell*, int*); // amx, cstring, length
};
extern pfnamx_engine_g* g_engAmxFunc;
#define AMX_ALIGN16 (*g_engAmxFunc->pfnamx_Align16)
#define AMX_ALIGN32 (*g_engAmxFunc->pfnamx_Align32)
#define AMX_ALLOT (*g_engAmxFunc->pfnamx_Allot)
#define AMX_CALLBACK (*g_engAmxFunc->pfnamx_Callback)
#define AMX_CLONE (*g_engAmxFunc->pfnamx_Clone)
#define AMX_DEBUG (*g_engAmxFunc->pfnamx_Debug)
#define AMX_EXEC (*g_engAmxFunc->pfnamx_Exec)
#define AMX_EXECV (*g_engAmxFunc->pfnamx_Execv)
#define AMX_FINDPUBLIC (*g_engAmxFunc->pfnamx_FindPublic)
#define AMX_FINDPUBVAR (*g_engAmxFunc->pfnamx_FindPubVar)
#define AMX_FINDTAGID (*g_engAmxFunc->pfnamx_FindTagId)
#define AMX_FLAGS (*g_engAmxFunc->pfnamx_Flags)
#define AMX_GETADDR (*g_engAmxFunc->pfnamx_GetAddr)
#define AMX_GETPUBLIC (*g_engAmxFunc->pfnamx_GetPublic)
#define AMX_GETPUBVAR (*g_engAmxFunc->pfnamx_GetPubVar)
#define AMX_GETSTRING (*g_engAmxFunc->pfnamx_GetString)
#define AMX_GETTAG (*g_engAmxFunc->pfnamx_GetTag)
#define AMX_GETUSERDATA (*g_engAmxFunc->pfnamx_GetUserData)
#define AMX_INIT (*g_engAmxFunc->pfnamx_Init)
#define AMX_INITJIT (*g_engAmxFunc->pfnamx_InitJIT)
#define AMX_MEMINFO (*g_engAmxFunc->pfnamx_MemInfo)
#define AMX_NAMELENGTH (*g_engAmxFunc->pfnamx_NameLength)
#define AMX_NATIVEINFO (*g_engAmxFunc->pfnamx_NativeInfo)
#define AMX_NUMPUBLICS (*g_engAmxFunc->pfnamx_NumPublics)
#define AMX_NUMPUBVARS (*g_engAmxFunc->pfnamx_NumPubVars)
#define AMX_NUMTAGS (*g_engAmxFunc->pfnamx_NumTags)
#define AMX_RAISEERROR (*g_engAmxFunc->pfnamx_RaiseError)
#define AMX_REGISTER (*g_engAmxFunc->pfnamx_Register)
#define AMX_RELEASE (*g_engAmxFunc->pfnamx_Release)
#define AMX_SETCALLBACK (*g_engAmxFunc->pfnamx_SetCallback)
#define AMX_SETDEBUGHOOK (*g_engAmxFunc->pfnamx_SetDebugHook)
#define AMX_SETSTRING (*g_engAmxFunc->pfnamx_SetString)
#define AMX_SETUSERDATA (*g_engAmxFunc->pfnamx_SetUserData)
#define AMX_STRLEN (*g_engAmxFunc->pfnamx_StrLen)
// Modules API
struct pfnmodule_engine_g {
int (*pfnadd_amxnatives)(module_info_s*,AMX_NATIVE_INFO*); // list
char* (*pfnbuild_pathname)(char*, ...); // format, ....
void (*pfncopy_amxmemory)(cell*,cell*,int); // dest, src, len
char* (*pfnformat_amxstring)(AMX*, cell*, int ,int& ); // amx, format, start pos, len
cell* (*pfnget_amxaddr)(AMX*,cell ); // amx, cell
AMX* (*pfnget_amxscript)(int, void**,const char**); // id, code, name
const char* (*pfnget_amxscriptname)(AMX* amx); // amx
char* (*pfnget_amxstring)(AMX*,cell,int, int&); // amx, src, buffer (0-3), len
void (*pfnget_modname)(char*); // modname
int (*pfnload_amxscript)(AMX*, void**, const char*, char[64]); // amx, code, path, error info
void (*pfnprint_console)(char*, ...); // format, ....
void (*pfnreport_error)(int code, char*, ... );
int (*pfnset_amxnatives)(AMX*,char[64]); // amx, error info
int (*pfnset_amxstring)(AMX*,cell ,const char*,int); // amx, dest, string, maxlen
int (*pfnamxstring_length)(cell*); // src
int (*pfnunload_amxscript)(AMX* amx,void**); // amx, code
void* (*pfnalloc_amxmemory)(void**,int size);
void (*pfnfree_amxmemory)(void**);
};
extern pfnmodule_engine_g* g_engModuleFunc;
#define ADD_AMXNATIVES (*g_engModuleFunc->pfnadd_amxnatives)
#define AMXSTRING_LENGTH (*g_engModuleFunc->pfnamxstring_length)
#define BUILD_PATHNAME (*g_engModuleFunc->pfnbuild_pathname)
#define COPY_AMXMEMORY (*g_engModuleFunc->pfncopy_amxmemory)
#define FORMAT_AMXSTRING (*g_engModuleFunc->pfnformat_amxstring)
#define GET_AMXADDR (*g_engModuleFunc->pfnget_amxaddr)
#define GET_AMXSCRIPT (*g_engModuleFunc->pfnget_amxscript)
#define GET_AMXSCRIPTNAME (*g_engModuleFunc->pfnget_amxscriptname)
#define GET_AMXSTRING (*g_engModuleFunc->pfnget_amxstring)
#define GET_MODNAME (*g_engModuleFunc->pfnget_modname)
#define LOAD_AMXSCRIPT (*g_engModuleFunc->pfnload_amxscript)
#define PRINT_CONSOLE (*g_engModuleFunc->pfnprint_console)
#define REPORT_ERROR (*g_engModuleFunc->pfnreport_error)
#define SET_AMXNATIVES (*g_engModuleFunc->pfnset_amxnatives)
#define SET_AMXSTRING (*g_engModuleFunc->pfnset_amxstring)
#define UNLOAD_AMXSCRIPT (*g_engModuleFunc->pfnunload_amxscript)
#define ALLOC_AMXMEMORY (*g_engModuleFunc->pfnalloc_amxmemory)
#define FREE_AMXMEMORY (*g_engModuleFunc->pfnfree_amxmemory)
#endif // __MODULES_H__

6
amxmodx/msvc/amxmod_mm.def Executable file
View File

@ -0,0 +1,6 @@
LIBRARY amx_mm
EXPORTS
GiveFnptrsToDll @1
SECTIONS
.data READ WRITE

288
amxmodx/msvc/amxmod_mm.dsp Executable file
View File

@ -0,0 +1,288 @@
# Microsoft Developer Studio Project File - Name="amxmod_mm" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
CFG=amxmod_mm - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "amxmod_mm.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "amxmod_mm.mak" CFG="amxmod_mm - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "amxmod_mm - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "amxmod_mm - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
MTL=midl.exe
RSC=rc.exe
!IF "$(CFG)" == "amxmod_mm - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "release"
# PROP Intermediate_Dir "release"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "amxmod_mm_EXPORTS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /I "..\..\metamod\metamod" /I "..\..\hlsdk\sourcecode\common" /I "..\..\hlsdk\sourcecode\engine" /I "..\..\hlsdk\sourcecode\dlls" /I "..\..\hlsdk\sourcecode\pm_shared" /I "..\extra\include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "amxmod_mm_EXPORTS" /YX /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC /l 0x409 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /def:".\amxmod_mm.def" /out:"release/amx_mm.dll" /libpath:"..\extra\lib_win32"
# Begin Custom Build
TargetPath=.\release\amx_mm.dll
TargetName=amx_mm
InputPath=.\release\amx_mm.dll
SOURCE="$(InputPath)"
"$(TargetName)" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
copy $(TargetPath) D:\SIERRA\Half-Life\cstrike\addons\amx\dlls
# End Custom Build
!ELSEIF "$(CFG)" == "amxmod_mm - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "debug"
# PROP Intermediate_Dir "debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "amxmod_mm_EXPORTS" /YX /FD /GZ /c
# ADD CPP /nologo /Zp4 /MTd /W3 /Gm /GX /ZI /Od /I "..\..\metamod\metamod" /I "..\...\hlsdk\sourcecode\common" /I "..\...\hlsdk\sourcecode\engine" /I "..\...\hlsdk\sourcecode\dlls" /I "..\...\hlsdk\sourcecode\pm_shared" /I "..\extra\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "amxmod_mm_EXPORTS" /YX /FD /GZ /c
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC /l 0x409 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /def:".\amxmod_mm.def" /out:"debug/amx_mm.dll" /pdbtype:sept /libpath:"..\extra\lib_win32"
# SUBTRACT LINK32 /incremental:no /nodefaultlib
# Begin Custom Build
TargetPath=.\debug\amx_mm.dll
TargetName=amx_mm
InputPath=.\debug\amx_mm.dll
SOURCE="$(InputPath)"
"$(TargetName)" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
copy $(TargetPath) D:\SIERRA\Half-Life\cstrike\addons\amx\dlls
# End Custom Build
!ENDIF
# Begin Target
# Name "amxmod_mm - Win32 Release"
# Name "amxmod_mm - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\amx.c
# End Source File
# Begin Source File
SOURCE=..\amxcore.c
# End Source File
# Begin Source File
SOURCE=..\amxmod.cpp
# End Source File
# Begin Source File
SOURCE=..\amxtime.c
# End Source File
# Begin Source File
SOURCE=..\CCmd.cpp
# End Source File
# Begin Source File
SOURCE=..\CEvent.cpp
# End Source File
# Begin Source File
SOURCE=..\CFile.cpp
# End Source File
# Begin Source File
SOURCE=..\CForward.cpp
# End Source File
# Begin Source File
SOURCE=..\CLogEvent.cpp
# End Source File
# Begin Source File
SOURCE=..\CMenu.cpp
# End Source File
# Begin Source File
SOURCE=..\CMisc.cpp
# End Source File
# Begin Source File
SOURCE=..\CModule.cpp
# End Source File
# Begin Source File
SOURCE=..\CPlugin.cpp
# End Source File
# Begin Source File
SOURCE=..\CString.cpp
# End Source File
# Begin Source File
SOURCE=..\CTask.cpp
# End Source File
# Begin Source File
SOURCE=..\CVault.cpp
# End Source File
# Begin Source File
SOURCE=..\emsg.cpp
# End Source File
# Begin Source File
SOURCE=..\file.cpp
# End Source File
# Begin Source File
SOURCE=..\float.cpp
# End Source File
# Begin Source File
SOURCE=..\meta_api.cpp
# End Source File
# Begin Source File
SOURCE=..\modules.cpp
# End Source File
# Begin Source File
SOURCE=..\power.c
# End Source File
# Begin Source File
SOURCE=..\srvcmd.cpp
# End Source File
# Begin Source File
SOURCE=..\string.cpp
# End Source File
# Begin Source File
SOURCE=..\strptime.cpp
# End Source File
# Begin Source File
SOURCE=..\util.cpp
# End Source File
# Begin Source File
SOURCE=..\vault.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File
SOURCE=..\amxmod.h
# End Source File
# Begin Source File
SOURCE=..\CCmd.h
# End Source File
# Begin Source File
SOURCE=..\CEvent.h
# End Source File
# Begin Source File
SOURCE=..\CFile.h
# End Source File
# Begin Source File
SOURCE=..\CForward.h
# End Source File
# Begin Source File
SOURCE=..\CList.h
# End Source File
# Begin Source File
SOURCE=..\CLogEvent.h
# End Source File
# Begin Source File
SOURCE=..\CMenu.h
# End Source File
# Begin Source File
SOURCE=..\CMisc.h
# End Source File
# Begin Source File
SOURCE=..\CModule.h
# End Source File
# Begin Source File
SOURCE=..\CPlugin.h
# End Source File
# Begin Source File
SOURCE=..\CString.h
# End Source File
# Begin Source File
SOURCE=..\CTask.h
# End Source File
# Begin Source File
SOURCE=..\CVault.h
# End Source File
# Begin Source File
SOURCE=..\modules.h
# End Source File
# End Group
# End Target
# End Project

29
amxmodx/msvc/amxmod_mm.dsw Executable file
View File

@ -0,0 +1,29 @@
Microsoft Developer Studio Workspace File, Format Version 6.00
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
###############################################################################
Project: "amxmod_mm"=.\amxmod_mm.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
}}}
###############################################################################
Global:
Package=<5>
{{{
}}}
Package=<3>
{{{
}}}
###############################################################################

60
amxmodx/osdefs.h Executable file
View File

@ -0,0 +1,60 @@
/* __MSDOS__ set when compiling for DOS (not Windows)
* _Windows set when compiling for any version of Microsoft Windows
* __WIN32__ set when compiling for Windows95 or WindowsNT (32 bit mode)
* __32BIT__ set when compiling in 32-bit "flat" mode (DOS or Windows)
*
* Copyright 1998-2002, ITB CompuPhase, The Netherlands.
* info@compuphase.com.
*/
#ifndef _OSDEFS_H
#define _OSDEFS_H
/* Every compiler uses different "default" macros to indicate the mode
* it is in. Throughout the source, we use the Borland C++ macros, so
* the macros of Watcom C/C++ and Microsoft Visual C/C++ are mapped to
* those of Borland C++.
*/
#if defined(__WATCOMC__)
# if defined(__WINDOWS__) || defined(__NT__)
# define _Windows 1
# endif
# ifdef __386__
# define __32BIT__ 1
# endif
# if defined(_Windows) && defined(__32BIT__)
# define __WIN32__ 1
# endif
#elif defined(_MSC_VER)
# if defined(_WINDOWS) || defined(_WIN32)
# define _Windows 1
# endif
# ifdef _WIN32
# define __WIN32__ 1
# define __32BIT__ 1
# endif
#endif
#if defined __linux__
#include <endian.h>
#endif
/* Linux NOW has these */
#if !defined BIG_ENDIAN
#define BIG_ENDIAN 4321
#endif
#if !defined LITTLE_ENDIAN
#define LITTLE_ENDIAN 1234
#endif
/* educated guess, BYTE_ORDER is undefined, i386 is common => little endian */
#if !defined BYTE_ORDER
#if defined UCLINUX
#define BYTE_ORDER BIG_ENDIAN
#else
#define BYTE_ORDER LITTLE_ENDIAN
#endif
#endif
#endif /* _OSDEFS_H */

42
amxmodx/power.c Executable file
View File

@ -0,0 +1,42 @@
/* This file implements two native functions. It is provided as
* an example to show how to add native functions. See the manual
* for more information.
*
* Copyright (c) ITB CompuPhase, 1998, 1999
* This file may be freely used. No warranties of any kind.
*/
#include "amx.h"
static cell power(AMX *amx, cell *params)
{
/* power(value, exponent);
* params[1] = value
* params[2] = exponent
*/
cell result = 1;
while (params[2]-- > 0)
result *= params[1];
return result;
}
static cell sqroot(AMX *amx, cell *params)
{
/* sqroot(value);
* params[1] = value
* This routine uses a simple successice approximation algorithm.
*/
cell div = params[1];
cell result = 1;
while (div > result) { /* end when div == result, or just below */
div = (div + result) / 2; /* take mean value as new divisor */
result = params[1] / div;
} /* while */
return div;
}
AMX_NATIVE_INFO power_Natives[] = {
{ "power", power },
{ "sqroot", sqroot },
{ 0, 0 } /* terminator */
};

48
amxmodx/sclinux.h Executable file
View File

@ -0,0 +1,48 @@
/*
* Things needed to compile under linux.
*
* Should be reworked totally to use GNU's 'configure'
*/
/*
* Getchar is not a 'cool' replacement for MSDOS getch: Linux/unix depends on the features activated or not about the
* controlling terminal's tty. This means that ioctl(2) calls must be performed, for instance to have the controlling terminal tty's
* in 'raw' mode, if we want to be able to fetch a single character. This also means that everything must be put back
* correctly when the program ends.
*
* For interactive use of SRUN/SDBG if would be much better to use GNU's readline package: the user would be able to have
* a complete emacs/vi like line editing system.
*
* So we stick to getchar at the moment... (one needs to key ctrl-d to terminate input if getch is called with a controlling
* terminal driven by a tty having -raw)
*/
#define getch getchar
#define stricmp(a,b) strcasecmp(a,b)
#define strnicmp(a,b,c) strncasecmp(a,b,c)
/*
* WinWorld wants '\'. Unices do not.
*/
#define DIRECTORY_SEP_CHAR '/'
#define DIRECTORY_SEP_STR "/"
/*
* SC assumes that a computer is Little Endian unless told otherwise. It uses
* (and defines) the macros BYTE_ORDER and BIG_ENDIAN.
* For Linux, we must overrule these settings with those defined in glibc.
*/
#if !defined __BYTE_ORDER
# include <stdlib.h>
#endif
#if defined __OpenBSD__
# define __BYTE_ORDER BYTE_ORDER
# define __LITTLE_ENDIAN LITTLE_ENDIAN
# define __BIG_ENDIAN BIG_ENDIAN
#endif
#if !defined __BYTE_ORDER
# error "Can't figure computer byte order (__BYTE_ORDER macro not found)"
#endif

228
amxmodx/srvcmd.cpp Executable file
View File

@ -0,0 +1,228 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
void amx_command(){
const char* cmd = CMD_ARGV(1);
if (!strcmp(cmd,"plugins") || !strcmp(cmd,"list"))
{
print_srvconsole( "Currently loaded plugins:\n");
print_srvconsole( " %-18.17s %-8.7s %-17.16s %-16.15s %-9.8s\n",
"name","version","author","file","status");
int plugins = 0;
int running = 0;
CPluginMngr::iterator a = g_plugins.begin();
while (a)
{
++plugins;
if ( (*a).isValid() && !(*a).isPaused() )
++running;
print_srvconsole( " [%3d] %-18.17s %-8.7s %-17.16s %-16.15s %-9.8s\n",
plugins,(*a).getTitle(),(*a).getVersion(),
(*a).getAuthor(), (*a).getName(), (*a).getStatus() );
++a;
}
print_srvconsole( "%d plugins, %d running\n",plugins,running );
}
else if (!strcmp(cmd,"pause") && CMD_ARGC() > 2)
{
const char* sPlugin = CMD_ARGV(2);
CPluginMngr::CPlugin *plugin = g_plugins.findPlugin(sPlugin);
if ( plugin && plugin->isValid() )
{
plugin->pausePlugin();
print_srvconsole("Paused plugin \"%s\"\n",plugin->getName() );
}
else print_srvconsole("Couldn't find plugin matching \"%s\"\n",sPlugin);
}
else if (!strcmp(cmd,"unpause") && CMD_ARGC() > 2)
{
const char* sPlugin = CMD_ARGV(2);
CPluginMngr::CPlugin *plugin = g_plugins.findPlugin(sPlugin);
if ( plugin && plugin->isValid() )
{
plugin->unpausePlugin();
print_srvconsole("Unpaused plugin \"%s\"\n",plugin->getName() );
}
else print_srvconsole("Couldn't find plugin matching \"%s\"\n",sPlugin);
}
else if (!strcmp(cmd,"cvars"))
{
print_srvconsole( "Registered cvars:\n");
print_srvconsole( " %-24.23s %-24.23s %-16.15s\n",
"name","value","plugin");
int ammount = 0;
for( CList<CCVar>::iterator a = g_cvars.begin(); a ; ++a )
{
print_srvconsole( " [%3d] %-24.23s %-24.23s %-16.15s\n",++ammount,
(*a).getName() ,CVAR_GET_STRING( (*a).getName() ),(*a).getPluginName() );
}
print_srvconsole( "%d cvars\n",ammount);
}
else if ( !strcmp(cmd,"cmds") )
{
print_srvconsole( "Registered commands:\n");
print_srvconsole( " %-24.23s %-16.15s %-8.7s %-16.15s\n",
"name","access" ,"type" ,"plugin");
int ammount = 0;
char access[32];
CmdMngr::iterator a = g_commands.begin( CMD_ConsoleCommand );
while( a )
{
UTIL_GetFlags( access , (*a).getFlags() );
print_srvconsole( " [%3d] %-24.23s %-16.15s %-8.7s %-16.15s\n",
++ammount,(*a).getCmdLine() , access , (*a).getCmdType() , (*a).getPlugin()->getName());
++a;
}
print_srvconsole( "%d commands\n",ammount);
}
else if (!strcmp(cmd,"version"))
{
print_srvconsole( "%s %s\n", Plugin_info.name, Plugin_info.version);
print_srvconsole( "author: %s (%s)\n", Plugin_info.author, Plugin_info.url);
print_srvconsole( "compiled: %s\n", __DATE__ ", " __TIME__);
}
else if (!strcmp(cmd,"modules"))
{
print_srvconsole( "Currently loaded modules:\n");
print_srvconsole( " %-23.22s %-7.8s %-8.7s %-20.19s %-11.10s\n",
"name","type","version", "author", "status");
int running = 0;
int modules = 0;
CList<CModule>::iterator a = g_modules.begin();
while ( a )
{
if ( (*a).getStatusValue() == MODULE_LOADED )
++running;
++modules;
print_srvconsole( " [%2d] %-23.22s %-7.6s %-8.7s %-20.19s %-11.10s\n",modules,
(*a).getName(), (*a).getType(), (*a).getVersion(), (*a).getAuthor() , (*a).getStatus() );
++a;
}
print_srvconsole( "%d modules, %d correct\n",modules,running);
}
else
{
print_srvconsole("Usage: amx < command > [ argument ]\n");
print_srvconsole("Commands:\n");
print_srvconsole(" version - display amx version info\n");
print_srvconsole(" plugins - list plugins currently loaded\n");
print_srvconsole(" modules - list modules currently loaded\n");
print_srvconsole(" cvars - list cvars registered by plugins\n");
print_srvconsole(" cmds - list commands registered by plugins\n");
print_srvconsole(" pause < plugin > - pause a running plugin\n");
print_srvconsole(" unpause < plugin > - unpause a previously paused plugin\n");
}
}
void plugin_srvcmd()
{
cell ret = 0;
int err;
const char* cmd = CMD_ARGV(0);
#ifdef ENABLEEXEPTIONS
try{
#endif
CmdMngr::iterator a = g_commands.srvcmdbegin();
while ( a )
{
if ( (*a).matchCommand( cmd ) &&
(*a).getPlugin()->isExecutable( (*a).getFunction() ) )
{
if ((err = amx_Exec( (*a).getPlugin()->getAMX(), &ret , (*a).getFunction()
, 3 , g_srvindex , (*a).getFlags() , (*a).getId() )) != AMX_ERR_NONE)
print_srvconsole("[AMX] Run time error %d on line %ld (plugin \"%s\")\n",
err,(*a).getPlugin()->getAMX()->curline,(*a).getPlugin()->getName());
if ( ret ) break;
}
++a;
}
#ifdef ENABLEEXEPTIONS
}catch( ... )
{
print_srvconsole( "[AMX] fatal error at forward function execution\n");
}
#endif
}

541
amxmodx/string.cpp Executable file
View File

@ -0,0 +1,541 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include <extdll.h>
#include <meta_api.h>
#include <ctype.h>
#include "amxmod.h"
const char* stristr(const char* str,const char* substr)
{
register char *needle = (char *)substr;
register char *prevloc = (char *)str;
register char *haystack = (char *)str;
while (*haystack) {
if (tolower(*haystack) == tolower(*needle)) {
haystack++;
if (!*++needle)
return prevloc;
}
else {
haystack = ++prevloc;
needle = (char *)substr;
}
}
return NULL;
}
char* format_amxstring(AMX *amx, cell *params, int parm,int& len)
{
static char buffer[2][3072];
static char format[16];
char *ptr,*arg;
char *dest = *buffer;
cell *src = get_amxaddr(amx, params[parm++]);
int numparam = *params/sizeof(cell);
while(*src) {
if (*src=='%'&&*(src+1)) {
ptr = format;
*ptr++ = *src++;
if (*src=='%'){
*dest++=*src++;
continue;
}
while (!isalpha(*ptr++=*src++))
;
*ptr=0;
if (numparam < parm) continue;
arg = buffer[1];
switch(*(ptr-1)){
case 's': sprintf(arg,format,get_amxstring(amx, params[parm++],2,len)); break;
case 'f': case 'g': sprintf(arg,format,*(float*)get_amxaddr(amx, params[parm++])); break;
default: sprintf(arg,format,(int)*get_amxaddr(amx, params[parm++]));
}
while(*arg) *dest++=*arg++;
continue;
}
*dest++=*src++;
}
*dest=0;
len = dest - *buffer;
return *buffer;
}
int amxstring_len(cell* a)
{
register int c = 0;
while( a[ c ] )
++c;
return c;
}
cell* get_amxaddr(AMX *amx,cell amx_addr)
{
return (cell *)(amx->base + (int)(((AMX_HEADER *)amx->base)->dat + amx_addr));
}
int set_amxstring(AMX *amx,cell amx_addr,const char *source,int max)
{
cell* dest = (cell *)(amx->base + (int)(((AMX_HEADER *)amx->base)->dat + amx_addr));
cell* start = dest;
while (max--&&*source)
*dest++=(cell)*source++;
*dest = 0;
return dest-start;
}
char* get_amxstring(AMX *amx,cell amx_addr,int id, int& len)
{
static char buffor[4][3072];
register cell* source = (cell *)(amx->base + (int)(((AMX_HEADER *)amx->base)->dat + amx_addr));
register char* dest = buffor[id];
char* start = dest;
while (*dest++=(char)*source++)
;
len = --dest - start;
return start;
}
void copy_amxmemory(cell* dest,cell* src,int len)
{
while (len--)
*dest++=*src++;
}
char* parse_arg(char** line,int& state)
{
static char arg[3072];
char* dest = arg;
state = 0;
while(**line) {
if ( isspace(**line) ) {
if (state == 1)
break;
else if (!state) {
(*line)++;
continue;
}
}
else if (state != 2)
state = 1;
if (**line=='"') {
(*line)++;
if (state == 2)
break;
state = 2;
continue;
}
*dest++ = *(*line)++;
}
*dest = '\0';
return arg;
}
static cell AMX_NATIVE_CALL replace(AMX *amx, cell *params) /* 4 param */
{
static char buffor[3072];
cell *a = get_amxaddr(amx,params[1]);
cell *b = get_amxaddr(amx,params[3]);
cell *c = get_amxaddr(amx,params[4]);
int iMain = amxstring_len(a);
int iWhat = amxstring_len(b);
int iWith = amxstring_len(c);
int iPot = iMain + iWith - iWhat;
if (iPot>=params[2]){
amx_RaiseError(amx,AMX_ERR_NATIVE);
return 0;
}
char *d = buffor;
cell *x, *y, *z = a, *l = a;
int p = 0;
while(*a){
if (*a==*b){
x=a+1;
y=b+1;
p=1;
if (!*y) break;
while(*x==*y){
x++; y++; p++;
if (!*y) break;
}
if (!*y) break;
p = 0;
*d++=(char)*a++;
continue;
}
*d++=(char)*a++;
}
if (p){
while(*c) *d++=(char)*c++;
a+=p;
while(*a) *d++=(char)*a++;
*d=0;
d = buffor;
while(*d) *z++=*d++;
*z=0;
return (z-l);
}
return 0;
}
static cell AMX_NATIVE_CALL contain(AMX *amx, cell *params) /* 2 param */
{
register cell *a = get_amxaddr(amx,params[2]);
register cell *b = get_amxaddr(amx,params[1]);
register cell *c = b;
cell* str = b;
cell* substr = a;
while (*c) {
if (*c == *a) {
c++;
if (!*++a)
return b - str;
}
else {
c = ++b;
a = substr;
}
}
return -1;
}
static cell AMX_NATIVE_CALL containi(AMX *amx, cell *params) /* 2 param */
{
register cell *a = get_amxaddr(amx,params[2]);
register cell *b = get_amxaddr(amx,params[1]);
register cell *c = b;
cell* str = b;
cell* substr = a;
while (*c) {
if (tolower(*c) == tolower(*a)) {
c++;
if (!*++a)
return b - str;
}
else {
c = ++b;
a = substr;
}
}
return -1;
}
static cell AMX_NATIVE_CALL strtonum(AMX *amx, cell *params) /* 1 param */
{
int iLen;
return atoi(get_amxstring(amx,params[1],0,iLen));
}
static cell AMX_NATIVE_CALL numtostr(AMX *amx, cell *params) /* 3 param */
{
char szTemp[32];
sprintf(szTemp,"%d",(int)params[1]);
return set_amxstring(amx,params[2],szTemp,params[3]);
}
static cell AMX_NATIVE_CALL add(AMX *amx, cell *params) /* 4 param */
{
cell *src = get_amxaddr(amx,params[3]);
cell *dest = get_amxaddr(amx,params[1]);
cell *start = dest;
int c = params[2], d = params[4];
while(*dest&&c--)
++dest;
if (d){
while(c--&&d--&&*src)
*dest++=*src++;
*dest=0;
return (dest-start);
}
while(c--&&*src)
*dest++=*src++;
*dest=0;
return (dest-start);
}
static cell AMX_NATIVE_CALL copy(AMX *amx, cell *params) /* 4 param */
{
cell *src = get_amxaddr(amx,params[3]);
cell *dest = get_amxaddr(amx,params[1]);
cell *start = dest;
int c = params[2];
while(c--&&*src)
*dest++=*src++;
*dest=0;
return (dest-start);
}
static cell AMX_NATIVE_CALL copyc(AMX *amx, cell *params) /* 4 param */
{
cell *src = get_amxaddr(amx,params[3]);
cell *dest = get_amxaddr(amx,params[1]);
cell *start = dest;
int c = params[2];
cell ch = params[4];
while(c--&&*src&&*src!=ch)
*dest++=*src++;
*dest=0;
return (dest-start);
}
static cell AMX_NATIVE_CALL setc(AMX *amx, cell *params) /* 4 param */
{
cell *src = get_amxaddr(amx,params[1]);
int c = params[2];
cell ch = params[3];
while(c--)
*src++=ch;
return 1;
}
static cell AMX_NATIVE_CALL equal(AMX *amx, cell *params) /* 3 param */
{
cell *a = get_amxaddr(amx,params[1]);
cell *b = get_amxaddr(amx,params[2]);
int c = params[3];
if (c) {
while (--c&&*a&&(*a==*b))
++a, ++b;
return (*a-*b)?0:1;
}
int ret;
while(!(ret=*a-*b)&&*b)
++a, ++b;
return ret?0:1;
}
static cell AMX_NATIVE_CALL equali(AMX *amx, cell *params) /* 3 param */
{
cell *a = get_amxaddr(amx,params[1]);
cell *b = get_amxaddr(amx,params[2]);
int f,l, c = params[3];
if (c) {
do {
f = tolower(*a++);
l = tolower(*b++);
}
while (--c &&l&&f&& f==l);
return(f - l)?0:1;
}
do {
f = tolower(*a++);
l = tolower(*b++);
} while (f && f == l);
return (f - l)?0:1;
}
static cell AMX_NATIVE_CALL format(AMX *amx, cell *params) /* 3 param */
{
int len;
return set_amxstring(amx,params[1],format_amxstring(amx,params,3,len),params[2]);
}
static cell AMX_NATIVE_CALL parse(AMX *amx, cell *params) /* 3 param */
{
int inum = *params/sizeof(cell), iarg = 2, c;
char* arg, *parse = get_amxstring(amx,params[1],0,c);
cell *cptr;
int state;
while(*parse){
arg = parse_arg(&parse,state);
if (state){
if (inum <= iarg)
return( (iarg-2)>>1 );
cptr = get_amxaddr(amx,params[iarg++]);
c = *get_amxaddr(amx,params[iarg++]);
while(c--&&*arg)
*cptr++=(cell)*arg++;
*cptr=0;
}
}
return( (iarg-2)>>1 );
}
static cell AMX_NATIVE_CALL strtolower(AMX *amx, cell *params) /* 1 param */
{
cell *cptr = get_amxaddr(amx,params[1]);
cell *begin = cptr;
while(*cptr){
*cptr = tolower(*cptr);
cptr++;
}
return cptr - begin;
}
static cell AMX_NATIVE_CALL strtoupper(AMX *amx, cell *params) /* 1 param */
{
cell *cptr = get_amxaddr(amx,params[1]);
cell *begin = cptr;
while(*cptr){
*cptr = toupper(*cptr);
cptr++;
}
return cptr - begin;
}
int fo_numargs(AMX *amx)
{
unsigned char *data =amx->base+(int)((AMX_HEADER *)amx->base)->dat;
cell bytes= * (cell *)(data+(int)amx->frm+2*sizeof(cell));
return (int)(bytes/sizeof(cell));
}
int fo_getargnum(AMX *amx, int pos)
{
unsigned char *data =amx->base+(int)((AMX_HEADER *)amx->base)->dat;
cell value = * (cell *)(data+(int)amx->frm+(pos+3)*sizeof(cell));
return *(cell *)(data+(int)value);
}
float fo_getargfloat(AMX *amx, int pos)
{
unsigned char *data =amx->base+(int)((AMX_HEADER *)amx->base)->dat;
cell value = * (cell *)(data+(int)amx->frm+(pos+3)*sizeof(cell));
cell number = *(cell *)(data+(int)value);
return *(float *)((void *)&number);
}
char* fo_getargstr(AMX *amx, int swap, int pos)
{
unsigned char *data =amx->base+(int)((AMX_HEADER *)amx->base)->dat;
cell src_value= * (cell *)(data+(int)amx->frm+(pos+3)*sizeof(cell));
cell value;
static char buffer[2][3072];
char* b = buffer[swap];
int a = 0;
do {
value = src_value + a++ * sizeof(cell);
value = *(cell *)(data+(int)value);
*b++ = value;
} while (value);
return buffer[swap];
}
char* format_arguments(AMX *amx, int parm,int& len)
{
static char buffer[2][3072];
static char format[16];
char *ptr,*arg, *dest = *buffer;
char *src = fo_getargstr(amx, 0,parm++);
int numparam = fo_numargs(amx);
while(*src) {
if (*src=='%'&&*(src+1)) {
ptr = format;
*ptr++ = *src++;
if (*src=='%'){
*dest++=*src++;
continue;
}
while (!isalpha(*ptr++=*src++))
;
*ptr='\0';
if (numparam < parm) continue;
arg = buffer[1];
switch(*(ptr-1)){
case 's': sprintf(arg,format,fo_getargstr(amx,1, parm++)); break;
case 'f': case 'g': sprintf(arg,format,fo_getargfloat(amx, parm++)); break;
default: sprintf(arg,format,fo_getargnum(amx, parm++));
}
while(*arg) *dest++=*arg++;
continue;
}
*dest++=*src++;
}
*dest='\0';
len = dest - *buffer;
return *buffer;
}
static cell AMX_NATIVE_CALL format_args(AMX *amx, cell *params)
{
int len;
int pos = params[3];
if (pos < 0){
amx_RaiseError(amx,AMX_ERR_NATIVE);
return 0;
}
char* string = format_arguments(amx, pos ,len); // indexed from 0
return set_amxstring(amx,params[1],string,params[2]);
}
static cell AMX_NATIVE_CALL is_digit(AMX *amx, cell *params)
{
return isdigit( params[1] );
}
static cell AMX_NATIVE_CALL is_alnum(AMX *amx, cell *params)
{
return isalnum( params[1] );
}
static cell AMX_NATIVE_CALL is_space(AMX *amx, cell *params)
{
return isspace( params[1] );
}
static cell AMX_NATIVE_CALL is_alpha(AMX *amx, cell *params)
{
return isalpha( params[1] );
}
AMX_NATIVE_INFO string_Natives[] = {
{ "add", add },
{ "contain", contain },
{ "containi", containi },
{ "copy", copy },
{ "copyc", copyc },
{ "equal", equal },
{ "equali", equali },
{ "format", format },
{ "format_args", format_args },
{ "isdigit", is_digit },
{ "isalnum", is_alnum },
{ "isspace", is_space },
{ "isalpha", is_alpha },
{ "numtostr", numtostr },
{ "num_to_str", numtostr },
{ "parse", parse },
{ "replace", replace },
{ "setc", setc },
{ "strtolower", strtolower },
{ "strtonum", strtonum },
{ "strtoupper", strtoupper },
{ "str_to_num", strtonum },
{ NULL, NULL }
};

398
amxmodx/strptime.cpp Executable file
View File

@ -0,0 +1,398 @@
/** strptime.c **********************************************************
Locales' support for DOS / Win31 / Win32.
Copyright (c) 1995-1997 by Timofei Bondarenko <tim@ipi.ac.ru>
Localized strptime().
*-----------------------------------------------------------------------*/
//#include "config.h"
#include <time.h>
#include <ctype.h>
#include <string.h>
#ifdef __linux__
#define strnicmp strncasecmp
#endif
const char *_lc_Wday_ [2][ 7],
*_lc_Month_[2][12],
*_lc_AmPm_ [2][ 2];
const char *_lc_fmt_c_[2],
*_lc_fmt_xD[2],
*_lc_fmt_XT[2];
int _lc_Txt_, /* 0="C", 1="Local Win"/"Rus DOS" Wday, Months, AmPm */
_lc_Fmt_; /* 0="C", 1="Local", for formats %c %x %X */
//#include "_locale.h"
struct tm_int
{
int qS, /* Seconds (0...61) */
qM, /* Minutes (0...59) */
qH, /* Hour (0...23) */
qI, /* Hour (1...12) */
qp, /* 0 = AM, 1 = PM */
qd, /* Day of month (1...31)=>[0...30] */
qm, /* Month (1...12)=>[0...11] */
qY, /* Year (0...9999) */
qy, /* year (0...99) */
qC, /* Century (0...99) */
qw, /* Weekday (0...6; Sunday = 0) */
qj, /* Day of year (1..366)=>[0...365] */
qZ, /* 0 = STD, 1 = DST */
qU, /* week in year (0...53) */
qV; /* week in year mode: 'U', 'W', 'V' */
};
/* skips spaces in `strp`. Returns 0 if no spaces skipped */
static void skip_sp(const unsigned char **strp)
{
while(isspace(**strp)) (*strp)++;
}
/* scans no more decimal digits than contained in `max` as an integer,
sign isn't allowed. Returns -1 if 0 digits scanned or
if the scanned number is greater than `max`. */
static int scan_int(const unsigned char **strp, int max)
{
int cc, val, pos;
skip_sp(strp);
for(val = pos = 0; pos < max && isdigit(cc = **strp); (*strp)++)
{
pos = pos * 10 + 9;
if ((val = val * 10 + (cc - '0')) > max) return -1;
/*val = val * 10 + (cc - '0');*/
}
return pos? val: -1;
}
static int scan_int2(const unsigned char **strp)
{
int cc, val, pos;
skip_sp(strp);
for(val = pos = 0; isdigit(cc = **strp); (*strp)++)
{
pos = pos * 10 + 9;
val = val * 10 + (cc - '0');
}
return pos? val: -1;
}
/* scans one word which is equivalence (case insensitive) to a
word from list `n_full` or from list `n_short` or when
n_short is NULL to first 3 characters from a word from `n_full`.
`max` is number of words in each list `n_full` or `n_short`.
Returns the index in a list >= 0 and < `max`, or -1 if no word found. */
static int scan_word_(const unsigned char **strp,
int max, const char *const *n_full
#if USE_ABBR_NAMES
, const char *const *n_short
#endif
)
{
int ix, l_max = 100;
int found, found_len;
const char *const *word_list;
found = found_len = -1;
skip_sp(strp); /* Required? Or Not? */
Scan0:
word_list = n_full;
/*Scan1:*/
for(ix = 0; ix < max; word_list++, ix++)
{
int len;
const char *word = *word_list;
skip_sp((const unsigned char**)&word);
if (l_max < (len = strlen(word))) len = l_max;
if (found_len < len && /* search for maximal lenth */
(!len || /* at least "" always founded */
!strnicmp((const char*)*strp, word, len))) /* found */
found_len = len, found = ix;
}
if (l_max >= 100) /* first pass: full names */
{ /* go to second pass: short names */
#if USE_ABBR_NAMES
if (n_short)
{
l_max--; word_list = n_short; goto Scan1;
}
#endif
l_max = 3; goto Scan0;
}
if (found_len > 0) (*strp) += found_len;
return found; /* -1 or index or first "" */
}
#if USE_ABBR_NAMES
#define scan_word scan_word_ /* pass all arguments as is */
#else
#define scan_word(str,max,n_full,n_short) scan_word_(str,max,n_full)
#endif
static int time_int(struct tm_int *ti,
const unsigned char **buf, const char *fmt, short addthem)
{
int ii;
for(; (ii = (unsigned char)*fmt); fmt++)
if (ii != '%')
{
Other:
if (isspace(ii))
{
/*SkipSp:*/ fmt++; skip_sp((const unsigned char **)&fmt);
fmt--; skip_sp(buf);
} /* toupper(ii) != toupper(**buf) */
/*else if (_lc_igncase[ii] != _lc_igncase[**buf]) return -1;*/
else (*buf)++;
}
else
{
const char *fs;
/*Fmt:*/ switch(ii = (unsigned char)*++fmt)
{
case 0 : goto FmtEnd;
case 'a':
case 'A':
ti->qw = ii = scan_word(buf, 7,
_lc_Wday_[_lc_Txt_],
_lc_Txt_? _lc_WdayS: NULL); break;
case 'h': /* STRFTIME_EXT */
case 'b':
case 'B':
ti->qm = ii = scan_word(buf, 12,
_lc_Month_[_lc_Txt_],
_lc_Txt_? _lc_MonthS: NULL); break;
case 'c':
fs = _lc_fmt_c_[_lc_Fmt_];
strpt: ii = time_int(ti, buf, fs, addthem); break;
#if STRFTIME_EXT
case 'C': /* STRFTIME_EXT */
ti->qC = ii = addthem ? scan_int2(buf) : scan_int(buf,99);
if (ti->qy >= 0) goto SetYear;
else if (ti->qY >= 0)
{
ti->qY = ti->qY % 100 + ii * 100;
goto CleanCy;
}
break;
case 'e': /* STRFTIME_EXT */
#endif
case 'd':
ti->qd = ii = (addthem ? scan_int2(buf) : scan_int(buf, 31)) - 1; break;
#if STRFTIME_EXT
case 'D': /* STRFTIME_EXT */
fs = _lc_fmt_xD[0]; goto strpt;
/* case 'E': STRFTIME_EXT "Era specefic" see %'O' */
/* case 'h': STRFTIME_EXT see %'b' */
#endif
case 'H':
ti->qH = ii = addthem ? scan_int2(buf) : scan_int(buf, 23);
CleanIp: ti->qI = ti->qp = -1; break;
case 'I':
ti->qI =
ti->qH = ii = addthem ? scan_int2(buf) : scan_int(buf, 23);
if (ii == 0 || ii > 12) goto CleanIp;
else ti->qH = -1;
break;
case 'j':
ti->qj = ii = (addthem ? scan_int2(buf) : scan_int(buf, 366)) - 1;
ti->qU = -1; break;
case 'm':
ti->qm = ii = (addthem ? scan_int2(buf) : scan_int(buf, 12)) - 1; break;
case 'M':
ti->qM = ii = addthem ? scan_int2(buf) : scan_int(buf, 59); break;
#if STRFTIME_EXT
case 'n': /* STRFTIME_EXT */
case 't': /* STRFTIME_EXT */ goto SkipSp;
case 'N': /* STRFTIME_EXT */
fs = _lc_fmt_N_; goto strpt;
case 'E': /* STRFTIME_EXT "Era specefic" */
#endif
#if STRFTIME_EXT | STRFTIME_WIN
case 'O': /* STRFTIME_EXT "Alternate digits" */
goto Fmt;
#endif
case 'p':
ti->qp = /*ii =*/ scan_word(buf, 2, _lc_AmPm_[_lc_Txt_], NULL);
break;
#if STRFTIME_EXT
case 'r': /* STRFTIME_EXT */
fs = _lc_fmt_rI; goto strpt;
case 'R': /* STRFTIME_EXT */
fs = _lc_fmt_RH; goto strpt;
#endif
case 'S':
ti->qS = ii = addthem ? scan_int2(buf) : scan_int(buf, 61); break;
#if STRFTIME_EXT
case 'T': /* STRFTIME_EXT */
fs = _lc_fmt_XT[0]; goto strpt;
case 'u': /* STRFTIME_EXT */
ti->qw = ii = addthem ? scan_int2(buf) : scan_int(buf, 7);
if (ii == 7) ti->qw = 0;
else if (!ii) ii--;
break;
#endif
#if STRFTIME_EXT && 0
case 'V': /* STRFTIME_EXT 0 = Wednesday ?(Thursday) */
#endif
case 'U':
case 'W':
ti->qV = ii;
ti->qU = ii = addthem ? scan_int2(buf) : scan_int(buf, 53); break;
case 'w':
ti->qw = ii = addthem ? scan_int2(buf) : scan_int(buf, 6); break;
case 'x':
fs = _lc_fmt_xD[_lc_Fmt_]; goto strpt;
case 'X':
fs = _lc_fmt_XT[_lc_Fmt_]; goto strpt;
case 'y':
ti->qy = ii = addthem ? scan_int2(buf) : scan_int(buf, 99);
#if STRFTIME_EXT
if (ti->qC >= 0)
{
SetYear: ti->qY = ti->qC * 100 + ti->qy;
goto CleanCy;
}
#endif
if (ti->qY >= 0)
{
ti->qY = ti->qY - ti->qY % 100 + ii;
goto CleanCy;
}
break;
case 'Y':
ti->qY = ii = addthem ? scan_int2(buf) : scan_int(buf, 9999);
CleanCy: ti->qC = ti->qy = -1; break;
#if STRFTIME_EXT
case 'Z': /* STRFTIME_EXT */
ti->qZ = ii = scan_word(buf, /*!daylight? 1:*/ 2, tzname, NULL) +1;
if (!ii)
while((ii = **buf) && !isspace(ii)
/*&& !isdigit(ii) && !strchr("+-,", ii)*/
) (*buf)++;
break;
#endif
/* case '%': */
default: /**************************/ goto Other;
} /* end of switch() */
if (ii < 0) return -1;
} /* end of else, for() */
FmtEnd:
return 0;
}
typedef void (*specoper)(int* one, int two);
void justreplace(int* one, int two){
*one = two;
}
void justadd(int* one, int two){
*one += two;
}
char *strptime(const char *buf, const char *fmt, struct tm *tm, short addthem)
{
specoper defoper = addthem ? justadd : justreplace;
struct tm_int ti;
ti.qS = /* Seconds (0...61) */
ti.qM = /* Minutes (0...59) */
ti.qH = /* Hour (0...23) */
ti.qI = /* Hour (1...12) */
ti.qp = /* 0 = AM, 1 = PM */
ti.qd = /* Day of month (1...31)=>[0...30] */
ti.qm = /* Month (1...12)=>[0...11] */
ti.qY = /* Year (0...9999) */
ti.qy = /* year (0...99) */
ti.qC = /* Century (0...99) */
ti.qw = /* Weekday (0...6; Sunday = 0) */
ti.qj = /* Day of year (1..366)=>[0...365] */
ti.qZ = /* 0 = STD, 1 = DST */
ti.qU = /* week in year (0...53) */
ti.qV = -1; /* week in year mode: 0=U, 1=W, 2=V */
if (0 > time_int(&ti, (const unsigned char **)&buf, fmt, addthem)) buf = NULL;
if (0 <= ti.qS) (*defoper) ( &tm->tm_sec , ti.qS );
if (0 <= ti.qM) (*defoper) ( &tm->tm_min , ti.qM ); //tm->tm_min = ti.qM;
if (0 <= ti.qI)
if (0 <= ti.qp) ti.qH = ti.qI % 12 + ti.qp * 12;
else (*defoper) ( &tm->tm_hour , ti.qI ); //tm->tm_hour = ti.qI;
if (0 <= ti.qH) (*defoper) ( &tm->tm_hour , ti.qH ); //tm->tm_hour = ti.qH;
if (0 <= ti.qZ) (*defoper) ( &tm->tm_isdst , ti.qZ - 1 ); //tm->tm_isdst = ti.qZ - 1;
if (0 <= ti.qy) ti.qY = ti.qy;
if (0 <= ti.qY) (*defoper) ( &tm->tm_year ,
ti.qY +=
(ti.qY > 99? -1900:
(ti.qY < 70? 100: 0)) );
/*tm->tm_year = ti.qY +=
(ti.qY > 99? -1900:
(ti.qY < 70? 100: 0));*/
/* ti.qC = %C = Century without an Year - ignored */
if (70 <= ti.qY && ti.qY < 200) /* a representable year */
{
/* 01-01-70 was Thursday, 1968 was leap */
int day = (((ti.qY - 69) >> 2) + ti.qY - 70 + 4) % 7;
/* 2100 wrongly assumed as leap!
if (ti.qY > 200 && --day < 0) day = 6; */
if (0 <= ti.qU && 0 <= ti.qw && 0 > ti.qj)
{
ti.qj = ti.qU * 7;
switch(ti.qV)
{
case 'U': /* %U Sun first */
ti.qj += ti.qw - (day == 0 ? 7: day);
break;
case 'W': /* %W Mon first */
ti.qj += (ti.qw + 6) % 7
- (day == 1 ? 7: (day + 6) % 7);
break;
#if STRFTIME_EXT && 0
case 'V': /* %V >= 4 day */
if (ti.qU == 53) ti.qj = 0;
/* Sun first: */
ti.qj += ti.qw - (day < 4 ? 7: 0) - day;
/* Mon first:
ti.qj += (ti.qw + 6) % 7
- ((day + 6) % 7 < 5 ? 7: 0)
- (day + 6) % 7; */
break;
#endif
default: break;
}
}
#if 0 /* Advanced validating for yday<>m/d/y */
if (0 <= ti.qj)
{
static int m_days[12] =
{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
int mon = (ti.qj + day) % 7;
if (0 > ti.qw) ti.qw = mon;
else if (ti.qw != mon) return NULL;
for(mon = 11; 0 > (day = /* not for 2100: && ti.qY != 200 */
ti.qj - (m_days[mon] + (mon > 1 && !(ti.qY & 3))))
; mon--);
if (0 > ti.qd) ti.qd = day;
else if (ti.qd != day) return NULL;
if (0 > ti.qm) ti.qm = mon;
else if (ti.qm != mon) return NULL;
}
#endif
}
if (0 <= ti.qd) (*defoper) ( &tm->tm_mday , ti.qd + 1 ); //tm->tm_mday = ti.qd + 1;
if (0 <= ti.qm) (*defoper) ( &tm->tm_mon , ti.qm ); //tm->tm_mon = ti.qm;
if (0 <= ti.qw) (*defoper) ( &tm->tm_wday , ti.qw ); //tm->tm_wday = ti.qw;
if (0 <= ti.qj) (*defoper) ( &tm->tm_yday , ti.qj ); //tm->tm_yday = ti.qj;
return (char*)buf;
}
/* end of strftime.c */

271
amxmodx/util.cpp Executable file
View File

@ -0,0 +1,271 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
int UTIL_ReadFlags(const char* c)
{
int flags = 0;
while (*c) flags |= ( 1 << ( *c++ - 'a' ) );
return flags;
}
void UTIL_GetFlags(char* f,int a)
{
for(int i='a';i<='z';++i){
if ( a & 1 ) *f++ = i;
a >>= 1;
}
*f = 0;
}
/* warning - don't pass here const string */
void UTIL_ShowMenu( edict_t* pEdict, int slots, int time, char *menu, int mlen )
{
char *n = menu;
char c = 0;
int a;
while ( *n ) {
a = mlen;
if ( a > 175 ) a = 175;
mlen -= a;
c = *(n+=a);
*n = 0;
MESSAGE_BEGIN( MSG_ONE , gmsgShowMenu, NULL, pEdict );
WRITE_SHORT( slots );
WRITE_CHAR( time );
WRITE_BYTE( c ? TRUE : FALSE);
WRITE_STRING( menu );
MESSAGE_END();
*n = c;
menu = n;
}
}
/* warning - don't pass here const string */
void UTIL_ShowMOTD( edict_t *client , char *motd, int mlen, const char *name)
{
MESSAGE_BEGIN( MSG_ONE , gmsgServerName, NULL, client );
WRITE_STRING(name);
MESSAGE_END();
char *n = motd;
char c = 0;
int a;
while ( *n ) {
a = mlen;
if ( a > 175 ) a = 175;
mlen -= a;
c = *(n+=a);
*n = 0;
MESSAGE_BEGIN( MSG_ONE , gmsgMOTD, NULL, client );
WRITE_BYTE( c ? FALSE : TRUE );
WRITE_STRING( motd );
MESSAGE_END();
*n = c;
motd = n;
}
MESSAGE_BEGIN( MSG_ONE , gmsgServerName, NULL, client );
WRITE_STRING( hostname->string );
MESSAGE_END();
}
void UTIL_IntToString(int value, char *output)
{
static const char *words[] = {"zero ","one ","two ","three ","four ",
"five ", "six ","seven ","eight ","nine ","ten ",
"eleven ","twelve ","thirteen ","fourteen ","fifteen ",
"sixteen ","seventeen ","eighteen ","nineteen ",
"twenty ","thirty ","fourty ", "fifty ","sixty ",
"seventy ","eighty ","ninety ",
"hundred ","thousand "};
*output = 0;
if (value < 0) value = -value;
int tho = value / 1000;
int aaa = 0;
if (tho){
aaa += sprintf(&output[aaa], words[ tho ] );
aaa += sprintf(&output[aaa], words[29] );
value = value % 1000;
}
int hun = value / 100;
if (hun) {
aaa += sprintf(&output[aaa], words[ hun ] );
aaa += sprintf(&output[aaa], words[28] );
value = value % 100;
}
int ten = value / 10;
int unit = value % 10;
if ( ten )
aaa += sprintf(&output[aaa], words[ ( ten > 1 ) ? ( ten + 18 ) : ( unit + 10 ) ] );
if ( ten != 1 && ( unit || (!value && !hun && !tho) ) )
sprintf(&output[aaa], words[ unit ] );
}
char* UTIL_SplitHudMessage(const char *src)
{
static char message[512];
short b = 0, d = 0, e = 0, c = -1;
while ( src[ d ] && e < 480 ) {
if ( src[ d ] == ' ' ) {
c = e;
}
else if ( src[ d ] == '\n' ) {
c = -1;
b = 0;
}
message[ e++ ] = src[ d++ ];
if ( ++b == 69 ) {
if ( c == -1 ) {
message[ e++ ] = '\n';
b = 0;
}
else {
message[ c ] = '\n';
b = e - c - 1;
c = -1;
}
}
}
message[ e ] = 0;
return message;
}
unsigned short FixedUnsigned16( float value, float scale )
{
int output = value * scale;
if ( output < 0 )
output = 0;
else if ( output > 0xFFFF )
output = 0xFFFF;
return (unsigned short)output;
}
short FixedSigned16( float value, float scale )
{
int output = value * scale;
if ( output > 32767 )
output = 32767;
else if ( output < -32768 )
output = -32768;
return (short)output;
}
void UTIL_HudMessage(edict_t *pEntity, const hudtextparms_t &textparms, char *pMessage)
{
if ( pEntity )
MESSAGE_BEGIN( MSG_ONE_UNRELIABLE, SVC_TEMPENTITY, NULL, pEntity );
else
MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
WRITE_BYTE(29);
WRITE_BYTE(textparms.channel & 0xFF);
WRITE_SHORT(FixedSigned16(textparms.x, (1<<13) ));
WRITE_SHORT(FixedSigned16(textparms.y, (1<<13) ));
WRITE_BYTE(textparms.effect);
WRITE_BYTE(textparms.r1);
WRITE_BYTE(textparms.g1);
WRITE_BYTE(textparms.b1);
WRITE_BYTE(0);
WRITE_BYTE(255);
WRITE_BYTE(255);
WRITE_BYTE(250);
WRITE_BYTE(0);
WRITE_SHORT(FixedUnsigned16(textparms.fadeinTime, (1<<8) ));
WRITE_SHORT(FixedUnsigned16(textparms.fadeoutTime, (1<<8) ));
WRITE_SHORT(FixedUnsigned16(textparms.holdTime, (1<<8) ));
if (textparms.effect==2)
WRITE_SHORT(FixedUnsigned16(textparms.fxTime, (1<<8) ) );
WRITE_STRING(pMessage);
MESSAGE_END();
}
/* warning - buffer of msg must be longer than 190 chars!
(here in AMX it is always longer) */
void UTIL_ClientPrint( edict_t *pEntity, int msg_dest, char *msg )
{
char c = msg[190];
msg[190] = 0; // truncate without checking with strlen()
if ( pEntity )
MESSAGE_BEGIN( MSG_ONE, gmsgTextMsg, NULL, pEntity );
else
MESSAGE_BEGIN( MSG_BROADCAST , gmsgTextMsg);
WRITE_BYTE( msg_dest );
WRITE_STRING( msg );
MESSAGE_END();
msg[190] = c;
}
void UTIL_FakeClientCommand(edict_t *pEdict, const char *cmd, const char *arg1, const char *arg2) {
if (!cmd) return;
//strncpy(g_fakecmd.argv[0], cmd, 127 );
//g_fakecmd.argv[0][ 127 ] = 0;
g_fakecmd.argv[0] = cmd;
if (arg2){
g_fakecmd.argc = 3;
g_fakecmd.argv[1] = arg1;
g_fakecmd.argv[2] = arg2;
snprintf( g_fakecmd.args ,255 , "%s %s",arg1,arg2 );
g_fakecmd.args[255] = 0;
//strncpy(g_fakecmd.argv[1], arg1 , 127 );
//g_fakecmd.argv[1][ 127 ] = 0;
//strncpy(g_fakecmd.argv[2], arg2 , 127 );
//g_fakecmd.argv[2][ 127 ] = 0;
//snprintf(g_fakecmd.args, 255 , "%s %s",arg1,arg2);
//g_fakecmd.args[255] = 0;
}
else if (arg1){
g_fakecmd.argc = 2;
g_fakecmd.argv[1] = arg1;
snprintf( g_fakecmd.args ,255 , "%s" , arg1 );
g_fakecmd.args[255] = 0;
//strncpy(g_fakecmd.argv[1], arg1, 127 );
//g_fakecmd.argv[1][ 127 ] = 0;
//*g_fakecmd.argv[2] = 0;
//snprintf(g_fakecmd.args, 255 ,"%s",arg1);
//g_fakecmd.args[255] = 0;
}
else
g_fakecmd.argc = 1;
g_fakecmd.fake = true;
MDLL_ClientCommand(pEdict);
g_fakecmd.fake = false;
}

85
amxmodx/vault.cpp Executable file
View File

@ -0,0 +1,85 @@
/*
* Copyright (c) 2002-2003 Aleksander Naszko
*
* This file is part of AMX Mod.
*
* AMX Mod is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* AMX Mod is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with AMX Mod; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*
*/
#include <extdll.h>
#include <meta_api.h>
#include "CVault.h"
#include "amxmod.h"
Vault g_vault;
static cell AMX_NATIVE_CALL set_vaultdata(AMX *amx,cell *params)
{
int iLen;
g_vault.put( get_amxstring(amx,params[1],0,iLen) , get_amxstring(amx,params[2],1,iLen) );
g_vault.saveVault();
return 1;
}
static cell AMX_NATIVE_CALL get_vaultdata(AMX *amx,cell *params)
{
int iLen;
const char* key = get_amxstring(amx,params[1],0,iLen);
if ( params[3] )
return set_amxstring( amx , params[2] , g_vault.get( key ) , params[3] );
return g_vault.get_number( key );
}
static cell AMX_NATIVE_CALL remove_vaultdata(AMX *amx,cell *params)
{
int iLen;
g_vault.remove( get_amxstring(amx,params[1],0,iLen) );
g_vault.saveVault();
return 1;
}
static cell AMX_NATIVE_CALL vaultdata_exists(AMX *amx,cell *params)
{
int iLen;
return g_vault.exists( get_amxstring(amx,params[1],0,iLen) ) ? 1 : 0;
}
AMX_NATIVE_INFO vault_Natives[] = {
{ "set_vaultdata", set_vaultdata },
{ "get_vaultdata", get_vaultdata },
{ "remove_vaultdata", remove_vaultdata },
{ "delete_vaultdata", remove_vaultdata },
{ "vaultdata_exists", vaultdata_exists },
{ 0, 0 }
};

70
configs/amx.cfg Executable file
View File

@ -0,0 +1,70 @@
// AMX Configuration File
echo Executing AMX Configuration File
// Default access for all non admin players (see users.ini for access details)
amx_default_access ""
// Name of setinfo which should store a password on a client
// (Example: setinfo _pw "password")
amx_password_field "_pw"
// Mode of logging to a server
// 0 - disable logging, players won't be checked (and access won't be set)
// 1 - normal mode which obey flags set in accounts
// 2 - kick all players not on list
amx_mode 1
// Show admins activity
// 0 - disabled
// 1 - show without admin name
// 2 - show with name
amx_show_activity 2
// Frequency in seconds and text of scrolling message
amx_scrollmsg "Welcome to %hostname% -- This server is using AMX" 600
// Center typed colored messages (last parameter is a color in RRRGGGBBB format)
amx_imessage "Welcome to %hostname%" "000255100"
amx_imessage "This server is using AMX\nVisit http://amxmod.net" "000100255"
// Frequency in seconds of colored messages
amx_freq_imessage 180
// Set in seconds how fast players can chat (chat-flood protection)
amx_flood_time 0.75
// Amount of reserved slots (for more details see comments in a plugin source)
amx_reservation 2
// Displaying of time remaining
// a - display white text on bottom
// b - use voice
// c - don't add "remaining" (only in voice)
// d - don't add "hours/minutes/seconds" (only in voice)
// e - show/speak if current time is less than this set in parameter
amx_time_display "ab 1200" "ab 600" "ab 300" "ab 180" "ab 60" "bcde 11"
// Announce "say thetime" and "say timeleft" with voice
amx_time_voice 1
// Minimum delay in seconds between two voting sessions
amx_vote_delay 10
// How long voting session goes on
amx_vote_time 10
// Display who votes for what option
amx_vote_answers 1
// Some ratios for voting success
amx_votekick_ratio 0.40
amx_voteban_ratio 0.40
amx_votemap_ratio 0.40
amx_vote_ratio 0.02
// Max. time to which map can be extended
amx_extendmap_max 90
// Step for each extending
amx_extendmap_step 15

18
configs/clcmds.ini Executable file
View File

@ -0,0 +1,18 @@
; Client commands configuration file
; File location: $moddir/addons/amx/clcmds.ini
; To use with Players Menu plugin
; NOTE: By default in all settings the access level is set to "u".
; However you can change that, to limit the access to some settings.
; Client Commands Menu:
; < description > < command > < flags > < access level >
; "a" - execute from server console
; "b" - execute from admin console
; "c" - execute on selected player
; "d" - back to menu when executed
"Kick player" "amx_kick #%userid%" "b" "u"
"Slay player" "amx_slay #%userid%" "bd" "u"
"Slap with 1 dmg." "amx_slap #%userid% 1" "b" "u"
"Ban on 5 minutes" "amx_banip 5 #%userid%" "b" "u"

17
configs/cmds.ini Executable file
View File

@ -0,0 +1,17 @@
; Menu configuration file
; File location: $moddir/addons/amx/cmds.ini
; To use with Commands Menu plugin
; NOTE: By default in all settings the access level is set to "u".
; However you can change that, to limit the access to some settings.
; Commands Menu:
; < description > < command > < flags > < access level >
; "a" - execute from server console
; "b" - execute from admin console
; "c" - execute on all clients
; "d" - back to menu when executed
"Pause" "amx_pause" "ad" "u"
" " "-" "" "u"
"Restart Round" "sv_restartround 1" "a" "u"

22
configs/configs.ini Executable file
View File

@ -0,0 +1,22 @@
; Menu configuration file
; File location: $moddir/addons/amx/configs.ini
; To use with Commands Menu plugin
; NOTE: By default in all settings the access level is set to "u".
; However you can change that, to limit the access to some settings.
; Commands Menu:
; < description > < command > < flags > < access level >
; "a" - execute from server console
; "b" - execute from admin console
; "c" - execute on all clients
; "d" - back to menu when executed
"PUBLIC Settings" "servercfgfile server.cfg;exec server.cfg" "a" "u"
"Clanbase" "exec clanbase.cfg;servercfgfile \'\'" "a" "u"
"Clanbase Charges Only" "exec clanbase_co.cfg;servercfgfile \'\'" "a" "u"
"Official CAL Match" "exec cal.cfg;servercfgfile \'\'" "a" "u"
"ProvingGrounds Server Config" "exec leagues/pg.cfg;servercfgfile \'\'" "a" "u"
"OGL CS Server Config" "exec ogl.cfg;servercfgfile \'\'" "a" "u"
"OGL CS FF Server Config" "exec ogl_ff.cfg;servercfgfile \'\'" "a" "u"
"OGL CS Advanced Server Config" "exec ogl_adv.cfg;servercfgfile \'\'" "a" "u"

1
configs/conmotd.txt Executable file
View File

@ -0,0 +1 @@
For newest AMX Mod and many plugins visit http://amxmod.net

7
configs/core.ini Executable file
View File

@ -0,0 +1,7 @@
; Configuration file for AMX
amx_logdir addons/amx/logs
amx_modules addons/amx/modules.ini
amx_plugins addons/amx/plugins/plugins.ini
amx_vault addons/amx/vault.ini
csstats_score addons/amx/csstats.amx
csstats addons/amx/csstats.dat

23
configs/cvars.ini Executable file
View File

@ -0,0 +1,23 @@
; Menu configuration file
; File location: $moddir/addons/amx/cvars.ini
; To use with Commands Menu plugin
; Cvars Menu:
; < cvar > < values > ... < access level >
"mp_timelimit" "0" "30" "45" "u"
"mp_friendlyfire" "0" "1" "u"
"mp_autoteambalance" "0" "1" "2" "u"
"sv_password" "" roxor "clanwar" "u"
"mp_limitteams" "0" "1" "2" "u"
"mp_freezetime" 0 "6" "u"
"mp_buytime" "1" "0.5" "u"
"mp_startmoney" "800" "1800" "3600" "u"
"mp_c4timer" "35" "45" "15" "u"
"mp_forcechasecam" "0" "1" "2" "u"
"pausable" 0 1 "u"
"sv_minrate" "2000" "3000" "u"
"sv_maxrate" "7000" "6500" "u"
"allow_spectators" "0" "1" "u"
"sv_voiceenable" "0" "1" "u"
"mp_logmessages" "0" "1" "u"

30
configs/maps.ini Executable file
View File

@ -0,0 +1,30 @@
; Maps configuration file
; File location: $moddir/addons/amx/maps.ini
; To use with Maps Menu plugin
as_oilrig "OilRig - Assassination"
as_tundra "Tundra - Assassination"
de_aztec "Aztec - Bomb/Defuse"
de_cbble "Cobble - Bomb/Defuse"
de_chateau "Chateau - Bomb/Defuse"
de_dust "Dust - Bomb/Defuse"
de_dust2 "Dust II - Bomb/Defuse"
de_inferno "Inferno - Bomb/Defuse"
de_nuke "Nuke - Bomb/Defuse"
de_prodigy "Prodigy - Bomb/Defuse"
de_storm "Storm - Bomb/Defuse"
de_survivor "Survivor - Bomb/Defuse"
de_train "Trainyard - Bomb/Defuse"
de_torn "Torn - Bomb/Defuse"
de_vegas "Vegas - Bomb/Defuse"
de_vertigo "Vertigo - Bomb/Defuse"
cs_747 "747 Hijack - Hostage Rescue"
cs_assault "Assault - Hostage Rescue"
cs_backalley "Alleyway - Hostage Rescue"
cs_estate "Zaphod's Estate - Hostage Rescue"
cs_havana "Havana - Hostage Rescue"
cs_italy "Italy - Hostage Rescue"
cs_militia "Militia - Hostage Rescue"
cs_office "The Office Complex - Hostage Rescue"
cs_siege "Canyon Siege - Hostage Rescue"

14
configs/modules.ini Executable file
View File

@ -0,0 +1,14 @@
; AMX Modules
; You can specify both linux & win32 modules here
; CS Stats
addons/amx/dlls/csstats_mm.dll
addons/amx/dlls/csstats_mm_i386.so
; More functions for modifications in HL
addons/amx/dlls/fun_mm.dll
addons/amx/dlls/fun_mm_i386.so
; MySQL access
;addons/amx/dlls/mysql.dll
;addons/amx/dlls/mysql_i386.so

10
configs/mysql.cfg Executable file
View File

@ -0,0 +1,10 @@
// MySQL access configuration file
// File location: $moddir/addons/amx
// *NOTE* Linux users may encounter problems if they specify "localhost" instead of "127.0.0.1"
// We recommend using your server IP address instead of its name
amx_mysql_host "127.0.0.1"
amx_mysql_user "root"
amx_mysql_pass ""
amx_mysql_db "amx"

26
configs/plugins.ini Executable file
View File

@ -0,0 +1,26 @@
; AMX Mod plugins
admin.amx ; admin base (required for any admin-related)
;admin_mysql.amx ; admin base - MySQL version (comment admin.amx)
admincmd.amx ; basic admin console commands
adminhelp.amx ; help command for admin console commands
adminslots.amx ; slot reservation
menufront.amx ; front-end for admin menus
cmdmenu.amx ; command menu (speech, settings)
plmenu.amx ; players menu (kick, ban, client cmds.)
restmenu.amx ; restrict weapons menu
mapsmenu.amx ; maps menu (vote, changelevel)
antiflood.amx ; prevent clients from chat-flooding the server
adminchat.amx ; console chat commands
adminvote.amx ; vote commands
nextmap.amx ; displays next map in mapcycle
timeleft.amx ; displays time left on map
mapchooser.amx ; allows to vote for next map
scrollmsg.amx ; displays a scrolling message
imessage.amx ; displays information messages
pausecfg.amx ; allows to pause and unpause some plugins
;telemenu.amx ; teleport menu (Fun Module required!)
stats.amx ; stats on death or round end (CSStats Module required!)
stats_logging.amx ; weapons stats logging (CSStats Module required!)
miscstats.amx ; bunch of events announcement for Counter-Strike
statscfg.amx ; allows to manage stats plugins via menu and commands

35
configs/speech.ini Executable file
View File

@ -0,0 +1,35 @@
; Menu configuration file
; File location: $moddir/addons/amx/speech.ini
; To use with Commands Menu plugin
; NOTE: By default in all settings the access level is set to "u".
; However you can change that, to limit the access to some settings.
; Commands Menu:
; < description > < command > < flags > < access level >
; "a" - execute from server console
; "b" - execute from admin console
; "c" - execute on all clients
; "d" - back to menu when executed
"Hello!" "spk \'vox/hello\'" "cd" "u"
"Don't think so" "spk \'barney/dontguess\'" "cd" "u"
"Don't ask me" "spk \'barney/dontaskme\'" "cd" "u"
"Hey! Stop that!" "spk \'barney/donthurtem\'" "cd" "u"
"Yup" "spk \'barney/yup\'" "cd" "u"
"Nope" "spk \'barney/nope\'" "cd" "u"
"Maybe" "spk \'barney/maybe\'" "cd" "u"
"Seeya" "spk \'barney/seeya\'" "cd" "u"
"Man that sounded bad" "spk \'barney/soundsbad\'" "cd" "u"
"Hello and die" "spk \'vox/hello and die\'" "cd" "u"
"Move!" "spk \'hgrunt/move! _comma yessir!\'" "cd" "u"
"You will definitely pay!" "spk \'hgrunt/c2a2_hg_chat5a\'" "cd" "u"
"Laughter" "spk \'hgrunt/c2a3_hg_laugh\'" "cd" "u"
"Silence!" "spk \'hgrunt/silence!\'" "cd" "u"
"You talk too much" "spk \'barney/youtalkmuch\'" "cd" "u"
"You thinkin?" "spk \'barney/thinking\'" "cd" "u"
"Open fire Gordon!" "spk \'barney/openfire\'" "cd" "u"
"Couldnt make a bigger mess" "spk \'barney/bigmess\'" "cd" "u"
"I have a Bad feeling" "spk \'barney/badfeeling\'" "cd" "u"
"Yes sir!" "spk \'hgrunt/yessir!\'" "cd" "u"
"No sir" "spk \'barney/nosir\'" "cd" "u"

42
configs/users.ini Executable file
View File

@ -0,0 +1,42 @@
; Line starting with ; is a comment
; Access flags:
; a - immunity (can't be kicked/baned/slayed/slaped and affected by other commmands)
; b - reservation (can join on reserved slots)
; c - amx_kick command
; d - amx_ban and amx_unban commands
; e - amx_slay and amx_slap commands
; f - amx_map command
; g - amx_cvar command (not all cvars will be available)
; h - amx_cfg command
; i - amx_chat and other chat commands
; j - amx_vote and other vote commands
; k - access to sv_password cvar (by amx_cvar command)
; l - access to amx_rcon command and rcon_password cvar (by amx_cvar command)
; m - custom level A (for additional plugins)
; n - custom level B
; o - custom level C
; p - custom level D
; q - custom level E
; r - custom level F
; s - custom level G
; t - custom level H
; u - menu access
; z - user
; Account flags:
; a - disconnect player on invalid password
; b - clan tag
; c - this is steamid
; d - this is ip
; e - password is not checked (only name/ip/steamid needed)
; Format of admin account:
; <name|ip|steamid> <password> <access flags> <account flags>
; Examples of admin accounts:
; "123.43.43.53" "" "abcdefghijklmnopqrstu" "de"
; "STEAM_0:0:14332" "my_password" "abcdefgnstu" "c"
; "My Name" "my_password" "abcdefghijklmnopqrstu" "a"
"loopback" "" "abcdefghijklmnopqrstu" "de"

202
plugins/admin.sma Executable file
View File

@ -0,0 +1,202 @@
/* AMX Mod script.
*
* (c) 2003, OLO
* This file is provided as is (no warranties).
*/
#include <amxmod>
#include <amxmisc>
#define MAX_ADMINS 64
new g_aPassword[MAX_ADMINS][32]
new g_aName[MAX_ADMINS][32]
new g_aFlags[MAX_ADMINS]
new g_aAccess[MAX_ADMINS]
new g_aNum
new g_logFile[16]
#if !defined NO_STEAM
new g_cmdLoopback[16]
#endif
public plugin_init()
{
register_plugin("Admin Base","0.9","default")
register_cvar("amx_mode","2.0")
register_cvar("amx_password_field","_pw")
register_cvar("amx_default_access","")
get_logfile(g_logFile,15)
#if !defined NO_STEAM
format( g_cmdLoopback, 15, "amxauth%c%c%c%c" ,
random_num('A','Z') , random_num('A','Z') ,random_num('A','Z'),random_num('A','Z') )
register_clcmd( g_cmdLoopback, "ackSignal" )
#endif
remove_user_flags(0,read_flags("z")) // Remove 'user' flag from server rights
new filename[64]
get_basedir( filename , 31 )
server_cmd("exec %s/amx.cfg" , filename ) // Execute main configuration file
format( filename, 63 , "%s/users.ini" , filename )
loadSettings( filename ) // Load admins accounts
}
loadSettings(szFilename[])
{
if (!file_exists(szFilename)) return 0
new szText[256], szFlags[32], szAccess[32]
new a, pos = 0
while ( g_aNum < MAX_ADMINS && read_file(szFilename,pos++,szText,255,a) )
{
if ( szText[0] == ';' ) continue
if ( parse(szText, g_aName[ g_aNum ] ,31,
g_aPassword[ g_aNum ], 31, szAccess,31,szFlags,31 ) < 2 ) continue
g_aAccess[ g_aNum ] = read_flags( szAccess )
g_aFlags[ g_aNum ] = read_flags( szFlags )
++g_aNum
}
return 1
}
getAccess(id,name[],authid[],ip[], password[])
{
new index = -1
new result = 0
for(new i = 0; i < g_aNum; ++i) {
if (g_aFlags[i] & FLAG_AUTHID) {
if (equal(authid,g_aName[i])) {
index = i
break
}
}
else if (g_aFlags[i] & FLAG_IP) {
new c = strlen( g_aName[i] )
if ( g_aName[i][ c - 1 ] == '.' ) { /* check if this is not a xxx.xxx. format */
if ( equal( g_aName[i] , ip , c ) ) {
index = i
break
}
} /* in other case an IP must just match */
else if ( equal(ip,g_aName[i]) ){
index = i
break
}
}
else {
if (g_aFlags[i] & FLAG_TAG) {
if (contain(name,g_aName[i])!=-1){
index = i
break
}
}
else if (equal(name,g_aName[i])) {
index = i
break
}
}
}
if (index != -1) {
if (g_aFlags[index] & FLAG_NOPASS){
result |= 8
new sflags[32]
get_flags(g_aAccess[index],sflags,31)
set_user_flags(id,g_aAccess[index])
log_to_file(g_logFile,"Login: ^"%s<%d><%s><>^" become an admin (account ^"%s^") (access ^"%s^") (address ^"%s^")",
name,get_user_userid(id),authid,g_aName[index] ,sflags,ip)
}
else if (equal(password,g_aPassword[index])) {
result |= 12
set_user_flags(id,g_aAccess[index])
new sflags[32]
get_flags(g_aAccess[index],sflags,31)
log_to_file(g_logFile,"Login: ^"%s<%d><%s><>^" become an admin (account ^"%s^") (access ^"%s^") (address ^"%s^")",
name,get_user_userid(id),authid,g_aName[index] ,sflags,ip)
}
else {
result |= 1
if (g_aFlags[index] & FLAG_KICK){
result |= 2
log_to_file(g_logFile,"Login: ^"%s<%d><%s><>^" kicked due to invalid password (account ^"%s^") (address ^"%s^")",
name,get_user_userid(id),authid,g_aName[index],ip)
}
}
}
else if (get_cvar_float("amx_mode")==2.0) {
result |= 2
}
else {
new defaccess[32]
get_cvar_string("amx_default_access",defaccess,31)
new idefaccess = read_flags(defaccess)
if (idefaccess){
result |= 8
set_user_flags(id,idefaccess)
}
}
return result
}
accessUser( id, name[] = "" )
{
remove_user_flags(id)
new userip[32],userauthid[32],password[32],passfield[32],username[32]
get_user_ip(id,userip,31,1)
get_user_authid(id,userauthid,31)
if ( name[0] ) copy( username , 31, name)
else get_user_name(id,username,31 )
get_cvar_string("amx_password_field",passfield,31)
get_user_info(id,passfield,password,31)
new result = getAccess(id,username,userauthid,userip,password)
if (result & 1) client_cmd(id,"echo ^"* Invalid Password!^"")
if (result & 2) {
#if !defined NO_STEAM
client_cmd(id,"echo ^"* You have no entry to the server...^";%s",g_cmdLoopback)
#else
client_cmd(id,"echo ^"* You have no entry to the server...^";disconnect")
#endif
return PLUGIN_HANDLED
}
if (result & 4) client_cmd(id,"echo ^"* Password accepted^"")
if (result & 8) client_cmd(id,"echo ^"* Privileges set^"")
return PLUGIN_CONTINUE
}
public client_infochanged(id)
{
if ( !is_user_connected(id) || !get_cvar_num("amx_mode") )
return PLUGIN_CONTINUE
new newname[32], oldname[32]
get_user_name(id,oldname,31)
get_user_info(id,"name",newname,31)
if ( !equal(newname,oldname) )
accessUser( id, newname )
return PLUGIN_CONTINUE
}
#if !defined NO_STEAM
public ackSignal(id)
server_cmd("kick #%d", get_user_userid(id) )
public client_authorized(id)
#else
public client_connect(id)
#endif
return get_cvar_num( "amx_mode" ) ? accessUser( id ) : PLUGIN_CONTINUE

234
plugins/admin_mysql.sma Executable file
View File

@ -0,0 +1,234 @@
/* AMX Mod script.
*
* (c) 2003, dJeyL
* This file is provided as is (no warranties).
*
* This AMX plugin requires MySQL module.
*
* For this to work, you might create your MySQL admins table with this SQL query :
CREATE TABLE admins (
auth varchar(32) NOT NULL default '',
password varchar(32) NOT NULL default '',
access varchar(32) NOT NULL default '',
flags varchar(32) NOT NULL default ''
) TYPE=MyISAM;
* IMPORTANT:
* o Check $moddir/addons/amx/mysql.cfg for MySQL access configuration
* o Disable admin.amx plugin if you use admin_mysql.amx
*
*/
#include <amxmod>
#include <amxmisc>
#include <mysql>
#define MAX_ADMINS 64
new g_aPassword[MAX_ADMINS][32]
new g_aName[MAX_ADMINS][32]
new g_aFlags[MAX_ADMINS]
new g_aAccess[MAX_ADMINS]
new g_aNum
new g_logFile[16]
#if !defined NO_STEAM
new g_cmdLoopback[16]
#endif
public plugin_init()
{
register_plugin("Admin Base for MySQL","0.9","default")
register_cvar("amx_mode","2.0")
register_cvar("amx_password_field","_pw")
register_cvar("amx_default_access","")
register_srvcmd("amx_sqladmins","adminSql")
register_cvar("amx_mysql_host","127.0.0.1")
register_cvar("amx_mysql_user","root")
register_cvar("amx_mysql_pass","")
register_cvar("amx_mysql_db","amx")
#if !defined NO_STEAM
format( g_cmdLoopback, 15, "amxauth%c%c%c%c" ,
random_num('A','Z') , random_num('A','Z') ,random_num('A','Z'),random_num('A','Z') )
register_clcmd( g_cmdLoopback, "ackSignal" )
#endif
remove_user_flags(0,read_flags("z")) // remove 'user' flag from server rights
get_logfile(g_logFile,15)
new filename[32]
get_basedir( filename , 31 )
server_cmd("exec %s/amx.cfg" , filename)
server_cmd("exec %s/mysql.cfg;amx_sqladmins" , filename)
}
public adminSql(){
new host[64],user[32],pass[32],db[32],error[128]
get_cvar_string("amx_mysql_host",host,63)
get_cvar_string("amx_mysql_user",user,31)
get_cvar_string("amx_mysql_pass",pass,31)
get_cvar_string("amx_mysql_db",db,31)
new mysql = mysql_connect(host,user,pass,db,error,127)
if(mysql < 1){
server_print("MySQL error: can't connect: '%s'",error)
return PLUGIN_HANDLED
}
if(mysql_query(mysql,"SELECT auth,password,access,flags FROM admins") < 1) {
mysql_error(mysql,error,127)
server_print("MySQL error: can't load admins: '%s'",error)
return PLUGIN_HANDLED
}
new szFlags[32], szAccess[32]
g_aNum = 0 /* reset admins settings */
while( mysql_nextrow(mysql) > 0 )
{
mysql_getfield(mysql, 1, g_aName[ g_aNum ] ,31)
mysql_getfield(mysql, 2, g_aPassword[ g_aNum ] ,31)
mysql_getfield(mysql, 3, szAccess,31)
mysql_getfield(mysql, 4, szFlags,31)
g_aAccess[ g_aNum ] = read_flags( szAccess )
g_aFlags[ g_aNum ] = read_flags( szFlags )
++g_aNum
}
server_print("Loaded %d admin%s from database",g_aNum, (g_aNum == 1) ? "" : "s" )
mysql_close(mysql)
return PLUGIN_HANDLED
}
getAccess(id,name[],authid[],ip[], password[]){
new index = -1
new result = 0
for(new i = 0; i < g_aNum; ++i) {
if (g_aFlags[i] & FLAG_AUTHID) {
if (equal(authid,g_aName[i])) {
index = i
break
}
}
else if (g_aFlags[i] & FLAG_IP) {
new c = strlen( g_aName[i] )
if ( g_aName[i][ c - 1 ] == '.' ) { /* check if this is not a xxx.xxx. format */
if ( equal( g_aName[i] , ip , c ) ) {
index = i
break
}
} /* in other case an IP must just match */
else if ( equal(ip,g_aName[i]) ){
index = i
break
}
}
else {
if (g_aFlags[i] & FLAG_TAG) {
if (contain(name,g_aName[i])!=-1){
index = i
break
}
}
else if (equal(name,g_aName[i])) {
index = i
break
}
}
}
if (index != -1) {
if (g_aFlags[index] & FLAG_NOPASS){
result |= 8
new sflags[32]
get_flags(g_aAccess[index],sflags,31)
set_user_flags(id,g_aAccess[index])
log_to_file(g_logFile,"Login: ^"%s<%d><%s><>^" become an admin (account ^"%s^") (access ^"%s^") (address ^"%s^")",
name,get_user_userid(id),authid,g_aName[index] ,sflags,ip)
}
else if (equal(password,g_aPassword[index])) {
result |= 12
set_user_flags(id,g_aAccess[index])
new sflags[32]
get_flags(g_aAccess[index],sflags,31)
log_to_file(g_logFile,"Login: ^"%s<%d><%s><>^" become an admin (account ^"%s^") (access ^"%s^") (address ^"%s^")",
name,get_user_userid(id),authid,g_aName[index] ,sflags,ip)
}
else {
result |= 1
if (g_aFlags[index] & FLAG_KICK){
result |= 2
log_to_file(g_logFile,"Login: ^"%s<%d><%s><>^" kicked due to invalid password (account ^"%s^") (address ^"%s^")",
name,get_user_userid(id),authid,g_aName[index],ip)
}
}
}
else if (get_cvar_float("amx_mode")==2.0) {
result |= 2
}
else {
new defaccess[32]
get_cvar_string("amx_default_access",defaccess,31)
new idefaccess = read_flags(defaccess)
if (idefaccess){
result |= 8
set_user_flags(id,idefaccess)
}
}
return result
}
accessUser( id, name[]="" )
{
remove_user_flags(id)
new userip[32],userauthid[32],password[32],passfield[32],username[32]
get_user_ip(id,userip,31,1)
get_user_authid(id,userauthid,31)
if ( name[0] ) copy( username , 31, name)
else get_user_name(id,username,31 )
get_cvar_string("amx_password_field",passfield,31)
get_user_info(id,passfield,password,31)
new result = getAccess(id,username,userauthid,userip,password)
if (result & 1) client_cmd(id,"echo ^"* Invalid Password!^"")
if (result & 2) {
#if !defined NO_STEAM
client_cmd(id,"echo ^"* You have no entry to the server...^";%s",g_cmdLoopback)
#else
client_cmd(id,"echo ^"* You have no entry to the server...^";disconnect")
#endif
return PLUGIN_HANDLED
}
if (result & 4) client_cmd(id,"echo ^"* Password accepted^"")
if (result & 8) client_cmd(id,"echo ^"* Privileges set^"")
return PLUGIN_CONTINUE
}
public client_infochanged(id)
{
if ( !is_user_connected(id) || !get_cvar_num("amx_mode") )
return PLUGIN_CONTINUE
new newname[32], oldname[32]
get_user_name(id,oldname,31)
get_user_info(id,"name",newname,31)
if ( !equal(newname,oldname) )
accessUser( id , newname )
return PLUGIN_CONTINUE
}
#if !defined NO_STEAM
public ackSignal(id)
server_cmd("kick #%d", get_user_userid(id) )
public client_authorized(id)
#else
public client_connect(id)
#endif
return get_cvar_num( "amx_mode" ) ? accessUser( id ) : PLUGIN_CONTINUE

204
plugins/adminchat.sma Executable file
View File

@ -0,0 +1,204 @@
/* AMX Mod script.
*
* (c) 2003, OLO
* This file is provided as is (no warranties).
*/
#include <amxmod>
#include <amxmisc>
// Uncomment if you want to display
// names with hud messages
//#define SHOW_NAMES
new g_logFile[16]
new g_msgChannel
#define MAX_CLR 7
new g_Colors[MAX_CLR][] = {"white","red","green","blue","yellow","magenta","cyan"}
new g_Values[MAX_CLR][] = {{255,255,255},{255,0,0},{0,255,0},{0,0,255},{255,255,0},{255,0,255},{0,255,255}}
new Float:g_Pos[4][] = {{0.0,0.0},{0.05,0.55},{-1.0,0.2},{-1.0,0.7}}
public plugin_init(){
register_plugin("Admin Chat","0.9","default")
register_clcmd("say_team","cmdSayAdmin",0,"@<text> - displays message to admins")
register_clcmd("say","cmdSayChat",ADMIN_CHAT,"@[@|@|@][w|r|g|b|y|m|c]<text> - displays hud message")
register_concmd("amx_say","cmdSay",ADMIN_CHAT,"<message> - sends message to all players")
register_concmd("amx_chat","cmdChat",ADMIN_CHAT,"<message> - sends message to admins")
register_concmd("amx_psay","cmdPsay",ADMIN_CHAT,"<name or #userid> <message> - sends private message")
register_concmd("amx_tsay","cmdTsay",ADMIN_CHAT,"<color> <message> - sends left side hud message to all players")
register_concmd("amx_csay","cmdTsay",ADMIN_CHAT,"<color> <message> - sends center hud message to all players")
get_logfile(g_logFile,15)
}
public cmdSayChat(id) {
if (!(get_user_flags(id)&ADMIN_CHAT)) return PLUGIN_CONTINUE
new said[6], i=0
read_argv(1,said,5)
while (said[i]=='@')
i++
if ( !i || i > 3 ) return PLUGIN_CONTINUE
new message[192], a = 0
read_argv(1,message,191)
switch(said[i]){
case 'r': a = 1
case 'g': a = 2
case 'b': a = 3
case 'y': a = 4
case 'm': a = 5
case 'c': a = 6
}
new name[32], authid[32], userid
get_user_authid(id,authid,31)
get_user_name(id,name,31)
userid = get_user_userid(id)
log_to_file(g_logFile,"Chat: ^"%s<%d><%s><>^" tsay ^"%s^"",name,userid,authid,message[i+1])
log_message("^"%s<%d><%s><>^" triggered ^"amx_tsay^" (text ^"%s^") (color ^"%s^")",
name,userid,authid,message[ i+1 ],g_Colors[a])
if (++g_msgChannel>6||g_msgChannel<3)
g_msgChannel = 3
new Float:verpos = g_Pos[i][1] + float(g_msgChannel) / 35.0
set_hudmessage(g_Values[a][0], g_Values[a][1], g_Values[a][2],
g_Pos[i][0], verpos , 0, 6.0, 6.0, 0.5, 0.15, g_msgChannel )
#if defined SHOW_NAMES
show_hudmessage(0,"%s : %s",name,message[i+1])
client_print(0,print_notify,"%s : %s",name,message[i+1])
#else
show_hudmessage(0,message[i+1])
client_print(0,print_notify,message[i+1])
#endif
return PLUGIN_HANDLED
}
public cmdSayAdmin(id) {
new said[2]
read_argv(1,said,1)
if (said[0]!='@') return PLUGIN_CONTINUE
new message[192], name[32],authid[32], userid
new players[32], inum
read_argv(1,message,191)
get_user_authid(id,authid,31)
get_user_name(id,name,31)
userid = get_user_userid(id)
log_to_file(g_logFile,"Chat: ^"%s<%d><%s><>^" chat ^"%s^"",name,userid,authid,message[1])
log_message("^"%s<%d><%s><>^" triggered ^"amx_chat^" (text ^"%s^")",name,userid,authid,message[1])
format(message,191,"(ADMINS) %s : %s",name,message[1])
get_players(players,inum)
for(new i=0; i<inum; ++i){
if (players[i] != id && get_user_flags(players[i]) & ADMIN_CHAT)
client_print(players[i],print_chat,message)
}
client_print(id,print_chat,message)
return PLUGIN_HANDLED
}
public cmdChat(id,level,cid){
if (!cmd_access(id,level,cid,2))
return PLUGIN_HANDLED
new message[192], name[32], players[32], inum, authid[32], userid
read_args(message,191)
remove_quotes(message)
get_user_authid(id,authid,31)
get_user_name(id,name,31)
userid = get_user_userid(id)
get_players(players,inum)
log_to_file(g_logFile,"Chat: ^"%s<%d><%s><>^" chat ^"%s^"",name,userid,authid,message)
log_message("^"%s<%d><%s><>^" triggered ^"amx_chat^" (text ^"%s^")",name,userid,authid,message)
format(message,191,"(ADMINS) %s : %s",name,message)
console_print(id,message)
for(new i = 0; i < inum; ++i){
if ( get_user_flags(players[i]) & ADMIN_CHAT )
client_print(players[i],print_chat,message)
}
return PLUGIN_HANDLED
}
public cmdSay(id,level,cid){
if (!cmd_access(id,level,cid,2))
return PLUGIN_HANDLED
new message[192], name[32],authid[32], userid
read_args(message,191)
remove_quotes(message)
get_user_authid(id,authid,31)
get_user_name(id,name,31)
userid = get_user_userid(id)
client_print(0,print_chat,"(ALL) %s : %s",name,message)
console_print(id,"(ALL) %s : %s",name,message)
log_to_file(g_logFile,"Chat: ^"%s<%d><%s><>^" say ^"%s^"", name,userid,authid,message)
log_message("^"%s<%d><%s><>^" triggered ^"amx_say^" (text ^"%s^")",name,userid,authid,message)
return PLUGIN_HANDLED
}
public cmdPsay(id,level,cid){
if (!cmd_access(id,level,cid,3))
return PLUGIN_HANDLED
new name[32]
read_argv(1,name,31)
new priv = cmd_target(id,name,0)
if (!priv) return PLUGIN_HANDLED
new length = strlen(name)+1
new message[192], name2[32],authid[32],authid2[32], userid, userid2
get_user_authid(id,authid,31)
get_user_name(id,name2,31)
userid = get_user_userid(id)
read_args(message,191)
if (message[0]=='"' && message[length]=='"'){// HLSW fix
message[0]=message[length]=' '
length+=2
}
remove_quotes(message[length])
get_user_name(priv,name,31)
if (id&&id!=priv) client_print(id,print_chat,"(%s) %s : %s",name,name2,message[length])
client_print(priv,print_chat,"(%s) %s : %s",name,name2,message[length])
console_print(id,"(%s) %s : %s",name,name2,message[length])
get_user_authid(priv,authid2,31)
userid2 = get_user_userid(priv)
log_to_file(g_logFile,"Chat: ^"%s<%d><%s><>^" psay ^"%s<%d><%s><>^" ^"%s^"",
name2,userid,authid,name,userid2,authid2,message[length])
log_message("^"%s<%d><%s><>^" triggered ^"amx_psay^" against ^"%s<%d><%s><>^" (text ^"%s^")",
name2,userid,authid,name,userid2,authid2,message[length])
return PLUGIN_HANDLED
}
public cmdTsay(id,level,cid){
if (!cmd_access(id,level,cid,3))
return PLUGIN_HANDLED
new cmd[16],color[12], message[192], name[32], authid[32], userid = 0
read_argv(0,cmd,15)
new bool:tsay = (tolower(cmd[4]) == 't')
read_args(message,191)
remove_quotes(message)
parse(message,color,11)
new found = 0,a = 0
for(new i=0;i<MAX_CLR;++i)
if (equal(color,g_Colors[i])) {
a = i
found = 1
break
}
new length = found ? (strlen(color) + 1) : 0
if (++g_msgChannel>6||g_msgChannel<3)
g_msgChannel = 3
new Float:verpos = ( tsay ? 0.55 : 0.1 ) + float(g_msgChannel) / 35.0
get_user_authid(id,authid,31)
get_user_name(id,name,31)
userid = get_user_userid(id)
set_hudmessage(g_Values[a][0], g_Values[a][1], g_Values[a][2], tsay ? 0.05 : -1.0, verpos, 0, 6.0, 6.0, 0.5, 0.15, g_msgChannel)
#if defined SHOW_NAMES
show_hudmessage(0,"%s : %s",name,message[length])
client_print(0,print_notify,"%s : %s",name,message[length])
console_print(id,"%s : %s",name,message[length])
#else
show_hudmessage(0,message[length])
client_print(0,print_notify,message[length])
console_print(id,message[length])
#endif
log_to_file(g_logFile,"Chat: ^"%s<%d><%s><>^" %s ^"%s^"",name,userid,authid,cmd[4],message[length])
log_message("^"%s<%d><%s><>^" triggered ^"%s^" (text ^"%s^") (color ^"%s^")",
name,userid,authid,cmd,message[length],g_Colors[a])
return PLUGIN_HANDLED
}

459
plugins/admincmd.sma Executable file
View File

@ -0,0 +1,459 @@
/* AMX Mod script.
*
* (c) 2003, OLO
* This file is provided as is (no warranties).
*/
#include <amxmod>
#include <amxmisc>
#define MAXRCONCVARS 16
new g_cvarRcon[ MAXRCONCVARS ][32]
new g_cvarRconNum
new g_logFile[16]
new g_pauseCon
new Float:g_pausAble
new bool:g_Paused
new g_addCvar[] = "amx_cvar add %s"
public plugin_init(){
register_plugin("Admin Commands","0.9","default")
register_concmd("amx_kick","cmdKick",ADMIN_KICK,"<name or #userid> [reason]")
register_concmd("amx_ban","cmdAddBan",ADMIN_BAN,"<minutes> <authid or ip> [reason]")
register_concmd("amx_banid","cmdBan",ADMIN_BAN,"<minutes> <name or #userid> [reason]")
register_concmd("amx_banip","cmdBan",ADMIN_BAN,"<minutes> <name or #userid> [reason]")
register_concmd("amx_unban","cmdUnban",ADMIN_BAN,"<authid or ip>")
register_concmd("amx_slay","cmdSlay",ADMIN_SLAY,"<name or #userid>")
register_concmd("amx_slap","cmdSlap",ADMIN_SLAY,"<name or #userid> [power]")
register_concmd("amx_leave","cmdLeave",ADMIN_KICK,"<tag> [tag] [tag] [tag]")
register_concmd("amx_pause","cmdPause",ADMIN_CVAR,"- pause or unpause the game")
register_concmd("amx_who","cmdWho",0,"- displays who is on server")
register_concmd("amx_cvar","cmdCvar",ADMIN_CVAR,"<cvar> [value]")
register_clcmd("amx_map","cmdMap",ADMIN_MAP,"<mapname>")
register_clcmd("pauseAck","cmdLBack")
register_clcmd("amx_cfg","cmdCfg",ADMIN_CFG,"<fliename>")
register_clcmd("amx_rcon","cmdRcon",ADMIN_RCON,"<command line>")
register_cvar("amx_show_activity","2")
register_cvar("amx_vote_delay","")
register_cvar("amx_vote_time","")
register_cvar("amx_vote_answers","")
register_cvar("amx_vote_ratio","")
register_cvar("amx_show_activity","")
get_logfile(g_logFile,15)
}
public plugin_cfg(){
// Cvars which can be changed only with rcon access
server_cmd( g_addCvar ,"rcon_password")
server_cmd( g_addCvar ,"amx_show_activity")
server_cmd( g_addCvar ,"amx_mode")
server_cmd( g_addCvar ,"amx_password_field")
server_cmd( g_addCvar ,"amx_default_access")
server_cmd( g_addCvar ,"amx_reserved_slots")
server_cmd( g_addCvar ,"amx_reservation")
server_cmd( g_addCvar ,"amx_conmotd_file")
}
public cmdKick(id,level,cid){
if (!cmd_access(id,level,cid,2))
return PLUGIN_HANDLED
new arg[32]
read_argv(1,arg,31)
new player = cmd_target(id,arg,1)
if (!player) return PLUGIN_HANDLED
new authid[32],authid2[32],name2[32],name[32],userid2, arg2[32]
get_user_authid(id,authid,31)
get_user_authid(player,authid2,31)
get_user_name(player,name2,31)
get_user_name(id,name,31)
userid2 = get_user_userid(player)
read_argv(2,arg2,31)
log_to_file(g_logFile,"Kick: ^"%s<%d><%s><>^" kick ^"%s<%d><%s><>^" (reason ^"%s^")",
name,get_user_userid(id),authid, name2,userid2,authid2,arg2 )
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"ADMIN %s: kick %s",name,name2)
case 1: client_print(0,print_chat,"ADMIN: kick %s",name2)
}
server_cmd("kick #%d",userid2)
console_print(id,"Client ^"%s^" kicked",name2)
return PLUGIN_HANDLED
}
public cmdUnban(id,level,cid){
if (!cmd_access(id,level,cid,2))
return PLUGIN_HANDLED
new arg[32],authid[32],name[32]
read_argv(1,arg,31)
if (contain(arg,".")!=-1) {
server_cmd("removeip ^"%s^";writeip",arg)
console_print(id,"Ip ^"%s^" removed from ban list", arg )
}
else {
server_cmd("removeid ^"%s^";writeid",arg)
console_print(id,"Authid ^"%s^" removed from ban list", arg )
}
get_user_name(id,name,31)
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"ADMIN %s: unban %s",name,arg)
case 1: client_print(0,print_chat,"ADMIN: unban %s",arg)
}
get_user_authid(id,authid,31)
log_to_file(g_logFile,"Cmd: ^"%s<%d><%s><>^" unban ^"%s^"",
name,get_user_userid(id),authid, arg )
return PLUGIN_HANDLED
}
public cmdAddBan(id,level,cid){
if (!cmd_access(id,level,cid,3))
return PLUGIN_HANDLED
new arg[32],authid[32],name[32],minutes[32],reason[32]
read_argv(1,minutes,31)
read_argv(2,arg,31)
read_argv(3,reason,31)
if (contain(arg,".")!=-1) {
server_cmd("addip ^"%s^" ^"%s^";wait;writeip",minutes,arg)
console_print(id,"Ip ^"%s^" added to ban list", arg )
}
else {
server_cmd("banid ^"%s^" ^"%s^" kick;wait;writeid",minutes,arg)
console_print(id,"Authid ^"%s^" added to ban list", arg )
}
get_user_name(id,name,31)
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"ADMIN %s: ban %s",name,arg)
case 1: client_print(0,print_chat,"ADMIN: ban %s",arg)
}
get_user_authid(id,authid,31)
log_to_file(g_logFile,"Cmd: ^"%s<%d><%s><>^" ban ^"%s^" (minutes ^"%s^") (reason ^"%s^")",
name,get_user_userid(id),authid, arg, minutes, reason )
return PLUGIN_HANDLED
}
public cmdBan(id,level,cid){
if (!cmd_access(id,level,cid,3))
return PLUGIN_HANDLED
new arg[32], cmd[32]
read_argv(0,cmd,31)
read_argv(2,arg,31)
new player = cmd_target(id,arg,9)
if (!player) return PLUGIN_HANDLED
new minutes[32],authid[32],name2[32],authid2[32],name[32], arg3[32]
new userid2 = get_user_userid(player)
read_argv(1,minutes,31)
get_user_authid(player,authid2,31)
get_user_authid(id,authid,31)
get_user_name(player,name2,31)
get_user_name(id,name,31)
read_argv(3,arg3,31)
log_to_file(g_logFile,"Ban: ^"%s<%d><%s><>^" ban and kick ^"%s<%d><%s><>^" (minutes ^"%s^") (reason ^"%s^")",
name,get_user_userid(id),authid, name2,userid2,authid2,minutes,arg3 )
if ( equal(cmd[7],"ip") || (!equal(cmd[7],"id") && get_cvar_num("sv_lan")) ){
new address[32]
get_user_ip(player,address,31,1)
server_cmd("addip ^"%s^" ^"%s^";wait;writeip",minutes,address)
}
else
server_cmd("banid ^"%s^" ^"%s^" kick;wait;writeid",minutes,authid2)
new activity = get_cvar_num("amx_show_activity")
if (activity) {
new temp[64], temp2[64]
if (activity == 1)
temp = "ADMIN:"
else
format(temp,63,"ADMIN %s:",name)
if (strtonum(minutes))
format(temp2,63,"for %s min.",minutes)
else
temp2 = "permanently"
client_print(0,print_chat,"%s ban %s %s",temp,name2,temp2)
}
console_print(id,"Client ^"%s^" banned",name2)
return PLUGIN_HANDLED
}
public cmdSlay(id,level,cid){
if (!cmd_access(id,level,cid,2))
return PLUGIN_HANDLED
new arg[32]
read_argv(1,arg,31)
new player = cmd_target(id,arg,5)
if (!player) return PLUGIN_HANDLED
user_kill(player)
new authid[32],name2[32],authid2[32],name[32]
get_user_authid(id,authid,31)
get_user_name(id,name,31)
get_user_authid(player,authid2,31)
get_user_name(player,name2,31)
log_to_file(g_logFile,"Cmd: ^"%s<%d><%s><>^" slay ^"%s<%d><%s><>^"",
name,get_user_userid(id),authid, name2,get_user_userid(player),authid2 )
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"ADMIN %s: slay %s",name,name2)
case 1: client_print(0,print_chat,"ADMIN: slay %s",name2)
}
console_print(id,"Client ^"%s^" slayed",name2)
return PLUGIN_HANDLED
}
public cmdSlap(id,level,cid){
if (!cmd_access(id,level,cid,2))
return PLUGIN_HANDLED
new arg[32]
read_argv(1,arg,31)
new player = cmd_target(id,arg,5)
if (!player) return PLUGIN_HANDLED
new spower[32],authid[32],name2[32],authid2[32],name[32]
read_argv(2,spower,31)
new damage = strtonum(spower)
user_slap(player,damage)
get_user_authid(id,authid,31)
get_user_name(id,name,31)
get_user_authid(player,authid2,31)
get_user_name(player,name2,31)
log_to_file(g_logFile,"Cmd: ^"%s<%d><%s><>^" slap with %d damage ^"%s<%d><%s><>^"",
name,get_user_userid(id),authid, damage,name2,get_user_userid(player),authid2 )
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"ADMIN %s: slap %s with %d damage",name,name2,damage)
case 1: client_print(0,print_chat,"ADMIN: slap %s with %d damage",name2,damage)
}
console_print(id,"Client ^"%s^" slaped with %d damage",name2,damage)
return PLUGIN_HANDLED
}
public chMap(map[])
server_cmd("changelevel %s",map)
public cmdMap(id,level,cid){
if (!cmd_access(id,level,cid,2))
return PLUGIN_HANDLED
new arg[32]
new arglen = read_argv(1,arg,31)
if ( !is_map_valid(arg) ){
console_print(id,"Map with that name not found or map is invalid")
return PLUGIN_HANDLED
}
new authid[32],name[32]
get_user_authid(id,authid,31)
get_user_name(id,name,31)
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"ADMIN %s: changelevel %s",name,arg)
case 1: client_print(0,print_chat,"ADMIN: changelevel %s",arg)
}
log_to_file(g_logFile,"Cmd: ^"%s<%d><%s><>^" changelevel ^"%s^"", name,get_user_userid(id),authid, arg)
set_task(1.0,"chMap",0,arg,arglen+1)
return PLUGIN_HANDLED
}
onlyRcon( name[] ) {
for(new a = 0; a < g_cvarRconNum; ++a)
if ( equal( g_cvarRcon[a] , name) )
return 1
return 0
}
public cmdCvar(id,level,cid){
if (!cmd_access(id,level,cid,2))
return PLUGIN_HANDLED
new arg[32], arg2[64]
read_argv(1,arg,31)
read_argv(2,arg2,63)
if ( equal(arg,"add") && (get_user_flags(id) & ADMIN_RCON) ) {
if ( cvar_exists(arg2) ){
if ( g_cvarRconNum < MAXRCONCVARS )
copy( g_cvarRcon[ g_cvarRconNum++ ] , 31, arg2 )
else
console_print(id,"Can't add more cvars for rcon access!")
}
return PLUGIN_HANDLED
}
if (!cvar_exists(arg)){
console_print(id,"Unknown cvar: %s",arg)
return PLUGIN_HANDLED
}
if ( onlyRcon(arg) && !(get_user_flags(id) & ADMIN_RCON)){
console_print(id,"You have no access to that cvar")
return PLUGIN_HANDLED
}
else if (equal(arg,"sv_password") && !(get_user_flags(id) & ADMIN_PASSWORD)){
console_print(id,"You have no access to that cvar")
return PLUGIN_HANDLED
}
if (read_argc() < 3){
get_cvar_string(arg,arg2,63)
console_print(id,"Cvar ^"%s^" is ^"%s^"",arg,arg2)
return PLUGIN_HANDLED
}
new authid[32],name[32]
get_user_authid(id,authid,31)
get_user_name(id,name,31)
log_to_file(g_logFile,"Cmd: ^"%s<%d><%s><>^" set cvar (name ^"%s^") (value ^"%s^")",
name,get_user_userid(id),authid, arg,arg2)
set_cvar_string(arg,arg2)
new activity = get_cvar_num("amx_show_activity")
if (activity) {
new temp[64]
if (activity == 1)
temp = "ADMIN:"
else
format(temp,63,"ADMIN %s:",name)
client_print(0,print_chat,"%s set cvar %s to ^"%s^"",temp,arg,equal(arg,"rcon_password") ? "*** PROTECTED ***" : arg2)
}
console_print(id,"Cvar ^"%s^" changed to ^"%s^"",arg,arg2)
return PLUGIN_HANDLED
}
public cmdCfg(id,level,cid){
if (!cmd_access(id,level,cid,2))
return PLUGIN_HANDLED
new arg[128]
read_argv(1,arg,127)
if (!file_exists(arg)){
console_print(id,"File ^"%s^" not found",arg)
return PLUGIN_HANDLED
}
new authid[32],name[32]
get_user_authid(id,authid,31)
get_user_name(id,name,31)
log_to_file(g_logFile,"Cmd: ^"%s<%d><%s><>^" execute cfg (file ^"%s^")",
name,get_user_userid(id),authid, arg)
console_print(id,"Executing file ^"%s^"",arg)
server_cmd("exec %s",arg)
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"ADMIN %s: execute config %s",name,arg)
case 1: client_print(0,print_chat,"ADMIN: execute config %s",arg)
}
return PLUGIN_HANDLED
}
public cmdLBack(){
set_cvar_float("pausable",g_pausAble)
console_print(g_pauseCon,"Server %s", g_Paused ? "unpaused" : "paused")
g_Paused = !g_Paused
return PLUGIN_HANDLED
}
public cmdPause(id,level,cid){
if (!cmd_access(id,level,cid,1))
return PLUGIN_HANDLED
new authid[32],name[32],slayer = id
get_user_authid(id,authid,31)
get_user_name(id,name,31)
g_pausAble = get_cvar_float("pausable")
if (!slayer) slayer = find_player("h")
if (!slayer){
console_print(id,"Server was unable to pause the game. Real players on server are needed")
return PLUGIN_HANDLED
}
set_cvar_float("pausable",1.0)
client_cmd(slayer,"pause;pauseAck")
log_to_file(g_logFile,"Cmd: ^"%s<%d><%s><>^" %s server",
name,get_user_userid(id),authid, g_Paused ? "unpause" : "pause" )
console_print(id,"Server proceed %s", g_Paused ? "unpausing" : "pausing")
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"ADMIN %s: %s server",name,g_Paused ? "unpause" : "pause")
case 1: client_print(0,print_chat,"ADMIN: %s server",g_Paused ? "unpause" : "pause")
}
g_pauseCon = id
return PLUGIN_HANDLED
}
public cmdRcon(id,level,cid){
if (!cmd_access(id,level,cid,2))
return PLUGIN_HANDLED
new arg[128],authid[32],name[32]
read_args(arg,127)
get_user_authid(id,authid,31)
get_user_name(id,name,31)
log_to_file(g_logFile,"Cmd: ^"%s<%d><%s><>^" server console (cmdline ^"%s^")",
name,get_user_userid(id),authid, arg)
console_print(id,"Commmand line ^"%s^" sent to server console",arg)
server_cmd(arg)
return PLUGIN_HANDLED
}
public cmdWho(id,level,cid){
new players[32], inum, authid[32],name[32], flags, sflags[32]
get_players(players,inum)
console_print(id,"^nClients on server:^n # %-16.15s %-12s %-8s %-4.3s %-4.3s %s",
"nick","authid","userid","imm","res","access")
for(new a = 0; a < inum; ++a) {
get_user_authid(players[a],authid,31)
get_user_name(players[a],name,31)
flags = get_user_flags(players[a])
get_flags(flags,sflags,31)
console_print(id,"%2d %-16.15s %-12s %-8d %-4.3s %-4.3s %s", players[a],name,authid,
get_user_userid(players[a]),(flags&ADMIN_IMMUNITY)?"yes":"no",
(flags&ADMIN_RESERVATION)?"yes":"no",sflags)
}
console_print(id,"Total %d",inum)
get_user_authid(id,authid,31)
get_user_name(id,name,31)
log_to_file(g_logFile,"Cmd: ^"%s<%d><%s><>^" ask for players list",name,get_user_userid(id),authid)
return PLUGIN_HANDLED
}
hasTag(name[],tags[4][32],tagsNum){
for(new a=0;a<tagsNum;++a)
if (contain(name,tags[a])!=-1)
return a
return -1
}
public cmdLeave(id,level,cid){
if (!cmd_access(id,level,cid,2))
return PLUGIN_HANDLED
new argnum = read_argc()
new ltags[4][32]
new ltagsnum = 0
for(new a=1;a<5;++a){
if (a<argnum)
read_argv(a,ltags[ltagsnum++],31)
else
ltags[ltagsnum++][0] = 0
}
new nick[32], ires, pnum = get_maxplayers() + 1, count = 0
for(new b=1;b<pnum;++b){
if (!is_user_connected(b)&&!is_user_connecting(b)) continue
get_user_name(b,nick,31)
ires = hasTag(nick,ltags,ltagsnum)
if (ires!=-1){
console_print(id,"Skipping ^"%s^" (matching ^"%s^")",nick,ltags[ires])
continue
}
if (get_user_flags(b)&ADMIN_IMMUNITY){
console_print(id,"Skipping ^"%s^" (immunity)",nick)
continue
}
console_print(id,"Kicking ^"%s^"",nick)
if (is_user_bot(b))
server_cmd("kick #%d",get_user_userid(b))
else
client_cmd(b,"echo * You have been dropped because admin has left only specified group of clients;disconnect")
count++
}
console_print(id,"Kicked %d clients",count)
new authid[32],name[32]
get_user_authid(id,authid,31)
get_user_name(id,name,31)
log_to_file(g_logFile,"Kick: ^"%s<%d><%s><>^" leave some group (tag1 ^"%s^") (tag2 ^"%s^") (tag3 ^"%s^") (tag4 ^"%s^")",
name,get_user_userid(id),authid,ltags[0],ltags[1],ltags[2],ltags[3] )
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"ADMIN %s: leave %s %s %s %s",name,ltags[0],ltags[1],ltags[2],ltags[3])
case 1: client_print(0,print_chat,"ADMIN: leave %s %s %s %s",ltags[0],ltags[1],ltags[2],ltags[3])
}
return PLUGIN_HANDLED
}

66
plugins/adminhelp.sma Executable file
View File

@ -0,0 +1,66 @@
/* AMX Mod script.
*
* (c) 2003, tcquest78
* This file is provided as is (no warranties).
*
* Provides help for admin commands with amx_help command
*/
#include <amxmod>
#define HELPAMOUNT 10 // Number of commands per page
new g_typeHelp[] = "Type 'amx_help' in the console to see available commands"
new g_timeInfo1[] = "Time Left: %d:%02d min. Next Map: %s"
new g_timeInfo2[] = "No Time Limit. Next Map: %s"
public plugin_init() {
register_plugin("Admin Help","0.9","tcquest78")
register_concmd("amx_help","cmdHelp",0,"- displays this help")
setHelp(0)
}
public client_putinserver(id)
setHelp(id)
public cmdHelp(id,level,cid){
new arg1[8],flags = get_user_flags(id)
new start = read_argv(1,arg1,7) ? strtonum(arg1) : 1
if (--start < 0) start = 0
new clcmdsnum = get_concmdsnum(flags,id)
if (start >= clcmdsnum) start = clcmdsnum - 1
console_print(id,"^n----- AMX Help: Commands -----")
new info[128], cmd[32], eflags
new end = start + HELPAMOUNT
if (end > clcmdsnum) end = clcmdsnum
for (new i = start; i < end; i++){
get_concmd(i,cmd,31,eflags,info,127,flags,id)
console_print(id,"%3d: %s %s",i+1,cmd,info)
}
console_print(id,"----- Entries %d - %d of %d -----",start+1,end,clcmdsnum)
if (end < clcmdsnum)
console_print(id,"----- Use 'amx_help %d' for more -----",end+1)
else
console_print(id,"----- Use 'amx_help 1' for begin -----")
return PLUGIN_HANDLED
}
public dispInfo(id){
if (id) client_print(id,print_chat, g_typeHelp )
else server_print( g_typeHelp )
new nextmap[32]
get_cvar_string("amx_nextmap",nextmap,31)
if (get_cvar_float("mp_timelimit")){
new timeleft = get_timeleft()
if (timeleft > 0){
if (id) client_print(id,print_chat, g_timeInfo1 , timeleft / 60, timeleft % 60,nextmap)
else server_print( g_timeInfo1 , timeleft / 60, timeleft % 60,nextmap)
}
}
else if (id) client_print(id,print_chat, g_timeInfo2 ,nextmap)
else server_print( g_timeInfo2 ,nextmap)
}
setHelp(id)
set_task(15.0,"dispInfo",id)

88
plugins/adminslots.sma Executable file
View File

@ -0,0 +1,88 @@
/* AMX Mod script.
*
* (c) 2003, OLO
* This file is provided as is (no warranties).
*
* Kick a player without reservation who tries
* to enter to one of the reservered slots set
* by amx_reservation cvar.
*
* Cvar:
* amx_reservation <value> - sets amount of reserved slots.
*/
#include <amxmod>
#include <amxmisc>
// Comment if you don't want to hide not used reserved slots
#define HIDE_RESERVED_SLOTS
new g_cmdLoopback[16]
public plugin_init()
{
register_plugin("Slots Reservation","0.9.7","default")
register_cvar("amx_reservation","1")
format( g_cmdLoopback, 15, "amxres%c%c%c%c" ,
random_num('A','Z') , random_num('A','Z') ,random_num('A','Z'),random_num('A','Z') )
register_clcmd( g_cmdLoopback, "ackSignal" )
}
#if !defined NO_STEAM
public ackSignal(id)
server_cmd("kick #%d", get_user_userid(id) )
public client_authorized(id)
#else
public client_connect(id)
#endif
{
new maxplayers = get_maxplayers( )
new players = get_playersnum( 1 )
new limit = maxplayers - get_cvar_num( "amx_reservation" )
if ( (get_user_flags(id) & ADMIN_RESERVATION) || (players <= limit) )
{
#if defined HIDE_RESERVED_SLOTS
setVisibleSlots( players , maxplayers, limit )
#endif
return PLUGIN_CONTINUE
}
#if !defined NO_STEAM
client_cmd(id,"echo ^"Dropped due to slot reservation^";%s" , g_cmdLoopback)
#else
if ( is_user_bot(id) )
server_cmd("kick #%d", get_user_userid(id) )
else
client_cmd(id,"echo ^"Dropped due to slot reservation^";disconnect")
#endif
return PLUGIN_HANDLED
}
#if defined HIDE_RESERVED_SLOTS
public client_disconnect(id)
{
new maxplayers = get_maxplayers( )
setVisibleSlots( get_playersnum(1) - 1 , maxplayers ,
maxplayers - get_cvar_num( "amx_reservation" ) )
return PLUGIN_CONTINUE
}
setVisibleSlots( players , maxplayers , limit )
{
new num = players + 1
if ( players == maxplayers )
num = maxplayers
else if ( players < limit )
num = limit
set_cvar_num( "sv_visiblemaxplayers" , num )
}
#endif

370
plugins/adminvote.sma Executable file
View File

@ -0,0 +1,370 @@
/* AMX Mod script.
*
* (c) 2003, OLO
* This file is provided as is (no warranties).
*
* I. Vote for changing the level:
* amx_votemap < map > [ map ] [ map ] [ map ]
*
* Examples:
* amx_votemap "de_dust"
* amx_votemap "de_dust" "de_dust2" "cs_italy"
*
* II. Vote for kicking the player:
* amx_votekick <name or #userid>
*
* Examples:
* amx_votekick "Player"
*
* III. Vote for banning and kicking the player for 30 minutes:
* amx_voteban <name or #userid>
*
* Examples:
* amx_voteban "Player"
*
* IV. Custom voting:
* amx_vote < question > < g_Answer1 > < g_Answer2 >
*
* Examples:
* amx_vote "sv_restart" "5" "0"
* amx_vote "mp_timelimit" "20" "45"
* amx_vote "are you hungry?" "yes" "no"
*
*/
#include <amxmod>
#include <amxmisc>
new g_Answer[128]
new g_optionName[4][32]
new g_voteCount[4]
new g_validMaps
new g_yesNoVote
new g_logFile[16]
new g_cstrikeRunning
new g_voteCaller
new g_Execute[256]
new g_execLen
new g_alredyVoting[]= "There is already one voting..."
new g_notAllowed[] = "Voting not allowed at this time"
new g_votingStarted[] = "Voting has started..."
new g_playerTag[] = "PLAYER"
new g_adminTag[] = "ADMIN"
new bool:g_execResult
new Float:g_voteRatio
public plugin_init() {
register_plugin("Admin Votes","0.9","default")
register_menucmd(register_menuid("Change map to ") ,(1<<0)|(1<<1),"voteCount")
register_menucmd(register_menuid("Choose map: ") ,(1<<0)|(1<<1)|(1<<2)|(1<<3),"voteCount")
register_menucmd(register_menuid("Kick ") ,(1<<0)|(1<<1),"voteCount")
register_menucmd(register_menuid("Ban ") ,(1<<0)|(1<<1),"voteCount")
register_menucmd(register_menuid("Vote: ") ,(1<<0)|(1<<1),"voteCount")
register_menucmd(register_menuid("The result: ") ,(1<<0)|(1<<1),"actionResult")
register_concmd("amx_votemap","cmdVoteMap",ADMIN_VOTE,"<map> [map] [map] [map]")
register_concmd("amx_votekick","cmdVoteKickBan",ADMIN_VOTE,"<name or #userid>")
register_concmd("amx_voteban","cmdVoteKickBan",ADMIN_VOTE,"<name or #userid>")
register_concmd("amx_vote","cmdVote",ADMIN_VOTE,"<question> <answer#1> <answer#2>")
register_concmd("amx_cancelvote","cmdCancelVote",ADMIN_VOTE,"- cancels last vote")
register_cvar("amx_votekick_ratio","0.40")
register_cvar("amx_voteban_ratio","0.40")
register_cvar("amx_votemap_ratio","0.40")
register_cvar("amx_vote_ratio","0.02")
register_cvar("amx_vote_time","10")
register_cvar("amx_vote_answers","1")
register_cvar("amx_vote_delay","60")
register_cvar("amx_last_voting","0")
set_cvar_float("amx_last_voting",0.0)
register_cvar("amx_show_activity","2")
g_cstrikeRunning = is_running("cstrike")
get_logfile(g_logFile,15)
}
public cmdCancelVote(id,level,cid){
if (!cmd_access(id,level,cid,0))
return PLUGIN_HANDLED
if ( task_exists( 99889988 , 1 ) ) {
new authid[32],name[32]
get_user_authid(id,authid,31)
get_user_name(id,name,31)
log_to_file(g_logFile,"Vote: ^"%s<%d><%s><>^" cancel vote session", name,get_user_userid(id),authid)
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"%s %s: cancel vote", (get_user_flags(id) & ADMIN_USER) ? g_playerTag : g_adminTag, name)
case 1: client_print(0,print_chat,"%s: cancel vote", (get_user_flags(id) & ADMIN_USER) ? g_playerTag : g_adminTag)
}
console_print(id, "Voting canceled" )
client_print(0,print_chat,"Voting canceled")
remove_task( 99889988 , 1 )
set_cvar_float( "amx_last_voting" , get_gametime() )
}
else
console_print(id, "There is no voting to cancel or the vote session can't be canceled with that command" )
return PLUGIN_HANDLED
}
public delayedExec(cmd[])
server_cmd(cmd)
new g_resultRef[] = "Result refused"
new g_resultAcpt[] = "Result accepted"
new g_votingFailed[] = "Voting failed"
new g_votingSuccess[] = "Voting successful"
public autoRefuse(){
log_to_file(g_logFile,"Vote: %s" , g_resultRef)
client_print(0,print_chat,g_resultRef )
}
public actionResult(id,key) {
remove_task( 4545454 )
switch(key){
case 0: {
set_task(2.0,"delayedExec",0,g_Execute,g_execLen)
log_to_file(g_logFile,"Vote: %s",g_resultAcpt)
client_print(0,print_chat,g_resultAcpt )
}
case 1: autoRefuse()
}
return PLUGIN_HANDLED
}
public checkVotes() {
new best = 0
if ( !g_yesNoVote ) {
for(new a = 0; a < 4; ++a)
if (g_voteCount[a] > g_voteCount[best])
best = a
}
new votesNum = g_voteCount[0] + g_voteCount[1] + g_voteCount[2] + g_voteCount[3]
new iRatio = votesNum ? floatround( g_voteRatio * float( votesNum ) ,floatround_ceil) : 1
new iResult = g_voteCount[best]
if ( iResult < iRatio ){
if (g_yesNoVote)
client_print(0,print_chat,"%s (yes ^"%d^") (no ^"%d^") (needed ^"%d^")",g_votingFailed, g_voteCount[0], g_voteCount[1] , iRatio )
else
client_print(0,print_chat,"%s (got ^"%d^") (needed ^"%d^")",g_votingFailed,iResult , iRatio )
log_to_file(g_logFile,"Vote: %s (got ^"%d^") (needed ^"%d^")",g_votingFailed,iResult , iRatio )
return PLUGIN_CONTINUE
}
g_execLen = format(g_Execute,255,g_Answer,g_optionName[best]) + 1
if (g_execResult){
g_execResult = false
if ( is_user_connected(g_voteCaller) ) {
new menuBody[512]
new len = format(menuBody,511,g_cstrikeRunning ? "\yThe result: \w%s^n^n" : "The result: %s^n^n", g_Execute )
len += copy( menuBody[len] ,511 - len, g_cstrikeRunning ? "\yDo you want to continue?^n\w" : "Do you want to continue?^n" )
copy( menuBody[len] ,511 - len, "^n1. Yes^n2. No")
show_menu( g_voteCaller ,0x03 ,menuBody, 10 )
set_task(10.0,"autoRefuse",4545454)
}
else
set_task(2.0,"delayedExec",0,g_Execute,g_execLen)
}
client_print(0,print_chat,"%s (got ^"%d^") (needed ^"%d^"). The result: %s", g_votingSuccess, iResult , iRatio , g_Execute )
log_to_file(g_logFile,"Vote: %s (got ^"%d^") (needed ^"%d^") (result ^"%s^")", g_votingSuccess, iResult , iRatio , g_Execute )
return PLUGIN_CONTINUE
}
public voteCount(id,key){
if ( get_cvar_num("amx_vote_answers") ) {
new name[32]
get_user_name(id,name,31)
if (g_yesNoVote)
client_print(0,print_chat,"%s voted %s",name,key ? "against" : "for" )
else
client_print(0,print_chat,"%s voted for option #%d",name,key+1)
}
++g_voteCount[key]
return PLUGIN_HANDLED
}
public cmdVoteMap(id,level,cid) {
if (!cmd_access(id,level,cid,2))
return PLUGIN_HANDLED
new Float:voting = get_cvar_float("amx_last_voting")
if (voting > get_gametime()){
console_print(id, g_alredyVoting )
return PLUGIN_HANDLED
}
if (voting && voting + get_cvar_float("amx_vote_delay") > get_gametime()) {
console_print(id, g_notAllowed )
return PLUGIN_HANDLED
}
new argc = read_argc()
if (argc > 5) argc = 5
g_validMaps = 0
g_optionName[0][0] = g_optionName[1][0] = g_optionName[2][0] = g_optionName[3][0] = 0
for(new i = 1; i < argc; ++i){
read_argv(i,g_optionName[g_validMaps],31)
if (is_map_valid(g_optionName[g_validMaps]))
g_validMaps++;
}
if (g_validMaps == 0) {
console_print(id,"Given %s not valid",(argc==2)?"map is":"maps are")
return PLUGIN_HANDLED
}
new menu_msg[256]
new keys = 0
if (g_validMaps > 1){
keys = (1<<9)
copy(menu_msg,255,g_cstrikeRunning ? "\yChoose map: \w^n^n" : "Choose map: ^n^n")
new temp[128]
for(new a = 0; a < g_validMaps; ++a){
format(temp,127,"%d. %s^n",a+1,g_optionName[a])
add(menu_msg,255,temp)
keys |= (1<<a)
}
add(menu_msg,255,"^n0. None")
g_yesNoVote = 0
}
else{
format(menu_msg,255,g_cstrikeRunning ? "\yChange map to %s?\w^n^n1. Yes^n2. No"
: "Change map to %s?^n^n1. Yes^n2. No",g_optionName[0])
keys = (1<<0)|(1<<1)
g_yesNoVote = 1
}
new authid[32],name[32]
get_user_authid(id,authid,31)
get_user_name(id,name,31)
if (argc==2)
log_to_file(g_logFile,"Vote: ^"%s<%d><%s><>^" vote map (map ^"%s^")",
name,get_user_userid(id),authid,g_optionName[0])
else
log_to_file(g_logFile,"Vote: ^"%s<%d><%s><>^" vote maps (map#1 ^"%s^") (map#2 ^"%s^") (map#3 ^"%s^") (map#4 ^"%s^")",
name,get_user_userid(id),authid,g_optionName[0],g_optionName[1],g_optionName[2],g_optionName[3])
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"%s %s: vote map(s)",name,
(get_user_flags(id) & ADMIN_USER) ? g_playerTag : g_adminTag)
case 1: client_print(0,print_chat,"%s: vote map(s)",
(get_user_flags(id) & ADMIN_USER) ? g_playerTag : g_adminTag)
}
g_execResult = true
new Float:vote_time = get_cvar_float("amx_vote_time") + 2.0
set_cvar_float("amx_last_voting", get_gametime() + vote_time )
g_voteRatio = get_cvar_float("amx_votemap_ratio")
g_Answer = "changelevel %s"
show_menu(0,keys,menu_msg,floatround(vote_time))
set_task(vote_time,"checkVotes" , 99889988 )
g_voteCaller = id
console_print(id, g_votingStarted )
g_voteCount = { 0,0, 0,0 }
return PLUGIN_HANDLED
}
public cmdVote(id,level,cid) {
if (!cmd_access(id,level,cid,4))
return PLUGIN_HANDLED
new Float:voting = get_cvar_float("amx_last_voting")
if (voting > get_gametime()){
console_print(id, g_alredyVoting )
return PLUGIN_HANDLED
}
if (voting && voting + get_cvar_float("amx_vote_delay") > get_gametime()) {
console_print(id, g_notAllowed )
return PLUGIN_HANDLED
}
new quest[48]
read_argv(1,quest,47)
if ((contain(quest,"sv_password")!=-1)||(contain(quest,"rcon_password")!=-1)||
(contain(quest,"kick")!=-1)||(contain(quest,"addip")!=-1)||(contain(quest,"ban")!=-1)){
console_print(id,"Voting for that has been forbidden")
return PLUGIN_HANDLED
}
read_argv(2,g_optionName[0],31)
read_argv(3,g_optionName[1],31)
new authid[32],name[32]
get_user_authid(id,authid,31)
get_user_name(id,name,31)
log_to_file(g_logFile,"Vote: ^"%s<%d><%s><>^" vote custom (question ^"%s^") (option#1 ^"%s^") (option#2 ^"%s^")",
name,get_user_userid(id),authid,quest,g_optionName[0],g_optionName[1])
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"%s %s: vote custom",
(get_user_flags(id) & ADMIN_USER) ? g_playerTag : g_adminTag,name )
case 1: client_print(0,print_chat,"%s: vote custom",
(get_user_flags(id) & ADMIN_USER) ? g_playerTag : g_adminTag)
}
new menu_msg[256]
new keys = (1<<0)|(1<<1)
format(menu_msg,255, g_cstrikeRunning ? "\yVote: %s\w^n^n1. %s^n2. %s"
: "Vote: %s^n^n1. %s^n2. %s",quest,g_optionName[0],g_optionName[1])
g_execResult = false
new Float:vote_time = get_cvar_float("amx_vote_time") + 2.0
set_cvar_float("amx_last_voting", get_gametime() + vote_time )
g_voteRatio = get_cvar_float("amx_vote_ratio")
format(g_Answer,127,"%s - %%s",quest)
show_menu(0,keys,menu_msg,floatround(vote_time))
set_task(vote_time,"checkVotes" , 99889988 )
g_voteCaller = id
console_print(id, g_votingStarted )
g_voteCount ={ 0,0,0,0}
g_yesNoVote = 0
return PLUGIN_HANDLED
}
public cmdVoteKickBan(id,level,cid) {
if (!cmd_access(id,level,cid,2))
return PLUGIN_HANDLED
new Float:voting = get_cvar_float("amx_last_voting")
if (voting > get_gametime()){
console_print(id, g_alredyVoting )
return PLUGIN_HANDLED
}
if (voting && voting + get_cvar_float("amx_vote_delay") > get_gametime()) {
console_print(id, g_notAllowed )
return PLUGIN_HANDLED
}
new cmd[32]
read_argv(0,cmd,31)
new voteban = equal(cmd,"amx_voteban")
new arg[32]
read_argv(1,arg,31)
new player = cmd_target(id,arg,1)
if (!player) return PLUGIN_HANDLED
if (voteban && is_user_bot(player)) {
new imname[32]
get_user_name(player,imname,31)
console_print(id,"That action can't be performed on bot ^"%s^"",imname)
return PLUGIN_HANDLED
}
new keys = (1<<0)|(1<<1)
new menu_msg[256]
get_user_name(player,arg,31)
format(menu_msg,255,g_cstrikeRunning ? "\y%s %s?\w^n^n1. Yes^n2. No"
: "%s %s?^n^n1. Yes^n2. No", voteban ? "Ban" : "Kick", arg)
g_yesNoVote = 1
if (voteban)
get_user_authid(player,g_optionName[0],31)
else
numtostr(get_user_userid(player),g_optionName[0],31)
new authid[32],name[32]
get_user_authid(id,authid,31)
get_user_name(id,name,31)
log_to_file(g_logFile,"Vote: ^"%s<%d><%s><>^" vote %s (target ^"%s^")",
name,get_user_userid(id),authid,voteban ? "ban" : "kick",arg)
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"%s %s: vote %s for %s",
(get_user_flags(id) & ADMIN_USER) ? g_playerTag : g_adminTag,name,voteban ? "ban" : "kick",arg )
case 1: client_print(0,print_chat,"%s: vote %s for %s",
(get_user_flags(id) & ADMIN_USER) ? g_playerTag : g_adminTag,voteban ? "ban" : "kick",arg)
}
g_execResult = true
new Float:vote_time = get_cvar_float("amx_vote_time") + 2.0
set_cvar_float("amx_last_voting", get_gametime() + vote_time )
g_voteRatio = get_cvar_float(voteban ? "amx_voteban_ratio" : "amx_votekick_ratio")
g_Answer = voteban ? "banid 30.0 %s kick" : "kick #%s"
show_menu(0,keys,menu_msg,floatround(vote_time))
set_task(vote_time,"checkVotes" , 99889988 )
g_voteCaller = id
console_print(id, g_votingStarted )
g_voteCount = {0,0,0,0}
return PLUGIN_HANDLED
}

41
plugins/antiflood.sma Executable file
View File

@ -0,0 +1,41 @@
/* AMX Mod script.
*
* (c) 2003, OLO
* This file is provided as is (no warranties).
*
* Cvar:
* amx_flood_time <time in sec.> - set frequency of chating
*/
#include <amxmod>
new Float:g_Flooding[33]
public plugin_init()
{
register_plugin("Anti Flood","0.9","default")
register_clcmd("say","chkFlood")
register_clcmd("say_team","chkFlood")
register_cvar("amx_flood_time","0.75")
}
public chkFlood(id)
{
new Float:maxChat = get_cvar_float("amx_flood_time")
if ( maxChat )
{
new Float:nexTime = get_gametime()
if ( g_Flooding[id] > nexTime )
{
client_print( id , print_notify , "** Stop flooding the server!" )
g_Flooding[ id ] = nexTime + maxChat + 3.0
return PLUGIN_HANDLED
}
g_Flooding[id] = nexTime + maxChat
}
return PLUGIN_CONTINUE
}

373
plugins/cmdmenu.sma Executable file
View File

@ -0,0 +1,373 @@
/* AMX Mod script.
*
* (c) 2003, OLO
* This file is provided as is (no warranties).
*
*/
#include <amxmod>
#include <amxmisc>
/* Commands Menus */
#define MAX_CMDS_LAYERS 3
new g_cmdMenuName[ MAX_CMDS_LAYERS ][ ] = {
"Commands Menu",
"Configs Menu",
"Speech Menu"
}
new g_cmdMenuCmd[ MAX_CMDS_LAYERS ][ ] = {
"amx_cmdmenu",
"amx_cfgmenu",
"amx_speechmenu"
}
new g_cmdMenuCfg[ MAX_CMDS_LAYERS ][ ] = {
"cmds.ini",
"configs.ini",
"speech.ini"
}
new g_cmdMenuHelp[ MAX_CMDS_LAYERS ][ ] = {
"- displays commands menu",
"- displays configs menu",
"- displays speech menu"
}
/* End of Commands Menu */
#define MAX_CMDS 32
#define MAX_CVARS 32
new g_cmdName[MAX_CMDS*MAX_CMDS_LAYERS][32]
new g_cmdCmd[MAX_CMDS*MAX_CMDS_LAYERS][64]
new g_cmdMisc[MAX_CMDS*MAX_CMDS_LAYERS][2]
new g_cmdNum[MAX_CMDS_LAYERS]
new g_cvarNames[MAX_CVARS][32]
new g_cvarMisc[MAX_CVARS][3]
new g_cvarCmd[MAX_CVARS*5][32]
new g_cvarCmdNum
new g_cvarNum
new g_menuPosition[33]
new g_menuSelect[33][64]
new g_menuSelectNum[33]
new g_menuLayer[33]
new g_cstrikeRunning
public plugin_init()
{
register_plugin("Commands Menu","0.9","default")
new basedir[32], workdir[64]
get_basedir( basedir , 31 )
for(new a = 0; a < MAX_CMDS_LAYERS; ++a) {
register_menucmd(register_menuid( g_cmdMenuName[ a ] ),1023,"actionCmdMenu")
register_clcmd( g_cmdMenuCmd[ a ] ,"cmdCmdMenu",ADMIN_MENU, g_cmdMenuHelp[ a ] )
format( workdir, 63, "%s/%s" , basedir , g_cmdMenuCfg[ a ] )
loadCmdSettings( workdir , a )
}
register_menucmd(register_menuid("Cvars Menu"),1023,"actionCvarMenu")
register_clcmd("amx_cvarmenu","cmdCvarMenu",ADMIN_CVAR,"- displays cvars menu")
format( workdir, 63, "%s/cvars.ini" , basedir )
loadCvarSettings( workdir )
g_cstrikeRunning = is_running("cstrike")
}
/* Commands menu */
public actionCmdMenu(id,key)
{
switch(key){
case 8: displayCmdMenu(id,++g_menuPosition[id])
case 9: displayCmdMenu(id,--g_menuPosition[id])
default:{
new option = g_menuSelect[ id ][ g_menuPosition[id] * 8 + key ]
new flags = g_cmdMisc[ option ][ 1 ]
if ( flags & 1)
server_cmd( g_cmdCmd[ option ] )
else if ( flags & 2)
client_cmd(id, g_cmdCmd[ option ] )
else if ( flags & 4)
client_cmd(0, g_cmdCmd[ option ] )
if ( flags & 8 ) displayCmdMenu(id,g_menuPosition[id])
}
}
return PLUGIN_HANDLED
}
displayCmdMenu(id,pos){
if (pos < 0) return
new menuBody[512]
new b = 0
new start = pos * 8
if (start >= g_menuSelectNum[id])
start = pos = g_menuPosition[id] = 0
new len = format(menuBody,511,g_cstrikeRunning ?
"\y%s\R%d/%d^n\w^n" : "%s %d/%d^n^n" , g_cmdMenuName[ g_menuLayer[id] ],
pos+1,( g_menuSelectNum[id] / 8 + ((g_menuSelectNum[id] % 8) ? 1 : 0 )) )
new end = start + 8
new keys = (1<<9)
if (end > g_menuSelectNum[id])
end = g_menuSelectNum[id]
for(new a = start; a < end; ++a)
{
if ( g_cmdCmd[ g_menuSelect[id][ a ] ][0] == '-' )
{
if ( g_cstrikeRunning)
len += format(menuBody[len],511-len,"\d%s^n\w",g_cmdName[ g_menuSelect[id][ a ] ] )
else
len += format(menuBody[len],511-len,"%s^n",g_cmdName[ g_menuSelect[id][ a ] ] )
++b
}
else
{
keys |= (1<<b)
len += format(menuBody[len],511-len,"%d. %s^n",++b, g_cmdName[ g_menuSelect[id][ a ] ] )
}
}
if (end != g_menuSelectNum[id]) {
format(menuBody[len],511-len,"^n9. More...^n0. %s", pos ? "Back" : "Exit")
keys |= (1<<8)
}
else format(menuBody[len],511-len,"^n0. %s", pos ? "Back" : "Exit" )
show_menu(id,keys,menuBody)
}
public cmdCmdMenu(id,level,cid)
{
if (!cmd_access(id,level,cid,1)) return PLUGIN_HANDLED
new szCmd[32]
read_argv(0, szCmd, 31)
new lvl = 0
while( lvl < MAX_CMDS_LAYERS )
{
if ( equal( g_cmdMenuCmd[ lvl ], szCmd ) )
break
++lvl
}
g_menuLayer[ id ] = lvl
new flags = get_user_flags(id)
g_menuSelectNum[id] = 0
new a = lvl * MAX_CMDS
new d , c = 0
while( c < g_cmdNum[ lvl ] )
{
d = a + c
if ( g_cmdMisc[ d ][0] & flags )
{
g_menuSelect[id][ g_menuSelectNum[id]++ ] = d
}
++c
}
displayCmdMenu(id,g_menuPosition[id] = 0)
return PLUGIN_HANDLED
}
loadCmdSettings( szFilename[], level )
{
if ( !file_exists ( szFilename ) )
return 0
new text[256], szFlags[32], szAccess[32]
new a, pos = 0, c, d = level * MAX_CMDS
while ( g_cmdNum[ level ] < MAX_CMDS && read_file (szFilename,pos++,text,255,a) )
{
if ( text[0] == ';' ) continue
c = d + g_cmdNum[ level ]
if ( parse( text , g_cmdName[ c ] , 31 ,
g_cmdCmd[ c ] ,63,szFlags,31,szAccess,31 ) > 3 )
{
while ( replace( g_cmdCmd[ c ] ,63,"\'","^"") ) {
// do nothing
}
g_cmdMisc[ c ][ 1 ] = read_flags ( szFlags )
g_cmdMisc[ c ][ 0 ] = read_flags ( szAccess )
g_cmdNum[ level ]++
}
}
return 1
}
/* Cvars menu */
public actionCvarMenu(id,key)
{
switch(key){
case 8: displayCvarMenu(id,++g_menuPosition[id])
case 9: displayCvarMenu(id,--g_menuPosition[id])
default:{
new option = g_menuSelect[ id ][ g_menuPosition[id] * 8 + key ]
new szValue[32]
get_cvar_string( g_cvarNames[ option ], szValue ,31)
new end = g_cvarMisc[ option ][ 2 ]
new start = g_cvarMisc[ option ][ 1 ]
for(new i = start ; ; ++i )
{
if ( i < end )
{
if ( equal( szValue , g_cvarCmd[ i ] ) )
{
if (++i >= end)
{
i = start
}
set_cvar_string( g_cvarNames[ option ], g_cvarCmd[ i ] )
break
}
}
else
{
set_cvar_string( g_cvarNames[ option ], g_cvarCmd[ start ] )
break
}
}
displayCvarMenu(id, g_menuPosition[id] )
}
}
return PLUGIN_HANDLED
}
displayCvarMenu(id,pos){
if (pos < 0) return
new menuBody[512]
new b = 0
new start = pos * 8
if (start >= g_menuSelectNum[id])
start = pos = g_menuPosition[id] = 0
new len = format(menuBody,511, g_cstrikeRunning ?
"\yCvars Menu\R%d/%d^n\w^n" : "Cvars Menu %d/%d^n^n",
pos+1,( g_menuSelectNum[id] / 8 + ((g_menuSelectNum[id] % 8) ? 1 : 0 )) )
new end = start + 8
new keys = (1<<9)
new szValue[64]
if (end > g_menuSelectNum[id])
end = g_menuSelectNum[id]
for(new a = start; a < end; ++a)
{
get_cvar_string( g_cvarNames[ g_menuSelect[id][ a ] ],szValue,31)
keys |= (1<<b)
++b
if ( g_cstrikeRunning )
len += format(menuBody[len],511-len,"%d. %s\R%s^n\w", b, g_cvarNames[ g_menuSelect[id][ a ] ], szValue )
else
len += format(menuBody[len],511-len,"%d. %s %s^n", b, g_cvarNames[ g_menuSelect[id][ a ] ], szValue )
}
if (end != g_menuSelectNum[id]) {
format(menuBody[len],511-len,"^n9. More...^n0. %s", pos ? "Back" : "Exit")
keys |= (1<<8)
}
else format(menuBody[len],511-len,"^n0. %s", pos ? "Back" : "Exit")
show_menu(id,keys,menuBody)
}
public cmdCvarMenu(id,level,cid)
{
if (!cmd_access(id,level,cid,1)) return PLUGIN_HANDLED
new flags = get_user_flags(id)
g_menuSelectNum[id] = 0
for(new a = 0; a < g_cvarNum; ++a)
if ( g_cvarMisc[ a ][0] & flags )
g_menuSelect[id][ g_menuSelectNum[id]++ ] = a
displayCvarMenu(id,g_menuPosition[id] = 0)
return PLUGIN_HANDLED
}
loadCvarSettings( szFilename[] )
{
if ( !file_exists ( szFilename ) )
return 0
new text[256], szValues[12][32]
new inum , a, pos = 0
new cvar_values = MAX_CVARS * 5
// a b c d
while ( g_cvarNum < MAX_CVARS && read_file (szFilename,pos++,text,255,a) )
{
if ( text[0] == ';' ) continue
inum = parse( text , g_cvarNames[ g_cvarNum ] , 31 ,
szValues[0] ,31 , szValues[1] ,31 , szValues[2] ,31 ,
szValues[3] ,31 , szValues[4] ,31 , szValues[5] ,31 ,
szValues[6] ,31 , szValues[7] ,31 , szValues[8] ,31 ,
szValues[9] ,31 , szValues[10] ,31 , szValues[11] ,31 )
inum -= 2
if ( inum < 2 ) continue
g_cvarMisc[ g_cvarNum ][1] = g_cvarCmdNum
for( a = 0 ; a < inum && g_cvarCmdNum < cvar_values ; ++a )
{
while ( replace( szValues[ a ] ,31 , "\'" , "^"" ) ) {
// do nothing
}
copy ( g_cvarCmd[ g_cvarCmdNum ] , 31 , szValues[ a ] )
g_cvarCmdNum++
}
g_cvarMisc[ g_cvarNum ][2] = g_cvarCmdNum
g_cvarMisc[ g_cvarNum ][0] = read_flags( szValues[ inum ] )
g_cvarNum++
}
return 1
}

12
plugins/compile.bat Executable file
View File

@ -0,0 +1,12 @@
@echo off
if not exist compiled mkdir compiled
if exist temp.txt del temp.txt
for %%i in (*.sma) do sc %%i -ocompiled\%%i >> temp.txt
copy compiled\*.sma compiled\*.amx
del compiled\*.sma
cls
type temp.txt
del temp.txt
pause

6
plugins/compile.sh Executable file
View File

@ -0,0 +1,6 @@
#!/bin/bash
test -e compiled || mkdir compiled
ls *.sma | xargs -i ./sc \{\} -ocompiled/\{\} > temp.txt
ls compiled/*.sma | xargs -i basename \{\} .sma | xargs -i mv compiled/\{\}.sma compiled/\{\}.amx
more temp.txt
rm temp.txt

26
plugins/csstats.sma Executable file
View File

@ -0,0 +1,26 @@
/* Get Score for CS STATS.
*
* (c) 2003, OLO
* This file is provided as is (no warranties).
*
* Function calculates position in rank.
*
* Stats:
* 0 - kills
* 1 - deaths
* 2 - headshots
* 3 - teamkilling
* 4 - shots
* 5 - hits
* 6 - damage
*
* Returning cellmin as value in get_score function
* makes that rank won't be saved.
*
* File location: $moddir/addons/amx
*/
#include <amxmod>
public get_score( stats[8] , body[8] )
return stats[0] - stats[1] // kills - deaths

76
plugins/imessage.sma Executable file
View File

@ -0,0 +1,76 @@
/* AMX Mod script.
*
* (c) 2003, OLO
* This file is provided as is (no warranties).
*
* Server command:
* amx_imessage <msg> <colour in RRRGGGBBB format>
*
*/
#include <amxmod>
#include <amxmisc>
#define MAX_MESSAGES 6
#define X_POS -1.0
#define Y_POS 0.30
#define HOLD_TIME 12.0
new g_Values[MAX_MESSAGES][3]
new g_Messages[MAX_MESSAGES][384]
new g_MessagesNum
new g_Current
public plugin_init(){
register_plugin("Info. Messages","0.9","default")
register_srvcmd("amx_imessage","setMessage")
register_cvar("amx_freq_imessage","10")
new lastinfo[8]
get_localinfo("lastinfomsg",lastinfo,7)
g_Current = strtonum(lastinfo)
set_localinfo("lastinfomsg","")
}
public infoMessage(){
if (g_Current >= g_MessagesNum)
g_Current = 0
set_hudmessage(g_Values[g_Current][0], g_Values[g_Current][1], g_Values[g_Current][2],
X_POS, Y_POS, 0, 0.5, HOLD_TIME , 2.0, 2.0, 1)
show_hudmessage(0,g_Messages[g_Current])
client_print(0,print_console,g_Messages[g_Current])
++g_Current
new Float:freq_im = get_cvar_float("amx_freq_imessage")
if ( freq_im > 0.0 ) set_task( freq_im ,"infoMessage",12345)
}
public setMessage(id,level,cid) {
if (!cmd_access(id,level,cid,3))
return PLUGIN_HANDLED
if (g_MessagesNum >= MAX_MESSAGES) {
console_print(id,"Information Messages limit reached!")
return PLUGIN_HANDLED
}
remove_task(12345)
read_argv(1,g_Messages[g_MessagesNum],380)
new hostname[64]
get_cvar_string("hostname",hostname,63)
replace(g_Messages[g_MessagesNum],380,"%hostname%",hostname)
while(replace(g_Messages[g_MessagesNum],380,"\n","^n")){}
new mycol[12]
read_argv(2,mycol,11) // RRRGGGBBB
g_Values[g_MessagesNum][2] = strtonum(mycol[6])
mycol[6] = 0
g_Values[g_MessagesNum][1] = strtonum(mycol[3])
mycol[3] = 0
g_Values[g_MessagesNum][0] = strtonum(mycol[0])
g_MessagesNum++
new Float:freq_im = get_cvar_float("amx_freq_imessage")
if ( freq_im > 0.0 ) set_task( freq_im ,"infoMessage",12345)
return PLUGIN_HANDLED
}
public plugin_end(){
new lastinfo[8]
numtostr(g_Current,lastinfo,7)
set_localinfo("lastinfomsg",lastinfo)
}

205
plugins/include/amxconst.inc Executable file
View File

@ -0,0 +1,205 @@
/* AMX Mod
*
* (c) 2002-2003, OLO
* This file is provided as is (no warranties).
*/
#if defined _amxconst_included
#endinput
#endif
#define _amxconst_included
// Uncomment if you are not using Steam
//#define NO_STEAM
#define ADMIN_IMMUNITY (1<<0) /* flag "a" */
#define ADMIN_RESERVATION (1<<1) /* flag "b" */
#define ADMIN_KICK (1<<2) /* flag "c" */
#define ADMIN_BAN (1<<3) /* flag "d" */
#define ADMIN_SLAY (1<<4) /* flag "e" */
#define ADMIN_MAP (1<<5) /* flag "f" */
#define ADMIN_CVAR (1<<6) /* flag "g" */
#define ADMIN_CFG (1<<7) /* flag "h" */
#define ADMIN_CHAT (1<<8) /* flag "i" */
#define ADMIN_VOTE (1<<9) /* flag "j" */
#define ADMIN_PASSWORD (1<<10) /* flag "k" */
#define ADMIN_RCON (1<<11) /* flag "l" */
#define ADMIN_LEVEL_A (1<<12) /* flag "m" */
#define ADMIN_LEVEL_B (1<<13) /* flag "n" */
#define ADMIN_LEVEL_C (1<<14) /* flag "o" */
#define ADMIN_LEVEL_D (1<<15) /* flag "p" */
#define ADMIN_LEVEL_E (1<<16) /* flag "q" */
#define ADMIN_LEVEL_F (1<<17) /* flag "r" */
#define ADMIN_LEVEL_G (1<<18) /* flag "s" */
#define ADMIN_LEVEL_H (1<<19) /* flag "t" */
#define ADMIN_MENU (1<<20) /* flag "u" */
#define ADMIN_USER (1<<25) /* flag "z" */
#define FLAG_KICK (1<<0) /* flag "a" */
#define FLAG_TAG (1<<1) /* flag "b" */
#define FLAG_AUTHID (1<<2) /* flag "c" */
#define FLAG_IP (1<<3) /* flag "d" */
#define FLAG_NOPASS (1<<4) /* flag "e" */
#define PLUGIN_CONTINUE 0 /* Results returned by public functions */
#define PLUGIN_HANDLED 1 /* stop other plugins */
#define PLUGIN_HANDLED_MAIN 2 /* to use in client_command(), continue all plugins but stop the command */
/* Destination types for message_begin() */
#define MSG_BROADCAST 0 /* unreliable to all */
#define MSG_ONE 1 /* reliable to one (msg_entity) */
#define MSG_ALL 2 /* reliable to all */
#define MSG_INIT 3 /* write to the init string */
#define MSG_PVS 4 /* Ents in PVS of org */
#define MSG_PAS 5 /* Ents in PAS of org */
#define MSG_PVS_R 6 /* Reliable to PVS */
#define MSG_PAS_R 7 /* Reliable to PAS */
#define MSG_ONE_UNRELIABLE 8 /* Send to one client, but don't put in reliable stream, put in unreliable datagram ( could be dropped ) */
#define MSG_SPEC 9 /* Sends to all spectator proxies */
/* Message types for message_begin() */
#define SVC_TEMPENTITY 23
#define SVC_INTERMISSION 30
#define SVC_CDTRACK 32
#define SVC_WEAPONANIM 35
#define SVC_ROOMTYPE 37
#define SVC_ADDANGLE 38 /* [vec3] add this angle to the view angle */
#define SVC_NEWUSERMSG 39
#define SVC_HLTV 50
/* Flags for register_cvar() */
#define FCVAR_ARCHIVE 1 /* set to cause it to be saved to vars.rc */
#define FCVAR_USERINFO 2 /* changes the client's info string */
#define FCVAR_SERVER 4 /* notifies players when changed */
#define FCVAR_EXTDLL 8 /* defined by external DLL */
#define FCVAR_CLIENTDLL 16 /* defined by the client dll */
#define FCVAR_PROTECTED 32 /* It's a server cvar, but we don't send the data since it's a password, etc. Sends 1 if it's not bland/zero, 0 otherwise as value */
#define FCVAR_SPONLY 64 /* This cvar cannot be changed by clients connected to a multiplayer server. */
#define FCVAR_PRINTABLEONLY 128 /* This cvar's string cannot contain unprintable characters ( e.g., used for player name etc ). */
#define FCVAR_UNLOGGED 256 /* If this is a FCVAR_SERVER, don't log changes to the log file / console if we are creating a log */
/* Id of weapons in CS */
#define CSW_P228 1
#define CSW_SCOUT 3
#define CSW_HEGRENADE 4
#define CSW_XM1014 5
#define CSW_C4 6
#define CSW_MAC10 7
#define CSW_AUG 8
#define CSW_SMOKEGRENADE 9
#define CSW_ELITE 10
#define CSW_FIVESEVEN 11
#define CSW_UMP45 12
#define CSW_SG550 13
#define CSW_GALI 14
#define CSW_FAMAS 15
#define CSW_USP 16
#define CSW_GLOCK18 17
#define CSW_AWP 18
#define CSW_MP5NAVY 19
#define CSW_M249 20
#define CSW_M3 21
#define CSW_M4A1 22
#define CSW_TMP 23
#define CSW_G3SG1 24
#define CSW_FLASHBANG 25
#define CSW_DEAGLE 26
#define CSW_SG552 27
#define CSW_AK47 28
#define CSW_KNIFE 29
#define CSW_P90 30
/* Parts of body for hits */
#define HIT_GENERIC 0 /* none */
#define HIT_HEAD 1
#define HIT_CHEST 2
#define HIT_STOMACH 3
#define HIT_LEFTARM 4
#define HIT_RIGHTARM 5
#define HIT_LEFTLEG 6
#define HIT_RIGHTLEG 7
/* Constants for emit_sound() */
/* Channels */
#define CHAN_AUTO 0
#define CHAN_WEAPON 1
#define CHAN_VOICE 2
#define CHAN_ITEM 3
#define CHAN_BODY 4
#define CHAN_STREAM 5 /* allocate stream channel from the static or dynamic area */
#define CHAN_STATIC 6 /* allocate channel from the static area */
#define CHAN_NETWORKVOICE_BASE 7 /* voice data coming across the network */
#define CHAN_NETWORKVOICE_END 500 /* network voice data reserves slots (CHAN_NETWORKVOICE_BASE through CHAN_NETWORKVOICE_END). */
/* Attenuation values */
#define ATTN_NONE 0.00
#define ATTN_NORM 0.80
#define ATTN_IDLE 2.00
#define ATTN_STATIC 1.25
/* Pitch values */
#define PITCH_NORM 100 /* non-pitch shifted */
#define PITCH_LOW 95 /* other values are possible - 0-255, where 255 is very high */
#define PITCH_HIGH 120
/* Volume values */
#define VOL_NORM 1.0
/* Destination types for client_print() */
enum {
print_notify = 1,
print_console,
print_chat,
print_center,
}
/* Destination types for engclient_print() */
enum {
engprint_console = 0,
engprint_center,
engprint_chat,
}
/* Render for set_user_rendering() */
enum {
kRenderNormal, /* src */
kRenderTransColor, /* c*a+dest*(1-a) */
kRenderTransTexture, /* src*a+dest*(1-a) */
kRenderGlow, /* src*a+dest -- No Z buffer checks */
kRenderTransAlpha, /* src*srca+dest*(1-srca) */
kRenderTransAdd, /* src*a+dest */
}
/* Fx for set_user_rendering() */
enum {
kRenderFxNone = 0,
kRenderFxPulseSlow,
kRenderFxPulseFast,
kRenderFxPulseSlowWide,
kRenderFxPulseFastWide,
kRenderFxFadeSlow,
kRenderFxFadeFast,
kRenderFxSolidSlow,
kRenderFxSolidFast,
kRenderFxStrobeSlow,
kRenderFxStrobeFast,
kRenderFxStrobeFaster,
kRenderFxFlickerSlow,
kRenderFxFlickerFast,
kRenderFxNoDissipation,
kRenderFxDistort, /* Distort/scale/translate flicker */
kRenderFxHologram, /* kRenderFxDistort + distance fade */
kRenderFxDeadPlayer, /* kRenderAmt is the player index */
kRenderFxExplode, /* Scale up really big! */
kRenderFxGlowShell, /* Glowing Shell */
kRenderFxClampMinScale, /* Keep this sprite from getting very small (SPRITES only!) */
}
enum {
force_exactfile, /* File on client must exactly match server's file */
force_model_samebounds, /* For model files only, the geometry must fit in the same bbox */
force_model_specifybounds, /* For model files only, the geometry must fit in the specified bbox */
}

104
plugins/include/amxmisc.inc Executable file
View File

@ -0,0 +1,104 @@
/* AMX Mod misc.
*
* (c) 2002-2003, OLO
* This file is provided as is (no warranties).
*/
#if defined _amxmisc_included
#endinput
#endif
#define _amxmisc_included
stock cmd_access(a,b,c,d){
if ( ((get_user_flags(a)&b)!=b) && (a!=(is_dedicated_server()?0:1)) ){
console_print(a,"You have no access to that command")
return 0
}
if (read_argc() < d){
new hcmd[32], hinfo[128], hflag
get_concmd(c,hcmd,31,hflag,hinfo,127,b)
console_print(a,"Usage: %s %s",hcmd,hinfo)
return 0
}
return 1
}
stock access(id,level)
return (get_user_flags(id) & level)
/* Flags:
* 1 - obey immunity
* 2 - allow yourself
* 4 - must be alive
* 8 - can't be bot
*/
stock cmd_target(id,const arg[],flags = 1) {
new player = find_player("bl",arg)
if (player){
if ( player != find_player("blj",arg) ){
console_print(id,"There are more clients matching to your argument")
return 0
}
}
else if ( ( player = find_player("c",arg) )==0 && arg[0]=='#' && arg[1] )
player = find_player("k",strtonum(arg[1]))
if (!player){
console_print(id,"Client with that name or userid not found")
return 0
}
if (flags & 1){
if ((get_user_flags(player)&ADMIN_IMMUNITY) && ((flags&2)?(id!=player):true) ){
new imname[32]
get_user_name(player,imname,31)
console_print(id,"Client ^"%s^" has immunity",imname)
return 0
}
}
if (flags & 4){
if (!is_user_alive(player)){
new imname[32]
get_user_name(player,imname,31)
console_print(id,"That action can't be performed on dead client ^"%s^"",imname)
return 0
}
}
if (flags & 8){
if (is_user_bot(player)){
new imname[32]
get_user_name(player,imname,31)
console_print(id,"That action can't be performed on bot ^"%s^"",imname)
return 0
}
}
return player
}
stock show_activity( id, const name[], {Float,_}: ... ){
new buffer[128]
format_args( buffer , 127 , 2 )
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"%s %s: %s",
(get_user_flags(id) & ADMIN_USER) ? "PLAYER" : "ADMIN" , name , buffer )
case 1: client_print(0,print_chat,"%s: %s",
(get_user_flags(id) & ADMIN_USER) ? "PLAYER" : "ADMIN", buffer )
}
}
stock is_running(const arg[]){
new mod_name[32]
get_modname(mod_name,31)
return equal(mod_name,arg)
}
stock build_path( path[] , len , {Float,_}:... ) {
new basedir[32]
get_localinfo( "amx_basedir", basedir , 31 )
format_args( path , len , 2 )
return replace( path , len , "$basedir", basedir )
}
stock get_basedir( name[], len )
return get_localinfo( "amx_basedir", name , len )
stock get_logfile( name[], len )
return get_time("admin%m%d.log",name,len)

560
plugins/include/amxmod.inc Executable file
View File

@ -0,0 +1,560 @@
/* AMX Mod functions
*
* (c) 2002-2003, OLO
* This file is provided as is (no warranties).
*/
#if defined _amxmod_included
#endinput
#endif
#define _amxmod_included
#include <core>
#include <float>
#include <amxconst>
#include <string>
#include <file>
#include <fun>
#include <vault>
/* Function is called just after server activation.
* Good place for configuration loading, commands and cvars registration. */
forward plugin_init();
/* Function is called when all plugin_init from plugins
* were called, so all commmands and cvars should be already registered. */
forward plugin_cfg();
/* Function called before plugin unloading (server deactivation) */
forward plugin_end();
/* Called on log message. */
forward plugin_log();
/* Use here model_precache() and sound_precache() functions. */
forward plugin_precache();
/* Whenever player info is changed, this function is called. */
forward client_infochanged(id);
/* Called on client connection. */
forward client_connect(id);
/* Called when client gets valid STEAM id (usually
* between client_connect() and client_putinserver()). */
forward client_authorized(id);
/* Called when client is disconnecting from server. */
forward client_disconnect(id);
/* Called when client is sending command. */
forward client_command(id);
/* Called when client is entering to a game. */
forward client_putinserver(id);
/* Sets informations about plugin. */
native register_plugin(const plugin_name[],const version[],const author[]);
/* Gets info about plugin by given index.
* Function returns -1 if plugin doesn't exist with given index. */
native get_plugin(index,filename[],len1,name[],len2,version[],len3,author[],len4,status[],len5);
/* Returns number of all loaded plugins. */
native get_pluginsnum();
/* Precache model. Can be used only in plugin_precache() function.*/
native precache_model(const name[]);
/* Precache sound. Can be used only in plugin_precache() function.*/
native precache_sound(const name[]);
/* Sets info for player. */
native set_user_info(index,const info[],const value[]);
/* Gets info from player. */
native get_user_info(index,const info[],output[],len);
/* Sets info for server. */
native set_localinfo(const info[],const value[]);
/* Gets info from server. */
native get_localinfo(const info[],output[],len);
/* Shows text in MOTD window. When there is no header, the MOTD title
* will be the name of server. If message is filename, then a contents
* of this file will be displayed as MOTD. */
native show_motd(player,const message[],const header[]="");
/* Sends message to player. Set index to 0 to send text globaly. */
native client_print(index,type,const message[],{Float,_}:...);
/* Sends message to player by engine. Set index to 0 to send text globaly. */
native engclient_print(player,type,const message[],{Float,_}:...);
/* Sends message to console. */
native console_print(id,const message[],{Float,_}:...);
/* Sends command to console. */
native console_cmd(id,const cmd[],{Float,_}:...);
/* Registers event on which a given function will be called
* Flags:
* "a" - global event.
* "b" - specified.
* "c" - send only once when repeated to other players.
* "d" - call if is send to dead player.
* "e" - to alive.
* Examples for conditions:
* "2=c4" - 2nd parameter of message must be sting "c4".
* "3>10" - 3rd parameter must be greater then 10.
* "3!4" - 3rd must be different from 4.
* "2&Buy" - 2nd parameter of message must contain "Buy" substring.
* "2!Buy" - 2nd parameter of message can't contain "Buy" substring. */
native register_event(const event[],const function[],const flags[],cond[]="", ... );
/* Registers log event on which the given function will be called
* Examples for conditions:
* "0=World triggered" "1=Game_Commencing"
* "1=say"
* "3=Terrorists_Win"
* "1=entered the game"
* "0=Server cvar"
*/
native register_logevent(const function[], argsnum, ... );
/* Sets format for hudmessage. */
native set_hudmessage(red=200, green=100, blue=0, Float:x=-1.0, Float:y=0.35, effects=0, Float:fxtime=6.0, Float:holdtime=12.0, Float:fadeintime=0.1, Float:fadeouttime=0.2,channel=4);
/* Displays HUD message to given player. */
native show_hudmessage(index,const message[],{Float,_}:...);
/* Displays menu. Keys have bit values (key 1 is (1<<0), key 5 is (1<<4) etc.). */
native show_menu(index,keys,const menu[], time = -1);
/* Gets value from client messages.
* When you are asking for string the array and length is needed (read_data(2,name,len)).
* Integer is returned by function (new me = read_data(3)).
* Float is set in second parameter (read_data(3,value)). */
native read_data(value, {Float,_}:... );
/* Returns number of values in client message. */
native read_datanum();
/* Gets log message. Can be called only in plugin_log() forward function. */
native read_logdata(output[],len);
/* Returns number of log arguments.
* Can be called only in plugin_log() forward function. */
native read_logargc();
/* Gets log argument indexed from 0.
* Can be called only in plugin_log() forward function. */
native read_logargv(id,output[],len);
/* Parse log data about user ( "Butcher<5><BOT><TERRORIST>" etc. ). */
native parse_loguser(const text[], name[], nlen, &userid = -2, authid[] = "", alen = 0, team[]="", tlen=0);
/* Prints message to server console.
* You may use text formating (f.e. server_print("%-32s %.2f!","hello",7.345)) */
native server_print(const message[], {Float,_}:...);
/* Returns 1 or 0. */
native is_map_valid(const mapname[]);
/* Returns 1 or 0. */
native is_user_bot(index);
/* Returns 1 or 0. */
native is_user_hltv(index);
/* Returns 1 or 0. */
native is_user_connected(index);
/* Returns 1 or 0. */
native is_user_connecting(index);
/* Returns 1 or 0. */
native is_user_alive(index);
/* Returns 1 or 0. */
native is_dedicated_server();
/* Returns 1 or 0. */
native is_linux_server();
/* If player is not attacked function returns 0, in other
* case returns index of attacking player. On second and third
* parameter you may get info about weapon and body hit place. */
native get_user_attacker(index,...);
/* If player doesn't hit at anything function returns 0.0,
* in other case the distance between hit point and player is returned.
* If player is aiming at another player then the id and part of body are set. */
native Float:get_user_aiming(index,&id,&body,dist=9999);
/* Returns player frags. */
native get_user_frags(index);
/* Returns player deaths. */
native get_user_deaths(index);
/* Returns player armor. */
native get_user_armor(index);
/* Returns player health. */
native get_user_health(index);
/* Returns index. */
native get_user_index(const name[]);
/* Returns ip. */
native get_user_ip(index,ip[],len, without_port = 0);
/* Returns id of currently carried weapon. Gets also
* ammount of ammo in clip and backpack. */
native get_user_weapon(index,&clip,&ammo);
/* Gets ammo and clip from current weapon. */
native get_user_ammo(index,weapon,&clip,&ammo);
/* Converts numbers from range 0 - 999 to words. */
native num_to_word(num,output[],len);
/* Returns team id. When length is greater then 0
* then a name of team is set. */
native get_user_team(index, team[]="", len = 0);
/* Returns player playing time in seconds.
* If flag is set then result is without connection time. */
native get_user_time(index, flag = 0);
/* Gets ping and loss at current time. */
native get_user_ping(index, &ping, &loss);
/* Gets origin from player.
* Modes:
* 0 - current position.
* 1 - position from eyes (weapon aiming).
* 2 - end position from player position.
* 3 - end position from eyes (hit point for weapon).
* 4 - position of last bullet hit (only CS). */
native get_user_origin(index, origin[3], mode = 0);
/* Returns all carried weapons as bit sum. Gets
* also theirs indexes. */
native get_user_weapons(index,weapons[32],&num);
/* Returns weapon name. */
native get_weaponname(id,weapon[],len);
/* Returns player name. */
native get_user_name(index,name[],len);
/* Gets player authid. */
native get_user_authid(index, authid[] ,len);
/* Returns player wonid. */
native get_user_wonid(index);
/* Returns player userid. */
native get_user_userid(index);
/* Slaps player with given power. */
native user_slap(index,power,rnddir=1);
/* Kills player. When flag is set to 1 then death won't decrase frags. */
native user_kill(index,flag=0);
/* Sends message to standard HL logs. */
native log_message(const message[],{Float,_}:...);
/* Sends log message to specified file. */
native log_to_file(const file[],const message[],{Float,_}:...);
/* Returns number of players put in server.
* If flag is set then also connecting are counted. */
native get_playersnum(flag=0);
/* Sets indexes of players.
* Flags:
* "a" - don't collect dead players.
* "b" - don't collect alive players.
* "c" - skip bots.
* "d" - skip real players.
* "e" - match with team.
* "f" - match with part of name.
* "g" - ignore case sensitivity.
* Example: Get all alive CTs: get_players(players,num,"ae","CT") */
native get_players(players[32], &num ,const flags[]="", const team[]="");
/* Gets argument from command. */
native read_argv(id,output[],len);
/* Gets line of all arguments. */
native read_args(output[],len);
/* Returns number of arguments (+ one as command). */
native read_argc();
/* Converts string to sum of bits.
* Example: "abcd" is a sum of 1, 2, 4 and 8. */
native read_flags(const flags[]);
/* Converts sum of bits to string.
* Example: 3 will return "ab". */
native get_flags(flags,output[],len);
/* Find player.
* Flags:
* "a" - with given name.
* "b" - with given part of name.
* "c" - with given authid.
* "d" - with given ip.
* "e" - with given team name.
* "f" - don't look in dead players.
* "g" - don't look in alive players.
* "h" - skip bots.
* "i" - skip real players.
* "j" - return index of last found player.
* "k" - with given userid.
* "l" - ignore case sensitivity. */
native find_player(const flags[], ... );
/* Removes quotes from sentence. */
native remove_quotes(text[]);
/* Executes command on player. */
native client_cmd(index,const command[],{Float,_}:...);
/* This is an emulation of a client command (commands aren't send to client!).
* It allows to execute some commands on players and bots.
* Function is excellent for forcing to do an action related to a game (not settings!).
* The command must stand alone but in arguments you can use spaces. */
native engclient_cmd(index,const command[],arg1[]="",arg2[]="");
/* Executes command on a server console. */
native server_cmd(const command[],{Float,_}:...);
/* Sets a cvar to given value. */
native set_cvar_string(const cvar[],const value[]);
/* If a cvar exists returns 1, in other case 0 */
native cvar_exists(const cvar[]);
/* Removes a cvar flags (not allowed for amx_version,
* fun_version and sv_cheats cvars). */
native remove_cvar_flags(const cvar[],flags = -1);
/* Sets a cvar flags (not allowed for amx_version,
* fun_version and sv_cheats cvars). */
native set_cvar_flags(const cvar[],flags);
/* Returns a cvar flags. */
native get_cvar_flags(const cvar[]);
/* Sets a cvar to given float. */
native set_cvar_float(const cvar[],Float:value);
/* Gets a cvar float. */
native Float:get_cvar_float(const cvarname[]);
/* Gets a cvar integer value. */
native get_cvar_num(const cvarname[]);
/* Sets a cvar with integer value. */
native set_cvar_num(const cvarname[],value);
/* Reads a cvar value. */
native get_cvar_string(const cvarname[],output[],iLen);
/* Returns a name of currently played map. */
native get_mapname(name[],len);
/* Returns time remaining on map in seconds. */
native get_timeleft();
/* Returns a game time. */
native Float:get_gametime();
/* Returns maxplayers setting. */
native get_maxplayers();
/* Returns a name of currently played mod. */
native get_modname(name[],len);
/* Returns time in given format. The most popular is: "%m/%d/%Y - %H:%M:%S". */
native get_time(const format[],output[],len);
/* Returns time in given format. The most popular is: "%m/%d/%Y - %H:%M:%S".
* Last parameter sets time to format. */
native format_time(output[],len, const format[],time = -1);
/* Returns system time in seconds elapsed since 00:00:00 on January 1, 1970.
* Offset is given in seconds.*/
native get_systime(offset = 0);
/* Returns time in input and additionaly fills missing information
* with current time and date. If time is different than -1 then parsed
* time is added to given time.
* Example:
* parset_time( "10:32:54 04/02/2003", "%H:%M:%S %m:%d:%Y" )
* For more information see strptime(...) function from C libraries. */
native parse_time(const input[],const format[], time = -1);
/* Calls function on specified time.
* Flags:
* "a" - repeat.
* "b" - loop task.
* "c" - do task on time after a map timeleft.
* "d" - do task on time before a map timelimit. */
native set_task(Float:time,const function[],id = 0,parameter[]="",len = 0,flags[]="", repeat = 0);
/* Removes all tasks with given id. If outside var is
* set then a task can be removed also when
* was set in another plugin. */
native remove_task(id = 0, outside = 0);
/* Returns 1 if task under given id exists. */
native task_exists(id = 0, outside = 0);
/* Sets flags for player. Set flags to -1 if you want to clear all flags.
* You can use different settings by changing the id, which is from range 0 - 31. */
native set_user_flags(index,flags=-1,id=0);
/* Gets flags from player. Set index to 0 if you want to read flags from server. */
native get_user_flags(index,id=0);
/* Removes flags for player. */
native remove_user_flags(index,flags=-1,id=0);
/* Registers function which will be called from client console. */
native register_clcmd(const client_cmd[],const function[],flags=-1, info[]="");
/* Registers function which will be called from any console. */
native register_concmd(const cmd[],const function[],flags=-1, info[]="");
/* Registers function which will be called from server console. */
native register_srvcmd(const server_cmd[],const function[],flags=-1, info[]="");
/* Gets info about client command. */
native get_clcmd(index, command[], len1, &flags, info[], len2, flag);
/* Returns number of registered client commands. */
native get_clcmdsnum(flag);
/* Gets info about server command. */
native get_srvcmd(index,server_cmd[],len1,&flags, info[],len2, flag);
/* Returns number of registered server commands. */
native get_srvcmdsnum(flag);
/* Gets info about console command. If id is set to 0,
then function returns only server cmds, if positive then
returns only client cmds. in other case returns all console commands. */
native get_concmd(index,cmd[],len1,&flags, info[],len2, flag, id = -1);
/* Returns number of registered console commands. */
native get_concmdsnum(flag,id = -1);
/* Gets unique id of menu. Outside set to 1 allows
* to catch menus outside a plugin where register_menuid is called. */
native register_menuid(const menu[], outside=0 );
/* Calls function when player uses specified menu and proper keys. */
native register_menucmd(menuid,keys, const function[] );
/* Gets what menu the player is watching and what keys for menu he have.
* When there is no menu the index is 0. If the id is negative then the menu
* is VGUI in other case the id is from register_menuid() function. */
native get_user_menu(index,&id,&keys);
/* Forces server to execute sent server command at current time.
* Very useful for map changes, setting cvars and other activities. */
native server_exec();
/* Emits sound. Sample must be precached. */
native emit_sound(index, channel, sample[], Float:vol, Float:att,flags, pitch);
/* Returns distance between two vectors. */
native get_distance(origin1[3],origin2[3]);
/* Registers new cvar for HL engine. */
native register_cvar(const name[],const string[],flags = 0,Float:fvalue = 0.0);
/* Generates random floating point number from a to b. */
native Float:random_float(Float:a,Float:b);
/* Generates random integer from a to b. */
native random_num(a,b);
/* Pauses function or plugin so it won't be executed.
* In most cases param1 is name of function and
* param2 name of plugin (all depends on flags).
* Flags:
* "a" - pause whole plugin.
* "b" - pause function.
* "c" - look outside the plugin (by given plugin name).
* "d" - set "stopped" status when pausing whole plugin.
* "e" - set "locked" status when pausing whole plugin.
* In this status plugin is unpauseable.
* Example: pause("ac","myplugin.amx")
* pause("bc","myfunc","myplugin.amx") */
native pause(flag[], const param1[]="",const param2[]="");
/* Unpauses function or plugin.
* Flags:
* "a" - unpause whole plugin.
* "b" - unpause function.
* "c" - look outside the plugin (by given plugin name). */
native unpause(flag[], const param1[]="",const param2[]="");
/* Returns id of client message.
* Example: get_user_msgid("TextMsg"). */
native get_user_msgid(const name[]);
/* These functinos are used to generate client messages.
* You may generate menu, smoke, shockwaves, thunderlights,
* intermission and many many others messages.
* See HL SDK for more examples. */
native message_begin( dest, msg_type, origin[3]={0,0,0},player=0);
native message_end();
native write_byte( x );
native write_char( x );
native write_short( x );
native write_long( x );
native write_entity( x );
native write_angle( x );
native write_coord( x );
native write_string( x[] );
/* Called on inconsistent file. You can put any text
* into reason to change an original message. */
forward inconsistent_file(id,const filename[], reason[64] );
/* Forces the client and server to be running with the same
* version of the specified file ( e.g., a player model ). */
native force_unmodified(force_type, mins[3] , maxs[3], const filename[]);
/* Checks if public variable with given name exists in loaded plugins. */
native xvar_exists( const name[] );
/* Returns an unique id for public variable specified by name. If such
* variable doesn't exist then returned value is -1. */
native get_xvar_id( const name[] );
/* Returns an integer value of a public variable. Id is a value
* returned by get_xvar_id(...) native. */
native get_xvar_num( id );
/* Returns a float value of a public variable. Id is a value
* returned by get_xvar_id(...) native. */
native Float:get_xvar_float( id );
/* Sets a value of a public variable. Id is a value
* returned by get_xvar_id(...) native. */
native set_xvar_num( id, value = 0 );
/* Sets a float value of a public variable. Id is a value
* returned by get_xvar_id(...) native. */
native set_xvar_float( id, Float:value = 0.0 );

39
plugins/include/core.inc Executable file
View File

@ -0,0 +1,39 @@
/* Core functions
*
* (c) Copyright 1998-2002, ITB CompuPhase
* This file is provided as is (no warranties).
*/
#if defined _core_included
#endinput
#endif
#define _core_included
native heapspace();
native funcidx(const name[]);
native numargs();
native getarg(arg, index=0);
native setarg(arg, index=0, value);
native strlen(const string[]);
native strpack(dest[], const source[]);
native strunpack(dest[], const source[]);
native tolower(c);
native toupper(c);
native swapchars(c);
native random(max);
native min(value1, value2);
native max(value1, value2);
native clamp(value, min=cellmin, max=cellmax);
native power(value, exponent);
native sqroot(value);
native time(&hour=0,&minute=0,&second=0);
native date(&year=0,&month=0,&day=0);
native tickcount(&granularity=0);

55
plugins/include/csstats.inc Executable file
View File

@ -0,0 +1,55 @@
/* CS Stats functions
*
* (c) 2002-2003, OLO
* This file is provided as is (no warranties).
*/
#if defined _csstats_included
#endinput
#endif
#define _csstats_included
/* Gets stats from given weapon index. If wpnindex is 0
* then the stats are from all weapons. If weapon has not been used function
* returns 0 in other case 1. Fields in stats are:
* 0 - kills
* 1 - deaths
* 2 - headshots
* 3 - teamkilling
* 4 - shots
* 5 - hits
* 6 - damage
* For body hits fields see amxconst.inc. */
native get_user_wstats(index,wpnindex,stats[8],bodyhits[8]);
/* Gets round stats from given weapon index.*/
native get_user_wrstats(index,wpnindex,stats[8],bodyhits[8]);
/* Gets overall stats which are stored in file on server
* and updated on every respawn or user disconnect.
* Function returns the position in stats by diff. kills to deaths. */
native get_user_stats(index,stats[8],bodyhits[8]);
/* Gets round stats of player. */
native get_user_rstats(index,stats[8],bodyhits[8]);
/* Gets stats with which user have killed/hurt his victim. If victim is 0
* then stats are from all victims. If victim has not been hurt, function
* returns 0 in other case 1. User stats are reset on his respawn. */
native get_user_vstats(index,victim,stats[8],bodyhits[8],wpnname[]="",len=0);
/* Gets stats with which user have been killed/hurt. If killer is 0
* then stats are from all attacks. If killer has not hurt user, function
* returns 0 in other case 1. User stats are reset on his respawn. */
native get_user_astats(index,wpnindex,stats[8],bodyhits[8],wpnname[]="",len=0);
/* Resets life, weapon, victims and attackers user stats. */
native reset_user_wstats(index);
/* Gets overall stats which stored in stats.dat file in amx folder
* and updated on every mapchange or user disconnect.
* Function returns next index of stats entry or 0 if no more exists. */
native get_stats(index,stats[8],bodyhits[8],name[],len);
/* Returns number of all entries in stats. */
native get_statsnum();

34
plugins/include/file.inc Executable file
View File

@ -0,0 +1,34 @@
/* Files functions
*
* (c) 2002-2003, OLO
* This file is provided as is (no warranties).
*/
#if defined _file_included
#endinput
#endif
#define _file_included
/* Reads content from directory.
* Returns index of next element or 0 when end of dir. is reached. */
native read_dir(const dirname[],pos,output[],len,&outlen);
/* Reads line from file. Returns index of next line or 0 when end of file is reached. */
native read_file(const file[],line,text[],len,&txtlen);
/* Writes text to file. Function returns 0 on failure.
* When line is set to -1, the text is added at the end of file. */
native write_file(const file[],const text[],line = -1);
/* Deletes file. Function returns 1 on success, 0 on failure. */
native delete_file(const file[]);
/* Checks for file. If file exists function returns 1, in other case 0. */
native file_exists(const file[]);
/* Returns a file size in bytes if flag is set to 0.
When flag is set to 1 returns number of lines in the file,
and when flags is 2, function returns 1 if the file ends
with line feed. If file doesn't exist returns -1.*/
native file_size(const file[], flag=0);

122
plugins/include/float.inc Executable file
View File

@ -0,0 +1,122 @@
/* Float arithmetic
*
* (c) Copyright 1999, Artran, Inc.
* Written by Greg Garner (gmg@artran.com)
* Modified in March 2001 to include user defined
* operators for the floating point functions.
*
* This file is provided as is (no warranties).
*/
#if defined _float_included
#endinput
#endif
#define _float_included
native Float:float(value);
native Float:floatstr(const string[]);
native Float:floatmul(Float:oper1, Float:oper2);
native Float:floatdiv(Float:dividend, Float:divisor);
native Float:floatadd(Float:dividend, Float:divisor);
native Float:floatsub(Float:oper1, Float:oper2);
native Float:floatfract(Float:value);
enum floatround_method {
floatround_round,
floatround_floor,
floatround_ceil
}
native floatround(Float:value, floatround_method:method=floatround_round);
native floatcmp(Float:fOne, Float:fTwo);
#pragma rational Float
/* user defined operators */
native Float:operator*(Float:oper1, Float:oper2) = floatmul;
native Float:operator/(Float:oper1, Float:oper2) = floatdiv;
native Float:operator+(Float:oper1, Float:oper2) = floatadd;
native Float:operator-(Float:oper1, Float:oper2) = floatsub;
stock Float:operator++(Float:oper)
return oper+1.0;
stock Float:operator--(Float:oper)
return oper-1.0;
stock Float:operator-(Float:oper)
return oper^Float:0x80000000; /* IEEE values are sign/magnitude */
stock Float:operator*(Float:oper1, oper2)
return floatmul(oper1, float(oper2)); /* "*" is commutative */
stock Float:operator/(Float:oper1, oper2)
return floatdiv(oper1, float(oper2));
stock Float:operator/(oper1, Float:oper2)
return floatdiv(float(oper1), oper2);
stock Float:operator+(Float:oper1, oper2)
return floatadd(oper1, float(oper2)); /* "+" is commutative */
stock Float:operator-(Float:oper1, oper2)
return floatsub(oper1, float(oper2));
stock Float:operator-(oper1, Float:oper2)
return floatsub(float(oper1), oper2);
stock bool:operator==(Float:oper1, Float:oper2)
return floatcmp(oper1, oper2) == 0;
stock bool:operator==(Float:oper1, oper2)
return floatcmp(oper1, float(oper2)) == 0; /* "==" is commutative */
stock bool:operator!=(Float:oper1, Float:oper2)
return floatcmp(oper1, oper2) != 0;
stock bool:operator!=(Float:oper1, oper2)
return floatcmp(oper1, float(oper2)) != 0; /* "==" is commutative */
stock bool:operator>(Float:oper1, Float:oper2)
return floatcmp(oper1, oper2) > 0;
stock bool:operator>(Float:oper1, oper2)
return floatcmp(oper1, float(oper2)) > 0;
stock bool:operator>(oper1, Float:oper2)
return floatcmp(float(oper1), oper2) > 0;
stock bool:operator>=(Float:oper1, Float:oper2)
return floatcmp(oper1, oper2) >= 0;
stock bool:operator>=(Float:oper1, oper2)
return floatcmp(oper1, float(oper2)) >= 0;
stock bool:operator>=(oper1, Float:oper2)
return floatcmp(float(oper1), oper2) >= 0;
stock bool:operator<(Float:oper1, Float:oper2)
return floatcmp(oper1, oper2) < 0;
stock bool:operator<(Float:oper1, oper2)
return floatcmp(oper1, float(oper2)) < 0;
stock bool:operator<(oper1, Float:oper2)
return floatcmp(float(oper1), oper2) < 0;
stock bool:operator<=(Float:oper1, Float:oper2)
return floatcmp(oper1, oper2) <= 0;
stock bool:operator<=(Float:oper1, oper2)
return floatcmp(oper1, float(oper2)) <= 0;
stock bool:operator<=(oper1, Float:oper2)
return floatcmp(float(oper1), oper2) <= 0;
stock bool:operator!(Float:oper)
return floatcmp(oper, 0.0) == 0;
/* forbidden operations */
forward operator%(Float:oper1, Float:oper2);
forward operator%(Float:oper1, oper2);
forward operator%(oper1, Float:oper2);

86
plugins/include/fun.inc Executable file
View File

@ -0,0 +1,86 @@
/* Fun functions
*
* (c) 2002-2003, OLO
* This file is provided as is (no warranties).
*/
#if defined _fun_included
#endinput
#endif
#define _fun_included
/* Sets who can listen who. Function returns 0
* if for some reasons this setting can't be done. */
native set_user_listening(receiver,sender,listen);
/* Returns 1 if receiver hears sender via voice communication. */
native get_user_listening(receiver,sender);
/* Sets player godmode. If you want to disable godmode set only first parameter. */
native set_user_godmode(index,godmode = 0);
/* Returns 1 if godmode is set. */
native get_user_godmode(index);
/* Sets player noclip. If you want to disable noclip set only first parameter. */
native set_user_noclip(index,noclip = 0);
/* Returns 1 if noclip is set. */
native get_user_noclip(index);
/* Sets player frags. */
native set_user_frags(index,frags);
/* Sets player armor. */
native set_user_armor(index,armor);
/* Sets player health. */
native set_user_health(index, health);
/* Move player to origin. */
native set_user_origin(index, origin[3]);
/* Sets player rendering mode. */
native set_user_rendering(index,fx = kRenderFxNone, r=255,g=255,b=255, render = kRenderNormal,amount=16);
/* Gives item to player, name of item can start
* with weapon_, ammo_ and item_. This event
* is announced with proper message to all players. */
native give_item(index,const item[]);
/* Sets hit zones for player. This event is announced
* with proper message to all players.
* Parts of body are as bits:
* 2 - head
* 4 - chest
* 8 - stomach
* 16 - left arm
* 32 - right arm
* 64 - left leg
* 128 - right leg*/
native set_user_hitzones(index=0,target=0,body=255);
/* Returns hit zones for player. */
native get_user_hitzones(index,target);
/* Makes that player spawns. This event is announced
* with proper message to all players. */
native user_spawn(index);
/* Sets users max. speed. */
native set_user_maxspeed(index,Float:speed=-1.0);
/* Returns users max. speed. */
native Float:get_user_maxspeed(index);
/* Sets users gravity. */
native set_user_gravity(index,Float:gravity=1.0);
/* Returns users gravity. */
native Float:get_user_gravity(index);
/* Gives money to user. */
native set_user_money(index,money,flash=1);
/* Returns users money. */
native get_user_money(index);

30
plugins/include/mysql.inc Executable file
View File

@ -0,0 +1,30 @@
/* MySQL functions
*
* (c) Copyright 2002, dJeyL
* This file is provided as is (no warranties).
*/
#if defined _mysql_included
#endinput
#endif
#define _mysql_included
/* Opens connection. If already such exists then that will be used.
* Function returns sql id to use with other sql natives.
* Host can be plain ip or with port seperated with ':' char. */
native mysql_connect(host[],user[],pass[],dbname[],error[],maxlength);
/* Uses an existing connection (sql) to perform a new query (query) (might close previous query if any). */
native mysql_query(sql,query[]);
/* Prepares next row of current query (sql) for read access ; returns the number of the row, 0 at end. */
native mysql_nextrow(sql);
/* Stores specified column (fieldnum) of current query (sql) in (dest) with (maxlength) characters maximum. */
native mysql_getfield(sql,fieldnum,dest[],maxlength);
/* Clears query (sql) and closes connection (if any other plugin doesn't use it). */
native mysql_close(sql);
/* Stores last error of current query/connection (sql) in (dest) with (maxlength) characters maximum. */
native mysql_error(sql,dest[],maxlength);

85
plugins/include/string.inc Executable file
View File

@ -0,0 +1,85 @@
/* Strings manipulation
*
* (c) 2002-2003, OLO
* This file is provided as is (no warranties).
*/
#if defined _string_included
#endinput
#endif
#define _string_included
/* Checks if source contains string. On success function
* returns position in source, on failure returns -1. */
native contain(const source[],const string[]);
/* Checks if source contains string with case ignoring. On success function
* returns position in source, on failure returns -1. */
native containi(const source[],const string[]);
/* Replaces given string to another in given text. */
native replace(text[],len,const what[],const with[]);
/* Adds one string to another. Last parameter different from 0, specifies
* how many chars we want to add. Function returns number of all merged chars. */
native add(dest[],len,const src[],max=0);
/* Fills string with given format and parameters.
* Function returns number of copied chars.
* Example: format(dest,"Hello %s. You are %d years old","Tom",17). */
native format(output[] ,len ,const format[] , {Float,_}:...);
/* Gets parameters from function as formated string. */
native format_args(output[] ,len ,pos = 0);
/* Converts number to string. */
native num_to_str(num,string[],len);
native numtostr(num,string[],len);
/* Returns converted string to number. */
native str_to_num(const string[]);
native strtonum(const string[]);
/* Checks if two strings equal. If len var is set
* then there are only c chars comapred. */
native equal(const a[],const b[],c=0);
/* Checks if two strings equal with case ignoring.
* If len var is set then there are only c chars comapred. */
native equali(const a[],const b[],c=0);
/* Copies one string to another. By len var
* you may specify max. number of chars to copy. */
native copy(dest[],len,const src[]);
/* Copies one string to another until char ch is found.
* By len var you may specify max. number of chars to copy. */
native copyc(dest[],len,const src[],ch);
/* Sets string with given character. */
native setc(src[],len,ch);
/* Gets parameters from text.
* Example: to split text: "^"This is^" the best year",
* call function like this: parse(text,arg1,len1,arg2,len2,arg3,len3,arg4,len4)
* and you will get: "This is", "the", "best", "year"
* Function returns number of parsed parameters. */
native parse(const text[], ... );
/* Converts all chars in string to lower case. */
native strtolower(string[]);
/* Converts all chars in string to upper case. */
native strtoupper(string[]);
/* Returns true when value is digit. */
native isdigit(ch);
/* Returns true when value is letter. */
native isalpha(ch);
/* Returns true when value is space. */
native isspace(ch);
/* Returns true when value is letter or digit. */
native isalnum(ch);

24
plugins/include/vault.inc Executable file
View File

@ -0,0 +1,24 @@
/* Vault
*
* (c) 2002-2003, OLO
* This file is provided as is (no warranties).
*/
#if defined _vault_included
#endinput
#endif
#define _vault_included
/* Reads a data from given key.
* If len is set to zero then get_vaultdata
* returns value as an number. */
native get_vaultdata(const key[], data[] = "", len = 0);
/* Sets a data under given key. */
native set_vaultdata(const key[], const data[] = "" );
/* Removes a key from vault.*/
native remove_vaultdata(const key[]);
/* Checks if a key exists in the vault.*/
native vaultdata_exists(const key[]);

191
plugins/mapchooser.sma Executable file
View File

@ -0,0 +1,191 @@
/* AMX Mod script.
*
* (c) 2002-2003, OLO
* This file is provided as is (no warranties).
*
* On two minutes before the timelimit plugin
* displays menu with 5 random maps to select.
* One of the options is also map extending.
* Map with most votes becomes the nextmap.
*
* Maps to selected are in maps.ini file.
*
* Cvars:
* amx_extendmap_max <time in mins.> - max. time for overall extending
* amx_extendmap_step <time in mins.> - with what time the map will be extended
*
* NOTE: Nextmap plugin is required for proper working of this plugin.
*/
#include <amxmod>
#include <amxmisc>
#define MAX_MAPS 128
#define SELECTMAPS 5
new g_mapName[MAX_MAPS][32]
new g_mapNums
new g_nextName[SELECTMAPS]
new g_voteCount[SELECTMAPS+2]
new g_mapVoteNum
new g_teamScore[2]
new g_lastMap[32]
new g_cstrikeRunning
new bool:g_selected = false
new g_logFile[16]
public plugin_init()
{
register_plugin("Nextmap chooser","0.9","default")
register_menucmd(register_menuid("AMX Choose nextmap:"),(-1^(-1<<(SELECTMAPS+2))),"countVote")
register_cvar("amx_extendmap_max","90")
register_cvar("amx_extendmap_step","15")
if ( ( g_cstrikeRunning = is_running("cstrike") ) != 0 )
register_event("TeamScore", "team_score", "a")
get_localinfo("lastMap",g_lastMap,31)
set_localinfo("lastMap","")
get_logfile(g_logFile,15)
new filename[64]
build_path( filename , 63 , "$basedir/maps.ini" )
if ( loadSettings( filename ) )
set_task(15.0,"voteNextmap",987456,"",0,"b")
}
public checkVotes(){
new b = 0
for(new a = 0; a < g_mapVoteNum; ++a)
if (g_voteCount[b] < g_voteCount[a])
b = a
if ( g_voteCount[SELECTMAPS] > g_voteCount[b] ) {
new mapname[32]
get_mapname(mapname,31)
new Float:steptime = get_cvar_float("amx_extendmap_step")
set_cvar_float("mp_timelimit", get_cvar_float("mp_timelimit") + steptime )
client_print(0,print_chat,"Choosing finished. Current map will be extended to next %.0f minutes", steptime )
log_to_file(g_logFile,"Vote: Voting for the nextmap finished. Map %s will be extended to next %.0f minutes",
mapname , steptime )
return
}
if ( g_voteCount[b] && g_voteCount[SELECTMAPS+1] <= g_voteCount[b] )
set_cvar_string("amx_nextmap", g_mapName[g_nextName[b]] )
new smap[32]
get_cvar_string("amx_nextmap",smap,31)
client_print(0,print_chat,"Choosing finished. The nextmap will be %s", smap )
log_to_file(g_logFile,"Vote: Voting for the nextmap finished. The nextmap will be %s", smap)
}
public countVote(id,key){
if ( get_cvar_float("amx_vote_answers") ) {
new name[32]
get_user_name(id,name,31)
if ( key == SELECTMAPS )
client_print(0,print_chat,"%s chose map extending", name )
else if ( key < SELECTMAPS )
client_print(0,print_chat,"%s chose %s", name, g_mapName[g_nextName[key]] )
}
++g_voteCount[key]
return PLUGIN_HANDLED
}
bool:isInMenu(id){
for(new a=0; a<g_mapVoteNum; ++a)
if (id==g_nextName[a])
return true
return false
}
public voteNextmap(){
new winlimit = get_cvar_num("mp_winlimit")
new maxrounds = get_cvar_num("mp_maxrounds")
if ( winlimit ) {
new c = winlimit - 2
if ( (c > g_teamScore[0]) && (c > g_teamScore[1]) ) {
g_selected = false
return
}
}
else if ( maxrounds ) {
if ( (maxrounds - 2) > (g_teamScore[0] + g_teamScore[1]) ){
g_selected = false
return
}
}
else {
new timeleft = get_timeleft()
if (timeleft<1||timeleft>129){
g_selected = false
return
}
}
if (g_selected)
return
g_selected = true
new menu[512], a, mkeys = (1<<SELECTMAPS+1)
new pos = copy(menu,511,g_cstrikeRunning ? "\yAMX Choose nextmap:\w^n^n" : "AMX Choose nextmap:^n^n")
new dmax = (g_mapNums > SELECTMAPS) ? SELECTMAPS : g_mapNums
for(g_mapVoteNum = 0;g_mapVoteNum<dmax;++g_mapVoteNum){
a=random_num(0,g_mapNums-1)
while( isInMenu(a) )
if (++a >= g_mapNums) a = 0
g_nextName[g_mapVoteNum] = a
pos += format(menu[pos],511,"%d. %s^n",g_mapVoteNum+1,g_mapName[a])
mkeys |= (1<<g_mapVoteNum)
g_voteCount[g_mapVoteNum] = 0
}
menu[pos++]='^n'
g_voteCount[SELECTMAPS] = 0
g_voteCount[SELECTMAPS+1] = 0
new mapname[32]
get_mapname(mapname,31)
if ( (winlimit + maxrounds)==0 && (get_cvar_float("mp_timelimit") < get_cvar_float("amx_extendmap_max"))){
pos += format(menu[pos],511,"%d. Extend map %s^n",SELECTMAPS+1,mapname)
mkeys |= (1<<SELECTMAPS)
}
format(menu[pos],511,"%d. None",SELECTMAPS+2)
show_menu(0,mkeys,menu,15)
set_task(15.0,"checkVotes")
client_print(0,print_chat,"It's time to choose the nextmap...")
client_cmd(0,"spk Gman/Gman_Choose2")
log_to_file(g_logFile,"Vote: Voting for the nextmap started")
}
loadSettings(filename[])
{
if (!file_exists(filename)) return 0
new szText[32]
new a, pos = 0
new currentMap[32]
get_mapname(currentMap,31)
while ( (g_mapNums < MAX_MAPS) && read_file(filename,pos++,szText,31,a) )
{
if ( szText[0] != ';'
&& parse(szText, g_mapName[g_mapNums] ,31 )
&& is_map_valid( g_mapName[g_mapNums] )
&& !equali( g_mapName[g_mapNums] ,g_lastMap)
&& !equali( g_mapName[g_mapNums] ,currentMap) )
++g_mapNums
}
return g_mapNums
}
public team_score(){
new team[2]
read_data(1,team,1)
g_teamScore[ (team[0]=='C') ? 0 : 1 ] = read_data(2)
}
public plugin_end(){
new current_map[32]
get_mapname(current_map,31 )
set_localinfo("lastMap",current_map)
}

473
plugins/mapsmenu.sma Executable file
View File

@ -0,0 +1,473 @@
/* AMX Mod script.
*
* (c) 2003, OLO
* This file is provided as is (no warranties).
*
* Content for configuation copied from ClanMod cfg. file.
*
* Admin command:
* amx_mapmenu - displays maps menu
*
* Example configuration in addons/amx/maps.ini
as_oilrig "OilRig - Assassination"
as_tundra "Tundra - Assassination"
de_aztec "Aztec - Bomb/Defuse"
de_cbble "Cobble - Bomb/Defuse"
de_chateau "Chateau - Bomb/Defuse"
de_dust "Dust - Bomb/Defuse"
de_dust2 "Dust II - Bomb/Defuse"
de_inferno "Inferno - Bomb/Defuse"
de_nuke "Nuke - Bomb/Defuse"
de_prodigy "Prodigy - Bomb/Defuse"
de_storm "Storm - Bomb/Defuse"
de_survivor "Survivor - Bomb/Defuse"
de_train "Trainyard - Bomb/Defuse"
de_torn "Torn - Bomb/Defuse"
de_vegas "Vegas - Bomb/Defuse"
de_vertigo "Vertigo - Bomb/Defuse"
cs_747 "747 Hijack - Hostage Rescue"
cs_assault "Assault - Hostage Rescue"
cs_backalley "Alleyway - Hostage Rescue"
cs_estate "Zaphod's Estate - Hostage Rescue"
cs_havana "Havana - Hostage Rescue"
cs_italy "Italy - Hostage Rescue"
cs_militia "Militia - Hostage Rescue"
cs_office "The Office Complex - Hostage Rescue"
cs_siege "Canyon Siege - Hostage Rescue"
*/
#include <amxmod>
#include <amxmisc>
#define MAX_MAPS 64
new g_mapName[MAX_MAPS][32]
new g_mapDesc[MAX_MAPS][32]
new g_mapNums
new g_menuPosition[33]
new g_logFile[16]
new g_voteCount[5]
new g_voteSelected[33][4]
new g_voteSelectedNum[33]
new g_cstrikeRunning
new g_choosed
public plugin_init()
{
register_plugin("Maps Menu","0.9","default")
register_clcmd("amx_mapmenu","cmdMapsMenu",ADMIN_MAP,"- displays changelevel menu")
register_clcmd("amx_votemapmenu","cmdVoteMapMenu",ADMIN_MAP,"- displays votemap menu")
register_menucmd(register_menuid("Changelevel Menu"),1023,"actionMapsMenu")
register_menucmd(register_menuid("Which map do you want?"),527,"voteCount")
register_menucmd(register_menuid("Change map to"),527,"voteCount")
register_menucmd(register_menuid("Votemap Menu"),1023,"actionVoteMapMenu")
register_menucmd(register_menuid("The winner: ") ,3,"actionResult")
new filename[64]
build_path( filename , 63 , "$basedir/maps.ini" )
load_settings( filename )
get_logfile(g_logFile,15)
g_cstrikeRunning = is_running("cstrike")
}
new g_resultAck[] = "Result accepted"
new g_resultRef[] = "Result refused"
public autoRefuse(){
log_to_file(g_logFile,"Vote: %s" , g_resultRef)
client_print(0,print_chat, g_resultRef )
}
public actionResult(id,key) {
remove_task( 4545454 )
switch(key){
case 0: {
message_begin(MSG_ALL, SVC_INTERMISSION)
message_end()
set_task(2.0,"delayedChange",0, g_mapName[ g_choosed ] , strlen(g_mapName[ g_choosed ]) + 1 )
log_to_file(g_logFile,"Vote: %s" , g_resultAck )
client_print(0,print_chat, g_resultAck)
}
case 1: autoRefuse()
}
return PLUGIN_HANDLED
}
new g_voteSuccess[] = "Voting successful. Map will be changed to"
new g_VoteFailed[] = "Voting failed"
public checkVotes( id )
{
id -= 34567
new num, ppl[32],a = 0
get_players(ppl,num,"c")
if (num == 0) num = 1
g_choosed = -1
for(new i = 0; i < g_voteSelectedNum[id] ; ++i)
if ( g_voteCount[a] < g_voteCount[i] )
a = i
if ( 100 * g_voteCount[a] / num > 50 ) {
g_choosed = g_voteSelected[id][a]
client_print(0,print_chat, "%s %s" , g_voteSuccess , g_mapName[ g_choosed ] )
log_to_file(g_logFile,"Vote: %s %s" , g_voteSuccess , g_mapName[ g_choosed ] )
}
if ( g_choosed != -1 ) {
if ( is_user_connected( id ) ) {
new menuBody[512]
new len = format(menuBody,511,g_cstrikeRunning ? "\yThe winner: \w%s^n^n" : "The winner: %s^n^n", g_mapName[ g_choosed ] )
len += copy( menuBody[len] ,511 - len, g_cstrikeRunning ? "\yDo you want to continue?^n\w" : "Do you want to continue?^n" )
copy( menuBody[len] ,511 - len, "^n1. Yes^n2. No")
show_menu( id ,0x03 ,menuBody, 10 )
set_task(10.0,"autoRefuse",4545454)
}
else {
message_begin(MSG_ALL, SVC_INTERMISSION)
message_end()
set_task(2.0,"delayedChange",0, g_mapName[ g_choosed ] , strlen(g_mapName[ g_choosed ]) + 1 )
}
}
else {
client_print(0,print_chat, g_VoteFailed )
log_to_file(g_logFile,"Vote: %s" , g_VoteFailed)
}
remove_task(34567 + id)
}
public voteCount(id,key)
{
if (key > 3) {
client_print(0,print_chat,"Voting has been canceled")
remove_task(34567 + id)
set_cvar_float( "amx_last_voting" , get_gametime() )
log_to_file(g_logFile,"Vote: Cancel vote session")
return PLUGIN_HANDLED
}
if (get_cvar_float("amx_vote_answers")) {
new name[32]
get_user_name(id,name,31)
client_print(0,print_chat,"%s voted for option #%d", name , key + 1 )
}
++g_voteCount[key]
return PLUGIN_HANDLED
}
isMapSelected( id , pos )
{
for( new a = 0 ; a < g_voteSelectedNum[ id ]; ++a )
if ( g_voteSelected[ id ][ a ] == pos )
return 1
return 0
}
displayVoteMapsMenu(id,pos)
{
if (pos < 0)
return
new menuBody[512], b = 0 , start = pos * 7
if (start >= g_mapNums)
start = pos = g_menuPosition[id] = 0
new len = format(menuBody,511, g_cstrikeRunning ?
"\yVotemap Menu\R%d/%d^n\w^n" : "Votemap Menu %d/%d^n^n",
pos+1,( g_mapNums / 7 + (( g_mapNums % 7) ? 1 : 0 )) )
new end = start + 7, keys = (1<<9)
if (end > g_mapNums)
end = g_mapNums
for(new a = start; a < end; ++a)
{
if ( g_voteSelectedNum[id]==4 || isMapSelected( id , pos * 7 + b ) )
{
++b
if ( g_cstrikeRunning)
len += format(menuBody[len],511-len,"\d%d. %s^n\w", b ,g_mapDesc[ a ])
else
len += format(menuBody[len],511-len,"#. %s^n", g_mapDesc[ a ])
}
else
{
keys |= (1<<b)
len += format(menuBody[len],511-len,"%d. %s^n", ++b ,g_mapDesc[ a ])
}
}
if ( g_voteSelectedNum[id] )
{
keys |= (1<<7)
len += format(menuBody[len],511-len,"^n8. Start Voting^n")
}
else
len += format(menuBody[len],511-len, g_cstrikeRunning ?
"^n\d8. Start Voting^n\w" : "^n#. Start Voting^n")
if (end != g_mapNums)
{
len += format(menuBody[len],511-len,"^n9. More...^n0. %s^n", pos ? "Back" : "Exit")
keys |= (1<<8)
}
else
len += format(menuBody[len],511-len,"^n0. %s^n", pos ? "Back" : "Exit")
len += format(menuBody[len],511-len, g_voteSelectedNum[id] ?
( g_cstrikeRunning ? "^n\ySelected Maps:^n\w" : "^nSelected Maps:^n") : "^n^n")
for(new c = 0; c < 4; c++)
{
if ( c < g_voteSelectedNum[id] )
len += format(menuBody[len],511-len,"%s^n", g_mapDesc[ g_voteSelected[id][ c ] ] )
else
len += format(menuBody[len],511-len,"^n" )
}
show_menu(id,keys,menuBody)
}
public cmdVoteMapMenu(id,level,cid)
{
if (!cmd_access(id,level,cid,1))
return PLUGIN_HANDLED
if ( get_cvar_float("amx_last_voting") > get_gametime() )
{
client_print(id,print_chat,"There is already one voting...")
return PLUGIN_HANDLED
}
g_voteSelectedNum[id] = 0
if ( g_mapNums )
{
displayVoteMapsMenu(id,g_menuPosition[id] = 0)
}
else
{
console_print(id,"There are no maps in menu")
client_print(id,print_chat,"There are no maps in menu")
}
return PLUGIN_HANDLED
}
public cmdMapsMenu(id,level,cid)
{
if (!cmd_access(id,level,cid,1))
return PLUGIN_HANDLED
if ( g_mapNums )
{
displayMapsMenu(id,g_menuPosition[id] = 0)
}
else
{
console_print(id,"There are no maps in menu")
client_print(id,print_chat,"There are no maps in menu")
}
return PLUGIN_HANDLED
}
public delayedChange(mapname[])
server_cmd("changelevel %s",mapname)
public actionVoteMapMenu(id,key)
{
switch(key){
case 7:{
new Float:voting = get_cvar_float("amx_last_voting")
if ( voting > get_gametime() ){
client_print(id,print_chat,"There is already one voting...")
return PLUGIN_HANDLED
}
if (voting && voting + get_cvar_float("amx_vote_delay") > get_gametime()) {
client_print(id,print_chat,"Voting not allowed at this time")
return PLUGIN_HANDLED
}
g_voteCount = { 0 , 0 , 0 , 0 , 0 }
new Float:vote_time = get_cvar_float("amx_vote_time") + 2.0
set_cvar_float("amx_last_voting", get_gametime() + vote_time )
new iVoteTime = floatround( vote_time )
set_task( vote_time , "checkVotes",34567 + id)
new menuBody[512]
new players[32]
new pnum, keys, len
get_players(players,pnum)
if ( g_voteSelectedNum[id] > 1 )
{
len = format(menuBody,511,g_cstrikeRunning ?
"\yWhich map do you want?^n\w^n" : "Which map do you want?^n^n")
for(new c = 0; c < g_voteSelectedNum[id] ; ++c)
{
len += format(menuBody[len],511,"%d. %s^n", c + 1 , g_mapDesc[ g_voteSelected[id][ c ] ] )
keys |= (1<<c)
}
keys |= (1<<8)
len += format(menuBody[len],511,"^n9. None^n")
}
else
{
len = format(menuBody,511, g_cstrikeRunning ? "\yChange map to^n%s?^n\w^n1. Yes^n2. No^n"
: "Change map to^n%s?^n^n1. Yes^n2. No^n" , g_mapDesc[ g_voteSelected[id][ 0 ] ] )
keys = (1<<0) | (1<<1)
}
for(new b = 0; b < pnum; ++b)
if ( players[b] != id )
show_menu(players[b],keys,menuBody, iVoteTime)
format(menuBody[len],511,"^n0. Cancel Vote")
keys |= (1<<9)
show_menu(id,keys,menuBody, iVoteTime)
new authid[32],name[32]
get_user_authid(id,authid,31)
get_user_name(id,name,31)
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"ADMIN %s: vote map(s)",name)
case 1: client_print(0,print_chat,"ADMIN: vote map(s)")
}
log_to_file(g_logFile,"Vote: ^"%s<%d><%s><>^" vote maps (map#1 ^"%s^") (map#2 ^"%s^") (map#3 ^"%s^") (map#4 ^"%s^")",
name,get_user_userid(id),authid,
g_voteSelectedNum[id] > 0 ? g_mapName[ g_voteSelected[id][ 0 ] ] : "" ,
g_voteSelectedNum[id] > 1 ? g_mapName[ g_voteSelected[id][ 1 ] ] : "" ,
g_voteSelectedNum[id] > 2 ? g_mapName[ g_voteSelected[id][ 2 ] ] : "",
g_voteSelectedNum[id] > 3 ? g_mapName[ g_voteSelected[id][ 3 ] ] : "")
}
case 8: displayVoteMapsMenu(id,++g_menuPosition[id])
case 9: displayVoteMapsMenu(id,--g_menuPosition[id])
default:
{
g_voteSelected[id][ g_voteSelectedNum[id]++ ] = g_menuPosition[id] * 7 + key
displayVoteMapsMenu(id,g_menuPosition[id])
}
}
return PLUGIN_HANDLED
}
public actionMapsMenu(id,key)
{
switch(key){
case 8: displayMapsMenu(id,++g_menuPosition[id])
case 9: displayMapsMenu(id,--g_menuPosition[id])
default:
{
new a = g_menuPosition[id] * 8 + key
message_begin(MSG_ALL, SVC_INTERMISSION)
message_end()
new authid[32],name[32]
get_user_authid(id,authid,31)
get_user_name(id,name,31)
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"ADMIN %s: changelevel %s",name,g_mapName[ a ])
case 1: client_print(0,print_chat,"ADMIN: changelevel %s",g_mapName[ a ])
}
log_to_file(g_logFile,"Cmd: ^"%s<%d><%s><>^" changelevel ^"%s^"",
name,get_user_userid(id),authid, g_mapName[ a ] )
set_task(2.0,"delayedChange",0, g_mapName[ a ] , strlen(g_mapName[ a ]) + 1 )
/* displayMapsMenu(id,g_menuPosition[id]) */
}
}
return PLUGIN_HANDLED
}
displayMapsMenu(id,pos)
{
if (pos < 0)
return
new menuBody[512]
new start = pos * 8
new b = 0
if (start >= g_mapNums)
start = pos = g_menuPosition[id] = 0
new len = format(menuBody,511, g_cstrikeRunning ?
"\yChangelevel Menu\R%d/%d^n\w^n" : "Changelevel Menu %d/%d^n^n",
pos+1,( g_mapNums / 8 + (( g_mapNums % 8) ? 1 : 0 )) )
new end = start + 8
new keys = (1<<9)
if (end > g_mapNums)
end = g_mapNums
for(new a = start; a < end; ++a)
{
keys |= (1<<b)
len += format(menuBody[len],511-len,"%d. %s^n",++b,g_mapDesc[ a ])
}
if (end != g_mapNums)
{
format(menuBody[len],511-len,"^n9. More...^n0. %s", pos ? "Back" : "Exit")
keys |= (1<<8)
}
else format(menuBody[len],511-len,"^n0. %s", pos ? "Back" : "Exit")
show_menu(id,keys,menuBody)
}
load_settings(filename[])
{
if (!file_exists(filename))
return 0
new text[256], szDesc[48]
new a , pos = 0
while ( g_mapNums < MAX_MAPS && read_file(filename,pos++,text,255,a) )
{
if ( text[0] == ';' ) continue
if ( parse(text, g_mapName[g_mapNums] ,31, szDesc ,47) < 2 ) continue
if ( !is_map_valid( g_mapName[g_mapNums] ) ) continue
if ( strlen( szDesc ) > 31 )
{
copy(g_mapDesc[g_mapNums],28, szDesc )
g_mapDesc[g_mapNums][28] = g_mapDesc[g_mapNums][29] = g_mapDesc[g_mapNums][30] = '.'
g_mapDesc[g_mapNums][31] = 0
}
else copy(g_mapDesc[g_mapNums],31, szDesc )
g_mapNums++
}
return 1
}

175
plugins/menufront.sma Executable file
View File

@ -0,0 +1,175 @@
/* AMX Mod script.
*
* (c) 2003, OLO
* This file is provided as is (no warranties).
*
*/
#include <amxmod>
#include <amxmisc>
new g_menuPosition[33]
#define MENUS_NUMBER 15
new g_menuBody[MENUS_NUMBER][] = {
"Kick Player",
"Ban Player",
"Slap/Slay Player",
"Team Player^n",
"Changelevel",
"Vote for maps^n",
"Speech Stuff",
"Client Commands",
// Next Page
"Server Commands",
"Cvars Settings",
"Configuration",
"Stats Settings^n",
"Pause Plugins",
"Restrict Weapons",
"Teleport Player" /* Last is Teleport menu - if you want to move
it change also code in displayMenu (look for fun module check) */
}
new g_menuCmd[MENUS_NUMBER][] = {
"amx_kickmenu",
"amx_banmenu",
"amx_slapmenu",
"amx_teammenu",
"amx_mapmenu",
"amx_votemapmenu",
"amx_speechmenu",
"amx_clcmdmenu",
// Next Page
"amx_cmdmenu",
"amx_cvarmenu",
"amx_cfgmenu",
"amx_statscfgmenu",
"amx_pausecfgmenu",
"amx_restmenu",
"amx_teleportmenu"
}
// Second value sets if menu is only for CS...
new g_menuAccess[MENUS_NUMBER][2] = {
{ADMIN_KICK,0},
{ADMIN_BAN,0},
{ADMIN_SLAY,0},
{ADMIN_LEVEL_A,1},
{ADMIN_MAP,0},
{ADMIN_MAP,0},
{ADMIN_MENU,0},
{ADMIN_LEVEL_A,0},
// Next Page
{ADMIN_MENU,0},
{ADMIN_CVAR,0},
{ADMIN_MENU,0},
{ADMIN_CFG,1},
{ADMIN_CFG,0},
{ADMIN_CFG,1},
{ADMIN_LEVEL_A,0}
}
new g_cstrikeRunning
new g_funModule
public plugin_init()
{
register_plugin("Menus Front-End","0.9","default")
register_menucmd(register_menuid("AMX Mod Menu"),1023,"actionMenu")
register_clcmd("amxmodmenu","cmdMenu",ADMIN_MENU,"- displays menus")
g_cstrikeRunning = is_running("cstrike")
g_funModule = cvar_exists( "fun_version" )
}
public actionMenu(id,key)
{
switch(key){
case 8: displayMenu(id,++g_menuPosition[id])
case 9: displayMenu(id,--g_menuPosition[id])
default: client_cmd(id, g_menuCmd[ g_menuPosition[id] * 8 + key ] )
}
return PLUGIN_HANDLED
}
displayMenu(id,pos){
if (pos < 0) return
new menuBody[512]
new b = 0
new start = pos * 8
if ( start >= MENUS_NUMBER )
start = pos = g_menuPosition[id] = 0
new len = format(menuBody,511,
g_cstrikeRunning ? "\yAMX Mod Menu\R%d/%d^n\w^n" : "AMX Mod Menu %d/%d^n^n" , pos+1, 2 )
new end = start + 8
new keys = (1<<9)
if (end > MENUS_NUMBER )
end = MENUS_NUMBER
new flags = get_user_flags(id)
for(new a = start; a < end; ++a)
{
if ( a == MENUS_NUMBER - 1 && !g_funModule )
continue // checks if there is fun module for teleport menu
if ( (flags & g_menuAccess[a][0]) && ( g_menuAccess[a][1] ? g_cstrikeRunning : 1 ) )
{
keys |= (1<<b)
len += format(menuBody[len],511-len,"%d. %s^n",++b, g_menuBody[ a ] )
}
else
{
++b
if ( g_cstrikeRunning )
len += format(menuBody[len],511-len, "\d%d. %s^n\w",b, g_menuBody[ a ] )
else
len += format(menuBody[len],511-len, "#. %s^n",g_menuBody[ a ] )
}
}
if (end != MENUS_NUMBER )
{
format(menuBody[len],511-len,"^n9. More...^n0. %s", pos ? "Back" : "Exit")
keys |= (1<<8)
}
else format(menuBody[len],511-len,"^n0. %s", pos ? "Back" : "Exit")
show_menu(id,keys,menuBody)
}
public cmdMenu(id,level,cid)
{
if (cmd_access(id,level,cid,1))
displayMenu(id,g_menuPosition[id] = 0)
return PLUGIN_HANDLED
}

514
plugins/miscstats.sma Executable file
View File

@ -0,0 +1,514 @@
/* AMX Mod script.
*
* This file is provided as is (no warranties).
*
* This plugin contains:
* o multikill announcement
* o bomb events
* o killing streak
* o enemy remaining
* o round counter
* o italy bonus kill
* o knife kill
* o headshot kill
* o greanade kill
* o last man
* o double kill
* o player name
* o first blood sound
*
* To use with AMX 0.9.6 (and higher) and Counter-Strike.
* Stats can be enabled with amx_statscfg and amx_statscfgmenu commands.
* NOTE: For pernament disable, comment file from plugins.ini
* or use amx_pausecfg and amx_pausecfgmenu commands.
* Rest of stats can be found in csstats plugin.
*/
#include <amxmod>
public MultiKill
public MultiKillSound
public BombPlanting
public BombDefusing
public BombPlanted
public BombDefused
public BombFailed
public BombPickUp
public BombDrop
public BombCountVoice
public BombCountDef
public BombReached
public ItalyBonusKill
public EnemyRemaining
public LastMan
public KnifeKill
public KnifeKillSound
public GrenadeKill
public GrenadeSuicide
public HeadShotKill
public HeadShotKillSound
public RoundCounterSound
public RoundCounter
public KillingStreak
public KillingStreakSound
public DoubleKill
public DoubleKillSound
public PlayerName
public FirstBloodSound
new g_streakKills[33][2]
new g_multiKills[33][2]
new g_Planter
new g_Defuser
new g_C4Timer
new g_Defusing
new Float:g_LastOmg
new Float:g_LastPlan
new g_LastAnnounce
new g_roundCount
new Float:g_doubleKill
new g_doubleKillId
new g_friend[33]
new g_firstBlood
new g_MultiKillMsg[7][] = {
"Multi-Kill! %s^nwith %d kills (%d hs)",
"Ultra-Kill!!! %s^nwith %d kills (%d hs)",
"%s IS ON A KILLING SPREE!!!^nwith %d kills (%d hs)",
"RAMPAGE!!! %s^nwith %d kills (%d hs)" ,
"%s IS UNSTOPPABLE!!!^nwith %d kills (%d hs)" ,
"%s IS A MONSTER!^nwith %d kills (%d hs)",
"%s IS GODLIKE!!!!^nwith %d kills (%d hs)"
}
new g_Sounds[7][] = {
"multikill",
"ultrakill",
"killingspree",
"rampage",
"unstoppable",
"monsterkill",
"godlike"
}
new g_KillingMsg[7][] = {
"%s: Multi-Kill!",
"%s: Ultra-Kill!!!",
"%s IS ON A KILLING SPREE!!!",
"%s: RAMPAGE!!!",
"%s IS UNSTOPPABLE!!!",
"%s IS A MONSTER!",
"%s IS GODLIKE!!!"
}
new g_KinfeMsg[4][] = {
"%s sliced and diced %s",
"%s pulled out knife and gutted %s",
"%s sneaks carefully behind and knifed %s",
"%s knived %s"
}
new g_LastMessages[4][] = {
"Now all depend on you!",
"I hope you still have a healthpack.",
"All your teammates were killed. Good luck!",
"Now you are alone. Have fun!"
}
new g_HeMessages[4][] = {
"%s sends a little gift to %s",
"%s throws a small present to %s",
"%s made a precision throw to %s",
"%s got a big explosion for %s"
}
new g_SHeMessages[4][] = {
"%s detonated himself with a grenade",
"%s trys the effect of a HE Grenade",
"%s kicked a grenade into his own ass",
"%s explodes!"
}
new g_HeadShots[7][] = {
"$kn killed $vn with a well^nplaced shot to the head!",
"$kn removed $vn's^nhead with the $wn",
"$kn turned $vn's head^ninto pudding with the $wn",
"$vn got pwned by $kn",
"$vn's head has been^nturned into red jello",
"$kn has superb aim with the $wn,^nas $vn well knows.",
"$vn's head stayed in $kn's^ncrosshairs a bit too long..."
}
new g_teamsNames[2][] = {
"TERRORIST",
"CT"
}
public plugin_init(){
register_plugin("Misc. Stats","0.9","default")
register_event("DeathMsg","eDeathMsg","a")
register_event("TextMsg","eRestart","a","2&#Game_C","2&#Game_w")
register_event("SendAudio", "eEndRound", "a", "2&%!MRAD_terwin","2&%!MRAD_ctwin","2&%!MRAD_rounddraw")
register_event("RoundTime", "eNewRound", "bc")
register_event("StatusValue","setTeam","be","1=1")
register_event("StatusValue","showStatus","be","1=2","2!0")
register_event("StatusValue","hideStatus","be","1=1","2=0")
new mapname[32]
get_mapname(mapname,31)
if (equali(mapname,"de_",3)||equali(mapname,"csde_",5)){
register_event("StatusIcon", "eGotBomb", "be", "1=1", "1=2", "2=c4")
register_event("SendAudio", "eBombPlanted", "a", "2&%!MRAD_BOMBPL")
register_event("SendAudio", "eBombDef", "a", "2&%!MRAD_BOMBDEF")
register_event("TextMsg", "eBombFail", "a", "2&#Target_B")
register_event("BarTime", "eBombDefG", "be", "1=10", "1=5","1=3")
register_event("BarTime", "eBombDefL", "be", "1=0")
register_event("TextMsg", "eBombPickUp", "bc", "2&#Got_bomb")
register_event("TextMsg", "eBombDrop", "bc", "2&#Game_bomb_d")
}
else if ( equali( mapname , "cs_italy" ) ) {
register_event( "23" , "chickenKill", "a" , "1=108" , /*"12=106",*/ "15=4" )
register_event( "23" , "radioKill", "a" , "1=108" , /*"12=294",*/ "15=2" )
}
}
public plugin_cfg(){
new g_addStast[] = "amx_statscfg add ^"%s^" %s"
server_cmd(g_addStast,"MultiKill","MultiKill")
server_cmd(g_addStast,"MultiKillSound","MultiKillSound")
server_cmd(g_addStast,"Bomb Planting","BombPlanting")
server_cmd(g_addStast,"Bomb Defusing","BombDefusing")
server_cmd(g_addStast,"Bomb Planted","BombPlanted")
server_cmd(g_addStast,"Bomb Defuse Succ.","BombDefused")
server_cmd(g_addStast,"Bomb Def. Failure","BombFailed")
server_cmd(g_addStast,"Bomb PickUp","BombPickUp")
server_cmd(g_addStast,"Bomb Drop","BombDrop")
server_cmd(g_addStast,"Bomb Count Down","BombCountVoice")
server_cmd(g_addStast,"Bomb Count Down (def)","BombCountDef")
server_cmd(g_addStast,"Bomb Site Reached","BombReached")
server_cmd(g_addStast,"Italy Bonus Kill","ItalyBonusKill")
server_cmd(g_addStast,"Last Man","LastMan")
server_cmd(g_addStast,"Knife Kill","KnifeKill")
server_cmd(g_addStast,"Knife Kill Sound","KnifeKillSound")
server_cmd(g_addStast,"Grenade Kill","GrenadeKill")
server_cmd(g_addStast,"Grenade Suicide","GrenadeSuicide")
server_cmd(g_addStast,"HeadShot Kill","HeadShotKill")
server_cmd(g_addStast,"HeadShot Kill Sound","HeadShotKillSound")
server_cmd(g_addStast,"Round Counter","RoundCounter")
server_cmd(g_addStast,"Round Counter Sound","RoundCounterSound")
server_cmd(g_addStast,"Killing Streak","KillingStreak")
server_cmd(g_addStast,"Killing Streak Sound","KillingStreakSound")
server_cmd(g_addStast,"Enemy Remaining","EnemyRemaining")
server_cmd(g_addStast,"Double Kill","DoubleKill")
server_cmd(g_addStast,"Double Kill Sound","DoubleKillSound")
server_cmd(g_addStast,"Player Name","PlayerName")
server_cmd(g_addStast,"First Blood Sound","FirstBloodSound")
}
public client_putinserver(id)
g_multiKills[id] = g_streakKills[ id ] = { 0 , 0 }
public eDeathMsg(){
new killerId = read_data(1)
if ( killerId == 0 ) return
new victimId = read_data(2)
new bool:enemykill = (get_user_team(killerId) != get_user_team(victimId))
new headshot = read_data(3)
if ( g_firstBlood ) {
g_firstBlood = 0
if ( FirstBloodSound ) client_cmd(0,"spk misc/firstblood")
}
if ( (KillingStreak || KillingStreakSound) && enemykill ) {
g_streakKills[ killerId ][ 0 ]++
g_streakKills[ killerId ][ 1 ] = 0
g_streakKills[ victimId ][ 1 ]++
g_streakKills[ victimId ][ 0 ] = 0
new a = g_streakKills[ killerId ][ 0 ] - 3
if ( (a > -1) && !( a % 2 ) ) {
new name[32]
get_user_name( killerId , name , 31 )
if ( (a >>= 1) > 6 ) a = 6
if ( KillingStreak ){
set_hudmessage(0, 100, 255, 0.05, 0.55, 2, 0.02, 6.0, 0.01, 0.1, 3)
show_hudmessage(0,g_KillingMsg[ a ], name )
}
if ( KillingStreakSound ) client_cmd( 0 , "spk misc/%s" , g_Sounds[ a ] )
}
}
if ( MultiKill || MultiKillSound ) {
if (killerId && enemykill ) {
g_multiKills[killerId][0]++
g_multiKills[killerId][1] += headshot
new param[2]
param[0] = killerId
param[1] = g_multiKills[killerId][0]
set_task( 4.0 + float( param[1] ) ,"checkKills",0,param,2)
}
}
if ( EnemyRemaining ) {
new ppl[32], pplnum
new team = get_user_team( victimId ) - 1
get_players(ppl,pplnum,"e", g_teamsNames[1 - team] )
if (pplnum){
new eppl[32], epplnum
get_players(eppl,epplnum,"ae",g_teamsNames[team])
if (epplnum) {
new message[128]
format(message,127,"%d %s%s Remaining...",epplnum,g_teamsNames[team],(epplnum==1)?"":"S" )
set_hudmessage(255,255,255,0.02,0.85,2, 0.05, 0.1, 0.02, 3.0, 3)
for(new a=0; a<pplnum; ++a) show_hudmessage(ppl[a],message)
//client_print(ppl[a],print_chat,message)
}
}
}
if ( LastMan ) {
new cts[32], ts[32], ctsnum, tsnum
get_players(cts,ctsnum,"ae", g_teamsNames[1] )
get_players(ts,tsnum,"ae", g_teamsNames[0] )
if ( ctsnum == 1 && tsnum == 1 ){
new ctname[32], tname[32]
get_user_name(cts[0],ctname,31)
get_user_name(ts[0],tname,31)
set_hudmessage(0, 255, 255, -1.0, 0.35, 0, 6.0, 6.0, 0.5, 0.15, 3)
show_hudmessage(0,"%s vs. %s",ctname,tname)
client_cmd(0,"spk misc/maytheforce")
}
else if ( !g_LastAnnounce ) {
new oposite = 0, team = 0
if ( ctsnum == 1 && tsnum > 1 ) {
g_LastAnnounce = cts[0]
oposite = tsnum
team = 0
}
else if ( tsnum == 1 && ctsnum > 1 ) {
g_LastAnnounce = ts[0]
oposite = ctsnum
team = 1
}
if (g_LastAnnounce){
new name[32]
get_user_name(g_LastAnnounce,name,31)
set_hudmessage(0, 255, 255, -1.0, 0.35, 0, 6.0, 6.0, 0.5, 0.15, 3)
show_hudmessage(0,"%s (%d HP) vs. %d %s%s: %s",name,
get_user_health(g_LastAnnounce),oposite,
g_teamsNames[team],(oposite==1)?"":"S" ,g_LastMessages[ random_num(0,3) ] )
client_cmd(g_LastAnnounce,"spk misc/oneandonly")
}
}
}
new arg[4]
read_data( 4 , arg , 3 )
if ( equal( arg, "kni" ) && ( KnifeKill || KnifeKillSound ) ) {
if ( KnifeKill ) {
new killer[32], victim[32]
get_user_name(killerId,killer,31)
get_user_name(victimId,victim,31)
set_hudmessage(255, 100, 100, -1.0, 0.25, 1, 6.0, 6.0, 0.5, 0.15, 1)
show_hudmessage(0,g_KinfeMsg[ random_num(0,3) ],killer,victim)
}
if ( KnifeKillSound ) client_cmd(0,"spk misc/humiliation")
}
else if ( equal( arg, "gre" ) && (GrenadeKill || GrenadeSuicide) ) {
new killer[32], victim[32]
get_user_name(killerId,killer,32)
get_user_name(victimId,victim,32)
set_hudmessage(255, 100, 100, -1.0, 0.25, 1, 6.0, 6.0, 0.5, 0.15, 1)
if ( killerId != victimId ){
if ( GrenadeKill ) show_hudmessage(0,g_HeMessages[ random_num(0,3)],killer,victim)
}
else if ( GrenadeSuicide ) show_hudmessage(0,g_SHeMessages[ random_num(0,3) ],victim)
}
if ( headshot && (HeadShotKill || HeadShotKillSound) ) {
if ( HeadShotKill ){
new killer[32], victim[32], weapon[32], message[128]
get_user_name(killerId,killer,31)
get_user_name(victimId,victim,31)
read_data( 4 , weapon , 31 )
copy( message, 127, g_HeadShots[ random_num(0,6) ] )
replace( message, 127 , "$vn", victim )
replace( message, 127 , "$wn", weapon )
replace( message, 127 , "$kn", killer )
set_hudmessage(100, 100, 255, -1.0, 0.29, 0, 6.0, 6.0, 0.5, 0.15, 1)
show_hudmessage(0,message )
}
if ( HeadShotKillSound ) {
client_cmd(killerId,"spk misc/headshot")
client_cmd(victimId,"spk misc/headshot")
}
}
if ( DoubleKill || DoubleKillSound ) {
new Float:nowtime = get_gametime()
if ( g_doubleKill == nowtime && g_doubleKillId == killerId ) {
if ( DoubleKill ) {
new name[32]
get_user_name( killerId , name , 31 )
set_hudmessage(255, 0, 255, -1.0, 0.35, 0, 6.0, 6.0, 0.5, 0.15, 3)
show_hudmessage(0,"Wow! %s made a double kill!!!" ,name )
}
if ( DoubleKillSound ) client_cmd(0,"spk misc/doublekill")
}
g_doubleKill = nowtime
g_doubleKillId = killerId
}
}
public hideStatus(id)
if ( PlayerName ){
set_hudmessage(0,0,0,0.0,0.0,0, 0.0, 0.01, 0.0, 0.0, 4)
show_hudmessage(id,"")
}
public setTeam(id)
g_friend[id] = read_data(2)
public showStatus(id)
if ( PlayerName ){
new name[32],pid = read_data(2)
get_user_name(pid,name,31)
new color1 = 0,color2 = 0
if ( get_user_team(pid)==1 )
color1 = 255
else
color2 = 255
if (g_friend[id]==1){ // friend
new clip, ammo, wpnid = get_user_weapon(pid,clip,ammo)
new wpnname[32]
get_weaponname(wpnid,wpnname,31)
set_hudmessage(color1,50,color2,-1.0,0.60,1, 0.01, 3.0, 0.01, 0.01, 4)
show_hudmessage(id,"%s -- %d HP / %d AP / %s",name,
get_user_health(pid),get_user_armor(pid),wpnname[7])
}
else {
set_hudmessage(color1,50,color2,-1.0,0.60,1, 0.01, 3.0, 0.01, 0.01, 4)
show_hudmessage(id,name)
}
}
public eNewRound()
if ( read_data(1) == floatround(get_cvar_float("mp_roundtime") * 60.0) ) {
g_firstBlood = 1
g_C4Timer = 0
++g_roundCount
if ( RoundCounter ) {
set_hudmessage(200, 0, 0, -1.0, 0.30, 0, 6.0, 6.0, 0.5, 0.15, 1)
show_hudmessage(0, "Prepare to FIGHT!^nRound %d" , g_roundCount )
}
if ( RoundCounterSound ) client_cmd( 0 , "spk misc/prepare" )
if ( KillingStreak ) {
new appl[32],ppl, i
get_players(appl,ppl, "ac" )
for(new a = 0; a < ppl; ++a) {
i = appl[ a ]
if ( g_streakKills[ i ][ 0 ] >= 2 )
client_print( i , print_chat , "* You've killed %d in a row so far", g_streakKills[ i ][ 0 ] )
else if ( g_streakKills[ i ][ 1 ] >= 2 )
client_print( i , print_chat , "* Careful! You've died %d rounds in a row now...", g_streakKills[ i ][ 1 ] )
}
}
}
public eRestart(){
eEndRound()
g_roundCount = 0
g_firstBlood = 1
}
public eEndRound(){
g_C4Timer = -2
g_LastPlan = 0.0
g_LastOmg = 0.0
g_LastPlan = 0.0
remove_task(8038)
g_LastAnnounce = 0
}
public checkKills(param[]){
new id = param[0]
new a = param[1]
if (a == g_multiKills[id][0]){
a -= 3
if ( a > -1 ){
if ( MultiKill ) {
new name[32]
get_user_name(id,name,31)
set_hudmessage(255, 0, 100, 0.05, 0.65, 2, 0.02, 6.0, 0.01, 0.1, 2)
if ( a > 6 ) a = 6
show_hudmessage(0,g_MultiKillMsg[a],name,g_multiKills[id][0],g_multiKills[id][1])
}
if ( MultiKillSound ) client_cmd(0,"spk misc/%s",g_Sounds[a])
}
g_multiKills[id] = { 0,0 }
}
}
public chickenKill()
if ( ItalyBonusKill ) announceEvent( 0 , "Somebody killed a chicken!!!" )
public radioKill()
if ( ItalyBonusKill ) announceEvent( 0 , "Somebody blew up the radio!!!" )
announceEvent( id , message[] ){
new name[32]
get_user_name(id, name , 31)
set_hudmessage(255, 100, 50, -1.0, 0.30, 0, 6.0, 6.0, 0.5, 0.15, 1)
show_hudmessage(0,message,name)
}
public eGotBomb(id){
g_Planter = id
g_Defuser = g_Defusing = 0
if ( BombReached && read_data(1)==2 && g_LastOmg<get_gametime()){
g_LastOmg = get_gametime() + 15.0
announceEvent(g_Planter , "Omg! %s reached the target!" )
}
}
public eBombDefG(id){
if (read_data(1) == 3){
if ( BombPlanting && g_LastPlan<get_gametime() ){
g_LastPlan = get_gametime() + 15.0
announceEvent(g_Planter , "%s is planting the bomb!" )
}
}
else {
g_Defuser = g_Defusing = id
if ( BombDefusing && g_LastPlan<get_gametime()){
g_LastPlan = get_gametime() + 15.0
announceEvent(g_Defusing , "%s is defusing the bomb..." )
}
}
}
public eBombDefL(id)
g_Defusing = 0
public eBombPlanted()
if ( g_C4Timer != -2 ){
if (BombPlanted) announceEvent(g_Planter , "%s set us up the bomb!!!" )
g_C4Timer = get_cvar_num("mp_c4timer") - 2
set_task(1.0,"bombTimer",8038,"",0,"b")
g_LastPlan = 0.0
}
public bombTimer(){
if (--g_C4Timer > 0){
if (BombCountVoice) {
if (g_C4Timer == 30 || g_C4Timer == 20){
new temp[48]
num_to_word(g_C4Timer,temp,47)
client_cmd(0,"spk ^"vox/%s seconds until explosion^"",temp)
}
else if (g_C4Timer < 11){
new temp[48]
num_to_word(g_C4Timer,temp,47)
client_cmd(0,"spk ^"vox/%s^"",temp)
}
}
if (BombCountDef && g_Defusing) client_print(g_Defusing,print_center,"%d",g_C4Timer)
}
else remove_task(8038)
}
public eBombDef()
if (BombDefused) announceEvent(g_Defuser , "%s defused the bomb!" )
public eBombFail()
if (BombFailed && g_Defuser ) announceEvent(g_Defuser , "%s failed to defuse the bomb..." )
public eBombPickUp(id)
if (BombPickUp) announceEvent(id , "%s pick up the bomb...")
public eBombDrop()
if (BombDrop) announceEvent(g_Planter , "%s dropped the bomb!!!")

137
plugins/nextmap.sma Executable file
View File

@ -0,0 +1,137 @@
/* AMX Mod script.
*
* (c) 2003, OLO
* This file is provided as is (no warranties).
*
* Mapcycle is immune to manual map changes and map votes.
*
* Cvars:
* amx_nextmap < mapname > - sets nextmap
* Commands:
* say nextmap - dispalys the nextmap (available for all clients)
*/
#include <amxmod>
// WARNING: If you comment this line make sure
// that in your mapcycle file maps don't repeat.
// However the same map in a row is still valid.
#define OBEY_MAPCYCLE
new g_nextMap[32]
new g_mapCycle[32]
new g_pos
public plugin_init()
{
register_plugin("NextMap","0.9","default")
register_event( "30" , "changeMap", "a" )
register_clcmd("say nextmap","sayNextMap",0,"- displays nextmap")
register_cvar("amx_nextmap","",FCVAR_SERVER|FCVAR_EXTDLL|FCVAR_SPONLY)
new szString[32], szString2[32], szString3[8]
get_localinfo( "lastmapcycle", szString , 31 )
parse( szString, szString2, 31, szString3 , 7 )
g_pos = strtonum( szString3 )
get_cvar_string( "mapcyclefile" , g_mapCycle , 31 )
if ( !equal( g_mapCycle , szString2 ) )
g_pos = 0 // mapcyclefile has been changed - go from first
readMapCycle( g_mapCycle , g_nextMap , 31 )
set_cvar_string( "amx_nextmap", g_nextMap )
format( szString3 , 31, "%s %d", g_mapCycle , g_pos ) // save lastmapcycle settings
set_localinfo( "lastmapcycle", szString3 )
}
getNextMapName(szArg[],iMax){
new len = get_cvar_string("amx_nextmap",szArg,iMax)
if ( is_map_valid(szArg) ) return len
len = copy(szArg,iMax,g_nextMap)
set_cvar_string("amx_nextmap",g_nextMap)
return len
}
public sayNextMap(){
new name[32]
getNextMapName(name,31)
client_print(0,print_chat,"Next Map: %s",name)
}
public delayedChange( param[] )
server_cmd( "changelevel %s", param )
public changeMap(){
new string[32]
set_cvar_float( "mp_chattime" , 3.0 ) // make sure mp_chattime is long
new len = getNextMapName(string, 31) + 1
set_task( 1.5 , "delayedChange" , 0 , string , len ) // change with 1.5 sec. delay
}
new g_warning[] = "WARNING: Couldn't find a valid map or the file doesn't exist (file ^"%s^")"
#if defined OBEY_MAPCYCLE
readMapCycle(szFileName[], szNext[], iNext ){
new b, i = 0, iMaps = 0
new szBuffer[32], szFirst[32]
if ( file_exists( szFileName ) ) {
while( read_file( szFileName , i++ , szBuffer , 31 , b ) ) {
if ( !isalpha( szBuffer[0] ) || !is_map_valid( szBuffer ) ) continue
if ( !iMaps ) copy( szFirst, 31, szBuffer )
if ( ++iMaps > g_pos ) {
copy( szNext , iNext , szBuffer )
g_pos = iMaps
return
}
}
}
if ( !iMaps ) {
log_message( g_warning , szFileName )
get_mapname( szFirst , 31 )
}
copy( szNext , iNext , szFirst )
g_pos = 1
}
#else
readMapCycle(szFileName[], szNext[], iNext )
{
new b, i = 0, iMaps = 0
new szBuffer[32], szFirst[32], szCurrent[32]
get_mapname( szCurrent , 31 )
new a = g_pos
if ( file_exists( szFileName ) ) {
while( read_file( szFileName , i++ , szBuffer , 31 , b ) ) {
if ( !isalpha( szBuffer[0] ) || !is_map_valid( szBuffer ) ) continue
if ( !iMaps ) {
iMaps = 1
copy( szFirst, 31, szBuffer )
}
if ( iMaps == 1 ){
if ( equali( szCurrent , szBuffer ) ) {
if ( a-- == 0 )
iMaps = 2
}
}
else {
if ( equali( szCurrent , szBuffer ) )
++g_pos
else
g_pos = 0
copy( szNext , iNext , szBuffer )
return
}
}
}
if ( !iMaps ) {
log_message( g_warning , szFileName )
copy( szNext ,iNext , szCurrent )
}
else copy( szNext ,iNext , szFirst )
g_pos = 0
}
#endif

366
plugins/pausecfg.sma Executable file
View File

@ -0,0 +1,366 @@
/* AMX Mod script.
*
* (c) 2003, OLO
* This file is provided as is (no warranties).
*
* Admin commads:
* amx_pausecfgmenu - displays menu by which you can pause, unpause and stop plugins
* amx_pausecfg - list commands for pause/unpause managment
*
* WARNING: Stopped plugins won't work properly after activation
* (without mapchange) due to unactive status during players connections.
* For proper activation clear the file with stopped plugins
* (option #7 in menu) or unstop selected one, save configuration,
* then change your map.
*/
#include <amxmod>
#include <amxmisc>
// Uncomment if you want to have two new commands
// amx_off - pause plugins not marked as unpauseable
// amx_on - enable plugins not marked as unpauseable
//#define DIRECT_ONOFF
#define MAX_SYSTEM 32
new g_menuPos[33]
new g_fileToSave[64]
new g_cstrikeRunning
new g_Modified
new g_couldntFind[] = "Couldn't find a plugin matching ^"%s^""
new g_pluginMatch[] = "Plugin matching ^"%s^" %s"
new g_addCmd[] = "amx_pausecfg add ^"%s^""
new g_system[MAX_SYSTEM]
new g_systemNum
public plugin_init(){
register_plugin("Pause Plugins","0.9","default")
register_concmd("amx_pausecfg","cmdPlugin",ADMIN_CFG,"- list commands for pause/unpause managment")
register_clcmd("amx_pausecfgmenu","cmdMenu",ADMIN_CFG,"- pause/unpause plugins with menu")
#if defined DIRECT_ONOFF
register_concmd("amx_off","cmdOFF",ADMIN_CFG,"- pauses some plugins")
register_concmd("amx_on","cmdON",ADMIN_CFG,"- unpauses some plugins")
#endif
register_menucmd(register_menuid("Pause/Unpause Plugins"),1023,"actionMenu")
g_cstrikeRunning = is_running("cstrike")
return PLUGIN_CONTINUE
}
#if defined DIRECT_ONOFF
public cmdOFF(id,level,cid){
if (cmd_access(id,level,cid,1))
pausePlugins(id)
return PLUGIN_HANDLED
}
public cmdON(id,level,cid){
if (cmd_access(id,level,cid,1))
unpausePlugins(id)
return PLUGIN_HANDLED
}
#endif
public plugin_cfg() {
build_path( g_fileToSave , 63 , "$basedir/pausecfg.ini" )
loadSettings(g_fileToSave)
// Put here titles of plugins which you don't want to pause
server_cmd(g_addCmd , "Pause Plugins" )
server_cmd(g_addCmd , "Admin Commands" )
server_cmd(g_addCmd , "TimeLeft" )
server_cmd(g_addCmd , "Slots Reservation" )
server_cmd(g_addCmd , "Admin Chat" )
server_cmd(g_addCmd , "NextMap" )
server_cmd(g_addCmd , "Admin Help" )
server_cmd(g_addCmd , "Admin Base" )
server_cmd(g_addCmd , "Admin Votes" )
server_cmd(g_addCmd , "Welcome Message" )
server_cmd(g_addCmd , "Stats Configuration" )
server_cmd(g_addCmd , "Commands Menu" )
server_cmd(g_addCmd , "Maps Menu" )
server_cmd(g_addCmd , "Menus Front-End" )
server_cmd(g_addCmd , "Admin Base for MySQL" )
server_cmd(g_addCmd , "Players Menu" )
server_cmd(g_addCmd , "Teleport Menu" )
}
public actionMenu(id,key){
switch(key){
case 6:{
if (file_exists(g_fileToSave)){
delete_file(g_fileToSave)
client_print(id,print_chat,"* Configuration file cleared. Reload the map if needed")
}
else
client_print(id,print_chat,"* Configuration was already cleared!")
displayMenu(id,g_menuPos[id])
}
case 7:{
if (saveSettings(g_fileToSave)){
g_Modified = 0
client_print(id,print_chat,"* Configuration saved successfully")
}
else
client_print(id,print_chat,"* Configuration saving failed!!!")
displayMenu(id,g_menuPos[id])
}
case 8: displayMenu(id,++g_menuPos[id])
case 9: displayMenu(id,--g_menuPos[id])
default:{
new option = g_menuPos[id] * 6 + key
new file[32],status[2]
get_plugin(option,file,31,status,0,status,0,status,0,status,1)
switch( status[0] ) {
case 'r': pause("ac",file)
case 'p': {
g_Modified = 1
pause("dc",file)
}
case 's': {
g_Modified = 1
unpause("ac",file)
}
}
displayMenu(id,g_menuPos[id])
}
}
return PLUGIN_HANDLED
}
getStatus( code, arg[], iarg ){
switch(code){
case 'r': copy( arg, iarg , "ON" )
case 's': copy( arg, iarg , "STOPPED" )
case 'p': copy( arg, iarg , "OFF" )
case 'b': copy( arg, iarg , "ERROR" )
default: copy( arg, iarg , "LOCKED" )
}
}
isSystem( id ){
for( new a = 0; a < g_systemNum; ++a)
if ( g_system[ a ] == id )
return 1
return 0
}
displayMenu(id, pos){
if (pos < 0) return
new filename[32],title[32],status[8]
new datanum = get_pluginsnum()
new menu_body[512], start = pos * 6, k = 0
if (start >= datanum) start = pos = g_menuPos[id] = 0
new len = format(menu_body,511,
g_cstrikeRunning ? "\yPause/Unpause Plugins\R%d/%d^n\w^n" : "Pause/Unpause Plugins %d/%d^n^n" ,
pos + 1,((datanum/6)+((datanum%6)?1:0)))
new end = start + 6, keys = (1<<9)|(1<<7)|(1<<6)
if (end > datanum) end = datanum
for(new a = start; a < end; ++a){
get_plugin(a,filename,31,title,31,status,0,status,0,status,1)
getStatus( status[0] , status , 7 )
if ( isSystem( a ) || (status[0]!='O'&&status[0]!='S')) {
if (g_cstrikeRunning){
len += format(menu_body[len],511-len, "\d%d. %s\R%s^n\w",++k, title, status )
}
else{
++k
len += format(menu_body[len],511-len, "#. %s %s^n", title, status )
}
}
else{
keys |= (1<<k)
len += format(menu_body[len],511-len,g_cstrikeRunning ? "%d. %s\y\R%s^n\w" : "%d. %s %s^n",++k,title, status )
}
}
len += format(menu_body[len],511-len,"^n7. Clear file with stopped^n")
len += format(menu_body[len],511-len,g_cstrikeRunning ? "8. Save stopped \y\R%s^n\w"
: "8. Save stopped %s^n" ,g_Modified ? "*" : "")
if (end != datanum){
format(menu_body[len],511-len,"^n9. More...^n0. %s", pos ? "Back" : "Exit")
keys |= (1<<8)
}
else format(menu_body[len],511-len,"^n0. %s", pos ? "Back" : "Exit")
show_menu(id,keys,menu_body)
}
public cmdMenu(id,level,cid){
if (cmd_access(id,level,cid,1))
displayMenu(id,g_menuPos[id] = 0)
return PLUGIN_HANDLED
}
pausePlugins(id){
new filename[32],title[32],status[2]
new count = 0, imax = get_pluginsnum()
for (new a=0;a<imax;++a){
get_plugin(a,filename,31,title,31,status,0,status,0,status,1)
if ( !isSystem( a ) && status[0]=='r' && pause("ac",filename) ) {
//console_print(id,"Pausing %s (file ^"%s^")",title,filename)
++count
}
}
console_print(id,"Paused %d plugin%s",count,(count==1)?"":"s")
}
unpausePlugins(id){
new filename[32],title[32],status[2]
new count = 0, imax = get_pluginsnum()
for (new a=0;a<imax;++a){
get_plugin(a,filename,31,title,31,status,0,status,0,status,1)
if ( !isSystem( a ) && status[0]=='p' && unpause("ac",filename) ) {
//console_print(id,"Unpausing %s (file ^"%s^")",title,filename)
++count
}
}
console_print(id,"Unpaused %d plugin%s",count,(count==1)?"":"s")
}
findPluginByFile(arg[32],&len){
new name[32],title[32],status[2]
new inum = get_pluginsnum()
for(new a = 0; a < inum; ++a){
get_plugin(a,name,31,title,31,status,0,status,0,status,1)
if ( equali(name,arg,len) && (status[0]=='r'||status[0]=='p'||status[0]=='s') ){
len = copy(arg,31,name)
return a
}
}
return -1
}
findPluginByTitle(name[],file[],len){
new title[32],status[2]
new inum = get_pluginsnum()
for(new a = 0; a < inum; ++a){
get_plugin(a,file,len,title,31,status,0,status,0,status,1)
if ( equali( title , name ) )
return a
}
return -1
}
public cmdPlugin(id,level,cid){
if (!cmd_access(id,level,cid,1))
return PLUGIN_HANDLED
new cmds[32]
read_argv(1,cmds,31)
if ( equal(cmds, "add" ) && read_argc() > 2 ) {
read_argv(2, cmds ,31)
new file[2]
if ( (g_system[ g_systemNum ] = findPluginByTitle( cmds , file , 0 )) != -1 ) {
if ( g_systemNum < MAX_SYSTEM )
g_systemNum++
else
console_print( id , "Can't mark more plugins as unpauseable!" )
}
}
else if ( equal(cmds, "off" ) ){
pausePlugins(id)
}
else if ( equal(cmds, "on" ) ){
unpausePlugins(id)
}
else if ( equal(cmds, "save" ) ){
if (saveSettings(g_fileToSave)){
g_Modified = 0
console_print(id,"Configuration saved successfully")
}
else
console_print(id,"Configuration saving failed!!!")
}
else if ( equal(cmds, "clear" ) ) {
if (file_exists(g_fileToSave)){
delete_file(g_fileToSave)
console_print(id,"Configuration file cleared. Reload the map if needed")
}
else
console_print(id,"Configuration was already cleared!")
}
else if ( equal(cmds, "pause" ) ) {
new arg[32], a ,len = read_argv(2,arg,31)
if ( len && ((a = findPluginByFile(arg,len)) != -1) && !isSystem( a ) && pause("ac",arg) )
console_print(id,g_pluginMatch,arg , "paused")
else console_print(id,g_couldntFind,arg)
}
else if ( equal(cmds, "enable" ) ) {
new arg[32], a , len = read_argv(2,arg,31)
if ( len && (a = findPluginByFile(arg,len)) != -1 && !isSystem( a ) && unpause("ac",arg) )
console_print(id,g_pluginMatch,arg , "unpaused")
else console_print(id,g_couldntFind,arg)
}
else if ( equal(cmds, "stop" ) ) {
new arg[32], a, len = read_argv(2,arg,31)
if ( len && (a = findPluginByFile(arg,len)) != -1 && !isSystem( a ) && pause("dc",arg)){
g_Modified = 1
console_print(id,g_pluginMatch,arg , "stopped")
}
else console_print(id,g_couldntFind,arg)
}
else if ( equal(cmds, "list" ) ) {
new arg1[8], running = 0
new start = read_argv(2,arg1,7) ? strtonum(arg1) : 1
if (--start < 0) start = 0
new plgnum = get_pluginsnum()
if (start >= plgnum) start = plgnum - 1
console_print(id,"^n----- Pause Plugins: Loaded plugins -----")
console_print(id, " %-18.17s %-8.7s %-17.16s %-16.15s %-9.8s","name","version","author","file","status")
new plugin[32],title[32],version[16],author[32],status[16]
new end = start + 10
if (end > plgnum) end = plgnum
for (new a = start; a < end; ++a){
get_plugin(a,plugin,31,title,31,version,15,author,31,status,15)
if (status[0] == 'r') ++running
console_print(id, " [%3d] %-18.17s %-8.7s %-17.16s %-16.15s %-9.8s",a+1,title,version,author,plugin, status )
}
console_print(id,"----- Entries %d - %d of %d (%d running) -----",start+1,end,plgnum,running)
if (end < plgnum)
console_print(id,"----- Use 'amx_pausecfg list %d' for more -----",end+1)
else
console_print(id,"----- Use 'amx_pausecfg list 1' for begin -----")
}
else {
console_print(id,"Usage: amx_pausecfg <command> [name]")
console_print(id,"Commands:")
console_print(id,"^toff - pauses all plugins not in the list")
console_print(id,"^ton - unpauses all plugins")
console_print(id,"^tstop <file> - stops a plugin")
console_print(id,"^tpause <file> - pauses a plugin")
console_print(id,"^tenable <file> - enables a plugin")
console_print(id,"^tsave - saves a list of stopped plugins")
console_print(id,"^tclear - clears a list of stopped plugins")
console_print(id,"^tlist [id] - lists plugins")
console_print(id,"^tadd <title> - marks a plugin as unpauseable")
}
return PLUGIN_HANDLED
}
saveSettings(filename[]){
if (file_exists(filename))
delete_file(filename)
new text[256], file[32],title[32],status[2]
new inum = get_pluginsnum()
if (!write_file(filename,";Generated by Pause Plugins Plugin. Do not modify!^n;Title Filename"))
return 0
for(new a = 0; a < inum; ++a){
get_plugin(a,file,31,title,31,status,0,status,0,status,1)
if ( status[0] == 's' ){
format(text,255,"^"%s^" ;%s",title,file)
write_file(filename,text)
}
}
return 1
}
loadSettings(filename[]){
if (!file_exists(filename)) return 0
new name[256], file[32], i, pos = 0
while (read_file(filename,pos++,name,255,i)){
if ( name[0]!= ';' && parse(name,name,31) &&
(i = findPluginByTitle( name , file , 31 ) != -1) )
pause("dc", file )
}
return 1
}

689
plugins/plmenu.sma Executable file
View File

@ -0,0 +1,689 @@
/* AMX Mod script.
*
* (c) 2003, OLO
* This file is provided as is (no warranties).
*
* Admin commands:
* amx_kickmenu - displays kick menu
* amx_banmenu - displays ban menu
* amx_slapmenu - displays slap/slay menu
* amx_teammenu - displays team menu
* amx_clcmdmenu - displays client commands menu
*
*/
#include <amxmod>
#include <amxmisc>
new g_menuPosition[33]
new g_menuPlayers[33][32]
new g_menuPlayersNum[33]
new g_menuOption[33]
new g_menuSettings[33]
new g_menuSelect[33][64]
new g_menuSelectNum[33]
#define MAX_CLCMDS 24
new g_clcmdName[MAX_CLCMDS][32]
new g_clcmdCmd[MAX_CLCMDS][64]
new g_clcmdMisc[MAX_CLCMDS][2]
new g_clcmdNum
new g_logFile[16]
new g_cstrikeRunning
public plugin_init()
{
register_plugin("Players Menu","0.9","default")
register_clcmd("amx_kickmenu","cmdKickMenu",ADMIN_KICK,"- displays kick menu")
register_clcmd("amx_banmenu","cmdBanMenu",ADMIN_BAN,"- displays ban menu")
register_clcmd("amx_slapmenu","cmdSlapMenu",ADMIN_SLAY,"- displays slap/slay menu")
register_clcmd("amx_teammenu","cmdTeamMenu",ADMIN_LEVEL_A,"- displays team menu")
register_clcmd("amx_clcmdmenu","cmdClcmdMenu",ADMIN_LEVEL_A,"- displays client cmds menu")
register_menucmd(register_menuid("Ban Menu"),1023,"actionBanMenu")
register_menucmd(register_menuid("Kick Menu"),1023,"actionKickMenu")
register_menucmd(register_menuid("Slap/Slay Menu"),1023,"actionSlapMenu")
register_menucmd(register_menuid("Team Menu"),1023,"actionTeamMenu")
register_menucmd(register_menuid("Client Cmds Menu"),1023,"actionClcmdMenu")
g_cstrikeRunning = is_running("cstrike")
new filename[64]
build_path( filename , 63 , "$basedir/clcmds.ini" )
load_settings( filename )
get_logfile(g_logFile,15)
}
/* Ban menu */
public actionBanMenu(id,key)
{
switch(key){
case 7:{
++g_menuOption[id]
g_menuOption[id] %= 3
switch(g_menuOption[id]){
case 0: g_menuSettings[id] = 0
case 1: g_menuSettings[id] = 5
case 2: g_menuSettings[id] = 60
}
displayBanMenu(id,g_menuPosition[id])
}
case 8: displayBanMenu(id,++g_menuPosition[id])
case 9: displayBanMenu(id,--g_menuPosition[id])
default:{
new player = g_menuPlayers[id][g_menuPosition[id] * 7 + key]
new name[32], name2[32], authid[32],authid2[32]
get_user_name(player,name2,31)
get_user_authid(id,authid,31)
get_user_authid(player,authid2,31)
get_user_name(id,name,31)
new userid2 = get_user_userid(player)
log_to_file(g_logFile,"Ban: ^"%s<%d><%s><>^" ban and kick ^"%s<%d><%s><>^" (minutes ^"%d^")",
name,get_user_userid(id),authid, name2,userid2,authid2, g_menuSettings[id] )
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"ADMIN %s: ban %s",name,name2)
case 1: client_print(0,print_chat,"ADMIN: ban %s",name2)
}
if (equal("4294967295",authid2)){ /* lan */
new ipa[32]
get_user_ip(player,ipa,31,1)
server_cmd("addip %d %s;writeip",g_menuSettings[id],ipa)
}
else
server_cmd("banid %d #%d kick;writeid",g_menuSettings[id],userid2)
server_exec()
displayBanMenu(id,g_menuPosition[id])
}
}
return PLUGIN_HANDLED
}
displayBanMenu(id,pos){
if (pos < 0) return
get_players(g_menuPlayers[id],g_menuPlayersNum[id])
new menuBody[512]
new b = 0
new i
new name[32]
new start = pos * 7
if (start >= g_menuPlayersNum[id])
start = pos = g_menuPosition[id] = 0
new len = format(menuBody,511, g_cstrikeRunning ?
"\yBan Menu\R%d/%d^n\w^n" : "Ban Menu %d/%d^n^n",
pos+1,( g_menuPlayersNum[id] / 7 + ((g_menuPlayersNum[id] % 7) ? 1 : 0 )) )
new end = start + 7
new keys = (1<<9)|(1<<7)
if (end > g_menuPlayersNum[id])
end = g_menuPlayersNum[id]
for(new a = start; a < end; ++a)
{
i = g_menuPlayers[id][a]
get_user_name(i,name,31)
if ( is_user_bot(i) || (get_user_flags(i)&ADMIN_IMMUNITY) )
{
++b
if ( g_cstrikeRunning )
len += format(menuBody[len],511-len,"\d%d. %s^n\w",b,name)
else
len += format(menuBody[len],511-len,"#. %s^n",name)
}
else
{
keys |= (1<<b)
len += format(menuBody[len],511-len,"%d. %s^n",++b,name)
}
}
if ( g_menuSettings[id] )
len += format(menuBody[len],511-len,"^n8. Ban on %d minutes^n" , g_menuSettings[id] )
else
len += format(menuBody[len],511-len,"^n8. Ban permanently^n" )
if (end != g_menuPlayersNum[id])
{
format(menuBody[len],511-len,"^n9. More...^n0. %s", pos ? "Back" : "Exit")
keys |= (1<<8)
}
else format(menuBody[len],511-len,"^n0. %s", pos ? "Back" : "Exit")
show_menu(id,keys,menuBody)
}
public cmdBanMenu(id,level,cid)
{
if (!cmd_access(id,level,cid,1)) return PLUGIN_HANDLED
g_menuOption[id] = 1
g_menuSettings[id] = 5
displayBanMenu(id,g_menuPosition[id] = 0)
return PLUGIN_HANDLED
}
/* Slap/Slay */
public actionSlapMenu(id,key)
{
switch(key){
case 7:{
++g_menuOption[id]
g_menuOption[id] %= 4
switch(g_menuOption[id]){
case 1: g_menuSettings[id] = 0
case 2: g_menuSettings[id] = 1
case 3: g_menuSettings[id] = 5
}
displaySlapMenu(id,g_menuPosition[id])
}
case 8: displaySlapMenu(id,++g_menuPosition[id])
case 9: displaySlapMenu(id,--g_menuPosition[id])
default:{
new player = g_menuPlayers[id][g_menuPosition[id] * 7 + key]
new name2[32]
get_user_name(player,name2,31)
if (!is_user_alive(player))
{
client_print(id,print_chat,"That action can't be performed on dead client ^"%s^"",name2)
displaySlapMenu(id,g_menuPosition[id])
return PLUGIN_HANDLED
}
new authid[32],authid2[32], name[32]
get_user_authid(id,authid,31)
get_user_authid(player,authid2,31)
get_user_name(id,name,31)
if ( g_menuOption[id] ) {
log_to_file(g_logFile,"Cmd: ^"%s<%d><%s><>^" slap with %d damage ^"%s<%d><%s><>^"",
name,get_user_userid(id),authid, g_menuSettings[id], name2,get_user_userid(player),authid2 )
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"ADMIN %s: slap %s with %d damage",name,name2,g_menuSettings[id])
case 1: client_print(0,print_chat,"ADMIN: slap %s with %d damage",name2,g_menuSettings[id])
}
}
else {
log_to_file(g_logFile,"Cmd: ^"%s<%d><%s><>^" slay ^"%s<%d><%s><>^"",
name,get_user_userid(id),authid, name2,get_user_userid(player),authid2 )
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"ADMIN %s: slay %s",name,name2)
case 1: client_print(0,print_chat,"ADMIN: slay %s",name2)
}
}
if ( g_menuOption[id])
user_slap(player, ( get_user_health(player) > g_menuSettings[id] ) ? g_menuSettings[id] : 0 )
else
user_kill( player )
displaySlapMenu(id,g_menuPosition[id])
}
}
return PLUGIN_HANDLED
}
displaySlapMenu(id,pos){
if (pos < 0) return
get_players(g_menuPlayers[id],g_menuPlayersNum[id])
new menuBody[512]
new b = 0
new i
new name[32], team[4]
new start = pos * 7
if (start >= g_menuPlayersNum[id])
start = pos = g_menuPosition[id] = 0
new len = format(menuBody,511, g_cstrikeRunning ?
"\ySlap/Slay Menu\R%d/%d^n\w^n" : "Slap/Slay Menu %d/%d^n^n" ,
pos+1,( g_menuPlayersNum[id] / 7 + ((g_menuPlayersNum[id] % 7) ? 1 : 0 )) )
new end = start + 7
new keys = (1<<9)|(1<<7)
if (end > g_menuPlayersNum[id])
end = g_menuPlayersNum[id]
for(new a = start; a < end; ++a)
{
i = g_menuPlayers[id][a]
get_user_name(i,name,31)
get_user_team(i,team,3)
if ( !is_user_alive(i) || (get_user_flags(i)&ADMIN_IMMUNITY) )
{
++b
if ( g_cstrikeRunning )
len += format(menuBody[len],511-len,"\d%d. %s\R%s^n\w", b,name,team)
else
len += format(menuBody[len],511-len,"#. %s %s^n",name,team)
}
else
{
keys |= (1<<b)
len += format(menuBody[len],511-len, g_cstrikeRunning ?
"%d. %s\y\R%s^n\w" : "%d. %s %s^n",++b,name,team)
}
}
if ( g_menuOption[id] )
len += format(menuBody[len],511-len,"^n8. Slap with %d damage^n",g_menuSettings[id] )
else
len += format(menuBody[len],511-len,"^n8. Slay^n")
if (end != g_menuPlayersNum[id])
{
format(menuBody[len],511-len,"^n9. More...^n0. %s", pos ? "Back" : "Exit")
keys |= (1<<8)
}
else format(menuBody[len],511-len,"^n0. %s", pos ? "Back" : "Exit")
show_menu(id,keys,menuBody)
}
public cmdSlapMenu(id,level,cid)
{
if (!cmd_access(id,level,cid,1)) return PLUGIN_HANDLED
g_menuOption[id] = 0
g_menuSettings[id] = 0
displaySlapMenu(id,g_menuPosition[id] = 0)
return PLUGIN_HANDLED
}
/* Kick */
public actionKickMenu(id,key)
{
switch(key){
case 8: displayKickMenu(id,++g_menuPosition[id])
case 9: displayKickMenu(id,--g_menuPosition[id])
default:{
new player = g_menuPlayers[id][g_menuPosition[id] * 8 + key]
new authid[32],authid2[32], name[32], name2[32]
get_user_authid(id,authid,31)
get_user_authid(player,authid2,31)
get_user_name(id,name,31)
get_user_name(player,name2,31)
new userid2 = get_user_userid(player)
log_to_file(g_logFile,"Kick: ^"%s<%d><%s><>^" kick ^"%s<%d><%s><>^"",
name,get_user_userid(id),authid, name2,userid2,authid2 )
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"ADMIN %s: kick %s",name,name2)
case 1: client_print(0,print_chat,"ADMIN: kick %s",name2)
}
server_cmd("kick #%d",userid2)
server_exec()
displayKickMenu(id,g_menuPosition[id])
}
}
return PLUGIN_HANDLED
}
displayKickMenu(id,pos){
if (pos < 0) return
get_players(g_menuPlayers[id],g_menuPlayersNum[id])
new menuBody[512]
new b = 0
new i
new name[32]
new start = pos * 8
if (start >= g_menuPlayersNum[id])
start = pos = g_menuPosition[id] = 0
new len = format(menuBody,511, g_cstrikeRunning ?
"\yKick Menu\R%d/%d^n\w^n" : "Kick Menu %d/%d^n^n",
pos+1,( g_menuPlayersNum[id] / 8 + ((g_menuPlayersNum[id] % 8) ? 1 : 0 )) )
new end = start + 8
new keys = (1<<9)
if (end > g_menuPlayersNum[id])
end = g_menuPlayersNum[id]
for(new a = start; a < end; ++a)
{
i = g_menuPlayers[id][a]
get_user_name(i,name,31)
if ( get_user_flags(i) & ADMIN_IMMUNITY )
{
++b
if ( g_cstrikeRunning )
len += format(menuBody[len],511-len,"\d%d. %s^n\w",b,name)
else
len += format(menuBody[len],511-len,"#. %s^n",name)
}
else
{
keys |= (1<<b)
len += format(menuBody[len],511-len,"%d. %s^n",++b,name)
}
}
if (end != g_menuPlayersNum[id])
{
format(menuBody[len],511-len,"^n9. More...^n0. %s", pos ? "Back" : "Exit")
keys |= (1<<8)
}
else format(menuBody[len],511-len,"^n0. %s", pos ? "Back" : "Exit")
show_menu(id,keys,menuBody)
}
public cmdKickMenu(id,level,cid)
{
if (cmd_access(id,level,cid,1))
displayKickMenu(id,g_menuPosition[id] = 0)
return PLUGIN_HANDLED
}
/* Team menu */
public actionTeamMenu(id,key)
{
switch(key){
case 7:{
g_menuOption[id] = 1 - g_menuOption[id]
displayTeamMenu(id,g_menuPosition[id])
}
case 8: displayTeamMenu(id,++g_menuPosition[id])
case 9: displayTeamMenu(id,--g_menuPosition[id])
default:{
new player = g_menuPlayers[id][g_menuPosition[id] * 7 + key]
new authid[32],authid2[32], name[32], name2[32]
get_user_name(player,name2,31)
get_user_authid(id,authid,31)
get_user_authid(player,authid2,31)
get_user_name(id,name,31)
log_to_file(g_logFile,"Cmd: ^"%s<%d><%s><>^" transfer ^"%s<%d><%s><>^" (team ^"%s^")",
name,get_user_userid(id),authid, name2,get_user_userid(player),authid2, g_menuOption[id] ? "TERRORIST" : "CT" )
switch(get_cvar_num("amx_show_activity")) {
case 2: client_print(0,print_chat,"ADMIN %s: transfer %s to %s",name,name2,g_menuOption[id] ? "TERRORIST" : "CT" )
case 1: client_print(0,print_chat,"ADMIN: transfer %s to %s",name2,g_menuOption[id] ? "TERRORIST" : "CT" )
}
new limitt = get_cvar_num("mp_limitteams")
set_cvar_num("mp_limitteams",0)
user_kill(player,1)
engclient_cmd(player, "chooseteam")
engclient_cmd(player, "menuselect", g_menuOption[id] ? "1" : "2" )
engclient_cmd(player, "menuselect", "5")
client_cmd(player,"slot1")
set_cvar_num("mp_limitteams",limitt)
displayTeamMenu(id,g_menuPosition[id])
}
}
return PLUGIN_HANDLED
}
displayTeamMenu(id,pos){
if (pos < 0) return
get_players(g_menuPlayers[id],g_menuPlayersNum[id])
new menuBody[512]
new b = 0
new i, iteam
new name[32], team[4]
new start = pos * 7
if (start >= g_menuPlayersNum[id])
start = pos = g_menuPosition[id] = 0
new len = format(menuBody,511, g_cstrikeRunning ?
"\yTeam Menu\R%d/%d^n\w^n" : "Team Menu %d/%d^n^n",
pos+1,( g_menuPlayersNum[id] / 7 + ((g_menuPlayersNum[id] % 7) ? 1 : 0 )) )
new end = start + 7
new keys = (1<<9)|(1<<7)
if (end > g_menuPlayersNum[id])
end = g_menuPlayersNum[id]
for(new a = start; a < end; ++a)
{
i = g_menuPlayers[id][a]
get_user_name(i,name,31)
iteam = get_user_team(i,team,3)
if ( (iteam == (g_menuOption[id] ? 1 : 2)) || (get_user_flags(i)&ADMIN_IMMUNITY) )
{
++b
if ( g_cstrikeRunning )
len += format(menuBody[len],511-len,"\d%d. %s\R%s^n\w",b,name,team)
else
len += format(menuBody[len],511-len,"#. %s %s^n",name,team)
}
else
{
keys |= (1<<b)
len += format(menuBody[len],511-len, g_cstrikeRunning ?
"%d. %s\y\R%s^n\w" : "%d. %s %s^n",++b,name,team)
}
}
len += format(menuBody[len],511-len,"^n8. Transfer to %s^n",g_menuOption[id] ? "TERRORIST" : "CT" )
if (end != g_menuPlayersNum[id])
{
format(menuBody[len],511-len,"^n9. More...^n0. %s", pos ? "Back" : "Exit")
keys |= (1<<8)
}
else format(menuBody[len],511-len,"^n0. %s", pos ? "Back" : "Exit")
show_menu(id,keys,menuBody)
}
public cmdTeamMenu(id,level,cid)
{
if (!cmd_access(id,level,cid,1)) return PLUGIN_HANDLED
g_menuOption[id] = 0
displayTeamMenu(id,g_menuPosition[id] = 0)
return PLUGIN_HANDLED
}
/* Client cmds menu */
public actionClcmdMenu(id,key)
{
switch(key){
case 7:{
++g_menuOption[id]
g_menuOption[id] %= g_menuSelectNum[id]
displayClcmdMenu(id,g_menuPosition[id])
}
case 8: displayClcmdMenu(id,++g_menuPosition[id])
case 9: displayClcmdMenu(id,--g_menuPosition[id])
default:{
new player = g_menuPlayers[id][g_menuPosition[id] * 7 + key]
new flags = g_clcmdMisc[g_menuSelect[id][g_menuOption[id]]][1]
if (is_user_connected(player)) {
new command[64], authid[32], name[32], userid[32]
copy(command,63,g_clcmdCmd[g_menuSelect[id][g_menuOption[id]]])
get_user_authid(player,authid,31)
get_user_name(player,name,31)
numtostr(get_user_userid(player),userid,31)
replace(command,63,"%userid%",userid)
replace(command,63,"%authid%",authid)
replace(command,63,"%name%",name)
if (flags & 1){
server_cmd(command)
server_exec()
}
else if (flags & 2)
client_cmd(id,command)
else if (flags & 4)
client_cmd(player,command)
}
if (flags & 8) displayClcmdMenu(id,g_menuPosition[id])
}
}
return PLUGIN_HANDLED
}
displayClcmdMenu(id,pos){
if (pos < 0) return
get_players(g_menuPlayers[id],g_menuPlayersNum[id])
new menuBody[512]
new b = 0
new i
new name[32]
new start = pos * 7
if (start >= g_menuPlayersNum[id])
start = pos = g_menuPosition[id] = 0
new len = format(menuBody,511, g_cstrikeRunning ?
"\yClient Cmds Menu\R%d/%d^n\w^n" : "Client Cmds Menu %d/%d^n^n",
pos+1,( g_menuPlayersNum[id] / 7 + ((g_menuPlayersNum[id] % 7) ? 1 : 0 )) )
new end = start + 7
new keys = (1<<9)|(1<<7)
if (end > g_menuPlayersNum[id])
end = g_menuPlayersNum[id]
for(new a = start; a < end; ++a)
{
i = g_menuPlayers[id][a]
get_user_name(i,name,31)
if ( !g_menuSelectNum[id] || get_user_flags(i)&ADMIN_IMMUNITY )
{
++b
if ( g_cstrikeRunning )
len += format(menuBody[len],511-len,"\d%d. %s^n\w",b,name)
else
len += format(menuBody[len],511-len,"#. %s^n",name)
}
else
{
keys |= (1<<b)
len += format(menuBody[len],511-len,"%d. %s^n",++b,name)
}
}
if ( g_menuSelectNum[id] )
len += format(menuBody[len],511-len,"^n8. %s^n", g_clcmdName[g_menuSelect[id][g_menuOption[id]]] )
else
len += format(menuBody[len],511-len,"^n8. No cmds available^n")
if (end != g_menuPlayersNum[id])
{
format(menuBody[len],511-len,"^n9. More...^n0. %s", pos ? "Back" : "Exit")
keys |= (1<<8)
}
else format(menuBody[len],511-len,"^n0. %s", pos ? "Back" : "Exit")
show_menu(id,keys,menuBody)
}
public cmdClcmdMenu(id,level,cid)
{
if (!cmd_access(id,level,cid,1)) return PLUGIN_HANDLED
new flags = get_user_flags(id)
g_menuSelectNum[id] = 0
for(new a = 0; a < g_clcmdNum; ++a)
if (g_clcmdMisc[a][0] & flags)
g_menuSelect[id][g_menuSelectNum[id]++] = a
g_menuOption[id] = 0
displayClcmdMenu(id,g_menuPosition[id] = 0)
return PLUGIN_HANDLED
}
load_settings( szFilename[] )
{
if ( !file_exists ( szFilename ) )
return 0
new text[256], szFlags[32], szAccess[32]
new a, pos = 0
while ( g_clcmdNum < MAX_CLCMDS && read_file (szFilename,pos++,text,255,a) )
{
if ( text[0] == ';' ) continue
if ( parse( text , g_clcmdName[g_clcmdNum] , 31 ,
g_clcmdCmd[g_clcmdNum] ,63,szFlags,31,szAccess,31 ) > 3 )
{
while ( replace( g_clcmdCmd[ g_clcmdNum ] ,63,"\'","^"") ) {
// do nothing
}
g_clcmdMisc[ g_clcmdNum ][1] = read_flags ( szFlags )
g_clcmdMisc[ g_clcmdNum ][0] = read_flags ( szAccess )
g_clcmdNum++
}
}
return 1
}

396
plugins/ppause.sma Executable file
View File

@ -0,0 +1,396 @@
/* AMX Mod script.
*
* (c) 2003, OLO
* This file is provided as is (no warranties).
*
* Admin commads:
* amx_pausemenu - displays menu by which you can pause, unpause and stop plugins
* amx_plugin - displays help for all commands for that plugin
*
* WARNING: Stopped plugins won't work properly after activation
* (without mapchange) due to unactive status during plugins initialization
* and at players connections. For proper activation clear the file with
* stopped plugins (option #7 in menu) or unstop selected one then change the map.
*/
#include <amxmod>
#include <amxmisc>
// Uncomment if you want to have two new commands
// amx_off - pause plugins not registered in the unpauseable list
// amx_on - enable all plugins not registered in the unpauseable list
//#define DIRECT_ONOFF
#define MAX_PLGDATA 64
#define MAX_PLUGINS 192
enum {
PLG_ERROR,
PLG_ON,
PLG_OFF,
PLG_STOPPED
}
new g_pluginList[MAX_PLGDATA][32]
new g_pluginListNum
new g_menuPos[33]
new g_dontPause[MAX_PLGDATA]
new g_dontPauseNum
new g_pluginStatus[MAX_PLUGINS]
new bool:g_Modified
new g_fileToSave[64]
new g_cstrikeRunning
public plugin_init(){
register_plugin("Pause Plugins","0.9","default")
#if defined DIRECT_ONOFF
register_concmd("amx_off","cmdOFF",ADMIN_CFG,"- pause some plugins")
register_concmd("amx_on","cmdON",ADMIN_CFG,"- unpause some plugins")
#endif
register_concmd("amx_plugin","cmdPause",ADMIN_CFG,"- list cmds. for pause/unpause managment")
register_clcmd("amx_pausemenu","cmdMenu",ADMIN_CFG,"- pause or unpause plugins via menu")
register_menucmd(register_menuid("Pause/Unpause Plugins"),1023,"actionMenu")
get_localinfo( "amx_basedir", g_fileToSave , 31 )
format( g_fileToSave , 63, "%s/ppause.ini" , g_fileToSave )
loadSettings(g_fileToSave)
new mod_name[32]
get_modname(mod_name,31)
g_cstrikeRunning = equal(mod_name,"cstrike")
}
new g_addCmd[] = "amx_plugin add ^"%s^""
public plugin_cfg() {
/* Put here titles of plugins which you don't want to pause. */
server_cmd(g_addCmd , "Pause Plugins" )
server_cmd(g_addCmd , "Admin Commands" )
server_cmd(g_addCmd , "TimeLeft" )
server_cmd(g_addCmd , "Slots Reservation" )
server_cmd(g_addCmd , "Admin Chat" )
server_cmd(g_addCmd , "NextMap" )
server_cmd(g_addCmd , "Admin Menu" )
server_cmd(g_addCmd , "Admin Help" )
server_cmd(g_addCmd , "Admin Base" )
server_cmd(g_addCmd , "Welcome Message" )
server_cmd(g_addCmd , "Stats Settings" )
}
public actionMenu(id,key){
switch(key){
case 6:{
if (file_exists(g_fileToSave)){
delete_file(g_fileToSave)
client_print(id,print_chat,"* Configuration file cleared")
}
else
client_print(id,print_chat,"* Configuration was already cleared!")
displayMenu(id,g_menuPos[id])
}
case 7:{
if (saveSettings(g_fileToSave)){
g_Modified = false
client_print(id,print_chat,"* Configuration saved successfully")
}
else
client_print(id,print_chat,"* Configuration saving failed!!!")
displayMenu(id,g_menuPos[id])
}
case 8: displayMenu(id,++g_menuPos[id])
case 9: displayMenu(id,--g_menuPos[id])
default:{
new option = g_menuPos[id] * 6 + key
new filename[32],title[32],version[2],author[2],status[2]
get_plugin(option,filename,31,title,31,version,0,author,0,status,1)
if (status[0]=='r'){
pause("ac",filename)
g_pluginStatus[option]=PLG_OFF
}
else if ( g_pluginStatus[option]!=PLG_STOPPED && status[0]=='p' ){
g_pluginStatus[option]=PLG_STOPPED
g_Modified = true
}
else {
unpause("ac",filename)
g_pluginStatus[option]=PLG_ON
}
displayMenu(id,g_menuPos[id])
}
}
return PLUGIN_HANDLED
}
displayMenu(id, pos){
if (pos < 0) return
new filename[32],title[32],version[2],author[2],status[2]
new datanum = get_pluginsnum()
new menu_body[512], start = pos * 6, k = 0
if (start >= datanum) start = pos = g_menuPos[id] = 0
new len = format(menu_body,511,
g_cstrikeRunning ? "\yPause/Unpause Plugins\R%d/%d^n\w^n" : "Pause/Unpause Plugins %d/%d^n^n" ,
pos + 1,((datanum/6)+((datanum%6)?1:0)))
new end = start + 6, keys = (1<<9)|(1<<7)|(1<<6)
if (end > datanum) end = datanum
for(new a = start; a < end; ++a){
get_plugin(a,filename,31,title,31,version,0,author,0,status,1)
if (dontPause(a)||(status[0]!='r'&&status[0]!='p')) {
if (g_cstrikeRunning){
len += format(menu_body[len],511-len, "\d%d. %s\R%s^n\w",++k,
title, ( status[0]=='r' ) ? "ON" : ( ( status[0]=='p' ) ? "OFF" : "ERROR" ) )
}
else{
++k
len += format(menu_body[len],511-len, "#. %s %s^n",
title, ( status[0]=='r' ) ? "ON" : ( ( status[0]=='p' ) ? "OFF" : "ERROR" ) )
}
}
else{
keys |= (1<<k)
len += format(menu_body[len],511-len,g_cstrikeRunning ? "%d. %s\y\R%s^n\w" : "%d. %s %s^n",++k,
title, ( status[0]=='r' ) ? "ON" : ((g_pluginStatus[a]==PLG_STOPPED)?"STOPPED":"OFF"))
}
}
len += format(menu_body[len],511-len,"^n7. Clear file with stopped^n")
len += format(menu_body[len],511-len,g_cstrikeRunning ? "8. Save stopped \y\R%s^n\w"
: "8. Save stopped %s^n" ,g_Modified ? "*" : "")
if (end != datanum){
format(menu_body[len],511-len,"^n9. More...^n0. %s", pos ? "Back" : "Exit")
keys |= (1<<8)
}
else format(menu_body[len],511-len,"^n0. %s", pos ? "Back" : "Exit")
show_menu(id,keys,menu_body)
}
public cmdMenu(id,level,cid){
if (!cmd_access(id,level,cid,1))
return PLUGIN_HANDLED
if (g_dontPauseNum != g_pluginListNum) chkStatus()
displayMenu(id,g_menuPos[id] = 0)
return PLUGIN_HANDLED
}
pasueALL(id){
if (g_dontPauseNum != g_pluginListNum) chkStatus()
new filename[32],title[32],version[2],author[2],status[2]
new count = 0, imax = get_pluginsnum()
for (new a=0;a<imax;++a){
get_plugin(a,filename,31,title,31,version,0,author,0,status,1)
if (dontPause(a)||status[0]!='r') continue
pause("ac",filename)
++count
console_print(id,"Pausing %s (file ^"%s^")",title,filename)
}
console_print(id,"Paused %d plugins",count)
}
unpauseALL(id){
if (g_dontPauseNum != g_pluginListNum) chkStatus()
new filename[32],title[32],version[2],author[2],status[2]
new count = 0, imax = get_pluginsnum()
for (new a=0;a<imax;++a){
get_plugin(a,filename,31,title,31,version,0,author,0,status,1)
if (dontPause(a)||status[0]!='p') continue
unpause("ac",filename)
++count
console_print(id,"Unpausing %s (file ^"%s^")",title,filename)
}
console_print(id,"Unpaused %d plugins",count)
}
#if defined DIRECT_ONOFF
public cmdOFF(id,level,cid){
if (cmd_access(id,level,cid,1))
pasueALL(id)
return PLUGIN_HANDLED
}
public cmdON(id,level,cid){
if (cmd_access(id,level,cid,1))
unpauseALL(id)
return PLUGIN_HANDLED
}
#endif
findPlugin(argument[32],&len){
new plugin[32],title[32],version[2],author[2],status[2]
new inum = get_pluginsnum()
for(new a = 0; a < inum; ++a){
get_plugin(a,plugin,31,title,31,version,0,author,0,status,1)
if ( equali(plugin,argument,len) && (status[0]=='r'||status[0]=='p') ){
len = copy(argument,31,plugin)
return a
}
}
return -1
}
public cmdPause(id,level,cid){
if (!cmd_access(id,level,cid,1))
return PLUGIN_HANDLED
new cmds[32]
read_argv(1,cmds,31)
if ( equal(cmds, "off" ) ){
pasueALL(id)
}
else if ( equal(cmds, "on" ) ){
unpauseALL(id)
}
else if ( equal(cmds, "save" ) ){
if (saveSettings(g_fileToSave)){
g_Modified = false
console_print(id,"Configuration saved successfully")
}
else
console_print(id,"Configuration saving failed!!!")
}
else if ( equal(cmds, "clear" ) ) {
if (file_exists(g_fileToSave)){
delete_file(g_fileToSave)
console_print(id,"Configuration file cleared")
}
else
console_print(id,"Configuration was already cleared!")
}
else if ( equal(cmds, "pause" ) ) {
new arg[32], len, a
if ( (len = read_argv(2,arg,31)) != 0 ){
if ( (a = findPlugin(arg,len)) != -1){
if (pause("ac",arg)) g_pluginStatus[a] = PLG_OFF
console_print(id,"Plugin matching ^"%s^" paused",arg)
}
}
if (!len || a==-1) console_print(id,"Couldn't find plugin matching ^"%s^"",arg)
}
else if ( equal(cmds, "unpause" ) ) {
new arg[32], len, a
if ( (len = read_argv(2,arg,31)) != 0 ){
if ( (a = findPlugin(arg,len)) != -1){
if (unpause("ac",arg)) g_pluginStatus[a] = PLG_ON
console_print(id,"Plugin matching ^"%s^" unpaused",arg)
}
}
if (!len || a==-1) console_print(id,"Couldn't find plugin matching ^"%s^"",arg)
}
else if ( equal(cmds, "stop" ) ) {
new arg[32], len, a
if ( (len = read_argv(2,arg,31)) != 0 ){
if ( (a = findPlugin(arg,len)) != -1){
pause("ac",arg)
g_pluginStatus[a] = PLG_STOPPED
g_Modified = true
console_print(id,"Plugin matching ^"%s^" stopped",arg)
}
}
if (!len || a==-1) console_print(id,"Couldn't find plugin matching ^"%s^"",arg)
}
else if ( equal(cmds, "list" ) ) {
new plugin[32],title[32],version[16],author[32],status[16]
new inum = get_pluginsnum()
console_print(id, "Currently loaded plugins:")
console_print(id, " name version author file status")
new running = 0, plugins = 0
for(new a = 0; a < inum; ++a){
plugins++
get_plugin(a,plugin,31,title,31,version,15,author,31,status,15)
if (status[0] == 'r') running++
console_print(id, " [%3d] %-18.17s %-8.7s %-17.16s %-16.15s %-9.8s",plugins,
title,version,author,plugin, (g_pluginStatus[a] == PLG_STOPPED) ? "stopped" : status )
}
console_print(id, "%d plugins, %d running",plugins,running)
}
else if ( equal(cmds, "add" ) && read_argc() > 2 ) {
if ( g_pluginListNum < MAX_PLGDATA )
read_argv(2,g_pluginList[g_pluginListNum++],31)
else
console_print(id, "Can't add more plugins to the unpauseable list, limit reached!")
}
else {
console_print(id,"Usage: amx_plugin <command> [name]")
console_print(id,"Commands:")
console_print(id,"^toff - pause all plugins not in the list")
console_print(id,"^ton - unpause all plugins")
console_print(id,"^tstop <file> - stop plugin")
console_print(id,"^tpause <file> - pause plugin")
console_print(id,"^tunpause <file> - unpause plugin")
console_print(id,"^tsave - save list of stopped plugins")
console_print(id,"^tclear - clear list of stopped plugins")
console_print(id,"^tlist - list plugins")
console_print(id,"^tadd <title> - add plugin to the unpauseable plugins list")
}
return PLUGIN_HANDLED
}
chkStatus(){
new filename[32],title[32],version[2],author[2],status[2]
new imax = get_pluginsnum()
for (new a=0;a<imax;++a){
get_plugin(a,filename,31,title,31,version,0,author,0,status,1)
if (status[0]=='p'){
if (g_pluginStatus[a]!=PLG_STOPPED)g_pluginStatus[a] = PLG_OFF
}
else if (status[0]=='r')
g_pluginStatus[a] = PLG_ON
else
g_pluginStatus[a] = PLG_ERROR
if (dontPausePre(title))
g_dontPause[g_dontPauseNum++] = a
}
}
bool:dontPause(myid) {
for(new a=0;a<g_dontPauseNum;++a)
if (g_dontPause[a]==myid)
return true
return false
}
bool:dontPausePre(name[]) {
for(new a=0;a<g_pluginListNum;++a)
if (equali(g_pluginList[a],name))
return true
return false
}
saveSettings(filename[]){
if (file_exists(filename))
delete_file(filename)
new text[256], plugin[32],title[32],version[2],author[2],status[2]
new inum = get_pluginsnum()
if (!write_file(filename,";Generated by Pause Plugins Plugin. Do not modify!^n;Filename Description"))
return 0
for(new a = 0; a < inum; ++a){
if (g_pluginStatus[a]==PLG_STOPPED){
get_plugin(a,plugin,31,title,31,version,0,author,0,status,1)
format(text,255,"%s ;%s",plugin,title)
write_file(filename,text)
}
}
return 1
}
loadSettings(filename[]){
if (!file_exists(filename)) return 0
new text[256], len, pos = 0
while (read_file(filename,pos++,text,255,len)){
if ( text[0] == ';' ) continue // line is a comment
parse(text,g_pluginList[g_pluginListNum++],31)
}
new plugin[32],title[32],version[2],author[2],status[2]
new inum = get_pluginsnum()
for(new a = 0; a < inum; ++a){
get_plugin(a,plugin,31,title,31,version,0,author,0,status,1)
if (!dontPausePre(plugin)) continue
pause("ac",plugin)
g_pluginStatus[a] = PLG_STOPPED
}
g_pluginListNum = 0
return 1
}

613
plugins/restmenu.sma Executable file
View File

@ -0,0 +1,613 @@
/* AMX Mod script.
*
* (c) 2003, OLO
* This file is provided as is (no warranties).
*
* Commands:
* amx_restmenu - displays restriction menu
* amx_restrict - displays help for restrict weapons command
*/
// Uncomment if you want to have seperate settings for each map
//#define MAPSETTINGS
#include <amxmod>
#include <amxmisc>
#if !defined NO_STEAM
#define MAXMENUPOS 34
#else
#define MAXMENUPOS 31
#endif
new g_Position[33]
new g_allowCheck[33]
new g_Modified
new g_blockPos[112]
new g_saveFile[64]
new g_Restricted[] = "* This item is restricted *"
new g_menusNames[7][] = {
"pistol",
"shotgun",
"sub",
"rifle",
"machine",
"equip",
"ammo"
}
new g_MenuTitle[7][] = {
"Handguns",
"Shotguns",
"Sub-Machine Guns",
"Assault & Sniper Rifles",
"Machine Guns",
"Equipment",
"Ammunition"
}
new g_menusSets[7][2] = {
#if !defined NO_STEAM
{0,6},{6,8},{8,13},{13,23},{23,24},{24,32},{32,34}
#else
{0,6},{6,8},{8,13},{13,21},{21,22},{22,29},{29,31}
#endif
}
#if !defined NO_STEAM
new g_AliasBlockNum
new g_AliasBlock[MAXMENUPOS]
#endif
// First position is a position of menu (0 for ammo, 1 for pistols, 6 for equipment etc.)
// Second is a key for TERRORIST (all is key are minus one, 1 is 0, 2 is 1 etc.)
// Third is a key for CT
// Position with -1 doesn't exist
new g_Keys[MAXMENUPOS][3] = {
#if !defined NO_STEAM
{1,1,1}, // H&K USP .45 Tactical
{1,0,0}, // Glock18 Select Fire
{1,3,3}, // Desert Eagle .50AE
{1,2,2}, // SIG P228
{1,4,-1}, // Dual Beretta 96G Elite
{1,-1,4}, // FN Five-Seven
{2,0,0}, // Benelli M3 Super90
{2,1,1}, // Benelli XM1014
{3,1,1}, // H&K MP5-Navy
{3,-1,0}, // Steyr Tactical Machine Pistol
{3,3,3}, // FN P90
{3,0,-1}, // Ingram MAC-10
{3,2,2}, // H&K UMP45
{4,1,-1}, // AK-47
{4,0,-1}, // Gali
{4,-1,0}, // Famas
{4,3,-1}, // Sig SG-552 Commando
{4,-1,2}, // Colt M4A1 Carbine
{4,-1,3}, // Steyr Aug
{4,2,1}, // Steyr Scout
{4,4,5}, // AI Arctic Warfare/Magnum
{4,5,-1}, // H&K G3/SG-1 Sniper Rifle
{4,-1,4}, // Sig SG-550 Sniper
{5,0,0}, // FN M249 Para
{6,0,0}, // Kevlar Vest
{6,1,1}, // Kevlar Vest & Helmet
{6,2,2}, // Flashbang
{6,3,3}, // HE Grenade
{6,4,4}, // Smoke Grenade
{6,-1,6}, // Defuse Kit
{6,5,5}, // NightVision Goggles
{6,-1,7}, // Tactical Shield
{0,5,5}, // Primary weapon ammo
{0,6,6} // Secondary weapon ammo
#else
{1,0,0}, // H&K USP .45 Tactical
{1,1,1}, // Glock18 Select Fire
{1,2,2}, // Desert Eagle .50AE
{1,3,3}, // SIG P228
{1,4,-1}, // Dual Beretta 96G Elite
{1,-1,5}, // FN Five-Seven
{2,0,0}, // Benelli M3 Super90
{2,1,1}, // Benelli XM1014
{3,0,0}, // H&K MP5-Navy
{3,-1,1}, // Steyr Tactical Machine Pistol
{3,2,2}, // FN P90
{3,3,-1}, // Ingram MAC-10
{3,4,4}, // H&K UMP45
{4,0,-1}, // AK-47
{4,1,-1}, // Sig SG-552 Commando
{4,-1,2}, // Colt M4A1 Carbine
{4,-1,3}, // Steyr Aug
{4,4,4}, // Steyr Scout
{4,5,5}, // AI Arctic Warfare/Magnum
{4,6,-1}, // H&K G3/SG-1 Sniper Rifle
{4,-1,7}, // Sig SG-550 Sniper
{5,0,0}, // FN M249 Para
{6,0,0}, // Kevlar Vest
{6,1,1}, // Kevlar Vest & Helmet
{6,2,2}, // Flashbang
{6,3,3}, // HE Grenade
{6,4,4}, // Smoke Grenade
{6,-1,5}, // Defuse Kit
{6,6,6}, // NightVision Goggles
{0,5,5}, // Primary weapon ammo
{0,6,6} // Secondary weapon ammo
#endif
}
new g_WeaponNames[MAXMENUPOS][] = {
"H&K USP .45 Tactical",
"Glock18 Select Fire",
"Desert Eagle .50AE",
"SIG P228",
"Dual Beretta 96G Elite",
"FN Five-Seven",
"Benelli M3 Super90",
"Benelli XM1014",
"H&K MP5-Navy",
"Steyr Tactical Machine Pistol",
"FN P90",
"Ingram MAC-10",
"H&K UMP45",
"AK-47",
#if !defined NO_STEAM
"Gali",
"Famas",
#endif
"Sig SG-552 Commando",
"Colt M4A1 Carbine",
"Steyr Aug",
"Steyr Scout",
"AI Arctic Warfare/Magnum",
"H&K G3/SG-1 Sniper Rifle",
"Sig SG-550 Sniper",
"FN M249 Para",
"Kevlar Vest",
"Kevlar Vest & Helmet",
"Flashbang",
"HE Grenade",
"Smoke Grenade",
"Defuse Kit",
"NightVision Goggles",
#if !defined NO_STEAM
"Tactical Shield",
#endif
"Primary weapon ammo",
"Secondary weapon ammo"
}
new g_MenuItem[MAXMENUPOS][] = {
"\yHandguns^n\w^n%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w^n",
"\yShotguns^n\w^n%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w^n",
"\ySub-Machine Guns^n\w^n%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w^n",
"\yAssault Rifles^n\w^n%d. %s\y\R%s^n\w",
#if !defined NO_STEAM
"%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w",
#endif
"%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w^n",
"\ySniper Rifles^n\w^n%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w^n",
"\yMachine Guns^n\w^n%d. %s\y\R%s^n\w^n",
"\yEquipment^n\w^n%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w",
#if !defined NO_STEAM
"%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w^n",
#else
"%d. %s\y\R%s^n\w^n",
#endif
"\yAmmunition^n\w^n%d. %s\y\R%s^n\w",
"%d. %s\y\R%s^n\w"
}
new g_Aliases[MAXMENUPOS][] = {
"usp",//Pistols
"glock",
"deagle",
"p228",
"elites",
"fn57",
"m3",//Shotguns
"xm1014",
"mp5",//SMG
"tmp",
"p90",
"mac10",
"ump45",
"ak47",//Rifles
#if !defined NO_STEAM
"galil",
"famas",
#endif
"sg552",
"m4a1",
"aug",
"scout",
"awp",
"g3sg1",
"sg550",
"m249", //Machine Gun
"vest",//Equipment
"vesthelm",
"flash",
"hegren",
"sgren",
"defuser",
"nvgs",
#if !defined NO_STEAM
"shield",
#endif
"primammo",//Ammo
"secammo"
}
#if !defined NO_STEAM
new g_moreAliases[MAXMENUPOS][] = {
"km45",//Pistols
"9x19mm",
"nighthawk",
"228compact",
"elites",
"fiveseven",
"12gauge",//Shotguns
"autoshotgun",
"smg",//SMG
"mp",
"c90",
"mac10",
"ump45",
"cv47",//Rifles
//#if !defined NO_STEAM
"defender",
"clarion",
//#endif
"krieg552",
"m4a1",
"bullup",
"scout",
"magnum",
"d3au1",
"krieg550",
"m249", //Machine Gun
"vest",//Equipment
"vesthelm",
"flash",
"hegren",
"sgren",
"defuser",
"nvgs",
//#if !defined NO_STEAM
"shield",
//#endif
"primammo",//Ammo
"secammo"
}
#endif
public plugin_init(){
register_plugin("Restrict Weapons","0.9.6","default")
register_clcmd("buyammo1","ammoRest1")
register_clcmd("buyammo2","ammoRest2")
register_clcmd("amx_restmenu","cmdMenu",ADMIN_CFG,"- displays weapons restriction menu")
register_menucmd(register_menuid("#Buy", 1 ),511,"menuBuy")
register_menucmd(register_menuid("\yRestrict Weapons"),1023,"actionMenu")
register_menucmd(register_menuid("BuyPistol", 1 ),511,"menuPistol")
register_menucmd(register_menuid("BuyShotgun", 1 ),511,"menuShotgun")
register_menucmd(register_menuid("BuySub", 1 ),511,"menuSub")
register_menucmd(register_menuid("BuyRifle", 1 ),511,"menuRifle")
register_menucmd(register_menuid("BuyMachine", 1 ),511,"menuMachine")
register_menucmd(register_menuid("BuyItem", 1 ),511,"menuItem")
register_menucmd(-28,511,"menuBuy" )
register_menucmd(-29,511,"menuPistol" )
register_menucmd(-30,511,"menuShotgun")
register_menucmd(-32,511,"menuSub")
register_menucmd(-31,511,"menuRifle")
register_menucmd(-33,511,"menuMachine")
register_menucmd(-34,511,"menuItem")
register_concmd("amx_restrict","cmdRest",ADMIN_CFG,"- displays help for weapons restriction")
register_event("StatusIcon","buyZone","b","2&buy")
#if defined MAPSETTINGS
new mapname[32]
get_mapname(mapname,31)
build_path( g_saveFile , 63 , "$basedir/weaprest_%s.ini" ,mapname )
#else
build_path( g_saveFile , 63 , "$basedir/weaprest.ini" )
#endif
loadSettings(g_saveFile)
}
public buyZone(id)
g_allowCheck[ id ] = read_data(1)
setWeapon( a , action ){
new b, m = g_Keys[a][0] * 8
if (g_Keys[a][1] != -1) {
b = m + g_Keys[a][1]
if ( action == 2 )
g_blockPos[ b ] = 1 - g_blockPos[ b ]
else
g_blockPos[ b ] = action
}
if (g_Keys[a][2] != -1) {
b = m + g_Keys[a][2] + 56
if ( action == 2 )
g_blockPos[ b ] = 1 - g_blockPos[ b ]
else
g_blockPos[ b ] = action
}
#if !defined NO_STEAM
for(new i = 0; i < g_AliasBlockNum; ++i)
if ( g_AliasBlock[ i ] == a ){
if ( !action || action == 2 ) {
--g_AliasBlockNum
for(new j = i; j < g_AliasBlockNum; ++j )
g_AliasBlock[ j ] = g_AliasBlock[ j + 1 ]
}
return
}
if ( action && g_AliasBlockNum < MAXMENUPOS )
g_AliasBlock[ g_AliasBlockNum++ ] = a
#endif
}
findMenuId( name[] ){
for(new i = 0; i < 7 ; ++i)
if( equal( name , g_menusNames[i] ) )
return i
return -1
}
findAliasId( name[] ){
for(new i = 0; i < MAXMENUPOS ; ++i)
if( equal( name , g_Aliases[i] ) )
return i
return -1
}
switchCommand( id, action ){
new c = read_argc()
if ( c < 3 ){
for(new a = 0; a < MAXMENUPOS; ++a)
setWeapon( a , action )
console_print( id , "Equipment and weapons have been %srestricted" , action ? "" : "un" )
g_Modified = true
}
else {
new arg[32], a
new bool:found = false
for(new b = 2; b < c; ++b){
read_argv(b,arg,31)
if ( (a = findMenuId( arg )) != -1 ){
c = g_menusSets[a][1]
for(new i = g_menusSets[a][0]; i < c; ++i)
setWeapon( i , action )
console_print( id , "%s %s been %srestricted" , g_MenuTitle[a], (a<5) ? "have" : "has" , action ? "" : "un" )
g_Modified = found = true
}
else if ( (a = findAliasId( arg )) != -1 ){
g_Modified = found = true
setWeapon( a , action )
console_print( id , "%s has been %srestricted" , g_WeaponNames[a], action ? "" : "un" )
}
}
if ( !found )
console_print( id , "Couldn't find such equipment or weapon" )
}
}
positionBlocked( a ) {
new m = g_Keys[a][0] * 8
new d = ( g_Keys[a][1]==-1) ? 0 : g_blockPos[ m + g_Keys[a][1] ]
d += ( g_Keys[a][2]==-1) ? 0 : g_blockPos[ m + g_Keys[a][2] + 56 ]
return d
}
public cmdRest(id,level,cid){
if (!cmd_access(id,level,cid,1))
return PLUGIN_HANDLED
new cmd[8]
read_argv(1,cmd,7)
if ( equali( "on" , cmd ) )
switchCommand( id, 1 )
else if ( equali( "off" , cmd ) )
switchCommand( id, 0 )
else if ( equali( "list" , cmd ) ) {
new arg1[8]
new start = read_argv(2,arg1,7) ? strtonum(arg1) : 1
if (--start < 0) start = 0
if (start >= MAXMENUPOS) start = MAXMENUPOS - 1
new end = start + 10
if (end > MAXMENUPOS) end = MAXMENUPOS
console_print(id, "^n----- Weapons Restriction: -----")
console_print(id, " %-32.31s %-10.9s %-9.8s","name","value","status")
if ( start != -1 ) {
for(new a = start; a < end; ++a){
console_print(id, "%3d: %-32.31s %-10.9s %-9.8s",a + 1,
g_WeaponNames[a], g_Aliases[a], positionBlocked(a) ? "ON" : "OFF")
}
}
console_print(id,"----- Entries %i - %i of %i -----",start+1,end,MAXMENUPOS)
if (end < MAXMENUPOS)
console_print(id,"----- Use 'amx_restrict list %i' for more -----",end+1)
else
console_print(id,"----- Use 'amx_restrict list 1' for begin -----")
}
else if ( equali( "save" , cmd ) ) {
if ( saveSettings( g_saveFile ) ){
console_print( id , "Configuration has been saved (file ^"%s^")" , g_saveFile )
g_Modified = false
}
else console_print( id , "Couldn't save configuration (file ^"%s^")" , g_saveFile )
}
else if ( equali( "load" , cmd ) ) {
for(new a = 0; a < MAXMENUPOS; ++a)
setWeapon( a , 0 ) // Clear current settings
new arg1[64]
if ( read_argv(2, arg1 , 63 ) ) build_path( arg1 , 63, "$basedir/%s", arg1 )
else copy( arg1, 63, g_saveFile )
if ( loadSettings( arg1 ) ){
console_print( id , "Configuration has been loaded (file ^"%s^")" , arg1 )
g_Modified = true
}
else console_print( id , "Couldn't load configuration (file ^"%s^")" , arg1 )
}
else {
console_print(id,"Usage: amx_restrict <command> [value]")
console_print(id,"Commands:")
console_print(id,"^ton - set restriction on whole equipment")
console_print(id,"^toff - remove restriction from whole equipment")
console_print(id,"^ton <value> [...] - set specified restriction")
console_print(id,"^toff <value> [...] - remove specified restriction")
console_print(id,"^tlist - display list of available equipment and weapons")
console_print(id,"^tsave - save restriction")
console_print(id,"^tload [file] - load restriction [from a file]")
console_print(id,"Available values to restrict are:^nammo, equip, pistol, shotgun, sub, rifle, machine")
console_print(id,"Type 'amx_restrict list' for more specified values")
}
return PLUGIN_HANDLED
}
displayMenu(id,pos){
if (pos < 0) return
new menubody[512], start = pos * 7
if (start >= MAXMENUPOS) start = pos = g_Position[id] = 0
new len = format(menubody,511,"\yRestrict Weapons\R%d/5^n\w^n",pos+1)
new end = start + 7, keys = (1<<9)|(1<<7), k = 0
if (end > MAXMENUPOS) end = MAXMENUPOS
for(new a = start; a < end; ++a){
keys |= (1<<k)
len += format(menubody[len],511-len,g_MenuItem[a],++k,g_WeaponNames[a],
positionBlocked(a) ? "ON" : "OFF" )
}
len += format(menubody[len],511-len,"^n8. Save settings \y\R%s^n\w",g_Modified?"*":"")
if (end != MAXMENUPOS){
format(menubody[len],511-len,"^n9. More...^n0. %s", pos ? "Back" : "Exit")
keys |= (1<<8)
}
else format(menubody[len],511-len,"^n0. %s", pos ? "Back" : "Exit")
show_menu(id,keys,menubody)
}
public actionMenu(id,key){
switch(key){
case 7: {
if (saveSettings(g_saveFile)){
g_Modified = false
client_print(id,print_chat,"* Configuration saved successfully")
}
else client_print(id,print_chat,"* Configuration saving failed!!!")
displayMenu(id,g_Position[id])
}
case 8: displayMenu(id,++g_Position[id])
case 9: displayMenu(id,--g_Position[id])
default: {
setWeapon( g_Position[id] * 7 + key , 2 )
g_Modified = true
displayMenu(id,g_Position[id])
}
}
return PLUGIN_HANDLED
}
#if !defined NO_STEAM
public client_command( id ){
if ( g_AliasBlockNum && g_allowCheck[ id ] ) {
new arg[16]
read_argv( 0, arg , 15 )
new a = 0
do {
if ( equal( g_Aliases[g_AliasBlock[ a ]] , arg ) || equal( g_moreAliases[g_AliasBlock[ a ]] , arg ) ) {
client_print(id,print_center,g_Restricted )
return PLUGIN_HANDLED
}
} while( ++a < g_AliasBlockNum )
}
return PLUGIN_CONTINUE
}
#endif
public cmdMenu(id,level,cid){
if (cmd_access(id,level,cid,1))
displayMenu(id, g_Position[id] = 0 )
return PLUGIN_HANDLED
}
checkRest(id,menu,key){
if ( g_blockPos[ (menu * 8 + key) + (get_user_team(id) - 1) * 56 ] ){
engclient_cmd(id,"menuselect","10")
//client_cmd(id,"slot10")
client_print(id,print_center, g_Restricted )
return PLUGIN_HANDLED
}
return PLUGIN_CONTINUE
}
public ammoRest1(id) return checkRest(id,0,5)
public ammoRest2(id) return checkRest(id,0,6)
public menuBuy(id,key) return checkRest(id,0,key)
public menuPistol(id,key) return checkRest(id,1,key)
public menuShotgun(id,key) return checkRest(id,2,key)
public menuSub(id,key) return checkRest(id,3,key)
public menuRifle(id,key) return checkRest(id,4,key)
public menuMachine(id,key) return checkRest(id,5,key)
public menuItem(id,key) return checkRest(id,6,key)
saveSettings(filename[]){
if (file_exists(filename))
delete_file(filename)
if (!write_file(filename,"; Generated by Restrict Weapons Plugin. Do not modify!^n; value name"))
return 0
new text[64]
for(new a = 0; a < MAXMENUPOS; ++a){
if ( positionBlocked( a ) ) {
format(text,63,"%-16.15s ; %s", g_Aliases[a] , g_WeaponNames[a])
write_file(filename,text)
}
}
return 1
}
loadSettings(filename[]){
if (!file_exists(filename)) return 0
new text[16]
new a, pos = 0
while (read_file(filename,pos++,text,15, a )){
if ( text[0] == ';' || !a ) continue // line is a comment
parse( text, text , 15 )
if ( (a = findAliasId( text )) != -1 )
setWeapon( a , 1 )
}
return 1
}

BIN
plugins/sc Executable file
View File

Binary file not shown.

BIN
plugins/sc.exe Executable file
View File

Binary file not shown.

84
plugins/scrollmsg.sma Executable file
View File

@ -0,0 +1,84 @@
/* AMX Mod script.
*
* (c) 2003, OLO
* This file is provided as is (no warranties).
*
* Server command:
* amx_scrollmsg <msg> <freq. in sec.>
*/
#include <amxmod>
#include <amxmisc>
#define SPEED 0.3
new g_startPos
new g_endPos
new g_scrollMsg[384]
new g_displayMsg[384]
new Float:g_xPos
new g_Length
new g_Frequency
public plugin_init(){
register_plugin("Scrolling Message","0.9","default")
register_srvcmd("amx_scrollmsg","setMessage")
}
public showMsg(){
new a = g_startPos, i = 0
while( a < g_endPos )
g_displayMsg[i++] = g_scrollMsg[a++]
g_displayMsg[i] = 0
if (g_endPos < g_Length)
g_endPos++
if (g_xPos > 0.35)
g_xPos -= 0.0063
else
{
g_startPos++
g_xPos = 0.35
}
set_hudmessage(200, 100, 0, g_xPos, 0.90, 0, SPEED, SPEED, 0.05, 0.05, 2)
show_hudmessage(0,g_displayMsg)
}
public msgInit(){
g_endPos = 1
g_startPos = 0
g_xPos = 0.65
set_task( SPEED , "showMsg",123,"",0,"a", g_Length + 48)
client_print(0,print_console,g_scrollMsg)
}
public setMessage(id,level,cid) {
if (!cmd_access(id,level,cid,3))
return PLUGIN_HANDLED
remove_task(123) /* remove current messaging */
read_argv(1,g_scrollMsg,380)
new hostname[64]
get_cvar_string("hostname",hostname,63)
replace(g_scrollMsg,380,"%hostname%",hostname)
g_Length = strlen(g_scrollMsg)
new mytime[32]
read_argv(2,mytime,31)
g_Frequency = strtonum(mytime)
if (g_Frequency > 0) {
new minimal = floatround((g_Length + 48) * (SPEED + 0.1))
if (g_Frequency < minimal) {
console_print(id,"Minimal frequency for this message is %d seconds",minimal)
g_Frequency = minimal
}
console_print(id,"Scrolling message displaying frequency: %d:%02d minutes",
g_Frequency/60,g_Frequency%60)
set_task(float(g_Frequency),"msgInit",123,"",0,"b")
}
else
console_print(id,"Scrolling message disabled")
return PLUGIN_HANDLED
}

Some files were not shown because too many files have changed in this diff Show More