Beiträge von Zia

Total verständlich, danke dir! Es ist zumindest ein Ansatz, an dem ich noch rumprobieren kann.

Um die 20 kommt hin. Ich kann nachher noch mal zählen, gerade habe ich schon wieder was umgebaut.

Das Problem ist, dass man bei den Versuchen häufig zwischen "Keine Auswirkung" und "Crash beim Szenenwechsel" pendelt. Letzteres könnte darauf hindeuten, dass die Elemente tatsächlich entfernt sind, muss aber nicht. Ich vermute, dass die Listener in dem Fall zum Crash führen, weil sie nicht finden, wonach sie suchen, und das schon in dem Frame, in dem der destroy stattfindet. Ich versuche, ihnen beizubringen, nicht in Panik zu geraten, wenn sie ein Element nicht finden ... Das neue HUD wird sofort im Anschluss generiert.

Ansonsten wäre natürlich toll, wenn es grundsätzlich nur eine Instanz des HUDs erzeugen würde und jedes Mal überschreibt/ergänzt, falls was fehlt, statt alles komplett neu anzulegen. Das HUD ist auf jeder Map identisch, da es sowieso alle Komponenten enthält.

Zitat von Grandro

...

Danke dir für deine Zeit!

Ich schaue mir das direkt mal an.

EDIT:

Ich habe es in 3 Varianten versucht, mit:

destroy(true);

destroy({ children: true });

destroy({ children: true, texture: true, baseTexture: true });

an allen relevanten Destroy-Positionen, aber leider scheint das keinen Unterschied zu machen. Die Elemente werden nicht entfernt.

Zitat von DaiRex

Ist vielleicht nicht die ultimative Lösung, dennoch vielleicht eine Idee.

Ich nutze zum Beispiel zur Bearbeitung von Plugins und Modifikationen Chatgpt 4o. Vielleicht kann dir die KI helfen.

Das hab ich schon versucht, aber die Gesamtheit des Codes ist wohl leider zu komplex. Oder ich konnte ihn nicht ausreichend anleiten.

Hallo zusammen,

in letzter Zeit habe ich zunehmend Memory Leaks in meinem Spiel festgestellt, und schließlich HUD Maker Ultra als Ursache identifiziert.

Ich habe mich jetzt einige Tage mit dem Code beschäftigt und alles mögliche versucht. Aber meine Fähigkeiten reichen leider nicht, um einen funktionierenden Fix hinzubekommen.

Falls jemand mit besseren JavaScript-Kenntnissen helfen möchte, dieses Plugin zu "retten", wäre ich wirklich dankbar.

Leider hat der Autor den Support eingestellt und reagiert seit Jahren nicht mehr auf Anfragen. Ich weiß, es ist super undankbar, die Arbeit anderer Leute zu fixen, aber dieses Plugin ist enorm mächtig.

Und - das zumindest muss man sagen - es ist sehr übersichtlich strukturiert und man findet sich thematisch gut zurecht.

Kurz gesagt ist es ein Plugin, das mit einem externen Editor kommt. Darin kann man HUDs gestalten, mit so ziemlich allem, was man sich nur vorstellen kann. Füllbalken, Bilder, Formen, Custom Code und individuellen Bedingungen für jedes Element. Das alles wird in eine Json-Datei exportiert, die wiederum vom Plugin interpretiert wird. Bis dahin wirklich beeindruckend.

Problematisch ist allerdings, wie das HUD gehandhabt wird. Bei jedem Szenenwechsel (z.B. Mapwechsel), wird das komplette HUD neu in den Cache geladen. Alle Elemente, Sprites, Bitmaps, etc. liegen unsichtbar im Hintergrund und warten darauf, dass ihre Conditions erfüllt werden. Das Problem dabei ist, dass die alten Instanzen des HUDs nicht entfernt werden. Wenn ich über 50 Teleporter laufe, habe ich also 50x das komplette Asset-Paket im Speicher. Binnen weniger Minuten kann ich den RAM überlaufen lassen, wenn ich es darauf anlege. Ohne das Plugin ist der RAM stabil niedrig.

Im Code sind diverse destroy()-Befehle platziert, die aber entweder nur den Code zum Initialisieren der HUD-Instanzen entfernt, oder aber dem Autor war nicht bewusst, dass andere Komponenten des Plugins die Sprites am Leben halten, da sie noch darauf referenzieren.

Das Plugin besteht aus zwei Files: SRD_HUDMakerUltra.js und SRD_UltraBase.js

Im SRD_HUDMakerUltra.js werden die HUD-Elemente erzeugt.

Im SRD_UltraBase.js befinden sich Listener, die in jedem Frame kommunizieren, ob die Bedingungen erfüllt sind, und ob die HUD-Elemente sichtbar werden müssen.

Diese Listener sind bei meinen Versuchen immer das Problem.

Mal verhindern sie, dass die Elemente aus dem Cache geleert werden, weil sie noch damit kommunizieren, und mal crasht das Spiel, weil die HUD-Elemente nicht mehr da sind, um zu kommunizieren.

Ich weiß nicht, was die beste Lösung wäre.

Mein letzter Versuch (ebenfalls nicht erfolgreich) war, den Szenenwechsel zu modifizieren. Sodass er im Grunde so abläuft:

1. Stoppe alle Listener, kappe alle Verbindungen zu den HUD-Elementen

2. Zerstöre alle HUD-Elemente, gib den Speicher frei

3. Führe den Teleport durch (oder was auch immer für die neue HUD-Instanz verantwortlich ist)

4. Generiere ein neues HUD im Hintergrund

5. Reaktiviere die Listener

Falls jemand einen Blick riskieren will, SRD_HUDMakerUltra.js und SRD_UltraBase.js sind hier zu finden:

HUDMakerUltra/SRD_HUDMakerUltra.js at main · SumRndmDde/HUDMakerUltra

Page dedicated to updating and distributing HUD Maker Ultra. - SumRndmDde/HUDMakerUltra

github.com

Vielen Dank im Voraus für jede Form von Unterstützung.

Danke dir!

Fürs erste nutze ich nun Galvs Timed Message Popup für den MV.

MV Timed Message Popups

FEATURES Display popup messages on the screen or over characters. These messages do not prevent player movement and last for a specified amount of time before…

galvs-scripts.com

Mit FOSSIL ist es MZ-fähig.

Leider gibt es ein paar Dinge, die nicht optimal sind.

* Der Text erscheint sofort, statt Buchstabe für Buchstabe (damit erübrigt sich dann auch Text-Sound).

* Die Sprechblase ragt aus dem Bild, wenn ich am Bildrand entlanglaufe. Galvs Messagestyles z.B. verschiebt die Sprechblase entsprechend, sodass sie nie außerhalb des Bildes ist.

* Eine MZ-Lösung ohne FOSSIL wäre natürlich schön.

Falls also jemand noch eine Idee hat, wäre ich weiterhin sehr dankbar.

Zitat von Firemaster640

ich kann natürlich nur von der Coding Seite es sagen, es müsste Funktionieren zusammen mit Galv seinen Plugins, wenn die erste Variante verwendet wird.

Ja, das dachte ich mir auch. Sein Plugin modifiziert die Optik der Textbox, erweist sich aber als sehr kompatibel.

Mit deinem Vorschlag wird das angehängte \pop[x] als Flag aber leider ignoriert. Es ist eine ganz normale Textbox, während der ich mich aber auch nicht bewegen kann. Sie verhält sich ganz normal, wie vom Maker selbst getriggert.

Danke für euren Input!

Zion: Ja, genau, ich habe den MZ.

Es gibt den SideChatter von VisuStella. Aber da ich die Sprechblasen von Galv nutze, wäre es schade, wenn diese Texte dann irgendwo am Bildrand erscheinen. Dadurch benutze ich auch eigentlich keine Facesets oder Namen zur Zuordnung.

Aber stimmt, es wäre eine Notfalllösung.

MurdockMurphy: Geht es dabei nur um statische, sprechende NPCs, wie z.B. Shop-Besitzer, die sagen "Schau dir meine Waren an", wenn man vorbeiläuft?

Firemaster640: Manuelle Textboxen sind schon ein bisschen Kopfschmerz, glaube ich. Bei einem ersten Test habe ich es nicht geschafft, dass der Galv-Message-Style angewendet wird, wenn man die Parameter an diesen Text hängt. Die Textboxen sind durch das Galv-Plugin als Sprechblasen konfiguriert, pointen auf den gewählten Sprecher und können ihm sogar folgen, während er sich bewegt.

Außerdem habe ich ein Plugin, das der Textbox einen Sprech-Sound hinzufügt, während Text geprintet wird. Das müsste alles integriert / nachempfunden werden.

Wenn es eine Lösung gäbe, dass man einer Textbox explizit sagen kann, dass sie einfach nicht sämtliche Prozesse stoppen soll ...

Hallo zusammen,

ich habe ein recht spezifisches Problem.

Es geht um ein Feature, das nenne ich mal "WalkingTexts". Während ich herumlaufe, reden meine Begleiter manchmal, indem eine Galv-Sprechblase über den Köpfen meiner Party erscheint. Die Textbox ist so konfiguriert, dass sie mit \^ automatisch schließt.

Normalerweise bleibt der Hero stehen, sobald eine Textbox aufgeht, daher habe ich ein kleines Plugin, mit dem ich per PluginCommand erlauben und verbieten kann, dass der Hero sich während einer offenen Textbox bewegen kann. Damit habe ich die WalkingTexts eingeklammert.

        ◆Plugin Command：AllowMovementWithOpenTextbox, Enable Movement During Messages
        ◆Text：None, None, Window, Middle
        ：    ：\v[607]\|\^\pop[a\v[606],-96]
        ◆Plugin Command：AllowMovementWithOpenTextbox, Disable Movement During Messages

Das Problem ist, dass "On Hero Touch"-Events nicht korrekt auslösen, solang eine Textbox offen ist.

Wenn diese Textbox innerhalb eines Autostarts o.ä. stattfindet, wird das "On Hero Touch"-Event komplett ignoriert. Ich kann also bspw. keine Items aufheben oder den Raum verlassen, solang jemand aus der Party redet.

Wenn ich die Textbox aus einem Parallel Process starten lasse, wird das "On Hero Touch"-Event getriggert, aber erst abgearbeitet, sobald die Textbox geschlossen ist. D.h., ich bin schon viele Schritte entfernt, und dann verschwindet das Item erst vom Boden, oder ich teleportiere in den anderen Raum.

Gibt es eine Möglichkeit, die Priorität der Textbox zu ändern, sodass das Spiel nicht alles stehen und liegen lässt, bis die Textbox wieder zu ist?

ChatGPT hat ein Update bekommen, auf die Version "4o", die deutlich komplexere Zusammenhänge auf die Reihe bekommt. Bisher war das Limit etwa bei 80 bis 120 Zeilen Code - alles, was an Komplexität darüber lag, hat er nicht mehr überblicken können. Oder anders ausgedrückt, er hat jedes Problem mit dieser Anzahl Zeilen zu lösen versucht, was je nach Komplexität einfach nicht geht.

Jetzt schafft er durchaus 400 Zeilen Code.

Als Test habe ich Schritt für Schritt mit ihm ein Debug-Menü aufgebaut, wie es hier im Thread thematisiert war.

* Das Menü ist komplett neu gebaut und nicht nur modifiziert. Es funktioniert im Grunde genauso wie vorher.

* Allerdings sind Switches und Variablen nun in getrennten Listen, sodass man nicht so viel scrollen muss. Mit Links/Rechts kann man umherschalten.

* PageUp rechnet nun +10, PageDown -10 auf Variablen. Ich verstehe bis heute nicht, warum das nativ im Maker umgekehrt ist.

* Wenn man das Menü schließt und wieder öffnet, bleibt die Position für beide Listen separat gespeichert. (Wenn man also auf Switch 600 und auf Variable 1000 war, dann ist man dort später wieder, wenn man erneut F9 drückt)

* Kommt mit Text in Variablen klar.

Was ich nicht hinbekommen habe, ist ein Eingabefeld für Variablen. Ich habe es zig mal versucht. Aber das überstieg dann die Kapazitäten von ChatGPT. Ich wollte gern, dass man den Wert manuell eintippen kann, wenn man auf eine Variable Enter drückt. Wenn jemand Lust hat, kann er das sehr gern ergänzen, würde mich freuen.

Falls außerdem jemand Lust hat, sich den Code mal auf Sinn und Redundanz anzuschauen, ebenfalls sehr gern. Ich frage mich nämlich, ob ChatGPT Probleme bei Iterationen wirklich im Kern behebt, oder nur Workaround um Workaround ergänzt, bis der Code am Ende irgendwie geht - aber eigentlich wäre es auch mit der Hälfte an Code gegangen. Oder ob er irgendwelche problematischen Mechaniken nutzt.

Und wer das Plugin einfach nur testen möchte, ebenfalls sehr gern.

/*:
 * @target MZ
 * @author Zia
 * @plugindesc Replaces the original F9 debug menu. Splits Switches and Variables into separate lists.
 * @help
 * Replaces the original F9 debug menu. 
 * Use Left / Right to switch between separate lists for Switches and Variables.
 *
 * ChatGPT was used to create this Plugin.
 */
(() => {
    const pluginName = "ImprovedDebugMenu";
    // Die neue Debug-Szene erstellen
    class Scene_CustomDebug extends Scene_MenuBase {
        create() {
            super.create();
            this.createCategoryWindow();
            this.createDetailWindow();
            this.createHelpWindow();
            this._categoryWindow.activate();
            this._categoryWindow.select($gameTemp._debugCategoryIndex || 0);
            this.updateDetailWindow();
        }

        terminate() {
            super.terminate();
            $gameTemp._debugCategoryIndex = this._categoryWindow.index();
            this.saveDetailWindowPosition();
        }

        start() {
            super.start();
            this._categoryWindow.select($gameTemp._debugCategoryIndex || 0);
            this.restoreDetailWindowPosition();
            this.updateDetailWindow(); // Sicherstellen, dass die Detailansicht aktualisiert wird
        }

        update() {
            super.update();
            if (Input.isTriggered('debug') && this._categoryWindow.active) {
                this.popScene();
            }
        }

        saveDetailWindowPosition() {
            if (this._categoryWindow._mode === 'switch') {
                $gameTemp._debugSwitchScrollPos = this._categoryWindow.topIndex();
                $gameTemp._debugSwitchIndex = this._categoryWindow.index();
            } else {
                $gameTemp._debugVariableScrollPos = this._categoryWindow.topIndex();
                $gameTemp._debugVariableIndex = this._categoryWindow.index();
            }
        }

        restoreDetailWindowPosition() {
            if (this._categoryWindow._mode === 'switch') {
                this._categoryWindow.select($gameTemp._debugSwitchIndex || 0);
                this._categoryWindow.setTopRow($gameTemp._debugSwitchScrollPos || 0);
            } else {
                this._categoryWindow.select($gameTemp._debugVariableIndex || 0);
                this._categoryWindow.setTopRow($gameTemp._debugVariableScrollPos || 0);
            }
        }

        createCategoryWindow() {
            const rect = new Rectangle(0, 0, 246, Graphics.boxHeight);
            this._categoryWindow = new Window_DebugCategory(rect);
            this._categoryWindow.setHandler('ok', this.onCategoryOk.bind(this));
            this._categoryWindow.setHandler('cancel', this.popScene.bind(this));
            this._categoryWindow.setHandler('select', this.updateDetailWindow.bind(this));
            this.addWindow(this._categoryWindow);
        }

        createDetailWindow() {
            const rect = new Rectangle(246, 0, Graphics.boxWidth - 246, Graphics.boxHeight - 100);
            this._detailWindow = new Window_DebugDetail(rect);
            this._detailWindow.setHandler('ok', this.onDetailOk.bind(this));
            this._detailWindow.setHandler('cancel', this.onDetailCancel.bind(this));
            this.addWindow(this._detailWindow);
            this._detailWindow.deactivate();
            this._detailWindow.deselect();
        }

        createHelpWindow() {
            const rect = new Rectangle(246, Graphics.boxHeight - 100, Graphics.boxWidth - 246, 100);
            this._helpWindow = new Window_Help(rect);
            this.addWindow(this._helpWindow);
        }

        onCategoryOk() {
            this._categoryWindow.deactivate();
            this._detailWindow.activate();
            this._detailWindow.select(0);
        }

        onDetailOk() {
            const index = this._detailWindow.index();
            const item = this._detailWindow.item(index);

            if (this._categoryWindow._mode === 'switch') {
                $gameSwitches.setValue(item.id, !$gameSwitches.value(item.id));
            }

            this.updateDetailWindow();
            this._detailWindow.activate();
        }

        onDetailCancel() {
            this._detailWindow.deactivate();
            this._detailWindow.deselect();
            this._categoryWindow.activate();
        }

        updateDetailWindow() {
            const index = this._categoryWindow.index();
            const start = index * 10 + 1;
            const end = Math.min(start + 9, this._categoryWindow._mode === 'switch' ? $dataSystem.switches.length - 1 : $dataSystem.variables.length - 1);
            const data = [];

            if (this._categoryWindow._mode === 'switch') {
                for (let i = start; i <= end; i++) {
                    const name = $dataSystem.switches[i] || '';
                    const status = $gameSwitches.value(i) ? '[ON]' : '[OFF]';
                    data.push({ id: i, name: name, status: status });
                }
            } else {
                for (let i = start; i <= end; i++) {
                    const name = $dataSystem.variables[i] || '';
                    const value = String($gameVariables.value(i));
                    data.push({ id: i, name: name, value: value });
                }
            }

            this._detailWindow.setData(data, this._categoryWindow._mode);
            this.updateHelpWindow();
        }

        updateHelpWindow() {
            if (this._categoryWindow._mode === 'variable') {
                this._helpWindow.setText("Left: -1      Right: +1      Page Down: -10      Page Up: +10");
            } else {
                this._helpWindow.clear();
            }
        }
    }

    // Fenster für die Kategorie (Switches und Variablen)
    class Window_DebugCategory extends Window_Selectable {
        initialize(rect) {
            super.initialize(rect);
            this._mode = 'switch';
            this.refresh();
        }

        maxItems() {
            if (this._mode === 'switch') {
                return Math.ceil(($dataSystem.switches.length - 1) / 10);
            } else {
                return Math.ceil(($dataSystem.variables.length - 1) / 10);
            }
        }

        refresh() {
            this.createContents();
            this.drawAllItems();
        }

        drawItem(index) {
            let start = index * 10 + 1;
            let end = Math.min(start + 9, this._mode === 'switch' ? $dataSystem.switches.length - 1 : $dataSystem.variables.length - 1);
            let text = this._mode === 'switch' ? `S [${start.padZero(4)} - ${end.padZero(4)}]` : `V [${start.padZero(4)} - ${end.padZero(4)}]`;
            let rect = this.itemRectWithPadding(index);
            this.drawText(text, rect.x, rect.y, rect.width, 'left');
        }

        cursorRight() {
            this.saveCurrentScrollPosition();
            this._mode = this._mode === 'switch' ? 'variable' : 'switch';
            this.restoreSavedScrollPosition();
            this.refresh();
            this.callHandler('select');
        }

        cursorLeft() {
            this.cursorRight();
        }

        saveCurrentScrollPosition() {
            if (this._mode === 'switch') {
                $gameTemp._debugSwitchScrollPos = this.topIndex();
                $gameTemp._debugSwitchIndex = this.index();
            } else {
                $gameTemp._debugVariableScrollPos = this.topIndex();
                $gameTemp._debugVariableIndex = this.index();
            }
        }

        restoreSavedScrollPosition() {
            if (this._mode === 'switch') {
                this.select(Math.min($gameTemp._debugSwitchIndex || 0, this.maxItems() - 1));
                this.setTopRow($gameTemp._debugSwitchScrollPos || 0);
            } else {
                this.select(Math.min($gameTemp._debugVariableIndex || 0, this.maxItems() - 1));
                this.setTopRow($gameTemp._debugVariableScrollPos || 0);
            }
        }

        cursorDown(wrap) {
            const lastIndex = this.maxItems() - 1;
            const nextIndex = this.index() + 1;
            if (nextIndex > lastIndex && wrap) {
                this.select(0);
                this.setTopRow(0);
            } else {
                super.cursorDown(false);
            }
            this.callHandler('select');
        }

        cursorUp(wrap) {
            const nextIndex = this.index() - 1;
            if (nextIndex < 0 && wrap) {
                const lastIndex = this.maxItems() - 1;
                this.select(lastIndex);
                this.setTopRow(this.maxTopRow());
            } else {
                super.cursorUp(false);
            }
            this.callHandler('select');
        }
    }

    // Fenster für die Detailansicht (Switches und Variablen)
    class Window_DebugDetail extends Window_Selectable {
        initialize(rect) {
            super.initialize(rect);
            this._data = [];
            this._mode = 'switch';
            this.refresh();
        }

        maxItems() {
            return this._data.length;
        }

        setData(data, mode) {
            this._data = data;
            this._mode = mode;
            this.refresh();
        }

        item(index) {
            return this._data[index];
        }

        refresh() {
            this.createContents();
            this.drawAllItems();
        }

        adjustTextSize(text, maxWidth) {
            const context = this.contents.context;
            let fontSize = this.contents.fontSize;
            while (context.measureText(text).width > maxWidth && fontSize > 8) {
                fontSize--;
                this.contents.fontSize = fontSize;
            }
            return fontSize;
        }

        drawItem(index) {
            const item = this._data[index];
            if (item) {
                const rect = this.itemRectWithPadding(index);
                const nameWidth = rect.width - 192; // Platz für 12 Zeichen + Puffer
                this.contents.fontSize = 28; // Setze die Schriftgröße zurück
                const adjustedFontSize = this.adjustTextSize(`${item.id.padZero(4)}: ${item.name}`, nameWidth);
                this.contents.fontSize = adjustedFontSize;
                this.drawText(`${item.id.padZero(4)}: ${item.name}`, rect.x, rect.y, nameWidth);

                if (this._mode === 'switch') {
                    this.drawText(item.status, rect.x + rect.width - 64, rect.y, 64, 'right');
                } else {
                    const valueWidth = rect.width - nameWidth;
                    this.contents.fontSize = 28; // Setze die Schriftgröße zurück
                    const adjustedFontSizeValue = this.adjustTextSize(item.value, valueWidth);
                    this.contents.fontSize = adjustedFontSizeValue;
                    this.drawText(item.value, rect.x + nameWidth, rect.y, valueWidth, 'right');
                }
            }
        }

        drawTextEx(text, x, y, width, align) {
            const textWidth = this.textWidthEx(text);
            const alignX = align === 'right' ? Math.max(x, x + width - textWidth) : x;
            this.drawText(text, alignX, y, width, 'left');
        }

        textWidthEx(text) {
            return this.textWidth(text);
        }

        processHandling() {
            if (this.active) {
                super.processHandling();
                if (this._mode === 'variable') {
                    if (Input.isRepeated('left')) {
                        this.processLeft();
                    }
                    if (Input.isRepeated('right')) {
                        this.processRight();
                    }
                    if (Input.isRepeated('pagedown')) {
                        this.processPagedown();
                    }
                    if (Input.isRepeated('pageup')) {
                        this.processPageup();
                    }
                }
            }
        }

        processLeft() {
            const index = this.index();
            this.updateVariableValue(index, -1);
        }

        processRight() {
            const index = this.index();
            this.updateVariableValue(index, 1);
        }

        processPagedown() {
            const index = this.index();
            this.updateVariableValue(index, -10);
        }

        processPageup() {
            const index = this.index();
            this.updateVariableValue(index, 10);
        }

        updateVariableValue(index, amount) {
            const item = this.item(index);
            if (!isNaN(Number($gameVariables.value(item.id)))) {
                const newValue = Number($gameVariables.value(item.id)) + amount;
                $gameVariables.setValue(item.id, newValue);
                this._data[index].value = String(newValue); // Aktualisiere den Wert in den Daten
                this.refresh(); // Neuzeichnen der gesamten Liste
                this.redrawItem(index); // Neuzeichnen des geänderten Items
            }
        }
    }

    // Fenster für die Hilfestellung
    class Window_Help extends Window_Base {
        initialize(rect) {
            super.initialize(rect);
            this.clear();
        }

        setText(text) {
            this.contents.clear();
            this.drawText(text, 0, 0, this.contentsWidth(), 'left');
        }

        clear() {
            this.contents.clear();
        }
    }

    // Überschreiben der Standard-F9-Funktionalität
    const _Scene_Map_updateCallDebug = Scene_Map.prototype.updateCallDebug;
    Scene_Map.prototype.updateCallDebug = function() {
        if (this.isDebugCalled()) {
            SceneManager.push(Scene_CustomDebug);
        } else {
            _Scene_Map_updateCallDebug.call(this);
        }
    };

    Scene_Map.prototype.isDebugCalled = function() {
        return Input.isTriggered('debug');
    };

    // Hilfsfunktion für das Padding von Zahlen
    Number.prototype.padZero = function(length) {
        return String(this).padStart(length, '0');
    };
})();

Ich habe den VisuStella-Debugger nun mal getestet und kann leider keine Empfehlung aussprechen.

Meine Anforderungen waren:

1. Nicht crashen, wenn Variablen Text statt Zahlen enthalten. ✔

Das klappt. Man kann den Text zwar nicht bearbeiten, aber das wäre auch nicht nötig. Aber man kann den gespeicherten Text einsehen und es stürzt nicht ab.

2. Eintippen der Variablen-Werte, statt hochklicken ✔

Man kann die gewünschten Zahlen direkt eintragen, das ist gut.

3. Schnellere Bedienung von Switches und Variablen ❌

Im Maker störte mich, dass Switches und Variablen hintereinander weg als eine Liste dargestellt werden. Dadurch scrollt man recht lange, bis man das Ziel erreicht hat.

Im VisuStella Debugger sind Switches und Variablen in separate Listen getrennt, das fand ich gut.

Leider scrollen diese Listen soooo langsam, dass man länger braucht als vorher.

Außerdem kann man vom Anfang der Liste nicht ans Ende springen und umgekehrt. Wenn man von Variable 1 zu Variable 1000 will, muss man also durch die Liste nach unten scrollen.

1000 Variablen zu scrollen dauert 1:50 Minuten.

Das geht einfach nicht ... Schade drum.

(Das Plugin bietet noch unzählige andere Funktionen, die bestimmt nützlich sind, aber für mich nicht wichtig. Daher habe ich mich damit nicht allzu sehr beschäftigt.)

Ich denke schon, seine "Master-Demo" hat er zuletzt am 13. Dezember 2023 aktualisiert, das ist nicht soo lang her.

Auf seiner Website kommentiert er Hilfegesuche auch noch.

Allerdings hauptsächlich mit "Frag am besten mal in einem Forum nach". Aber ob man noch neue Plugins erwarten kann, weiß ich nicht.

Edit:

Galv hat sich bedankt und freut sich, dass ich mein Problem lösen konnte. Er klang jetzt aber nicht so, als würde er da irgendwie aktiv werden.

Ich weiß aber auch nicht, ob das ein globales Problem ist, oder eher ein Sonderfall.

Gute Idee, werde ich machen.

Unter

Window_Message.prototype.changeWindowDimensions = function() {

werden die Fenstergrößen anhand der Textlänge berechnet, das passiert sowohl für X als auch für Y.

Da habe ich jeweils ans "Endergebnis" noch einen Check gehängt, ob die Zahl gerade ist.

        w = Math.ceil(w); // Aufrunden auf die nächste ganze Zahl
        if (w % 2 !== 0) w += 1; // Stelle sicher, dass die Breite gerade ist

und

        this.height = Math.ceil(this.height); // Aufrunden auf die nächste ganze Zahl
        if (this.height % 2 !== 0) this.height += 1; // Stelle sicher, dass die Höhe gerade ist

Das Runden auf eine ganze Zahl ist ziemlich sicher nicht notwendig, aber da ich nicht wusste, was genau das Problem ist, habe ich das auch noch drin.

Zitat von Zia

Noch mal ein neues Problem:

Manchmal haben meine Textboxen mit dem Galv-Plugin links eine Pixellinie. Man sieht es sowohl neben der Box als auch am Indikator.

Sicher fehlt dafür rechts eine Pixel-Spalte.

Es ist, als wäre das Systemset um einen Pixel verschoben.

Aber das ist nicht der Fall. Die Textboxen sind manchmal korrekt und manchmal nicht.

Als würde das Plugin manchmal beim Berechnen der Position oder der Breite einen 0,5-Wert rausbekommen.

Hat das schon mal jemand erlebt?

Alles anzeigen

Lustig, das scheint mein ganz privater Monolog-Thread zu sein.

Aber - ich habe die Ursache und Lösung für das zitierte Problem gefunden und wollte es hier noch ergänzen, falls jemand über das gleiche Problem stolpert.

Der MZ hat bei mir Schwierigkeiten, Bilder und Textboxen sauber darzustellen, wenn die Breite eine ungerade Pixelzahl hat. Dann rechnet er wohl mit halben Pixeln, wenn er versucht, den Mittelpunkt zu bestimmen oder so, keine Ahnung. Das Resultat sind halbtransparente Kanten sowie eine verschobene Window-Grafik, die zu diesen Linien geführt hat.

Ich habe das Galv-Plugin leicht angepasst, sodass nach dem Ermitteln der Textlänge und damit der Breite der Textbox, noch auf die nächste gerade Zahl aufgerundet wird. Damit ist das Problem weg, da alle Textboxen definitiv eine gerade Pixelanzahl in der Breite haben.

Danke euch, das sieht super aus!

Ich teste es direkt mal.

Edit:

Das Plugin scheint leider nicht mit dem MZ kompatibel zu sein.

Aber das Anpassen der index.html hat super geklappt. Vielen Dank!

Hallo zusammen,

wenn man das Spiel auf eine Größe zieht, die nicht der definierten Auflösung entspricht, hat man ja schwarze Balken an den Seiten.

Ist es möglich, mithilfe eines Plugins eine Grafik zu definieren, die diese schwarzen Flächen ausfüllt?

Dabei ist mir fast egal, ob man eine Textur kachelt, oder ob eine Art Wallpaper hinter dem Spiel liegt (wie damals, wenn man Gameboy-Spiele auf dem Fernseher gespielt hat). Bei letzterer Lösung könnte es natürlich sein, dass auch dieser Wallpaper irgendwann an seine Grenzen kommt und dann wieder Schwärze folgt, aber damit könnte ich leben.

Herausforderung ist, dass man nichts von den Zusatzgrafiken sieht, solang das Spielfenster die "richtige" Auflösung hat.

Meint ihr, das ist möglich? Gibt's da vielleicht ein Plugin für den MZ?

Sie ist echt toll geworden. Sehr kreativ und charakterstark umgesetzt.

Ich halte mich da auch an keinen Zeitplan. Bisher habe ich etwa 400 Stunden mit meinem Projekt zugebracht, und die liefen sehr gut.

Wenn es so den Rest des Jahres weitergeht, werde ich mit der Entwicklung viel Freude haben. Und dann mal gucken, wie weit das Projekt ist. Wenn es noch ein zweites oder ein drittes Jahr Entwicklung braucht, bekommt es die Zeit sehr gerne.

Meine Motivation war, mich mit dem Maker zu beschäftigen, daher habe ich jetzt schon was ich wollte. Der Release eines Tages wird ein wundervoller Bonus.

Zitat von TheRealFusion

Du darfst der Dame einen Namen geben

Rizz?

Irgendwie fühlt sich das richtig an.

Gefällt mir jetzt schon sehr