# tiers.ludic - what is owned and what a tier is worth
export function gear_ok(k: int) -> bool { return k >= 0 and k < GEAR_COUNT }

export function gear_level(gear_st: GearState, k: int) -> int {
  return gear_st.gear__lv[k]
}

# outright: staging, a test, a camera handed over with the trip
export function gear_set_level(gear_st: mut GearState, k: int, lv: int) -> void {
  gear_st.gear__lv[k] = lv
}

export function gear_owned(gear_st: GearState, k: int) -> bool { return gear_level(gear_st, k) > 0 }

export function gear_best(gear_st: GearState, k: int) -> bool { return gear_level(gear_st, k) >= GearKinds[k].tiers }

# a tier's name, "" for none
export function gear_level_name(k: int, lv: int) -> string {
  if lv <= 0 or lv > GearKinds[k].tiers { return "" }
  @alloc_ok("a cast: a key's marked text, nothing is made")
  return string(GearKinds[k].names[lv - 1])
}

# the tier on offer next: its name, cost and the standing it wants
export function gear_next_name(gear_st: GearState, k: int) -> string { return gear_level_name(k, gear_level(gear_st, k) + 1) }

export function gear_next_cost(gear_st: GearState, k: int) -> int {
  if gear_best(gear_st, k) { return 0 }
  return GearKinds[k].cost[gear_level(gear_st, k)]
}

export function gear_next_rep(gear_st: GearState, k: int) -> int {
  if gear_best(gear_st, k) { return 0 }
  return GearKinds[k].rep[gear_level(gear_st, k)]
}

function gear__pick(xs: []float, lv: int, fallback: float) -> float {
  if xs == null or len(xs) == 0 { return fallback }
  if lv >= len(xs) { return xs[len(xs) - 1] }
  if lv < 0 { return xs[0] }
  return xs[lv]
}

# the kind's own number at its level (1.0 when it has none)
export function gear_mult(gear_st: GearState, k: int) -> float { return gear__pick(GearKinds[k].mult, gear_level(gear_st, k), 1.0) }

# a value its kind's tier decides
export function gear_value(gear_st: GearState, v: int) -> float {
  let d = GearValues[v]
  return gear__pick(d.at, gear_level(gear_st, d.gear), 0.0)
}

# the room for a thing whose base stack is `base`, scaled: a single thing stays single, and a
# stack never falls below one
export function gear_stack_limit(base: int, mult: float) -> int {
  if base <= 1 { return base }
  let s = int(float(base) * mult)
  if s < 1 { return 1 }
  return s
}

# the kinds a vendor sells (-1 every vendor), leaving out what the game hides
export function gear_kinds_at(vendor: int) -> []int {
  let out = new []int
  for k in 0 .. GEAR_COUNT {
    if vendor >= 0 and GearKinds[k].vendor != vendor { continue }
    if GearWorld.hidden(k) { continue }
    push(out, k)
  }
  return out
}