# queries.ludic - what the rules ask: the sum for a kind right now, and what is running
function ef_live(e: Effect) -> bool { return e.delay < 0.01 }

# what the rules should add for a kind right now (a delayed one counts only once it begins)
export function effects_sum(effects_st: EffectsState, kind: int) -> float {
  let all = ef_all(effects_st)
  var t = 0.0
  for i in 0 .. len(all) { if all[i].kind == kind and ef_live(all[i]) { t = t + all[i].mag } }
  return t
}

export function effects_has(effects_st: EffectsState, kind: int) -> bool {
  let all = ef_all(effects_st)
  for i in 0 .. len(all) { if all[i].kind == kind and ef_live(all[i]) { return true } }
  return false
}

export function effects_bonus_count(effects_st: EffectsState) -> int {
  let all = ef_all(effects_st)
  var n = 0
  for i in 0 .. len(all) { if all[i].bonus { n += 1 } }
  return n
}

# everything held, delayed or not, in the order added
export function effects_count(effects_st: EffectsState) -> int { return len(ef_all(effects_st)) }

# a copy, so a reader cannot change the ring
export function effects_at(effects_st: EffectsState, i: int) -> Effect {
  let src = ef_all(effects_st)[i]
  let e = new Effect
  e.kind = src.kind
  e.mag = src.mag
  e.left = src.left
  e.delay = src.delay
  e.bonus = src.bonus
  e.label = src.label
  return e
}

# the indices of the ones that have begun, for a read-out (a frame's read-out fills its own list)
export function effects_live(effects_st: EffectsState) -> []int {
  let out = new []int
  effects_live_into(effects_st, out)
  return out
}

export function effects_live_into(effects_st: EffectsState, out: []int) -> void {
  List.clear(out)
  let all = ef_all(effects_st)
  @alloc_ok("into the caller's kept list, at most the ring's size")
  for i in 0 .. len(all) { if ef_live(all[i]) { push(out, i) } }
}

export function effects_live_count(effects_st: EffectsState) -> int {
  var n = 0
  let all = ef_all(effects_st)
  for i in 0 .. len(all) { if ef_live(all[i]) { n += 1 } }
  return n
}