Code Optimierung

Nja da sollte ja jeder draufkommen sobald

public function lacks forward declaration (symbol "StartTimer_2")

kommt :>
Für PlayerOnServer müsste man eben nochmal ein extra public anlegen, damit er Beispielsweise unter
OnPlayerConnect/OnPlayerDisconnect Spieler hinzufügt/entfernt.
Aber was soll ich sagen, ist halt die Trägheit im Alter

Wieder was neues gelernt auch wenn ich das mit der string länge schon wusste.

Frage,
wenn man alle new für tore etc auch auf die art macht bringt das was ?

enum Newdefine
{
pdtor,
callcost,
}
new Newdefine;

Zitat von [NSG]Bright

Andere Beispiele von vollkommen abstrakter, unverständlicher Logik sind beispielsweise solche Sachen:
GetPlayerID(playerid)
{
return playerid;
}

Ok, ok, dieses Beispiel war vielleicht doch etwas zu fiktiv xD

Alles anzeigen

Nicht so fiktiv wie man vllt. denkt, es hat wirklich mal jemand im SA-MP Forum diese Funktion im "Useful Functions" Fred gepostet
Ihr könnt euch sicherlich vorstellen, wie Y_Less danach explodiert ist...

Achja übrigends zur ersten Seite, dass dcmd langsamer sei, als strcmp etc. stimmt natürlich, weils eine neue Funktion aufruft ABER
in Verbindung mit strcmp wird dann meist strtok verwendet und das ist wiederum der CPU Killer schlecht hin und wenn man beachtet, wieviel übersichtlich dcmd das ganze Skript macht, dann kann man diesen wirklich sehr kleinen Leistungsunterschied ruhig ignorieren...

So und damit mein Post auch noch etwas Konstruktives an Funktionen hat:

Sparen von Zeit in Positionsvergleichen

Eine ziemlich nützliche Funktion, die sehr oft auch von Streamern benutzt wird ist:

bool: isInReach(Float: x1, Float: y1, Float: z1, Float: x2, Float: y2, Float: z2, Float: reach)
{
	return (getDistanceBetweenPoints(x1, y1, z1, x2, y2, z3) <= reach);
}
Float: getDistanceBetweenPoints(Float: x1, Float: y1, Float: z1, Float: x2, Float: y2, Float: z2)
{
	return floatsqroot(floatpower(floatabs(floatsub(x1, x2)),2) + floatpower(floatabs(floatsub(y1, y2)),2) + floatpower(floatabs(floatsub(z1, z2)),2));
}

Sieht ziemlich professionell und optimiert aus, ist es aber definitiv NICHT.

Was macht getDistanceBetweenPoints?
Es rechnet den drei dimensionalen Pythagoras aus, also es zieht die Positionen von einander ab und berechnet den absoluten Wert um die Länge der Strecken zu erhalten, dann werden die Seiten alle mit 2 potenziert und anschließend die Wurzel draus gezogen. Klingt logisch. Ist es auch. Aber nicht effektiv.
Zuerst einmal könnte man

floatpower(floatabs(floatsub(x1, x2)),2)

durch

floatsub(x1, x2)*floatsub(x1, x2)

ersetzen womit man einen Funktionsaufruf sparen würde. Der wahre Leistungsausbremser ist aber floatsqroot welche in dieser Form sehr ineffektiv ist.
Natürlich ist diese Funktion von den Entwicklern von Pawn sehr effektiv programmiert worden, jedoch rechnet sie nunmal die Wurzel auf glaub ich 20 Stellen genau aus und das ist halt selbst mit der besten Engine leistungsfordernd.
Zumal wir ja nichtmal die wirkliche Distanz brauchen, wir brauchen ja lediglich wissen ob die Koordinaten in Reichweite der anderen liegen.
Durch simple mathematische Termumformungen kann man dann folgendes machen:

(getDistanceBetweenPoints(x1, y1, z1, x2, y2, z3)*getDistanceBetweenPoints(x1, y1, z1, x2, y2, z3) <= reach*reach)

ist exakt das gleiche, beide Seiten wurden mit 2 potenziert, jedoch wird dadurch die Wurzel welche in getDistanceBetweenPoints steckt aufgehoben und wenn man die Funktion nun intern schreibt und weitere Kürzungen von floatpower und floatabs vornimmt die auch überflüssig werden hat man also:

bool: isInReach(Float: x1, Float: y1, Float: z1, Float: x2, Float: y2, Float: z2, Float: reach)
{
	return (floatsub(x1, x2)*floatsub(x1, x2) + floatsub(y1, y2)*floatsub(y1, y2) + floatsub(z1, z2)*floatsub(z1, z2) <= reach*reach)
}

Das ist nun schon um einiges optimierter als am Anfang.
Aber es geht noch um einiges besser, wir erinnern uns, dass Funktionsaufrufe Zeit kosten also werden auch die floatsubs alle durch ein "-" ersetzt somit haben wir:

bool: isInReach(Float: x1, Float: y1, Float: z1, Float: x2, Float: y2, Float: z2, Float: reach)
{
	return ((x1- x2)*(x1-x2) + (y1-y2)*(y1- y2) + (z1-z2)*(z1- z2) <= reach*reach)
}

Nah dran am Perfekten ABER es geht natürlich immernoch besser und zwar können wir noch einen Funktionsaufruf sparen. Welchen? Richtig "isInReach"
Also weiter optimiert:

#define isInReach(%0,%1,%2,%3,%4,%5,%6) \
	(((%0 - %3) * (%0 - %3)) + ((%1 - %4) * (%1 - %4)) + ((%2 - %5) * (%2 - %5)) <= %6 * %6)

So und weiter gehts nicht, dieser Code ist jetzt so weit optimiert, dass er 40 mal schneller ist als der ursprüngliche Code und somit vor allem in Streamern, wo diese Funktion sehr oft aufgerufen wird, einiges an wichtiger Rechenzeit spart
Ist übrigends nichts was ich rausgefunden habe ._. Sondern Y_Less wie auch fast alle anderen Sachen die mit SA-MP Scripting zu tun haben
Naja ich hoffe mal ich konnt auch mal ein bisschen helfen
/me legt die wunden Finger in ein Erholungsbad

Ich finde das keine Optimierung, das macht das script nur länger

ich weiß zwar jetzt nicht genau auf welchen Beitrag du dich beziehst, jedoch sind viele Optimierungen auch zur Leserlichkeit und tragen meistens dazu bei, dass das Skript "länger" wird, jedoch nur die .pwn in der .amx ist es dann wieder so als wenn nichts wär (bestes Beispiel Kommentare oder defines)

Jo sry wollte dich nicht angreifen. Du magst besser sein wie ich im scripten aber schau weisst du wielange du dann für ein script schreiben würdest? Aber wenn sich das wirklich lohnt hab ich nix gesagt

Achso wenn du "länger" auf die Zeit beziehst, die es zur Entwicklung braucht dann muss ich dir zustimmen, wenn man an jeder Ecke nur rumoptimieren würde, würden sich Entwicklungszeiten mit der Zeilenanzahl expotential erhöhen. Aber so ein paar simple Sachen gehen ja schon, vor allem wenn sie schon so wie hier bereitgestellt werden und nicht selber entwickelt werden müssen. Und länger macht ja mein Beitrag dein Skript nicht, es sspart ja sogar nen paar Zeilen weils aus 2 Funktionen nen theoretischen Einzeiler macht, wobei die Anwendung die gleiche ist...

Das finde ich eine gute Idee vtl kann tjong mal sowas machen und einsatz zeigen

Zitat von [NSG]Bright

Muss ich jetzt grad überlegen.
Du könntest beispielsweise so etwas machen:
enum e_Tor_Names {
LSPD_Tor,
SFPD_Tor,
LVPD_Tor
}

new Tore[e_Tor_Names];

/* Object erstellen, am besten unter OnGameModeInit() : */
Tore[LSPD_Tor] = CreateObject(...);
/* Command zum Bewegen : */
if(!strcmp(cmdtext,"/lspd")) {
MoveObject(Tore[LSPD_Tor], ...);
return 1;
}

THEORETISCH funktioniert es so, weiß nicht ob es praktisch auch funktioniert, dürfte aber in dieser Form stimmen.

// Was ganz wichtig ist:
Eine enum-Struktur darf NICHT so heißen wie eine Variable, führt zu Errors.
Der "Header" der Enumeration (enum blabla) sollte IMMER einen anderen Namen haben als die dazu gehörige Variable/Array.

Falsch:
enum Everything
CallCost
}

new Everything[Everything];

Richtig:
enum _Everything
CallCost
}

new Everything[_Everything];

Alles anzeigen

jo wenn man das so macht Bringt das auch was ?

Zitat von LiL One

Das finde ich eine gute Idee vtl kann tjong mal sowas machen und einsatz zeigen

Was machen? oO

Für alle die ihren AMX Code per DisAMX (nicht zu verwechseln mit DeAMX) optimieren wollen:

Addition
Beispiel: a = b + 2
load.pri %[b] // primary register
const.alt 2 // alternate
add // primary = primary + alternate
stor.pri %[a]

Läßt sich optimieren durch:
load.pri %[b]
add.c 2
stor.pri %[a]

Vergleich: 8 Calls gegen 6 Calls.
Die zweite Register-Variante ist um einiges schneller. (Nachzulesen Pawn Impl.)

Auch Dec (In jeglicher Form) ist schneller als Sub (In jeglicher Form)
Wobei dieses Defiziet zumindest auf Intel Prozessoren weniger gewichtig ist.

Außerdem, wenn genug Dynamic Memory noch frei ist, ruhig diesen niedriger setzen.
#pragma dynamic 4096
Genügt für viele Filterscripte vollkommen.

Hm naja zB. in nem Checkpoint Streamer:

#define CHECKPOINT_AMOUNT 1
#define CP_UPDATE_INTERVALL 500
#define STREAM_DISTANCE 50.0
#define isCheckpointActive(%1) (playerData[%1][playerCheckpoint] != -1)


enum ePData
{
	playerCheckpoint
}
new playerData[MAX_PLAYERS][ePData];


new CPcoords[CHECKPOINT_AMOUNT][4] = {
{1.0, 2.0, 3.0, 4.0}
};


public OnGameModeInit()
{
	SetTimer("CheckpointStreamer", CP_UPDATE_INTERVALL, true);
	return 1;
}


public OnPlayerConnect(playerid)
{
	playerData[playerid][playerCheckpoint] = -1;
	return 1;
}


public OnPlayerDisconnect(playerid, reason)
{
	if(isCheckpointActive(playerid))
		DisablePlayerCheckpoint(playerid);
	return 1;
}


public CheckpointStreamer()
{
	for(new playerid = 0; playerid < MAX_PLAYERS; playerid++)
	{
		if(IsPlayerConnected(playerid))
		{
			new
				Float: px,
				Float: py,
				Float: pz;
			GetPlayerPos(playerid, px, py, pz);
			for(new checkid = 0, checkid < CHECKPOINT_AMOUNT, checkid++)
			{
				if(isInReach(px, py, pz, CPcoords[checkid][0], CPcoords[checkid][1], CPcoords[checkid][2], STREAM_DISTANCE))
				{
					if(isCheckpointActive(playerid))
						DisablePlayerCheckpoint(playerid);
					SetPlayerCheckpoint(playerid, CPcoords[checkid][0], CPcoords[checkid][1], CPcoords[checkid][2], CPcoords[checkid][3]);
					playerData[playerid][playerCheckpoint] = checkid;
					break;	
				} else if(iplayerData[playerid][playerCheckpoint] == checkid) {
					DisablePlayerCheckpoint(playerid);
					playerData[playerid][playerCheckpoint] = -1;
				}
			}
		}
	}
}

kA ob der funktioniert hab ich jetzt grad mal so hier im Forum hingeskriptet, aber für so welche Sachen halt, wenn halt teilweise mehrere 1000 Aufrufe pro Sekunde stattfinden, bringt das wirklich viel.
Im Vergleich zB. zu Commands die werden wesentlich seltener aufgerufen