Beiträge von Hamrath im Thema „BASIC und Assembler mischen“

    Als ich vor einiger Zeit mein vor 31 Jahren angefangenes Spielprojekt wieder aufgenommen hatte, kam auch ich ins Grübeln und war im Begriff, abtrünnig zu werden. Nach ausgiebiger Beobachtung der 8bit-Religionsgemeinschaft und der überschwemmten PC-Spiele-Welt kam ich zum Schluss, dass ein Wechsel Quatsch wäre und mir nichts bringt - anderen im Verhältnis zur User-Masse auch nicht.

    Bei einem Wechsel versteh ich das. Aber hier geht es ja um eine Neuentwicklung. Natürlich wäre auch es auch möglich, das komplett auf dem C64 zu entwickeln. Ich hab mir gestern das Bitte melde dich an, um diesen Link zu sehen. angeschaut. Das hat sich viel Inspiration bei Ultima IV geholt, aber die Entwickler wollten ein Spiel mit den Features eines heutigen Spiels machen. So hat es ein Tutorial und alle Dialoge und Infos werden in Fenstern angezeigt. Das fand ich schon sehr spannend, denn so in etwa war von Anfang auch meine Intention: ein Oldschool-RPG mit heutigen Gamedesign-"Komfort"-Funktionen, im Stil eben von Ultima, DDD oder den Goldbox-Spielen. Am PC kann ich mich da anders austoben, es aber trotzdem so oldschoolig wie möglich aussehen und funktionieren lassen. Das würde bspw. auch bedeuten, dass ich (nach aktuellem Stand) auf eine reine Tastatur-Steuerung setze und auf Maus oder Gamepad verzichten möchte. Dem C64-Gedanken möchte ich aber nicht ganz abschwören. Ein Prequel oder Prolog könnte man gut in 8bit umsetzen.


    Ich hab mich im Rahmen meiner Recherche auch mal in Foren und auf Twitter umgehört. Interesse gibt es an solchen Spielen auf jeden Fall, die Zielgruppe oder User-Masse an sich ist nicht so gering.

    Btw: Nox Archaist kann man auch auf Steam kaufen, da wird es dann in einem Emulator ausgeführt.

    @M. J. Danke für die ausführliche Beschreibung. DDD ist tatsächlich eine Inspiration für mich. Die Spieleprogrammierung ist mir nicht neu, auch wenn ich so ein großes Spielprojekt noch nicht umgesetzt habe. Es ist allerdings ein Herzensprojekt, an dessen Konzept ich schon länger feile.

    Ich bin mir aber nicht wirklich sicher, ob ich daraus wirklich ein C64-Projekt machen möchte. Meine Assembler-Kenntnisse sind okay-ish, aber ich glaube, mit etwas Übung (und Fragerei hier) würde ich das schon hinkriegen. Meine Eingangsfragen waren aber eher theoretischer Natur, da ich mich wirklich schon öfter gefragt habe, wie solche Spiele umgesetzt wurden.

    Ich werde die Idee aber wohl - auch nach den hilfreichen Antworten hier - eher auf dem PC umsetzen. Aussehen und funktionieren soll es aber trotzdem wie DDD oder Ultima 4, denn das ist das Grundkonzept, bei dem ich mir 100% sicher bin.

    Bei einem Rollenspiel läuft es doch (auf dem C64) eher auf ein von "Raum" zu "Raum" gehen hinaus. Scrolling ist da eher wenig (also nix). Wobei es auch (wenige) andere Beispiele gibt (die mir vor dem Auge herumflattern aber wo mir der Name nicht einfällt). Das sind dann aber echte "Großprojekte". So ein von "Raum" zu "Raum" wollte ich mal für DSA umsetzen, das Wollen ist aber auch schon über 30 Jahre alt... :sad:

    Ach, so unmöglich ist das gar nicht. Das von mir bereits erwähnte Bitte melde dich an, um diesen Link zu sehen. ist in BASIC geschrieben und eher ein Ultima-Clone. Ein anderes Beispiel ist Bitte melde dich an, um diesen Link zu sehen., bediente sich offensichtlich auch am Runen-Zaubersystem von DSA Pro. Und als nächstes fällt mir noch Bitte melde dich an, um diesen Link zu sehen. ein. Da gibt es tatsächlich schon ein paar, die eine relativ große Oberwelt haben über die man sich per Scrolling bewegt.

    Mit einer Mischung aus Basic und Assembler läßt sich sehr viel erreichen. Für viele Spiele wie Rollenspiele, Adventures oder Strategiespiele ist diese Kombination auch ausreichend. Jedoch stellt sie eine große Gefahr dar: Man unterliegt schnell der Versuchung, immer mehr Routinen nach Assembler zu verlagern, bis man vor der Frage steht, ob man überhaupt noch Basic verwenden soll. ^^

    Tatsächlich geht es mir auch um Rollenspiele. Deshalb hatte ich bspw. "Die Dunkle Dimension" in meinem Eingangspost erwähnt. So etwas würde ich gerne bauen. Ich hab mir in den vergangenen Wochen einige alte DSA-Boxen in der Bucht geschossen, um mich inspirieren zu lassen. Und auf Twitter wurde ich dann scherzhaft gefragt, warum ich das nicht für den C64 mache. Aktuell wüsste ich aber null, wie ich das umsetzen soll, gerade was das Scrolling oder die Map-Daten angeht. Deshalb wollte ich mal die Forum64-Schwarmintelligenz nutzen.

    Berufsprogrammierer [...]

    Na danke. :P Bin halt bloß Webentwickler. :D Aber da ich weder am C64 beruflich programmiert habe und ich denke, dass auch bei vielen Indiegame-Entwicklern die Planung (anfangs) hinten an steht, ist mein Punkt schon valide.

    Aber beim Rest hab ich mir gedacht, dass das so gemacht wurde. Ich hatte auch überlegt, dass ich erstmal schaue, welche Assembler-Routinen ich brauchen könnte. Da fand ich den Hinweis von detlef mit den JMP-Listen schon sehr hilfreich.

    Ich habe meine Programme früher auf 2-3 Extra Dateien aufgeteilt, die nachgeladen werden.

    z.b. Zeichensatz Scrolling (für wasser) als IRQ , Ein Bildschirmscrolling , Extra Zeichensatz & Die Spieldaten (Map)

    Waren das zufällig Rollenspiele? Klingt gerade so.

    Wenn ich eine Assembler-Bibliothek schreibe und die verschiedenen Routinen über SYS-Befehle ausführe, was passiert, wenn ich einen Bug in der Bibliothek habe? Dann verschieben sich die ganzen Routinen und ich darf den Quellcode nach SYS-Befehlen durchsuchen und den Code verändern. Alternativ könnte ich für diese Routinen Blöcke im Speicher reservieren, so dass bspw. für jede Routine 256 Byte zur Verfügung stehen - oder weniger oder mehr - je nach Routine. Dann hätte ich am Ende eine Memory-Map, wo diese Befehle liegen und damit eine Liste von SYS-Befehlen, die ich verwenden kann.

    In dem Fall würde ich eine Sprungleiste an den Anfang deiner Assemblerroutinen legen. Die bleibt dann von Basic aus gesehen unverändert.

    Oh, du meinst, dass ich an den Anfang der Assembler-Bibliothek eine Menge JMPs packe, die dann auf die eigentliche Routine springen? Und dann muss ich nur noch SYS49152, SYS49155, SYS49158, etc. nutzen?

    Eine typische Möglichkeit war, dass man jede Menge DATA Zeilen hatte die dann per Poke in den entsprechenden Bereich geschrieben wurden. Die Adresse $C000... bietet sich ganz gut für Assemblerroutinen an.

    Das funktioniert aber nur bei kurzen Assembler-Routinen. Ansonsten wird das ziemlich lange dauern. :)

    Schau mal bei Pirates rein, das dürfte einige Fragen beantworten.

    Bitte melde dich an, um diesen Link zu sehen.

    Hab ich schon. Und ich hab mir auch das Bitte melde dich an, um diesen Link zu sehen. angeschaut, wo er den Quellcode zeigt und Stellen daraus erklärt. Da sieht man auch SYS-Befehle, also lieg ich nicht so verkehrt. Aber ich seh das gerade aus Planungs- und Optimierungssicht und da fällt mir mindestens ein Problem bei auf:

    Wenn ich eine Assembler-Bibliothek schreibe und die verschiedenen Routinen über SYS-Befehle ausführe, was passiert, wenn ich einen Bug in der Bibliothek habe? Dann verschieben sich die ganzen Routinen und ich darf den Quellcode nach SYS-Befehlen durchsuchen und den Code verändern. Alternativ könnte ich für diese Routinen Blöcke im Speicher reservieren, so dass bspw. für jede Routine 256 Byte zur Verfügung stehen - oder weniger oder mehr - je nach Routine. Dann hätte ich am Ende eine Memory-Map, wo diese Befehle liegen und damit eine Liste von SYS-Befehlen, die ich verwenden kann.

    Ich finde es gerade sehr anstrengend so ein Programm zu planen. Heute programmiert man einfach drauf los und schaut, was am Ende rauskommt. Bei einem reinen BASIC- oder Assembler-Programm stell ich mir das auch recht einfach vor - in der Planung wohlgemerkt. Aber sobald ich beides mische, seh ich da einen echt großen Aufwand - oder ich denke irgendwas falsch.

    Moin,

    ich frage mich schon länger, wie man früher in Spielen BASIC und Assembler gemischt hat, bspw. in Pirates!, Rings of Medusa, Spirit of Adventure oder Die Dunkle Dimension - also Spielen, wo ein großer Teil der Spielelogik wirklich in BASIC geschrieben war, die Spiele aber nicht so aussahen. Meine Idee wäre:

    • Es gibt einen Assembler-Teil mit verschiedenen Routinen, die über SYS-Befehle aufgerufen werden.
    • Dieser Assembler-Teil wird am Anfang des BASIC-Programms über LOAD geladen.

    Daraus ergeben sich aber einige Fragen für mich:

    1. Wie bindet man Schriftarten, Sprites, etc. ein? Das läuft wahrscheinlich über die Assembler-Routinen, nehm ich an?
    2. Wird der BASIC-Speicher dadurch nicht extrem klein?
    3. Hat man ggf. mehrere BASIC-Programme die je nach Bedarf geladen und ausgeführt werden?
    4. Wird für so etwas auch ein BASIC-Compiler eingesetzt?

    Vielen Dank schonmal für eure Antworten.