Entfernung von events berechnen !

[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~