njin_procgen.h

#pragma once
#include "_tilemap.h"
#include "_types.h"
#include <functional>
#include <initializer_list>
#include <string_view>
#include <vector>
 
namespace njin {
 
// ---------------------------------------------------------------------------
// Lưới ô tạm để sinh bản đồ
// ---------------------------------------------------------------------------

struct tile_grid {
  i32 width = 0;           
  i32 height = 0;          
  std::vector<i32> cells{}; 

  bool inside(i32 x, i32 y) const { return x >= 0 && y >= 0 && x < width && y < height; }
  i32 get(i32 x, i32 y) const { return inside(x, y) ? cells[(usize)(y * width + x)] : -1; }
  void set(i32 x, i32 y, i32 tile) {
    if (inside(x, y))
      cells[(usize)(y * width + x)] = tile;
  }
};

tile_grid tile_grid_make(i32 width, i32 height, i32 fill = -1);

tile_grid tile_grid_from_text(std::string_view text, std::initializer_list<tile_key> legend);

void tilemap_from_grid(tilemap &map, const tile_grid &grid, cell origin = {});

i32 grid_count(const tile_grid &grid, i32 tile);
 
// ---------------------------------------------------------------------------
// Nhiễu
// ---------------------------------------------------------------------------

enum noise_type {
  noise_perlin, 
  noise_value,  
};

enum noise_fractal {
  fractal_none,   
  fractal_fbm,    
  fractal_ridged, 
  fractal_billow, 
};

struct noise_desc {
  u32 seed = 1;                          
  noise_type type = noise_perlin;        
  f32 frequency = 0.05f;                 
  noise_fractal fractal = fractal_fbm;   
  i32 octaves = 4;                       
  f32 lacunarity = 2.0f;                 
  f32 gain = 0.5f;                       
  f32 warp = 0.0f;                       
  f32 warp_frequency = 0.03f;            
};

f32 noise_2d(const noise_desc &desc, f32 x, f32 y);

f32 noise_1d(const noise_desc &desc, f32 x);
 
// ---------------------------------------------------------------------------
// Luật: làm bản đồ trông tự nhiên
// ---------------------------------------------------------------------------

enum grid_side : u8 {
  side_up = 1,    
  side_down = 2,  
  side_left = 4,  
  side_right = 8, 
  side_all = 15,  
};

void grid_majority(tile_grid &grid, i32 iterations = 1, i32 threshold = 5);

void grid_smooth(tile_grid &grid, i32 solid, i32 open, i32 iterations = 3, i32 threshold = 5);

i32 grid_remove_small(tile_grid &grid, i32 tile, i32 min_size, i32 replace);

i32 grid_merge_small(tile_grid &grid, i32 min_size);

i32 grid_keep_largest(tile_grid &grid, std::initializer_list<i32> walkable, i32 replace);

i32 grid_border(tile_grid &grid, i32 tile, i32 touching, i32 replace, u8 sides = side_all, i32 distance = 1);

i32 grid_scatter(tile_grid &grid, i32 on, i32 place, f32 chance, u32 seed, i32 min_distance = 0);

i32 grid_scatter(tile_grid &grid, i32 place, f32 chance, u32 seed,
                 const std::function<bool(const tile_grid &, i32, i32)> &where, i32 min_distance = 0);
 
// ---------------------------------------------------------------------------
// Bo góc tự nhiên: autotile
// ---------------------------------------------------------------------------

enum autotile_layout {
  autotile_edges,
  autotile_blob,
};

enum autotile_neighbor : u8 {
  neighbor_up = 1,          
  neighbor_up_right = 2,    
  neighbor_right = 4,       
  neighbor_down_right = 8,  
  neighbor_down = 16,       
  neighbor_down_left = 32,  
  neighbor_left = 64,       
  neighbor_up_left = 128,   
};

i32 autotile_count(autotile_layout layout);

i32 autotile_index(u8 mask, autotile_layout layout = autotile_blob);

struct autotile_rule {
  std::vector<i32> tiles{};
  std::vector<i32> joins{};
  i32 base = 0;                        
  autotile_layout layout = autotile_blob; 
  u8 outside = side_all;
};

i32 grid_autotile(tile_grid &grid, const std::vector<autotile_rule> &rules);
 
// ---------------------------------------------------------------------------
// Top-down: vùng đất theo độ cao và độ ẩm
// ---------------------------------------------------------------------------

struct biome {
  i32 tile;                 
  f32 max_height = 1.0f;    
  f32 max_moisture = 1.0f;  
};

struct topdown_gen_desc {
  i32 width = 64;                 
  i32 height = 64;                
  noise_desc height_noise{};      
  noise_desc moisture_noise{.seed = 7919, .frequency = 0.03f, .octaves = 3};
  std::vector<biome> biomes{};    
  f32 island = 0.0f;              
  bool normalize = true;
  i32 smooth = 1;                 
  i32 min_region = 6;             
  std::vector<i32> walkable{};
  i32 blocked_tile = -1;          
  i32 border_tile = -1;           
};

struct topdown_gen_result {
  tile_grid grid{};               
  std::vector<f32> heights{};     
  cell spawn{};                   
};

topdown_gen_result generate_topdown(const topdown_gen_desc &desc);
 
// ---------------------------------------------------------------------------
// Platformer: mặt đất, hang, hố, bục
// ---------------------------------------------------------------------------

struct platformer_gen_desc {
  i32 width = 120;                  
  i32 height = 30;                  
  noise_desc surface_noise{.seed = 1, .frequency = 0.04f, .octaves = 3};
  i32 ground_min = 12;              
  i32 ground_max = 24;              
  i32 max_step = 2;                 
  i32 surface_tile = 0;             
  i32 dirt_tile = 1;                
  i32 deep_tile = -1;               
  i32 deep_depth = 6;               
  i32 slope_r_tile = -1;
  i32 slope_l_tile = -1;            
  noise_desc cave_noise{.seed = 3, .frequency = 0.09f, .octaves = 2};
  f32 caves = 0.0f;
  i32 cave_margin = 4;              
  f32 pit_chance = 0.0f;            
  i32 pit_min = 1;                  
  i32 pit_max = 2;
  i32 safe_columns = 6;             
  f32 platform_chance = 0.0f;       
  i32 platform_tile = -1;           
  i32 platform_min = 3;             
  i32 platform_max = 5;             
  i32 platform_height = 3;          
};

struct platformer_gen_result {
  tile_grid grid{};                 
  std::vector<i32> surface{};       
  cell spawn{};                     
  cell goal{};                      
};

platformer_gen_result generate_platformer(const platformer_gen_desc &desc);
 
// ---------------------------------------------------------------------------
// Wave Function Collapse
// ---------------------------------------------------------------------------

enum wfc_dir { wfc_right, wfc_down, wfc_left, wfc_up };

struct wfc_rules {
  std::vector<i32> tiles{};             
  std::vector<f32> weights{};           
  std::vector<u64> allow{};
  i32 words = 0;                        
};

i32 wfc_add_tile(wfc_rules &rules, i32 tile, f32 weight = 1.0f);

void wfc_allow(wfc_rules &rules, i32 a, wfc_dir dir, i32 b);

wfc_rules wfc_learn(const tile_grid &sample, bool periodic = false);

struct wfc_desc {
  i32 width = 32;         
  i32 height = 32;        
  u32 seed = 1;           
  i32 attempts = 20;      
  bool periodic = false;  
  std::function<bool(i32 x, i32 y, i32 tile)> allowed{};
};

bool wfc_generate(const wfc_rules &rules, const wfc_desc &desc, tile_grid &out);

} // namespace njin