# water.ludic - a body that floats: each step it is buoyed against the surface PhysWater gives,
# carried by its current, and slowed by its drags. Reaching the water is a PHYS_SPLASH fact.
const PH_K: int = 4

# buoyancy 1 floats level with the surface, more rides higher; drags in 1/s. At most 256 float at
# once (a table made with the state): past that a body is simply not buoyed
export function phys_float(physics_st: mut PhysicsState, id: int, buoyancy: float, linear_drag: float, angular_drag: float) -> void {
  ph_buffers()
  phys_sink(physics_st, id)
  if physics_st.ph_nf >= len(physics_st.ph_floats) { return }
  let i = physics_st.ph_nf
  physics_st.ph_floats[i] = id
  physics_st.ph_float_k[i * PH_K] = buoyancy
  physics_st.ph_float_k[i * PH_K + 1] = linear_drag
  physics_st.ph_float_k[i * PH_K + 2] = angular_drag
  physics_st.ph_float_k[i * PH_K + 3] = 0.0
  physics_st.ph_nf += 1
}

# no longer floats (it is still a body): the last one takes its row
export function phys_sink(physics_st: mut PhysicsState, id: int) -> void {
  for i in 0 .. physics_st.ph_nf {
    if physics_st.ph_floats[i] == id {
      let last = physics_st.ph_nf - 1
      physics_st.ph_floats[i] = physics_st.ph_floats[last]
      for k in 0 .. PH_K { physics_st.ph_float_k[i * PH_K + k] = physics_st.ph_float_k[last * PH_K + k] }
      physics_st.ph_nf = last
      return
    }
  }
}

export function phys_floating(physics_st: PhysicsState, id: int) -> bool {
  for i in 0 .. physics_st.ph_nf { if physics_st.ph_floats[i] == id { return true } }
  return false
}

function ph_buoy_all(physics_st: mut PhysicsState) -> void {
  let dt = physics_st.ph_step
  for i in 0 .. physics_st.ph_nf {
    let id = physics_st.ph_floats[i]
    if jph_body_read(physics_st.ph_world, id, physics_st.ph_vals) == 0 {
      ph_buoy_one(physics_st, i, id, physics_st.ph_vals[0], physics_st.ph_vals[2], dt)
    }
  }
}

function ph_buoy_one(physics_st: mut PhysicsState, i: int, id: int, x: float, z: float, dt: float) -> void {
  let sy = PhysWater.height(x, z)
  if sy <= PHYS_NONE { return }
  let k = i * PH_K
  let cx = PhysWater.current_x(x, z)
  let cz = PhysWater.current_z(x, z)
  let kk = physics_st.ph_float_k
  let wet = jph_body_buoyancy(physics_st.ph_world, id, sy, 0.0, 1.0, 0.0, kk[k], kk[k + 1], kk[k + 2], cx, cz, dt)
  if wet == 1 and kk[k + 3] == 0.0 { ph_splash(physics_st, id, x, sy, z) }
  physics_st.ph_float_k[k + 3] = float(wet)
}

function ph_splash(physics_st: mut PhysicsState, id: int, x: float, y: float, z: float) -> void {
  let f = ph_fact_record(physics_st)
  f.what = PHYS_SPLASH
  f.a = id
  f.b = -1
  f.speed = 0.0
  f.x = x;  f.y = y;  f.z = z
  q_push(phys_facts(physics_st), f)
}