spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Hallo liebe Community,

heute möchte ich euch mein aktuelles Projekt vorstellen.

Zu mir:

Aber erst einmal einige Infos zu meiner Person. Ich bin Henrik, 20 Jahre alt, und Kaufmann für Versicherungen- und Finanzen.
Ich beschäftige mich schon seit einigen Jahren, mal mehr und mal weniger intensiv, mit den Thema Programmierung. Um etwas genauer zu werden, seit meinem 13 Lebensjahr. Angefangen hat alles mit einfachem HTML, gefolgt von VisualBasic und Java. Hier habe ich mich erst mit Programmierung von Mods beschäftigt, und dann ein eigenes, sehr sehr kleines Rundenbasiertes 2D-"Kampfspiel" programmiert. Danach habe ich mich wieder verstärkt mit HTML und auch PHP und SQL beschäftigt, und hier auch an einem Browsergame mitgewirkt. Das Projekt wurde leider vor Release eingestellt, da ein Großteil der Entwickler abgesprungen ist. Zwischendurch habe ich in VisualBasic noch ein kleines Tarifierungs-Tool für die Firma in der ich arbeite geschrieben. Nun beschäftige ich mich seit einiger Zeit mit C++.

Zum Idee

Das Projekt ist bereits in vollem Gange.

Wie dem Arbeitstitel eventuell bereits zu entnehme ist, handelt es sich um ein von Jump'n'Run's inspiriertes 2D-Spielprinzip.
Der Spieler streift durch zufällig generierte Höhlen und Dungeons auf welcher er von schräg-oben schaut. Eine Karten besteht dabei aus mehreren Höhlensystemen welche Stockwerke darstellen und somit verbunden sind. Pro Karte soll der Spieler, je nach Schwierigkeit und Level, zwischen 10 und 60 Minuten brauchen.

Das Spielprinzip besteht darin, den Aufstieg aus dem Höhlensystem zu schaffen, und dabei möglichst viel Geld und Erfahrungspunkte zu sammeln. Dabei machen dem Spieler verschiedenste Gegner und Aufgaben das Leben schwer. In Mitten eines Höhlensystem kann das Spiel zwar pausiert, aber nicht gespeichert werden.

Mit den gesammelten Erfahrungspunkten lassen sich die Eigenschaften des Charakters verbessern. Mit den verdienten Münzen lässt sich das Design des Charakters verändern, sowie die Generierung von Maps beeinflussen.

Ihr fragt euch nun sicher, wo sich hier das Jump'n'Run versteckt. Dies sei ganz einfach beantwortet. Es wird lediglich einige für dieses Genre typische Aspekte und Mechanismen geben. Zum einen die Möglichkeit Sprünge und Doppelsprünge auszuführen. Außerdem soll das besiegen von Gegnern ausschließlich durch hinaufspringen auf diese geschehen. Im weiteren Verlauf sollen dann auch Items verwendet werden können, welche die Spielfigur kurzzeitig stärken.

Zur Umsetzung

Die Umsetzung erfolgt zur Zeit in Eigenarbeit. Ich nutze also meine Freizeit um die Programmierung vorzunehmen. Später will ich auch die Grafiken, Töne und Musik selbst erstellen. Dies ist zwar ein hartes Stück Arbeit, welche sich aber durch einen hohen Lernfaktor lohnen wird.

Die Umsetzung erfolgt in C++ mit dem SFML Framkework.

So ist der aktuelle Stand

Ich habe die SFML-Bibliotheken eingerichtet und ein grobes Grundgerüst für das Framework geschrieben.

Anschließend habe ich mir überlegt, wie die einzelnen Level / Karten aufgebaut sein sollen und bin zu folgenden Schluss gekommen: Map -> MapLayer -> MapCoordinate Wobei die Map mehrere Layer, also Stockwerke, enthält. Das Layer wiederum enthält ein zweidiemensionales Array, welches die Objekte vom Typ MapCoordinate speichert. Dieses Objekt wiederum enthält diverse Informationen über den enstprechenden Kartenpunkt, z.B. Typ des Untergrundes und eventuelle Sonderfunktionen. Dieses Objekt-Konstrukt habe ich bereits komplett geschrieben.

Nun habe ich damit begonnen, die zufällige Generierung der Karten zu programmieren. Diese hat vorerst den Stand, dass die Außengrenzen mit Wänden abgesteckt werden.

Zu Kontrollzwecken habe ich außerdem eine Methode geschrieben, welche die Maps Layer für Layer als png-Schemata ausgibt. Dies einfach aus dem Grund, schon in diesem Entwicklungsstadium kontrollieren zu können ob und wie die Kartengenerierung funktioniert.

Was kommt nun?

Als nächstes muss die Funktion zur Ausgabe der MapLayer überarbeitet werden, da sich hier ein kleiner Fehler mit dem Zugriff auf die Objekte eingeschlichen hat. Die Änderung der Informationen der MapCoordinate-Objekte erfolgt in einer Kopie, wobei der Zugriff dann aus dem Original-Objekt erfolgt. Da es sich hier um ein Problem handelt, welches das gesamte Objekt betreffen wird, hat dieses höchste Priorität. Der Fehler wird sicherlich bei einem Zeige liegen, aber dazu mehr, wenn der Fehler behoben ist.

Sobald dieser Arbeitsschritt vollendet ist, werde ich an der Generierung der Map weiterschreiben. Hierzu ein kleines Konzeptblatt:



Hier ist folgendes zu sehen:
Zuerst wird die Karte vermessen und ein Zufallspunkt vergeben. Nun wird ein Raum in zufälliger Größe um diesem Punkt erstellt. Dies erfolgt in Schleife so lange, bis ca. 30 bis 55 % der Karte mit Räumen gefüllt sind. Wie dann eine Verbindung der Räume mit Wegen erfolgt wird sich zeigen.

Ich werde euch auf jeden Fall auf dem laufenden halten.

Konstruktive Kritik oder Verbesserungsvorschläge lese ich gerne.

Freundliche Grüße

Henrik

Vielen Dank für den Hinweis. Ich habe den Beitrag entsprechend bearbeitet.

Guten Morgen,

wie bereits im Eingangspost geschrieben, habe ich mich gestern mit einigen Problemen auseinandersetzen müssen.

Die Fehler, welche beim Nutzen der verschiedenen Variablen meiner Kartenpunkte auftauchten, konnte ich mit Hilfe zweier Forum-Nutzer beheben. Durch löschen der Kopierkonstruktoren meiner Klassen habe ich den Fehler finden und beheben können. Dafür noch einmal Danke.

Später habe ich angefangen die Generierung der Räume zu implementieren. Da hier viele Random-Werte zu trage kommen, habe ich mir zur Erstellung von diesen eine kleine Funktion geschrieben. So kann ich den Code übersichtlicher halten.

Die erste Ausgabe einer Map sah wie folgt aus:



Nachdem diverse folgende Generierungen ein ähnliches Ergebnis ausgaben, musste ich meinen Code verändern.
Ich habe also ein wenig mit den Startpunkten der Raum-Generierung gespielt und die Minimal- und Maximalwerte der Random-Abfrage geändert, um die einzelnen Räume mittiger zu positionieren.



Wie ihr seht, sind die Räume zwar nun mittiger, aber in einen einzigen großen Raum verschmolzen.
Diesem konnte ich etwas entgegenwirken, in dem ich die einzelnen Raumstrukturen verfeinert habe.



Nun sind die Räume zwar etwas feiner, aber immer noch gebündelt.

Dies zu verhindern werde ich heute Abend versuchen. Zu diesem zweck habe ich mir die Maps als Raster ausgeben lassen, um herauszufinden, wie genau die Layer überlappen.



Dies ist der aktuelle Stand der Programmierung. Ich werde euch natürlich weiter auf dem Laufenden halten.

Grüße

Henrik

Bearbeitungsstand: Update 3

Hallo Leute,

nachdem ich am gestrigen Abend noch diverse Konfigurationen an der Raum-Generierung bin ich zu dem Stand gekommen, dass der jetzige Algorithmus nicht flexibel genug ist. Aus diesem Grunde habe ich mir vorgenommen, noch einmal von Grund auf mit diesem anzufangen.

Aus Frust habe ich zwischendurch noch eine Klasse geschrieben, welche es erlaubt einfach zwischen mehreren Spielsprachen zu wechseln.
Diese enthält die Texte als Variablen in verschiedenen Sprachen, sowie die Methoden zum Ändern der Sprachoption.

Heute morgen nun habe ich mich an ein neues Konzept zur Raum-Generierung gemacht, und dazu erst einmal etwas recherchiert.
Entstanden ist folgendes Konzeptblatt, welches mir allerdings nur als Gedankenstütze sowie Überlegung dient.



Im ersten Abschnitt ist die zufällige Positionierung des ersten Raumes zu sehen. Im zweiten Abschnitt würde der nächste Raum korrekt hinzugefügt werden. in Teil drei sind vier Kollisionen vorhanden, sowie ein korrekter Raum.

Ich will nun also prüfen, ob sich zwei Räume berühren, und dabei einen Abstand von einem "Block" lassen.

Hierzu speichere ich folgende Daten. BeginnX (x1), EndeX (x2), BeginnY (y1) und EndeY (y2) aller vorhandenen Räume. Hierzu dient ein mehrdimensionales Array. Zudem ermittele ich die o.g. Werte Ebenfalls von dem neu hinzuzufügenden Objekt.

Der Übersicht halber übergebe ich diese nun ich eine Funktion welche einen Boolean an Rückgabewert besitzt, welcher ausdrückt, ob eine Kollsision vorhanden wäre.

Diese könnte wie folgt aussehen (noch nicht getestet)



Wie gesagt, ob das so klappt weiß ich nicht, das wird sich heute Abend zeigen.

Henrik

Gestern hatte ich leider weder viel Zeit, noch große Erfolge.

Die neue Funktion ist implementiert, und wirft auch keine Fehler aus.

Wie man allerdings an folgendem Ergebnis unschwer erkennen kann:



Ist hier irgendetwas schief gelaufen.

Ich vermute einen Flüchtigkeitsfehler beim Vergleich der Variablen, welchen ich aber erst im laufe des Abends suchen kann.

Henrik

Da hier keine Höhenverschiebungen vorhanden sind, sehe ich aktuell keinen Grund, warum eine Map nicht schaffbar sein sollte.

Die Generierung der Karte ist mit dem aktuellen Stand noch nicht beendet. Es folgen noch Gänge, sowie spezielle Felder mit Funktionen.

So sieht es aus.

Der Slogan "Jump 'n' Run der anderen Art" stellt mehr eine Anspielung oder Provokation dar. Es werden Akzente dieses Genres gesetzt werden, das Spielprinzip ist aber ein anderes.

Wenn ich ein klassisches Jump 'n' Run schreiben wollen würde, würde ich die Level-Generierung ganz anders angehen, und von unten nach oben generieren.