Tutorial für die Funktionsweise von verschiedenen Codes

ich hab mal ein tutorial erstellt, es geht um...
lest selbst::D

Note:<<<Tutorial Anfang>>>

Vorwort:

Was ist das für ein Tutorial?

Es soll ein tutorial werden, was die funktionsweise von menüs,ks,weltkarten,hp/mpanzeige,... erklärt, kein
script zum abschreiben: die meisten scripts sind so aufgebaut:

"Da wir dieses erreichen wollen, machen wir jetzt diesen Befehl, stellen da noch dieses und
jenes ein, nun muss logischerweise(?) noch dieser Befehl kommen und danach, wie man sich
denken kann(?), noch dieser Befehl. Zum Schluss müsst ihr noch diesen und jenen Befehl machen,
das ganze als paralell(auto start, call) event, mit diesem Switch als Startbedingung. Dann erstellt
noch massig Variablen, die wir später brauchen(?). Hier noch ein Codebeispiel:...


Dann liest man sich das durch, macht die Befehle, hat meistens keine Anhung warum, und wenn dann
am Ende auch noch Fehler drin sind, hat man meistens keine Ahnung mehr. Noch schlimer wird es, wenn
man sich nur das Codebeispiel anschaut...

Vielleicht werden manche jetzt denken, das abschreiben einfacher ist, aber:
1. wisst ihr am ende auch was ihr da fabriziert habt.
2. wenn ihr änderungen vornehmen wollt, ist das viel leichter.
3. bei irgendwelchen fehlern, kennt ihr euern code, und könnt das problem leichter beheben(überhaupt beheben)
4. es mehr spaß macht, auch mal selbst zu überlegen, statt nur abzuschreiben

Was muss ich dafür wissen?

Ihr solltet auf jedenfall mit den Grundlagen des makers vertraut sein und wissen, was variablen/switches sind.
Oder anders gesagt: Wenn ihr dieses Tutorial versteht, wisst ihr genug. Profis müssten das auch so können.
Ein bisschen Mathematik kann auch nicht schaden.

Wann geht es endlich los?

Jetzt!
----------------------------------------------------------------------

Als erstes ein paar Tipps:
Wenn ihr ein Paralleles Event macht(Common,Mappe), was sich ständig wiederholt, so setzt dahinter
ein wait 0,1-0,2.
0,0 sec wait = 1/6 von 0,1 wait, oder 1/60 sekunde. Denkt dran, wenn ihr eine feinerer Wartezeit braucht.

Zur Fehlerbehebung ist das Variablen/Switches Menü, welches sich mit F9 im Testplay aufrufen lässt, sehr
wichtig, ihr könnt dort z.B. prüfen, ob die Variablen überhaupt die richtigen Werte haben.

Oder macht an kritische Stellen im Code eine Message, um z.B. zu schauen, ob der code überhaupt
ausgeführt wird, am Ende, wenn es geht, die Messages wieder löschen.
----------------------------------------------------------------------

Teil I
Weltkarte

I.I: Der Maßstab und scheinbare Position

Zuerst braucht ihr ein Bild euer Weltkarte, verkleinert, höchstens 320x240 Pixel groß.
Dann müsst ihr es natürlich erstmal erscheinen lassen, und es muss immer wieder kommen,
wenn sich der Held bewegt(Tipp: Common Event, Move Picture).
So, dann natürlich noch die Berechnung. Bei der Berrechnung stecken folgende Gedanken dahinter:

Ihr habt eine verkleinerte Weltkarte, und eure richtige als Map. Dann soll ein Cursor auf der verkleinerten Map
dargestellt werden, der den Helden darstellt. Richtig? Wie lässt sich das anstellen? Hmm, der Held und der Cursor
ändern ihre Postition ja nicht richtig, auf dem Picture(verkleinerte Map) ist ja nur ein anderer MAßSTAB.
Maßstab ist das richtige Wort dafür. Jetzt stellt sich nur noch die Frage, wie man das mit dem Maker macht:

Ein Maßstab hat immer ein bestimmtes Verhältniss. Das bestimmt ihr jetzt für euere Map(1 Pixel gleich wieviel
Felder in "Wirklichkeit"). Und zwar für die x-und y-koordinate.(Tipp: x/y=z zum Bestimmen)

Die Tippformel enthält auch gleich die Formel, was man jetzt im Maker macht. Man teilt die Heldenposition
durch z(s.o.)

I.II: Die wirkliche Postion

Nun habt ihr die Position auf der Mappe. Jedoch kann die Karte(Picture) an irgendeiner Position sein(vorzugsweise
Mitte), dass muss mit einbezogen werden. und zwar so:
Wenn man die Weltkartekarte so anzeigt, dass sie linksoben ist, so dass die linke obere Ecke bei der Position 0,0 ist,
so muss nichts berechnet werden, da dann automatisch der Cursor richtig angezeigt wird. Wenn man die Karte jetzt
woanders anzeigen lässt, muss man den Abstand zwischen vorheriger x-und y position ermitteln. Die vorherige
Postion war ja die Hälfte der Größe des Bildes(x/2;y/2).
Nun braucht ihr die Koordinaten euer Bildes, wo ihr es anzeigen lasst, und überlegt, wieviel ihr dazuaddieren müsst
(die oben ermittelten Kordinaten), damit eure Koordinaten rauskommen. Die beiden ermittelten Werte müsst ihr
jetzt zu x,y position des Cursors(oben ermittelt)dazuaddieren.
Fertig! Bedenkt, dass die Karte nicht immer kommen darf.

Noch ein Wort zum Cursor:
Damit ihr nicht noch mehr Berechnungen anstellen müsst, macht die Mitte des Cursorbildes gleichzeitig
zur Anzeige. Ich habe meinen Cursor so gemacht(3x3 Pixel groß):
0|0
|||
0|0

0-transparente Farbe
|-Cursorfarbe(bei mir: rot)

Das wars zur Weltkarte. Der letzte Abschnitt mit dem dazuaddieren war der schwerste, wenn ihr den vertanden habt, könnt ihr stolz auf euch sein^^.

----------------------------------------------------------------------

Teil II
HP/MP Anzeige/Berrechnung


Zuerst braucht ihr Bilder mit den Zahlen von 0-9.(^^^^wenn geht, im Bereich von R^^^^)
Nun solltet ihr bedenken, dass die HP/MP sich ständig ändern können, so dass ihr auch immer die
Prüfung, Anzeige machen müsst. Falls es geht, könnt ihr es auch so machen, das es nur bei HP/MP
Veränderung aufgerufen wird.(Tipp: Common Event)
Nun hier wieder mal die Berrechnung:

II.I: Prozentberrechnung
(kann man machen, muss man nicht):
Eurer Held hat HP, von einer max. möglichen Anzahl. Nun wollt ihr die Prozent ermitteln.
Ihr errinert euch an Mathe und an die Formel: p=(W/G) *100(Prozentsatz=(Prozentwert/Grundwert)*100)
Nun macht ihr das mit dem Maker: (HP/max. HP) *100, und stellt fest, das es nicht funktioniert.
Versucht es ruhig mal, ihr werdet entweder 0% oder 100% rausbekommen. Da liegt daran, das der Maker
nicht mit Kommazahlen rechnen kann(gut, gut, ich habe ein Bruchrechnungsscript und ein Kommazahl
in Bruchumwandlungsscript(+noch mehr Sachen wie Primfaktorzerlegung, ggT, kgV), aber das funktioniert
letztendlich ja auch mit ganzen Zahlen, und ausserdem wäre der Aufwand zu groß, wenn ihr es so macht)

Also, was dann? Schaut euch nochmal die Formel an: p=(W/G)*100, oder eben auch so:
p=(W/G)*(100/1), das sind hier jetzt 2 Brüche, die multipliziert werden. Und wie multipliziert man
Brüche? Richtig! p=(W*100)/(G*1), tja und das ist das selbe wie (W*100)/G(habt ihr in Mathe schön
aufgepasst? Dann versteht ihr das auch.)
Das ist nun die Formel. Hier noch einmal die Zeichenerklärung: p=Ergebniss in %
W= momentane HP; G= maximale HP. So lasst ihr es berechnen.
Jetzt fehlt nur noch die Anzeige, und die kommt jetzt.

II.II: Zahlenanzeige und Mod
Ihr habt jetzt eueren Prozentwert oder eure HP/MP? Und wollt sie jetzt darstellen lassen?
Das geht so:
Zum ersten könntet ihr überprüfen lassen, ob die "Zahl zur Anzeige(ZuA)", ich nenn sie mal so,
0,1,2,3,4,5,6,7,8,9,10,11,12,13,...,100,...,500,...,999,...1200,...9999,... ist, und
dann immer das entsprechende Bild anzeigen lassen(ihr solltet eure Termine für die
nächsten 2-3 Jahre streichen). Wenn ihr dann damit frtig seid, verrat ich euch, wie ihr dass
in 10 Minuten hinkriegt^^.
*wait 3 Jahre*

Hier also die Beschreibung:
Man müsste die einzelnen Stellen extra anzeigen lassen. Doch wie bekomme ih diese Stellen?
Hierzu gibt es die Mod Funktion des Makers(statt +,*,-,/ bei variablenberrechnungen zu finden).
Dabei werden die Zahlen dividiert, und der Rest genommen.

Ich fang mal mit den Hundertern an:

Ihr habt eine Zahl mit Hunderterstelle. Nun wolt ihr alle Stellen davor weghaben. Also
Mod 1000, weil: Die Stellen davor sind 1000er o. 10.000er o. 100.000er, alles, was sic durch 1000 teilen lässt.
Wenn ihr nun Mod 1000 macht, wird die Zahl durch 1000 geteilt, und da alles davor Stellen sind, die sich
(ohne Rest) durch 1000 teilen lassen, bleiben sie weg, der Rest lässt sich nicht teilen(auch nicht 999/1000),
sodass sie übrig bleiben.
Nun habt ihr also die Stellen, und nun zur Darstellung:
Als erstes lasst ihr überprüfen, ob die ZuA >= 900 ist,dann 800, dann 700,...,0(Tipp: Else Case).
Dies sorgt dafür, das überprüft wird, ob die Hunderterstellen 9 sind, wenn nicht, ob sie 8 sind,...
(die Zehner und Einer können weggelassen werden, Richtig?)
Und dann jeweils das richtige Bild anzeigen lassen.

Die Zehner stellen genauso, nur nicht Mod 1000(sondern?sehr schwierig!) und die Forks müssen
dann ebenfalls nicht 900,800,... abfragen.(Tipp: ihr wollt nicht die 100er, sondern die 10er ermitteln,
alles andere(Mod,Forks) werden genauso reduziert wie die 100er zu 10ern,/)

Bei den Koordinaten müsst ein bisschen probieren, sollte nicht zu lange dauern, ihr solltet die Bilder
höchstens 20x20Pixlel groß machen(als Richtlinie)

Fertig!
Und vergesst nicht, das sie des öfteren wieder neu berrechnet werden müssen.
----------------------------------------------------------------------

Ich hör jetzt erstmal auf, wenn es euch gefällt, mach ich es weiter.
[Edit]Da es auf jeden Fall einem gefällt, mach ich weiter[Edit]
Note:<<<Tutorial Ende>>>

Ich finde, das man, wenn man die Funktionsweise versteht, gleich
viel besser scripten und fehler beheben kann.
Naja, wie gefällt es euch?

Ich bin immer offen für neue tutorials obwohl mir diese nicht helfen können da ich die skriptweise der sachen die du behandelt hast schon behersche...ICh find es super ich würde mich über weitere tutorials freuen und hoffe du machst weiter:)

Ey, Danke!

Vor allem das mit der Weltkarte fang ich erst jetzt an zu kapieren!
BIG THX @ Sensemann5!

Nana...sowas darf doch nicht untergehen. Kann das mal einer pinnen? :)

hatte letzte woche nicht sehr viel zeit...aber
ein kistenrätsel script mit koordinatensystem erklärung
hab ich hin bekommen, hier:
---------------------------------------------------------------------
Teil III
Kistenrätsel

Hier geht es also darum, Kisten zu verschieben, um einen Schalter zu aktivieren oder einen Ausgang freizulegen.
Das ganze ist relativ simpel:

III.I: Das Verschieben der Kiste

Es soll ein Event, wenn man es "anspricht", verschoben werden, und zwar um 1 Feld nach hinten.
Das Ansprechen ist ja ganz einfach(Tipp: "push key"condition,"same level as hero").
Doch dann, wie soll es immer nach hinten verschoben werden(Also weg vom Helden?)
Man müsste die Heldblickrichtung überprüfen lassen...und das geht mit Fork Conditions(Seite 2).
Ihr lasst also als erstes, nachdem das Event "angesprochen" wurde, die Heldblickrichtung
über und dann mit "move event" das event entsprechend bewegen. Das wär´s dann auch schon.
Und falls die Kisten irgendeinen Eingang blockieren sollen, und man sie dann davon wegschieben
soll, seid ihr jetzt schon fertig, da die Kisten dann ja nach dem Schieben bereits weg sind und den
Ein/Ausgang nicht mehr blockieren.

III.II: Überprüfen der Kistenposition mit Hilfe von Variablen

Man möchte die Position der Kiste überprüfen. Das geht mit Hilfe der X/Y Position
des Events. Doch zuvor, was ist X/Y-Position überhaupt?

III.I 1/2
Zwischenthema: Erklärung des Koordinatessystems
vor allem wichtig für Neulinge

Der Maker verfügt über ein Koordinatensystem, eigentlich 2, eines für Events und einens
für Bilder. Bei dem Koordinatensystem ist 0 links oben. Das sieht dann etwa so aus:

1 2 3 4 5 6 7 8 9
0---------------------------->x
| |
| 1 |
| 2--------|=> 4;2(x,y)
| 3
| 4
| 5
| 6
| 7
| 8
| 9
\/
y

Wie man sehen kann, bezeichnet die X-Achse die horizontale Lage, die Y-Achse die vertikale Lage.
X geht von links nach rechts, y von oben nach unten. Bei Events ist 0,0(erste Zahl bezeichtnet
dabei X, zweite Y) immer links oben von der MAPPE(Map,Karte). Bei Pictures ist 0,0 immer
links oben vom BILDSCHIRM. Und noch etwas: Bei Maps bezeichntet z.B. 4,8 64 Pixel nach
rechts von links aus und 128 Pixel nach unten von oben aus. Bei Pictures bezeichnet 4,8
4 Pixel oben, und 8 Pixel nach unten. Also: 1X(Map) = 16X Picture; 1X(Picture) = 1/16 X(Map)
(wobei das eher 0 wären, da er keine Kommazahlen kann).
Und: 1Y(Map) = 16Y(Picture); 1Y(Picture) = 1/16Y(Map)(oder wieder eben 0).

Dann gäbe es noch zu erwähnen, dass bei einem Bild der Pixel in der Mitte genommen
wird, und dann die Position von diesem Pixel die Position des Bildes ist.
Weiterhin ist bei einem Bild 160,120 genau in der Mitee des Bildschrims, 320,240
ganz rechts unten(und damit wären wir bei einer Auflösung von 320x240 Pixeln).

Damit wären hoffentlich alle Klarheiten beseitigt.
Übrigens gibt es in "3D" Spielen zusätzlich noch eine Z-Koordinaten, welche
die Höhe angibt.

-->hier gehts weiter

Wollen wir uns doch wieder mal dem überprüfen der X/Y Position der Kiste zuwenden.
Ihr lasst also zwei Variablen auf die X/Y Position(set "X/Y Coordinate) der Kiste anpassen
(Tipp: Parallel Process,wait) und überprüft diese danach mit 2 Forks, ob sie die selben
X/Y Positionen wie die Stelle haben, wo die Kiste hinsoll. Und in die Forks dann,
was passieren soll, wenn sie den Schalter berührt.
Fertig! War doch gar nicht so schwer, oder?
----------------------------------------------------------------------
@Manni_the_Dark:
hab mal nachgeschaut, so ein ähnliches ist drin, aber nach der
art: *macht nun den befehl, klickt dann nun darauf, dann darauf...*
bei meinem kommt so was nicht vor.

und ausserdem: die meisten schauen eh nicht ins e-book und
stellen dann solche fragen hier im forum:D

als nächstes wir dann wahrscheinlich ein einfaches
2D(von der Seite aus gesehen) Shooter KS kommen
dabei werden dann auch themen wie kollisionsprüfung
2er Bilder und mehr behandelt.
da ich selbst mal ein einfaches shooter-ks erstellt
habe, wirds dazu auch noch ein beispiel geben.
ich versuchs mal bis nächste woche zu schaffen:)

@Sensenmann5
Ist so ein Tuturial nicht auch im E-Book drin ?

so, ich bin jetzt fertig mit dem shooter-ks-tut.
hier ist es:
---------------------------------------------------------------------
Teil IV
Shooter-KS

Ihr solltet hierfür auf jeden Fall schon Erfahrung mit dem Maker haben, da dies ein wenig
umfangreicher ist.
Erstmal was zur Vorbereitung: Für den Hintergrund würde ich Panoramas nutzen, da sie immer unter
BIldern sind und sich leichter scrollen lassen. Dann solltet ihr ein Bild, möglichst als ID 1, nehmen und
als "Untergrund" für KP,... Anzeige benutzen. Wie ihr Zahlen als Bilder macht, steht oben in Teil I.
Ansonsten solltet ihr drauf achten, dass ihr den Held und den/die Gegner als möglichst kleine
ID macht(die Attacken sollen schließlich über den Kontrahenten sein).
Und nun, Start!


IV.I.I: Anfang und Heldenbewegung mit Variablen

Am Anfang gibt es zu beachten, dass ihr erstmal alle Bilder anzeigt, die Helden/Gegner Variablen
Initialisiert,... . Danach solltet ihr dieses Event ausschalten, aber vorher noch Switches o.ä.
aktivieren, die für Heldbewegung, Gegner, Schiessen,... zuständig sind.

Ich habe selbst mal zu Testzwecken ein Shooter-KS gebastelt, hier der Downloadlink:
http://mitglied.lycos.de/werdops/Shooter-KS.zip
(ich bin momentan noch am hochladen, wundert euch nicht, wenn der
link nicht geht)
Als erstes kommen wir zu der Bewegung des Helden:
Zunächst einmal solltet ihr die X/Y Werte des Helden in zwei Variablen, z.B. "Held X"
und "Held Y". Jenes solltet ihr gleich zu Beginn machen, und IMMER, wenn sich Held
(oder auch Gegner) bewegen, deren Variablen ändern und das Bild zu deren Koordinaten
"moven" lassen(dafür gibt es bei dem "Show Picturebefehl" den Menüpunkt "by Variable",
wählt dort die X, bzw. die Y Variablen aus).
Schön, nun haben wir also den Held an einer Stelle in Variablen. Und jetzt soll er sich
auch noch bewegen(soll doch beleiben, wo er ist^^). Na gut, so geht´s:

Der Held soll sich ja auf Knopfdruck bewegen. Also als erstes eine Tastenabfrage,
und man jederzeit drücken kann, und vor allem, weil man den Knopf auch gedrückt
halten kann, wählen wir die Option "wait until key hit"(Warte is Knopf GEDRÜCKT)
nicht aus. Sie bewirkt ja, dass man, wenn man den Knopf drückt, der Knopf in eine Variable
gespeichert wird, und es erst nach Knopfdruck weitergeht. Wenn man nun diesen Knopf gedrückt
hält, zählt dies nicht als Tastendruck und man muss die Taste loslassen und wieder drücken, bevor
es weitergeht. Genau das Gegenteil von dem, was wir wollen.
So, nun wird überprüft, welcher Knopf gedrückt wurde, und dann die entsprechende Variable
geändert. Z.B.: Wenn man "rechts" drückt, soll sich der Held nach rechts bewegen, und da
man sich auch in kleinen Abständen bewegen soll, lasst ihr "Held X" + 3 ausführen(oder +1,+2
+4,+5).Noch höher ist normalerweise zu schnell. X + 3 bedeutet ja 3 Pixel nach rechts,
wie ihr oben bei meiner Koordinatensystemerklärung seht.
Da dies nun eine sehr kleine Bewegung(ca. 1/106 des Bildschirms bei X+3), sollte auch eine
kurze Bewegungszeit gewählt werden(Ich bevorzuge 0,0 sec(=1/60 sekunde)).

Probiert das ruhig mal so. Ihr werdet allerdings feststellen, dass es noch nicht ganz funktioniert.
Der Held wird an den Rändern nicht anhalten. Doch was tun? Die Koordinaten helfen hier mal
wieder. Ihr macht also vor den Move Picture Befehl noch ein paar Überprüfungen, ob die X-und
Y-Koordinate zu kleine oder zu groß sind(zu klein sind sie oben(links), zu groß unten(rechts),
da der Koordinatenursprung ja links-oben ist). Und wie kommt ihr auf die Werte. Man kann sie
berrechnen, allerdings ist probieren meist doch am besten. Falls der Held aber nur ganz an
den Rändern anhalten soll, berrechnet ihr es wie folgt:
Er soll ganz links anhalten. Der Mittelpunkt des Bildes ist der Punkt, für den die Koordinaten
gelten. Das sieht dann in etwa so aus:
0 1 2 3 4 5 6
-------------------->
|__.__
|
|
|
|
\/

oder:
0 1 2 3 4 5 6 7 8
--------------------------->
|______.______
|
|
|
|
\/

Die Y-Einteilung habe ich weggelassen. _._ ist das Bild, der Punkt der Mittelpunkt, und die Unterstriche
stellen die Breite des Bildes da.
Da der Mittelpnkt nun in der Mitte ist, und somit die Entfernung von der Mitte bis zum Rand(es soll
ja am Rand anhalten) logischerweise die Hälfte der Breite des Bildes ist, darf der Held nicht unter folgenden
Wert kommen:

K...Koordinatenwert des Punktes den er nicht unterschreiten darf
B...Breite/Höhe des Bildes in Pixeln
W...Ergebniss(Wert)

W=K+(B/2)

dasselbe gilt auch für einen Y-Wert, den er nicht unterschreiten darf.

Beim Überschreiten:

K...Koordinatenwert des Punktes den er nicht überschreiten darf
B...Breite/Höhe des Bildes in Pixeln
W...Ergebniss(Wert)

W=K-(B/2)

Wie ihr seht, ist das fast dasselbe. Wenn wir das genauso wie oben in einer Skizze darstellen,
muss der Punkt (Ergebniss) ja nun links von dem Wert, den er nicht überschreiten darf, liegen.
Da er in unserem Falle ja an den Rändern anstoßen soll, ist K bei uns 0(oben) und 320(Breite) bzw.
240(Höhe)(unten). Ich habe die Formel allerdings allgemein gehalten, so dass, wenn ihr den
Anhaltepunkt kennt, auch den Wert berrechnen könnt. Noch allgemeiner wäre es so:

(+-)...plusminus
B...Breite/Höhe/Tiefe des Bildes in Pixeln

W=K(+-)(B/2)

Diese Formel ist dann wirklich allgemein gültig. In eure Überprüfungen lasst ihr dann den
entsprechenden Wert, der abweicht, auf das Minimum, bzw. Maximum anpassen(er unterschreitet
10, also muss er auf 10, dem Minimum angepasst werden).
Danach euren Move Picturebefehl.

Jetzt noch einen kleinen Bonus:

IV.I.II: Heldenanimation
Simpel, kann aber eine große Wirkung erzielen. Ihr braucht erstmal
ein paar Einzelbilder der Heldenanimation. Da bei einer Animation Einzelbilder
hintereinander angezeigt werden, lasst ihr also(Parallel Process) die Bilder nacheinander
anzeigen. Und damit es nicht zu schnell wird, macht ihr dazwischen noch einen Wait-Befehl
(mind. 0,1 sec). Nun werden schnell die Einzelbilder angezeigt, eine Animation ist entstanden.


IV.II: Das Schiessen

Nun kommen wir zu einem wichtigen Teil, dem Schiessen. Ihr braucht ein Bild einer
Kugel(ca.8x8 Pixel).

IV.II.I: Registrieren der Spielereingabe

Da auf Knopfdruck geschossen werden soll, lasst ihr als erstes überprüfen, wann der
"Schiessen"-Knopf gedrückt wird. Sobald er dann gedrückt wird, lasst ihr das Schiessen
Event starten. Ausserdem solltet ihr, damit man nicht ganz schnell hintereinander schiessen
kann. Da ja auch mehrere Kugeln hintereinander abgeschossen werden können solllen,
müsst ihr auch eine Prüfung machen, welche Kugeln bereits da sind. Die Anzahl der max.
möglichen Kugeln könnt ihr selbst festlegen, bedenkt jedoch, dass jede Kugel ein Bild braucht und
ihr ausserdem für jede Kugel die Schadensüberprüfung machen müsst. Nun ja, wie schon gesagt, müsst
ihr überprüfen, welche Kugeln aktiv sind. Was eignet sich da besser als Switches? Ihr müsst sie natürlich
ON schalten, wenn die Kugel da ist. Die Überprüfung muss wie folgt aussehen: Falls Kugel 1 nicht
da, schiesse Kugel 1 ab, ansonsten, wenn Kugel 2 nicht da ist, schiesse Kuge 2 ab, ansonsten, wenn Kugel
3 nicht da ist, schiesse Kugel 3 ab, ansonsten...
(Tipp: Wenn heißt "If", Ansonsten "Else")
Falls die Kugel nun abgeschossen wird, muss gespeichert werden, dass sie momentan "unterwegs"
ist(Switches). Und falls jede Kugel schon abgeschossen ist, kann eben keine mehr kommen
(Ihr solltet die Zeit zwischen dem minimalen Zeitabstand des Abschiessen der Kugel und der
max. Anzahl an Kugeln so kalkulieren, dass man immer eine Kugel abschiessen kann.)

Nun, da die Kugeln ja auch alle auf einmal kommen können, macht ihr für jede Kugel
ein Extra-Event. Der Code in den Events sieht folgendermaßen aus:

IV.II.II: Die Kugel fliegt

Z.B. für die Schadensüberprüfung speichert ihr die Position der Kugel/n in Variablen(pro Kugel
2 Variablen; X/Y).
Als erstes muss die Kugel natürlich erscheinen, und wo? Normalerweise bei dem Helden. Also
übernehmt ihr die Position des Helden für die Position der Kugel. Ihr würde euch ausserdem
empfehlen, beim Anzeigen in 0,1sec die Kugel von 100% auf 0 %Transparenz zu bewegen lassen.
Nun wird die Kugel sich logischerweise nach rechts bewegen. Welche Koordinate müsst ihr also
verändern? Und + oder -? Sehr schwer! Gut, ihr lasst nun also die Kugelkoordinate 5(probiert mal)
erhöhen(vermindern, falls sie nach links fliegen soll). Jetzt lasst ihr logischerweise die Kugel
bewegen, am besten wieder in 0,0s. Falls ihr das so lasst, fleigt die Kugel ewig. Also lasst ihr überprüfen
ob die Kugel bereits weit genug geflogen ist(gewöhnlich >320). Da sich das ja immer wieder-
holt, ist die Empfehlung eine Schleife(Cycle,Loop). Falls die Kugel nun weit genug ist, wird
aus der Schleife "ausgestiegen". Am Ende lasst ihr dann die Kugel verschwinden, und, damit
wieder eine neue Kugel kommen kann, OFF.

Dasselbe macht ihr dann für alle anderen Kugeln, nur dass ihr dann andere ID´s und Variablen
nehmt, da es ja eine andere Kugel ist.

IV.II:III: Raketen können zielen

Falls ihr noch Raketen oder ähnliches reinnehmen wollt, mach ihr das genauso, nur dann
wieder andere Bilder usw.
Wenn die Rakete automatisch treffen soll, macht ihr zu X+5 dann folgendes:
Eigentlich ganz einfach. Ihr lasst überprüfen, ob die Y-Koordinate(die Höhe)
der Rakete >,< oder = ist, und lasst dann entsprechend die Y-Koordinate verändern.

Somit wäre dann auch das Schiessen fertig. Und nun geht es weiter mit:


IV.III: Der Schaden

Das wohl wichtigste, das Überprüfen des Schadens. Wenn man es einmal verstanden hat, ist
es ganz leicht. Ihr solltet die Schadensüberprüfung Parallel ablaufen lassen, Schadensüberprüfungen,
ob Gegner treffen extra, und, entweder für jeden Gegner ein extra Event, ob er getroffen worde, oder
als ein Event, und dann mit Switches/Variablen überprüfen, welcher Gegner aktiv ist, und dann entsprechend
Gegner Koordianten usw. einstellen. Das leigt bei euch. Und dfür jeden Schuss müsst ihr eine Extra-Prüfung
machen, allerdings könnt ihr dies untereinander im selben Event machen.

IV.III.I: Die Überprüfung des Schadens

Ich schmeiß erst mal ein paar Bedingungen in den Raum(?):

Variablen:
B1...Breite des Bildes 1 in Pixel
H1...Höhe des Bildes 1 in Pixel
X1...X-Koordinate des Bildes 1
Y1...Y-Koordinate des Bildes 1
B2...Breite des Bildes 2 in Pixel
H2...Höhe des Bildes 2 in Pixel
X2...X-Koordinate des Bildes 2
Y2...Y-Koordinate des Bildes 2

Bedingungen:
X1-B1/2<=X2+B2/2
X1+B1/2>=X2-B2/2
Y1-H1/2<=Y2+H2/2
Y1+H2/2>=Y2-H2/2

Falls all diese Bedingungen erfüllt sind, berühren sich die beiden Bilder.
Dies lässt sich einfach mit Forks überprüfen, doch sehen wir uns mal an, was hinter
diesen Bedingungen steckt. Es steht da: X + B/2, das bedeutet, die Breite des
Bildes wird duch 2 geteilt und dann zum X-Wert addiert. Und da der X-Wert genau die Mitte
des Bildes ist, kommen wir auf den rechten Rand des Bildes(__.__, der Punkt ist die Mitte, also
die Breite durch 2, und Breite durch 2 + Breite durch 2 ergibt Breite(B/2+B/2=(B+B)/2=2B/2,
2 mal B durch 2= B, und dann gibt X noch den Punkt an, wo sich das Bild auf dem Bildschirm
befindet, so dass dieser Wert berücksichtigt wird dasselbe für Höhe)). Es werden also die Ränder
der Bilder ermittelt, und die dann überprüft, da sie ja das Bild beschränken
(X1-B1/2=B/2 - B/2= (B-B)/2 = 0, jetzt wird noch die Position auf dem Bildschirm addiert, fertig).

IV.III.II: Warum das so ist

Jetzt zu den Überprüfungen:
______________
| | /=>Schnittstelle
| Bild 1 | /
| ___ |/__________
| | | |
|_____________| |
/| Bild 2 |
/ | |
/ |_______________|
/
/=>Schnittstelle

Ich hab das hier mal skizziert. Man kann erkenennen, dass oben die linke mit der rechten Seite
und die rechte mit der linken Seite verglichen werden. Und wenn jetzt die linke Seite rechts(also
größer ist) von der rechten Seite und die rechte Seite links(also kleiner) von der Linken ist,
kann da irgendwas nicht stimmen, und zwar, dass die Bilder nicht kollidieren. Schaut euch
einfach mal die Skizze an, und ihr werdet es verstehen.
(Man kann auch so überprüfen, dass man den X-Wert des einen Bildes nimmt und vergleicht, ob
er links von der rechten und rechts von der linken Seite ist, und beim Y-Wert ob er unterhalb
der oberen Seite und oberhalb der unteren Seite ist, wobei man noch die Breite/Höhe
des 1. Bildes berücksichtigen muss, indem man einfach bei den Überprüfungen, die man
ausfführt, indem man wieder die Seiten des einen Bildes ermittelt, dann noch die Hälfte
der Breite/Höhe des 1. Bildes zu den Seiten der Überprüfung hinzuaddiert. So ist das
vielleicht verständlicher.)

Nachdem ihr überprüft habt, ob getroffen worde, und wenn getroffen wurde, solltet
ihr eine kurze Animation machen, die HP senken, überprüfen, ob der Gegner tot ist,
und eventuell die Prüfung abschalten(bei einem Schuss z.B. hab ich es so gemacht, dass
er nur einmal treffen kann), oder zumindestens eine Wait Zeit, da die Kugel o.ä.
sonst ganz schnell hintereinander trifft. Doch wie gesagt, dass ist euch überlassen.

Nun seid ihr also auch mit der Überprüfung fertig. Was fehlt also noch?

IV.IV: Die Gegner

Das so schwierigste überhaupt. Als erstes braucht ihr Ideen, wie sie sich verhalten
sollen. Da das sehr Variabel ist, kann ich hier nur Tipps und Ratschläge geben:

Ihr solltet daran denken, dass ihr auch eine Prüfung macht, ob sie euch treffen. Vor allem
bei Endgegnern solltet ihr sie z.B. bei Attacken unverwndbar machen. Ihr schaltet
dazu einfach die Schadensüberprüfung aus. Wenn der Gegner auf euch zukommen soll,
mach ihr das genauso wie bei der Rakete(erhalte Koordinaten, wenn Gegner X < HeroX,
Gegner X+[2-8], bei größer minus, wenn Gegner Y <HeroY, GegnerY+[2-8], bei größer
minus; die Werte in den Klammern sind nur Richtwerte), nur dass ihr statt der Rakete
dann den Gegner nehmt. Der Angriff geht genauso wie das Schiessen(und manchmal
einfacher). Und ihr könnt auch jederzeit die Heldkoodinaren abfragen, um den Gegner/
die Attacke dorthin zu geleiten o.ä.
Alles in allem sollten die Gegner nicht zu schwer sein, wenn ihr euch vorher genau
überlegt, was sie machen sollten.
Übrigens solltet ihr die Gegner in einem extra Event erstellen, was möglichst Parallel ablaufen
sollte.

Falls ihr trotzdem bei einem Gegner nicht weiter wisst, so schreibt einfach mal hier rein.

IV.V: Schlusswort

Am Anfang solltet ihr nur ein Event aktiv haben, was als Einführung dient, Bilder initialisiert,...
Danach wird dieses Event ausgeschaltet und die Events für Bewegen, Schiessen und das für das
Erscheinen der Gegner wird aktiviert. Der Rest wird dann akitviert, wenn ihr sie braucht.
Das sind die Hauptevents. Der Rest ist vor allem zur Überprüfung.
Das ist alles, was ihr wissen müsst, um ein Shooter-KS zu erstellen.
Und schaut euch auch mal mein Script an, es enthält viel Nützliches, wie
es dann in etwa aussehen müsste.

Ich wünsche euch gutes Gelingen!

Hier noch ein Tutorial, was ich mal irgendwann geschrieben habe, schaut es euch nur
im Notfall an!

Zitat:

---

Es könnte etwas komisch werden, was daran liegt, dass ich die Texte einfach aus dem Spiel
kopiert habe.

Inhalt:
Kapitel 1: Der Anfang
Kapitel 2: Herzstück - Teil 1: Das Bewegen
Kapitel 3: Herzstück - Teil 2: Das Schießen
Kapitel 4- Die HP-Anzeige
Kapitel 5- Die Zufallsauswahl der Attacken
Kapitel 6- Die normalen Gegner
Kapitel 7- Die Attacken der Gegner
Kapitel 8- Die Schadensüberprüfung Teil 1: Der Code
Kapitel 9- Die Schadensüberprüfung Teil 2: Die Berrechnung
Kapitel 10: Die automatischzielenden Raketen
Kapitel 11- Der Schluss

Kapitel 1: Der Anfang

1. Also, an den Anfang kommt, je nach
nach eurer Story, wie der Held
erscheint, Veränderung der
Landschaft....

2. Viel könnt ihr dabei nicht
falschmachen. Auf jeden Fall muss das
Erscheinen des Helden da sein.

3. Ich habe dort noch ein paar Cheats
eingebaut. Man gibt einem Helden
einen Namen, wo dann überprüft wird,
ob es diesen "Cheat" gibt!

4. Vorher muss man noch
X,Z,oben,links,unten,rechts
eingeben(mit Enter Password).

5. Probiert mal den Cheat "Death"!
(ggg)

6. Nicht vergessen: Am Ende des Events
einen Switch (z.B. Anfang) auf ON
stellen!

Kapitel 2: Herzstück - Teil 1: Das Bewegen


Ich will an dieser Stelle noch nicht
zuviel verraten. Wir werden es ge-
meinsam erarbeiten. So wirst du es
auch schneller begreifen!
1. Den Helden als Bild darzustellen
2. Auf Knopfdruck soll er sich bewegen
3. Er soll an den Rändern anhalten
Wir nehmen uns jetzt jeden Schritt
einzeln vor!
Was war 1.?
Achso, den Helden als Bild
darzustellen.
Dazu legen wir in dem Event
mit dem Anfang eine 2. Seite an,
wo der Switch "Anfang" ON sein muss.
Man kann hier den Helden erscheinen
lassen. Es empfielt sich aber, ihn
gleich am Anfang mit darzustellen.
Show Picture ID 1: Held
Move Picture ID 1:
Da wir nicht dumm sind, sollten
wir für spätere Schadensüber-
prüfungen(und das Bewegen) die
Heldenposition in Variablen speichern.
Also:
Change Variable: 0001(Hero X) Set 160
Change Variable: 0002(Hero Y) Set 120
Den Variablenwert je nach Position
des Helden verändern.
So, damit sehen wir den Helden
schon.
Ich habe bei mir noch ein Extra-Event
gemacht, damit der Held bei
mir mit den Füssen strampelt.
Wollt ihr dies auch machen, ein
neues Event anlegen wo der
Switch "Anfang" ON sein muss.
Nun die Heldenbilder besorgen
und:
Show Pitcure ID 1 (Held 1) Var 1 u. 2
Wait (in etwa) 0,1 sec
Ich habe hier statt den Variablen
feste Zahlen genommen, ihr müsst
es dann aber mit den Variablen
Hero X und Y machen!
Damit wäre dies fertig!
Kommen wir zu zweitens.
Das Bild soll sich auf Knopfdruck
bewegen.
Dies sollte in die zweite Seite
des Events "Anfang".
Wir sehen sofort das hier
Enter Password hin muss.
Das wird also unser erster
Befehl sein:
Enter Password(Wait Until Key hit)
direction.
Dann noch 4 Forks zum überprüfen
des Variablenwertes und in die
Forks, damit sich der Held bewegt,
Change Variable Hero X(oder Y)
+/- 5.
Am Schluss noch Move Picture: ID 1
(Variable Hero X und Y) und 0, 0 sec.
Hmm, das funktioniert noch nicht so
richtig...
Idee!:
Wir probieren es mal, bei Enter
Password den "Wait Until Key Hit"
rauszumachen.
Kommen wir zu Schritt 3!
Der Held soll an den Seiten
anhalten. Dazu brauchen wir erstmal
die Variablen an den der Held anhalten
soll. Da dies unterschiedlich sein
kann, gehe einfach so vor.
Mache das Bewegen erstmal ohne
Anhalten und teste es.
Nun bewege dich zu den Stellen,
wo der Held anhalten soll.
Und zwar: Einmal das Anhalten
am unteren Rand.
Bist du dort, drücke F9 um den
Variablen/Switch Modus aufzurufen.
Schaue dir nun Wert der Variable
Hero Y an. Merke ihn dir.
Nun gehen wir wieder in das
Event "Anfang" auf die 2. Seite.
Gehe vor den Befehl "Move Picture"
und füge folgende Befehle ein:
Fork Condition: If Variable Hero Y
above (den gemerkten Wert).
Ohne Else Case.
In diese Fork kommt nun:
Change Variable (Hero Y) Set
(den gemerkten Wert)
Nun gehe wieder ins Testspiel
und der Position, wo der
Held am oberen Rand anhalten soll.
Drücke wiederum F9 und merke dir
den Wert der Variable Hero Y.
Im Event Anfang unter(nicht in)
die letzte Fork:
Fork Conditions:
If Variable Hero Y below(!!)
(der von euch gemerkte Wert).
In diese Fork:
Change Variable (Hero Y) Set
(der von euch gemerkte Wert).
Nun geht ihr wieder(wie sollte es
auch anders sein) ins Testspiel und
die Anhalteposition des
Helden am rechten Rand.
Drückt wieder F9 und merkt euch
den Wert der Variable Hero X.
Im "Anfang" Event unter die letzte
Fork noch eine Fork:
If Variable (Hero X) above
(der von euch gemerkte Wert).
Und nun nocheinmal:
Geht ins Testspiel und bewegt
den Helden an die linke Anhalte-
position. Drückt F9 und merkt euch
den Wert der Variable "Hero X".
Wiederum im Event "Anfang" unter
die letze Fork eine letzte Fork:
If Variable (Hero X) below
(der von euch gemerkte Wert)
Das klingt jetzt alles ein bisschen
kompliziert, aber so schwer ist es
gar nicht(4 Forks, 4 Change Variable).
Es ist nur viel Text.
Probiert es einfach mal.
So, das wäre eigentlich schon alles.
Und versucht nicht, das im Maker
bei meiner Erkärung zu verstehen.
Hier habe ich noch andere Befehle
hinzugefügt.
Wenn ihr es schon im Maker betrachten
wollt, in der Mappe "Sensenmann KS".
Der Kampf mit dem Sensenmann stammt
aus meinem Spiel Namens 16 Keys,
wo ich eine Demo bald veröffentlichen
werde.
Und wenn ih euch über die vielen
Variablen, Switches, Bilder, Music
u.s.w. wundert, ich habe mein Spiel
kopiert und dann die meisten Mappen
gelöscht, weil ich nicht alles noch
mal neu importieren wollte.
Nun aber weiter im Script!



Kapitel 3: Herzstück - Teil 2: Das Schießen

So, nun kommt das Schiessen dran.
Als erstes lassen wir unseren Helden
erscheinen!
1.Wir wollen einen Schuss(als Bild)
an dem (Bild) Helden anzeigen lassen.
2. Dieses Bild soll sich dann nach
rechts bewegen.
3.Es sollen mehere Schüsse kommen
(statt nur einem) und man kann auch
nicht erst den schiessen, wenn der
jetzige weg ist.(wie z.B. in Delta Star).
( trotzdem auf jeden Fall ein Download wert)).
Also, erstens den Schuss als Bild
am Helden darstellen.
Da wir nicht wissen, wo der Held
sich gerade befindet, müssen wir
2 neue Variablen einrichten.
Wir nehmen die Variablen
0003: Schuss X,
und 0004: Schuss Y.
Nun gilt es noch die Position
der Variablen zu ermitteln.
Da wir den Schuss am Helden
darstellen wollen, sollten
wir die Werte von den Helden-
koordinaten übernehmen.
Also:
Change Variable: Schuss X (Set)
Variable Hero X und
Schuss Y (Set) Variable Hero Y.
Doch jetzt stop.
Wir richten ein neues Event
mit dem Namen schiessen ein.
(Parallel Process, Below Hero,
Switch "Anfang" muss ON sein).
In dieses Event kommt nun:
Enter Password(Store into Variable
0005: Schiessen, kein "wait until
key hit, nur bei "Decision(5)" ein
Häckchen machen).
Nun Fork Conditions:
If Variable Schiessen 5.
In diese Fork nun noch eine Fork:
If Switch 0002 Auszeit ON.
(Switch später noch erklärt)
In diese Fork kommt wait 0,2 sec,
danach Change Switch "Auszeit" Off.
Unter den folgenden End Case
noch Change Switch 0003 Schiessen ON.
(Auch dieser Switch später erklärt)
Nun legen wir ein neues Common Event
an, welches wir Schiessen nennen.
Wir stellen es auf Parallel Process
ein und es muss der Switch "Schiessen"
ON sein.
Fork Condition:
If Switch Schuss 1 Off.
In diese Fork:
Play Sound Effect: Einen Sound-
effect fürs Schiessen(ich habe plop
genommen).
Change Switch 0006 Schuss 1 On
Change Switch Auzeit On und
goto Label 1.
(Den Label ganz am Ende hinsetzen)
Unter diese Fork(und den Label schön
am Ende lassen) kommt:
Fork Condition:
If Switch Schuss 2 Off.
In diese Fork:
Play Sound Effect: Einen Sound-
effect fürs Schiessen(ich habe plop
genommen).
Change Switch 0007 Schuss 2 On
Change Switch Auzeit On und
goto Label 1.
Unter diese Forks(Label am Ende
lassen) noch drei weitere Forks
wie eben, nur die Switches in
Schuss 3, 4 oder 5 verändern.
Nun richten wir 5 neue Common-Events
ein, die wir Schuss 1 bis Schuss 5
nennen. Wir stellen es auf Parallel
Process und es muss jeweils der
Switch "Schuss 1" bis "Schuss 5" On
sein.
In das Event "Schuss 1" kommt nun:
Change Variable: Schuss 1 X (Set)
Variable Hero X und
Schuss 1 Y (Set) Variable Hero Y.
Und damit wären wir dort angelangt,
wo wir vorhins aufgehört haben.
Nun kommt:
Show Picture ID 2 Schuss (Variable
Schuss 1 X und Schuss 1 Y)
Tranzparenz 0%, Magnify 100%.
Nun kommt ein Cycle(oder Loop)
Befehl.
Gleich zu Beginn kommt in diesen
Loop eine Fork Condition:
If Switch Schuss 1 Off.
Sie dient dazu, den Schuss
zu verschwinden zu lassen, wenn
er nicht mehr da ist.
In diese Fork noch ein
"Goto Label 1" mit rein.
Nach der Fork, damit sich der
Schuss auch bewegt, Change Variable:
Schuss 1 X (+) 5.
Ich habe danach noch
Change Variable Schuss 1 Y (+) 5,
damit der Schuss sich etwas nach oben
und unten bewegt. Dies könnt ihr machen,
ihr müsst aber nicht.
Nun folgt, damit sich der Schuss
nun auch wirklich bewegt, Move
Picture: ID 2 (Variable Schuss 1 X
und Schuss 1 Y) bei 0,0 sec.
(Tranzparenz=0 %, Magnify=100 %)
Solltet ihr es so gemacht haben, dass
er Schuss etwas nach oben und unten
abweicht, so müsst ihr nun folgende
3 Befehle noch mit reinbringen:
Change Variable Schuss 1 X (+) 5,
Schuss 1 Y (-) 5 und
Move Picture ID 2 (Variable Schuss 1 X
und Schuss 1 Y). 0,0 sec und
Tranzparenz=0 %, Magnify=100 %.
Nun kommt wieder eine Fork Condition:
If Variable Schuss 1 X (above) 325.
(Bei dem Wert, sollte der Schuss zu
früh oder zu spät verschwinden, müsst
ihr ein bisschen herum-
experimentieren.
In diese Fork kommt nun:
Change Variable: Schuss 1 X (Set) 0
und Change Variable Schuss 1 Y (Set) 0,
sowie Change Switch Schuss 1 Off.
Am Ende noch "Break Cycle".
Unter den Loop kommt erstmal
ein Label 1.
Nun nocheinmal Change Variable
Schuss 1 X (Set) 0 und
Schuss 1 Y(Set) 0, sowie
Change Switch Schuss 1 Off.
Nun kann euer Held schon 1 Schuss
schiessen!
Ein Schuss geht nun, wir wollen
aber meherer Schüsse!
(Insgesamt 5)
Dafür sind die Common Events
Schuss 2 bis Schuss 5 zuständig.
Wir müssen sie noch ausfüllen.
In diese Events kommt im Prinzip
dasselbe hin, nur mit dem Unterschied,
dass es nicht mehr die Variablen Schuss
1 X und Y sind, sondern bei
Common Event Schuss 2 "Schuss 2 X"
und "Y", bei Schuss 3 "Schuss 3 X"
und "Y",...
Wie dies aussieht, habe ich schon
im vorigen Kapitel demonstriert.
Soweit seit ihr fertig.
PS: Manche wollen auch Raketen
oder ähnliches, die automatisch
zielen. Kein Problem: Im Prinzip
ist es genau wie die Schüsse, nur
mit einem anderen Bild.
Wie das automatische Zielen
funktioniert, kommt in einem anderen
Kapitel.
Bis dahin:
Viel Spaß beim Ausprobieren,
wünscht euch André Productions!
Wenn ihr soweit seit, kann es ja
weitergehen!


Kapitel 4- Die HP-Anzeige

Also, beginnen wir mit der Anzeige
deiner Leben. Dies ist wohl das
wichtigste.
Ich würde euch raten, 9 Leben zu machen, da dies nur 1 Bild
kostet, und ihr Bilder brauchen werdet.
Am Anfang solltet ihr noch eine
Variable, nennen wir sie
Hero Leben, auf 9 setzen und
Call Event: Helden Leben.
Dies sorgt dafür, dass die
Leben am Anfang initialisiert
werden.
Nun kommt in den Common Events
ein neues Event mit Namen
Helden Leben.
Stelle es auf Call Event.
Da wir die Leben als Bilder
anzeigen lassen wollen, kommt:
Fork Condition:
If Variable (Hero Leben) = 9.
Bitte mit Else Case.
In diese Fork kommt nun,
damit die Leben auch angezeigt
werden, Show Picture: ID 7
(ein Bild für 9 Leben)
Set X = 80, Y = 225.
Dies sind meine Werte.
Ihr habt warscheinlich andere.
Probiert doch einfach mal.
In den Else Case kommt
nun wiederum eine Fork,
die diesmal abfragt, ob die
Variable Hero Leben 8 ist.
Wieder mit Else Case.
In die Fork ein Bild für
die 8.
In den Else Case eine Fork
die abfragt, ob die Leben 7
sind...
Dies macht ihr so weiter bis 0.
In die Fork bei 0 macht ihr
"Game Over".
Damit man bei 0 Leben "stirbt".
Wenn ihr wollt, das die Leben
sich etwas nach oben und unten
bewegen, geht so vor:
Legt ein neues Event(kein Common Event)
an. In dieses Event kommt:
Move Picture: ID 7 X= ?
Y= ? in etwa 0,2-3 sec.
Setzt für die Fragezeichen eure
Bilderwerte von den Leben
ein. Wollt ihr, dass sich die Leben
nach oben und unten bewegen,
so verändert die Variable Y
um +/- 12(in etwa) und setzt sie
statt dem normalen Wert ein.
Wollt ihr, dass sich die Leben
nach rechts und links bewegen,
verändert die Variable X um +/-
12(in etwa). Setzt diese statt dem
ursprünglichen Wert ein.
Nun macht wieder ein Move
Picture: ID 7 Befehl,
und lasst das Bild zu seinen
ursprünglichen Koordinaten zurück-
kehren.
Damit wäre auch dies geschafft.
Wenn dein Held dann Leben abgezogen
bekommt, Change Variable "Hero Leben"
-(wieviel Leben abgezogen werden
sollen) und dann Call Event: Leben.
Und macht am Anfang auch
Change Variable: Hero Leben (Set) 9
Call Event:Hero Leben.
Damit dein Held am Anfang Leben bekommt.
Wollt ihr auch die Gegner
HP anzeigen lassen, geht genauso
wie bei den Hero Leben vor.
Wenn die HP des Gegners über
9 sein sollen, dann müsst ihr das
Common Event "Gegner Leben"
(oder wie ihr es auch immer genannt
habt, dies ist ein neues Event für
die Anzeige der HP der Gegner)
wie folgt verändern:
Change Variable: "HP(einer)"
(Set) HP.
Habt ihr Zehner, auch die
Variable "HP(zehner) an die HP
anpassen, usw.
Nun Change Variable: HP(einer)
(mod) 10.
Die Zehner mod 100, usw.
Bei den Forks:
Erstmal Forks für die HP(einer)
genauso wie bei den Leben.
(nur die Variable HP(einer) einsetzen)
(natürlich andere ID´s bei den Pictures)
Dann Forks für die Zehner:
Im Prinzip genauso: nur die Variablen
HP(zehner) einsetzen, und statt
der Überprüfung, ob die Variable
9,8,7,6,... ist, 90,80,70,60,...
benutzen.
Bei den Hundertern dann 900,800,...
sowie andere Variablen.
Und so weiter!
Am Anfang wie die HP
"definieren", und immer,
wenn er welche verliert,
HP abziehen, und dann Call Event.
Wollt ihr, wie ich z.B.
die Namen der Gegner anzeigen lassen,
dann macht es in etwa genauso.
Bei dem Common Event
(z.B. Gegner Was tun?),
dann Fork Conditions, die abfragen,
wie der Wert der Variable(z.B. Gegnertun)
ist, und dann das entsprechende Bild
anzeigen lassen.
Das wars erstmal!

Kapitel 5- Die Zufallsauswahl der Attacken

Dies ist nicht sehr lang, also:
Falls wir es nicht schon getan haben,
legen wir ein neues Event mit Namen
"Gegner" an.
Wenn ihr verschiedene Gegner wollt,
dann macht ertsmal folgenden Befehl:
Change Variable: Gegner (Set)
Random 1 to (wieviel Gegner ihr wollt)
Nun legt ihr soviel neue Seiten
an wie viel Gegner ihr wollt.
Auf der 1. Seite der Gegner muss
die Variable above 1 sein, auf der
zweiten 2, auf der dritten 3, usw.
Bei diesem Event muss der Switch
"Anfang" an sein.
Nun macht ihr folgenden Befehl:
Bei dem 1. Gegner(falls ihr mehrere
gemacht haben solltet|danach dann
bei dem 2. Gegner, 3. Gegner,...)
Change Variable: Attacke (Set)
Random: 1 to (wieviel verschiedene
Attacken ihr wollt).
Nun wieder neue Seiten.
(neue Seiten=Anzahl der Attacken)
Und zwar gleich nach der Gegnerseite
mit dem aktuellen Gegner.
Bei diesen Seiten muss nun wieder
die Variable "Attacke" bei
der 1. Seite 1 sein, bei der zweiten
2,...
Dort kommen nun die Attacken der
Gegner hin, die hier noch nicht
behandelt werden.
Und alle Seiten bitte auf
"PARALELL PROCESS"!!!


Kapitel 6- Die normalen Gegner

Ich werde dir erklären, wie
du "normale Gegner"(wie bei meinem
Beipsiels KS der Übungsgegner:
Abolisher) erstellst.
Diese sind noch recht einfach.
Also:
Als erstes kommt ein Change Variable
Befehl: Gegner HP (Set) 20(z.B.)
Nun noch Call Event: HP Gegner.
Nun wieder 2 Change Variable:
Gegner X (Set) (bei mir:332)
und Y (Set) (bei mir RAndom 10 to 230)
Show Picture ID(was ihr noch frei habt)
Gegner 1 bei Variable Gegner X und Y,
sowie Change Switch: Überprüfe Schaden:
ON.
Nun kommt ein Cycle(oder Loop)
Befehl.
Und nun: Change Variable:
Gegner X (-) 1(ihr könnt auch andere
Werte nehmen, je nach dem wie schnell
er sein soll).
Damit sich der Gegner auch noch
bewegt: Move Picture(Gegner 1)
zu Variable X=Gegner X und Y=Gegner Y.
Zum Überprüfen, ob der Gegner
verschwunden ist, kommt eine Fork:
If Variable Gegner X (below)
(bei mir:-12).
Nun "Change Switch: Übeprüfe Schaden"
OFF.
Wenn ihr wollt, dass man dort noch
einLeben verliert, Change Variable:
Hero Leben (-)1 und Call Event
Leben.
In die Fork nun noch:
Break Cycle.
Ganz am Ende, damit das Bild auch
verschwindet: Erase Picture.
Noch etwas für Endgegner:
Wenn ihr erst normale Gegner
machen wollt, und dann nach einer
bestimmten Anzahl Gegner, der Endgegner
erscheinen soll, dann macht bei jedem
Gegner am Ende noch Change Variable:
Gegner Besiegt (+)1 und in der Zufalls-
gegnerauswahl am Anfang eine Fork:
If Variable: Gegner Besiegt:
Above (wieviel GEgner man besiegen
muss), und in die Fork:
Change Switch: Boss erscheint ON.
Ganz am Ende eine neue Seite anlegen,
wo der Switch Boss erscheint On sein
muss. Dort dann das Auftauchen des
Bosses und dann wie bei einem
gewöhnlichen Gegnern vefahren, nur
mehr HP...
Das war´s auch schon!


Kapitel 7- Die Attacken der Gegner

Dies ist das wohl ziemlichst
schwierigste im Spiel.
Hier kannst du viel nach deinen
Wünschen gestalten. Ich werde es
dir mal so gut wie es geht erklären.
Also:
Für die Animationen, wenn die Gegner
sich bewegen(z.B.Arme hochstrecken,
Füße einziehen usw.), brauchst du
nicht wie in manchen Spielen,
ein Haufen Animationen, sondern
es reichen auch 2(z.B.: Arme unten
und Arme oben). Bei größeren Bewegungen
kann es auch mal 1 Zwischenanimation
sein. Probier einfach mal aus,
wie es aussieht. Zwischen die
Animationen sollte noch ein Wait-Befehl.
Ehe ich es vergesse:
Das erscheinen der Gegner
kommt (meistens) bei den Attacken
hin(ihr könnt aber auch selber
entscheiden, wo ihr das Auftauchen
erstellt, beachtet aber, das der
Gegner in der Regel nur
EINMAL erscheint).
Und speichert den Standort
der Gegner in Variablen!!!
Wenn er sich oben-unten
bzw. rechts-links bewegen
soll, ein neues Event mit
Parralel Process und einem
Switch(den ihr On stellt, solange
er sich bewegen soll).
In dieses Event kommt:
Change Variable:
Hero X +(wenn er anch rechts soll)
-(wenn er nach links soll) 1-5
oder Hero Y +(wenn er nach unten soll)
-(wenn er nach oben soll) 1-5.
Nun ein Move Picture Befehl,
der den Gegner zu den neuen
Variablen bewegen lässt.
Nun eine Fork:
If Variable:
Hero X above(wenn er sich nach rechts
bewegt), below(wenn er sich nach links
bewegt) oder Hero Y
above(wenn er sich nach unten
bewegt), below(wenn er sich
nach links bewegt).
Nun einen Wert eintragen wo er
anhalten soll.
Die Fork mit Else Case.
In die Fork kommt nichts,
in den Else Case "Goto Label 1"
Den Label 1 vor den Change Variablen
Befehl machen.
Unter die Fork dasselbe
mit der entgegengesetzten Richtung.
Diesmal wird aus "Goto Label 1"
"Goto Label 2", und den Label
2 vor der letzten Change Variable.
PS: Statt den Labels lassen
sich auch Loops verwenden(in die
Forks dann: Break Cycle)
Und jetzt zurück zu den Attacken.
Wenn der Gegner Schaden erleiden
kann, müsst ihr einen Switch(z.B.
überprüfe Schaden) auf ON stellen.
Wenn er keinen mehr erleiden
soll, den Switch wieder auf Off
stellen.
Wenn der Held verwundet werden
soll, einen Switch(z.B. Hero Schaden?)
auf On stellen. Wenn er keinen mehr
erleiden soll, den Switch wieder Off.
Und jedes "Bild", von dem
der Held verwundet werden kann,
in Variablen speichern(Position),
und so wie die Gegner bewegen lassen
was ich euch vorhin erklärt habe).
Am Ende der Attacke
den Switch, welcher auf der Seite
für die Attacke On sein muss,
auf Off stellen,
so wie vorher bei dieser
Attacke verwendete Switches
gegebenfalls auf Off und Variablen
auf 0 stellen.
Der Rest ist euch überlassen!

Kapitel 8- Die Schadensüberprüfung Teil 1: Der Code

Ein paar Worte vorweg:
Nun wird es wieder einfacher.
Nun sollte man bei dir Gegner
schon Attacken ausüben sehen,
nur die Angriffe verwunden keinen.
Dafür ist dieses Kapitel!
Dies ist erstmal nur
für die Schadensberechnung,
wenn der Gegner am ganzen Körper
verwundbar ist.
Doch erstelle dies erstmal.
Man braucht dann nur geringfügige
Änderungen, wenn man will, dass der
Gegner nur an einer ganz bestimmten
Stelle verwundbar ist.
Dieses Kapitel ist nur für den
"Code", woher man die Zahlen bekommt
, die man braucht, später.
Ps: Dies ist auch für deinen
Schaden(des Helden).
(bei der Schadensüberprüfung
wird der Schaden für ein Viereck
überprüft, was von den tatsächlichen
Werten kaum abweicht)
Nun also los.
Erstellt ein neues Event
(oder eine neue Seite in einem Event,
wo ihr die anderen Seiten gerade nicht
braucht). Stellt es auf Parallel
Process und es muss der jeweilige
Switch für die Schadensüberprüfung
On sein.
Erstmal die Überprüfung ob du Schaden
bekommst.
Change Variable: Trefferzone X1
(und) X2 (Set) Hero X,
Trefferzone Y1 (und) Y2 (Set) Hero Y.
Jetzt kommt Change Variable:
Trefferzone X1 -(den Wert den ihr
ermittelt habt,später(WIES)),
Trefferzone X2 +(WIES),
Trefferzone Y1 -(WIES) und
Trefferzone Y2 +(WIES).
Und nun 4 Forks:
If Variable(Koordinate X von
dem Bild, dass den Helden treffen
soll) above Trefferzone X1,
If Variable(Koordinate X von
dem Bild, dass den Helden treffen
soll) below Trefferzone X2,
If Variable(Koordinate Y von
dem Bild, dass den Helden treffen
soll) above Trefferzone Y1 und
If Variable(Koordinate Y von
dem Bild, dass den Helden treffen
soll) below Trefferzone Y2.
Alle ohne Else Case und
die nächste immer in die
darauffolgende.
In die letzte Fork nun:
Change Variable: Hero Leben
(-) 1 und Call Event: Hero Leben.
Wenn ihr wollt, könnt ihr noch eine
Treffanimation machen. Ihr müsst aber
nicht. Wenn ihr wollt, dass man von
der Attacke nur einmal getroffen
werden kann, müsst ihr noch
Change Switch(den Switch für
die jeweilige Schadensüberprüfung)
auf Off stellen.
Auf jeden Fall empfiehlt sich ein
kurzer Wait-Befehl(ca. 0,2 sec),
damit der Held nicht durchweg
getroffen wird.
Nun zu der Überprüfung,
ob der Gegner getroffen wird.
In etwa müsst ihr es genauso
wie eben machen, aber mit
folgenden Veränderungen:
Ertsmal muss ein anderer Switch
aktiv sein.
Die Variablen Trefferzone
X1 und 2, Y 1 und 2 müssen an
die Variablen von dem Bild
der Attacke X bzw. Y angepasst werden.
Bei den Forks statt den Variablen
des Bildes was dich treffen soll,
Schuss 1 X oder Y nehmen.
Statt Change Variable Hero Leben
(-) 1 Change Variable Gegner HP
(-) 1(oder wieviel ihm abgezogen
werden soll).
Und dann natürlich Call Event
Gegner HP statt Hero Leben.
Diese 4 Forks nun noch mit
Schuss 2 X und Y bis Schuss 5
X und Y sowie,wenn ihr Raketen
oder ähnliches habt, Rakete X und Y.
Das war auch schon alles!

Kapitel 9- Die Schadensüberprüfung Teil 2: Die Berrechnung

Also, du brauchst dafür
irgendein Zeichenprogramm
(z.B. Psp) das die *.png Dateien
öffnen kann.
Erstmal mache ich die Berechnung,
wenn der Gegner überall verwundbar
sein soll.
Dafür brauchst du nur die Bildgröße
in Pixeln. Das Bild sollte optimal
"beschnitten" sein, d.h.:
rechts, links,unten, oben sollte
nichts frei sein.
Nehmen wir als Beispiel eine Bildgröße
von 57x85. Entweder rechnest du
im Kopf oder mit dem Tachenrechner.
Du teilst beide Werte durch 2,
bei uns würde dann 28,5
und 42,5 rauskommen.
Der erste Wert ist für beide
(+/-) Trefferzone X Werte,
der 2. Wert für die Y Werte.
Wenn ,5 rauskommt, runde bei
dem einen ab und bei dem anderen
auf. Bei uns wären die Befehle so:
Change Variable: Trefferzone X1
(-) 28 und X 2(+) 29, sowie:
Trefferzone Y1 (-) 42 und Y2(+) 43.
Das war alles.
Kommen wir nun dazu, dass ein
Gegner nur an bestimmten Stellen
treffbar ist.
Dies ist auch nur ein wenig anders.
Als erstes öffnest du das Bild mit
einem Grafik-Programm.
Nun markierst du dir mit einer gut
sichtbaren Farbe den Bereich, wo
er verwundbar sein soll(Viereck,
kein schrägen Linien).
Nun gehst du bei dem markierten
Kästchen mit der Maus auf den linken
Rand und schaust dir den X-Wert
(meistens unten links, der linke Wert)
an.
Dasselbe nochmal mit dem rechten
Rand.
Nun gehst du mit der Maus an den
oberen sowie unteren Rand des
Kästchens und schaust dir den Y
Wert an(der rechtere Wert).
Mehr Werte brauchst du ertmal
nicht, ausser der Grösse des
Bildes(in Pixeln).
Nun teile die X und Y Grösse des
Bildes durch 2(wie oben).
Nun wird es ernst:
Wenn der linke Rand des Kästchens
links vom Punkt liegt, so rechne
X Koordinate des Punktes - der X
Koordinate des linken Randes und
bei der Schadensüberprüfung
X1-(der ermittelete Wert).
Wenn die Kante auf dem Punkt liegt,
X1 +0(oder lass den Befehl weg).
Wenn sie rechts neben dem Punkt
liegt, so rechne: X Kante - X Punkt.
Bei der Schadensüberprüfung:
X1 + (der ermittelte Wert).
Dasselbe mit der rechten Kante,
nur bei der Schadensüberprüfung dann
X2 nehmen.
Wenn der obere Rand des Kästchens
oberhalb vom Punkt liegt, so rechne
Y Koordinate des Punktes - der Y
Koordinate des oberen Randes und
bei der Schadensüberprüfung
Y1-(der ermittelete Wert).
Wenn die Kante auf dem Punkt liegt,
Y1 +0(oder lass den Befehl weg).
Wenn sie unterhalb neben dem Punkt
liegt, so rechne: Y Kante - Y Punkt
und bei der Schadensüberprüfung:
Y1 + (der ermittelte Wert).
Dasselbe mit der unteren Kante,
nur bei der Schadensüberprüfung dann
Y2 nehmen.
Und das ihr mir das Bild ja nicht
abspeichert. Es ist nur als
Gedächtnisstütze gedacht.
Das wäre eigentlich alles.

Kapitel 10: Die automatischzielenden Raketen

Ich werde dir jetzt nun die
Raketen erklären. Aber es ist nicht
leicht. Du solltest vorher es erstmal
ohne Raketen machen und dann am Schluss
Raketen reinbringen.
Bereit?
Los!
Ready? GO!
Wir machen es genauso wie bei den
Schüssen. Erstmal mit einer
Rakete, weil es Bilder spart und
sonst vielleicht zu einfach werden
könnte(im Spiel, nicht das Script).
Nun brauchen wir nur noch ein Common
Event, z.B. Raketenschiessen.
Dieses Common Event erkäre ich euch
nun(bei dem Event muss ein Switch
(Rakete schiessen z.B.) On sein).
Als erstes solltet ihr bei den
Gegnern, wenn einer erscheint, einen
Switch, z.B. Rakete auf Gegner 1
auf On schalten, und wenn
er besiegt ist, wieder auf Off.
Bei anderen Gegner dann auch ein anderer
Switch. Ansonsten wüssten wir nicht
WANN die Rakete WO hinzielen soll.
Aber nun zu den Common Event.
Als erstes ein Play Sound
Effect für den Schuss(kann
auch weggelassen werden).
Und nun: Wie auch bei den
Schüssen, Rakete X (Set) Hero X und
Rakete Y (Set) Hero Y.
Nun Show Picture Rakete (Variablen
Rakete X und Y).
Jetzt kommt: Fork Condition:
If Switch(Rakete auf den 1. Gegner)
On, in den Else Case die selbe
Fork, nur ein anderer Switch
(z.B. Rakete auf Gegner 2).
Nun in diesen Else Case wieder
eine Fork...
Macht dies bis zum letzten Gegner,
in die letzte Fork auch ein Else Case.
Erstmal zum letzten Else Case:
Change Variable Rakete X
+5.
In die einzelnen
Forks kommt: Am Anfang ein Loop, dann
Change Variable (Rakete X) +5.
Falls der Gegner am ganzen
"Körper" treffbar sein soll,
könnt ihr diesen Schritt auch über-
springen. Ansonsten kommt:
Change Variable Prüfe Raketentreffer
(Set) (des jeweiligen Gegner Y
Position). Change Variable
Prüfe Raketentr. +/-
(der von euch errechnete Wert,
komm ich am Ende nochmal dazu).
Nun geht es ganz normal weiter:
Nun kommt eine Fork mit Else Case:
If Variable Rakete Y (bigger)
(des jeweiligen Gegners Y).
In den Else Case wieder eine Fork
mit Else Case:
If Variable Rakete Y (same)
(des jeweiligen Gegners Y).
In den Else Case wieder eine Fork
ohne Else Case:
If Variable Rakete Y (smaller)
(des jeweiligen Gegners Y).
In die 1. Fork:
If Variable Position
(same) 1,
und mit Else Case.
In diese Fork nichts, aber in den
Else Case:
Show Picture: ID(der Rakete)
Rakete schräg oben.
(Variablen Rakete X und Y).
Zu dem Bild:
Öffnet das normale Bild der
Rakete mit Psp(oder einem anderen
Programm) und dreht es um 45 Grad
nach links und um 45 Grad nach rechts
für das Bild Rakete schräg unten
(später verwendet).
Nun kommt in die Fork
noch: Change Variable
Position (Set) 1 und
Rakete Y - 1(in etwa).
In die 2. Fork(die Fork mit
If Variable Rakete Y same
(des jew. Gegner Y):
If Variable Position
(same) 2,
und mit Else Case.
In diese Fork nichts, aber in den
Else Case:
Show Picture: ID(der Rakete)
Rakete(normal).
Nun kommt in noch: Change Variable
Position (Set) 2.
In die 3. Fork(die Fork mit
If Variable Rakete Y smaller
(des jew. Gegner Y):
If Variable Position
(same) 3,
und mit Else Case.
In diese Fork nichts, aber in den
Else Case:
Show Picture: ID(der Rakete)
Rakete(normal). Nun kommt noch rein: Change Variable
Position (Set) 3 und Rakete Y +1
(in etwa).
Nun kommt am Ende der Fork
If Variable Rakete Y (bigger)
(des jeweiligen Gegners Y) folgendes:
Move Picture: ID(der Rakete)
(Variablen Rakete X und Y).
Nun kommt folgende Fork:
If Variable Rakete X (above)
325(in etwa).
In die Fork:
Change Variable Rakete X und Y
(Set) 0, Change Switch Schiesse Rakete
Off und Break Cycle(oder Loop).
In die anderen Fork dasselbe,
nur dann eben mit anderen
Switches/Variablen.
Jetzt komme ich nochmal
auf Berechnung des Wertes,
wenn die Rakete einen Gegner
an einer bestimmten Stelle treffen
soll.
Im Prinzip ist es auch nichts
anderes als die Berechnung der
Schadensüberprüfung.
Also, als erstes öffnen
wir den "Gegner" mit einem
Zeichenprogramm.
Nun markiert ihr euch wieder
den Mittelpunkt des Bildes.
Also den Punkt mit den Koordinaten:
X= X-Größe des Bildes : 2,
Y=Y-Wert des Bildes : 2.
Das wäre bei mir:
Nun markiert ihr euch eine
Y-Achse, auf die sich die Rakete
fixieren soll(dabei interessiert
nur der Y-Wert)(es reicht auch ein
Punkt).
Nun schreibt ihr euch den
Y-Wert des Punktes und der
Achse auf.
Wenn der Y-Wert der Achse
niedriger als der Y Wert des
Punktes ist, rechnet den
Punkt - den Achsen Y-Wert.
Dann lautet der Befehl:
Change Variable: Prüfe Rakete
-(der ermittelte Wert).
Wenn die beiden Koordinaten
gleich sind, lasse den
Befehl einfach weg,
oder +0.
Wenn der Y-Wert der Achse höher
als der Wert des Punktes, rechne:
Achse - Punkt Y-Wert.
Dann lautet der Befehl:
Change Variable: Prüfe Rakete
+(der ermittelte Wert).
Damit wäre eigentlich
alles geklärt.
Noch etwas:
Wundert euch nicht, wenn plötzlich
ein/e neue/r Switch/Variable
auftaucht. Dann erstellt ihn/sie
einfach.
Damit gebe ich zurück zum Studio.

Kapitel 11- Der Schluß

1. Also, das Ende
ist eigentlich euch überlassen.
Am Anfang solltet ihr
alle Switches und Variablen

2. die ihr verwendet habt(sofern
ihr sie nicht mehr braucht)
auf Off bzw. auf 0 stellen.

3. Ich würde den Helden noch mit
Move Picture in die linke
obere Ecke schicken und
verschwinden lassen.

4. Doch wie gesagt, es ist
euch überlassen!!!

---

-----------------------------------------------------------------

am besten lest ihr es euch mal in ruhe durch