Pawn Einstieg 2.0

- Sonderzeichen -

Wozu sind Sonderzeichen in einer Sprache da ?
Sie sind im Prinzip kleine Befehle & Regeln den Code Ablauf.
Fangen wir mit Grundkenntnis Mathematik an...

+ - / * % ^ ( )

Jeder kennt sie , jeder kennt die Mathe Regeln.

Regel 1 : Punkt vor Strich also immer erst * und / vor + und -
Regel 2 : Klammern gehen vor Regel 1 !

(2+2)*8 = 32
 2+2 *8 = 18

Man sieht das immer andere Ergebnisse folgen :

Aufgabe 1 : Klammer Regel > 2+2 > 4 mal 8 = 32
Aufgabe 2 : Punkt vor Strich > 2*8 > 16 + 2 = 18

So wie man sieht ist das soweit klar , hoffe ich doch.

Rest der Zeichen : % und ^ , ^ = Potenz , % = Rest

So kommen wir zum eigentlichen Thema, der Sprache selber, wieso werden klammern dort genutzt & wie Funktioniert das ganze.
Also eine Sprache wertet zwischen Terminal & nicht Terminal , Terminale Symbole sind Bezeichner sprich Namen für
Begriffe wie Variablen und Funktionen , derren Namen sind Terminale Symbole, Zahlen & Sonderzeichen hingegen ,
sind in bestimmten fällen nicht Terminal, Zahlen sind nur nicht Terminal wenn sie einzeln da stehen,
Sonderzeichen hingegen sind immer nicht Terminal , jedenfalls in einer Skript/Programmiersprache.

So wir sind gerade bei Sonderzeichen , daher fangen wir wie gesagt bei den Klammerregeln an,
in dieser Sprache gelten : ( ) und { }, 2 Klammerpaare , jedes paar hat seine Funktion.

So Klammer A ( und Klammer B ) haben die gleichen Funktionen wie in der Mathematik, die Klammer wird
immer als erstes ausgewertet sprich in der ersten Auswertung wird immer die innerste Klammer ausgewertet.

So wir definieren Beispielsweise das Terminal Symbol : xirgendwas
dieses enthält einen Wert , bei uns den Wert 7

So nun die Mathematik Aufgabe :

(xirgendwas+8)*7

Da die Sprache die Regel innerste Klammer immer zuerst beachten muss wie es sein soll, Rechnen wir

xirgendwas + 8 = 15

So in der Sprache ist das Terminal Symbol ,,xirgendwas´´ eine Variable , zu Variablen kommen wir gleich,
sie enthält einen Wert 7, dieser wird nun genommen , da ,,xirgendwas´´ nur ein Name ist der ersatzweise
für unseren Wert 7 dient , dieser wird + 8 gerechnet eine Zahl also nicht Terminal und nochmal mal 7 auch
nicht Terminal, das Ergebnis lautet hier 105.

So wir waren gerade beim Begriff Variable ?
Wozu werden Variablen genutzt ?
Sie sind das wichtigste in einer Sprache, sie können verändert werden sprich ihr Inhalt ist nicht zwingend
gleich, so können wir diese Variablen wenn sie den Typ Zahl enthält , sie auch wie eine Zahl behandeln,
wir können Addieren, dividieren , Multiplizieren usw...
Im Grunde dienen Variablen als Zwischenablage wo wir Werte lagern können die wir unter Umständen wieder verwenden dürfen & können,
Variablen können auch als fest gesetzt werden, sie können eine Kette von Zeichen oder Zahlen sein , sie können
das was nötig ist um unser Skript mit Informationen zu füllen.

So hier kommen wir zur Sprache Pawn, diese hat gewisse Regeln die es zulassen Variablen auf bestimmer Basis zu erstellen
und zu verwalten, es gibt eine Menge Typen :

• Float , ein Typ der Koordinaten fassen kanns sprich Komma Zahlen
• Array , Ein Typ wie er schon sagt eine Reihe von Zahlen oder Zeichen enthalten darf
• Integer , Eine ganze Zahl
• Boolean, Falsch & Wahr, gibt nur diese 2 Angaben wieder ( eng. true false )

dazu gibt es folgende Eigenschaften :

• const , was im Englischen Konstant heißt also unveränderbar & sie hat immer den selben Wert der zugeteilt wurde.
• new , damit definieren wir eine Variable erst sprich muss immer da sein, heißt ja auch Neu
• [] , folgt am Ende einer Variable , dies nennt man Dimension wenn eine Reihenfolge mehrere Räume haben soll, in dieser Sprach darf die Variable Maximale 3 Räume haben.

Als Beispiel , so nun folgt eine definierung, dort müsste ihr euere Logik einschalten :

new const xirgendwas = 5;

so wie ihr seht erstelle ich eine Variable , new = neu für neue Variablen , const ist hier eine Eigenschaft wie z.b. Float oder eine Array,
danach folgt der Name des Bezeichners er muss Terminal sein! , danach unser Wert 5 der dank const immer der gleiche bleibt.

new xirgendwas = 5;

Hier besteht die Eigenschaft const nicht, daher darf die Variable geändert werden , nicht ?
So geben wir ihr eine Eigenschaft wie Float , da Float eine 3te Eigenschaft ist also die Struktur
der Variable angibt darf auch vorher const folgen da es ein Hauptwort ist sprich was
die Variable selber beschreibt und nicht ihre Struktur.

new const Float:xirgendwas = 3.14;

Wie ihr seht habe ich der Variable die Eigenschaft fest & unveränderbar gegeben, dann die Struktur Komma Zahl,
also darf sie alles was für eine Komma Zahl gültig ist enthalten.

new Float:xirgendwas = 3.14;

Jetzt ist sie nicht fest & kann verändert werden,
da wir aber gerade beim verändern sind, wie verändern wir sie ?
Ganz einfach , wir greifen normal auf sie zu wenn es Möglich ist,

xirgendwas = 5.4;

schon hat unsere nicht feste Variable einen neuen Wert, feste Variablen hingegen können
nicht geändert werden, da würde euch der Compiler sagen, nein das geht nicht und beendet den Vorgang.

Ihr seht das definieren ist gar nicht so schwer, komme wir aber nun endlich zu den geschweiften Klammern
im Englischen Brackets { } , diese sind in Pawn wichtig, sie geben Bereich an ,
sie geben an wie lange Dinge gültig sind & was in dem Bereich passiert, einige Bereiche besitzen ebenso
Eigenschaften die den Bereich bei bestimmten Situationen auslassen oder ihn doch beachten , mehr dazu jetzt.

Fangen wir an , Bereiche entstehen bei neuen Funktionen oder Anweisungen aber was ist das ?
Funktionen sind eigene Befehle ähnlich wie feste Variablen die nur etwas zurückgeben wenn
man es ihnen sagt, so Anweisungen ? Dies sind z.b. Fragen an den Code ,
oder Schleifen sprich Vorgänge die Solange laufen bzw. den Bereich ausführen solange
das stimmt was ihnen vorgegeben wird, alles liegt im eigenen ermessen & man hat
im Grunde die volle Kontrolle über den Code :

So Funktionen sind wie gesagt wie Variablen verhalten sich aber etwas anders,
denn man kann bestimmen ob sie was zurückgeben oder einfach nur Kommandos auführen,
sie können aber beides nicht das dies auch Falsch verstanden wird,
So eine Funktion :

xirgendwas()
{
// Ein Bereich
}

Wie man sieht müssen Funktionen nicht extra gekennzeichnet werden wie bei Variablen ABER
sie können auch 2te und 3te Eigenschaften enthalten ( variablen können 1te 2te und 3te enthalten ),
aber nicht das euch das verwirrt , es soll euch das ganze erleichtern so das ihr versteht wovon ich spreche.
diese lauten folgendermaßen :

2te

• keine Eigenschaft , ganz normale Funktion ohne besondere kennzeichnung
• public , eine Öffentlich Funktion die sich im gesamten / Globalen Bereich verwenden lässt

3te

• wie gesagt integer, float , array, boolean

So diese Bereiche { } ihr wisst sie grenzen ein oder ?
Das hat aber auch einen Grund , sie bestimmen falls variablen
in ihnen definiert wurden wie lange sie gültig sind, definieren wir Variablen
in einem Bereich { sind sie bis zum Ende des Bereich gültig }
ganze Einfache Regel, nicht ?

xirgendwas()
{
new unserevariable = 89;

} // Ab hier nicht mehr gültig

So ganz einfach, wie man sieht ist die Regel so einfach
das man sich da nicht viel merken muss außer man ist zu Faul zum lesen

Funktionen mit Eigenschaft :

Float:xirgendwas()
{
return 3.14;
}

Warum haben Funktionen auch Eigenschaften ? Warum nicht ist die Frage ,
so kann man eingrenzen was Funktionen zurückgeben dürfen wenn sie es tun,
wie man sieht darf in jeder Funktion egal an welcher stelle ,,return´´
verwendet werden ABER Achtung, sobald das erfolgt wird
die Funktion beendet, gibt aber den Wert , bei uns 3.14 an eine Anweisung
oder Variable wieder, bei Anweisungen wie Abfragen ist es egal welcher Typ es ist
Hauptsache es kann in einen Wahr oder Falsch Wert konvertiert werden,
bei Variablen ist es wichtig das diese die gleiche Eigenschaft haben,
sie müssen dann vom selben Typ sein !

new Float:unservar = xirgendwas();

so nun hat unsere Variable den Rückgabewert erhalten & darf sich einen Keks freuen :>
wie ihr seht ganz gutes Prinzip.

Aber auch in Funktionsköpfen dürfen sich Variablen befinden die einen Standardwert haben dürfen z.b.

new hallo = 5; // Variable Hallo hat wert 5

xirgendwas(variable0 = 7,variable1 = 8)
{

}

Wozu diese Standardwerte ? Das kann ich euch sagen , so muss man wenn man
die Funktion verwendet diese 2 Angaben nicht mehr machen, aber wie macht man sie ?

new variablex = xirgendwas(5,9);

jetzt haben ,,variable0´´ und ,,variable1´´ in xirgendwas den Wert 5 und 9,
so diese Kopfvariablen darf man in der Funktion nutzen & dementsprechend verwenden,
so kommen wir aber zu den Standardwerten, denn hat man schon Standardwerte & möchte
z.b. ,,variable1´´ nicht immer angeben ist es auch ganz nützlich einen Standardwert zu haben,
den man nur angibt falls nötig. Aber was wenn variable0 einen hat aber variable1 angegeben werden muss ?
Kein Problem , einfach überspringen , das geht mit dem zeichen _ für nichts,

Funktion :

xirgendwas(variable0 = 7,variable1 = 8)
{

}

Beispiel :

new unserevar = xirgendwas(_,8);

Einfach, nicht ?

Aber wozu sind Funktionen da ?
Stellt euch vor ihr habt einen sehr langen Abschnitt der was erledigt und immer wieder was macht was ihr braucht & ihr braucht
den Wert der errechnet wird z.b. aber ihr braucht ihn in mehreren Abschnitten,
dann baut ihr eine Funktion , so braucht ihr weniger Platz , erspart euch Arbeit & euer Compiler wird sich auch freuen
über kürzere verarbeitung des Codes, so kann die Funktion auch mit ,,return´´ das zurückgeben was ihr braucht.

Kommen wir zum nächsten Bereichs Prinzip, den Anweisungen ( if und else , while, for , do und while )
Wie ihr seht gibt es diese Anweisungen nicht umsonst :

• if und else, eine Abfrage wo ihr je nach einem Wahrheitsgehalt entscheiden könnt was der Code machen soll
• while, eine andere Form einer Schleifen , arbeitet genau wie eine Abfrage
• for ebenfalls eine Schleife , wo ihr aber bestimmen könnte wie sie enden soll & was passieren soll eig. ebenso gut wie while nur anders
• do und while, diese Art von Schleife entspricht in etwa der normalen while abfrage , jedoch muss der erste durchgang zwingen passieren dann erst wird entschieden ob wiederholt werden soll oder nicht

So das ganze Prinzip entspricht einer Fernsteuerung, ihr steuert den Code mit Anweisungen , entscheidet was passieren soll und was nicht.

if()
{

}
else if()
{

}
else
{

}

Diese 3 Schritte sind Möglich , der erste wäre erforderlich für die Existenz der 2 anderen,
Schritt 2 darf so oft wie man will, Schritt 3 nur einmal , genau wie Schritt 1
dies gilt für eine Abfrage, hierbei steuert ,,if´´ das ganze geschehen was so viel heißt wie ,,wenn´´,
der nächste heißt ,,andernfalls wenn´´ und der letzte nur ,,andernfalls´´ sprich ihr stellt dem Code
eine Bedingung die erfüllt werden muss dann darf das dementsprechende passieren, was im Bereich für
den Block liegt, jede Anweisung hat ihren Bereich, auch in diesen Bereichen gilt für Variablen,
solange gültig bis der Bereich beendet wurde wenn man es für alle definiert ist es auch für alle gültig
also müsste man es in keinem der Anweisungsbereiche sein damit es für alle 3 Gilt, müsste sozusagen
im Bereich darüber existieren. Hoffe das wurde soweit verstanden.

So diese Anweisungen arbeiten auf Eigenschaft Boolean , für Boolean gibt es besondere Kombinationen
und Eigenschaften :

== heißt wenn genau gleich
=> größer gleich
> Größer ohne gleich also nur Größer
<= Kleiner Gleich
< Kleiner
!= Wenn nicht
! Wenn Negativ , Wenn nicht für bestimmte Zwecke wenn bei der Funktion Falsch & wahr wiedergegeben wird
true,false , Wenn eine Funktion nur 1 und 0 also auch true & false wiedergibt und man z.b. nur so abfragt

new bool:deinevar = true;

if(deinevar)
{
// Bereich
}

Wird dies als richtig gewertet je nach dem ob false oder true oder 1 oder 0

new deinevar = 0; // jetzt ohne boolean nur mit 0

if(!deinevar)
{
// Ergibt dann true da das stimmt , ! = negativ , 0 = false / Negativ , Wahr ist dann das gegenteil
}

genau das gleiche wie

if(deinevar != deinezahl) // deine Zahl wäre in meinem Fall jetzt 3 dann wäre es richtig da ich will das deinevar nicht gleich 3 ist und das ist sie nicht.

Hier mal die While Version die ebenfalls genauso geht

while(deinevar > 0) // als Beispiel, Größer als 0
{
deinevar-=1; // Ich ziehe 1 ab geht auch so deinevar--; genau das gleiche gilt für +
}

Wird solange ausgeführt solange deinevar größer als 0 ist also stimmt die Anweisung und solange wird auch eingegriffen,

hier die nicht Kopfgesteuerte Variante wo der erste Durchlauf passieren muss

do
{
deinevar-=1;
}
while(deinevar > 0);

Wenn deinevar danach immer noch größer als 0 ist wird wiederholt

Die Schleife die sich for nennt , dort wird eine Variable angegeben , bei dieser
wird eine Anweisung gesetzt also eine Abfrage und die Aktion dazu :

for(new varbla;varbla<4;varbla++)
{

}

Wird solange ausgeführt, solange der for Kopf falsch wiedergibt.

Ok kommen wir zu Arrays bzw. Reihen von zusammensetzungen :

new deinevar[5];

Wie man sieht wird der Index also der Maximale Inhalt mit einer Zahl angegeben ,
dieser Inhalt fängt bei 0 an und endet bei 4 , insgesamt ergibt das ganz dann doch 5,
der wirkliche letzte Inhalt enthält unser ende der Reihe die wird aber nie mit einbezogen
daher bleiben wir bei der normalen Zusammenkettung unserer Daten.

diese Angaben können folgendermaßen gestaltet werden

new deinevar[6] = "Hallo";

oder

new deinevar[6] = {'H','a','l','l','o'}; // Methode 1

oder

new deinevar[6]; // Methode 2

deinevar[0] = 'H';
deinevar[1] = 'a';

usw...

oder

new deinevar[5];

deinevar[0] = '1'; // bei Zahlen geht auch Methode 1, bei Float auch , die Var muss dann aber Float sein sprich voll Float
deinevar[1] = '2';

So wie man sieht 5 Zeichen , die Reihe darf nie die Maximale Angabe überschreiten,
wissen wir aber nicht wie groß unser Inhalt wird, können wir beim erstellen die Zahl des Index auslassen
unter Bedingung das der Inhalt Direkt beim erstellen angegeben wird wie hier :

new deinevar[] = "Hallo Welt";

Methode1 und 2 gehen hierbei auch , Hauptsache der Inhalt wird beim erstellen festgelegt.

So nun können unsere Variablen sogar 3 Räume haben :o

new variablex[][][] = {
{
{'A','B','C','D'},
{5,8,6,9}
},

{
{1,2,3,5}
}

};

Wie eine kleine Tabelle, jeder Raum darf eine Feste größe haben , muss aber nicht zwingend sein,
für die verarbeitungszeit ist es jedoch Positiv.
Bei Zeichenketten hingegen können es Maximal 2 Räume sein da die Zeichenketten die Plätze von Raum 3 schon brauchen,
zudem dürfen die Räume nur immer die Daten enthalten die als Eigenschaft angegeben wurden wie
z.b. Float,boolean usw. also darf diese Variable nur diesen Datentyp haben ,
aber dazu gibt es Enum, diese Anweisung erlaubt es mehrere Datentypen & neue neue Strukturen zu erschaffen.

enum pack
{
daten1, // Integer
daten2[32], // zeichenkette
Float:kommax
}
new variablex[][pack] = {
{2,"Hallo bla",3.14},
{5,"anderer inhalt",3.80}
}

Wie man sieht gar nicht so schwer zu begreifen, diese Variablen in der Enum geben die Struktur an
sprich es wird eine neue Struktur erschaffen die immer & überall verwendet werden kann & darf,
sprich möchte man diese Struktur in einer anderen Variable übernehmen so kann man diese Enum wieder
verwenden.
So lässt sich das ganze auch kompexer gestalten.

Kommen wir wieder zurück zur normalen array für die Zeichen,
es gibt noch spezielle Dinge die man wissen sollte um eine gewisse Kontrolle über
eine Array zu erlangen :

An jede stelle in einer Zeichenfolge und in einer stelle der Array kann man Formatierungen setzen sprich

* \n = Neue Linie
* \r = Rekursiv
* \\ = Normales Slash Zeichen
* \' = Einzelquote
* \" = Doppelquote 
* \xNummer = Hex Nummer mit danachfolgenden Zahlen / Angaben
* \NNN = Nummer Einfügen
* \0 = Ende der Array festlegen sprich der Inhalt danach wird gelöscht

new deintext[] = "\"Hallo\""

Ausgabe : "Hallo"

Also mit Doppelquote , da die Normale Quote ohne formatierung als Stringangabe erkannt wird wie man sieht.

deintext[1] = '\0';

Wie man sieht kann eine Array auch an bestimmten stellen verändert werden.

So nun noch zur größen ermittlung von deintext z.b. ,

new size = sizeof(deintext); // gibt die Größe wieder sprich die volle größe der Array
new laenge = strlen(deintext); // Die Momentane Größe des Textes

So das wars fürs erste, es folgt mehr.

Ich hoffe ich konnte die Basis gut genug erklären auch wenn es etwas Quer Beet ist.

Nach lesen dieses Artikels : [ SCRIPTING ] Datentypen ( Pawn )

mfg. BlackFoX_UD_

Was ist das eigentlich und wozu ?
Direktiven sind kurz gesagt Compiler Eigenschaften, sie geben definitionen an die extra für den Compiler sind,
sie grenzen Bereiche ein , können bestimmen was in den Stack kommt, der Stack ist der Code Zwischenspeicher,
sprich so kann man einfach bestimmen was der Compiler tun soll, worauf er achten soll, ja sogar der Speicher
des Codes lässt sich Manipulieren.

Wie beginnen Direktiven ?
Sie beginnen immer mit der Raute, das gibt an , das diese Zeile eine bestimmte Option angibt.

( Raute : # )

Hinter einer Direktive können Abfragen mit Variablen aus dem Code entstehen sowohl auch Variablen aus dem
Präprozessor ( Präprozessor verarbeitet Direktiven und weist sie zu )

Fangen wir mit ,,define´´ diese Option setzt eine feste Compiler Variable,
die nur vom Präprozessor noch einmal verarbeitet werden kann, vom Code selber nicht!
Wie jede andere Direktive, sie sind wie feste Variablen ( Kontanzen )

Hier mal die wichtigsten Direktiven

• #if
• #else
• #endif
• #pragma
• #include
• #tryinclude
• #undef

Als erstes beginnen wir wie man sieht man #if #else und #endif , diese 3 Direktiven Funktionieren wie gewöhnliche Abfragen,
Unterschied zum normalen Code ist im Präprozessor wie man sieht, man braucht keine Blocks / Brackets { } ,
diese werden vom Präprozessor nicht beachtet sprich :

#define VARIABLEFEST 50

#if VARIABLEFEST == 50
funktionbla()
{
#endif
return 1;
}

So ist der Wert nun nicht 50 so wird der Code nicht mit in den Zwischenspeicher geschmissen und existiert in unserer Ausgabe auch nicht,
also da aber jeder Block Vollständig sein muss und eine Anweisung besitzen muss, ergibt dies einen Fehler im Code,
da der Kopf mit dem Anfang nicht existiert sobald die Variablen des Präprozessors nicht 50 ist.

Da wir gerade bei den Variablen sind , diese können auch abgefragt werden, ob sie definiert wurden oder nicht,
als Beispiel :

#if defined VARIABLEFEST

#endif

Hier lässt sich ebenfalls wie bei er normalen Abfrage mit Boolean also dem Wahr/Falsch Prinzip arbeiten,
die höchste Regel ! Immer wenn ich kein gleich benutzte also einen bestimmten Wert haben will muss
die Negativ / Positiv Prüfung vo der Funktion stattfinden die Wahr / Falsch wiedergibt ,
sont schlägt die Logik Fehler , es heißt ja nicht

wenn definiert nicht gleich VARIABLEFEST

sondern::

wenn nicht definiert VARIABLEFEST

Wenn man das mit Wörtern nachvollzieht kann man so gut wie nicht scheitern, da jeder die nötige Logik besitzen müsste
um diese Sätze zu verstehen, denn auch die Sprache wurde von einem Menschen gemacht, also basiert alles auf
Menschlicher Logik.

Kommen wir zu ,,pragma´´ , diese Option stellt den Compiler ein und sagt ihm wie er konvertieren soll,
sprich welche Koordierung genutzt werden soll, wie viel Speicher reserviert werden soll,
wie viel Tabs verwendet werden für die Struktur , auch Variablen können als unnütz gekennzeichnet werden und
so einfach entfernt werden, das gilt für die vom Code erstellte Variablen, für die Präprozessor Variablen
benutzt man gewöhnlich ,,undef´´ als Option.

#pragma unused VARIABLEN_NAME
#pragma tabsize 2 // 2 tabs als Struktur nötig

Da ich die Option ,,undef´´ schon währendessen erklärt habe, kommen wir zu den letzten 2 wichtigen
Optionen die mehr oder weniger zusammegehören und jede hat ihre Funktion.

,,include´´ kennt jeder , damit bezieht man Externe Dateien ein die in den Code einbezogen werden,
hierbei dienen Externe Dateien immer als Ablage um eine gewisse Übersicht zu behalten,
groß Erklären müsste ich hoffentlich nichts.

,,tryinclude´´ wie der Begriff sagt, ausprobieren , Funktion vollkommen gleich ABER ,
sobald diese Datei nicht vorhanden ist, wird kein Fehler ausgegeben und die Direktive wird
ignoriert also nur wenn vorhanden.

Direktiven sind komplex aber während der Laufzeit nicht vom Code aufgreifbar, sprich sobald der Compiler
diese einmal verarbeitet hat verschwinden sie für immer, im Quellcode bleiben sie jedoch vorhanden,
nicht das dies Falsch verstanden wird.
Die Ausgabe Übernimmt alle Einstellung die getroffen werden.

Direktiven im Bezug auf ,,define´´ haben noch Spezielle Merkmale

• In ihnen können alle Datentypen Definiert werden ( float,boolean,Integer,String )
• Es können Funktionen verbaut werden

#define KOMMAZAHL 3.14

Wenn man diese Variable nutzt muss die Empfänger Variable ebenfalls vom selben Typ sein.

Da diese Art von Variablen jede Art von Datentyp wiedergeben können, können auch Locker Funktionen verbaut werden :

#define FunktionX(a,b) if(a==b)

Warum diese Art von Funktionen schneller sind ?
Sie greifen Direkt ein sprich da der Präprozessor alles ersetzt und einarbeitet werden diese Abfragen Direkt getätigt & Direkt berechnet.

Standard Variablen Struktur & Verwendung

new [<Eigenschaft>] <Struktur> <Identifikator> [=] [Wert] ;

Erweiterte Anwendung der Variablen

new [<Eigenschaft>] <Struktur> <Identifikator> [ [index][index][index] ] [=] [{] 


    [{]
    [{] [,] [}] [,]
    [{} [,] [}]
    [}] [,]
    [{]
    [{] [,] [}] [,]
    [{} [,] [}]
    [}] [...]


[}];

Anwendung Funktionen

<Eigenschaft> <Struktur> <Identifikator> ( [<Identifikator>] [,] [<Identifikator>][...] )
[{]
    [<Identifikator>] ;
    [<Identifikator>] ;
    [...];


    [return <Wert(e)>];
[}]

Anwendung Enum

enum <Identifikator>
{
    [<Identifikator>] [=] [Wert][,]
    [<Identifikator>] [=] [Wert] [,]
    [<Identifikator>] [=] [Wert] [...]
}

Standard Abfrage

if(<Identifikator> [Boolean] [<Identifikator>])
[{]
	[<Identifikator>] ;
	[<Identifikator>] ;
	[...]
[}]
[else if(<Identifikator> [Boolean] [<Identifikator>])]
[{]
	[<Identifikator>] ;
	[<Identifikator>] ;
	[...]
[}]
[else]
[{]
	[<Identifikator>] ;
	[<Identifikator>] ;
	[...]
[}]

Kopfgesteuerte Schleife & Normale While Schleife auch For

do
[{]
	[<Identifikator>] ;
	[<Identifikator>] ;
	[...]
[}]
while(<Identifikator> [Boolean] [<Identifikator>])

while(<Identifikator> [Boolean] [<Identifikator>])
[{]
	[<Identifikator>] ;
	[<Identifikator>] ;
	[...]
[}]

for([new] <Identifikator> [=] [Wert] ; [Boolean] ; [<Identifikator>])
[{]
	[<Identifikator>] ;
	[<Identifikator>] ;
	[...]	
[}]

Switch / Case Anwendung

switch([<Identifikator>])
[{]
	case [Konstante]:
	[{]
		[<Identifikator>] ;
		[<Identifikator>] ;
		[...]			
	[}]
	[default:]
	[{]
		[<Identifikator>] ;
		[<Identifikator>] ;
		[...]		
	[}]
[}]

* MAP *

• [] Kann vorhanden sein , muss nicht
• ... Mehr Werte dieser Art ( Reihenfolge )
• <Eigenschaft> Eigenschaften wie Öffentliche Funktion,Variable oder Statische Funktion , Variable
• <Struktur> Eine Struktur ( Datentyp ) wie Float,Boolean,String usw.
• <Identifikator> ident ein nicht Terminal Symbol , wie ein Name einer Variable

So wen das verwirrt, das ist eine Map, sprich ein Plan wie das ganze Funktioniert, die Legende dazu steht ja hier,
viele Begriffe sind so erkennbar, dies soll die Komplexe Bauweise der Sprache mal etwas besser darstellen.

Eine genauere Erklärung von Reihenfolgen bestimmter Daten wie Zeichenfolgen ,
Logisch aufeinander folgende Zeichen ( Wörter , Sätze ... ) , eine Verkettung von Daten,
jede Eingabe hat ihren Platz.

Beispiel

new Beispiel[] = "Hallo Welt"; // Initialisierte Array

new Beispiel[10]; // Initialisiert mit 0x00 in jedem Bereich was Leer heißt

Beispiel = "Hallo Welt";

Wie ihr seht haben beide Teile einen Unterschied aber bei genauerem hinsehen ist der Unterschied gar nicht
so groß, im ersten Beispiel wurde der Wert Direkt zugewiesen, sprich die Größe wurde
Automatisch angenommen & die Variable wurde gleich Initialisiert, was heißt,
sie wurde einem Wert verwiesen, das zweite Beispiel hingegen muss eine feste Größe haben,
da die Sprache nicht wissen kann wie Groß euer Inhalt werden wird & den Speicher
der dafür gebraucht wird muss vorher Initialisiert werden.

So kommen wir nun zum Zugriff auf die Plätze, ihr seht wir benutzen den Typ Array [] ,
die Kombination der Operatoren steht für ein Paket mit mehreren Plätzen sprich ,
zeigt der Variable wie ihr sicher lesen konntet das sie über mehrere Zugriffe verfügt,
der Zugriff auf die Plätze erfolgt gleich, aber wie weiß die Sprache das ihr nicht den Speicher
reserviert sondern zugreift ? Ganz einfach die Schlüsselwörter wie static,const,new
geben Bescheid das der Speicher reserviert wird & nicht auf ihn Zugegriffen werden soll,
sprich das ganze braucht immer einen Zeiger der nicht im Sinne von auf Speicher Zeigen arbeitet sondern
der dem Code z.b. zeigt was passieren soll.

Beispiel des Zugriffs ( Mit Variable Beispiel ) :

Beispiel[0] = 'a'; // Enthält statt H den Buchstaben a sprich der Wert wurde verändert

Es lassen sich ebenso Zahlen setzen

Beispiel[0] = 1;

oder Hex Werte , auch Binäre Werte 0b0001 z.b.

Beispiel[0] = 0x21;

Aber Float ließe sich nicht setzen , warum ? da die Variable erst die Struktur ,,Floating Point Value´´ haben müsste also
auf Deutsch Komma Zahl. Aber das wisst ihr sicher schon da es bereits erklärt wurde
In jedem Zugriff lassen sich auf Spezielle Werte setzen , die kennt ihr auch schon vom Hauptthema.

Ihr kennt bestimmt auch Mehrdimensionale Array Typen , in der Sprache Pawn begrenzt sich dies auf 3 Dimensionen,
entweder werden alle 3 Dimensionen auf eine Struktur verwiesen oder man legt diese per Enum fest,
die Struktur gibt auch die Maximalen Werte an die in diesem Raum enthalten werden sein dürfen.

enum struktur
{
Float:kzahl,
integerbla,
string[32]
}

new multidim[][struktur] = {
{3.14,50,"Hallo Welt"},
{2.55,987,"Test Text"}};

Wie ihr seht beinhaltet der Raum Nummer 1 mehrere Inhalte die sich Raum 2 nennen, jeder Raum in Raum 1 beinhaltet Werte
nach Struktur , als erstes Float dann Zahl und dann Text, würdet ihr statt struktur nichts oder eine bestimmte Anzahl von Inhalten nehmen
enthielten diese keinen festen Typ, sie übernehmen somit die Struktur der Variable , die auch Zahl ist,
also können nun nur Zahlen verwendet werden, würdet ihr multidim nun auf Float setzen so würden
nur noch Komma zahlen angenommen werden ABER kombiniert ihr Struktur mit Float würde dies einen Fehler ergeben,
da in einer festen Struktur die ja nur Komma zahlen beinhalten darf keine weitere Übernommen werden kann
die 3 verschiedene Strukturen enthält, da dies Sinnlos wäre, ist es unnötig das nochmal zu erwähnen,
wer kombiniert schon was ,was komplett Falsch ist wenn es keinen Sinn ergibt, da in der Struktur eine weitere Übernommen werden
kann , sprich sogar mehrere, in Exel würde man dies auch eine formatierte Tabelle nennen, auf dem gleichen Prinzip
arbeitet dieses Array System, da der Speicher so weißt wie viel reserviert werden muss & der Speicher
somit richtig & ohne bedenken zusammengesetzt werden kann.