226 lines
7.4 KiB
C
226 lines
7.4 KiB
C
/*
|
|
* Tux-Town is a chill life-simulation game.
|
|
* Copyright (C) 2025 orangerot <me@orangerot.dev>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "raylib.h"
|
|
#include <stddef.h>
|
|
|
|
#define MIN(a,b) (((a)<(b))?(a):(b))
|
|
#define MAX(a,b) (((a)>(b))?(a):(b))
|
|
#define CLAMP2(val, min, max) MIN(max, MAX(min, val))
|
|
#define CLAMP(val, min, max) ((val) < (min) ? (min) : ((val) > (max) ? (max) : (val)))
|
|
#define LROT(v,n) ((v << n) | (v >> (sizeof(v)*8 - n)))
|
|
#define RROT(v,n) ((v >> n) | (v << (sizeof(v)*8 - n)))
|
|
|
|
#define MAP_SIZE 64
|
|
|
|
struct ModelDirection {
|
|
Model model;
|
|
unsigned char pattern;
|
|
};
|
|
|
|
void generate_river(Color *map_data, int previous) {
|
|
int x = previous % MAP_SIZE, y = previous / MAP_SIZE;
|
|
if (x == 0 || x == MAP_SIZE -1 || y == 0 || y == MAP_SIZE -1) return;
|
|
|
|
int local_minimum_map_i = previous;
|
|
int local_minimum_val = 255;
|
|
int gradients[4][2] = {{0,-1},{-1,0},{0,1},{1,0}};
|
|
for (int gradient_i = 0; gradient_i < 4; gradient_i++) {
|
|
int dx = CLAMP(x + gradients[gradient_i][0], 0, MAP_SIZE - 1);
|
|
int dy = CLAMP(y + gradients[gradient_i][1], 0, MAP_SIZE - 1);
|
|
int i = dy * MAP_SIZE + dx;
|
|
if (i == previous || map_data[i].r == 1) continue;
|
|
if (map_data[i].b < local_minimum_val) {
|
|
local_minimum_map_i = i;
|
|
local_minimum_val = map_data[i].b;
|
|
}
|
|
}
|
|
if (local_minimum_val == 255) return;
|
|
map_data[local_minimum_map_i].r = 1;
|
|
generate_river(map_data, local_minimum_map_i);
|
|
}
|
|
|
|
void select_river_tile(Color *map_data, struct ModelDirection *rivers, int x, int y, size_t *river_i, size_t *direction) {
|
|
|
|
int surrounding[8][2] = {{-1,-1},{0,-1},{1,-1},{1,0},{1,1},{0,1},{-1,1},{-1,0}};
|
|
unsigned char river_tile = 0;
|
|
for (int surrounding_i = 0; surrounding_i < 8; surrounding_i++) {
|
|
int dx = CLAMP(x + surrounding[surrounding_i][0], 0, MAP_SIZE - 1);
|
|
int dy = CLAMP(y + surrounding[surrounding_i][1], 0, MAP_SIZE - 1);
|
|
if (map_data[dy * MAP_SIZE + dx].r)
|
|
river_tile |= 1 << (7 - surrounding_i);
|
|
}
|
|
for (*river_i = 0; *river_i < 11; (*river_i)++) {
|
|
for (*direction = 0; *direction < 4; (*direction)++) {
|
|
if ((rivers[*river_i].pattern & RROT(river_tile, 2 * *direction)) == rivers[*river_i].pattern) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
int main(void) {
|
|
const int screenWidth = 800;
|
|
const int screenHeight = 450;
|
|
|
|
InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");
|
|
|
|
Camera camera = { 0 };
|
|
camera.position = (Vector3){ 10.0f, 10.0f, 10.0f };
|
|
camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };
|
|
camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
|
|
camera.fovy = 45.0f;
|
|
camera.projection = CAMERA_PERSPECTIVE;
|
|
|
|
|
|
struct ModelDirection rivers[] = {
|
|
/* 0b12345678
|
|
* 1 | 2 | 3
|
|
* 8 | | 4
|
|
* 7 | 6 | 5
|
|
*/
|
|
{
|
|
.model = LoadModel("assets/kenney_nature-kit/Models/OBJ format/ground_riverOpen.obj"),
|
|
.pattern = 0b11111111
|
|
},
|
|
// edge
|
|
{
|
|
.model = LoadModel("assets/kenney_nature-kit/Models/OBJ format/ground_riverCornerSmall.obj"),
|
|
.pattern = 0b11011111
|
|
},
|
|
{
|
|
.model = LoadModel("assets/kenney_nature-kit/Models/OBJ format/ground_riverSideOpen.obj"),
|
|
.pattern = 0b01011111
|
|
},
|
|
{
|
|
.model = LoadModel("assets/kenney_nature-kit/Models/OBJ format/ground_riverSide.obj"),
|
|
.pattern = 0b11110001
|
|
},
|
|
{
|
|
.model = LoadModel("assets/kenney_nature-kit/Models/OBJ format/ground_riverCross.obj"),
|
|
.pattern = 0b01010101
|
|
},
|
|
{
|
|
.model = LoadModel("assets/kenney_nature-kit/Models/OBJ format/ground_riverSplit.obj"),
|
|
.pattern = 0b01010001
|
|
},
|
|
// STRAIGHT
|
|
{
|
|
.model = LoadModel("assets/kenney_nature-kit/Models/OBJ format/ground_riverStraight.obj"),
|
|
.pattern = 0b01000100
|
|
},
|
|
// corner
|
|
{
|
|
.model = LoadModel("assets/kenney_nature-kit/Models/OBJ format/ground_riverCorner.obj"),
|
|
.pattern = 0b11000001
|
|
},
|
|
// L SHAPE
|
|
{
|
|
.model = LoadModel("assets/kenney_nature-kit/Models/OBJ format/ground_riverBend.obj"),
|
|
.pattern = 0b01000001
|
|
},
|
|
// closed
|
|
{
|
|
.model = LoadModel("assets/kenney_nature-kit/Models/OBJ format/ground_riverEndClosed.obj"),
|
|
.pattern = 0b01000000
|
|
},
|
|
{
|
|
.model = LoadModel("assets/kenney_nature-kit/Models/OBJ format/ground_riverTile.obj"),
|
|
.pattern = 0b00000000
|
|
},
|
|
};
|
|
|
|
Model ground = LoadModel("assets/kenney_nature-kit/Models/OBJ format/ground_grass.obj");
|
|
Model cliff = LoadModel("assets/kenney_nature-kit/Models/OBJ format/cliff_top_rock.obj");
|
|
|
|
Vector3 position = {0};
|
|
Image map = GenImagePerlinNoise(MAP_SIZE, MAP_SIZE, 0, 0, 1.f);
|
|
Texture2D map_texture = LoadTextureFromImage(map);
|
|
Color *map_data = LoadImageColors(map);
|
|
size_t global_minimum_map_i;
|
|
size_t global_minimum_val = 255;
|
|
|
|
for (size_t i = 0; i < MAP_SIZE * MAP_SIZE; i++) {
|
|
int x = i % MAP_SIZE, y = i / MAP_SIZE;
|
|
Color c = map_data[i];
|
|
if (c.r < global_minimum_val) {
|
|
global_minimum_map_i = i;
|
|
global_minimum_val = map_data[i].b;
|
|
}
|
|
map_data[i] = (Color) {
|
|
.r = 0,
|
|
.g = MAX(0, c.g - 64) / 32,
|
|
.b = c.b,
|
|
.a = 255
|
|
};
|
|
}
|
|
|
|
map_data[global_minimum_map_i].r = 1;
|
|
generate_river(map_data, global_minimum_map_i);
|
|
generate_river(map_data, global_minimum_map_i);
|
|
|
|
// SetTargetFPS(60);
|
|
while (!WindowShouldClose()) {
|
|
UpdateCamera(&camera, CAMERA_ORBITAL);
|
|
|
|
BeginDrawing();
|
|
ClearBackground(RAYWHITE);
|
|
BeginMode3D(camera);
|
|
for (int i = 0; i < MAP_SIZE * MAP_SIZE; i++) {
|
|
int x = i % MAP_SIZE, y = i / MAP_SIZE;
|
|
int gradients[4][2] = {{0,-1},{-1,0},{0,1},{1,0}};
|
|
for (int gradient_i = 0; gradient_i < 4; gradient_i++) {
|
|
int dx = CLAMP(x + gradients[gradient_i][0], 0, MAP_SIZE - 1);
|
|
int dy = CLAMP(y + gradients[gradient_i][1], 0, MAP_SIZE - 1);
|
|
for (int height = map_data[i].g; height < map_data[dy * MAP_SIZE + dx].g; height++) {
|
|
DrawModelEx(cliff,
|
|
(Vector3){
|
|
.x = MAP_SIZE * (x / (float) MAP_SIZE - 0.5f),
|
|
.y = height - 8,
|
|
.z = MAP_SIZE * (y / (float) MAP_SIZE - 0.5f)
|
|
},
|
|
(Vector3) {0, 1, 0}, gradient_i * 90.f, (Vector3) {1,1,1}, WHITE);
|
|
}
|
|
}
|
|
size_t river_i, direction;
|
|
if (map_data[i].r) {
|
|
select_river_tile(map_data, rivers, x, y, &river_i, &direction);
|
|
}
|
|
DrawModelEx(map_data[i].r ? rivers[river_i].model : ground,
|
|
(Vector3){
|
|
.x = MAP_SIZE * (x / (float) MAP_SIZE - 0.5f),
|
|
.y = map_data[i].g - 8, //- (map_gradient_magnitude_data[i].g < 2),
|
|
.z = MAP_SIZE * (y / (float) MAP_SIZE - 0.5f)
|
|
} , (Vector3) {0,1,0}, map_data[i].r ? direction * 90.f: 0,
|
|
(Vector3) {1,1,1},
|
|
WHITE);
|
|
}
|
|
DrawGrid(20, 10.0f);
|
|
EndMode3D();
|
|
DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY);
|
|
DrawTexture(map_texture, 0, 0, WHITE);
|
|
EndDrawing();
|
|
}
|
|
|
|
CloseWindow();
|
|
|
|
return 0;
|
|
}
|
|
|