ludic/packages/ludic.wildlife/tests/lures_test.ludic

# lures_test.ludic - food of its diet draws an animal and feeding it is a fact with the one who left
# it; the wrong food does not; a snare holds a small animal; thirst finds water; a bird comes to seed
import "ludic.wildlife"
import "ludic.base"
import "fake"
program LuresTest {
  numbers float
  bind WildlifeWorld {
    ground: fn fk_ground
    water: fn fk_water
    players: fn fk_players
    player_on: fn fk_player_on
    player_x: fn fk_x
    player_y: fn fk_y
    player_z: fn fk_z
    lures: fn fk_count
    lure: fn fk_lure
    present: fn fk_present
    spot: fn fk_spot
  }

  function facts(wildlife_st: WildlifeState) -> []WildFact { return q_drain(wildlife_facts(wildlife_st)) }
  function set_out(wildlife_tests_fake_st: mut WildlifeTestsFakeState, uid: int, kind: int, diet: int, x: float, z: float, owner: int) -> WildLure {
    let l = new WildLure
    l.uid = uid
    l.kind = kind
    l.diet = diet
    l.x = x
    l.z = z
    l.owner = owner
    push(wildlife_tests_fake_st.fk_lures, l)
    return l
  }
  function idle(wildlife_st: mut WildlifeState, sp: int, x: float, z: float) -> WildAnimal {
    let a = wildlife_make(wildlife_st, sp, x, z, false, 0.0, 0, 1.0, 7)
    a.timer = 30.0
    return a
  }
  function go(wildlife_st: mut WildlifeState, a: WildAnimal, secs: float) -> void {
    for k in 0 .. int(secs * 20.0) { wildlife_tick_ground(wildlife_st, a, 0.05, 0.05 / 60.0) }
  }

  test "food of its diet draws it in, it eats, and the fact names what and whose" (wildlife_st: mut WildlifeState, wildlife_tests_fake_st: mut WildlifeTestsFakeState) {
    fk_setup(wildlife_st, wildlife_tests_fake_st)
    set_out(wildlife_tests_fake_st, 41, WILD_FEED, WILD_PLANTS, 20.0, 0.0, 3)
    let a = idle(wildlife_st, 0, 0.0, 0.0)
    go(wildlife_st, a, 40.0)
    let fs = facts(wildlife_st)
    var fed = 0
    for i in 0 .. len(fs) {
      if fs[i].what == WILD_FED {
        fed += 1
        expect_eq(fs[i].lure, 41)
        expect_eq(fs[i].owner, 3)
      }
    }
    expect_eq(fed, 1)
    expect(a.calm > 0.0)
  }

  test "food of another diet is left alone" (wildlife_st: mut WildlifeState, wildlife_tests_fake_st: mut WildlifeTestsFakeState) {
    fk_setup(wildlife_st, wildlife_tests_fake_st)
    set_out(wildlife_tests_fake_st, 41, WILD_FEED, WILD_FISH, 20.0, 0.0, -1)
    let a = idle(wildlife_st, 0, 0.0, 0.0)
    go(wildlife_st, a, 5.0)
    expect(a.state != WILD_APPROACH)
    expect_eq(a.lure, 0)
  }

  test "food taken away while it walks is given up" (wildlife_st: mut WildlifeState, wildlife_tests_fake_st: mut WildlifeTestsFakeState) {
    fk_setup(wildlife_st, wildlife_tests_fake_st)
    set_out(wildlife_tests_fake_st, 41, WILD_FEED, WILD_PLANTS, 50.0, 0.0, -1)
    let a = idle(wildlife_st, 0, 0.0, 0.0)
    go(wildlife_st, a, 1.0)
    expect_eq(a.state, WILD_APPROACH)
    wildlife_tests_fake_st.fk_gone = 41
    go(wildlife_st, a, 0.2)
    expect(a.state != WILD_APPROACH)
  }

  test "a snare holds a small animal, the port can find it, and a release lets it go" (wildlife_st: mut WildlifeState, wildlife_tests_fake_st: mut WildlifeTestsFakeState) {
    fk_setup(wildlife_st, wildlife_tests_fake_st)
    let l = set_out(wildlife_tests_fake_st, 55, WILD_SNARE, 0, 10.0, 0.0, -1)
    l.size = 0
    let h = idle(wildlife_st, 2, 0.0, 0.0)
    for k in 0 .. 40 {
      if h.state == WILD_TRAPPED { break }
      go(wildlife_st, h, 2.0)
    }
    expect_eq(h.state, WILD_TRAPPED)
    expect(wildlife_in_snare(wildlife_st, 55) == h)
    let fs = facts(wildlife_st)
    var held = false
    for i in 0 .. len(fs) { if fs[i].what == WILD_CAUGHT and fs[i].lure == 55 { held = true } }
    expect(held)
    wildlife_release(h)
    expect_eq(h.state, WILD_FLEE)
    expect(wildlife_in_snare(wildlife_st, 55) == null)
  }

  test "a thirsty animal walks to the water the port offers, and drinks it down" (wildlife_st: mut WildlifeState, wildlife_tests_fake_st: mut WildlifeTestsFakeState) {
    fk_setup(wildlife_st, wildlife_tests_fake_st)
    let a = idle(wildlife_st, 0, 0.0, 0.0)
    a.thirst = 90.0
    a.state = WILD_WANDER
    go(wildlife_st, a, 0.1)
    expect_eq(a.state, WILD_GO_DRINK)
    expect_eq(a.spot, 900)
    go(wildlife_st, a, 40.0)
    expect(a.thirst < 60.0)
  }

  test "seed down brings a bird out of the sky and it takes it" (wildlife_st: mut WildlifeState, wildlife_tests_fake_st: mut WildlifeTestsFakeState) {
    fk_setup(wildlife_st, wildlife_tests_fake_st)
    set_out(wildlife_tests_fake_st, 77, WILD_FEED, WILD_SEED, 30.0, 0.0, -1)
    let j = wildlife_new(wildlife_st, 3, 0.0, 0.0, false)
    wildlife_tests_fake_st.fk_px[0] = 200.0                               # within 900 m: an animal nobody is near does not think
    wildlife_tests_fake_st.fk_pz[0] = 0.0
    var landed = false
    var ate = false
    for k in 0 .. 4000 {
      wildlife_tick(wildlife_st, 0.05, 0.0)
      if j.state == WILD_PERCH { landed = true }
      let fs = facts(wildlife_st)
      for i in 0 .. len(fs) { if fs[i].what == WILD_FED and fs[i].diet == WILD_SEED { ate = true } }
      if ate { break }
    }
    expect(landed)
    expect(ate)
  }
}