Prolog:
Dieses Tutorial ist nur für Fortgeschrittene gedacht.
Mir viel schon immer auf, daß viele nicht genau die Syntax möglichkeiten von PAWN kennen.
Wer will schon if und else, wenn es auch kürzer geht?
Constanten und Arrays:
Const Variablen haben bekanntlich keinen veränderlichen Wert und können zur Array Initalisierung genutzt werden.
Dazu wird beim erstellen der Wert hinzugefügt.
Allerdings meckern ältere PAWNCC's auch bei späterer Wertvergabe und nur erstellung nicht.
new c;
read(c); // Diese Funktion existiert nicht wirklich
const b = c; // Nun ist b für immer c und unveränderlich!
new a[code=c]; // Solange c > 0 ist, funktioniert dies prächtig!
Enum Struktur:
Der Vorteil eines Enums liegt auf der Hand.
Namen anstatt Zahlen.
Es gibt zwei Anwendungsbereiche.
Einmal als Type und einmal als Array Zelle.
Ersteres ist dies:
enum a {
test,
ja
}
b(a:arg)
return (arg == test) ? (-1) : (-2);
Aufgerufen wie folgend:
a(test);
Zweiteres:
enum a {
test,
test2
}
new b[a];
Aufgerufen wie folgend:
b[test]; // oder b[test2];
Vordefinierte Werte/Default Value bei Funktionen:
Der gebrauch ist vielfälltig, und wenn öfters eine Funktion als Parameter den selben Wert besitzt, liegt es nahe, den faulen Default Weg zu nutzten.
a(b, c=1) { // default value c welches bei nicht setzten 1 ist!
printf("%d und %d", b, c);
}
a(2); // möglich
a(2, _); // genauso möglich _ ist ein Platzhalter und ruft dementsprechend den Default Value auf.
a(2, 2); // geht auch
a(2, 3); // und dies ebenso
Unbestimmte Argumenten-Anzahl:
Immer gut zu gebrauchen.
Z.b. möchte man gerne sich tausend Addierungsoperatoren sparen und es lieber in eine Funktion packen.
Nun weiß man die Parameter Anzahl leider nicht.
Macht nichts, wir lassen PAWN einfach zählen.
FastAdd(&a, ...) { // ... sind die unbekannten Parameter!
for(new i = 0; i < numargs(); i++) {
a += getarg(i);
}
return a;
}
Aufzurufen:
new b = 0;
FastAdd(33, 22, 11, 23);
FastAdd(99, 25); // Auch möglich
Vordefinieren einer Funktion:
Da hat man den Salat, man ruft eine Funktion auf die es noch nicht gibt, oder man erstellt eine Public function.
Viele nutzten dann "forward", aber das braucht man garnicht.
Genauso wie das Keyword "public".
Es geht kürzer (Vordefinieren):
a(b);
// Viel Quellcode
a(b) {
// code
}
Und nun eine kurze public:
@a(); // Unsere Public wir kennzeichnen durch das '@' das wir die Funktion Publik nutzten.
@a() {
// code
}
Kürzer oder? :>
Eigene Operatoren:
Hier keinen heißen Brei, wird jeder schonmal gehört haben. ;x
enum bad {
god = 3,
halfgod = 2,
user = 1
}
stock bad:operator+(bad:a, bad:b) {
return (a!=god&&b!=god) ? (a+b) : (god);
}
MEHR FOLGT SPÄTER! (MORGEN :X)
