Beiträge von BlackFoX

Seid wann sind Proxys verboten bitte...

SpielerPos|LookAt Pos

KameraPos

if(!fexist(save))dini_Create(save);

Ein Klammer Fehler bzw. Statement Fehler

{
}

oder in den Semikolons

sprich

funktion(parameter);
{

}

Rot Makiert = Fehler = Crash

Meist auch

{
{

Kann auch zum Crash führen, sprich Blöcke ohne Kopf Anweisung

Simple Lösung

• Du hast Ein Filterskript & hast es in OnGameModeInit gepackt
• Du hast ein Gamemode & anders rum gemacht ( siehe über dem Satz )
• Du hast die Objekte zwischen einer Makro Abfrage (#if ) & dort stimmt was nicht

Du brauchst dazu die Funktion strtok

strtok(const string[], &index)
{
new length = strlen(string);
while ((index < length) && (string[index] <= ' '))
{
index++;
}

new offset = index;
new result[20];
while ((index < length) && (string[index] > ' ') && ((index - offset) < (sizeof(result) - 1)))
{
result[index - offset] = string[index];
index++;
}
result[index - offset] = EOS;
return result;
}

Zudem definier in OnPlayerCommandText :

new cmd[128],idx,tmp[128];

Erklärung ?
Weil iwie sagt mir das Bild gar nichts

Die Zone Ergibt immer ein Rechteck oder Viereck je nach dem

Y < MAX Y
|^
|^
|^
| MIN Y & X >>>>>MAX X
|-------------------X

In MTA wäre das leichter in Sa-mp viel zu Kompliziert
wie Opa sagte Zone mit Höhen Vergleich

OnPlayerCommandText muss einen Wert zurückgeben sprich wenn nichts zurückgegeben wird kann es zu einer Null Verweis Ausnahme führen
sprich Fehler

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 .

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 ]]

Damit erstellt man eine Zone auf der Spieler eingegrenzt diese Umgeben Unsichtbar Mauern sprich sobald du raus willst wirst du Automatisch zurückversetzt

if(not <Variable> == <Wert>) // Heißt soviel wie ist Negativ Gegenüber Wert

if(not <Variable>) // Heißt soviel wie ist im Negativen Bereich ( False )

if(<Variable> == <Wert>) // ist gleich

if(<Variable>) // ist Positiv ( True )

if(not <variable> and variable >= <Wert>)

if(<Variable> or not variable <= <Wert>)

Wie ihr seht ist die Vielfalt der Kombinationen wirklich Groß so wie im geliebten Pawn nur das tippen leichter fällt mir gewohnter Grammatik wie

ist nicht
not

usw.

Wörter merkt man sich eben etwas leichter...

Da Lua keine wirklich festen Datentypen besitzt ist es wohl auch einfacher alles mit einander zu Kombinieren siehe hier...

local var = {"Hallo","Welt",20} -- Ganz Einfach oder übrigens Doppel Minus = Kommentar

--[[ Multi Linien Kommentar ]]--

Auch Schleifen... Ein Kinderspiel

for <variable> = 0,1, 0.5 do

end

• variable gleich 0 zu 1 im Schritt 0.5 Plus

Es geht auch

for <variable> = 0,-2, -.5 do

end

• variable gleich 0 zu -2 im Schritt 0.5 Minus

Oder Abfrage Schleifen...

while <variable> < 7 do
-- Aktion
end

• Solange Variable kleiner ist als 7 führe Aktion aus

Ich hoffe ihr konntet dem Abstrakten Syntax näher kommen

Jeder Mann kenn ihn , keiner Checkts wirklich aber deswegen erkläre ich es nochmal,
Der Block Code ist ein Abschnitt der unter gewissen Umständen ausgeführt wird

Block

<Anweisungs-Kopf>
{

}

2 Dimensionaler Block

<Anweisungs-Kopf>
{
<Anweisungs-Kopf>
{

}
}

Jeder Block ist ein Bereich, werden darin Variablen definiert bleiben sie nur für den Block in dem Sie definiert wurden & Alle Blöcke die sich in dem Block befinden

<Anweisungs-Kopf>
{
new var = 5; // Lebt Auf
<Anweisungs-Kopf>
{

}

} // Nach dem Block Ende Existiert die Variable nicht mehr

Um dieses ,,<Anweisungs-Kopf>´´ genauer zu beschreiben , kurz gefasst sind dies Eigenschaftsträger & bestimmen

• Welcher Datentyp ( Zahl,Zeichenkette/Array,Dezimal,Kommazahl )
• Wie Oft der Block ausgeführt wird oder ob er Überhaupt ausgeführt wird

Beispiel:

<Anweisungs-Kopf>
{
new var = 5;
if(var == 5)
{
// Ich werde beachtet weil ich den Wert enthalte der die Eigenschaft verlangt
}
} // Variable ,,var´´ tot X.X :>

Wie ihr seht if also Wenn gibt an ,,Eine Frage´´ oder kurz Abfrage stimmt die Abfrage gibt dieser Kopf dem Block die Eigenschaft ,,Du darfst ausgeführt werden´´

Doppel Kopf ;>

main()
{
new var = 5;
if(var == 5)
{
// Ich werde beachtet weil ich den Wert enthalte der die Eigenschaft verlangt
}
} // Variable ,,var´´ tot X.X :>

Wie man sieht hab ich dem Block 1 die Eigenschaft Einer Funktion bzw. Eigenen Klasse gegeben sie hat keinen Datentyp bzw. einen Unbekannten Datentyp,
sie erfasst Block 2 , heißt Block 2 wird erkannt & wäre in Block 2 eine Variable würde diese aber nicht mehr in Block 1 Existieren denn wo Block 2 Endet stirbt
alles was in Block 2 ist solange es in Block 2 erstellt wurde, wäre aber in Block 1 eine Variable würde sie auch in Block 2 Leben, denn sie lebt solange bis Block 1 Endet
wieder solange sie in Block 1 erstellt wurde.

Alles was außerhalb Block 1 wäre also im ,,nichts´´ ist Lokal & wird in jedem Block erkannt lebt also solange bis der ganze Code durchgelaufen ist

Visuell

new einevar = 7; // Lebt auf
main()
{
new var = 5;// Lebt auf
if(var == 5)
{
new var2 = 8;// Lebt auf

} --->> var 2 ist tot weil Ende Block 2

}--->> var ist tot weil Ende Block 1

einevar ist tot weil Ende der Datei->>
(Sorry besser gings nicht :x )

Wie ihr seht tut die Block Struktur das was von ihr erwartet wird

Mal schauen ob es ne Möglichkeit gibt den Prozess Speicher auszulesen & somit die Cheats zu blocken :>
Y_Less hat mal gesagt es würde keine Möglichkeit geben aber als Entwickler würde ich dies auch behaupten

• Anti Geld - Eigene Funktionen für die Geldübergabe/abnahme + Temporärer Speicher in einer Form einer Variable + einen Timer der das ganze checkt
• Anti Waffen - Waffen Daten abfragen , wieder eigene Funktion damit Waffen gegeben genommen werden können damit die Slot Informationen dementsprechend gesetzt werden können
• Anti Health - Maximalen Health auf 99 setzen da Cheat Engines den Status meist auf die 100 setzen somit = Cheat dein Server begrenzt auf 99 also no Chance

Text erstellen der die Anzeige für die Minuten darstellt ( Editoren gibts genug ) am besten für jeden Spieler

new Text:blubb[MAX_PLAYERS];

Unter OnGamemodeinit TextdrawCreate...

im Payday Timer TextdrawSetString & Text Aktualisieren ...

Ich bleib weiterhin bei Miranda, ICQ tut seine Arbeit aber nur als Träger für Werbung

Aso & tmp ist bei dir bereits definiert daher lösche die tmp Variable einfach

if(!strcmp(cmd, "/skin", true))
{
tmp = strtok(cmdtext,idx);
if(!tmp[0])return SendClientMessage(playerid,COLOR_RED,"Verwendung : /skin [Skinid]");
SetPlayerSkin(playerid,strval(tmp));
return 1;
}

Sorry das ");)" war mein Fehler, vertippt