Add files via upload

Author: ProgrammingRainbow

Makefile

@@ -0,0 +1,57 @@
+TARGET			= game-of-life
+BUILD_DIR		= .build
+SRC_DIR			?= src
+
+CC				?= gcc
+CFLAGS_BASE		= -std=c99 $(shell pkg-config --cflags sdl2 SDL2_image SDL2_ttf SDL2_mixer)
+CFLAGS_RELEASE	= -O2
+LDFLAGS			?=
+LDLIBS_BASE		= $(shell pkg-config --libs sdl2 SDL2_image SDL2_ttf SDL2_mixer)
+
+SRCS			= $(wildcard $(SRC_DIR)/*.c)
+OBJS			= $(addprefix $(BUILD_DIR)/, $(notdir $(SRCS:.c=.o)))
+
+ifeq ($(OS),Windows_NT)
+	CFLAGS_DEV	= -O0 -ggdb3 -Wall -Wextra -Werror -Wpedantic -Wwrite-strings -Wconversion \
+				  -Wshadow -Wmissing-prototypes -Wmissing-declarations -Wfloat-equal \
+				  -Wsign-compare -Wundef -Wcast-align -Wstrict-prototypes -Wswitch-default \
+				  -Wold-style-definition -Wmissing-include-dirs
+	LDLIBS_DEV	=
+	CLEAN 		= del /f $(TARGET).exe & if exist $(BUILD_DIR) rmdir /s /q $(BUILD_DIR)
+else
+	CFLAGS_DEV	= -O0 -ggdb3 -Wall -Wextra -Werror -Wpedantic -Wwrite-strings -Wconversion \
+				  -Wshadow -Wmissing-prototypes -Wmissing-declarations -Wfloat-equal \
+				  -Wsign-compare -Wundef -Wcast-align -Wstrict-prototypes -Wswitch-default \
+				  -Wold-style-definition -Wmissing-include-dirs -fsanitize=address \
+				  -fsanitize-address-use-after-scope
+	LDLIBS_DEV	= -fsanitize=address -fsanitize-address-use-after-scope
+	CLEAN		= $(RM) -r $(TARGET) $(BUILD_DIR)
+endif
+
+CFLAGS		?= $(CFLAGS_BASE) $(CFLAGS_DEV)
+LDLIBS		?= $(LDLIBS_BASE) $(LDLIBS_DEV)
+
+$(BUILD_DIR):
+	mkdir $(BUILD_DIR)
+
+$(BUILD_DIR)/%.o: $(SRC_DIR)/%.c $(SRC_DIR)/%.h | $(BUILD_DIR)
+	$(CC) $(CFLAGS) -c $< -o $@
+
+$(TARGET): $(OBJS)
+	$(CC) $^ -o $@ $(LDLIBS)
+
+.PHONY: all clean run rebuild release
+
+all: $(TARGET)
+
+release: CFLAGS = $(CFLAGS_BASE) $(CFLAGS_RELEASE)
+release: LDLIBS = $(LDLIBS_BASE)
+release: all
+
+clean:
+	$(CLEAN)
+
+run: $(TARGET)
+	./$<
+
+rebuild: clean all

README.md

@@ -1,2 +1,26 @@
-# Conways-Game-of-Life-C-SDL2
-Conway's Game of Life written in C++ and using SDL2 game library.
+![Screenshot](screenshot.png)
+
+# Conway's Game of Life (C++ - SDL2)
+Conway's Game of Life is a classic cellular automaton devised by British mathematician John Horton Conway in 1970. It's a zero-player game, meaning its evolution is determined by its initial state, with no further input from humans. Despite its simplicity, the Game of Life exhibits complex and fascinating patterns.
+
+* If a dead cell has exactly three live neighbors, it becomes alive in the next generation.
+* If a live cell has two or three live neighbors, it remains alive in the next generation.
+* In all other cases, a cell dies or remains dead.
+
+# ArchLinux instructions.
+```
+sudo pacman -S --needed base-devel sdl2 sdl2_image sdl2_mixer sdl2_ttf
+cd
+git clone https://github.com/ProgrammingRainbow/Conways-Game-of-Life-C-SDL2
+cd Conways-Game-of-Life-C-SDL2
+make run
+```
+# Controls
+Up Arrow - Speeds up the game.\
+Down Arrow - Slows down the game.\
+Space Bar - Toggles game pauses.\
+Escape - Quits the game.\
+R - Resets and randomizes the board.\
+C - Clears the board.\
+F - Toggles display FPS.\
+Mouse Click - Toggles a cell on/off.

Video2/game.c

@@ -0,0 +1,83 @@
+#include "game.h"
+#include "init_sdl.h"
+
+bool game_events(struct Game *g);
+void game_draw(struct Game *g);
+
+bool game_new(struct Game **game) {
+    *game = calloc(1, sizeof(struct Game));
+    if (*game == NULL) {
+        fprintf(stderr, "Error in calloc of new game.\n");
+        return false;
+    }
+    struct Game *g = *game;
+
+    g->is_running = true;
+
+    if (!game_init_sdl(g)) {
+        return false;
+    }
+
+    return true;
+}
+
+void game_free(struct Game **game) {
+    if (*game) {
+        SDL_DestroyRenderer((*game)->renderer);
+        (*game)->renderer = NULL;
+
+        SDL_DestroyWindow((*game)->window);
+        (*game)->window = NULL;
+
+        IMG_Quit();
+        SDL_Quit();
+
+        free(*game);
+        *game = NULL;
+
+        printf("all clean!\n");
+    }
+}
+
+bool game_events(struct Game *g) {
+    while (SDL_PollEvent(&g->event)) {
+        switch (g->event.type) {
+        case SDL_QUIT:
+            g->is_running = false;
+            break;
+        case SDL_KEYDOWN:
+            switch (g->event.key.keysym.scancode) {
+            case SDL_SCANCODE_ESCAPE:
+                g->is_running = false;
+                break;
+            default:
+                break;
+            }
+        default:
+            break;
+        }
+    }
+
+    return true;
+}
+
+void game_draw(struct Game *g) {
+    SDL_RenderClear(g->renderer);
+
+    SDL_RenderPresent(g->renderer);
+}
+
+bool game_run(struct Game *g) {
+    while (g->is_running) {
+
+        if (!game_events(g)) {
+            return false;
+        }
+
+        game_draw(g);
+
+        SDL_Delay(16);
+    }
+
+    return true;
+}

Video2/game.h

@@ -0,0 +1,17 @@
+#ifndef GAME_H
+#define GAME_H
+
+#include "main.h"
+
+struct Game {
+        SDL_Window *window;
+        SDL_Renderer *renderer;
+        SDL_Event event;
+        bool is_running;
+};
+
+bool game_new(struct Game **game);
+void game_free(struct Game **game);
+bool game_run(struct Game *g);
+
+#endif

Video2/init_sdl.c

@@ -0,0 +1,40 @@
+#include "init_sdl.h"
+
+bool game_init_sdl(struct Game *g) {
+
+    if (SDL_Init(SDL_FLAGS)) {
+        fprintf(stderr, "Error initializing SDL: %s\n", SDL_GetError());
+        return false;
+    }
+
+    int img_init = IMG_Init(IMG_FLAGS);
+    if ((img_init & IMG_FLAGS) != IMG_FLAGS) {
+        fprintf(stderr, "Error initializing SDL_image: %s\n", IMG_GetError());
+        return false;
+    }
+
+    g->window = SDL_CreateWindow(WINDOW_TITLE, SDL_WINDOWPOS_CENTERED,
+                                 SDL_WINDOWPOS_CENTERED, WINDOW_WIDTH,
+                                 WINDOW_HEIGHT, 0);
+    if (!g->window) {
+        fprintf(stderr, "Error creating window: %s\n", SDL_GetError());
+        return false;
+    }
+
+    g->renderer = SDL_CreateRenderer(g->window, -1, SDL_RENDERER_ACCELERATED);
+    if (!g->renderer) {
+        fprintf(stderr, "Error creating renderer: %s\n", SDL_GetError());
+        return false;
+    }
+
+    SDL_Surface *icon_surf = IMG_Load("images/icon.png");
+    if (icon_surf) {
+        SDL_SetWindowIcon(g->window, icon_surf);
+        SDL_FreeSurface(icon_surf);
+    } else {
+        fprintf(stderr, "Error creating icon surface: %s\n", SDL_GetError());
+        return false;
+    }
+
+    return true;
+}

Video2/init_sdl.h

@@ -0,0 +1,8 @@
+#ifndef INIT_SDL_H
+#define INIT_SDL_H
+
+#include "game.h"
+
+bool game_init_sdl(struct Game *g);
+
+#endif

Video2/main.c

@@ -0,0 +1,18 @@
+#include "main.h"
+#include "game.h"
+
+int main(void) {
+    bool exit_status = EXIT_FAILURE;
+
+    struct Game *game = NULL;
+
+    if (game_new(&game)) {
+        if (game_run(game)) {
+            exit_status = EXIT_SUCCESS;
+        }
+    }
+
+    game_free(&game);
+
+    return exit_status;
+}

Video2/main.h

@@ -0,0 +1,15 @@
+#ifndef MAIN_H
+#define MAIN_H
+
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_image.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+#define SDL_FLAGS (SDL_INIT_VIDEO | SDL_INIT_AUDIO)
+#define IMG_FLAGS IMG_INIT_PNG
+#define WINDOW_TITLE "Conway's Game of Life"
+#define WINDOW_WIDTH 1280
+#define WINDOW_HEIGHT 720
+
+#endif

Video3/board.c

@@ -0,0 +1,80 @@
+#include "board.h"
+
+bool board_new(struct Board **board, SDL_Renderer *renderer) {
+    *board = calloc(1, sizeof(struct Board));
+    if (*board == NULL) {
+        fprintf(stderr, "Error in calloc of new Board.\n");
+        return false;
+    }
+    struct Board *b = *board;
+
+    b->renderer = renderer;
+    b->rows = WINDOW_HEIGHT / SIZE;
+    b->columns = WINDOW_WIDTH / SIZE;
+    b->rect.w = SIZE - 1;
+    b->rect.h = SIZE - 1;
+
+    b->board = calloc(1, sizeof(bool) * (Uint64)(b->rows * b->columns));
+    if (b->board == NULL) {
+        fprintf(stderr, "Error in calloc of new board.\n");
+        return false;
+    }
+
+    b->next_board = calloc(1, sizeof(bool) * (Uint64)(b->rows * b->columns));
+    if (b->next_board == NULL) {
+        fprintf(stderr, "Error in calloc of new board.\n");
+        return false;
+    }
+
+    board_reset(b);
+
+    return true;
+}
+
+void board_free(struct Board **board) {
+    if (*board) {
+        free((*board)->board);
+        (*board)->board = NULL;
+
+        free((*board)->next_board);
+        (*board)->next_board = NULL;
+
+        (*board)->renderer = NULL;
+
+        free(*board);
+        *board = NULL;
+    }
+}
+
+void board_reset(struct Board *b) {
+    for (int row = 0; row < b->rows * b->columns; row += b->columns) {
+        for (int column = 0; column < b->columns; column++) {
+            if (rand() % 2 == 0) {
+                b->board[row + column] = true;
+            } else {
+                b->board[row + column] = false;
+            }
+        }
+    }
+}
+
+void board_clear(struct Board *b) {
+    for (int row = 0; row < b->rows * b->columns; row += b->columns) {
+        for (int column = 0; column < b->columns; column++) {
+            b->board[row + column] = false;
+        }
+    }
+}
+
+void board_draw(struct Board *b) {
+    SDL_SetRenderDrawColor(b->renderer, CELL_COLOR);
+    for (int row = 0; row < b->rows; row++) {
+        b->rect.y = SIZE * row;
+        for (int column = 0; column < b->columns; column++) {
+            b->rect.x = SIZE * column;
+            if (b->board[row * b->columns + column]) {
+                SDL_RenderFillRect(b->renderer, &b->rect);
+            }
+        }
+    }
+}

Video3/board.h

@@ -0,0 +1,21 @@
+#ifndef BOARD_H
+#define BOARD_H
+
+#include "main.h"
+
+struct Board {
+        SDL_Renderer *renderer;
+        bool *board;
+        bool *next_board;
+        int rows;
+        int columns;
+        SDL_Rect rect;
+};
+
+bool board_new(struct Board **board, SDL_Renderer *renderer);
+void board_free(struct Board **board);
+void board_reset(struct Board *b);
+void board_clear(struct Board *b);
+void board_draw(struct Board *b);
+
+#endif