# gear_test.ludic - tiers bought with a fake purse once the standing is there, the item that follows,
# values by tier, the stack's room, a hand whose charges burn down and run out, the save by key
import "ludic.gear"
import "ludic.base"
program GearTest {
  numbers float
  const IT_ROD: int = 3
  const IT_TORCH: int = 5
  const IT_LAMP: int = 6

  def GearKinds rod { tiers: 3, names: [k"gear.rod", k"gear.reel", k"gear.guide_rod"], cost: [30, 100, 300], rep: [0, 10, 40], item: IT_ROD }
  def GearKinds camera { tiers: 2, names: [k"gear.camera", k"gear.zoom"], cost: [0, 150], rep: [0, 20], start: 1 }
  def GearKinds pack { tiers: 3, names: [k"gear.pack", k"gear.frame", k"gear.hauler"], cost: [20, 60, 120], rep: [0, 0, 0], mult: [1.0, 1.3, 1.7, 2.2] }
  def GearValues bite { gear: GEAR_ROD, at: [1.0, 1.0, 0.75, 0.55] }
  def GearValues drain { gear: GEAR_CAMERA, at: [14.0, 14.0, 8.0] }
  def GearCharges torch { item: IT_TORCH, full: 60.0, per_hour: 60.0 }
  def GearCharges lamp { item: IT_LAMP, full: 100.0, rate: GV_DRAIN }
  def GearCharges radio { item: 9, full: 100.0, per_hour: 5.0, hand: false }

  state GearTestState {
    money: int = 0
    rep: int = 0
    pack: []int = null
    hide_pack: bool = false
  }

  function purse_money(gear_test_st: GearTestState) -> int { return gear_test_st.money }
  function purse_spend(gear_test_st: mut GearTestState, n: int) -> bool {
    if n > gear_test_st.money { return false }
    gear_test_st.money -= n
    return true
  }
  function purse_rep(gear_test_st: GearTestState) -> int { return gear_test_st.rep }
  function pack_count(gear_test_st: GearTestState, it: int) -> int { return gear_test_st.pack[it] }
  function pack_add(gear_test_st: mut GearTestState, it: int, n: int) -> int {
    gear_test_st.pack[it] = gear_test_st.pack[it] + n
    return n
  }
  function hidden(gear_test_st: GearTestState, k: int) -> bool { return gear_test_st.hide_pack and k == GEAR_PACK }

  bind GearPurse { money: fn purse_money, spend: fn purse_spend, rep: fn purse_rep }
  bind GearPack { count: fn pack_count, add: fn pack_add }
  bind GearWorld { hidden: fn hidden }

  function fresh(gear_st: mut GearState, gear_test_st: mut GearTestState) -> void {
    gear_test_st.money = 0
    gear_test_st.rep = 0
    gear_test_st.hide_pack = false
    gear_test_st.pack = new []int
    for i in 0 .. 12 { push(gear_test_st.pack, 0) }
    gear_reset(gear_st)
  }

  function ran_out(gear_st: GearState) -> int {
    let fs = q_drain(gear_facts(gear_st))
    var n = -1
    for i in 0 .. len(fs) { if fs[i].what == GEAR_RAN_OUT { n = fs[i].charge } }
    return n
  }

  test "a new trip starts where the kinds say" (gear_st: mut GearState, gear_test_st: mut GearTestState) {
    fresh(gear_st, gear_test_st)
    expect_eq(gear_level(gear_st, GEAR_ROD), 0)
    expect_eq(gear_level(gear_st, GEAR_CAMERA), 1)
    expect(gear_next_name(gear_st, GEAR_CAMERA) == string(k"gear.zoom"))
    expect_eq(gear_next_cost(gear_st, GEAR_ROD), 30)
  }

  test "bought with money once the standing is there, and the item follows" (gear_st: mut GearState, gear_test_st: mut GearTestState) {
    fresh(gear_st, gear_test_st)
    expect(not gear_buy(gear_st, GEAR_ROD))
    gear_test_st.money = 200
    expect(gear_buy(gear_st, GEAR_ROD))
    expect_eq(gear_test_st.money, 170)
    expect_eq(gear_test_st.pack[IT_ROD], 1)
    expect(not gear_can_buy(gear_st, GEAR_ROD))
    gear_test_st.rep = 10
    expect(gear_buy(gear_st, GEAR_ROD))
    expect_eq(gear_test_st.pack[IT_ROD], 1)
    let fs = q_drain(gear_facts(gear_st))
    expect_eq(len(fs), 2)
    expect_eq(fs[1].what, GEAR_BOUGHT)
    expect_eq(fs[1].level, 2)
    expect_eq(fs[1].cost, 100)
  }

  test "the best tier is the end, and a hidden kind is not for sale" (gear_st: mut GearState, gear_test_st: mut GearTestState) {
    fresh(gear_st, gear_test_st)
    gear_test_st.money = 1000
    gear_test_st.rep = 50
    for i in 0 .. 5 { gear_buy(gear_st, GEAR_PACK) }
    expect(gear_best(gear_st, GEAR_PACK))
    expect_eq(gear_level(gear_st, GEAR_PACK), 3)
    fresh(gear_st, gear_test_st)
    gear_test_st.money = 100
    gear_test_st.hide_pack = true
    expect(not gear_buy(gear_st, GEAR_PACK))
    expect_eq(len(gear_kinds_at(-1)), 2)
  }

  test "a tier decides a value and a mult, and the stack's room follows" (gear_st: mut GearState, gear_test_st: mut GearTestState) {
    fresh(gear_st, gear_test_st)
    expect_eq(gear_value(gear_st, GV_BITE), 1.0)
    gear_set_level(gear_st, GEAR_ROD, 3)
    expect_eq(gear_value(gear_st, GV_BITE), 0.55)
    expect_eq(gear_mult(gear_st, GEAR_PACK), 1.0)
    gear_set_level(gear_st, GEAR_PACK, 2)
    expect_eq(gear_mult(gear_st, GEAR_PACK), 1.7)
    expect_eq(gear_stack_limit(10, gear_mult(gear_st, GEAR_PACK)), 17)
    expect_eq(gear_stack_limit(1, 3.0), 1)
    expect_eq(gear_stack_limit(4, 0.1), 1)
    expect_eq(gear_mult(gear_st, GEAR_ROD), 1.0)
  }

  test "a carried item counts as the first tier" (gear_st: mut GearState, gear_test_st: mut GearTestState) {
    fresh(gear_st, gear_test_st)
    gear_test_st.pack[IT_ROD] = 1
    gear_sync(gear_st)
    expect_eq(gear_level(gear_st, GEAR_ROD), 1)
  }

  test "a held charge runs only in the hand, burns by the hour and runs out" (gear_st: mut GearState, gear_test_st: mut GearTestState) {
    fresh(gear_st, gear_test_st)
    let t = CHARGE_TORCH
    expect(not gear_run(gear_st, t, true))
    gear_set_hand(gear_st, IT_TORCH)
    expect(gear_run(gear_st, t, true))
    expect(gear_lit(gear_st))
    gear_system().tick(tick_new(0.1, 1, 0.5))
    expect_eq(gear_charge(gear_st, t), 30.0)
    gear_system().tick(tick_new(0.1, 2, 0.6))
    expect_eq(gear_charge(gear_st, t), 0.0)
    expect(not gear_lit(gear_st))
    expect_eq(ran_out(gear_st), t)
    expect(not gear_run(gear_st, t, true))
  }

  test "a charge's rate can be its tier's, and a new hand puts the light out" (gear_st: mut GearState, gear_test_st: mut GearTestState) {
    fresh(gear_st, gear_test_st)
    gear_set_hand(gear_st, IT_LAMP)
    gear_run(gear_st, CHARGE_LAMP, true)
    gear_system().tick(tick_new(0.1, 1, 1.0))
    expect_eq(gear_charge(gear_st, CHARGE_LAMP), 86.0)
    gear_set_level(gear_st, GEAR_CAMERA, 2)
    gear_system().tick(tick_new(0.1, 2, 1.0))
    expect_eq(gear_charge(gear_st, CHARGE_LAMP), 78.0)
    gear_run(gear_st, CHARGE_RADIO, true)
    gear_set_hand(gear_st, -1)
    expect(not gear_running(gear_st, CHARGE_LAMP))
    expect(gear_running(gear_st, CHARGE_RADIO))
  }

  test "levels and charges are saved by key" (gear_st: mut GearState, gear_test_st: mut GearTestState) {
    fresh(gear_st, gear_test_st)
    gear_set_level(gear_st, GEAR_ROD, 2)
    gear_charge_set(gear_st, CHARGE_TORCH, 12.5)
    let v = gear_save(gear_st)
    fresh(gear_st, gear_test_st)
    gear_load(gear_st, v, 1)
    expect_eq(gear_level(gear_st, GEAR_ROD), 2)
    expect_eq(gear_level(gear_st, GEAR_CAMERA), 1)
    expect_eq(gear_charge(gear_st, CHARGE_TORCH), 12.5)
    expect_eq(gear_charge(gear_st, CHARGE_LAMP), 100.0)
  }
}