moin! Ich hab eine wichtige Frage.
Und zwar soll ih als Hausarbeit ein 6-eckiges Spielfeld erstellen, bei dem ein Feld alle seine sechs Nachbarn kennt. Das Spielfeld soll beim erstellen nur seine Kantenlänge kennen. Ich bin da schon ne ganze weile am grübeln und hab nach vielen Ansätzen keine Ahnung wie ich das hinbekomme. Pseudo Code wäre ne gute Hilfe, ansonsten hilt auch sonst jede Idee weiter.

Danke schonmal im vorraus!

_________________
Klar Soweit?

Hast du dir den Wikieintrag dazu schon angeschaut? Hexfeld

Gruß Lord Horazont

_________________
If you find any deadlinks, please send me a notification – Wenn du tote Links findest, sende mir eine Benachrichtigung.
current projects: ManiacLab; aioxmpp
zombofant network • my photostream
„Writing code is like writing poetry“ - source unknown

„Give a man a fish, and you feed him for a day. Teach a man to fish and you feed him for a lifetime. “ ~ A Chinese Proverb

ja hab ich, das Problem an dem Eintrag ist, das das Feld das dort beshrieben wird immernoch quadratish ist, trotz der 0,5 vershobenen Koordinaten. Das gesamte Spielfeld selbst soll auch in einem Sechseck liegen mit einer überall gleichen Kantenlänge. Dadurch kann ich das Feld schonmal nicht in einem 2d Array erzeugen.

_________________
Klar Soweit?

Nun ja. Also eine Art 2D Array wirst du so oder so haben müssen. Und da kannst du in einem quadratischen Feld entweder einzelnen Felder als "kein Spielfeld" kennzeichnen (wie auch immer das dann aussehen kann). Oder aber du machst ein Array wo jeder Eintrag wiederrum aus einem Array besteht. Und diese Unterarrays wären dann unterschiedlich groß. So, dass du nur die wirklichen Daten halten müsstest. Bei den Unterarrays könntest du dann noch ein Offset einbauen um diese Spielfeldreihe zu verschieben. Dass jede ungerade Zeile im Vergleich zur geraden Zeile um 0.5 verschoben ist ist sowieso klar.

Lossy hats schon angedeutet. In "Phase 2" mach ich das auch ähnlich, dort ist das Hexspielfeld rund und nicht mehr quadratisch, aber trotzdem in einem 2D-Array abgelegt. Hier hat jedes Hexfeld halt noch die Eigenschaft "valid", die auf False gesetzt wird wenn dieses ausserhalb der angepeilten Form liegt (also der kreisrunden Spielfläche). Das Feld wird dann einfach beim Rendern und der Spiellogik ignoriert.
Die Form des Spielfeldes spielt dann also eigentlich keine Rolle, beim Erstellen iteriert man halt über das komplette 2D-Array und schaut ob das Hexfeld noch in der gewünschten Form (in deinem Falle dann ein Hexagon) liegt oder nicht, und setzt dann obiges Flag.
Alternativ kann man das auch über den Stencilpuffer machen und so ausmarkieren, allerdings sollte man dies dann auch bei der Spiellogik (sprich Selektion, egal wie man die regelt) berücksichtigten.

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)

Ich hab erst versucht das ganze in Worten zu formulieren, aber das wäre noch aufwendiger gewesen.

Ich würde glaub ich mich vom 2D-Array entfernen und eine Klasse "THexField" erstellen die 6 Pointer auf die benachbarten Felder besitzt.
So kannst du jedem HexFeld eine position zum zeichnen geben und weißt auch welche Felder wie verbunden sind.

Dadurch kannst du dann jede erdenkliche form schaffen

Ja, das 2D-Array kann man dann darin überführen, aber wenn man das Zeichnen will wäre es dann bischen unpraktisch oder?

Wieso? Was wäre daran unpraktisch?
Alle HexFelder würde ich natürlich noch in nem normalen 1D-Array speichern, dann geht man einfach den Array durch und ruft von jedem HexFeld die Draw-Funktion auf.

Aya~

Hm, stimmt. Aber für direkte Zugriffe muss man dann die ganze Liste durchsuchen. Man kann die natürlich sortieren oder gleich eine Abbildung vom zweidimensionalen auf das Array machen.
Naja, muss man dann sehen, machen kann man sicher viel, aber ob der Aufwand bei einer Hausarbeit gerechtfertigt ist...^^

Danke ür die Antworten!

Ich habs eben über ein 2d-Array versucht, so wie ihr das vorgeschlagen habt mit dem prüfen auf "valid", allerdings geht
dabei ne ganze Menge Speicher verloren. Die Formel ür den verschwendeten Platz ist (n-1)*n, wobei n die Kantenlänge ist.
bei kleinen Spielfeldern ist das nicht so wild, bei Feldern mit der Kantenlänge 128 hingegen sind das schon 16256 ungenutzte
Felder.
Ich habe mich deshalb entschlossen, alles in ein 1d-Array zu schmeißen und ne Formel für die gesamt Anzahl der benötigten
Felder ausgemacht. Das hat den Vorteil, dass bekannte such-algorithmen ohne weiteres darau angewendet werden können.
Die Koordinaten werden unmittelbar nach anlegen des Arrays errechnet und auf die Felder verteilt. Dazu sind lediglich 2
Schleifen nötig, bei der die Eine ständig ihre Start- und Endwerte aktualisiert bis alle Felder ihre Koordinaten haben.
Jetzt mus ich nur noch eine Funktion schreiben, um die benachbarten Felder zu finden, was ja anhand der such-algos kaum
aufwendig sein sollte.

Die Lösung in Code-Form möchte ich hier noch nicht posten, da es sich hierbei wie gesagt um eine Hausarbeit fürs Studium handelt
und ich unteranderem zunächst die Richtigkeit/Nutzbarkeit des Codes "professionell" bewerten lassen will. Ansonsten bin ich gerne
offen mein Wissen preiszugeben. Vorraussichtlich wird die Bewertung mitte Februar stattfinden.

danke noch einmal für die Denkanstöße!

_________________
Klar Soweit?

Um meinen Senf noch dazu zu geben:
Ich hätte in Java die Hexfelder ebenfalls als Klasse wie Aya angelegt, diese in einen Vector (kann beliebig viele aufnehmen) abgelegt, und eine Hashtable als Index angelegt. Als Indexschlüssel hätte ich die Position auf dem 2D Hexfeld, wie es Sascha benutzt, genommen. So kann ich sehr schnell auf ein beliebiges Feld zugreifen (Hashtable) und habe trotzdem nur den Speicher genutzt, den die Felder belegen (Vector).

_________________
Blog: kevin-fleischer.de und fbaingermany.com

Der Vorteil für mich ist, dass ich keine besondere Interaktion programmieren muss, da das Feld nur in der Lage sein soll Zustände zu prüfen.
Das Zeichnen des Spielfeldes ist ebenfalls nicht nötig. Das einzige was ich brauche ist die Möglichkeit Felder als besetzt/unbesetzt zu markieren.
Dass ich jedem Feld eine Koordinate gebe, als würden sie in einem 2d Array liegen, hat nur den Grund, dass ich auf diese weiße die Nachbarn
schnell errechnen kann. Die Nachbarn werden natürlich auch in jedem Feld als Pointer gemerkt.
Weitere Bestandteile eines Feldes sind zwei Booleans, einmal "besetzt" und einmal "besucht". "besetzt" gibt halt nur an ob das Feld noch frei ist
oder nicht und "besucht" ist immer false, es sei denn während einer Suche wurde das Feld schon geprüft. So verhinder ich, das bereits geprüfte
Felder nocheinmal geprüft werden.
Das Spielfeld soll außerdem in der Lage sein zu erkennen welche Felder zu einem Gebiet gehören, also unbesetzte Felder die zusammenhängend
sind und von Kartenrand oder besetzten Feldern umzogen sind.
Das wahnsinnige ist, dass nur der Quellode abgegeben werden soll, keine lauffähige exe. Dazu eine Dokumentation über die Beweise der Funk-
tionalität und Zeitkomplexität der genutzten Algorithmen.

_________________
Klar Soweit?