AMXX.pl: Support AMX Mod X i SourceMod

<?php



    if(!defined('IN_IPB')){

        print "<h1>Incorrect access</h1>You cannot access this file directly. If you have recently upgraded, make sure you upgraded all the relevant files.";

        exit();

    }



    class Generator{

        private $sma;

        private $includes=array();

        private $defines=array();

        private $zmienne=array();

        private $stale=array();

        private $funkcje=array();

        private $packs=array();



        public function __construct(){

            $this->load();

            $this->output();

            $this->optimize();

        }



        // dodanie nowej biblioteki

        private function include_add(){

            $this->includes=array_unique(array_merge($this->includes,func_get_args()));

        }



        // dodanie nowej definicji

        private function define_add(){

            $this->defines=array_unique(array_merge($this->defines,func_get_args()));

        }



        // dodanie nowej zmiennej

        private function zmienna_add(){

            $this->zmienne=array_unique(array_merge($this->zmienne,func_get_args()));

        }



        // dodanie nowej stalej

        private function stala_add(){

            $this->stale=array_unique(array_merge($this->stale,func_get_args()));

        }



        // dodanie nowej funkcji

        private function funkcja_register($funkcja, $prefix, $sufix){

            $this->funkcje=array_merge($this->funkcje,array(array($funkcja, $prefix, $sufix, array())));

        }



        // dodanie tresci do nowej funkcji

        private function funkcja_add(){

            $args=func_get_args();

            $funkcja=array_shift($args);

            $kod=array_shift($args);

            sort($args);

            if(count($args)==0){

                $args=array("true");

            }

            $warunki=$args;

            foreach($this->funkcje as &$sfunkcja){

                if($sfunkcja[0]==$funkcja){

                    $arr=&$sfunkcja[3];

                    for($i=0;$i<count($arr);++$i){

                        if(count($arr[$i])==2 && $arr[$i][0]==$warunki[0]){

                            $arr=&$arr[$i][1];

                            $i=-1;

                            array_shift($warunki);

                        }

                    }

                    while(($warunek=array_shift($warunki))!==NULL){

                        $arr=array_merge($arr,array(array($warunek,array())));

                        $arr=&$arr[count($arr)-1][1];

                    }

                    $arr=array_unique(array_merge($arr,array($kod)));

                    sort($arr);

                    return;

                }

            }

            die("ERR vipgen.gen.03 :: funkcja_add :: Proba dodania kodu do niezadeklarowanej funkcji $funkcja.\nZadeklaruj napierw funkcję poprzez funkcję function_register(funkcja, prefix, sufix)");

        }



        // dodanie nowego warunku do tresci funkcji

        private function warunek_add($warunki,$tabulacje){

            $sma=$t='';

            for($i=0;$i<$tabulacje;++$i){

                $t.="\t";

            }

            foreach($warunki as $warunek){

                if(count($warunek)==2){

                    if($warunek[0]=="true"){

                        $sma.=$this->warunek_add($warunek[1],$tabulacje);

                    } else {

                        $sma.=$t."if(".$warunek[0]."){\n";

                        $sma.=$this->warunek_add($warunek[1],$tabulacje+1);

                        $sma.=$t."}\n";

                    }

                } else {

                    $sma.=$t.$warunek;

                }

            }

            return $sma;

        }



        // dodanie nowego pakietu poleceń

        private function pack_register(){

            $args=func_get_args();

            $pakiet=array_shift($args);

            foreach($this->packs as &$spack){

                if($spack[0]==$pakiet){

                    $spack[1]=array_merge($spack[1],array($args));

                    return;

                }

            }

            $this->packs=array_merge($this->packs,array(array($pakiet,array($args))));

        }



        // uruchomienie pakietu poleceń

        private function pack_add($pack){

            for($i=0; $i<count($this->packs); ++$i){

                $spack=&$this->packs[$i];

                if($spack[0]==$pack){

                    $arr=&$spack[1];

                    foreach($arr as &$pakiet){

                        $funkcja=array_shift($pakiet);

                        call_user_func_array('Generator::'.$funkcja,$pakiet);

                    }

                    array_splice($this->pack,$i,1);

                }

            }

        }



        // zaladowanie dodatkow

        private function load(){

            @include_once(IPSLib::getAppDir('vipgenerator').'/generator/include.php');

        }



        // formatowanie kodu SMA

        private function output(){

            // biblioteki

            sort($this->includes);

            foreach($this->includes as $include){

                $this->sma.='#include <'.$include.">\n";

            }

            // definicje

            sort($this->defines);

            foreach($this->defines as $define){

                $this->sma.='#define '.$define."\n";

            }

            // zmienne

            sort($this->zmienne);

            if(($zmienna=array_shift($this->zmienne))!==NULL){

                $this->sma.="\nnew ".$zmienna;

                $i=0;

                foreach($this->zmienne as $zmienna){

                    $this->sma.=((++$i)%5?', ':",\n").$zmienna;

                }

                $this->sma.=";\n";

            }

            // stale

            sort($this->stale);

            foreach($this->stale as $stala){

                $this->sma.="\nnew const ".$stala;

            }

            if(count($this->stale)){

                $this->sma.="\n";

            }

            // funkcje

            sort($this->funkcje);

            foreach($this->funkcje as $funkcja){

                $this->sma.="\n".$funkcja[1].$funkcja[0].$funkcja[2]."{\n";

                $this->sma.=$this->warunek_add($funkcja[3],1);

                $this->sma.="}";

            }

        }



        // optymalizuje kod, łącząc pojedyncze, zagnieżdżone warunki koniunkcją

        private function optimize(){

            while(($preg=preg_replace_callback('/if\(([^{]*)\)\{[\s]*if\(([^{]*)\)\{([^}]*)\}[\s]*\}/',create_function(

                '$m','return "if(".$m[1]." && ".$m[2]."){".preg_replace("/\n\t/","\n",$m[3])."}";'),$this->sma)

            )!=$this->sma){

                $this->sma=$preg;

            }

        }



        public function getSma(){

            return $this->sma;

        }

    }



?>

include_add(string ...); // dodaje tyle bibliotek, ile argumentów



// przykłady użycia:

$this->include_add("fun", "hamsandwich", "cstrike"); // dodaje biblioteki fun, hamsandwich i cstrike

$this->include_add("csx"); // dodaje bibliotekę csx



// uwagi

Każda biblioteka dodawana jest jednorazowo.

Biblioteki sortowane są alfabetycznie i rosnąco.

Każda biblioteka dodawana jest w osobnej linii.

define_add(string ...); // dodaje tyle definicji, ile argumentów



// przykłady użycia:

$this->define_add("PLUGIN \"New Plug-In\"", "VERSION \"1.0\"", "AUTHOR \"author\""); // dodaje definicje pluginu, wersji i autora

$this->define_add("ADD_TASKID 1549"); // definiuje numer zadania do reklamowania



// uwagi

Wszystkie definicje są sortowane alfabetycznie i rosnąco.

Kolejne w pełni identyczne argumenty funkcji define_add są pomijane,

lecz identyczne same nazwy zmiennych predefiniowanych już nie są.

Każda definicja dokonywana jest w osobnej linii.

zmienna_add(string ...); // dodaje tyle zmiennych, ile argumentów



// przykłady użycia:

$this->zmienna_add("gMaxClients", "obrazenia[33]", "bool:bGamesEnabled = true");

$this->zmienna_add("Float:dmg"); // dodaje zmienną dmg typu zmiennoprzecinkowego



// uwagi

Poza nazwami zmiennych należy podać w razie potrzeby typ zmienej, liczbę wymiarów i komórek oraz domyślną wartość.

Kolejne w pełni identyczne argumenty funkcji będą pomijane nawet przy innym wywołaniu funkcji zmienna_add.

Zmienne dodawane są piątkami na linię.

stala_add(string ...); // dodaje tyle stalych, ile argumentów



// przykłady użycia:

$this->stala_add('doswiadczenie_poziomu[] = {0, 46, 113, 247, 396, 622, 901, 1228, 1683, 2219, 2770}');



// uwagi

Nie należy podawać słów kluczowych: new ani const, które generowane są automatycznie

Kolejne w pełni identyczne argumenty funkcji będą pomijane nawet przy innym wywołaniu funkcji stala_add.

Każda stała dodawana jest w osobnej linii.

funkcja_register(string $funkcja, string $prefix, string $sufix); // rejestruje nową funkcję



//opis

$funkcja - nazwa funkcji



$prefix - prefix funkcji, wszystko przed nazwą funkcji, w tym typ funkcji oraz rodzaj zwracanego wyniku

Można zamiast funkcji, zdefiniować stock, zastępując słowo public na stock.

Spacja po argumencie jest wymagana, jeśli to konieczne.



$sufix - wszystko, co po nazwie funkcji, w praktyce nawias wraz z ew. argumentami i ich typami



// przykłady użycia:

$this->funkcja_register('plugin_init','public ','()');



// uwagi

Rejestracja funkcji przed jej użyciem jest konieczna.

Kolejne dodanie tej samej funkcji nie będzie pomijane.

funkcja_add(string $funkcja, string $kod, string ...); // dodaje kod do funkcji



//opis

$funkcja - nazwa funkcji, do której będzie dodawany kod

Funkcja musi być wcześniej zarejestrowana poprzez funkcję funkcja_register



$kod - blok instrukcji (blok kodu), który będzie dodawany do funkcji.

Kod winien być zakończony znakiem nowego wiersza.

Nie należy podawać znaków tabulacji dla pojedynczych wierszów.

Znaki tabulacji generowane są automatycznie na podstawie warunków.



... - dowolna liczba warunków do spełnienia, aby kod został wywołany

Argumenty warunków są sortowane alfabetycznie i rosnąco

Argumenty są łączone, a na ich podstawie generowane tabulacje



// przykłady użycia:

$this->funkcja_add("plugin_init","register_plugin(PLUGIN, VERSION, AUTHOR);\n"); // rejestruje plugin

$this->funkcja_add("ham_spawned_post","give_item(id, \"item_thighpack\");\n",'gRound>=2','gRound<=4','get_user_team(id)==2');

// daje defusera dla antyterrorystów od drugiej do czwartej rundy, funkcja ham_spawned_post musi być wcześnie zdefiniowana



// uwagi

Kolejne bloki instrukcji są sortowane alfabetycznie i rosnąco.

Funkcja z pierwszego argumentu funkcji musi być wcześniej zarejestrowana.

pack_register(string $pakiet, string $funkcja, string ...); // dodaje pakiet funkcji do wykonania

pakiet jest to zestaw instrukcji wykonywany jednokrotnie, o ile zostanie wywołany poprzez funkcję pack_add



//opis

$pakiet - nazwa pakietu, jaki ma zostać zarejestrowany



$funkcja - nazwa funkcji, jaka zostanie wywołana poprzez pakiet



... - dowolna liczba argumentów funkcji $funkcja, zgodnie z opisem tej funkcji



// przykłady użycia:

$this->pack_register('model','zmienna_add','bool:g_Vip[33]','model_ct','model_tt');

// rejestruje w pakiecie "model" dodanie trzech zmiennych poprzez funkcję zmienna_add

$this->pack_register('spawn','funkcja_add','plugin_init',"RegisterHam(Ham_Spawn, \"player\", \"Ham_Spawned\", 1);\n");

// rejestruje dodanie do plugin_init funkcji uchwytu Ham_Spawned poprzez funkcję funkcja_add w pakiecie "spawn"



// uwagi

Nie potrzeba rejestrować samego w sobie pakietu, od tego służy pierwszy argument.



Wywołanie punkcji z identycznym pierwszym argumentem spowoduje dodanie kolejnego

pakietu kodu do wykonania dla tego samego pakietu danych.



Aby zarejestrować inny pakiet, należy użyć innej nazwy pakietu.

Aby aktywować pakiet, należy użyć funkcji pack_add.



Użycie funkcji pack_add będzie skutkować wykonaniem pakietu kodu tylko jednoktornie.

Nie użycie funkcji pack_add pomimo zarejestrowania pakietu, nie spowoduje jego wykonania.



Należy zwrócić uwagę, aby drugim parametrem była jedna z powyższych funkcji,

a każdym kolejnym, kolejne argumenty tej wybranej funkcji do dodania do pakietu.

pack_add(string $pakiet); // wykonuje wcześniej zarejestrowany pakiet kodu



//opis

$pakiet - nazwa pakietu instrukcji, który ma zostać wykonany



// przykłady użycia:

$this->pack_add('spawn'); // wykonuje pakiet danych "spawn"



// uwagi

Pakiet winien być wcześniej zarejestrowany poprzez funkcję pack_register.

Wywoływany pakiet wykonanie zostanie tylko raz nawet przy wielokrotnym wywołaniu funkcji.

Próba wykonania niezarejestrowanego pakietu nie zakończy się błędem, lecz brakiem działań.