|
Originally Posted by kurta999
 Any idea how to import the "command processor" into C++, example ZCMD?
I think its possible to do with "int asdasd(...)" but I don't know how to call it. |
|
Originally Posted by kurta999
Thanks!!
Anyway possible to do something like this without initialazation? But this is not problem for me. |
|
Originally Posted by kurta999
Okey, and it won't be slow if I use ~1500cmd with this method?
|
|
Originally Posted by Gamer_Z
if a normal programwhich has thousands of function isn't slow, why should this be?
But ye, about the map: the more you store the slower the lookup. The lookup time is Log(n) with n the amount of items in the container. To make it easier, let's say we have 100 commands in the list, this is our base for now. The lookup time will be 2. if we have 10000 commands in the list, the lookup time will be 4. which is just 2 times slower than when we have 100 commands in the map. |
|
Originally Posted by AndreT
Function time complexity is not associated with the actual time it may take for it to execute as this may greatly vary from system to system. Instead it represents the number of operations performed.
The complexity of map::find is O(log n) - that is very efficient and comes from how maps operate internally using binary search. Anyways this is a very elegant solution in terms of code readability and file organizing, but lets not get ourselves too deep into the premature optimization, shall we :P |
#include <iostream>
#include <map>
#include <algorithm>
#include <string>
#define PLUGIN_EXPORT
#define PLUGIN_CALL
//begin command library
//header
class Command
{
public:
virtual bool do_command(int playerid, std::string params) = 0;
};
#define CMD(name) \
class cmd ## name : public Command\
{\
public:\
cmd ## name() { ZCMD_COMMAND_LIBRARY_register_command(this, "/"#name); }\
bool do_command(int playerid, std::string params)
//M$ and clang have a mangled name limit of 2048 chars, g++ "unlimited" (well, limited by memory).
#define CMDEND(name) };cmd ## name ZCMD_COMMAND_LIBRARY_CMD_ ## name;
bool OnPlayerCommandReceived(int playerid,std::string command, std::string params);
void OnPlayerCommandExecuted(int playerid, std::string, std::string params, bool success);
//source
std::map<std::string, Command*> ZCMD_COMMAND_LIBRARY_command_map;
void ZCMD_COMMAND_LIBRARY_register_command(Command* cmd, std::string name)
{
std::string data(name);
std::transform(data.begin(), data.end(), data.begin(), ::tolower);
ZCMD_COMMAND_LIBRARY_command_map[data] = cmd;
}
PLUGIN_EXPORT bool PLUGIN_CALL OnPlayerCommandText(int playerid, const char *cmdtext)
{
std::string main(cmdtext);
std::string command;
std::string parameters;
size_t space = main.find(' ');
if(space == std::string::npos)
{
command.assign(main);
}
else
{
command.assign(main.begin(),main.begin()+space);
parameters.assign(main.begin()+(space+1),main.end());
}
std::transform(command.begin(), command.end(), command.begin(), ::tolower);
if(OnPlayerCommandReceived(playerid,command,parameters))
{
if(ZCMD_COMMAND_LIBRARY_command_map.find(command) != ZCMD_COMMAND_LIBRARY_command_map.end())
{
bool success = ZCMD_COMMAND_LIBRARY_command_map[command]->do_command(playerid,parameters);
OnPlayerCommandExecuted(playerid, command, parameters, success);
return success;
}
}
else
{
return false;
}
//printf("Unknown command: %s\n",command.c_str());
return false;
}
//end command library
//end-user code
bool OnPlayerCommandReceived(int playerid,std::string command, std::string params)
{
return true;
}
void OnPlayerCommandExecuted(int playerid, std::string command, std::string params, bool success)
{
return;
}
CMD(start)
{
//printf("start issued, params: '%s'\n",params.c_str());
return true;
}
CMDEND(start);
CMD(end)
{
//printf("end issued, params: '%s'\n",params.c_str());
return false;
}
CMDEND(end);
//end commands
//test run
#include <Windows.h>
int main()
{
DWORD end;
DWORD time = GetTickCount();
for(int i =0; i < 1000000; ++i)
{
OnPlayerCommandText(0, "/start");
OnPlayerCommandText(0, "/StaRT");
OnPlayerCommandText(0, "/start ello lololol");
OnPlayerCommandText(0, "/kill");
OnPlayerCommandText(0, "/end");
OnPlayerCommandText(0, "/end 1234");
}
end = GetTickCount();
printf("%d ms\n",end-time);
return 0;
}
|
Originally Posted by xeeZ
Calling other plugins' natives is a bit complex: you have to have an AMX instance on which you call the native function and do all the argument conversion (pushing and popping them on to the stack) similar to public functions.
You can use sampgdk_get_natives() and sampgdk_num_natives() to get the address of the native function you want to call. The former returns a pointer to the array of *all* native functions that have been registered (including those provided by plugins), not just the ones that are used by the AMX - so it's basically unimportant which AMX you'll pass in. The latter returns the number of entries in the array. For example, to call SendClientMessage() you'd do something like this: pawn Код:
|
|
Originally Posted by LeaveMe
The amx is undefined on line :
amx_PushString(amx, &message_addr, 0, message, false, false); How to initialize and define it ? |
AMX *amx
bool DoSendClientMessage()
bool DoSendClientMessage(AMX *amx, int playerid, int color, const char *message)
|
Originally Posted by xeeZ
Looks like you are right - amx->stk indeed should be incremented by "params_size + sizeof(cell)".
|
|
Originally Posted by Blowfish
Hey, many thanks to xeeZ for this awesome plugin.
Theres just one problem, which i can't find a solution for. How do I send german umlauts like д, ц, ь to players? In pawn I always used escape codes like \228; \246; \252;, but this does not work with sampgdk. Directly writing the umlauts doesn't work either. Thanks, Blowfish |
