Beiträge von FlipelyFlip

Ohje, da hab ich schlechte Nachrichten für dich.

Um den nächsten Rang zu erreichen musst du in Pokemon Rot neu beginnen, Glumanda als Starter wählen und dann in der ersten Möglichen Wiese auf Level 98 trainieren, ohne es zu entwickeln. Sobald du das geschaft hast, startest du das Spiel erneut neu und machst das selbe mit Schiggy, nur diesmal bis 99. Sobald Shiggy Level 99 erreicht hat, musst du ein letztes Mal neu starten und nimmst Bisasam als dein Starterpokemon. Jetzt trainierst du Bisasam bis Level 100 (egal wo) ohne es zu Entwickeln. Sobald es auf Level 100 ist, mussr du Kojote 800€ überweisen und du erreichst den nächsten Rang.

Spaß bei seite, es hängt ganz von deiner Anzahl an Beiträgen ab. Du kannst mal schauen wer einen anderen Rang hat und wieviele Beiträge diese Person geschrieben hat. Dann kannst du ungefähr erahnen, wie lange du noch für die nächste Stufe hast.

Zitat von Kojote

Habs gestern fixen können, aber das Problem an sich scheint noch nicht behoben zu sein, nen bisschen was macht mich gerade skeptisch an dem Bug. Ich bin noch am forschen wo das Problem ist.

wenn du mir die Fehlermeldung verrätst, dann kann ich dir eventuell weiter helfen, gern auch per PN.

Das meiste Wissen bei den Damage Formulas kommt vom Ace damals, wie ich ein Script von Yanfly genutzt hatte, welches mir mehr Kontrolle über die Damage Formula gab, wo ich dann mit der Zeit genauer hin schaute und merkte, dass es eigentlich nur statt dem Wert aus der Datenbank, den aus dem Script weiter gegeben hat. Von da an begann ich dann halt vieles auszutesten, was geht und was nicht.

Ich habe dann halt nur überlegt, wie man da einen Stehlen-Skill bauen könnte und wie man das mit den Bomben umsetzt. Es hilft einem zwar, dass man weiß wie man Code schreibt, aber man schafft das im Grunde auch ohne.

Hallo,

ich arbeite derzeit an ein paar Szenen in Lumos und auch an dem ersten Mini-Bosskampf. Vorzeigbares hab ich leider nicht wirklich, da nicht all zu viel neues Grafisch dazu gekommen ist.

Ich würde aber schon mal 1-2 Leutchen suchen, die mir den ersten Abschnitt testen würden.

Willkommen zu meiner zweiten Einheit zu Schadensformeln. Hier richte ich mich explizit an die fortgeschrittenen Nutzer, die sich bereits meinen ersten Kurs zu Herzen genommen haben und selbst schon einiges durchprobiert haben. Ich werde hier mal grob erwähnen, was wir alles durcharbeiten werden.

• Wir werden uns eine Formel ansehen, bei der immer mindestens 1 Schaden verursacht wird.
• Wir werden uns ansehen, wie man bei einem Skill eine eigene BattleLog Meldung erstellt.
• Wie man einen Skill aus einem Plugin korrekt einbindet.
• Wir werden uns einen Skill ansehen, bei dem wir nach dem Einsatz dem Helden einen Zustand erteilen werden.
• Wir werden uns einen Skill ansehen, bei dem wir dem Gegner eventuell etwas klauen werden, abhängig von unserer Flinkheit.
• Wir werden uns einen Skill ansehen, mit dem man bei allen Gegnern eine Bombe platziert.
• Wir werden uns einen Skill ansehen, mit dem man bei allen Gegnern die platzierten Bomben explodieren lässt.

Diese Punkte werden uns einige mächtige Möglichkeiten eröffnen, bei der wir schon sehr Tief in der Materie drin hängen werden. Es wird teilweise sehr kompliziert werden, aber ich gebe mir Mühe, euch das ganze so einfach wie Möglich zu erklären! Falls trotzdem Fragen aufkommen, meldet euch gern in den Kommentaren und wir fangen jetzt ohne große Umschweife mit dem Tutorial an. Haltet euch fest, jetzt geht es los!

Einleitung

Wie schon eingangs erwähnt, richtet sich dieses Tutorial auf fortgeschrittene Anwender. Wir werden uns teilweise auch etwas tiefer in der Materie bewegen, da ich meinen Fokus auch etwas erweitere und nicht nur in der Schadensformel hängen werde, sondern auch etwas allgemeiner mit den Skills arbeiten werde. Die .js welche ich für dieses Tutorial erstellt habe, wurde selbstverständlich an diesem Tutorial angehängt und kann dann von euch selbst auch nochmal in Ruhe begutachtet werden. Wer will, kann diese auch in sein eigenes Projekt einbinden.

Diese Formeln können im Grunde ebenfalls bei RPG Maker VX Ace bzw. RPG Maker MV verwendet werden, benötigen jedoch etwaige Anpassungen.

Grundlagen für dieses Tutorial

Immer mindestens 1 Schaden

Formel

Dieser Punkt ist ein interessantes Konzept für Schadensberechnung, da man so immer mindestens 1 Schaden anrichtet, wenn der Skill schaden austeilt, man aber eindeutig zu Schwach ist, um dem Gegner wirklich Schaden auszurichten. Wenn wir den Standardangriff als Grundlage her nehmen, würde das wie folgt aussehen:

dmg = a.atk*4 - b.def*2; if (dmg < 1) { dmg = 1; }; dmg;

Erklärung

dmg = a.atk*4 - b.def*2; ist unsere übliche Schadensformel, welche an die Variable dmg übergeben wird.

if (dmg < 1) { dmg = 1; }; dmg; hier wird mit einem if überprüft, ob die Variable dmg weniger Schaden als 1 machen würde und falls ja, wird der Schaden auf 1 gesetzt. Das dmg; dient dazu, dass der Schaden ausgegeben wird.

Im Grunde war dies eine einfache Wiederholung aus dem vorherigen Kurs und konnte auch mit diesem Wissen von dort umgesetzt werden. Dieser Punkt wird jedoch gelegentlich im Tutorial erwähnt, weswegen es eine gute Idee ist, diesen auch hier noch vorzuzeigen.

Eine eigene Meldung in den BattleLog übergeben

Aufbau

Hier sind wir schon beim ersten Punkt, der uns in diesem Tutorial sehr nützlich ist. Es gibt einige Standard-Möglichkeiten, die einem beim BattleLog einen vordefinierten Text anzeigen, aber wenn wir selbst einen aufbauen wollen, dann wird das für viele ohne ein Plugin nicht funktionieren. Doch da liegt Ihr falsch. Ich zeige euch wie es geht!

BattleManager._logWindow.addText("Ich bin ein Text, der nun angezeigt werden kann"); Damage-Formula;

Erklärung

Eine kurze Erklärung was dieser Befehl macht und wie mächtig dieser wirklich wird.

BattleManager._logWindow.addText( dies fügt eine Nachricht zum Kampf-Log mit hinzu, sobald der Skill genutzt wird. Hier kann man spezielle Nachrichten reinschreiben, die auch den Gegner betreffen. Beim Text kann man zum Beispiel auch ausgeben, dass der Anwender mit dem Namen XY das Ziel YZ ganz bezaubernd findet. Dies würde dann so aussehen:

BattleManager._logWindow.addText(a.name() + " findet " + b.name() + " ganz bezaubernd.");

Dies würde also aussagen, dass sobald der Skill verwendet wird, steht dann im Kampflog (als Beispiel verwendet Reid den Skill gegen einen Gnom) "Reid findet Gnom A ganz bezaubernd.".

Ihr werdet in diesem Tutorial diese Funktion ein paar mal sehen!

Wie man eine Schadensformel für einen Skill aus einer .js korrekt einbindet!

Erklärung

Als erstes würde ich sagen, wir öffnen uns den Editor. Empfehlen würde ich persönlich Notepad++, da es doch sehr viele und auch gute Vorteile bietet, wenn man da etwas macht.

Grundsätzlich sieht es wie folgt aus, wenn man einen Skill in der .js erstellt:
function name(a, b) { return damageFormula };

function name(a, b) gibt an, dass man diese Methode mit dem Namen der Funktion aufrufbar wird. Die beiden Parameter (a, b) müssen dann beim Aufrufen gesetzt werden, ansonsten erhält man eine Fehlermeldung, also achtet darauf! Bei diesem Beispiel, müsste man dann beim Skill in der Schadensformel folgendes angeben: dmg = name(a, b); dmg;

Ebenso muss man diese .js bei den Plugins hinzufügen, so dass es auch genutzt werden kann.

Zustandsänderung beim Anwender durch Nutzen des Skills

Aufbau

Wir wollen einen Skill machen, der dem Gegner Schaden anrichtet, welcher sich durch Angriff des Anwenders - Verteidigung berechnen lässt. Der Anwender soll dabei aber den Status 11 erhalten.

a.addState(11); a.atk - b.def

Erklärung

Der Befehl a.addState(11) fügt dem Anwender den Status 11 hinzu. Danach wird mit a.atk - b.def berechnet, wie hoch der Schaden ausfällt. Wenn man einen anderen Status erteilen will, muss man lediglich die 11 mit der entsprechenden ID des gewünschten Status ersetzten.

Weitere Möglichkeiten & Anwendungsbeispiele

Es gibt hier viele verschiedene Situationen, in denen man dies nutzen kann. Man kann so zum Beispiel einen Status erstellen, welcher erst nach 2 Zügen weg geht, so dass man von Pokemon den Hyperstrahl nachbauen könnte. Ebenso kann man so auch für schwache, aber flinke Charaktere einen Skill basteln, der etwas Schaden austeilt und dem Anwender dann den Status 2 (Verteidigung) erteilt. So würde der Anwender in folge dessen, weniger Schaden erhalten.

Mann kann aber auch einen Status entfernen, mit a.removeState(11). Hier würde man dem Anwender den Status mit der ID 11 wieder entfernen. Probiert euch hier ruhig etwas aus.

Komplexe Skills

Stehlen

Spezifikation

Was benötigen wir hier? Wir wollen einen Skill erstellen, der dem Gegner anhand der eigenen Flinkheit (agi) etwas Geld, oder gar ein Item klaut. Man könnte zwar alles in der Damage Formula selbst bearbeiten, jedoch würde ich dies nicht empfehlen. Wir werden nun auch erste Änderungen in an bestehenden Klassen des Makers durchführen um uns das ganze zu erleichtern.

Wir wollen nun den Skill so erstellen, dass man einmal bei einem Gegner etwas klauen kann. Sobald etwas geklaut wurde, kann bei diesem Gegner nichts mehr geklaut werden in diesem Kampf. Ebenso könnte man ja sagen, dass man bei dem Gegner entweder eine zufällig bestimmte Menge Gold oder ein Item klauen kann.

Als Erfolgschance würde ich sagen, nehmen wir die doppelte agi des Anwenders und rechnen diese * 100 und dividieren dann durch die vierfache agi des Ziels. Wir runden diesen Wert dann auf eine ganze Zahl. Dann lassen wir eine zufällige Zahl zwischen 0 und <100 zufällig bestimmen. Ist die zufällig generierte Zahl kleiner als unsere errechnete Zahl, so ist der Versuch es zu klauen erfolgreich und es wird nun ermittelt, ob es ein Item wird, oder doch eher etwas Geld. Das Item das geklaut werden kann, soll speziell hinterlegt sein. Die Chance zwischen Geld und Item soll bei 50:50 liegen. Es wird hier nochmals eine zufällige Zahl zwischen 1 und 10 generiert, wobei die geraden Zahlen für Item stehen und die ungeraden Zahlen für Geld. Es soll eine Zufällige Zahl zwischen 1 und 50 gerollt werden und dies ist dann das Gold das geklaut wird. Es soll dann im Battlelog eine Nachricht ausgegeben werden, was geklaut wurde, oder ob es überhaupt etwas zu klauen gibt. Zusätzlich soll der Angriff etwas Schaden anrichten.

Zusammengefasst, soll der Skill folgendes beinhalten:

1. Eine Abfrage, ob es bei dem Ziel etwas zu stehlen gibt, bzw. ob dieser bereits erfolgreich beklaut wurde.
2. Die Formel für den Erfolg soll berechnet werden (2x a.agi * 100 / 4x b.agi) > Math.floor(Math.random() * 100);
3. Eine Abfrage bei einem erfolgreichen Versuch, was geklaut werden soll. if (Math.floor(Math.random() * 10 + 1) % 2 == 0) {ja;}else{nein};
4. Falls Geld geklaut wird, soll eine zufällige Zahl zwischen 1 und 50 generiert werden Math.floor(Math.random() * 50 + 1)
5. Nachricht im BattleLog BattleManager._logWindow.addText(a.name() + " klaut " + Gegenstand/Geld + " vom Gegner " + b.name() + " .");
6. Schaden soll ausgeteilt werden a.atk*2 - b.def

Vorbereitung

Wenn wir nun das alles von oben zusammen fassen, haben wir eine recht interessante Aufgabe vor uns. Starten wir mit dem ersten Punkt, so dass wir hier auch wirklich sauber arbeiten können. Erstellen wir als erstes eine .js welche wir Schadensformeln nennen und als Schadensformeln.js im plugin-Ordner abspeichern. Nun gehen wir in die Datenbank zum Skill und schreiben in die Schadensformel folgendes: dmg = stehlen(a, b); dmg;.

Als nächstes gehen wir nun zurück in unser frisch erstelltes Plugin und schreiben einmal folgendes:

function steal(a, b) {

};

Damit haben wir zumindest unsere Funktion bereits erstellt. Als nächstes werden wir dem Game_Battler eine Möglichkeit geben, zu erkennen, ob dieser erfolgreich bestohlen wurde. Dies machen wir wie folgt:

var addNewFunctions = Game_Battler.prototype.initMembers;

Game_Battler.prototype.initMembers = function() {

addNewFunctions.call(this);

this._steal = false;

};

Was haben wir hier gemacht? Wir haben eine bereits bestehende Methode um einen Wert erweitert, den wir dann in weiterer Folge brauchen werden. Der Übersicht halber werden wir noch 2 Methoden hinzu fügen um die Variable _steal abfragen zu können, bzw. um diese Variable auf true zu setzten. Dies sieht dann wie folgt aus:

Game_Battler.prototype.stealSuccess = function() {

this._steal = true;

};

Game_Battler.prototype.stealable = function() {

return this._steal;

};

Wir haben nun die Methoden stealSuccess() und stealable() zum Game_Battler hinzu gefügt, was nun bedeutet, dass bei Gegnern und auch bei Helden etwas geklaut werden kann.

Mit diesen Erweiterungen der Basis haben wir uns schon viele Möglichkeiten geschaffen. Starten wir nun durch mit unseren Überprüfungen. Dafür gehen wir in die anfangs erstellte Methode steal.

Ausführung

Wir werden uns nun erstmal der Tatsache widmen, dass wir schauen wollen, ob man bei diesem Gegner etwas klauen kann, oder nicht. Dies sieht wie folgt aus:

if (!b.stealable()) {

} else {

};

In unserer Abfrage, fragen wir nun ab, ob bei unserem Ziel die Variable stealable true ist. Da wir diese aber Grundsätzlich auf false haben, wird diese mit einem ! davor automatisch auf das Gegenteil gesetzt. Damit wird aus einem false ein true bzw. aus einem true ein false. Als nächstes würde ich vorschlagen, dass wir den Else-Zweig abschließen. Ich würde dort folgendes eingeben:

if (b.enemyId() == 2) {

BattleManager._logWindow.addText(b.name() + " hat nichts, das man stehlen könnte.");

} else {

BattleManager._logWindow.addText(b.name() + " hat nichts mehr, das man stehlen könnte.");

};

Ich habe hier nochmal eine if-Abfrage gemacht, da wir ja auch eventuell Gegner haben wollen, bei denen wir nichts klauen können. Dann würden wir einen Text ausgeben, bei dem eben drin steht, dass es nichts zum Stehlen gibt. Andernfalls soll einfach nur ein Text ausgegeben werden, dass es nichts mehr zu stehlen gibt bei besagtem Gegner.

Konzentrieren wir uns nun auf den ersten Teil der übergeordneten if-Abfrage.

if ((a.agi * 2 * 100 / (b.agi * 4)) > Math.floor(Math.random()*100)) {

} else {

};

So sieht es nun richtig aus. Den else-Zweig werden wir zum Schluss bearbeiten. Wenn diese Abfrage nun aber positiv ausfällt, soll folgendes passieren:

if ((Math.floor(Math.random()*10 + 1)) % 2 == 0) {

} else {

}

Kurze Erklärung was hier gemacht wird. Der erste Teil der Abfrage mit dem Math.floor und Math.random sollte jedem noch bekannt sein aus dem vorhergehenden Tutorial. Jedoch haben wir jetzt ein % 2 == 0 mit dazu bekommen. Dieses macht folgendes: Dividiere das Ergebnis durch 2. Gibt es keinen Rest, dann ist die Zahl gerade, ansonsten Ungerade.

Sollte die Zahl ungerade sein, geben wir folgendes ein:

money = Math.floor(Math.random()*50 + 1);

$gameParty.gainGold(money);

BattleManager._logWindow.addText(a.name() + " konnte " + money + "\G von " + b.name() + " stehlen.");

b.stealSuccess();

Wir haben hier also erfolgreich Gold geklaut!

Nun kümmern wir uns um das Item. Für dieses Tutorial würde ich sagen, soll man immer das Item mit der ID 1 erhalten. Ihr könnt das dann aber später mit etwas JavaScript-Wissen selbst erweitern und so für jeden Gegner ein eigenes Item zum stehlen definieren.

Das stehlen würde dann wie folgt aussehen:

item = $dataItems[1]

$gameParty.gainItem(item, 1)

BattleManager._logWindow.addText(a.name() + " konnte " + item.name() + " von " + b.name() + " stehlen.");

b.stealSuccess();

Was haben wir hier nun gemacht? Einfach gesagt, wir haben der Variable item das erste Item aus dem Datensatz $dataItems gegeben. Danach erhält der Spieler genau 1x das Item. Es wird ein Text ausgegeben und der Diebstahl wird als Erfolg verbucht.

Kommen wir nun zu dem Fall, dass die Abfrage zum Stehlen fehl schlägt. Dann werden wir folgenden Text anzeigen:

BattleManager._logWindow.addText(a.name() + " konnte leider nichts von " + b.name() + " stehlen.");

Wir haben nun aber noch 2 Punkte offen. Wir haben ja zu Beginn gesehen, dass wir einmal bei Gegner 2 sagen, der hat Grundsätzlich nichts. Das müssen wir nun in unserer Abfrage berücksichtigen. Daher würde ich die Abfrage etwas umbauen und dann so aussehen lassen:

function steal(a, b) {

if (b.enemyId() == 2) {

BattleManager._logWindow.addText(b.name() + " hat nichts, das man stehlen könnte.");

} else if (!b.stealable()) {

if ((a.agi * 2 * 100 / (b.agi * 4)) > Math.floor(Math.random()*100)) {

if ((Math.floor(Math.random()*10 + 1)) % 2 == 0) {

item = $dataItems[1]

$gameParty.gainItem(item, 1)

BattleManager._logWindow.addText(a.name() + " konnte " + $dataItems[1].name() + " von " + b.name() + " stehlen.");

b.stealSuccess();

} else {

money = Math.floor(Math.random()*50 + 1);

$gameParty.gainGold(money);

BattleManager._logWindow.addText(a.name() + " konnte " + money + "\G von " + b.name() + " stehlen.");

b.stealSuccess();

};

} else {

BattleManager._logWindow.addText(a.name() + " konnte leider nichts von " + b.name() + " stehlen.");

};

} else {

BattleManager._logWindow.addText(b.name() + " hat nichts mehr, das man stehlen könnte.");

};

};

Was hat sich nun geändert? Naja sagen wir es so, wir haben die Abfrage ob die Gegnerische ID == 2 ist, an den Anfang gesetzt, da dies weitaus Sinnvoller ist, da wenn dies zutrifft, der Rest nicht berücksichtigt werden muss und wir diesen Punkt nur einmal vorhanden haben und nicht 2 mal schreiben müssen. Jetzt müssen wir nur mehr die Formel für den Schaden hinzufügen. Dies schreiben wir dann zum Schluss vor dem letzten }; rein:

return a.atk*2 - b.def

Dadurch haben wir nun auch eine kleine Formel für den Schaden dabei.

Das wars dann auch schon mit dem Stehlen Skill.

Bomben Platzieren Skill

Spezifikation

Wir wollen nun einen Skill erstellen, den wir nutzen und dann eine Bombe bei dem Ziel platzieren. Wir können den Skill beliebig oft verwenden und so mehrere Bomben bei einem Gegner platzieren. Es soll beim Platzieren ein Text angezeigt werden, welcher uns zum einen sagt, dass wir Bomben platziert haben und wie viele Bomben bei dem besagten Gegner platziert sind.

Vorbereitung

Wir werden nun wieder unser Plugin Schadensberechnung.js öffnen, da wir hier ein paar Dinge ergänzen werden. Die erste Änderung wird hier gemacht:

var addNewStuff = Game_Battler.prototype.initMembers;

Game_Battler.prototype.initMembers = function() {

addNewStuff.call(this);

this._steal = false;

this._bombs = 0;

};

Verändert hat sich das nun soweit, dass wir eine weitere Variable hinzugefügt haben, welche sich this._bombs nennt. Dies werden wir dann dafür her nehmen, damit wir verfolgen können, wieviele Bomben platziert wurden. Da wir das nun haben, benötigen wir noch 3 Methoden.

1. Einmal eine Methode um Bomben zu platzieren (addBombs(anzahl))
2. Einmal eine Methode um die Bomben auf 0 zu setzten (resetBombs())
3. Einmal eine Methode um heraus zu finden, wieviele Bomben platziert sind (bombs())

Legen wir diese 3 mal schnell an:

Game_Battler.prototype.bombs = function() {

return this._bombs;

};

Game_Battler.prototype.addBombs = function(value) {

this._bombs += value;

};

Game_Battler.prototype.resetBombs = function() {

this._bombs = 0;

};

Nun haben wir unsere 3 Methoden angelegt, welche uns helfen, dass wir nun diesen Skill umsetzten können. Deswegen würde ich sagen: Legen wir los!

Ausführung

Beginnen wir einmal mit dem Grundgerüst für diesen Skill. Wir erstellen einen Skill, den wir zum Beispiel Bomben legen Einzeln nennen, welcher nur auf einen Gegner anwendbar ist. Bei der Schadensformel geben wir dann folgendes an:
bombenLegen(a, b)

In unserem "Plugin" werden wir uns nun diese Funktion ebenfalls anlegen.

function bombenLegen(a, b) {

};

Mit dieser einfachen Zeile beginnen wir nun zu arbeiten. Wir wollen nun den Zähler um 1 erhöhen und dann eine Nachricht ausgeben, dass eine Bombe platziert wurde. Ebenso wollen wir eine Nachricht ausgeben, die besagt, wieviele Bomben bereits platziert sind. Beginnen wir also:

b.addBombs(1);

BattleManager._logWindow.addText(a.name() + " platziert eine Bombe in der Nähe von " + b.name());

Hier haben wir nun den Zähler vom Ziel um 1 erhöht. Ebenfalls haben wir zuerst einmal eine Nachricht ausgegeben, dass der Anwender beim Ziel eine Bombe platziert hat. Jetzt fehlt nur noch eine Nachricht, die besagt wieiviele Bomben nun beim Ziel sind. Da es im deutschen einen kleinen Unterschied gibt zwischen "Beim Ziel liegt eine Bombe" und "Beim Ziel liegen 2 Bomben", brauchen wir noch eine kleine Abfrage, der Schönheit wegen.

if (b.bombs() == 1) {

BattleManager._logWindow.addText("Derzeit wurde eine Bombe bei " + b.name() + " platziert.");

} else {

BattleManager._logWindow.addText("Derzeit sind " + b.bombs() + " Bomben bei " + b.name() + " platziert.");

};

Hier prüfen wir nun, ob das Ziel genau eine Bombe hat. Sofern dies zutrifft, wird explizit der Text für die Einzahl verwendet, ansonsten der für die Mehrzahl.

Im gesamten sieht diese Funktion dann so aus:

function bombenLegen(a, b) {

b.addBombs(1);

BattleManager._logWindow.addText(a.name() + " platziert eine Bombe in der Nähe von " + b.name());

if (b.bombs() == 1) {

BattleManager._logWindow.addText("Derzeit wurde eine Bombe bei " + b.name() + " platziert.");

} else {

BattleManager._logWindow.addText("Derzeit sind " + b.bombs() + " Bomben bei " + b.name() + " platziert.");

};

};

Zusätzliche Information

Wenn man diesen Skill anwendbar auf alle Gegner macht, so wird der Text so oft angezeigt, wie Gegner am Bildschirm sind, man muss also im Grunde nichts ändern. Man sollte das nur dabei beachten.

Bitte nicht wundern, wenn der Skill eingesetzt wird, erhaltet man immer wieder die Meldung, dass der Gegner keinen Schaden erhalten hat. Dies liegt daran, dass durch die Schadensformel ein Schaden erwartet wird. Wenn wir bei dem Skill nur platzieren und nicht Schaden machen, dann ist das leider nicht anders lösbar mit der Schadensformel. Dieser Skill kann theoretisch auch per Common Event umgesetzt werden, ist jedoch weitaus schwieriger das gezielt auf einzelne Ziele zu machen. Daher empfehle ich hier minimal Schaden mitzugeben, weil man dem Gegner die Bomben entgegenwirft, da könnt Ihr kreativ sein.

Bomben zünden Skill

Spezifikation

Wir haben nun einen Skill, mit dem wir Bomben legen können, nun brauchen wir noch einen Skill, mit dem wir diese auch zum Explodieren bringen können sollten. Deswegen werden wir nun einen Skill erstellen, welcher beim Verwenden alle Bomben beim Ziel zum explodieren bringt. Der Schaden soll dabei pro Bombe erhöht werden (zB. 1 Bombe macht 50 Schaden und so würden dann 2 Bomben 100 machen). Es soll auch gesagt werden, wieviele Bomben gezündet werden.

Ausführung

Beginnen wir beim Skill in der Datenbank selbst. Wir erstellen einen Skill und schreiben bei der Schadensformel dann folgendes rein:

dmg = bombenExplodieren(a, b, 50); dmg;

Dies sieht nun etwas anders aus als sonst. Wir haben hier noch zusätzlich den Wert 50 dabei stehen. Damit kann man verschiedene Skills machen, mit denen man die Bomben zünden kann, die dann eventuell einfach besser Funktionieren und daher mehr Schaden verursachen. Da ist eurer Fantasie freien Lauf gelassen. Zurück aber zum Tutorial. Wir wollen nun diese Funktion auch in unserer Schadensformel.js hinzufügen.

function bombenExplodieren(a, b, base) {

};

Wir haben nun den Grundstein gelegt, welchen wir im nächsten Schritt ausfüllen werden und damit das ganze funktionsfähig wird. Lasst uns den Schaden berechnen und den Text ausgeben, so wie die Bomben wieder auf 0 zurück setzten.

dmg = base * b.bombs();

BattleManager._logWindow.addText(a.name() + " zündet alle " + b.bombs() + " Bomben bei " + b.name());

b.resetBombs();

return dmg;

Zuerst wird einmal der Schaden an sich berechnet, indem wir die übergebene Variable base mit der Anzahl der platzierten Bomben multiplizieren. Danach geben wir den Text aus, wieviele Bomben explodiert sind. Jetzt müssen wir nur noch die Bomben zurück setzten und den Schaden übergeben, was mit return dmg; passiert.

Das war die große Hexerei dahinter. Hier noch einmal die gesamte Funktion auf einen Blick:

function bombenExplodieren(a, b, base) {

dmg = base * b.bombs();

BattleManager._logWindow.addText(a.name() + " zündet alle " + b.bombs() + " Bomben bei " + b.name());

b.resetBombs();

return dmg;

};

Zusätzliche Information

Wenn der Skill nicht nur auf ein Ziel angewendet wird, sondern auf alle, wird der Schaden für jedes Ziel einzeln gerechnet und die Nachricht wird dann ebenfalls mehrmals angezeigt.

Abschluss

Ich bin nun zum Schluss des Tutorials gekommen. Ich hoffe es ist noch immer recht verständlich für euch, da ich mir recht viele Gedanken dazu gemacht habe. Es gibt bei den ganzen Skills die hier heute vorgestellt wurden, noch immer Luft nach oben. Vor allem beim Stehlen Skill kann man noch so viel mehr machen, als das was gezeigt wurde von mir. Da kann man noch viel komplexer werden und auch verschiedene Items geben, bzw. auch Waffen & Rüstung ausgeben. Jedoch würde das mehr am Tutorial selbst vorbei gehen.

Ich habe auch etwas JavaScript mit rein gepackt, da wir ohne diese kleinen Zusätze, die Skills erst gar nicht realisieren konnten. Ich habe ein paar Befehle nicht genauer erklärt, stehe da aber gern Rede und Antwort bei Fragen. Falls Ihr noch weitere Ideen für Skills habt, gebt bescheid und wir können das dann in eines der beiden Tutorials einarbeiten.

Ich hoffe es hat euch im Großen und Ganzen gefallen. Das Plugin für die Damage Formeln befinden sich im Anhang in der .zip-Datei. Auf dieser könnt Ihr auch gern aufbauen und in eurem Projekt verwenden.

Lyon Seit dem RPG Maker MV ist es auch von Haus aus im Maker eingebaut. Dieser wird meist dann angezeigt, wenn der Rechner auf dem Gespielt wird, nicht ganz so stark ist.

Ist recht praktisch, da man früher immer mit einem schwarzen Screen konfrontiert war und nicht wusste, wird nun geladen, oder nicht.

Werd ich dir im nächsten Tutorial einbauen. Ist je nach dem, wie man es haben will, recht simpel oder sehr komplex. Werde da dann beide Versionen thematisieren.

Sonst noch Wünsche? Du oder jemand anderer?

Kojote ja, irgendwie quälen sich da gerade viele durch

Kommt also recht passend irgendwie

Lyon ja das ist durchaus Möglich, man benötigt aber ein paar kleine Tricks und Kniffe dafür. Soll es immer die selbe Anzahl sein? also zB. 3 Bomben legen und beim 4ten Mal sprengt es den Gegner mit massivem Schaden? Oder willst du vielleicht 2 Skills/ein Skill und ein Item machen, bei dem du das Item x-mal platzierst und dann beim Verwenden des Skills jagst du entsprechend den gelegten Bomben alle Gegner/einen Gegner hoch? Beides möglich. 😬

Hallo,

das freut mich, dass es so gut ankommt. 😁

Baxeda ja, es ist klein. Es wirkt so groß, weil halt viel Erklärungen dabei sind, aber man kann noch so viel mehr da rein bauen. Ich werde in den nächsten Tagen ein weiteres Tutorial zu Schadensformeln raus bringen, in dem weitere Dinge beleuchtet werden und man noch mehr Kontrolle über den Schaden hat.

Lyon passt ja perfekt! Jetzt hast schon mal einige Grundlagen, die man verwenden kann!

Coucassi Das freut mich zu hören, ich hoffe nur du verrenst dich da dann nicht auch so wie ich damals. x)

Es ist halt sehr vielfältig nutzbar, was einem nie gesagt wird, warum auch immer.

@IanZarewitsch ich kenne mich hier bei den Schadensformeln aich nur deswegen so gut aus, weil ich selbst mal ein Script (zu VXAce Zeiten) genutzt hatte um verrückte Schadensberechnungen durchzuführen. Mit der Zeit hatte ich gemerkt, dass das Script gar nicht mehr macht als die Schadensformel aus dem Script an die Stelle zu übergeben, an der man sonst die Schadensformel aus der Datenbank erhält. Von da an begann ich mich durch ausprobieren an alles ran zu tasten. Inzwischen gibt es vermutlich kaum eine Schadensformel, die ich nicht hin bekommen würde.

ChimaereJade bitte gern, ist noch der Anfang, wie bereits gesagt, kommt da nochmal ein Tutorial dazu, welches noch mehr Themen abdeckt.

Allgemein:

Falls also jemand Wünsche zu bestimmten Effekten (Pokemon Attacken, Attacken aus anderen Spielen oder sonstiges) hat, immer her damit. Ich bereite in der Zwischenzeit die Fortsetzung vor und werde dort noch ein paar schöne Spielereien präsentieren.

lg

Willkommen zu diesem kleinen aber feinen Tutorial.

Ich werde heute mit euch einmal ein paar Grundlagen zur Schadensberechnung machen und ebenfalls einen etwas fortgeschrittenen Einstieg, was da eigentlich alles möglich ist. Seit gespannt, was man eigentlich mit der Grundfunktion im Maker anrichten kann. Dieser Kurs kann im Grunde ab dem RPG Maker VX Ace verwendet werden, jedoch konzentriere ich mich hier jetzt auf den RPG Maker MZ, weswegen einige Befehle im VX Ace bzw. im MV anders heißen könnten, oder entweder nicht existieren oder über Umwege erreichbar sind. Falls da Fragen sind, könnt Ihr mich gern hier im Tutorial oder per PN fragen und ich helfe euch gern weiter!

Einleitung

Wir kennen es alle; Wir haben uns einen Skill überlegt, der extrem mächtig sein soll, aber wir wissen einfach nicht so recht wie wir das umsetzten können und wie sehr uns hier eventuell "Out of the Box" bereits zur Verfügung steht. Denn sind wir uns einmal ehrlich, wer kann den wirklich dieser Box zutrauen, so mächtig zu sein.

Grundlagen

Was sehen wir am Screenshot?

pasted-from-clipboard.png
Wir haben hier beim Typ, den HP-Schaden eingestellt, also fügen wir auch den HP Schaden zu. Als Element haben wir einen Normalen Angriff, also im Grunde ist es ohne ein Element.

Die Formel zur Berechnung des Schadens ist a.atk * 4 - b.def * 2. Darauf werde ich in Kürze weiter drauf eingehen.

Die Abweichung beträgt 20%, was bedeutet, wenn unser errechneter Treffer 100 ergibt, kann dieser Wert +/- 20 Schaden machen. Heißt mindestens 80 Schaden und Maximal 120.

Den Kritischen Treffer haben wir mit Ja bestätigt, was dazu führt, dass es möglich ist, mit dem Angriff einen Kritschen Treffer zu erzielen und dadurch mehr Schaden austeilen.

Wie wird die Formel aufgebaut?

Die Formel beinhaltet auf jeden Fall einmal 2 wichtige Komponenten, auf die wir immer Acht geben müssen! a und b. Doch was bedeuten diese beiden Buchstaben?

Kurz erklärt: a ist der Anwender und b das BAngriffsziel.

Wenn wir uns die Schadensformel nochmal ansehen, heißt das also:

a.atk = Angriffskraft des Anwenders

b.def = Verteidigung des Angriffsziel.

Also heißt die Formel jetzt dieses: Angriffskraft des Anwenders * 4 und davon ziehen wir dann die Verteidigung des Angriffsziel * 2.

Wenn wir jetzt sagen, unsere Angriffskraft ist 25 und die Verteidigung des Ziels wäre ebenfalls 25, somit würde die Rechnung so aussehen:
25 * 4 - 25 * 2 = 50 Schaden.

Was kann alles bei a und b angegeben werden?

Einiges. Da geht echt viel. Ich habe hier mal eine kleine Auflistung, was alles geht, ohne dass ich jetzt tiefer in die Materie rein gehe:

Es gibt auch noch spezielle Parameter, welche jedoch in % Angezeigt werden im Maker, jedoch im Maker anders gespeichert sind. Grundsätzlich sind diese Werte immer als Floatingpoint Zahlen gespeichert. Das heißt, diese Zahlen sind Dezimalzahlen im Gegensatz zu den voran gegangenen Werten, welche Integer sind, was für Ganzzahlen steht.

Wenn der Maker sagt, dass etwas 90% ist, dann liegt der Wert im Hintergrund bei 0.9. Ist etwas bei zum Beispiel 110%, so wird dies im Maker mit 1.1 abgebildet.

Folgende Werte sind rein als Prozentzahlen vorhanden und können ebenfalls in der Schadensformel verwendet werden:

Doch was fangen wir nun mit diesen Informationen an? Gute Frage, jetzt bauen wir uns eine erste komplexere Schadensformel.

Fortgeschrittene Schadensformeln

Legen wir nun einmal fest, was wir genau machen wollen.

Wir wollen die Attacke Psychoschlag aus Pokemon nachbauen. Es ist ein Angriff, der die spezielle Angriffskraft nimmt und anstelle der speziellen Verteidigung wird die physische Verteidigung verwendet. Der spezielle Angriff entspricht hier unserem magischen Angriff und die spezielle Verteidigung, der magischen Verteidigung. Somit würde die Formel dann wie folgt aussehen:

a.mat - b.def

Ich weiß, es heißt ja, fortgeschrittenere Schadensformeln, aber das war ja sehr einfach! Wo ist hier der Fortschritt? Dazu kommen wir jetzt; Wir erweitern diese Schadensformel so, dass der Angreifer seinen magischen Angriff zusätzlich durch seine magische Ausweichrate beeinflusst wird, während die Ausweichrate des Gegners die physische Verteidigung stärkt.

Die Formel würde nun so aussehen:
(a.mat + a.mat * a.mev) - (b.def + b.def * b.eva)

Schon sieht das ganze etwas interessanter aus.

Ein weiteres Beispiel, wie interessant man das ganze gestalten kann ist folgendes Beispiel:

Ich möchte gerne einen Skill erstellen, welcher Grundsätzlich immer 100 Schaden macht, jedoch wird der Angriff immer schwächer, je weniger HP der Anwender hat. Dies würde dann so aussehen:

100 * a.hp/a.mhp

Wenn wir jetzt diese Schadensformel verwenden und der Anwender zum Beispiel 33 HP hat, seine Max HP sind bei 101, somit würde das Ergebnis in der Klammer folgendes sein: 32.6732 periodisch. Somit würde der Schaden auch in einer Dezimalzahl enden, was wir jedoch nicht wollen und vom Maker selbst auch abgefangen wird.

Komplexe Schadensformeln

Dieser Bereich sollte wirklich nur dann erforscht werden, wenn man sich sicher ist, dass man mit all den vorhandenen Möglichkeiten seine individuellen Schadensformeln zu berechnen. Ich empfehle hier schon gewisse Tauchgänge in die Plugins gemacht zu haben und da ein kleines Grundverständnis zu besitzen. Ansonsten wird es etwas schwieriger, diese Punkte zu verstehen.

Was kann ich in eine Schadensformel alles packen?

Im Grunde geht alles, was man will. Diese eine Zeile für die Schadensformel ist im Grunde ein Eingabefeld für JavaScript Code. Es gibt ein paar kleine Ausnahmen, die man zwar rein schreiben kann, aber kein Ergebnis liefern bzw. den Schaden auf 0 setzen. Ein gutes Beispiel hierfür wäre Console.log();. Aber was wäre denn jetzt eine Möglichkeit, die ich in meiner Schadensformel machen könnte, das ich sonst nicht könnte?

Rückstoßschaden

Den meisten bekannt aus Pokemon, kann man sich relativ Simpel eine Fähigkeit bauen, die Rückstoßschaden ermöglicht. Sagen wir mal, wir haben einen Angriff, dessen Formel ist a.atk * 4 - b.def * 2 und wir wollen hier nun einen Rückstoßschaden von 33% des verursachten Schadens. Die Varianz stellen wir hier nun auf 0%, denn wir werden diese ebenfalls in der Formel hinzufügen. Wir nehmen eine Varianz von 20%. Die Schadensformel werden wir als dmg bezeichnen, die Varianz wird mit vari betitelt und der Rückstoßschaden wird als rss bezeichnet werden. Nun würde die Formel wie folgt aussehen:

vari = ((20 - Math.floor(Math.random()*41))/100.0); dmg = a.atk * 4 - b.def * 2; dmg = Math.floor(dmg * (1.0 + vari)); rss = Math.floor(dmg * 0.33); a.setHp(a.hp - rss); dmg;

Was zum Henker ist den jetzt hier passiert? Wo sind meine einfachen Formeln hin gekommen? Warum um Himmels willen, sollte man sich so eine Arbeit antun? Ganz einfach, weil es einfach schön ist, wenn die Schadensformeln nicht einfach nur einfache A - B Formeln sind, sondern einiges an Komplexität aufweisen. Nun aber mal der Reihe nach. Ich werde euch nun aufschlüsseln, was dieses Monster bedeutet.

Varianz

vari = ((20 - Math.floor(Math.random()*41))/100.0);

Hier wird die Varianz berechnet. Das machen wir deshalb, weil wir ja gerne vom Schaden den Rückstoß wissen wollen. Wenn wir die Varianz aus der Datenbank nehmen, so wird das hier leider nicht berücksichtigt, so aber schon. Wir wollten eine Varianz von 20% haben, was bedeutet +/- 20%. So nun aber zur Aufschlüsselung:

vari = dient uns als Variable, in der wir den Wert zwischenspeichern wollen.

Math.floor(arg) dient uns dazu, dass wir aus einer Dezimalzahl eine Ganzzahl machen. Es wird hierbei immer abgerundet auf die nächste ganze Zahl.

Math.random()*41 dient uns dazu, dass wir eine Zufallszahl erhalten. Math.random() liefert eine Zahl zwischen 0 und <1. Wir multiplizieren das Ergebnis mit 41, damit wir eine Zahl zwischen 0 und 40 erhalten. Dies ist wichtig, da wir ja eine Varianz von +/- 20 haben wollen, weswegen dann das Ergebnis von 20 abgezogen wird. Hätten wir mit 40 Multipliziert, so wäre das Ergebnis eine Zahl zwischen 0 und 39.

/100.0 dient uns dazu, um aus dem Ergebnis das wir in der Rechnung erhalten, eine Dezimalzahl zu machen, welche uns beim weiterrechnen hilft. die Zahl wird dann zwischen -0.2 und 0.2 liegen.

Schadensformel

dmg = a.atk * 4 - b.def * 2

Hier haben wir unsere recht simple Schadensformel vom Anfang aus dem Bild. Ich glaube ich muss hier nichts erklären. Das dmg = ist wie vari, lediglich eine Variable zum zwischenspeichern des Wertes.

Schadensberechnung inkl. Varianz

dmg = Math.floor(dmg * (1.0 + vari))

Hier wird nun die Varianz in den Schaden mit einbezogen.

dmg = wird erneut verwendet, da wir dieser Variable nun einen neuen Wert zuweisen wollen.

Math.floor(arg) kennen wir ja bereits.

dmg * sieht wohl etwas verwirrend aus. Wir wollen ja der Variable dmg einen neuen Wert geben, jedoch verwenden wir es in der Zuweisung selbst? Richtig, dadurch können wir den bisherigen Wert verwenden und das Ergebnis neu zuweisen.

(1.0 + vari) wird für die Multiplikation zur Variable dmg verwendet. Hier wird zu den 1.0 die Varianz hinzugerechnet. Mathematisch gesehen ergibt ja + und + ein +, hingegen + und - ja bei - bleiben. Unabhängig vom Ergebnis bei vari, wird zu der 1.0 entweder +0.2 gerechnet oder -0.2. Dadurch wird das Ergebnis (0.8 bis 1.2) mit dem errechneten Schaden multipliziert und ergibt dann das Ergebnis inkl. Varianz. Einfach, oder?

Rückstoßschaden berechnen

rss = Math.floor(dmg * 0.33)

Mit diesem Teil wird nun der Rückstoßschaden bestimmt. Wir hatten ja gesagt, dass dieser 33% des erteilten Schadens entspricht, weswegen wir schon von Haus aus mit 0.33 gerechnet haben.

rss = ist eine weitere Zuweisung zu einer Variable die wir in dieser Formel etwas später benötigen werden.

Math.floor(arg) verfolgt uns auch schon in dieser Auflistung.

dmg * 0.33 habe ich bereits in der Einleitung erklärt, aber es nimmt hier nun den Schaden aus dmg, welcher die Schadensformel + Varianz bereits beinhaltet und wird nun mit 0.33 multipliziert um zum Rückstoßschaden zu gelangen.

Rückstoß abziehen und dem Gegner Schaden zufügen

a.setHp(a.hp - rss); dmg;

In diesem Abschnitt, wird dem Anwender nun endlich der Rückstoßschaden zugefügt und der Gegner erhält seinen Schaden.

a.setHp(arg); ist unser großer Helfer hier. Dieser setzt die aktuellen HP auf den in den Klammern befindlichen Wert.

a.hp - rss berechnet uns die neuen HP des Anwenders. Hier wird mit rss der Rückstoßschaden von den aktuellen HP abgezogen und als Ergebnis dann über den Befehl a.setHp(args) als neue HP verwendet.

dmg; Dies ist das letzte Glied in unserer Schadensformel, weswegen auch dies angibt, wieviel Schaden verursacht wird. Hier ist es zum Beispiel der Wert, welcher in der Variable dmg steht.

Zusammenfassung zum Rückstoßschaden

Wenn wir nun das Ganze zusammenfassen, steckt dahinter eigentlich sehr viel was im Hintergrund berechnet wird, nur um am Schluss dann am Bildschirm zB. die Zahl 100 steht und dem Helden 33 HP abgezogen werden. Es veranschaulicht aber auch in meinen Augen perfekt, wie man etwas so Bekanntes einfach nachstellen kann, ohne zwingend ein Plugin dafür verwenden zu müssen. Man ist damit auch um einiges flexibler als eventuell mit einem Plugin.

Praktisch bei dieser Übung war es auch, den Umgang mit Math.floor() und Math.random() zu lernen. Diese beiden Funktionen gehen beim RPG Maker gerne Hand in Hand, vor allem wenn man Berechnungen mit Zufallszahlen anstellen will. Wichtig ist hier auch immer, dass man bei Math.random() nicht vergisst, dass das Ergebnis eine Zahl zwischen 0 und <1 ist. Wenn man dann zum Beispiel eine Zahl zwischen 0 und 10 haben will, dass man dann mit 11 Multiplizieren muss. Will man ein Ergebnis zwischen 1 und 10, so wäre folgendes der richtige Weg:

Math.floor(Math.random() * 10) + 1

Dadurch erhält man ein Ergebnis zwischen 0 und 9 und mit dem + 1 wird es dann natürlich auf ein Ergebnis zwischen 1 und 10 erhöht.

Abfrage in einer Schadensformel

Dieser Punkt ist ein sehr praktischer, aber auch sehr fortgeschrittener Punkt. Man kann in eine Schadensformel auch eine Abfrage packen. Es gibt hierfür 2 Möglichkeiten, wie dies stattfinden kann. Doch dazu kommen wir gleich. Zuerst wollen wir einmal unseren Anwendungsfall definieren.

Wir wollen einen Angriff starten, welcher 100 Schaden macht. Hat der Anwender den Status mit der ID 10, so macht der Angriff 200 Schaden. Hat der Anwender den Status 11, so macht dieser Angriff 50 Schaden.

Wie sieht die Formel hierfür aus?

Verschiedene Versionen

Version 1

if (a.isStateAffected(10)) { dmg = 200;} else if (a.isStateAffected(11)) { dmg = 50;} else { dmg = 100;}; dmg;

Version 2

a.isStateAffected(10) ? 200 : a.isStateAffected(11) ? 50 :100

Ich persönlich empfehle grundsätzlich immer Version 1, da hier weniger Fehler gemacht werden können. Ich finde es aber dennoch wichtig, dass man Version 2 auch kennt. Beide bewirken das selbe, unterscheiden sich jedoch am Aufbau. Beleuchten wir diese genauer.

Aufschlüssselung Version 1

Wenn wir dies nun in einem Plugin schreiben würden, dann würde es so aussehen:

if (a.isStateAffected(10)) {

  dmg = 200;

} else if (a.isStateAffected(11)) {

  dmg = 50;

} else {

  dmg = 100;

};

dmg;

Sieht um einiges besser aus, als die vorherige Version, stimmts? Ist auch bei weitem Leserlicher als zuvor. Deswegen empfehle ich auch diese Schreibweise, weil man es auf diese Art und Weise zurecht schreiben kann und dann lediglich nur mehr die Zeilen dazwischen löschen muss.

a.isStateAffected(StateId) gibt uns einen boolschen Wert zurück. Dieser Wert kann entweder Wahr oder Falsch sein. Anhand dessen wird auch weiter verfahren. Wir haben hier eine Verkettung von 2 If-Abfragen. Wenn eine der beiden zutrifft, wird der entsprechende Punkt ausgeführt, der dafür steht, falls beide nicht Zutreffen, wird das else ausgeführt. Schlussendlich wird der dmg ausgeteilt.

Aufschlüsselung Version 2

Es ist etwas redundant diesen Punkt erneut aufzuschlüsseln, deswegen kommt eine kurze Erklärung zum Syntax.

Der Syntax baut sich im Grunde so auf:

Prüfung ? Wenn Ja : Wenn Nein

Es sieht simpel aus. Wichtig hier ist jedoch, dass man das ganze Richtig aufbaut. Im Vergleich zu Version 1, sieht diese Version sehr kompakt aus und eher wie die Arbeit eines Profis. Lasst euch davon nicht blenden, geht den sicheren Weg von Version 1, bis ihr nicht sattelfest seid und dann könnt ihr immer noch auf Version 2 umsteigen.

Tipps von Profis für Anfänger und Fortgeschrittene

Ich habe hier zwei kleine Tipps an euch, mit denen ihr euch viel Übersicht verschaffen könnt. Ich werde euch nicht großartig auf die Folter spannen.

Unendlich Platz mit einer besseren Übersicht

Dies ist ein Geheimtipp unter all den Entwicklern, die selbst viele komplexe Schadensformeln schreiben. Erstellt eine .js-Datei und nennt diese zum Beispiel "Schadensformeln.js" und fügt diese in euer Projekt ein und setzt das Plugin auf aktiv. Jedes Mal, wenn ihr eine neue Schadensformel anlegen wollt, erstellt ihr eine neue Methode mit dem Skillnamen in euerer "Schadensformeln.js" an. Die Methode sollte dann so aussehen:
var schadensformelName = function(a, b) {

  var dmg;

  // code;

  return dmg;

};

In die Schadensformel beim Reiter Skill schreibt ihr dann einfach nur mehr folgendes:

schadensformelName(a, b)

Dadurch wird dann einfach die Methode aus eurem Plugin aufgerufen und es wird die Schadensformel berechnet und ausgegeben. Der Grund warum wir a und b übergeben wollen, ist jener, damit wir mit der Schadensformel auch wirklich rechnen können. Ihr könnt dann in eurer Schadensformel anstelle von a und b andere Bezeichnungen wählen. Dazu müssten nur die Übergabe-Parameter in der function() umbenannt werden. Ich würde sogar zu Beginn folgendes empfehlen:

var schadensformelName = function(anwender, ziel) {

  var dmg;

  // code;

  return dmg;

};

In der Einabe zur Scahdensformel im Reiter Skill muss es trotzdem bei schadensformelName(a, b) bleiben.

Euer großer Gewinn daraus?
Die ganzen Schadensformeln sind an einem Ort. Ihr könnt schnell nachsehen, wie man zum Beispiel bei Skill 4 die Schadensformel aufgebaut hat, weil man was ähnliches bei Skill 16 nun ebenfalls will. So muss man nun nicht mehr zwischen den beiden Skills immer wieder hin und her hüpfen, sondern hat alles auf einem Blick. Beim VX Ace war dies zusätzlich noch ein wichtiger Punkt: Keine Zeichenbeschränkung. Ich weiß jetzt nicht genau wie lang das Feld beim MV und beim MZ ist, jedoch deutlich länger als beim VX Ace.

Wo man das Wissen noch Anwenden kann

Bei den Items. Im Grunde überall, wo man eine Schadensformel angeben kann. Es ist extrem praktisch. Man kann dadurch so viele komplexe Formeln aufbauen.

Was man alles in der Schadensformel einbauen kann

Man kann die Anzahl an Mitglieder mit einfügen, nahezu alles. Ich bin bis jetzt noch nie vor einem Punkt gestanden und wusste nicht, wie ich diesen einbinde. Wenn man sich in einem Editor (Notepad++ kann ich empfehlen) die rpg_objects.js öffnet und etwas durchsucht, kann man sehr viele Dinge abfragen. Wenn man Spieler/Gegnerspezifische Dinge abfragen will, sollte man sich etwas an die Klassen Game_Actor, Game_Actors, Game_Battler, Game_BattlerBase sowie Game_Enemy halten. Diese halten alle Werte, die Helden und Monster haben. Man kann auch andere Dinge einbinden, wie zum Beispiel, wenn man mehr Schaden machen will, je mehr Partymitglieder man hat. Dies ist alles Möglich, es sind kaum Grenzen gesetzt.

Abschluss

Abschließend möchte ich gerne Sagen, dass ich euch jederzeit zur Verfügung stehe und euch gerne helfe bei der Ausarbeitung von Schadensformeln. Es gibt so viele Möglichkeiten die einem dadurch eröffnet werden, die man dann auch Nutzen sollte.

Falls es gewünscht wird, kann ich auch noch ein weiteres Tutorial schreiben, in dem ich in noch komplexere Schadensformeln eintauche und diese euch Erkläre. Falls Ihr hierzu Beispiele/Wünsche habt, die ich behandeln soll, immer her damit.

Somit sage ich zum abschließenden Abschluss, vielen Dank für eure Zeit, dies hier zu lesen. Ich hoffe es ist verständlich genug. Ich werde es auch weiterhin immer wieder etwas ausarbeiten und auch Fehler verbessern. Alle Formeln die ich in diesem Tutorial angegeben habe, die funktionieren zu 100% in einem frischen RPG Maker MZ Projekt.

Liebe Grüße,
Flipely

such mal nach Wordwrapper für MZ. Die Berechnen die Breite des Fensters und passen so den Text an das ganze an. Eventuell gibt es da auch die Möglichkeit, die du suchst

wenn du den nur sterben lassen willst, dann brauchst du das c = a.hp nicht, es reicht lediglich aus, den State 1 hinzuzufügen. bei den 20 Schaden kann man theoretisch den ; weglassen. Das letzte Statement was da dann schlussendlich steht, gibt den Schadenswert zurück.

Ich werde bei Gelegenheit mal ein kleines Tutorial zu den Damage-Formulas machen. Da kann man ohne Plugins default mäßig schon extrem viel machen seit der Einführung im Ace.

Die einfachste Version wäre folgende:

a.changeHp(-amount); deine damage formel

wenn du zum Beispiel aber das ganze etwas komplexer haben willst wie zB 10% des verursachten Schadens, dann würde das zB so aussehen:

dmg = damage formel; a.setHp(a.hp-(dmg/10)); dmg

das kann man im Grunde ewig erweitern. Es sind auch if abfragen möglich

Hast du das Tileset für eine Map ausgewählt, hast die Map offen und änderst es dann in der Datenbank?

Wenn ja, dann müsste es reichen auf eine andere Map zu klicken, dass die Änderung in der Auswahl übernommen wird.

Falls nein, dann bin ich selbst überfragt.

nicht wirklich, der Code in der Mesaagebox würde ein Plugin benötigen, welches drn Textboxbefehl auch wieder interpretieren müsste, das entsprechende File dann laden und anzeigen. Könnte auch ein Stück langsamer sein, als mit Show Picture.

Man müsste wissen, wieviele Personen reden und ob alle gleichzeitig angezeogt werden sollen, oder nicht.

Ich hatte schonmal ein Projekt so aufgebaut. Das werde ich bei Zeit mal vorstellen. Im Grunde war das eine einzige Map, auf der ich per Show Picture den Hintergrund angezeigt hatte, was immer Picture ID 1 hatte.

Dann wurden die IDs für Busts vergeben, wobei ich da eigentlich nie mehr als glaub 3 oder 4 Busts zeitgleich anzeigen ließ. Die waren dann eben entsprechend Picture ID 41 bis 44.

War nicht ganz so viel Aufwand, wie man zuerst glauben würde.

Im Grunde ist das eigentlich nur ein Show Picture Befehl, bevor die Message aufgerufen wird.

Je nach dem, was man noch haben will, wirds halt etwas ausgeschweifter 😬

Der einzig wahre Fehler!

Ich kann dir da einiges erzählen, wo ich mich zum Glück richtig Entschieden hatte oder aber auch von Momenten, an denen ich dann auch sage, dass war dumm. Das ganze auch relativ gut anhand von 2 Spielen von mir.

Einmal anhand von Schicksal -Stubenhocker. Hier hatte ich mich damals etwas an ein großes Storyepos gerangewagt, dass ich schon länger geplant hatte. Ich wollte damit einmal das gesamte Konzept dem Spieler vorstellen und hatte das ganze etwas zu hektisch aufgebaut und einige Storyelemente sehr bescheiden eingebaut. Heutzutage würde ich das definitiv anders machen, auch weil sich die gesamte Story inzwischen stark gewandelt hat.

Bei Schicksal - Weltenspringer muss ich sagen, dass ich in vielen Punkten alles richtig gemacht hatte, jedoch wollte ich nach 2 Jahren Entwicklung auch endlich mal eine Demo präsentieren, bei der dann vieles nicht ganz gelungen war. Ich hatze hier etwas die Testberichte der Tester ignoriert und nur das nötigste gefixt und dadurch halt viel Potential verschenkt und damit das Spiel schlechter wirken lassen, als es eigentlich sein hätte sollen.

Inzwischen plane ich alles sehr genau und baue daher eher selten neue Feature ein. Mir hilft es auch, wenn ich meine Gedanken wo festhalten kann. Mein Google Drive ist größtenteils komplett voll mit Spielideen, die vermutlich nie umgesetzt werden, auch wenn diese teilweise sehr weit ausgearbeitet sind.

Ich empfehle dir, auch wie coucassi sagte, schreibs dir auf und denk nicht dran. Du merkst selbst irgendwann, ob das Spiel das Feature dann braucht oder nicht. Meistens merkt man dann eh, dass man es eh nicht braucht.

Falls du mal testen willst, ob ein Feature in deinem Projekt funktionieren könnte, rate ich dir ein Testprojekt zu haben, welches genau wie dein aktuelles Projekt ist. Dann baust du es dort ein und testest dich durch. Später muss man lediglich die fertigen Sachen ins Originalprojekt kopieren. Falls es nicht klappt, muss man im Hauptprojekt nicht unnötig lange alles dann wieder zurück basteln. Zusätzlich bleibt das Testprojekt auch immer am aktuellen Stand, wenn man da ständig hin und her kopiert.

lg Flip

Ich persönlich mag Screenshot 14 extrem gern! Den von Nummer 3 finde ich persönlich überhaupt nicht passend für eine Verkaufsseite, wäre eher was für ein Video oder als gif, aber als Bild wirkt es einfach nicht gut.

Zur zweiten Frage, ich mag Stilbrüche in Spielen nicht. Mir gefällt das ehrlich gesagt überhauptnicht. Man kann zwar drüber hinwegsehen, aber wenns dann immer wieder passiert, dann würde ich das Spiel vermutlich irgendwann abbrechen. Bin da aber witzigerweise lockerer eingestellt, wenn es um die Klassiker aus der Szene geht. 🙈

Jop, ist ein extrem mächtiges Tool, welches ich gern nutze.

Ist aber leider sehr unbekannt und wird auch in den meisten Mapping Tutorials nicht erwähnt, weil die Leute das entweder selbst nicht kennen, oder (wie bei mir manchmal) davon ausgehen, die Leute wissen das eh.