Sicher ist ein Nachteil von Phönix Tears System, dass jede Einheit separat behandelt werden muss und der Code so mit jeder zusätzlichen Einheit anschwillt.

Da sieht dadies System dann doch viel übersichtlicher aus. Allerdings wird bei seinem System, bei einem 5x5 Felder großen Sichtfeld, ständig eine Fläche von 121 Felder durchgegangen, ohne dass sich darauf eine gegnerische Einheit befinden muss (die [0/x],[x/0],[0/0] Felder nicht vergessen!!).
(BTW dadie, schau mal die temporären Zähler an, die würden, so wie du es im Code angegeben hast, nach der 2. Zeile unendlich nach rechts wandern)

Hier werden wiederum bei Phönix's System nur die Einheiten, die auch wirklich existieren, berücksichtigt, was es, obwohl das Skript größer ist, gegenüber dadie's, performanter macht.
Und Performanz ist das, was man bei einem solchen Projekt am meisten beachten sollte.


Da beide Systeme ihre Vor- und Nachteile haben, schlage ich einen Mix aus beidem vor.
Es werden nicht die Felder, auf denen sich ein Event möglicherweiße befinden könnte abgefragt, sondern die Positionen der Einheiten direkt. Allerdings werden diese nicht statisch im Code angegeben, sondern auf sie wird verpointert.

Das ganze könnte so aussehen: <Parallel Process oder Autostart Event>
(wem es zu unübersichtlich ist, sollte die Kommentare herauslöschen)
Code: 
//setzen: Eventbereich (Etart/Ende) der Einheiten
<>Variable Oper: [0001:$_fUnits startIndex] Set, 2
<>Variable Oper: [0002:$_fUnits endIndex] Set, 3
<>Variable Oper: [0003:$_eUnits startIndex] Set, 4
<>Variable Oper: [0004:$_eUnits endIndex] Set, 5
//setzen: Startpointer auf Einheitenkoordinaten
<>Variable Oper: [0012:$_fUnits Pointer] Set, 7
<>Variable Oper: [0013:$_eUnits Pointer] Set, 9
setzen: Koordinaten-Eventseite auf Einheiten
<>Variable Oper: [0014:$_units Coords Page] Set, 2
//setzen: sichtradius (quadratisch um Einheit)
<>Variable Oper: [0015:$_units Vision Size] Set, 5
//Zähler mit Startwerten initialisieren
<>Variable Oper: [0005:&_friendly index] Set, Var [0001:$_fUnits startIndex]'s Value
<>Variable Oper: [0006:&_enemy index] Set, Var [0003:$_eUnits startIndex]'s Value
//Zählschleife durch eigene Einheiten
<>Loop
  //Zählschleife durch gegnerische Einheiten
  <>Loop
  	//Pointer auf Koordinaten der eigenen Einheiten setzen
	<>Variable Oper: [0011:%_units KoordsPointr] Set, Var [0012:$_fUnits Pointer]'s Value
	//Koordinaten von eigener Einheit in Variablen, auf die Pointer referenziert, speichern
	<>Call Event: V[0005:&_friendly index][V[0014:$_units Coords Page]]
	//Pointer auf Koordinaten der gegnerischen Einheiten setzen
	<>Variable Oper: [0011:%_units KoordsPointr] Set, Var [0013:$_eUnits Pointer]'s Value
	//Koordinaten von gegnerischer Einheit in Variablen, auf die Pointer referenziert, speichern
	<>Call Event: V[0006:&_enemy index][V[0014:$_units Coords Page]]
	//Koordinaten gegnerischer Einheiten von Koordinaten eigener Einheiten abziehen, um Abstand zu ermitteln
	<>Variable Oper: [0007:fUnit X] -, Var [0009:eUnit X]'s Value
	<>Variable Oper: [0008:fUnit Y] -, Var [0010:eUnitY]'s Value
	//negative Werte unerwünscht, daher auf absoluten Wert umwandeln
	<>Branch if Var [0007:fUnit X] is 0 Less
	  <>Variable Oper: [0007:fUnit X] *, -1
	: End
	<>Branch if Var [0008:fUnit Y] is 0 Less
	  <>Variable Oper: [0008:fUnit Y] *, -1
	: End
	//prüfen, ob gegnerische Einheit im Sichtradius der eigenen Einheit liegt (==> ermittelter Abstand muss <= Sichtradius sein)
	<>Branch if Var [0007:fUnit X] is V[0015:$_units Vision Size] Less/Equal
    	  <>Branch if Var [0008:fUnit Y] is V[0015:$_units Vision Size] Less/Equal
      	    //gegnerische Einheit wurde gesichtet
	    Message: Friend \v[5] (Event ID) spots Enemy \v[6] (Event ID)
	  : End
	: End
	//gegnerische Einheiten Zähler um 1 erhöhen
	<>Variable Oper: [0006:&_enemy index] +, 1
	//prüfen, ob gegnerische Einheiten Zähler letzten Gegner durchlaufen hat
	<>Branch if Var [0006:&_enemy index] is V[0004:$_eUnits endIndex] Greater
    	  //gegnerische Einheiten Zähler auf Startwert resetten und Zählschleife durch gegnerische Einheiten beenden
	  <>Variable Oper: [0006:&_enemy index] Set, Var [0003:$_eUnits startIndex]'s Value
	  <>Break Loop
	: End
  : End Loop
  //eigene Einheiten Zähler um 1 erhöhen
  <>Variable Oper: [0005:&_friendly index] +, 1
  //prüfen, ob eigene Einheiten Zähler letzte eigene Einheit durchlaufen hat
  <>Branch if Var [0005:&_friendly index] is V[0002:$_fUnits endIndex] Greater
    //Zählschleife durch eigene Einheiten beenden
    <>Break Loop
  : End
: End Loop
Aufmerksame Leser werden sich nun fragen, woher denn die Koordinaten zu den Einheiten kommen.
Nun, diese werden im Event der Einheit direkt gesetzt.
Dazu wird im Event der Einheit eine neue Seite erstellt. Diese wird durch einen Switch gesperrt. Da dieser Switch nur zum Sperren dient und im Spiel NIEMALS angeschaltet wird, kann er ebenso für alle weiteren Eventseiten in anderen Events, die gesperrt bleiben sollen, verwendet werden.

Diese Seite enthält folgenden Code: <Push Key>
Code: 
<>Variable Oper: [V[0011:%_units KoordsPointr]] Set, This Event X Coord.
<>Variable Oper: [0011:%_units KoordsPointr] +, 1
<>Variable Oper: [V[0011:%_units KoordsPointr]] Set, This Event Y coord.
So hat man sogar einen kleinen, objektorientierten Ansatz mit eingebracht, auch wenn das wohl eher eine Vergewaltigung des Begriffes ist. ^^'


Noch ein paar Erklärungen zu den Variablen:
Code: 
0001:$_fUnits startIndex		//Bereich eigener Einheiten (Index beschreibt Event ID) -> Startindex
0002:$_fUnits endIndex			//Bereich eigener Einheiten (Index beschreibt Event ID) -> Endindex
0003:$_eUnits startIndex		//Bereich gegnerischer Einheiten (Index beschreibt Event ID) -> Startindex
0004:$_eUnits endIndex			//Bereich gegnerischer Einheiten (Index beschreibt Event ID) -> Endindex
0005:&_friendly index			//Iterator, zählt von 0001:$_fUnits startIndex bis 0002:$_fUnits endIndex
0006:&_enemy index			//Iterator, zählt von 0003:$_eUnits startIndex bis 0004:$_eUnits endIndex
0007:fUnit X				//X Koordinate einer eigenen Einheit (in ihr wird auch Abstand zwischen eigener und gegnerischer Einheit gespeichert)
0008:fUnit Y				//Y Koordinate einer eigenen Einheit (in ihr wird auch Abstand zwischen eigener und gegnerischer Einheit gespeichert)
0009:eUnit X				//X Koordinate einer gegnerischen Einheit
0010:eUnitY				//Y Koordinate einer gegnerischen Einheit
0011:%_units KoordsPointr		//Pointer, über dessen Wert die Koordinaten der Einheiten in die jeweiligen Variablen geschrieben werden
0012:$_fUnits Pointer			//Pointerstartbereich für die Koordinaten der eigenen Einheiten (0007:fUnit X)
0013:$_eUnits Pointer			//Pointerstartbereich für die Koordinaten der gegnerischen Einheiten (0009:eUnit X)
0014:$_units Coords Page		//Nummer der Eventseite in den Einheiten, in denen sich der Code zum setzen der Koordinaten befindet
0015:$_units Vision Size		//quadratisch angegebene Größe des Sichtbereichs der Einheiten in Felder
Vorangestellte Zeichen:

$ = statisch (werden zur Laufzeit nicht mehr verändert)
% = Pointer/Zeiger
& = Index/Zähler/Iterator