Pawn - Kleine Grundbasis ( Teil 1 )

Pawn – Die kleine Grundbasis

Das Erste Skript

main()
{
print("Hallo Welt");
return 1;
}

Main dient als Einstiegspunkt nicht nur in dieser Sprache sondern auch in den meisten ander Sprachen wie Lua,C,C++ sogar meine Sprache Unstable
benutzt Main als einen Einstiegspunkt.

Wie ihr seht ist der Syntax eigentlich ganz Einfach & stellt kein großes Problem da, sehen wir uns das nächste Beispiel
an das dies genauer darstellen soll.

<Kopf>
{
<Kopf>
{
Funktion0(Funktion1(Parameter Funktion 1));
}
}

Wie man sieht erhalten alle Köpfe " " ihre Anweisungsstruktur & somit die Reihenfolge der Funktionen sprich Befehle die ausgeführt werden sollen.
Jeder Kopf spielt dabei eine Rolle, denn diese geben dem Block { } eine Eigenschaft weiter, mehr Infos dazu hier:
[Prinzip] Block Code
Bitte lest euch das gut durch somit erleichtert ihr euch den Einstieg hoffentlich etwas

Datentypen, für einige ein Fremdwort aber das soll sich ändern ,denn Datentypen sind einfach nur Strukturen die
weitere Eigenschaften an bestimmte Elemente weitergeben

new Float:Variable;

Float:Funktion(Parameter)
{

}

Wie man sieht habe ich eine Variable diese erhält nun die Eigenschaft Float sprich Kommazahl somit kann sie nur diesen einen Datentyp tragen wie
z.b. 3.14

Bei Funktionen ist das ganze im Prinzip genau so, diese dürfen in dem Fall nur Kommazahlen zurückgeben, sprich sie kann nur mit Float belegt werden
dies geschieht bei Funktionen durch

return

Dieser kleine Befehl ,,zurückgeben´´ gibt einen bestimmten Wert an die Funktion weiter sobald die Funktion ausgeführt wird.
Hat man nichts an die Funktion zurückgegeben behält diese den Basiswert von z.b. Float 0.0 oder einfach 0
nützt euch aber nichts denn dann müsstet ihr der Funktion die Eigenschaft Float nicht zuteilen.

return 3.14;

Ihr müsst nicht unbedingt einen festen Wert wiedergeben sondern könnt auch Variablen die auch die Eigenschaft Float haben haben zurückgeben

return Variable;

Gebt ihr einen Falschen Typ wieder so schlägt eure Funktion fehl.

Die Rückgabe ist eine Dynamische Sache wie man anhand dieses Beispiels sehen kann.

new variable = funktion(parameter);

Hier habe ich eine variable die den Typ Zahl hat, die Funktion gibt diesen Typ wieder

funktion(parameter)
{
return 1;
}

Somit erhält variable nun den Wert 1

Zu den Parametern muss ich auch noch was sagen, diese sind Variablen nur ohne die Einleitung new denn diese brauchen sie nicht, da Funktionsköpfe
Automatische darauf ausgelegt sind, ihr könnt natürlich all eure Eigenschaften verwenden wie gewöhnlich

funktion(Float:variable_blubb)
{
if(variable_blubb == 3.14)return 1;
}

Wie ihr seht verwende ich variable_blubb & frage ab ob 3.14 enthalten ist aber wie ihr seht habe ich den { } für if vergessen
bitte genau hinhören , diesen brauche ich auch nicht wenn ich nur ein Befehl für den Block habe
ich könnte aber auch

funktion(Float:variable_blubb)
{
if(variable_blubb == 3.14)
{
return 1;
}
}

seht ihr, nur da ich einen Befehl für diesen Block habe müsste ich diesen nicht mehr platzieren
was wenn aber keine 3.14 enhalten ist ? Tja dann wird dieser Block sozusagen Ignoriert & der Code fährt fort
ich möchte aber das die Funktion einen Standardwert mit return wiedergibt

funktion(Float:variable_blubb)
{
if(variable_blubb == 3.14)
{
return 1;
}
return 0;
}

Wenn meine Abfrage nicht stimmt Ignoriert der Code Block 2 & fährt fort somit führt er Automatisch return 0; aus
sprich er gibt Null zurück, was ihr über Return noch wissen solltet ist das return nicht nur wiedergibt sondern
auch Automatisch die Funktion beendet!
Nicht Vergessen!

Platz sparend Coden...

funktion()
{
print("Hallo Welt");
return 1;
}

Viel zu lang wenn man bedenkt das print 1 zurück gibt sobald die Aktion ausgeführt & dabei nur ein Kommando übrig bleiben würde.
siehe hier

funktion()return print("Hallo Welt");

Gibt 1 Zurück & Funktion ist übrigens 2x Kürzer dabei beendet return die Funktion sofort
So ist es wenn man die Tricks kennt, einfach mal selber probieren & staunen

Operatoren sprich Sonderzeichen

* + - / =

Dies sind die Hauptoperatoren die verwendet werden können um zu Rechnen, setzen & abzufragen

new variable = 5;
variable *=5;

Ich nehme meine Variable *5 also 5*5 = 25
geht auch so

variable = variable * 5;

genau das gleiche geht mit Minus,Plus,Geteilt
das Gleich Zeichen setzt hierbei den Wert

Wahr/Falsch Operatoren bzw. Kombinationen

variable1 == variable2

gibt Wahr oder Falsch zurück da == fragt ob der Wert in variable1 genau gleich variable2 ist

variable1 >= variable2

gibt Wahr oder Falsch zurück da >= fragt ob der Wert in variable1 Größer oder Gleich variable2 ist

variable1 <= variable2

gibt Wahr oder Falsch zurück da >= fragt ob der Wert in variable1 Kleiner oder Gleich variable2 ist

variable1 > variable2

gibt Wahr oder Falsch zurück da >= fragt ob der Wert in variable1 Größer variable2 ist

variable1 < variable2

gibt Wahr oder Falsch zurück da >= fragt ob der Wert in variable1 Kleiner variable2 ist

Diese Dinge geben etwas zurück also sind es Rückgabe Typen mit der Eigenschaft Boolean sprich Wahr/Falsch Rückgabe
ihr könntet dies also gleich mit return zurückgeben, in eine Variable tun die vom Typ Bool ist usw.

Wenn ihr das ganze jedoch abfragen wollt könnt ihr if oder while nehmen aber aufgepasst, ist beides verschieden

if , diese Abfrage fragt einmal ab & führt den Block unter sich aus wenn Einzelkommando das Kommando
while, diese Abfrage wird solange ausgeführt solange die Anweisung stimmt bzw. die Rückgabe

WICHTIG : Wenn ihr die Wirkung umkehren wollt z.b. fragt ihr ab

if(variable1 == variable2)

so könnt ihr die Abfrage umgekehrt gestalten mit [ IST NICHT ]

if(variable1 != variable2)

Ist nicht gleich

Variablen, sind im Grunde auch Werte die etwas tragen können sprich bei Funktionen setzt man die Werte der Funktionen mit return &
bei Variablen mit einem Simplen Gleich zeichen, es gibt Array Variablen sprich Reihenfolgen & Einzel Wert Variablen

new variable = 1; // Ein Wert Variable
new variable = 'A'; // Ein Wert Variablen nur mit Zeichen

new variable[5];
variable[0] = 1;
variable[1] = 5;
variable[2] = 4;
variable[3] = 7;
variable[4] = 8;

Eine Variable mit 5 Speicherplätzen von 0 angefangen.

new variable[5] = {1,5,4,7,8};

So geht es sogar noch schneller
Dort passen also 5 Zahlen oder 5 Zeichen hinein

new variable[5] = {'A','B','C','D','E'};

Ganz einfach oder (?)

Eine Variable kann in Pawn Maximal 3 Dimensionen haben [][][]
ihr könnt die variablen auch wieder beliebig setzen

variable[1] = 'L';
variable[1] = 7;

Zeichenketten sind also nichts anderes als Reihenfolgen, in jeden Speicher passt ein Zeichen hinein, eins gibt es noch bei Zeichenketten
zu sagen nämlich ihr Spezial Eingaben wie

\n = Neue Linie
\\ = Für das Backslash Symbol \
\' = Für '
\" = Für "
\x478 = Für eine Hex Dezimale Zahl ,,478´´ soll dabei zu Hex gewandelt werden
\478 = Für eine Nummer
\0 = Für Das Ende einer Zeichenkette

variable[1] = '\n';

An dieser stelle ist eine Neue Linie, so können auch die anderen genutzt werden, ganz einfach.

Schneller Variablen Definition

new variable1,
variable2,
variable[128];

So werden 3 Variablen aufeinmal definiert.

Schubladen System

switch()
{
case 0:
{

}
}

Wie man sieht springt diese Anweisung zu dem Block mit der Schublade die, den Wert enthält Switch enthält.

new var = 5;
switch(var)
{
case 5:
{
print("Hallo Welt");
}
}

Die Schublade kann auch bei mehreren Werten Reagieren wie

case 1,2,3,4,5:
{

}

oder

case 1..5:
{

}

Oben gezeigt 1,2,3,4,5 die Werte werden beachtet , & hier 1 bis 5
also werden nicht nur ausgesuchte Werte beachtet sondern alle von 1 bis 5

Zusatz Erklärungen

Der Goto Befehl

main()
{
goto marke;
print("Mich wird man nicht sehen :<");
marke:
print("Mich sieht man :>");
}

Goto ist ein ganz Simpler Befehl, dieser springt gleich zu der Stelle bei der, der Code
weitermachen soll der Code zwischen Sprungmarke & Befehl wird nicht beachtet.

Schleifen & ihre Spezial Möglichkeiten

main()
{
for(new i = 0;i<100;i++)
{
// Ich werde Solange Ausgeführt solange variable i kleiner 100 ist :>
}
new i = 0;
while(i<100)
{
// Ich werde ebenfalls solange ausgeführt nur das ich eine Abfrage bin :>
i++; // Zählt hoch ansonsten würde diese Schleifen Endlos sein
}
}

Wie man sieht, ganz einfach oder ?

für variable i gleich 0 führt solange aus bis i nicht mehr kleiner 100 im Schritt i + 1

Solange i kleiner 100 führe Aktion aus

Bei Schleifen gibt es noch Spezielle Kommandos wie break oder continue

Break = Bricht/Beendet die schleifen bzw. Stoppt sie
continue = Springt zur nächsten Zahl / Nächsten Aktion bzw. Überspringt den derzeitigen Ablauf

for(new i = 0;i<100;i++)
{
if(i == 50)continue; // Überspinge 50 & die Aktionen hiernach
}

Genau das gleich geht bei der While Schleife

[[ Teil 2 folgt ]]

Nein , ein Zeichen braucht eine Zelle

new variable = 5;
new variable = 'B';

Ein Zeichen das eine Zelle benötigt dazu ist nicht unbedingt ein Array nötig, der Array verträgt nur mehrere Werte unter anderem Zeichen, Zahlen & andere Strukturen Werte .