orangerot/domino-dungeon
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

style: seperate functions into files

Browse source
This commit is contained in:
orangerot 2025-10-18 17:32:37 +02:00
parent d6f9adad13
commit 464069851c
7 changed files with 177 additions and 153 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
Makefile
View file

@ -1,8 +1,15 @@
CC = gcc
CFLAGS := -ggdb -Wall -Wextra
# -fsanitize=address
LDFLAGS = -lglfw -lm -lGL -I./glad/include
SOURCES = main.c game.c game.h glad/src/glad.c assets/white_and_blue_dominoes.h assets/red_and_peach_dominoes.h domino.c domino.h
SOURCES = main.c \
game.c game.h \
domino.c domino.h \
draw.c draw.h \
assets/white_and_blue_dominoes.h \
assets/red_and_peach_dominoes.h \
glad/src/glad.c \
domino-dungeon: ${SOURCES}
$(CC) ${CFLAGS} -o $@ $^ ${LDFLAGS}

61
domino.c
View file

@ -1,6 +1,18 @@
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include "domino.h"
#define DIRECTIONS 6
const struct eye direction[DIRECTIONS] = {
{.x = 0, .y = -1},
{.x = -2, .y = 0},
{.x = 1, .y = 0},
{.x = 0, .y = 1},
{.x = -1, .y = -1},
{.x = -1, .y = 1},
};
void bricks_append(struct bricks *bricks, struct brick brick) {
if (bricks->count+1 > bricks->capacity) {
if (bricks->capacity == 0) bricks->capacity = 256;
@ -10,3 +22,52 @@ void bricks_append(struct bricks *bricks, struct brick brick) {
bricks->items.brick[bricks->count++] = brick;
}
void brick_print(const struct brick b) {
struct eye *eyes = (struct eye*) &b;
for (size_t i = 0; i < 2; i++) {
printf("{.x = %d, .y = %d, .val = %d, .vertical = %d}" , eyes[i].x, eyes[i].y, eyes[i].val, eyes[i].vertical); }
printf("\n");
}
void brick_previews(const struct brick active, const struct bricks bricks, struct bricks *preview) {
preview->count = 0;
for (size_t i = 0; i < bricks.count * 2; i++) {
struct eye e = bricks.items.eye[i];
if (e.val != active.front.val && e.val != active.back.val) continue;
struct brick p = active;
p.front.x = e.x;
p.front.y = e.y;
p.back.x = e.x + !active.front.vertical;
p.back.y = e.y + active.front.vertical;
struct brick previews[DIRECTIONS] = {0};
for (size_t ii = 0; ii < DIRECTIONS; ii++) {
int offset_x = active.front.vertical ? direction[ii].y : direction[ii].x;
int offset_y = active.front.vertical ? direction[ii].x : direction[ii].y;
previews[ii] = p;
previews[ii].front.x += offset_x;
previews[ii].front.y += offset_y;
previews[ii].front.val = 0;
previews[ii].back.x += offset_x;
previews[ii].back.y += offset_y;
for (size_t iii = 0; iii < bricks.count * 2; iii++) {
previews[ii].front.val |= (
(bricks.items.eye[iii].x == previews[ii].back.x && bricks.items.eye[iii].y == previews[ii].back.y) ||
(bricks.items.eye[iii].x == previews[ii].front.x && bricks.items.eye[iii].y == previews[ii].front.y)
|| (
(active.front.val != active.back.val) &&
((e.val == active.front.val && direction[ii].x < 0) || (e.val == active.back.val && direction[ii].x >= 0))
)
);
}
if (!previews[ii].front.val)
bricks_append(preview, previews[ii]);
}
}
}

2
domino.h
View file

@ -17,6 +17,8 @@ struct bricks {
};
void bricks_append(struct bricks *bricks, struct brick brick);
void brick_print(const struct brick b);
void brick_previews(const struct brick active, const struct bricks bricks, struct bricks *preview);
#endif // DOMINO_H

39
draw.c Normal file
View file

@ -0,0 +1,39 @@
#include "characters.h"
#include "draw.h"
void draw_image( struct image canvas, struct image texture, size_t xpos, size_t ypos, bool vertical) {
for (size_t y = 0; y < texture.height; y++) {
for (size_t x = 0; x < texture.width; x++) {
int canvas_y = (vertical ? x : y) + ypos;
int canvas_x = (vertical ? y : x) + xpos;
if (canvas_x < 0 || canvas_x >= (int) canvas.width - 1 || canvas_y < 0 || canvas_y >= (int) canvas.height - 1) continue;
canvas.buf[canvas_y * canvas.width + canvas_x] = texture.buf[y * texture.width + x];
}
}
}
void draw_glyph( struct image canvas, uint32_t glyph, size_t xpos, size_t ypos, struct color color) {
struct image texture = {
.width = 5,
.height = 6,
.bufsize = 5 * 6,
.buf = (uint32_t[30]) {0}
};
for (size_t y = 0; y < texture.height; y++) {
for (size_t x = 0; x < texture.width; x++) {
if ((glyph >> ((texture.height - y - 1) * texture.width + (texture.width - x - 1))) & 1) {
texture.color[y * texture.width + x] = color;
}
}
}
draw_image(canvas, texture, xpos, ypos, 0);
}
void draw_text(struct image canvas, char *string, size_t xpos, size_t ypos, struct color color) {
for (size_t i = 0; string[i]; i++) {
uint32_t glyph = characters[string[i] - ' '];
draw_glyph(canvas, glyph, xpos + i * 5, ypos, color);
}
}

8
draw.h Normal file
View file

@ -0,0 +1,8 @@
#include <stdbool.h>
#include <stddef.h>
#include "game.h"
void draw_image( struct image canvas, struct image texture, size_t xpos, size_t ypos, bool vertical);
void draw_glyph( struct image canvas, uint32_t glyph, size_t xpos, size_t ypos, struct color color);
void draw_text(struct image canvas, char *string, size_t xpos, size_t ypos, struct color color);

207
game.c
View file

@ -7,7 +7,7 @@
#include "game.h"
#include "domino.h"
#include "characters.h"
#include "draw.h"
#include "assets/white_and_blue_dominoes.h"
#include "assets/red_and_peach_dominoes.h"
@ -15,6 +15,10 @@
#define MAX(a,b) (((a)>(b))?(a):(b))
#define CLAMP(x,a,b) (MIN(MAX(x,a),b))
const uint32_t glyph_heart = 0b00010101111111111011100010000000;
const uint32_t glyph_flag = 0b00011000111001100010000100011100;
const uint32_t glyph_monster = 0b00111011111101011111111111101010;
int mouse_x = 0, mouse_y = 0;
struct bricks bricks = {0};
@ -25,8 +29,7 @@ size_t hand_count = 0;
struct brick active = {0};
bool has_active = 0;
struct brick preview[256] = {0};
size_t preview_count = 0;
struct bricks preview = {0};
int camera_x = 0;
int camera_y = 0;
@ -43,66 +46,6 @@ struct enemy {
struct enemy enemies[20] = {0};
size_t enemy_count = 0;
#define DIRECTIONS 6
struct eye direction[DIRECTIONS] = {
{.x = 0, .y = -1},
{.x = -2, .y = 0},
{.x = 1, .y = 0},
{.x = 0, .y = 1},
{.x = -1, .y = -1},
{.x = -1, .y = 1},
};
void get_prewiews() {
preview_count = 0;
for (size_t i = 0; i < bricks.count * 2; i++) {
struct eye e = bricks.items.eye[i];
if (e.val != active.front.val && e.val != active.back.val) continue;
struct brick p = active;
p.front.x = e.x;
p.front.y = e.y;
p.back.x = e.x + !active.front.vertical;
p.back.y = e.y + active.front.vertical;
struct brick previews[DIRECTIONS] = {0};
for (size_t ii = 0; ii < DIRECTIONS; ii++) {
int offset_x = active.front.vertical ? direction[ii].y : direction[ii].x;
int offset_y = active.front.vertical ? direction[ii].x : direction[ii].y;
previews[ii] = p;
previews[ii].front.x += offset_x;
previews[ii].front.y += offset_y;
previews[ii].front.val = 0;
previews[ii].back.x += offset_x;
previews[ii].back.y += offset_y;
for (size_t iii = 0; iii < bricks.count * 2; iii++) {
previews[ii].front.val |= (
(bricks.items.eye[iii].x == previews[ii].back.x && bricks.items.eye[iii].y == previews[ii].back.y) ||
(bricks.items.eye[iii].x == previews[ii].front.x && bricks.items.eye[iii].y == previews[ii].front.y)
|| (
(active.front.val != active.back.val) &&
((e.val == active.front.val && direction[ii].x < 0) || (e.val == active.back.val && direction[ii].x >= 0))
)
);
}
}
for (size_t ii = 0; ii < DIRECTIONS; ii++) {
if (!previews[ii].front.val)
preview[preview_count++] = previews[ii];
}
}
}
void print_brick(struct brick b) {
struct eye *eyes = (struct eye*) &b;
for (size_t i = 0; i < 2; i++) {
printf("{.x = %d, .y = %d, .val = %d, .vertical = %d}" , eyes[i].x, eyes[i].y, eyes[i].val, eyes[i].vertical); }
printf("\n");
}
void key_callback(int key, int scancode, int action, int mods) {
(void) scancode;
@ -117,7 +60,7 @@ void key_callback(int key, int scancode, int action, int mods) {
active.back.val = tmp.val;
}
active.front.vertical = !active.front.vertical;
get_prewiews();
brick_previews(active, bricks, &preview);
printf("rotate\n");
break;
case GLFW_KEY_ENTER:
@ -138,6 +81,7 @@ void cursor_position_callback(int xpos, int ypos) {
void mouse_button_callback(int button, int action, int mods) {
(void) mods;
printf("click!\n");
if (button == GLFW_MOUSE_BUTTON_RIGHT) {
is_dragging = (action == GLFW_PRESS);
@ -147,65 +91,75 @@ void mouse_button_callback(int button, int action, int mods) {
// pick up brick from hand
for (size_t i = 0; i < hand_count; i++) {
struct brick *b = &hand[i];
if (!has_active) {
if (b->front.x <= mouse_x && mouse_x <= b->front.x + DOMINO_WIDTH &&
b->front.y <= mouse_y && mouse_y <= b->front.y + DOMINO_HEIGHT
) {
has_active = 1;
active = *b;
active.front.x -= mouse_x;
active.front.y -= mouse_y;
}
} else {
if (has_active) {
hand[i - 1] = hand[i];
continue;
}
if (b->front.x <= mouse_x && mouse_x <= b->front.x + DOMINO_WIDTH &&
b->front.y <= mouse_y && mouse_y <= b->front.y + DOMINO_HEIGHT
) {
has_active = 1;
active = *b;
active.front.x -= mouse_x;
active.front.y -= mouse_y;
}
}
if (has_active) {
hand_count--;
get_prewiews();
brick_previews(active, bricks, &preview);
}
}
printf("click!\n");
if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_RELEASE) {
if (has_active) {
has_active = 0;
// get preview with minimal distance from active brick
size_t min_dist = -1;
for (size_t i = 0; i < preview_count; i++) {
for (size_t i = 0; i < preview.count; i++) {
int active_x = active.front.x + mouse_x + DOMINO_WIDTH / 2;
int active_y = active.front.y + mouse_y + DOMINO_HEIGHT / 2;
int preview_x = camera_x + preview[i].front.x * EYE_SIZE + DOMINO_WIDTH / 2;
int preview_y = camera_y + preview[i].front.y * EYE_SIZE + DOMINO_HEIGHT / 2;
preview[i].front.val = (active_x - preview_x) * (active_x - preview_x) + (active_y - preview_y) * (active_y - preview_y);
int preview_x = camera_x + preview.items.brick[i].front.x * EYE_SIZE + DOMINO_WIDTH / 2;
int preview_y = camera_y + preview.items.brick[i].front.y * EYE_SIZE + DOMINO_HEIGHT / 2;
preview.items.brick[i].front.val = (active_x - preview_x) * (active_x - preview_x) + (active_y - preview_y) * (active_y - preview_y);
if (min_dist == (size_t)-1) min_dist = i;
if (preview[i].front.val < preview[min_dist].front.val) min_dist = i;
if (preview.items.brick[i].front.val < preview.items.brick[min_dist].front.val) min_dist = i;
}
if (preview[min_dist].front.val < EYE_SIZE * EYE_SIZE && preview_count) {
preview[min_dist].front.val = active.front.val;
preview[min_dist].front.vertical = active.front.vertical;
preview[min_dist].back.val = active.back.val;
bricks_append(&bricks, preview[min_dist]);
if (preview.items.brick[min_dist].front.val < EYE_SIZE * EYE_SIZE && preview.count) {
preview.items.brick[min_dist].front.val = active.front.val;
preview.items.brick[min_dist].front.vertical = active.front.vertical;
preview.items.brick[min_dist].back.val = active.back.val;
bricks_append(&bricks, preview.items.brick[min_dist]);
hand[hand_count++] = (struct brick) {
.front = {.val = rand() % 6},
.back = {.val = rand() % 6},
};
if ((preview[min_dist].front.x == goal_x && preview[min_dist].front.y == goal_y) ||
(preview[min_dist].back.x == goal_x && preview[min_dist].back.y == goal_y)) {
if ((preview.items.brick[min_dist].front.x == goal_x &&
preview.items.brick[min_dist].front.y == goal_y) ||
(preview.items.brick[min_dist].back.x == goal_x &&
preview.items.brick[min_dist].back.y == goal_y)) {
is_goal_reached = 1;
}
for (size_t i = 0; i < bricks.count; i++) print_brick(bricks.items.brick[i]);
for (size_t i = 0; i < bricks.count; i++) brick_print(bricks.items.brick[i]);
} else {
hand[hand_count++] = active;
}
printf("dist: %d\n", preview[min_dist].front.val);
preview_count = 0;
printf("dist: %d\n", preview.items.brick[min_dist].front.val);
preview.count = 0;
}
}
}
void draw_enemy(struct image canvas, int attack, int health, size_t xpos, size_t ypos) {
char a[] = {(attack + '0'), 0};
char h[] = {(health + '0'), 0};
draw_glyph(canvas, glyph_monster, camera_x + xpos * EYE_SIZE + 2, camera_y + ypos * EYE_SIZE + 3, (struct color) {255, 0, 0, 255});
draw_text(canvas, a, camera_x + xpos * EYE_SIZE + 8, camera_y + ypos * EYE_SIZE, (struct color) {255, 0, 0, 255});
draw_text(canvas, h, camera_x + xpos * EYE_SIZE + 8, camera_y + ypos * EYE_SIZE + 6, (struct color) {255, 0, 0, 255});
}
void init(struct image canvas) {
camera_x = canvas.width / 2;
camera_y = canvas.height / 2;
@ -226,67 +180,21 @@ void init(struct image canvas) {
}
}
void draw( struct image canvas, struct image texture, size_t xpos, size_t ypos, bool vertical) {
for (size_t y = 0; y < texture.height; y++) {
for (size_t x = 0; x < texture.width; x++) {
int canvas_y = (vertical ? x : y) + ypos;
int canvas_x = (vertical ? y : x) + xpos;
if (canvas_x < 0 || canvas_x >= (int) canvas.width - 1 || canvas_y < 0 || canvas_y >= (int) canvas.height - 1) continue;
canvas.buf[canvas_y * canvas.width + canvas_x] = texture.buf[y * texture.width + x];
}
}
}
void draw_glyph( struct image canvas, uint32_t glyph, size_t xpos, size_t ypos, struct color color) {
struct image texture = {
.width = 5,
.height = 6,
.bufsize = 5 * 6,
.buf = (uint32_t[30]) {0}
};
texture.buf = (uint32_t[30]) {0};
for (size_t y = 0; y < texture.height; y++) {
for (size_t x = 0; x < texture.width; x++) {
if ((glyph >> ((texture.height - y - 1) * texture.width + (texture.width - x - 1))) & 1) {
texture.color[y * texture.width + x] = color;
}
}
}
draw(canvas, texture, xpos, ypos, 0);
}
void print(struct image canvas, char *string, size_t xpos, size_t ypos, struct color color) {
for (size_t i = 0; string[i]; i++) {
uint32_t glyph = characters[string[i] - ' '];
draw_glyph(canvas, glyph, xpos + i * 5, ypos, color);
}
}
void draw_enemy(struct image canvas, int attack, int health, size_t xpos, size_t ypos) {
char a[] = {(attack + '0'), 0};
char h[] = {(health + '0'), 0};
draw_glyph(canvas, (uint32_t) 0b00111011111101011111111111101010, camera_x + xpos * EYE_SIZE + 2, camera_y + ypos * EYE_SIZE + 3, (struct color) {255, 0, 0, 255});
print(canvas, a, camera_x + xpos * EYE_SIZE + 8, camera_y + ypos * EYE_SIZE, (struct color) {255, 0, 0, 255});
print(canvas, h, camera_x + xpos * EYE_SIZE + 8, camera_y + ypos * EYE_SIZE + 6, (struct color) {255, 0, 0, 255});
}
void render(struct image canvas) {
for (size_t i = 0; i < canvas.bufsize; i++) canvas.buf[i] = 0;
// domino playground
for (size_t i = 0; i < bricks.count; i++) {
struct brick *b = &bricks.items.brick[i];
draw(canvas, red_and_peach_dominoes[b->back.val][b->front.val], camera_x + b->front.x * EYE_SIZE, camera_y + b->front.y * EYE_SIZE, b->front.vertical);
draw_image(canvas, red_and_peach_dominoes[b->back.val][b->front.val], camera_x + b->front.x * EYE_SIZE, camera_y + b->front.y * EYE_SIZE, b->front.vertical);
}
// preview
for (size_t i = 0; i < preview_count; i++) {
draw(canvas, white_and_blue_dominoes[active.back.val][active.front.val], camera_x + preview[i].front.x * EYE_SIZE, camera_y + preview[i].front.y * EYE_SIZE, active.front.vertical);
for (size_t i = 0; i < preview.count; i++) {
draw_image(canvas, white_and_blue_dominoes[active.back.val][active.front.val], camera_x + preview.items.brick[i].front.x * EYE_SIZE, camera_y + preview.items.brick[i].front.y * EYE_SIZE, active.front.vertical);
}
draw_glyph(canvas, (uint32_t) 0b00011000111001100010000100011100, camera_x + goal_x * EYE_SIZE + 3, camera_y + goal_y * EYE_SIZE + 3, (struct color) {255, 255, 0, 255});
draw_glyph(canvas, glyph_flag, camera_x + goal_x * EYE_SIZE + 3, camera_y + goal_y * EYE_SIZE + 3, (struct color) {255, 255, 0, 255});
draw_enemy(canvas, 6, 3, 0, 3);
@ -295,12 +203,12 @@ void render(struct image canvas) {
struct brick *b = &hand[i];
b->front.x = (canvas.width - hand_count *(DOMINO_WIDTH + 4))/2 + i * (DOMINO_WIDTH + 4);
b->front.y = canvas.height - DOMINO_WIDTH;
draw(canvas, red_and_peach_dominoes[b->back.val][b->front.val], b->front.x, b->front.y, b->front.vertical);
draw_image(canvas, red_and_peach_dominoes[b->back.val][b->front.val], b->front.x, b->front.y, b->front.vertical);
}
// active
if (has_active) {
draw(canvas, red_and_peach_dominoes[active.back.val][active.front.val], mouse_x + active.front.x, mouse_y + active.front.y, active.front.vertical);
draw_image(canvas, red_and_peach_dominoes[active.back.val][active.front.val], mouse_x + active.front.x, mouse_y + active.front.y, active.front.vertical);
}
// character
@ -308,15 +216,14 @@ void render(struct image canvas) {
char inventory[] = "Inventory";
char game_over[] = "You reached the goal!";
// print(canvas, title, (canvas.width - (sizeof(title)-1) * 5) / 2, 5, (struct color) {255, 255, 255, 255});
print(canvas, inventory, (canvas.width - (sizeof(inventory)-1) * 5) / 2, canvas.height - DOMINO_WIDTH - 10, (struct color) {255, 255, 255, 255});
print(canvas, "Drag Dominos from your inventory onto the chain to", 3, 2, (struct color) {255, 255, 255, 255});
print(canvas, "reach the goal. Press [R] to rotate", 3, 9, (struct color) {255, 255, 255, 255});
draw_glyph(canvas, 0b00010101111111111011100010000000, 3, 20, (struct color) {255, 0, 0, 255});
print(canvas, "10", 10, 20, (struct color) {255, 255, 255, 255});
draw_text(canvas, inventory, (canvas.width - (sizeof(inventory)-1) * 5) / 2, canvas.height - DOMINO_WIDTH - 10, (struct color) {255, 255, 255, 255});
draw_text(canvas, "Drag Dominos from your inventory onto the chain to", 3, 2, (struct color) {255, 255, 255, 255});
draw_text(canvas, "reach the goal. Press [R] to rotate", 3, 9, (struct color) {255, 255, 255, 255});
draw_glyph(canvas, glyph_heart, 3, 20, (struct color) {255, 0, 0, 255});
draw_text(canvas, "10", 10, 20, (struct color) {255, 255, 255, 255});
if (is_goal_reached) {
print(canvas, game_over, (canvas.width - (sizeof(game_over)-1) * 5) / 2, 20, (struct color) {255, 255, 255, 255});
draw_text(canvas, game_over, (canvas.width - (sizeof(game_over)-1) * 5) / 2, 20, (struct color) {255, 255, 255, 255});
}
}

4
main.c
View file

@ -11,8 +11,8 @@
#include "game.h"
unsigned int SCR_WIDTH = 800;
unsigned int SCR_HEIGHT = 600;
unsigned int SCR_WIDTH = 768;
unsigned int SCR_HEIGHT = 720;
GLFWwindow* window;
unsigned int texture;