C - [Snake-Contest] - Wie Wandformen mit Koordinaten vorgeben?

[theSplit]

Hallo,

im Zuge des Snake-Contest suche ich gerade nach einem Weg Wände, nach bestimmten vorgegebenen Mustern, erzeugen zu lassen, ich weiß aber nicht recht wie ich die Daten in Code abbilden kann.

Da ich SDL2 verwende, wollte ich die SDL_Point Klasse nutzen, welche eine X und Y Koordinate speichern kann.

Ein Beispiel der Koordinaten einer "Eckwand", angelegt im 90 Grad Winkel:
[0, 2, 0, -2, 2, 0]

Das heißt die Wand-Punkte liegen auf einem bestimmen X, Y Punkt/Feld und würden dann wie eine Turtle Grafik abgelaufen werden:
Wandert von der aktuellen Position zu "0x, +2y", geht wieder zurück mit "0x, -2y", wandert nach rechts zu "+2x, 0y".

Daraus sollte dann eine Ecke konstruiert werden.

Die Datenstruktur um die Wand zu speichern würde in etwa so aussehen:
[src=c]typedef struct wallShape {
int length; // Anzahl der Wege im Shape (im Beispiel 3)
SDL_Point* points; // Die Zeichenpunkte (3 mal jeweils X und Y-Koordinaten)
} wallShape;[/src]

Ich hatte jetzt daran gedacht eine Funktion zu schreiben, die einmal die Anzahl (3) und die Punkte als Array (3 mal X,Y-Koordinaten) erhält und das wallShape mit allokiertem Speicher und gesetzten Werten zurückgibt.

Aber ich weiß nicht wie es möglich wäre die Anzahl der Punkte dynamisch an die Funktion zu übergeben da die Länge dieser variable sein soll.
Das Problem was dabei immer aufkommt, ich kann ein Array ala:
[src=c]int corners[10];
corners = {0, 2, 0, -2, 2, 0};[/src]

dazu verwenden die Daten an die Funktion zu übergeben, also:
createWallShape(3, corners);

Aber gibt es einen Weg die Funktion mit Parametern zu überladen also das ich "createWallShape(3, [0, 2, 0, -2 ...])" irgendwie umsetzen kann oder geht nur der Weg mit einem fixen Array das immer anders gesetzt wird und ist das überhaupt "sinnvoll" gelöst?

Ich stehe gerade ein wenig auf dem Schlauch wie man das umsetzen könnte und wäre über einen Denkanstoß dankbar.

Eine andere Idee wäre, meiner Meinung nach, die Wände mutieren und zufällige Shapes generieren zu lassen, in der man nur die Anzahl der Wandteile vorgibt.
Aber das wäre vermutlich mit den ganzen Regeln und Corner-Cases noch komplexer zu realisieren, außerdem wollte ich schon die Formen vorgeben lassen können.

 

[drfuture]

Nunja, du könntest dir mit Paint Beispielwände bauen.
Dann lässt du dein Programm zufällige Kombinationen an Wänden erstellen und machst jewils einen Screenshot.
Vom Screenshot dann einen Fingerprint erstellen und mit dem Original-Bild aus Paint eine ähnlichkeitsanalyse drüber laufen lassen. Sobald die Ähnlichkeit hoch genug ist passt die Erstellte Wand

Nun aber evtl. noch was Sinnvolleres.
Ich würde die Parameter als Mehrdimensionales Array übergeben:

array(
array(länge, Schnittpunkt (pixel 1 bis Maximal länge aus parameter "länge), vertikal/horizonal)
array(länge,Schnittpunkt,Ausrichtung)
)

usw.
Gut du könntest noch optional ein Feld *verknüpft mit* und eine ID einfügen das angibt für welche 2 Balken die Schnittpunkte gelten, oder einfach von oben nach unten arbeiten und immer das erste mit dem 2. das mit dem 3. usw. zu verknüpfen.

 

[theSplit]

Also zum ersten Part - genau so..., ich nehme Bitmaps als Vorlage die ich dann auf die Felder mappe.... wobei die Idee vermutlich gar nicht so schlecht ist, hat aber den Nachteil das es nicht zufallsgeneriert wäre und man die Masken für ein Level vorgeben muß versus dynamische Formen. Aber man könnte schon ermitteln ob ein Pixel Schwarz oder Weiß ist. Wand versus normales Feld..... hmmm.... das ist gar nicht so doof


Zum zweiten Teil deines Vorschlags, ich werd nicht ganz schlau daraus, vielleicht hapert es auch bei der Definition:
Also du würdest die Koordinate angeben und sagen X Pixel/Felder weiter von diesem Punkt aus in horizontaler/vertikaler Richtung für die Schrittlänge (Länge) ?

Ich würde davon ausgehen das ein negativer Wert jetzt dafür sorgen würde das die Wand nach oben/links wächst und ein positiver Wert den Stift nach rechts oder unten gleiten lässt.

Aber Arrays sind in C gar nicht so leicht anzulegen, speziell Mehrdimensionale mit unterschiedlicher Größe was per se so nicht geht - ich hab aber auch mit diesem Feature bisher kaum gearbeitet - meiner Einschätzung nach würde das aber alles noch weiter verkomplizieren weil du statt zwei Parametern ja ganze 3 hättest. So ergibt sich die Länge ja aus den Sprung der Koordinaten und ich würde dies bei der Implementierung berücksichtigen.

Daher habe ich ja versucht die Parameter als ein Array mit jeweils einer X und Y-Koordinate bzw. dem Versetzen um +-X, +-Y entstehen zu lassen wobei man mit einem Stift umher kreist und diesen nur in fixen Einheiten auf X und Y-Achse, vorzugsweise nur auf einer Achse, umher bewegt und alle Felder dazwischen werden als Mauern gekennzeichnet/geflagt über eine Variable die die Felder schon besitzen. Das wäre also nur einmal durchzuführen der Schritt.

Aber DrFuture, ich weiß noch nicht ob die Idee so hinhauen würde um ehrlich zu sein.

 

[drfuture]

Die Position habe ich um ehrlich zu sein erst mal außer acht gelassen... Dachte es geht "erstmal" einer Wandformation.
aber du hast schon recht um sie zu erstellen raucht man auch einen Startpunkt.

Ich würde halt der Funktion dann 2 Parameter übergeben, 1x Koordinaten des Startpunktes 2x das multi-Dim Array.
Das würde dir die Flexibilität einer Formation von beliebig vielen Wänden geben.

in der Implementierung der Funktion gehst du dann in meinem Beispiel von oben nach unten vor:

vom Startpunkt an zeichnest du die angegebene Länge horrizontal oder Verikal > Wand 1
dann gehst du auf die Position des Schnittpunktes der angegeben ist > Sprung zu Wand 2
Wenn bei Wand 2 der Schnittpunkt auf 0 ist dann direkt zeichnen - wenn nicht in Horrizonal oder Vertikal um x verschieben, dann länge Wand 2 in Richtung ... Zeichnen

usw.

Dann kannst du L's, T, Kreuze aus 2 Wänden und auch komplexeres aus mehr Wänden zeichnen.

Nun habe ich mir zugegeben deinen Code noch nicht angeschaut bzw. verstehe ich nunmal von c/c++ nichts um sagen zu können wie das dann mit deiner Kollisionserkennung aussieht und wie komplex dann die weitere Ausarbeitung aussieht.

Gut außer Arrays gibt es noch dinge die Collections usw. - Muss doch in C oder c++ etwas geben das man eine Liste von Variablen zusammenfassen kann vom gleichen Typ wie die Liste selber + oder sowas wie array.add(array(xxxxx)) ?

 

[theSplit]

Okay, ich glaube jetzt hab ich auch geblickt was du meinst. Also du würdest das Zeichnen in mehrere Schritte einteilen, also das man die Koordinaten nicht an einem Stück definiert, sondern nur sagt "Gehe vom Startpunkt zu 0x -3y und zeichne, um die Länge, 3 Felder nach oben die Wand" - Wandteil 2 im Array sollte dann von Feld "0x 0y" bewegen und "um Länge 2, nach rechts" zeichnen (=Eckwand), ist das in etwa korrekt?

Also wenn ich deinen Denkweg verfolge, dann würde es dahingehend vereinfachen das eine Wand nur zwei X und Y-Koordinaten benötigt, eine Länge und Richtung. Weil, einmal die relative Position zum Startpunkt in X und Y, dann die Länge in Feldern, dann die Richtung (Links, Rechts, Oben, Unten). Das ließe sich definitiv leichter abbilden, da die Parameter konstant bleiben. Sehr gute Idee!

Hat nicht mehr viel mit der Frage gemein, aber:
In C gibt es schon Arrays eines Datentyps bzw. von Strukturen, aber die sind entweder mit fixer Breite anzugeben oder eben mittels Pointern zu realisieren...

Spoiler

Die Varianten die ich dazu kenne in C:

"char nameArray[10]" (1 Name mit 10 Buchstaben wobei das 10 Zeichen für '\0' reserviert ist um das Ende eines Strings zu markieren)

Dann sowas: "char nameArray[5][10]" (5 Namen a 10 Buchstaben, also 9 Zeichen plus zu setzendes "String-Ende-Zeichen")

Die Pointer Variante sollte in etwa so aussehen "char* nameArray[10]" wobei man hier beliebig viele Namen mit 10 Buchstaben (-1 reserviertes Zeichen) angeben könnte.

und dann noch diese Variante: "char* nameArray[]" - beliebig viele Namen mit beliebiger Länge, aber diese dürfen nur einmal angelegt werden und sind nicht mehr veränderbar.

 

[BurnerR]

Aber gibt es einen Weg die Funktion mit Parametern zu überladen also das ich "createWallShape(3, [0, 2, 0, -2 ...])" irgendwie umsetzen kann oder geht nur der Weg mit einem fixen Array das immer anders gesetzt wird und ist das überhaupt "sinnvoll" gelöst?

Wieso nicht

createWallShape(int, int *);

?

Ich würde keine Pfade speichern sondern die absoluten Positionen der Objekte.


Btw., warum überhaupt C statt C++?

 

[theSplit]

@BurnerR:

"createWallShape(int, int *);"

Würde natürlich gehen, was ich aber nicht verstanden habe, wie kann ich die Funktion dann mit Variablen Parametern aufrufen?

Zum Beispiel ging es für mich nur so:
[src=c]int integerArray[10];
integerArray = {0, 2, 0, 0, 2, 0};
createWallShape(3, integerArray);[/src]

So ging es nicht:
"createWallShape(int, [0, 2, 0, 0, 2, 0] );"

Ich bekomme es nicht hin das Array direkt an die Funktion zu übergeben ohne es vorher in einer Variable zwischengespeichert zu haben, daher die Frage, geht das überhaupt?
--------

Zur Frage warum ich die Formen speichern will... nun ja, die Wände sollten erst einmal nach bestimmen Formen konstruiert werden. Ich brauche die Formen auch nur bei der Platzierung. Während des Platzierens werden dann alle Felder, die einen boolschen Wert enthalten "isWall?" auf "ja" gesetzt und entsprechend gerendert. Daher benötige ich auch nicht die genauen Positionen.

Das ist natürlich nur der Anfang, wie es später aussieht ob Formen schrumpfen können wenn eine andere Wand entdeckt wird oder ähnliches ist damit noch nicht behandelt, aber dann kann ich es auch über den Switch ermitteln ob ein Feld begehbar ist oder nicht.

--------


Warum C statt C++, weil ich mich aktuell mit C beschäftige und dann später wenn ich in C fit bin zu C++ wechseln möchte. Eine andere Bewandtnis hat es aktuell nicht. Außerdem steht der Snake-Clon schon zu 100% in C, weßhalb also (jetzt) dann zu C++ umschwenken?

 

[drfuture]

Warum C statt C++, weil ich mich aktuell mit C beschäftige und dann später wenn ich in C fit bin zu C++ wechseln möchte. Eine andere Bewandtnis hat es aktuell nicht. Außerdem steht der Snake-Clon schon zu 100% in C, weßhalb also (jetzt) dann zu C++ umschwenken?

Das muss so....

c > Basisversion
c++ > Erweiterte Version

Daher kommt doch die Namensgebung

 

[BurnerR]

So ging es nicht:
"createWallShape(int, [0, 2, 0, 0, 2, 0] );"
Ich bekomme es nicht hin das Array direkt an die Funktion zu übergeben ohne es vorher in einer Variable zwischengespeichert zu haben, daher die Frage, geht das überhaupt?

Schau dir nochmal an welche Bedeutung eckige Klammern bei C haben, dann wird dir klar warum das nicht geht.
Du schreibst ja auch nicht

integerArray = [0, 2, 0, 0, 2, 0];

Zu der Frage "geht das überhaupt" ist festzustellen, dass die richtige Frage lautet: "will ich das überhaupt".
Und die Antwortet lautet: Nein, willst du nicht, das ist considered bad practice.
Pro Zeile Code wird eine Sache gemacht: Ein Array deklarieren und initialisieren oder eine Funktion aufrufen oder ein Array ändern,...

Dafür gibt es zwei Gründe:
1. Ist das viel besser lesbarer und du willst besser lesbaren Code
2. Können dir ansonsten gemeine Dinge passieren

int variable = 0;
someFunction(variable++, variable++);

Wo im Zweifelsfall das Verhalten undefiniert ist, also Compilerabhängig.

Warum C statt C++, weil ich mich aktuell mit C beschäftige und dann später wenn ich in C fit bin zu C++ wechseln möchte.

Auch auf die Gefahr einen Flamewar zu starten: Man sollte lieber mit C++ anfangen und dann erst C lernen, das ist didaktisch sinnvoller.
Gründe werden insbesondere hier genannt.
Objekt orientiertes programmieren ist heute am weitesten verbreitet, das möchte man daher am ehesten als ersten Programmierstil lernen.

 

[theSplit]

@BurnerR:

Ich habe bewusst nicht geschweifte Klammern verwendet, weil diese laut meinem Verständnis nur für Initialisierungen verwendet werden im Zusammenhang mit einem Array oder einem Objekt/struct.

Als ich "gcc" (mit "-std=c11") dazu nötigen wollte mir diesen Code abzunehmen, mit eckigen Klammern oder geschweiften Klammern, wurde gestreikt - also ist es gar nicht möglich das vorhaben so umzusetzen. Es kompiliert nicht, weder die eine noch die andere Variante, daher auch meine Frage ob es nicht einen Weg darum herum gibt es vorher in einer Variable zu speichern.

Weil es mir lieber gewesen wäre diese mögliche Definition in einer Zeile zu erledigen. Aber was nicht geht, geht nicht, sehe ich - etwas Zähneknirschend - ein.

 

[BurnerR]

Der Vollständigkeit halber siehe hier.
Aber wie gesagt, machen würde ich es nicht.

 

[theSplit]

Ich habe mich heute mal daran versuchen wollen einen LevelLoader auf BMP Basis zu implementieren, weil das ursprüngliche Formationen zu nutzen, (auch) nicht so leicht umzusetzen ist.

Mein erster Versuch war die BMPs die SDL2 per Default laden kann zu verwenden, das hat aber nur zu Speicherzugriffsfehlern geführt und ist gecrashed - selbst nach Anweisungen in der Hilfe. Mit anderen Worten, auch nach vielem suchen habe ich es nicht geschafft es mit SDL zum laufen zu bringen.

Zweiter Versuch, das was ich jetzt machen will, einen BMP Loader zu schreiben der ein Level im Maßstab 1 zu 16 parsed.

Dazu öffne ich das File im binären Modus und lese die (für mich) wichtigsten Informationen wie Höhe, Breite, BitPerPixel, ob es eine Farbtabelle gibt und wieviele Farben diese hat (Info habe ich erstmal ignoriert, weil keine vorhanden) und ob das BMP eine Kompression verwendet.

Die beiden Header Strukturen (siehe Link) konnte ich ohne weiteres nachvollziehen. - Aber die Farbwerte der Pixel sind falsch wenn ich diese auslesen will.

Erstmal zu den Headern, diese sollen wie folgt aufgebaut sein
https://de.wikipedia.org/wiki/Windows_Bitmap

Die Header lade ich Anfang mit den ganzen fseek und freads.

Und hier mein bisherigen Code, tut mir leid das der nicht wirklich kommentiert ist... notfalls würde ich das nachbessern.
[src=c]bool loadLevel(const int level) { // Level = 1
char filename[128];
sprintf(filename, "lvls/level_%d.bmp", level); // "lvls/level_1.bmp" laden

unsigned char dataBuffer[32] = "\0";
unsigned char* ptrC = (unsigned char*) &dataBuffer;

int width = 0, height = 0, offset = 0, bitCount = 0, colorTable = 0, colorCount = 0, bitCompression = 0;
int biSizeImage = 0;
FILE* levelFile = fopen(filename, "rb");
if (levelFile != NULL) {

fseek(levelFile, 10, SEEK_SET);
fread(ptrC, sizeof (char), 4, levelFile);
offset = (int) *ptrC;

fseek(levelFile, 18, SEEK_SET);
fread(ptrC, sizeof (char), 4, levelFile);
width = (int) *ptrC;

fseek(levelFile, 22, SEEK_SET);
fread(ptrC, sizeof (char), 4, levelFile);
height = (int) *ptrC;

fseek(levelFile, 28, SEEK_SET);
fread(ptrC, sizeof (char), 2, levelFile);
bitCount = (int) *ptrC;

fseek(levelFile, 30, SEEK_SET);
fread(ptrC, sizeof (char), 4, levelFile);
bitCompression = (int) *ptrC;

fseek(levelFile, 46, SEEK_SET);
fread(ptrC, sizeof (char), 4, levelFile);
colorTable = (int) *ptrC;

fseek(levelFile, 50, SEEK_SET);
fread(ptrC, sizeof (char), 4, levelFile);
colorCount = (int) *ptrC;

printf("Level information:\nWidth: %i\nHeight: %i\nBPP: %i\nData Offset: %i\nColor Table used: %i\nColors in table: %i\nCompression: %i\n\n",
width, height, bitCount, offset, colorTable, colorCount, bitCompression, biSizeImage);
//fseek(levelFile, 0, SEEK_END);
//int levelFileEnd = ftell(levelFile);
//rewind(levelFile);

fseek(levelFile, offset, SEEK_SET);

// Junk Bytes / Padding Kalkulation
//int junkBytes = ((width * 3) + 3) & ~3; // Diese ist von Wikipedia
int junkBytes = 4 - ((width * 3) + 3) % 4; // Ein anderes Netzfundstueck

unsigned char r = 0, g = 0, b = 0;

for (int y = 0; y <= height; y++) {
for (int x = 0; x <= width; x++) {
b = fgetc(levelFile);
g = fgetc(levelFile);
r = fgetc(levelFile);

//printf("R%i G%i B%i\n", r, g, b);
}
if (junkBytes != 0) {
fseek(levelFile, junkBytes, SEEK_CUR);
}
}

/*for (int i = offset; i < levelFileEnd; i += 4) {

fseek(levelFile, i, SEEK_SET);
fread(ptrC, sizeof 1, 1, levelFile);
r = (unsigned char) *ptrC;

fseek(levelFile, i + 1, SEEK_SET);
fread(ptrC, sizeof 1, 1, levelFile);
g = (unsigned char) *ptrC;

fseek(levelFile, i + 2, SEEK_SET);
fread(ptrC, sizeof 1, 1, levelFile);
b = (unsigned char) *ptrC;

b = getc(levelFile);
g = getc(levelFile);
r = getc(levelFile);

}*/

fclose(levelFile);
return true;
}

return false; // false
}[/src]

Die Ausgabe sieht in etwa so aus:
[src=text]Level information:
Width: 39
Height: 27
BPP: 8
Data Offset: 54
Color Table used: 0
Colors in table: 0
Compression: 0[/src]

und die Pixel Ausgabe so: Sollten aber nur Schwarz, Weiß oder einmal Rot beinhalten:
[src=text]R0 G0 B0
R1 G1 B0
R2 G0 B1
R0 G2 B2
R3 G3 B3
R4 G4 B0
R5 G0 B4
R0 G5 B5
R6 G6 B6
R7 G7 B0
R8 G0 B7
R0 G8 B8
R9 G9 B9
R10 G10 B0
R11 G0 B10
R0 G11 B11
R12 G12 B12
R13 G13 B0
R14 G0 B13
R0 G14 B14
R15 G15 B15
R16 G16 B0
R17 G0 B16
R0 G17 B17
R18 G18 B18 // Treppenaufbau, geht so weiter bis R254, G254...
[......]
R254 G254 B254
R255 G255 B0
R1 G0 B255
R0 G0 B0
R0 G0 B0
R0 G0 B0
R0 G0 B0
R0 G0 B0
R0 G0 B0
R0 G0 B0
R0 G0 B0
R0 G0 B0
R0 G0 B0
R0 G0 B0
R0 G0 B0
R0 G1 B0
R0 G255 B255
R255 G0 B0
R255 G255 B255
R255 G255 B255
R255 G255 B255
R255 G255 B255
R255 G255 B255
R255 G255 B255
R255 G255 B255
R255 G254 B255
R255 G255 B255
R255 G255 B255
R0 G255 B254
R255 G0 B0
R255 G255 B255
R255 G255 B255
[/src]


Und im Anschluß die BMP im Anhang (nur 39x27 Pixel groß).

Anhang anzeigen level_1.bmp

 

[BurnerR]

Du kannst auch statt einem Bild eine normale Textdatei, z.B. csv einlesen.
Sowas wie

xCoord;yCoord;Type
0;0;Wall
0;1;Wall
0;2;Wall
[...]

Das erscheint mir simpler und mehr straight forward.

 

[drfuture]

Dann könnte er auch direkt wieder die Werte in den Code schreiben und Dynamisch generieren

 

[BurnerR]

Na gut

 

[theSplit]

Na gut

Wenn man natürlich nen Leveleditor hätte, also ein Interface mit dem man ein Level painten kann, könnte man auch so etwas wie CSV verwenden. Aber rein händisch wäre das einfach too much, deßhalb der Versuch über ein Bitmap das Level zu generieren.

Ich bin der Meinung ich bin eigentlich schon dich dran die richtige Werte zu bekommen, aber irgendwas stimmt an meiner Herangehensweise noch nicht.

Zur Not muss ich mir die Datei mit einem HexEditor anschauen, irgendwo müssen ja die Werte stehen die ich suche, vielleicht ist nur die Zeigerposition falsch oder ein weiteres Feld für einen Alphakanal oder Positionsindex oder irgend was. Oder ich verwende den falschen Datentyp / Breite für beim auslesen.

*Edit:
Ich hab mir die Datei jetzt mal mit WinHex angesehen, da ich die Datei mit 8 Bit (aber indiziert) gespeichert habe, scheint die auf Wikipedia genannte Farbtabelle?, das müssen die Wertvorgaben 0 bis 255 sein, zu kommen. Und dann die Farbwerte, aber ganz so sicher bin ich mir noch nicht da ich nicht verstehe wie das bitoffset zusammenkommt was bei Offset 54 steht aber dort scheinbar die Tabelle anfängt, mach ja so nicht ganz Sinn...