From 3c2107bf1d9a87c0ec7581cec0092397a5e69fdc Mon Sep 17 00:00:00 2001 From: Pavol Marko Date: Thu, 26 Feb 2004 19:04:53 +0000 Subject: [PATCH] rewritten; have not changed interface should support messages with more than 32 params now --- amxmodx/CEvent.cpp | 633 +++++++++++++++++++++++++++------------------ amxmodx/CEvent.h | 175 +++++++------ 2 files changed, 474 insertions(+), 334 deletions(-) diff --git a/amxmodx/CEvent.cpp b/amxmodx/CEvent.cpp index 54890dec..cd6b14f8 100755 --- a/amxmodx/CEvent.cpp +++ b/amxmodx/CEvent.cpp @@ -1,32 +1,32 @@ -/* AMX Mod X +/* +* Copyright (c) 2002-2003 Aleksander Naszko, Pavol Marko * -* by the AMX Mod X Development Team -* originally developed by OLO +* This file is part of AMX Mod X. * +* AMX Mod X 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 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 X 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. * -* 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 AMX Mod Xod; if not, write to the Free Software Foundation, +* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * -* 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 +* 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. * -* 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 @@ -35,303 +35,440 @@ #include "CEvent.h" // ***************************************************** -// class EventsMngr +// class ClEvent // ***************************************************** -EventsMngr::EventsMngr() -{ - memset( modMsgsFunCall, 0 , sizeof(modMsgsFunCall) ); + +EventsMngr::ClEvent::ClEvent(CPluginMngr::CPlugin* plugin, int func, int flags) +{ + m_Plugin = plugin; + m_Func = func; + + // flags + m_FlagWorld = (flags & 1) ? true : false; // flag a + m_FlagPlayer = (flags & 2) ? true : false; // flag b + m_FlagOnce = (flags & 4) ? true : false; // flag c + if (flags & 24) + { + m_FlagAlive = (flags & 16) ? true : false; // flag e + m_FlagDead = (flags & 8) ? true : false; // flag d + } + + m_Stamp = 0.0f; + m_Done = false; } -EventsMngr::~EventsMngr() -{ + +EventsMngr::ClEvent::~ClEvent() +{ + +} + +int EventsMngr::ClEvent::getFunction() +{ + return m_Func; +} + +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)); +EventsMngr::~EventsMngr() +{ + clearEvents(); } -void EventsMngr::ClEvent::registerFilter( char* filter ) + +CPluginMngr::CPlugin * EventsMngr::ClEvent::getPlugin() { - if ( filter == 0 ) return; + return m_Plugin; +} + +// ***************************************************** +// class EventsMngr +// ***************************************************** + +void EventsMngr::ClEvent::registerFilter(char *filter) +{ + // filters (conditions) have the form x&y + // x is the param number + // & may also be other characters + // y is a string or a number + if (!filter) + return; char* value = filter; - while ( isdigit(*value) ) + // get the first numbr + while (isdigit(*value)) ++value; - if ( *value == 0 ) return; + // end of string => ignore + if (!*value) + return; - cond_t* b = new cond_t; + CondMapPair pair; - if ( b == 0 ) return; - - b->type = *value; + // type character + pair.second.type = *value; + // set a null here so param id can be recognized later *value++ = 0; - b->sValue.set(value); - b->fValue = atof(value); - b->iValue = atoi(value); + // rest of line + pair.second.sValue = value; + pair.second.fValue = atof(value); + pair.second.iValue = atoi(value); - int i = atoi(filter); - if (i >= 0 && i < MAX_PARSE_VALUES) { - b->next = cond[i]; - cond[i] = b; + // param id + pair.first = atoi(filter); + + m_Conditions.insert(pair); +} + +EventsMngr::ClEvent* EventsMngr::registerEvent(CPluginMngr::CPlugin* plugin, int func, int flags, int msgid) +{ + // validate parameter + if (msgid < 0 || msgid >= MAX_AMX_REG_MSG) + return NULL; + + ClEvent *event = new ClEvent(plugin, func, flags); + if (!event) + return NULL; + + m_Events[msgid].push_back(event); + + return event; +} + +void EventsMngr::parserInit(int msg_type, float* timer, CPlayer* pPlayer, int index) +{ + if (msg_type < 0 || msg_type > MAX_AMX_REG_MSG) + return; + + m_ParseNotDone = false; + m_Timer = timer; + + // don't parse if nothing to do + if (m_Events[msg_type].empty()) + return; + + for(ClEventVecIter iter = m_Events[msg_type].begin(); iter != m_Events[msg_type].end(); ++iter) + { + if ((*iter)->m_Done) + continue; + + if (!(*iter)->m_Plugin->isExecutable((*iter)->m_Func)) + { + (*iter)->m_Done = true; + continue; + } + + if (pPlayer) + { + if (!(*iter)->m_FlagPlayer || (pPlayer->IsAlive() ? !(*iter)->m_FlagAlive : !(*iter)->m_FlagDead ) ) + { + (*iter)->m_Done = true; + continue; + } + } + else if (!(*iter)->m_FlagWorld) + { + (*iter)->m_Done = true; + continue; + } + + if ((*iter)->m_FlagOnce && (*iter)->m_Stamp == (float)(*timer)) + { + (*iter)->m_Done = true; + continue; + } + m_ParseNotDone = true; } - else delete b; + + if (m_ParseNotDone) + { + // we don't clear it (performance) + if (m_ParseVault.size() < 1) + { + m_ParseVault.reserve(32); // 32 as default + m_ParseVault.push_back(MsgDataVault()); + } + m_ParsePos = 0; + m_ParseVault[m_ParsePos].type = MSG_INTEGER; + m_ParseVault[m_ParsePos].iValue = index; + } + m_ParseFun = &m_Events[msg_type]; } -EventsMngr::ClEvent* EventsMngr::registerEvent( CPluginMngr::CPlugin* p, int f, int flags, int pos ) +void EventsMngr::parseValue(int iValue) { - ClEvent* a = new ClEvent( p , f , flags ); - if ( a == 0 ) return 0; - ClEvent** end = &modMsgsFunCall[pos]; - while( *end ) end = &(*end)->next; - return *end = a; -} + // not parsing + if (!m_ParseNotDone || !m_ParseFun) + return; -void EventsMngr::parserInit(int msg_type, float* tim, CPlayer *pPlayer, int index) { - parseNotDone = false; - timer = tim; - if ( (parseFun = modMsgsFunCall[msg_type]) == 0 ) return; + // grow if needed + if (m_ParseVault.size() <= static_cast(++m_ParsePos)) + { + MsgDataVault tmp; + m_ParseVault.push_back(tmp); + } - 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; - } -} + m_ParseVault[m_ParsePos].type = MSG_INTEGER; + m_ParseVault[m_ParsePos].iValue = iValue; + // loop through the registered funcs, and decide whether they have to be called + bool skip; + for (ClEventVecIter iter = m_ParseFun->begin(); iter != m_ParseFun->end(); ++iter) + { + if ((*iter)->m_Done) + continue; -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; + skip = false; + ClEvent::CondMapIter condIter = (*iter)->m_Conditions.find(m_ParsePos); + if (condIter == (*iter)->m_Conditions.end()) + continue; + + do + { + switch(condIter->second.type) + { + case '=': if (condIter->second.iValue == iValue) skip=true; break; + case '!': if (condIter->second.iValue != iValue) skip=true; break; + case '&': if (iValue & condIter->second.iValue) skip=true; break; + case '<': if (iValue < condIter->second.iValue) skip=true; break; + case '>': if (iValue > condIter->second.iValue) skip=true; break; + } + if (skip) + break; + } while ( ++condIter != (*iter)->m_Conditions.end() ); + + if (skip) + continue; + (*iter)->m_Done = true; } } -int EventsMngr::getArgInteger(int a) +void EventsMngr::parseValue(float fValue) { - 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; + // not parsing + if (!m_ParseNotDone || !m_ParseFun) + return; + + // grow if needed + if (m_ParseVault.size() <= static_cast(++m_ParsePos)) + { + MsgDataVault tmp; + m_ParseVault.push_back(tmp); + } + + m_ParseVault[m_ParsePos].type = MSG_FLOAT; + m_ParseVault[m_ParsePos].fValue = fValue; + + // loop through the registered funcs, and decide whether they have to be called + bool skip; + for (ClEventVecIter iter = m_ParseFun->begin(); iter != m_ParseFun->end(); ++iter) + { + if ((*iter)->m_Done) + continue; + + skip = false; + ClEvent::CondMapIter condIter = (*iter)->m_Conditions.find(m_ParsePos); + if (condIter == (*iter)->m_Conditions.end()) + continue; + + do + { + switch(condIter->second.type) + { + case '=': if (condIter->second.fValue == fValue) skip=true; break; + case '!': if (condIter->second.fValue != fValue) skip=true; break; + case '<': if (fValue < condIter->second.fValue) skip=true; break; + case '>': if (fValue > condIter->second.fValue) skip=true; break; + } + if (skip) + break; + } while ( ++condIter != (*iter)->m_Conditions.end() ); + + if (skip) + continue; + (*iter)->m_Done = true; } } -float EventsMngr::getArgFloat(int a) +void EventsMngr::parseValue(const char *sz) { - 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; + // not parsing + if (!m_ParseNotDone || !m_ParseFun) + return; + + // grow if needed + if (m_ParseVault.size() <= static_cast(++m_ParsePos)) + { + MsgDataVault tmp; + m_ParseVault.push_back(tmp); + } + + m_ParseVault[m_ParsePos].type = MSG_STRING; + m_ParseVault[m_ParsePos].sValue = sz; + + // loop through the registered funcs, and decide whether they have to be called + bool skip; + for (ClEventVecIter iter = m_ParseFun->begin(); iter != m_ParseFun->end(); ++iter) + { + if ((*iter)->m_Done) + continue; + + skip = false; + ClEvent::CondMapIter condIter = (*iter)->m_Conditions.find(m_ParsePos); + if (condIter == (*iter)->m_Conditions.end()) + continue; + + do + { + switch(condIter->second.type) + { + case '=': if (!strcmp(sz, condIter->second.sValue.c_str())) skip=true; break; + case '!': if (!strstr(sz, condIter->second.sValue.c_str())) skip=true; break; + case '&': if (strstr(sz, condIter->second.sValue.c_str())) skip=true; break; + } + if (skip) + break; + } while ( ++condIter != (*iter)->m_Conditions.end() ); + + if (skip) + continue; + (*iter)->m_Done = true; } } - - -void EventsMngr::executeEvents() { +void EventsMngr::executeEvents() +{ int err; - + #ifdef ENABLEEXEPTIONS try { -#endif - - for ( ClEvent*p = parseFun ; p ; p = p->next ) +#endif // #ifdef ENABLEEXEPTIONS + for (ClEventVecIter iter = m_ParseFun->begin(); iter != m_ParseFun->end(); ++iter) { - - if ( p->done ) + if ( (*iter)->m_Done ) { - p->done = false; + (*iter)->m_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()); - + + (*iter)->m_Stamp = *m_Timer; + + if ((err = amx_Exec((*iter)->m_Plugin->getAMX(), NULL, (*iter)->m_Func, 1, m_ParseVault.size() ? m_ParseVault[0].iValue : 0)) != AMX_ERR_NONE) + { + print_srvconsole("[AMX] Run time error %d on line %ld (plugin \"%s\")\n", err, + (*iter)->m_Plugin->getAMX()->curline, (*iter)->m_Plugin->getName()); + } } - + #ifdef ENABLEEXEPTIONS } catch( ... ) { print_srvconsole( "[AMX] fatal error at event execution\n"); } -#endif - +#endif // #ifdef ENABLEEXEPTIONS } -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() +int EventsMngr::getArgNum() { - for(int i=0;inext; - delete *b; - *b = aa; - } + return m_ParsePos + 1; +} + +const char* EventsMngr::getArgString(int a) +{ + if ( a < 0 || a > m_ParsePos ) + return ""; + + static char var[32]; + + switch(m_ParseVault[a].type) + { + case MSG_INTEGER: + sprintf( var, "%d", m_ParseVault[a].iValue ); + return var; + case MSG_STRING: + return m_ParseVault[a].sValue; + default: + sprintf( var, "%g", m_ParseVault[a].fValue ); + return var; } } -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; - } +int EventsMngr::getArgInteger(int a) +{ + if ( a < 0 || a > m_ParsePos ) + return 0; + + switch(m_ParseVault[a].type) + { + case MSG_INTEGER: + return m_ParseVault[a].iValue; + case MSG_STRING: + return atoi(m_ParseVault[a].sValue); + default: + return (int)m_ParseVault[a].fValue; } } -EventsMngr::ClEvent* EventsMngr::getValidEvent(ClEvent* a ) { - while(a){ - if ( a->done ) { - a->done = false; - a = a->next; - continue; - } - a->stamp = *timer; - return a; +float EventsMngr::getArgFloat(int a) +{ + if ( a < 0 || a > m_ParsePos ) + return 0.0f; + + switch(m_ParseVault[a].type) + { + case MSG_INTEGER: + return m_ParseVault[a].iValue; + case MSG_STRING: + return atof(m_ParseVault[a].sValue); + default: + return m_ParseVault[a].fValue; } - return 0; } -int EventsMngr::getEventId( const char* msg ){ - struct CS_Events { +void EventsMngr::clearEvents(void) +{ + for (int i = 0; i < MAX_AMX_REG_MSG; ++i) + { + for (ClEventVecIter iter = m_Events[i].begin(); iter != m_Events[i].end(); ++iter) + { + if (*iter) + delete *iter; + } + m_Events[i].clear(); + } +} + +int EventsMngr::getEventId(const char* msg) +{ + const struct CS_Events + { const char* name; CS_EventsIds id; - } table[] = { + } table[] = + { { "CS_DeathMsg" , CS_DeathMsg }, -// { "CS_RoundEnd" , CS_RoundEnd }, -// { "CS_RoundStart" , CS_RoundStart }, -// { "CS_Restart" , CS_Restart }, + // { "CS_RoundEnd" , CS_RoundEnd }, + // { "CS_RoundStart" , CS_RoundStart }, + // { "CS_Restart" , CS_Restart }, { "" , CS_Null } }; - int pos; - if ( (pos = atoi( msg )) != 0 ) + // if msg is a number, return it + int pos = atoi(msg); + if (pos != 0) return pos; + + // try to find in table first 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 ); + + // not found + return pos = GET_USER_MSG_ID(PLID, msg , 0 ); } diff --git a/amxmodx/CEvent.h b/amxmodx/CEvent.h index d710c697..9e58a618 100755 --- a/amxmodx/CEvent.h +++ b/amxmodx/CEvent.h @@ -1,40 +1,43 @@ -/* AMX Mod X +/* +* Copyright (c) 2002-2003 Aleksander Naszko, Pavol Marko * -* by the AMX Mod X Development Team -* originally developed by OLO +* This file is part of AMX Mod X. * +* AMX Mod X 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 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 X 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. * -* 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 AMX Mod Xod; if not, write to the Free Software Foundation, +* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * -* 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 +* 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. * -* 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 +#ifndef __CEVENTS_H__ +#define __CEVENTS_H__ + +#include +#include +#include -#define MAX_PARSE_VALUES 32 #define MAX_AMX_REG_MSG MAX_REG_MSGS+16 - + enum { CS_DEATHMSG = MAX_REG_MSGS, // CS_ROUNDEND, @@ -46,10 +49,10 @@ enum { // class EventsMngr // ***************************************************** - -class EventsMngr { - - enum MsgValueType{ +class EventsMngr +{ + enum MsgParamType + { MSG_INTEGER, MSG_FLOAT, MSG_STRING, @@ -57,7 +60,8 @@ class EventsMngr { public: - enum CS_EventsIds { + enum CS_EventsIds + { CS_Null = 0, CS_DeathMsg = MAX_REG_MSGS, // start from last element // CS_RoundEnd, @@ -65,51 +69,69 @@ public: // CS_Restart, }; - class iterator; - friend class iterator; + class ClEvent + { + friend class EventsMngr; // events manager may access our private members - 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; + int m_Func; // function to be executed + CPluginMngr::CPlugin *m_Plugin; // the plugin this ClEvent class is assigned to + + // flags + bool m_FlagPlayer; + bool m_FlagWorld; + bool m_FlagOnce; + bool m_FlagDead; + bool m_FlagAlive; + + float m_Stamp; // for 'once' flag + + bool m_Done; + + // conditions + struct cond_t + { + std::string sValue; // value float fValue; int iValue; int type; - cond_t* next; - } *cond[MAX_PARSE_VALUES]; - ClEvent* next; - ClEvent( CPluginMngr::CPlugin* p, int f, int flags ); + }; + + typedef std::pair CondMapPair; + typedef std::map CondMap; + typedef CondMap::iterator CondMapIter; + + CondMap m_Conditions; + + // constructors & destructors + ClEvent(CPluginMngr::CPlugin* plugin, int func, int flags); ~ClEvent(); public: - inline CPluginMngr::CPlugin* getPlugin() { return plugin; } - inline int getFunction() { return func; } - void registerFilter( char* filter ); + inline CPluginMngr::CPlugin* getPlugin(); + inline int getFunction(); + void registerFilter(char* filter); // add a condition }; private: - struct MsgDataVault { + struct MsgDataVault + { float fValue; int iValue; const char* sValue; - MsgValueType type; - } parseVault[MAX_PARSE_VALUES]; + MsgParamType type; + }; + typedef std::vector MsgDataVaultVec; + typedef MsgDataVaultVec::iterator MsgDataVaultVecIter; + MsgDataVaultVec m_ParseVault; + typedef std::vector ClEventVec; + typedef ClEventVec::iterator ClEventVecIter; + ClEventVec m_Events[MAX_AMX_REG_MSG]; + ClEventVec *m_ParseFun; // current Event vector - ClEvent* modMsgsFunCall[MAX_AMX_REG_MSG]; - ClEvent* parseFun; - bool parseNotDone; - int parsePos; // is -1 less then args. num. - float* timer; + bool m_ParseNotDone; + int m_ParsePos; // is -1 less then args. num. + float* m_Timer; + ClEvent* getValidEvent(ClEvent* a ); public: @@ -118,37 +140,18 @@ public: // 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); + ClEvent* registerEvent(CPluginMngr::CPlugin* plugin, int func, int flags, int msgid); + void parserInit(int msg_type, float* timer, CPlayer* pPlayer, int index); void parseValue(int iValue); void parseValue(float fValue); void parseValue(const char *sz); void executeEvents(); - inline int getArgNum() { return (parsePos+1); } + 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 - +#endif // #ifdef __CEVENTS_H__ \ No newline at end of file