Wie gesagt, dein Quellcode ist beschissen. Man könnte weinen, wenn man das sieht. Ach quatsch, sogar heulen!
Mach es auf deine Weise , heißt ja nicht das du es nicht auf deine Art & Weise umsetzen darfst , wenn jeder so
denken würde, könnten wir uns gleich ins Grab legen weil schon ein Mensch existiert 
p.s. Nicht böse gemeint oder so
Er hat nicht gesagt das er ihn nicht freigibt ...
wenn man keine Ahnung hat ...
Jetzt kommts wieder, Kye ist das Arsch , wenn er keine Lust hat braucht ihn auch keiner zwingen.
Jetzt gehts wieder los, IV-Mp ist die Zukunft ? ;D ich sehe noch wenig von der Zukunft
Achso und später kommen dann die ganze MTA Freaks und meinen IV-Mp ist schlecht, MTA kann alles besser,
viel Spaß Leute, wenns Spaß macht...
Ich finde schon krass wenn man erst alles unterstützt und alles dermaßen in den Dreck zieht.
*facepalm*
FPS Maker benutzt oder wie ? 
Ist das nicht so ein Klick Tool 
nennt man Programmieren da das ganze nicht mit Komponenten arbeitet sprich die Sprachen dienen nicht als Extension
Vor nen paar Stunden war Squirrel für dich noch fremd sprich kann mich daran erinnern das du es nicht verstanden hast,
C++ ist in etwa gleich nur mit mehr Features , irgendwie zweifle ich das ganze an.
ja jeder Mulitplayer braucht Zeit, nur alles braucht Zeit für die Arbeit nur wenn es keine weiteren Versionen gibt, wird IV-MP, SA-MP einholen....
Sa-mp hat auch Zeit gebraucht , viel zeit daher sehe ich das dort nicht anders oder meinst du alles passiert von heute auf Morgen, eher nicht
Firewall hilft schon, mach die mal aus, dann schauen wir wie es endet
@Adan : keiner hat behauptet das hacker die ports durchsuchen oder wurde das irgendwie erwähnt ?
IV-MP vs Sa-mp ? Nicht im Ernst oder , IV-MP ist im Moment um Längen schlechter
Hast du auch schon Bilder oder derartiges ?
Wirbst du für dich ?
hast du Referenzen die dies Beweisen ?
Mit welcher Sprache werden die Spiele geschrieben ?
gefährlich wird es nur wenn ein Trojaner oder derartiges darauf zugreift aber ich denke das jeder sein System so sauber hält
das, das gefährlichste erst gar nicht drauf kommt , außer man fällt auf jeden scheiß rein
Bleibt mir gleich, hab mit Sa-mp selber sprich mit dem Spiel lange nichts mehr am Hut, mich interessiert nur das Coding
Du kannst es in ein Modul kopieren oder Direkt in die Klasse deiner Anwendung , danach einfach einen Timer erstellen,
entweder via Code oder halt per Klick durch die Toolleiste
Dim tm As New Timer
tm.Interval = deinintervall
tm.start()
AddHandler tm.Tick, AddressOf tmx_doworkPrivate Sub tmx_dowork(ByVal sender As System.Object, ByVal e As System.EventArgs)
if GetAsyncKeyState(13) then Msgbox("bla")
End SubPrivate Declare Function GetAsyncKeyState Lib "user32" _
(ByVal vKey As Long) As IntegerEinbinden & via Timer abfragen , für die Virtuellen tasten ASCII Tabelle nutzen
http://www.torsten-horn.de/techdocs/ascii.htm
if GetAsyncKeyState(13) then Msgbox("Eingabe gedrückt")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 :
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 abfragtnew 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öschtnew 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_
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 = 18Man 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 = 18So wie man sieht ist das soweit klar , hoffe ich doch.
Rest der Zeichen : % und ^ , ^ = Potenz , % = RestSo 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)*7Da die Sprache die Regel innerste Klammer immer zuerst beachten muss wie es sein soll, Rechnen wir
xirgendwas + 8 = 15So 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 :
dazu gibt es folgende Eigenschaften :
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
3te
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,
Stimme Roy voll & ganz zu, sie brauchen dich solange, solange nur du was hast
daher behalts lieber für dich
Im Showroom wurde von MWP extra eine Liste mit allem Gamemodes die ihre Zwecke erfüllen, erstellt aber selbst dann ist man sich zu Schade...
Beispiel
ohneRueckgabe()
{
DoSomething();
}
if(ohneRueckgabe()) // << kann nicht gewertet werden da kein Wert wiedergegeben wird
mitRueckgabe()
{
DoSomething();
return 10;
}
if(mitRueckgabe() == 10) // << Beispiel 1 ( genaue Abfrage )
Da 1 Automatisch = Wahr & 0 = Falsch
mitRueckgabe()
{
DoSomething();
return 1; // return true; geht auch
}
if(mitRueckgabe()) // Beispiel 2 ( Boolean , Wahr Falsch )
Sollte dann erledigt werden wenn es nötig ist
PlayerToPoint gibt nichts wieder, also muss PlayerToPoint einen Wert wiedergeben damit die Rückgabe gewertet werden kann,
aber den Umweg kannst du dir ersparen da es schon IsPlayerInRangeOfPoint gibt