Entfernung von events berechnen !

[Balduras]

So, hier mein prob:

Ich würde gerne für eine gegner KI, die entfernung von einem event mit 2 anderen berechnen lassen. Der Gegner soll erkennen, welches event (von den 2en) näher bei ihm ist (und dann dort hingehen... etc)

Ich meine ich habe da eine Idee ( Pytagoras, schreibt man den so ? ) aber es gibt bestimmt ne profi lösung !

Natürlich gibts im Voraus schon mal ein fettes Lob: §schleim

[RB [Redbounty]]

Hier mal mein Lösungsvorschlag xD...
Kommentare sind nur spärlich gesetzt ^^"



Auf Wunsch send ich dir das Script auch gern zu ^^ - vielleicht gibbet aber auch ne einfachere Lösung, aber ich wollt unbedingt das Schräglaufen des Gegners einbauen. Ich hoffe die Mühe war net umsonst :).

~RB~

Edit: Erklärung (jedenfalls der Versuch)

Diese Fork dient lediglich dazu, zu überprüfen, ob die beiden Gegner schon "erledigt" sind. Die Anzahl der

getöteten Gegner wird (wie wir ja später sehen werden - oder jetzt schon sehen, in Variable 0031 gespeichert). Ist die Fork

erfüllt, so wird das Skript beendet.

Code:

<>FORK Optn:Varbl[0031:GegnerTot?]-2
 <>Messg:Die Gegner sind platt ;)
 <>Goto Title Screen
 <>
:END Case

Speichern wir zunächst die X- und Y-Positionen des Gegners und von Ziel1 & 2 (Gegner, Ziel1 und Ziel2 sind die

Namens der Events)

Code:

<>Variable Ch:[0001:GegnerX] Set, Gegner X pos
<>Variable Ch:[0002:GegnerY] Set, Gegner Y pos
<>Variable Ch:[0003:Target1X] Set, Ziel1 X pos
<>Variable Ch:[0004:Target1Y] Set, Ziel1 Y pos
<>Variable Ch:[0005:Target2X] Set, Ziel2 X pos
<>Variable Ch:[0006:Target2Y] Set, Ziel2 Y pos

Jetzt müssen wir den Abstand von Ziel1 und Ziel2 zum Gegner berechnen. Da dort allerdings auch negative Werte

herauskommen können, (Beispiel: X-Positon Gegner = 10, X-Position Ziel1 = 14, d. h. 10 - 14 = -4) fügen wir noch ein paar

Forks ein, um dies zu verhindern.

Code:

<>FORK Optn: Varbl[0001:GegnerX]-V[0003]abov		<- GegnerPosX größer als Ziel1-PosX?
 <>Variable Ch:[0007:Abstand1X] Set, Var.[0001] val.	<- Wenn ja, dann größeren Wert (GegnerPosX) in Var 0007 sichern
 <>Variable Ch:[0007:Abstand1X] -, Var.[0003] val.	<- und den kleineren Wert abziehen (Var 0001).
 <>
: ELSE Case						<- ANSONSTEN:
 <>Variable Ch:[0007:Abstand1X] Set, Var.[0003] val.	<- Größeren Wert (Target1X) in Var 0007 sichern
 <>Variable Ch:[0007:Abstand1X] -, Var [0001] val.	<- und den kleineren Wert abziehen (Var 0003)
 <>
:END Case

Das ganze wiederholt sich für die Y-Position und dann nochmal für die X- und Y-Position von Ziel2. (siehe Code)

Nachdem wir nun all die schönen Forks gebastelt haben (und die verdammten Schusseligkeitsfehler entfernt sind *grml*), gehts

nun weiter... Wir fassen nun den gesamten Abstand (in Kästchen) vom Gegner zu Ziel1 bzw. Ziel2 zusammen.

Code:

<>Variable Ch:[0011:Abstand1Total] Set, Var.[0007] val	<- Erstmal den X-Abstand von Ziel1 sichern
<>Variable Ch:[0011:Abstand1Total] Set, Var.[0008] val	<- und den Y-Abstand hinzuaddieren
<>Variable Ch:[0012:Abstand2Total] Set, Var.[0009] val	<- Das Gleiche für Ziel 2
<>Variable Ch:[0012:Abstand2Total] Set, Var.[0010] val

Jop, jetzt haben wir ja schon die Werte für den Abstand! Juhu! - Nur noch bestimmen, wo der Gegner hinrennen

soll... also wieder ne kleine Fork gebastelt, welcher Abstand denn nun größer ist.

Code:

<>FORK Optn:Varbl[0011:Abstand1Total]-V[0012]abov	<- Abstand1 größer als Abstand2?
 <>FORK Optn:Switch [0002:Gegner2Tot] - ON		<- Wenn ja, prüfen ob Ziel2 schon tot ist
  <>Variable Ch:[0017:Movement] Set, 1			<- und Ziel anvisieren, jawoll :)
  <>
  :ELSE Case						<- Ja, ansonsten...
  <>Variable Ch:[0017:Movement] Set, 2			<- natürlich zu Ziel 2 rennen, da es noch "lebt" und näher dran ist
  <>
 :END Case
 <>
:ELSE Case						<- ansonsten ist Abstand1 kleiner als Abstand2
 <>FORK Optn:Switch[0001:Gegner1Tot] - ON		<- und wir überprüfen, ob Ziel1 schon tot ist
  <>Variable Ch:[0017:Movement] Set, 2			<- Wenn dem so ist, Ziel2 anvisieren
  <>
  :ELSE Case						<- Ansonsten (Wie sollte es anders sein :P)
  <>Variable Ch:[0017:Movement] Set, 1			<- Ziel 1 anvisieren, da näher dran und noch lebendig ^^
  <>
 :END Case
 <>
:END Case

Nun gut, wir wissen nun, welches Ziel angegriffen werden soll... und wir wissen wie weit es wegsteht, auch gut :)

- Nur können wir mit dem Abstand allein nicht viel anfangen. Wir müssen diesmal auch die Negativwerte kennen, das erledigen

wir ganz fix mit ein wenig Code.

Code:

<>Variable Ch:[0013:Abstand1XfürBewegung] Set, Var.[0003]val.	<- X Pos von Ziel1 sichern
<>Variable Ch:[0014:Abstand1YfürBewegung] Set, Var.[0004]val.	<- Y Pos von Ziel1 sichern
<>Variable Ch:[0015:Abstand2XfürBewegung] Set, Var.[0005]val.	<- X Pos von Ziel2 sichern
<>Variable Ch:[0016:Abstand2YfürBewegung] Set, Var.[0006]val.	<- Y Pos von Ziel2 sichern
<>Variable Ch:[0013:Abstand1XfürBewegung] - , Var.[0001]val.	<- GegnerX-Pos von Ziel1 X-Pos abziehen
<>Variable Ch:[0015:Abstand2XfürBewegung] - , Var.[0001]val.	<- GegnerX-Pos von Ziel2 X-Pos abziehen
<>Variable Ch:[0014:Abstand1YfürBewegung] - , Var.[0002]val.	<- GegnerY-Pos von Ziel1 Y-Pos abziehen
<>Variable Ch:[0016:Abstand2YfürBewegung] - , Var.[0002]val.	<- GegnerY-Pos von Ziel2 Y-Pos abziehen

So, Abstand berechnet. Fangen wir an, die Richtung zu bestimmen in die der Gegner rennen soll. FORK folgt...

wieder mal. In Variable 0019 [MoveCode] sichern wir einen Wert, dieser bestimmt in welche Richtung der Gegner gehen soll. da

er auch schräg rennen soll, besteht der Wert aus 2 Werten. Einmal für X-Pos (1, 3 oder 7) und einmal für die Y-Pos (15, 31

oder 63). Diese werden addiert und ergeben den entgültigen "MoveCode".

Werte X: Werte Y:

1 = Gegner links vom Ziel 15 = Gegner über Ziel
3 = Gegner auf gleicher X-Pos wie Ziel 31 = Gegner auf gleicher Y-Pos wie Ziel
7 = Gegner rechts vom Ziel 63 = Gegner unter Ziel

Beispiele:

1 und 63 = 64, d.h. Schritt nach links-unten
3 und 15 = 18, d.h. Schritt hoch
7 und 31 = 32, d.h. Schritt rechts

Der Wert 34 wird NIE entstehen, der Gegner müsste "im" Ziel stehen.

Code:

<>FORK Optn:Varbl[0017:Movement]-1
 <>FORK Optn:Varbl[0013:Abstand1XfürBewegung]-0 less than	<- Ziel1 steht links vom Gegner (Wert < 0)
  <>Variable Ch:[0019:MoveCode] Set, 1				<- also Wert 1 zuteilen
  <>
  :ELSE Case
  <>FORK Optn:Varbl[0013:Abstand1XfürBewegung]-0		<- Ziel1 steht auf gleicher X-Pos wie Gegner (Wert = =0)
   <>Variable Ch:[0019:MoveCode] Set, 3				<- Wert 3 zuteilen
   <>
   :ELSE Case							<- Ansonsten muss Ziel1 rechts vom Gegner stehen
   <>Variable Ch:[0019:MoveCode] Set, 7				<- Wert 7 zuteilen
   <>
  :END Case
  <>
 :END Case
 <>FORK Optn:Varbl[0014:Abstand1YfürBewegung]-0 less than	<- Ziel1 steht über Gegner (Wert < 0)
  <>Variable Ch:[0019:MoveCode] + , 15				<- wir addieren also 15
  <>
 :ELSE Case
  <>FORK Optn:Varbl[0014:Abstand1YfürBewegung]-0		<- Ziel1 steht auf gleicher Y-Pos wie Gegner (Wert = 0)
   <>Variable Ch:[0019:MoveCode] + , 31				<- Wert 31 addieren
   <>
  :ELSE Case							<- Ansonsten muss Ziel1 unter dem Gegner stehen
   <>Variable Ch:[0019:MoveCode] + , 63				<- Wert 63 addieren
   <>
 :END Case
 <>
:ELSE Case							<- Movement hat den Wert 2, also für Ziel2 das gleiche wie 

für Ziel1
 <>FORK Optn:Varbl[0015:Abstand2XfürBewegung]-0 less than
  <>Variable Ch:[0019:MoveCode] Set, 1
  <>
  :ELSE Case
  <>FORK Optn:Varbl[0015:Abstand2XfürBewegung]-0
   <>Variable Ch:[0019:MoveCode] Set, 3
   <>
   :ELSE Case
   <>Variable Ch:[0019:MoveCode] Set, 7
   <>
  :END Case
  <>
 :END Case
 <>FORK Optn:Varbl[0016:Abstand2YfürBewegung]-0 less than
  <>Variable Ch:[0019:Move Code] + , 15
  <>
 :ELSE Case
  <>FORK Optn:Varbl[0016:Abstand2YfürBewegung]-0
   <>Variable Ch:[0019:Move Code] + , 31
   <>
   :ELSE Case
   <>Variable Ch:[0019:Move Code] + , 63
   <>
  :END Case
  <>
 :END Case
 <>
:END Case

*Puh*... wat'n Absatz, ne...

So, nun einfach die Werte für die Richtungen einfach per FORK vergleichen...
Folgende Werte sind möglich:

16 = links-oben
32 = links
64 = links-unten
18 = hoch
34 = geht nicht ;) - wie schon gesagt
38 = rechts
22 = rechts-hoch
66 = runter
70 = rechts-unten (brauchen wir nicht abfragen, da letzte Möglichkeit -> kommt in letzten ELSE-Case)

Nun wieder der ellenlange Code...

Code:

<>FORK Optn:Varbl[0019:MoveCode]-16
 <>Move Event...:	Gegner, Left-Up
 <>Move All
 <>
:ELSE Case
 <>FORK Optn:Varbl[0019:MoveCode]-32
  <>Move Event...:	 Gegner, Left
  <>Move All
  <>
  :ELSE Case
  <>FORK Optn:Varbl[0019:MoveCode]-64
   <>Move Event...:	  Gegner, Left-Down
   <>Move All
   <>
   :ELSE Case
   <>FORK Optn:Varbl[0019:MoveCode]-18
    <>Move Event...:	   Gegner, Up
    <>Move All
    <>
    :ELSE Case
    <>FORK Optn:Varbl[0019:MoveCode]-34
     <>Note: Keine Bewegung, Wert nicht möglich
     <>
     :ELSE Case
     <>FORK Optn:Varbl[0019:MoveCode]-66
      <>Move Event...:	     Gegner, Down
      <>Move All
      <>
      :ELSE Case
      <>FORK Optn:Varbl[0019:MoveCode]-38
       <>Move Event...:       Gegner, Right
       <>Move All
       :ELSE Case
       <>Move Event...:	      Gegner, Right-Down	<- Wert ist 70, braucht keine Extrafork
       <>
       :END Case
       <>
      :END Case
      <>
     :END Case
     <>
    :END Case
    <>
   :END Case
   <>
  :END Case
  <>
 :END Case
 <>
:END Case

Dat wär auch erledigt... Code für Angriff folgt sofort... *gäääähhhn*

Code:

<>FORK Optn:Varbl[0017:Movement]-1			<- Ziel1 wird anvisiert
 <>FORK Optn:Switch[0001:Gegner1Tot]-OFF		<- Aber lebt der überhaupt noch?
  <>FORK Optn:Varbl[0011Abstand1Total]-1less		<- Steht der Gegner nah genug dran, um das Ziel zu treffen?
   <>Show Battle Anim.: Irgendwas, Ziel1(W)		<- Wenn ja, Kampfanimation auf Ziel1 zeigen
   <>Variable Ch:[0028:Gegner1LP] - , 3			<- Dem Ziel 3 LP abziehen (Beispiel)
   <>FORK Optn:Varbl[0028:Gegner1LP]-0less		<- Hat Ziel1 weniger oder gleich 0 LP? Also tot... xD
    <>Show Battle Anim.: Irgendwas, Ziel1(W)		<- Wenn ja, Kampfanimation auf Ziel1 zeigen
    <>Change Switch:[0001:GegnerTot]-ON Set		<- Und den Switch Gegner1Tot auf ON setzen
    <>Variable Ch:[0031:GegnerTot?] + ,1		<- Anzahl der getöteten Gegner um 1 (eins) erhöhen
    <>
    :ELSE Case
    <>//Pack hier rein, was passieren soll, wenn der Gegner das Ziel1 attackiert hat, beispielsweise
    <>//ein Move Event + Move All, wo das Ziel vor dem Gegner fließt... ein paar Random Moves z.B., whatever
    <>
   :END Case
   <>
  :END Case
  <>
 :END Case
 <>
:ELSE Case						<- Ziel2 wird attackiert (Movement hat den Wert 2)
 <>FORK Optn:Switch[0002:Gegner2Tot] - OFF		<- Lebt Ziel2 noch?
  <>FORK Optn:Varbl[0012:Abstand2Total]-1less		<- Steht der Gegner nah genug dran, um das Ziel zu treffen?
   <>Show Battle Anim.: Irgendwas, Ziel2(W)		<- Wenn ja, Kampfanimation auf Ziel2 zeigen
   <>Variable Ch:[0029:Gegner2LP] - , 3			<- Und dem Ziel 3 LP abziehen
   <>FORK Optn:Varbl[0029:Gegner2LP]-0 less		<- Hat Ziel2 weniger oder gleich 0 LP?
    <>Show Battle Anim.: Irgendwas, Ziel2(W)		<- Wenn ja, Kampfanimation auf Ziel2 zeigen
    <>Change Switch:[0002:Gegner2Tot]-ON Set		<- Und den Switch Gegner2Tot auf ON setzen
    <>Variable Ch:[0031:GegnerTot?] + ,2		<- Anzahl der getöteten Gegner um 1 (eins) erhöhen
    <>
    :ELSE Case
    <>//Pack hier rein, was passieren soll, wenn der Gegner das Ziel2 attackiert hat
    <>
   :END Case
   <>
  :END Case
  <>
 :END Case
 <>
:END Case
<>

That's it... *uff* - Und ja - mir war langweilig... :O

~RB~

[Balduras]

Hey, grosses Lob, da hast du dir echt Mühe gegeben !

§krass

[Gekiganger]

Das ist eine Möglichkeit, die kürzeste Laufstrecke (durch horizontal/vertikales Gehen) auszurechnen.
Wenn du allerdings die direkte Entfernung errechnen willst (Luftlinie), dann machs so wie ichs in diesem Thread mal beschrieben habe, besonders wenn der Gegner auch schräg gehen soll halte ich dies für besser:
http://forum.rpg-ring.com/forum/show...?threadid=1607
(ist dann auch mit Pythagoras)
Da wird aber nur beschrieben wie du die Entfernugn rauskriegst. Die Überprüfung, wer jetzt näher ist usw. müsstest du weiterhin dem Skript von Redbounty entnehmen. ("c²" entspräche dann "Abstand1Total" bzw. "Abstand2Total")


BTW @ Redi
Negative Werte lassen sich doch einfach durch ne Fork "kleiner als 0" und ein "mal -1" verhindern. @_@

und:

Code:

<>Variable Ch:[0011:Abstand1Total] Set, Var.[0007] val	<- Erstmal den X-Abstand von Ziel1 sichern
<>Variable Ch:[0011:Abstand1Total] Set, Var.[0008] val	<- und den Y-Abstand hinzuaddieren
<>Variable Ch:[0012:Abstand2Total] Set, Var.[0009] val	<- Das Gleiche für Ziel 2
<>Variable Ch:[0012:Abstand2Total] Set, Var.[0010] val

Da sind noch n paar Schusseligkeitsfehler.^^"

[Balduras]

danke euch beiden ! §thx

Ich habe jetzt die nötigen Anregungen bekommen und werde jetzt selber ein Skript schreiben !

das wird leider ne menge arbeit !

[RB [Redbounty]]

@Geki: Man lernt halt nie aus - Ich lass das Ganze trotzdem mal so stehen, da Balduras ja schon die benötigten "Anregungen" bekommen hat, um ein eigenes Skript zu "schreiben". Und *arghs*, die verdammten Schusseligkeitsfehler werd ich wohl nie ganz wegbekommen ^^"

~RB~