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!!!
...
Zitieren