_tilemap.h

#pragma once
#include "_collide.h"
#include <array>
#include <cmath>
#include <initializer_list>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace njin {

inline constexpr i32 tile_chunk_size = 32;

inline constexpr i32 tile_flip_x = 1 << 29;
inline constexpr i32 tile_flip_y = 1 << 30;

constexpr i32 tile_id(i32 value) {
  return value < 0 ? -1 : value & ~(tile_flip_x | tile_flip_y);
}

struct tile_chunk {
  std::array<i32, (usize)tile_chunk_size * tile_chunk_size> tiles;
  i32 filled = 0;  
  u32 version = 0; 
 
  tile_chunk() { tiles.fill(-1); }
};

struct cell {
  i32 x = 0; 
  i32 y = 0; 
};

enum tile_shape : u8 {
  tile_solid = 0,    
  tile_none,         
  tile_one_way,      
  tile_slope_r,      
  tile_slope_l,      
  tile_slope_r_low,  
  tile_slope_r_high, 
  tile_slope_l_low,  
  tile_slope_l_high, 
  tile_shape_count   
};

constexpr bool tile_is_slope(tile_shape shape) {
  return shape >= tile_slope_r && shape <= tile_slope_l_high;
}

constexpr f32 tile_surface(tile_shape shape, f32 u) {
  u = u < 0.0f ? 0.0f : (u > 1.0f ? 1.0f : u);
  switch (shape) {
  case tile_slope_r: return u;
  case tile_slope_l: return 1.0f - u;
  case tile_slope_r_low: return u * 0.5f;
  case tile_slope_r_high: return 0.5f + u * 0.5f;
  case tile_slope_l_low: return (1.0f - u) * 0.5f;
  case tile_slope_l_high: return 0.5f + (1.0f - u) * 0.5f;
  default: return 1.0f;
  }
}

bool tile_shape_from_name(const char *name, tile_shape &out);

struct tile_anim {
  std::vector<i32> frames;    
  std::vector<f32> durations; 
  f32 total = 0.0f;           
};

struct tilemap {
  texture_handle tileset{};     
  vec2 tile_size{16.0f, 16.0f}; 
  f32 margin = 0.0f;  
  f32 spacing = 0.0f; 
  i32 layer = 0;                
  rgba tint{1.0f, 1.0f, 1.0f, 1.0f}; 
  bool visible = true;          
  std::unordered_map<u64, tile_chunk> chunks;
  u32 revision = 0; 
  std::vector<u8> shapes;
  std::unordered_map<i32, tile_anim> anims;
};

inline void tilemap_set_shape(tilemap &map, i32 id, tile_shape shape) {
  if (id < 0)
    return;
  if ((usize)id >= map.shapes.size())
    map.shapes.resize((usize)id + 1, tile_solid);
  map.shapes[(usize)id] = shape;
}

inline tile_shape tilemap_shape(const tilemap &map, i32 value) {
  if (value < 0)
    return tile_none;
  const i32 id = tile_id(value);
  tile_shape s = (usize)id < map.shapes.size() ? (tile_shape)map.shapes[(usize)id] : tile_solid;
  if ((value & tile_flip_x) != 0 && tile_is_slope(s)) {
    switch (s) {
    case tile_slope_r: s = tile_slope_l; break;
    case tile_slope_l: s = tile_slope_r; break;
    case tile_slope_r_low: s = tile_slope_l_low; break;
    case tile_slope_r_high: s = tile_slope_l_high; break;
    case tile_slope_l_low: s = tile_slope_r_low; break;
    case tile_slope_l_high: s = tile_slope_r_high; break;
    default: break;
    }
  }
  return s;
}

inline void tilemap_animate(tilemap &map, i32 id, const std::vector<i32> &frames, f32 seconds) {
  if (id < 0 || frames.empty() || seconds <= 0.0f)
    return;
  tile_anim anim{frames, std::vector<f32>(frames.size(), seconds), seconds * (f32)frames.size()};
  map.anims[id] = std::move(anim);
}

inline i32 tile_anim_frame(const tile_anim &anim, f32 time) {
  if (anim.frames.empty() || anim.total <= 0.0f)
    return -1;
  f32 t = std::fmod(time, anim.total);
  if (t < 0.0f)
    t += anim.total;
  for (usize i = 0; i < anim.frames.size(); i++) {
    const f32 d = i < anim.durations.size() ? anim.durations[i] : 0.0f;
    if (t < d)
      return anim.frames[i];
    t -= d;
  }
  return anim.frames.back();
}

struct move_result {
  vec2 pos{};         
  bool hit_x = false; 
  bool hit_y = false; 
};

constexpr i32 floor_div(i32 a, i32 b) {
  return a >= 0 ? a / b : -((-a + b - 1) / b);
}

constexpr u64 tile_chunk_key(i32 cx, i32 cy) {
  return ((u64)(u32)cx << 32) | (u64)(u32)cy;
}

constexpr cell tile_chunk_coord(u64 key) {
  return {(i32)(u32)(key >> 32), (i32)(u32)(key & 0xffffffffu)};
}

inline i32 tilemap_get(const tilemap &map, i32 x, i32 y) {
  const i32 cx = floor_div(x, tile_chunk_size);
  const i32 cy = floor_div(y, tile_chunk_size);
  const auto it = map.chunks.find(tile_chunk_key(cx, cy));
  if (it == map.chunks.end())
    return -1;
  const i32 lx = x - cx * tile_chunk_size;
  const i32 ly = y - cy * tile_chunk_size;
  return it->second.tiles[(usize)(ly * tile_chunk_size + lx)];
}

inline void tilemap_set(tilemap &map, i32 x, i32 y, i32 id) {
  if (id < -1)
    id = -1;
  const i32 cx = floor_div(x, tile_chunk_size);
  const i32 cy = floor_div(y, tile_chunk_size);
  const u64 key = tile_chunk_key(cx, cy);
  auto it = map.chunks.find(key);
  if (it == map.chunks.end()) {
    if (id < 0)
      return; // xóa một ô vốn đã trống
    it = map.chunks.emplace(key, tile_chunk{}).first;
  }
  tile_chunk &chunk = it->second;
  i32 &slot = chunk.tiles[(usize)((y - cy * tile_chunk_size) * tile_chunk_size +
                                  (x - cx * tile_chunk_size))];
  if (slot == id)
    return;
  chunk.filled += (id >= 0 ? 1 : 0) - (slot >= 0 ? 1 : 0);
  slot = id;
  chunk.version = ++map.revision;
  if (chunk.filled == 0)
    map.chunks.erase(it);
}

inline void tilemap_clear(tilemap &map) {
  map.chunks.clear();
  ++map.revision;
}

struct tile_key {
  char symbol;         
  i32 tile;            
  bool marker = false; 
};

struct tile_marker {
  char symbol; 
  cell at;     
};

inline void tilemap_apply_row(tilemap &map, std::string_view row, i32 y, std::initializer_list<tile_key> legend,
                              cell origin, std::vector<tile_marker> &markers) {
  for (usize i = 0; i < row.size(); i++) {
    const char c = row[i];
    const cell at{origin.x + (i32)i, origin.y + y};
    const tile_key *key = nullptr;
    for (const tile_key &k : legend)
      if (k.symbol == c) {
        key = &k;
        break;
      }
    if (key != nullptr) {
      tilemap_set(map, at.x, at.y, key->tile);
      if (key->marker)
        markers.push_back({c, at});
    } else if (c != ' ' && c != '.' && c != '\t') {
      markers.push_back({c, at});
    }
  }
}

/// @param origin Ô của ký tự đầu tiên. Mặc định `(0, 0)`.
/// @return Các ký tự đánh dấu, theo thứ tự đọc: từ trên xuống, trái sang phải.
inline std::vector<tile_marker> tilemap_from_text(tilemap &map, std::string_view text,
                                                  std::initializer_list<tile_key> legend = {}, cell origin = {}) {
  std::vector<tile_marker> markers;
  usize pos = 0;
  if (text.starts_with("\r\n"))
    pos = 2;
  else if (text.starts_with('\n'))
    pos = 1;
  i32 y = 0;
  while (pos < text.size()) {
    usize end = text.find('\n', pos);
    if (end == std::string_view::npos)
      end = text.size();
    std::string_view row = text.substr(pos, end - pos);
    if (!row.empty() && row.back() == '\r')
      row.remove_suffix(1);
    tilemap_apply_row(map, row, y, legend, origin, markers);
    pos = end + 1;
    y++;
  }
  return markers;
}

/// @param origin Ô của ký tự đầu tiên. Mặc định `(0, 0)`.
/// @return Các ký tự đánh dấu, theo thứ tự đọc.
inline std::vector<tile_marker> tilemap_from_rows(tilemap &map, std::initializer_list<std::string_view> rows,
                                                  std::initializer_list<tile_key> legend = {}, cell origin = {}) {
  std::vector<tile_marker> markers;
  i32 y = 0;
  for (const std::string_view row : rows)
    tilemap_apply_row(map, row, y++, legend, origin, markers);
  return markers;
}

/// @param world_pos Điểm trong thế giới.
/// @return Ô chứa điểm đó.
inline cell tilemap_cell_at(const tilemap &map, vec2 origin, vec2 world_pos) {
  const vec2 local = world_pos - origin;
  return {(i32)std::floor(local.x / map.tile_size.x),
          (i32)std::floor(local.y / map.tile_size.y)};
}

/// @param y Hàng.
/// @return Hình chữ nhật của ô.
inline rect tilemap_cell_rect(const tilemap &map, vec2 origin, i32 x, i32 y) {
  return {{origin.x + (f32)x * map.tile_size.x,
           origin.y + (f32)y * map.tile_size.y},
          map.tile_size};
}

/// @param box Hình chữ nhật cần kiểm tra.
/// @return `true` nếu `box` chồng lên ít nhất một ô không trống.
inline bool tilemap_overlaps(const tilemap &map, vec2 origin, rect box) {
  if (box.size.x <= 0.0f || box.size.y <= 0.0f)
    return false;
  const cell a = tilemap_cell_at(map, origin, box.pos);
  // Trừ một chút để cạnh phải/dưới chạm đúng mép ô không bị tính sang ô kế.
  const cell b =
      tilemap_cell_at(map, origin, box.pos + box.size - vec2{1e-4f, 1e-4f});
  for (i32 y = a.y; y <= b.y; y++) {
    for (i32 x = a.x; x <= b.x; x++) {
      if (tilemap_get(map, x, y) >= 0)
        return true;
    }
  }
  return false;
}

/// @param delta Độ dời mong muốn trong frame này.
/// @return Vị trí mới và trục nào bị chặn.
inline move_result tilemap_move(const tilemap &map, vec2 origin, rect box,
                                vec2 delta) {
  move_result result{box.pos, false, false};
  // Đẩy `r` ra khỏi mọi ô nó chồng lên, ngược hướng của `step` trên một trục.
  const auto resolve = [&](rect &r, f32 step, bool horizontal) {
    const cell a = tilemap_cell_at(map, origin, r.pos);
    const cell b =
        tilemap_cell_at(map, origin, r.pos + r.size - vec2{1e-4f, 1e-4f});
    for (i32 y = a.y; y <= b.y; y++) {
      for (i32 x = a.x; x <= b.x; x++) {
        if (tilemap_get(map, x, y) < 0)
          continue;
        const rect c = tilemap_cell_rect(map, origin, x, y);
        if (horizontal) {
          if (step > 0.0f && r.pos.x + r.size.x > c.pos.x)
            r.pos.x = c.pos.x - r.size.x;
          else if (step < 0.0f && r.pos.x < c.pos.x + c.size.x)
            r.pos.x = c.pos.x + c.size.x;
        } else {
          if (step > 0.0f && r.pos.y + r.size.y > c.pos.y)
            r.pos.y = c.pos.y - r.size.y;
          else if (step < 0.0f && r.pos.y < c.pos.y + c.size.y)
            r.pos.y = c.pos.y + c.size.y;
        }
      }
    }
  };
 
  rect r{{box.pos.x + delta.x, box.pos.y}, box.size};
  if (delta.x != 0.0f && tilemap_overlaps(map, origin, r)) {
    resolve(r, delta.x, true);
    result.hit_x = true;
  }
  r.pos.y += delta.y;
  if (delta.y != 0.0f && tilemap_overlaps(map, origin, r)) {
    resolve(r, delta.y, false);
    result.hit_y = true;
  }
  result.pos = r.pos;
  return result;
}
} // namespace njin