RGCMD [Commandprocessor][v1.0.0]

Wichtiger Hinweis: Bitte ändert nicht manuell die Schriftfarbe auf schwarz sondern belasst es bei der Standardeinstellung. Somit tragt ihr dazu bei dass euer Text auch bei Verwendung unseren dunklen Forenstils noch lesbar ist!

Tipp: Ihr wollt längere Codeausschnitte oder Logfiles bereitstellen? Benutzt unseren eigenen PasteBin-Dienst Link

    Moin Leute,


    Heut gibts mal was ganz kleines von mir. Hierbei handelt es sich um einen Commandprozessor, welcher dieselbe Funktion übernimmt, wie der allgemein bekannte Prozessor "OCMD", nur ist dieser ein Stück schneller, wie im Folgenden Speedtest belegt wird.
    Vorweg: Wie erstellt man einen Befehl?
    Diese Frage ist leicht zu beantworten. Ihr erstellt den Befehl nach folgendem Shema:
    RGCMD:Befehlname(playerid,params[])
    {
    return 1;
    }
    Natürlich darf hierbei das #include rgcmd am Scriptanfang nicht fehlen.
    Diesen Code könnt ihr nach Belieben iwo in eurem GM oder FS platzieren.
    Darin könnt ihr nun wie gewohnt mit sscanf eure Params verwalten.


    Soo nun zum Speedtest:
    Bei 25 Durchläufen mit jeweils 100.000 Befehlsaufrufen komme ich auf folgendes Ergebnis:

    Spoiler anzeigen

    Spoiler anzeigen


    Testcode:

    Spoiler anzeigen
    /*
    Timing test
    made by BlackAce
    modified by RG
    */
    #include a_samp

    Spoiler anzeigen

    Spoiler anzeigen
    #define TEST_RUNS 25
    #define TEST_LOOPS 100000
    #define TEST_CMD "/test Moin Leutz was macht ihr so?"
    new result[3];
    forward StartTest();
    public StartTest() {

    Spoiler anzeigen

    Spoiler anzeigen
    printf(" --- BCMD vs RGCMD (%d a %d), TestCMD: %s",TEST_RUNS,TEST_LOOPS,TEST_CMD);
    for(new i ; i < TEST_RUNS ; i++ )
    {
    new
    tick2,
    tick3,
    tick1,
    tick4;
    tick1 = GetTickCount();
    for(new j ; j < TEST_LOOPS ; j++)
    {
    RGOnPlayerCommandText(0,TEST_CMD);
    }
    tick2 = GetTickCount();
    for(new j ; j < TEST_LOOPS ; j++)
    {
    BCMDOnPlayerCommandText(0,TEST_CMD);
    }
    tick3 = GetTickCount();
    for(new j ; j < TEST_LOOPS ; j++)
    {
    OCMDOnPlayerCommandText(0,TEST_CMD);
    }
    tick4 = GetTickCount();
    new
    RGCMD = tick2 - tick1,
    BCMD = tick3 - tick2,
    OCMD = tick4 - tick3;
    printf("RGCMD %04dms",RGCMD);
    printf("BCMD %04dms",BCMD);
    printf("OCMD %04dms",OCMD);
    if(RGCMD < BCMD && RGCMD < OCMD)
    result[0]++,printf("Gewinner Runde %d -> RGCMD",(i+1));
    if( BCMD < RGCMD && BCMD < OCMD)
    result[1]++,printf("Gewinner Runde %d -> BCMD",(i+1));
    if( OCMD < RGCMD && OCMD < BCMD)
    result[2]++,printf("Gewinner Runde %d -> OCMD",(i+1));
    }
    printf("-------ERGEBNIS:------");
    printf("RGCMD %d/%d Runden gewonnen",result[0],TEST_RUNS);
    printf("BCMD %d/%d Runden gewonnen",result[1],TEST_RUNS);
    printf("OCMD %d/%d Runden gewonnen",result[2],TEST_RUNS);
    return 1;
    }

    Spoiler anzeigen

    Spoiler anzeigen
    public OnFilterScriptInit() {
    SetTimer("StartTest",1800,false);
    return 1;
    }
    #define RGCMD:%0(%1) forward rgcmd_%0(%1);\
    public rgcmd_%0(%1)
    #define bcmd:%1(%2) forward bcmd_%1(%2); \
    public bcmd_%1(%2)
    #define ocmd:%1(%2) forward ocmd_%1(%2); \
    public ocmd_%1(%2)
    forward RGOnPlayerCommandText(playerid,cmdtext[]);
    forward OCMDOnPlayerCommandText(playerid,cmdtext[]);
    forward BCMDOnPlayerCommandText(playerid,cmdtext[]);
    public RGOnPlayerCommandText(playerid,cmdtext[])
    {
    new cmd[32], pos = strfind(cmdtext," ",true);
    strmid(cmd,cmdtext,1,pos);
    for(new i = 0, len = strlen(cmd); i < len; i++)
    {
    switch(cmd[i])
    {
    case 'A': cmd[i] = 'a'; case 'B': cmd[i] = 'b'; case 'C': cmd[i] = 'c';
    case 'D': cmd[i] = 'd'; case 'E': cmd[i] = 'e'; case 'F': cmd[i] = 'f';
    case 'G': cmd[i] = 'g'; case 'h': cmd[i] = 'h'; case 'I': cmd[i] = 'i';
    case 'J': cmd[i] = 'j'; case 'K': cmd[i] = 'k'; case 'L': cmd[i] = 'l';
    case 'M': cmd[i] = 'm'; case 'N': cmd[i] = 'n'; case 'O': cmd[i] = 'o';
    case 'P': cmd[i] = 'p'; case 'Q': cmd[i] = 'q'; case 'R': cmd[i] = 'r';
    case 'S': cmd[i] = 's'; case 'T': cmd[i] = 't'; case 'U': cmd[i] = 'u';
    case 'V': cmd[i] = 'v'; case 'W': cmd[i] = 'w'; case 'X': cmd[i] = 'x';
    case 'Y': cmd[i] = 'y'; case 'Z': cmd[i] = 'z';
    }
    }
    strins(cmd,"rgcmd_",0);
    if(pos == -1)
    {
    if(CallLocalFunction(cmd,"ds",playerid, " ")) return 1;
    strins(cmd,"/",0);
    return CallLocalFunction("oldOnPlayerCMDText","ds",playerid,cmdtext);
    }
    new params1[64];
    strmid(params1,cmdtext,pos+1,strlen(cmdtext));
    if(CallLocalFunction(cmd,"ds",playerid, params1)) return 1;
    return CallLocalFunction("oldOnPlayerCMDText","ds",playerid,cmdtext);
    }
    public BCMDOnPlayerCommandText(playerid,cmdtext[])
    {

    }
    public OCMDOnPlayerCommandText(playerid,cmdtext[])
    {
    cmdtext[0]='_';
    new ocmdStr[128],ocmdParams[128],bool:ocmdAffe,ocmdFu;
    for(new i;i<128;i++)
    {
    if(cmdtext[i]=='\0')break;
    if((cmdtext[i]==' ')&&(!ocmdAffe))
    {
    ocmdAffe=true;
    continue;
    }
    if(!ocmdAffe)
    {
    cmdtext[i] = tolower(cmdtext[i]);
    ocmdStr[i]=cmdtext[i];
    }
    else
    {
    ocmdParams[ocmdFu]=cmdtext[i];
    ocmdFu++;
    }
    }
    format(ocmdStr,128,"ocmd%s",ocmdStr);
    if(!strlen(ocmdParams))format(ocmdParams,128," ");
    if(CallLocalFunction(ocmdStr,"ds",playerid,ocmdParams))return 1;
    cmdtext[0]='/';
    return CallLocalFunction("oldOnPlayerCMDText","ds",playerid,cmdtext);
    }
    bcmd:test(playerid,params[])
    {
    return 1;
    }
    ocmd:test(playerid,params[])
    {
    return 1;
    }
    RGCMD:test(playerid,params[])
    {
    return 1;
    }

    Spoiler anzeigen

    Spoiler anzeigen
    Hierbei BCMD einfach vernachlässigen, da ich keine Erlaubnis habe, dieses zu releasen.

    Spezielles Danke an:
    946ben, er hat mir gezeigt, dass ein switch schneller ist, als die "tolower" Funktion



    Download:
    Pastebin
    Mirror1

    schön gemacht :D code schaut gut aus, bleibe aber beim alten dcdm :D

    Zitat von eL_M0NST3R

    Gefällt mir ;)
    Aber ein bisschen unnötig da es schon viele XCMD Arten gibt.
    mfg


    Eben nicht. Es gibt zwar viele CMD-Systeme, aber alle Systeme versuchen sich gegenseitig, in Punkto Schnelligkeit zu schlagen. Und wir machen da jetzt mit.
    Gerade arbeiten wir an einer Optimierung, welche das System noch schneller macht. Bisher war es so, dass bspw. BCMD bei kleinen Command-Längen noch schneller war. Erst bei längeren Befehlen wurde auch RGCMD schneller. In der neuen Version ist RGCMD immer schneller, egal wie lang oder kurz ;D

    Unnötig, niemand wird jemals den Zeitlichen Unterschied von ( 1000 / 100 000 )ms pro Befehlsaufruf merken. Langsam sollte es doch so ziemlich Jedem auf die Nerven gehen,dass jeder meint, sein eigenes <HIER_BUCHSTABE_EINSETZEN>CMD erstellt.
    Von allen die bisher behauptet haben,ihres wäre schneller und besser als OCMD ( oder sonst ein A,B,C,D,E ... CMD ) ist noch keines schneller als ZCMD oder YCMD gewesen. Die beiden sind sowieso die Originale,wenn man es so nehmen will.

    Zitat von Goldkiller

    Unnötig, niemand wird jemals den Zeitlichen Unterschied von ( 1000 / 100 000 )ms pro Befehlsaufruf merken. Langsam sollte es doch so ziemlich Jedem auf die Nerven gehen,dass jeder meint, sein eigenes <HIER_BUCHSTABE_EINSETZEN>CMD erstellt.
    Von allen die bisher behauptet haben,ihres wäre schneller und besser als OCMD ( oder sonst ein A,B,C,D,E ... CMD ) ist noch keines schneller als ZCMD oder YCMD gewesen. Die beiden sind sowieso die Originale,wenn man es so nehmen will.


    Haben gerade einen Test mit dem neuen System gemacht, das noch nicht ganz ausgereift ist.
    Bei kurzen Befehlen, müssen wir zugeben, dass ZCMD wirklich schneller ist. Bei längeren Befehlen, wie bspw. "/o Hallo Leute, wie gehts euch heute mal wieder so?", also auch mit längeren Parametern, ist RGCMD schon schneller.

  • do.de - Domain-Offensive - Domains für alle und zu super Preisen

    Toll. Verschwendest doch nur deine Zeit,egal ob es schneller oder nicht schneller wird.
    So viele Leute haben schon ihren "eigenen" Command-Processor rausgebracht. Kaum einer kommt dabei aber auf die Idee, die Zeit in etwas sinnvolleres zu investieren.Etwas, was es noch nicht gibt und wirklich nützlich ist. Wen jucken denn die 1000 *CMD Versionen ? Mich persönlich sowieso nicht,da es sowieso immer das Gleiche ( Ausnahme: RyDeR` ) ist.
    Der minimale Zeitliche Unterschied wird sowieso niemals bemerkt, also wieso da so viel Zeit rein stecken. Leute releasen in der Regel ihren Code, damit Andere davon profitieren und es einfach anwenden können. Das ist ja der Sinn dabei. Ich brauch mich nicht darum kümmern wie die Befehle verarbeitet wurden, darum haben sich bereits Andere gekümmert. Natürlich kann man sich da auch Tipps und Tricks abschauen.
    Wenn jeder sein eigenes *CMD rausbringt, bräuchten wir bald ein eigenes Sub-Forum wo jeder sein *CMD vorstellen kann.
    Bringt dann aber wahrscheinlich eh nichts,jeder verwendet dann eh sein eigenes.


    Um zum Schluss zu kommen. Versuch dein Glück, ich rate aber davon ab. Für sowas würde ich meine Zeit nicht verschwenden.

    Schöne Idee, aber es ist doch völlig egal welches CMD man nun nimmt. Ob es nun ACMD, BCMD oder ADAC ist, ist doch egal. 8|

    [tabmenu][tab=Signatur,'http://bit.ly/1i4RY3v']

    Wie poste ich richtig?
    Nachdem du Google, die FAQ und die Suchfunktion erfolgreich ignoriert hast, erstellst du 2 bis 5 neue Themen in den falschen Unterforen mit lustigem Titel,
    zu vielen Ausrufezeichen und undeutlichem Text, unter dem sich jeder etwas anders vorstellen kann.



    Mr.Dubstep | GFX | Scripting | Hackerplace
    If Mr.DubStep don't have it, you don't need it.

    [tab=Spieler bei,'http://bit.ly/1db2jaf'][subtab=Hackerplace,'http://bit.ly/1bswN2T']


    Welch wunderschöner Hack ist heute vollzogen worden, könntest Du mir es denn sagen? Ein wunderschönes Browsergame, auch für Kleinigkeiten unterwegs. Erschaffe deinen eigenen Computer, nutze ihn um anderen das Geld zu rauben, schließe dich einem Clan an oder gründe selbst einen. Bleibe allein oder mit vielen Freunden.

    Hagelt ja dennoch ziemlich viel Kritik. Viele von euch behaupten, es wäre egal, denn der Zeitunterschied ist so minimal, dass es kein Mensch merkt. Stimmt ja eigentlich auch.
    Aber was, wenn der Zeitunterschied nicht das einzige ist? Was wenn es obendrein noch 100 mal einfacher anzuwenden ist? Wie würdet ihr das dann finden?
    Da sind wir nämlich gerade dran :P

    Zitat von Goldkiller

    Wozu denn noch einfacher. Es ist schon sehr einfach anzuwenden mit ZCMD,OCMD oder *CMD.Einfacher als RCMD wird es mit Sicherheit auch nicht, zumindest nicht 100 mal einfacher. Ihr investiert definitiv in die falschen Dinge eure Zeit :/.

    Stimmt, dieses rCmd macht es ziemlich einfach, wäre vielleicht eine Überlegung wert von ZCMD auf rCmd umzusteigen.
    Mich würde mal ein Test interessieren zwischen: RGCMD, ZCMD, OCMD, rCmd

    Ich kann Goldkiller nur Zustimmen,
    Ist doch Scheiss Egal, wie schnell so ein ding ist, hauptsache mal kann Befehle machen, und sie brauchen keine 10 Stunden bis sie Ausgeführt werden,
    Für mich reicht OCMD, das ist gut genug,

    Stahlbau Azubi deswegen kaum Aktiv

    Wenn man statt mit sscanf und so rumzuarbeiten, die Parameter direkt in das RGCMD:befehl(playerid, param1, param2) einbauen kann?
    Fände ich irgendwie sehr einfach.
    RCMD kannte ich nicht, aber so in der Art würde es dann wohl doch wieder aussehen.
    Trotzdem: Es ist doch schön, wenn man ein gutes Command-System hat. Es hilft Leuten sicherlich. Genauso wie A, B und XCMD helfen. Jeder soll das verwenden, was er selbst am besten findet, oder das was ihm vielleicht einfach als erstes unter die Augen kommt. Letztendlich geht es hier immer noch um den Spaß an der Sache. Wenn jemand Spaß daran hat, ein neues und vielleicht sogar gutes Commandsystem zu entwickeln, warum sollte man ihn dann daran hindern?
    Dass es niemand braucht, kann ich mir nicht vorstellen.


    Zum Test zu OCMD: OCMD verliert, wenn du jetzt von der Zeit redest, total. ZCMD gewinnt bei kurzen Befehlen mit kurzen Parametern (< 15 Zeichen) haushoch. Danach gewinnt RGCMD aber wieder. Das liegt daran, dass beide Systeme komplett verschieden sind. ZCMD sucht den string manuell mit einer for-Schleife ab. Die ist bei kurzen Befehlen natürlich sehr schnell durch, braucht mit jedem Zeichen aber auch länger. RGCMD arbeitet mit strfind, was eine relativ konstante Zeit hat.