wip(0.S2): migrate - a var nothing writes becomes a let; a state is keyed by its module, directory or program, so every program's plan agrees; paths normalized; program states named SceneDemoState / scene_demo_st; the LSP reads state, mut and entry/handler parameters
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
parent
3eda72e8c2
commit
5ffe50ed02
463 changed files with 72045 additions and 67421 deletions
|
|
@ -1,16 +1,16 @@
|
|||
# fight.ludic - what takes, how big it is, and the green band the marker has to cross in
|
||||
# a legend on a lure, likelier in deep water and with skill; else an everyday one by weight
|
||||
function fishing_pick(fishing_st: mut FishingState) -> int {
|
||||
function fishing_pick() -> int {
|
||||
let leg = fishing_legend()
|
||||
if leg >= 0 and fishing_st.fishing_lure_on {
|
||||
if leg >= 0 and fishing_lure_on {
|
||||
let k = FishSpecies[leg]
|
||||
var p = k.chance
|
||||
if FishingWorld.afloat() or FishingWorld.depth(fishing_st.fishing_bx, fishing_st.fishing_bz) >= fishing_st.fishing_deep { p = k.chance_deep }
|
||||
if fishing_rand(fishing_st) < p + FishingWorld.skill() { return leg }
|
||||
if FishingWorld.afloat() or FishingWorld.depth(fishing_bx, fishing_bz) >= fishing_deep { p = k.chance_deep }
|
||||
if fishing_rand() < p + FishingWorld.skill() { return leg }
|
||||
}
|
||||
var total = 0.0
|
||||
for s in 0 .. FISH_COUNT { if not FishSpecies[s].legend { total = total + FishSpecies[s].weight } }
|
||||
var r = fishing_rand(fishing_st) * total
|
||||
var r = fishing_rand() * total
|
||||
var last = -1
|
||||
for s in 0 .. FISH_COUNT {
|
||||
if FishSpecies[s].legend { continue }
|
||||
|
|
@ -21,37 +21,37 @@ function fishing_pick(fishing_st: mut FishingState) -> int {
|
|||
return last
|
||||
}
|
||||
|
||||
function fishing_size(fishing_st: mut FishingState, s: int) -> int {
|
||||
function fishing_size(s: int) -> int {
|
||||
let k = FishSpecies[s]
|
||||
let spread = int(fishing_rand(fishing_st) * float(k.cm_spread + 1))
|
||||
let spread = int(fishing_rand() * float(k.cm_spread + 1))
|
||||
return k.cm_min + spread + int(FishingWorld.skill() * k.skill_cm)
|
||||
}
|
||||
|
||||
# the green's half width this crossing: a fish that closes it does so at every rung, and Hard
|
||||
# closes it for everything else
|
||||
export function fishing_window(fishing_st: FishingState) -> float {
|
||||
if not fishing_kind_ok(fishing_st.fishing_sp) { return 0.12 }
|
||||
let k = FishSpecies[fishing_st.fishing_sp]
|
||||
let hw = FishingWorld.window(fishing_st.fishing_sp)
|
||||
if k.closes > 0.0 { return Math.max(hw * (1.0 - k.closes * float(fishing_st.fishing_won)), hw * k.floor) }
|
||||
if FishingWorld.level() == FISHING_HARD { return Math.max(hw * (1.0 - 0.10 * float(fishing_st.fishing_won)), hw * 0.55) }
|
||||
export function fishing_window() -> float {
|
||||
if not fishing_kind_ok(fishing_sp) { return 0.12 }
|
||||
let k = FishSpecies[fishing_sp]
|
||||
let hw = FishingWorld.window(fishing_sp)
|
||||
if k.closes > 0.0 { return Math.max(hw * (1.0 - k.closes * float(fishing_won)), hw * k.floor) }
|
||||
if FishingWorld.level() == FISHING_HARD { return Math.max(hw * (1.0 - 0.10 * float(fishing_won)), hw * 0.55) }
|
||||
return hw
|
||||
}
|
||||
|
||||
export function fishing_window_lo(fishing_st: FishingState) -> float { return Math.clamp(fishing_st.fishing_win_c - fishing_window(fishing_st), 0.0, 1.0) }
|
||||
export function fishing_window_hi(fishing_st: FishingState) -> float { return Math.clamp(fishing_st.fishing_win_c + fishing_window(fishing_st), 0.0, 1.0) }
|
||||
export function fishing_window_lo() -> float { return Math.clamp(fishing_win_c - fishing_window(), 0.0, 1.0) }
|
||||
export function fishing_window_hi() -> float { return Math.clamp(fishing_win_c + fishing_window(), 0.0, 1.0) }
|
||||
|
||||
# where it sits: the middle on Relaxed, somewhere new each crossing above it
|
||||
function fishing_new_window(fishing_st: mut FishingState) -> void {
|
||||
function fishing_new_window() -> void {
|
||||
let lv = FishingWorld.level()
|
||||
if lv == FISHING_RELAXED or fishing_st.fishing_gentle_on {
|
||||
fishing_st.fishing_win_c = 0.5
|
||||
if lv == FISHING_RELAXED or fishing_gentle_on {
|
||||
fishing_win_c = 0.5
|
||||
return
|
||||
}
|
||||
let hw = fishing_window(fishing_st) + 0.05
|
||||
fishing_st.fishing_win_c = hw + fishing_rand(fishing_st) * (1.0 - hw - hw)
|
||||
let hw = fishing_window() + 0.05
|
||||
fishing_win_c = hw + fishing_rand() * (1.0 - hw - hw)
|
||||
}
|
||||
|
||||
function fishing_in_window(fishing_st: FishingState) -> bool {
|
||||
return fishing_st.fishing_mark > fishing_st.fishing_win_c - fishing_window(fishing_st) and fishing_st.fishing_mark < fishing_st.fishing_win_c + fishing_window(fishing_st)
|
||||
function fishing_in_window() -> bool {
|
||||
return fishing_mark > fishing_win_c - fishing_window() and fishing_mark < fishing_win_c + fishing_window()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,64 +1,64 @@
|
|||
# run.ludic - `dt` real seconds of a line in the water: the wait, the bite, and the fight
|
||||
function fishing_run_wait(base_st: mut BaseState, fishing_st: mut FishingState) -> void {
|
||||
if fishing_st.fishing_t >= 0.0 { return }
|
||||
fishing_st.fishing_st = FISHING_BITE_ON
|
||||
fishing_st.fishing_t = 1.6
|
||||
fishing_st.fishing_sp = fishing_pick(fishing_st)
|
||||
fishing_say(base_st, fishing_st, FISHING_BITE)
|
||||
function fishing_run_wait() -> void {
|
||||
if fishing_t >= 0.0 { return }
|
||||
fishing_st = FISHING_BITE_ON
|
||||
fishing_t = 1.6
|
||||
fishing_sp = fishing_pick()
|
||||
fishing_say(FISHING_BITE)
|
||||
}
|
||||
|
||||
# a fish that runs: the marker is all over the bar and nothing done with it helps
|
||||
function fishing_run_runs(base_st: mut BaseState, fishing_st: mut FishingState, dt: float) -> float {
|
||||
let k = FishSpecies[fishing_st.fishing_sp]
|
||||
if fishing_st.fishing_run_t > 0.0 {
|
||||
fishing_st.fishing_run_t = fishing_st.fishing_run_t - dt
|
||||
if fishing_st.fishing_run_t <= 0.0 {
|
||||
fishing_st.fishing_run_t = 0.0
|
||||
fishing_say(base_st, fishing_st, FISHING_TIRED)
|
||||
function fishing_run_runs(dt: float) -> float {
|
||||
let k = FishSpecies[fishing_sp]
|
||||
if fishing_run_t > 0.0 {
|
||||
fishing_run_t = fishing_run_t - dt
|
||||
if fishing_run_t <= 0.0 {
|
||||
fishing_run_t = 0.0
|
||||
fishing_say(FISHING_TIRED)
|
||||
}
|
||||
return 4.2
|
||||
}
|
||||
if fishing_st.fishing_run_left > 0 {
|
||||
fishing_st.fishing_run_next = fishing_st.fishing_run_next - dt
|
||||
if fishing_st.fishing_run_next <= 0.0 {
|
||||
fishing_st.fishing_run_left -= 1
|
||||
fishing_st.fishing_run_t = 2.2
|
||||
fishing_st.fishing_run_next = 4.0 + fishing_rand(fishing_st) * 4.0
|
||||
fishing_say(base_st, fishing_st, FISHING_RUNS)
|
||||
if fishing_run_left > 0 {
|
||||
fishing_run_next = fishing_run_next - dt
|
||||
if fishing_run_next <= 0.0 {
|
||||
fishing_run_left -= 1
|
||||
fishing_run_t = 2.2
|
||||
fishing_run_next = 4.0 + fishing_rand() * 4.0
|
||||
fishing_say(FISHING_RUNS)
|
||||
}
|
||||
}
|
||||
return k.speed + k.speed_per_hit * float(fishing_st.fishing_won)
|
||||
return k.speed + k.speed_per_hit * float(fishing_won)
|
||||
}
|
||||
|
||||
function fishing_run_reel(base_st: mut BaseState, fishing_st: mut FishingState, dt: float) -> void {
|
||||
let sp = fishing_run_runs(base_st, fishing_st, dt)
|
||||
if fishing_st.fishing_gentle_on {
|
||||
fishing_st.fishing_ring_t = fishing_st.fishing_ring_t - dt
|
||||
if fishing_st.fishing_ring_t <= 0.0 { fishing_lost(base_st, fishing_st, FISHING_LINE_SNAPPED) }
|
||||
function fishing_run_reel(dt: float) -> void {
|
||||
let sp = fishing_run_runs(dt)
|
||||
if fishing_gentle_on {
|
||||
fishing_ring_t = fishing_ring_t - dt
|
||||
if fishing_ring_t <= 0.0 { fishing_lost(FISHING_LINE_SNAPPED) }
|
||||
return
|
||||
}
|
||||
fishing_st.fishing_mark = fishing_st.fishing_mark + sp * fishing_st.fishing_dir * dt
|
||||
if fishing_st.fishing_mark > 1.0 {
|
||||
fishing_st.fishing_mark = 1.0
|
||||
fishing_st.fishing_dir = -1.0
|
||||
fishing_mark = fishing_mark + sp * fishing_dir * dt
|
||||
if fishing_mark > 1.0 {
|
||||
fishing_mark = 1.0
|
||||
fishing_dir = -1.0
|
||||
}
|
||||
if fishing_st.fishing_mark < 0.0 {
|
||||
fishing_st.fishing_mark = 0.0
|
||||
fishing_st.fishing_dir = 1.0
|
||||
if fishing_mark < 0.0 {
|
||||
fishing_mark = 0.0
|
||||
fishing_dir = 1.0
|
||||
}
|
||||
if fishing_st.fishing_t < 0.0 { fishing_lost(base_st, fishing_st, FISHING_SLACK) }
|
||||
if fishing_t < 0.0 { fishing_lost(FISHING_SLACK) }
|
||||
}
|
||||
|
||||
export function fishing_run(base_st: mut BaseState, fishing_st: mut FishingState, dt: float) -> void {
|
||||
if fishing_st.fishing_st == FISHING_OFF { return }
|
||||
fishing_st.fishing_t = fishing_st.fishing_t - dt
|
||||
if fishing_st.fishing_st == FISHING_WAIT {
|
||||
fishing_run_wait(base_st, fishing_st)
|
||||
export function fishing_run(dt: float) -> void {
|
||||
if fishing_st == FISHING_OFF { return }
|
||||
fishing_t = fishing_t - dt
|
||||
if fishing_st == FISHING_WAIT {
|
||||
fishing_run_wait()
|
||||
return
|
||||
}
|
||||
if fishing_st.fishing_st == FISHING_BITE_ON {
|
||||
if fishing_st.fishing_t < 0.0 { fishing_lost(base_st, fishing_st, FISHING_MISSED) }
|
||||
if fishing_st == FISHING_BITE_ON {
|
||||
if fishing_t < 0.0 { fishing_lost(FISHING_MISSED) }
|
||||
return
|
||||
}
|
||||
fishing_run_reel(base_st, fishing_st, dt)
|
||||
fishing_run_reel(dt)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,88 +4,86 @@ export const FISHING_WAIT: int = 1
|
|||
export const FISHING_BITE_ON: int = 2
|
||||
export const FISHING_REEL: int = 3
|
||||
|
||||
export state FishingState {
|
||||
fishing_st: int = 0
|
||||
fishing_t: float = 0.0 # seconds: to the bite, of the bite, of the fight
|
||||
fishing_bx: float = 0.0 # where the line is in the water
|
||||
fishing_bz: float = 0.0
|
||||
fishing_sp: int = -1 # what is on it
|
||||
fishing_len: int = 0 # cm
|
||||
fishing_bait_on: bool = false
|
||||
fishing_lure_on: bool = false
|
||||
fishing_mark: float = 0.0 # 0..1 across the bar
|
||||
fishing_dir: float = 1.0
|
||||
fishing_win_c: float = 0.5 # where the green sits this crossing
|
||||
fishing_ring_t: float = 0.0 # Gentle: seconds left to press
|
||||
fishing_gentle_on: bool = false
|
||||
fishing_won: int = 0 # crossings won
|
||||
fishing_need_n: int = 3
|
||||
fishing_run_t: float = 0.0 # seconds left of a run
|
||||
fishing_run_left: int = 0
|
||||
fishing_run_next: float = 0.0
|
||||
fishing_dice: Rng = null
|
||||
fishing_fact_q: Queue<FishingFact> = null
|
||||
fishing_n: int = 0 # the record: caught, the biggest (cm), a legend landed
|
||||
fishing_big: int = 0
|
||||
fishing_leg: bool = false
|
||||
fishing_min_depth: float = 0.15 # a cast needs this much water
|
||||
fishing_deep: float = 2.5 # a legend's deep-water chance from here down
|
||||
fishing_seed_n: int = 4242
|
||||
}
|
||||
var fishing_st: int = 0
|
||||
var fishing_t: float = 0.0 # seconds: to the bite, of the bite, of the fight
|
||||
var fishing_bx: float = 0.0 # where the line is in the water
|
||||
var fishing_bz: float = 0.0
|
||||
var fishing_sp: int = -1 # what is on it
|
||||
var fishing_len: int = 0 # cm
|
||||
var fishing_bait_on: bool = false
|
||||
var fishing_lure_on: bool = false
|
||||
var fishing_mark: float = 0.0 # 0..1 across the bar
|
||||
var fishing_dir: float = 1.0
|
||||
var fishing_win_c: float = 0.5 # where the green sits this crossing
|
||||
var fishing_ring_t: float = 0.0 # Gentle: seconds left to press
|
||||
var fishing_gentle_on: bool = false
|
||||
var fishing_won: int = 0 # crossings won
|
||||
var fishing_need_n: int = 3
|
||||
var fishing_run_t: float = 0.0 # seconds left of a run
|
||||
var fishing_run_left: int = 0
|
||||
var fishing_run_next: float = 0.0
|
||||
var fishing_dice: Rng = null
|
||||
var fishing_fact_q: Queue<FishingFact> = null
|
||||
var fishing_n: int = 0 # the record: caught, the biggest (cm), a legend landed
|
||||
var fishing_big: int = 0
|
||||
var fishing_leg: bool = false
|
||||
|
||||
var fishing_min_depth: float = 0.15 # a cast needs this much water
|
||||
var fishing_deep: float = 2.5 # a legend's deep-water chance from here down
|
||||
var fishing_seed_n: int = 4242
|
||||
|
||||
# a cast needs `min_depth` metres; `deep` is where a legend is likelier; the line's own dice
|
||||
export function fishing_config(fishing_st: mut FishingState, min_depth: float, deep: float, seed: int) -> void {
|
||||
fishing_st.fishing_min_depth = min_depth
|
||||
fishing_st.fishing_deep = deep
|
||||
fishing_st.fishing_seed_n = seed
|
||||
fishing_st.fishing_dice = rng_new(seed)
|
||||
export function fishing_config(min_depth: float, deep: float, seed: int) -> void {
|
||||
fishing_min_depth = min_depth
|
||||
fishing_deep = deep
|
||||
fishing_seed_n = seed
|
||||
fishing_dice = rng_new(seed)
|
||||
}
|
||||
|
||||
export function fishing_facts(base_st: mut BaseState, fishing_st: mut FishingState) -> Queue<FishingFact> {
|
||||
if fishing_st.fishing_fact_q == null { fishing_st.fishing_fact_q = queue_new(base_st, "fishing.facts") }
|
||||
return fishing_st.fishing_fact_q
|
||||
export function fishing_facts() -> Queue<FishingFact> {
|
||||
if fishing_fact_q == null { fishing_fact_q = queue_new("fishing.facts") }
|
||||
return fishing_fact_q
|
||||
}
|
||||
|
||||
function fishing_rand(fishing_st: mut FishingState) -> float {
|
||||
if fishing_st.fishing_dice == null { fishing_st.fishing_dice = rng_new(fishing_st.fishing_seed_n) }
|
||||
return rng_float(fishing_st.fishing_dice)
|
||||
function fishing_rand() -> float {
|
||||
if fishing_dice == null { fishing_dice = rng_new(fishing_seed_n) }
|
||||
return rng_float(fishing_dice)
|
||||
}
|
||||
|
||||
function fishing_say(base_st: mut BaseState, fishing_st: mut FishingState, what: int) -> void {
|
||||
function fishing_say(what: int) -> void {
|
||||
let f = new FishingFact
|
||||
f.what = what
|
||||
f.species = fishing_st.fishing_sp
|
||||
f.cm = fishing_st.fishing_len
|
||||
f.kg = fishing_weight_of(fishing_st.fishing_sp, fishing_st.fishing_len)
|
||||
f.hits = fishing_st.fishing_won
|
||||
f.need = fishing_st.fishing_need_n
|
||||
f.bait = fishing_st.fishing_bait_on
|
||||
f.lure = fishing_st.fishing_lure_on
|
||||
f.x = fishing_st.fishing_bx
|
||||
f.z = fishing_st.fishing_bz
|
||||
q_push(base_st, fishing_facts(base_st, fishing_st), f)
|
||||
f.species = fishing_sp
|
||||
f.cm = fishing_len
|
||||
f.kg = fishing_weight_of(fishing_sp, fishing_len)
|
||||
f.hits = fishing_won
|
||||
f.need = fishing_need_n
|
||||
f.bait = fishing_bait_on
|
||||
f.lure = fishing_lure_on
|
||||
f.x = fishing_bx
|
||||
f.z = fishing_bz
|
||||
q_push(fishing_facts(), f)
|
||||
}
|
||||
|
||||
export function fishing_state(fishing_st: FishingState) -> int { return fishing_st.fishing_st }
|
||||
export function fishing_active(fishing_st: FishingState) -> bool { return fishing_st.fishing_st != FISHING_OFF }
|
||||
export function fishing_species(fishing_st: FishingState) -> int { return fishing_st.fishing_sp }
|
||||
export function fishing_cm(fishing_st: FishingState) -> int { return fishing_st.fishing_len }
|
||||
export function fishing_line_x(fishing_st: FishingState) -> float { return fishing_st.fishing_bx }
|
||||
export function fishing_line_z(fishing_st: FishingState) -> float { return fishing_st.fishing_bz }
|
||||
export function fishing_marker(fishing_st: FishingState) -> float { return fishing_st.fishing_mark }
|
||||
export function fishing_hits(fishing_st: FishingState) -> int { return fishing_st.fishing_won }
|
||||
export function fishing_need(fishing_st: FishingState) -> int { return fishing_st.fishing_need_n }
|
||||
export function fishing_running(fishing_st: FishingState) -> bool { return fishing_st.fishing_run_t > 0.0 }
|
||||
export function fishing_gentle(fishing_st: FishingState) -> bool { return fishing_st.fishing_gentle_on }
|
||||
export function fishing_ring(fishing_st: FishingState) -> float { return fishing_st.fishing_ring_t }
|
||||
export function fishing_baited(fishing_st: FishingState) -> bool { return fishing_st.fishing_bait_on }
|
||||
export function fishing_lured(fishing_st: FishingState) -> bool { return fishing_st.fishing_lure_on }
|
||||
export function fishing_caught(fishing_st: FishingState) -> int { return fishing_st.fishing_n }
|
||||
export function fishing_biggest(fishing_st: FishingState) -> int { return fishing_st.fishing_big }
|
||||
export function fishing_legend_caught(fishing_st: FishingState) -> bool { return fishing_st.fishing_leg }
|
||||
export function fishing_state() -> int { return fishing_st }
|
||||
export function fishing_active() -> bool { return fishing_st != FISHING_OFF }
|
||||
export function fishing_species() -> int { return fishing_sp }
|
||||
export function fishing_cm() -> int { return fishing_len }
|
||||
export function fishing_line_x() -> float { return fishing_bx }
|
||||
export function fishing_line_z() -> float { return fishing_bz }
|
||||
export function fishing_marker() -> float { return fishing_mark }
|
||||
export function fishing_hits() -> int { return fishing_won }
|
||||
export function fishing_need() -> int { return fishing_need_n }
|
||||
export function fishing_running() -> bool { return fishing_run_t > 0.0 }
|
||||
export function fishing_gentle() -> bool { return fishing_gentle_on }
|
||||
export function fishing_ring() -> float { return fishing_ring_t }
|
||||
export function fishing_baited() -> bool { return fishing_bait_on }
|
||||
export function fishing_lured() -> bool { return fishing_lure_on }
|
||||
export function fishing_caught() -> int { return fishing_n }
|
||||
export function fishing_biggest() -> int { return fishing_big }
|
||||
export function fishing_legend_caught() -> bool { return fishing_leg }
|
||||
|
||||
# can a line land at (x, z)?
|
||||
export function fishing_water_at(fishing_st: FishingState, x: float, z: float) -> bool {
|
||||
return FishingWorld.afloat() or FishingWorld.depth(x, z) >= fishing_st.fishing_min_depth
|
||||
export function fishing_water_at(x: float, z: float) -> bool {
|
||||
return FishingWorld.afloat() or FishingWorld.depth(x, z) >= fishing_min_depth
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,35 +1,35 @@
|
|||
# system.ludic - fishing as a system: its tick, and the record in its own save section (a line in
|
||||
# the water is never saved)
|
||||
export function fishing_reset(base_st: mut BaseState, fishing_st: mut FishingState) -> void {
|
||||
fishing_stop(fishing_st)
|
||||
fishing_st.fishing_n = 0
|
||||
fishing_st.fishing_big = 0
|
||||
fishing_st.fishing_leg = false
|
||||
fishing_st.fishing_dice = rng_new(fishing_st.fishing_seed_n)
|
||||
q_clear(base_st, fishing_facts(base_st, fishing_st))
|
||||
export function fishing_reset() -> void {
|
||||
fishing_stop()
|
||||
fishing_n = 0
|
||||
fishing_big = 0
|
||||
fishing_leg = false
|
||||
fishing_dice = rng_new(fishing_seed_n)
|
||||
q_clear(fishing_facts())
|
||||
}
|
||||
|
||||
# the record outright (staging, a test, the network's word)
|
||||
export function fishing_record_set(fishing_st: mut FishingState, caught: int, biggest: int, legend: bool) -> void {
|
||||
fishing_st.fishing_n = caught
|
||||
fishing_st.fishing_big = biggest
|
||||
fishing_st.fishing_leg = legend
|
||||
export function fishing_record_set(caught: int, biggest: int, legend: bool) -> void {
|
||||
fishing_n = caught
|
||||
fishing_big = biggest
|
||||
fishing_leg = legend
|
||||
}
|
||||
|
||||
export function fishing_save(fishing_st: FishingState) -> Val {
|
||||
export function fishing_save() -> Val {
|
||||
let v = Value.object()
|
||||
sv_put_int(v, "caught", fishing_st.fishing_n)
|
||||
sv_put_int(v, "biggest", fishing_st.fishing_big)
|
||||
sv_put_bool(v, "legend", fishing_st.fishing_leg)
|
||||
sv_put_int(v, "caught", fishing_n)
|
||||
sv_put_int(v, "biggest", fishing_big)
|
||||
sv_put_bool(v, "legend", fishing_leg)
|
||||
return v
|
||||
}
|
||||
|
||||
export function fishing_load(base_st: mut BaseState, fishing_st: mut FishingState, v: Val, version: int) -> void {
|
||||
fishing_reset(base_st, fishing_st)
|
||||
fishing_record_set(fishing_st, sv_int(v, "caught", 0), sv_int(v, "biggest", 0), sv_bool(v, "legend", false))
|
||||
export function fishing_load(v: Val, version: int) -> void {
|
||||
fishing_reset()
|
||||
fishing_record_set(sv_int(v, "caught", 0), sv_int(v, "biggest", 0), sv_bool(v, "legend", false))
|
||||
}
|
||||
|
||||
function fishing_sys_tick(base_st: mut BaseState, fishing_st: mut FishingState, t: Tick) -> void { fishing_run(base_st, fishing_st, t.dt) }
|
||||
function fishing_sys_tick(t: Tick) -> void { fishing_run(t.dt) }
|
||||
|
||||
export function fishing_system() -> System {
|
||||
let s = system_new("fishing", PH_SIMULATE)
|
||||
|
|
|
|||
|
|
@ -10,248 +10,246 @@ program FishingTest {
|
|||
def FishSpecies brook { weight: 0.25, cm_min: 20, cm_spread: 10 }
|
||||
def FishSpecies old_maroon { legend: true, cm_min: 70, cm_spread: 25, skill_cm: 0.0, chance: 1.0, chance_deep: 1.0, need: 5, runs: 2, fight: 30.0, speed: 1.3, speed_per_hit: 0.22, closes: 0.12 }
|
||||
|
||||
state FishingtestState {
|
||||
bait: bool = false
|
||||
lure: bool = false
|
||||
boat: bool = false
|
||||
level: int = 0
|
||||
skill: float = 0.0
|
||||
}
|
||||
var bait: bool = false
|
||||
var lure: bool = false
|
||||
var boat: bool = false
|
||||
var level: int = 0
|
||||
var skill: float = 0.0
|
||||
|
||||
# water past x = 10, deepening a metre every ten
|
||||
function depth(x: float, z: float) -> float { return Math.max((x - 10.0) / 10.0, 0.0) }
|
||||
function afloat(fishingtest_st: FishingtestState) -> bool { return fishingtest_st.boat }
|
||||
function has_bait(fishingtest_st: FishingtestState) -> bool { return fishingtest_st.bait }
|
||||
function has_lure(fishingtest_st: FishingtestState) -> bool { return fishingtest_st.lure }
|
||||
function fake_skill(fishingtest_st: FishingtestState) -> float { return fishingtest_st.skill }
|
||||
function fake_level(fishingtest_st: FishingtestState) -> int { return fishingtest_st.level }
|
||||
function afloat() -> bool { return boat }
|
||||
function has_bait() -> bool { return bait }
|
||||
function has_lure() -> bool { return lure }
|
||||
function fake_skill() -> float { return skill }
|
||||
function fake_level() -> int { return level }
|
||||
|
||||
bind FishingWorld { depth: fn depth, afloat: fn afloat, has_bait: fn has_bait, has_lure: fn has_lure, skill: fn fake_skill, level: fn fake_level }
|
||||
|
||||
function fresh(base_st: mut BaseState, fishing_st: mut FishingState, fishingtest_st: mut FishingtestState) -> void {
|
||||
fishing_config(fishing_st, 0.15, 2.5, 99)
|
||||
fishing_reset(base_st, fishing_st)
|
||||
fishingtest_st.bait = false
|
||||
fishingtest_st.lure = false
|
||||
fishingtest_st.boat = false
|
||||
fishingtest_st.level = FISHING_RELAXED
|
||||
fishingtest_st.skill = 0.0
|
||||
function fresh() -> void {
|
||||
fishing_config(0.15, 2.5, 99)
|
||||
fishing_reset()
|
||||
bait = false
|
||||
lure = false
|
||||
boat = false
|
||||
level = FISHING_RELAXED
|
||||
skill = 0.0
|
||||
}
|
||||
|
||||
function facts(base_st: mut BaseState, fishing_st: mut FishingState) -> []FishingFact { return q_drain(base_st, fishing_facts(base_st, fishing_st)) }
|
||||
function facts() -> []FishingFact { return q_drain(fishing_facts()) }
|
||||
function saw(fs: []FishingFact, what: int) -> bool {
|
||||
for i in 0 .. len(fs) { if fs[i].what == what { return true } }
|
||||
return false
|
||||
}
|
||||
|
||||
# run until it bites, then strike
|
||||
function hook(base_st: mut BaseState, fishing_st: mut FishingState) -> void {
|
||||
fishing_set_wait(fishing_st, 0.0)
|
||||
fishing_run(base_st, fishing_st, 0.02)
|
||||
fishing_press(base_st, fishing_st)
|
||||
function hook() -> void {
|
||||
fishing_set_wait(0.0)
|
||||
fishing_run(0.02)
|
||||
fishing_press()
|
||||
}
|
||||
|
||||
# hold the marker in the green and press, until it is landed or `n` presses are spent
|
||||
function play(base_st: mut BaseState, fishing_st: mut FishingState, n: int) -> void {
|
||||
function play(n: int) -> void {
|
||||
for i in 0 .. n {
|
||||
if fishing_state(fishing_st) != FISHING_REEL { return }
|
||||
if fishing_state() != FISHING_REEL { return }
|
||||
var guard = 0
|
||||
while (fishing_running(fishing_st) or fishing_marker(fishing_st) <= fishing_window_lo(fishing_st) or fishing_marker(fishing_st) >= fishing_window_hi(fishing_st)) and guard < 4000 {
|
||||
fishing_run(base_st, fishing_st, 0.005)
|
||||
while (fishing_running() or fishing_marker() <= fishing_window_lo() or fishing_marker() >= fishing_window_hi()) and guard < 4000 {
|
||||
fishing_run(0.005)
|
||||
guard += 1
|
||||
}
|
||||
if fishing_state(fishing_st) == FISHING_REEL { fishing_press(base_st, fishing_st) }
|
||||
if fishing_state() == FISHING_REEL { fishing_press() }
|
||||
}
|
||||
}
|
||||
|
||||
test "a cast lands only in water, and never twice" (base_st: mut BaseState, fishing_st: mut FishingState, fishingtest_st: mut FishingtestState) {
|
||||
fresh(base_st, fishing_st, fishingtest_st)
|
||||
expect_eq(fishing_cast(base_st, fishing_st, 5.0, 0.0), FISHING_NOT_WATER)
|
||||
expect(not fishing_active(fishing_st))
|
||||
expect_eq(fishing_cast(base_st, fishing_st, 20.0, 0.0), FISHING_CAST_OK)
|
||||
expect_eq(fishing_state(fishing_st), FISHING_WAIT)
|
||||
expect_eq(fishing_cast(base_st, fishing_st, 20.0, 0.0), FISHING_BUSY)
|
||||
fishingtest_st.boat = true
|
||||
fishing_stop(fishing_st)
|
||||
expect_eq(fishing_cast(base_st, fishing_st, 0.0, 0.0), FISHING_CAST_OK)
|
||||
test "a cast lands only in water, and never twice" {
|
||||
fresh()
|
||||
expect_eq(fishing_cast(5.0, 0.0), FISHING_NOT_WATER)
|
||||
expect(not fishing_active())
|
||||
expect_eq(fishing_cast(20.0, 0.0), FISHING_CAST_OK)
|
||||
expect_eq(fishing_state(), FISHING_WAIT)
|
||||
expect_eq(fishing_cast(20.0, 0.0), FISHING_BUSY)
|
||||
boat = true
|
||||
fishing_stop()
|
||||
expect_eq(fishing_cast(0.0, 0.0), FISHING_CAST_OK)
|
||||
}
|
||||
|
||||
test "bait is used and said, and halves the wait" (base_st: mut BaseState, fishing_st: mut FishingState, fishingtest_st: mut FishingtestState) {
|
||||
fresh(base_st, fishing_st, fishingtest_st)
|
||||
fishing_cast(base_st, fishing_st, 20.0, 0.0)
|
||||
expect(not saw(facts(base_st, fishing_st), FISHING_BAIT_USED))
|
||||
test "bait is used and said, and halves the wait" {
|
||||
fresh()
|
||||
fishing_cast(20.0, 0.0)
|
||||
expect(not saw(facts(), FISHING_BAIT_USED))
|
||||
var plain = 0
|
||||
while fishing_state(fishing_st) == FISHING_WAIT {
|
||||
fishing_run(base_st, fishing_st, 0.1)
|
||||
while fishing_state() == FISHING_WAIT {
|
||||
fishing_run(0.1)
|
||||
plain += 1
|
||||
}
|
||||
expect(plain <= 201)
|
||||
fresh(base_st, fishing_st, fishingtest_st)
|
||||
fishingtest_st.bait = true
|
||||
fishing_cast(base_st, fishing_st, 20.0, 0.0)
|
||||
let fs = facts(base_st, fishing_st)
|
||||
fresh()
|
||||
bait = true
|
||||
fishing_cast(20.0, 0.0)
|
||||
let fs = facts()
|
||||
expect(saw(fs, FISHING_BAIT_USED))
|
||||
expect(fs[0].bait)
|
||||
var baited = 0
|
||||
while fishing_state(fishing_st) == FISHING_WAIT {
|
||||
fishing_run(base_st, fishing_st, 0.1)
|
||||
while fishing_state() == FISHING_WAIT {
|
||||
fishing_run(0.1)
|
||||
baited += 1
|
||||
}
|
||||
expect(baited <= 101)
|
||||
}
|
||||
|
||||
test "a bite missed is gone, a bite struck is hooked" (base_st: mut BaseState, fishing_st: mut FishingState, fishingtest_st: mut FishingtestState) {
|
||||
fresh(base_st, fishing_st, fishingtest_st)
|
||||
fishing_cast(base_st, fishing_st, 20.0, 0.0)
|
||||
fishing_set_wait(fishing_st, 0.0)
|
||||
fishing_run(base_st, fishing_st, 0.02)
|
||||
expect_eq(fishing_state(fishing_st), FISHING_BITE_ON)
|
||||
expect(fishing_species(fishing_st) >= 0)
|
||||
fishing_run(base_st, fishing_st, 2.0)
|
||||
expect(not fishing_active(fishing_st))
|
||||
expect(saw(facts(base_st, fishing_st), FISHING_MISSED))
|
||||
fishing_cast(base_st, fishing_st, 20.0, 0.0)
|
||||
hook(base_st, fishing_st)
|
||||
expect_eq(fishing_state(fishing_st), FISHING_REEL)
|
||||
expect(saw(facts(base_st, fishing_st), FISHING_HOOKED))
|
||||
test "a bite missed is gone, a bite struck is hooked" {
|
||||
fresh()
|
||||
fishing_cast(20.0, 0.0)
|
||||
fishing_set_wait(0.0)
|
||||
fishing_run(0.02)
|
||||
expect_eq(fishing_state(), FISHING_BITE_ON)
|
||||
expect(fishing_species() >= 0)
|
||||
fishing_run(2.0)
|
||||
expect(not fishing_active())
|
||||
expect(saw(facts(), FISHING_MISSED))
|
||||
fishing_cast(20.0, 0.0)
|
||||
hook()
|
||||
expect_eq(fishing_state(), FISHING_REEL)
|
||||
expect(saw(facts(), FISHING_HOOKED))
|
||||
}
|
||||
|
||||
test "everyday fish only without a lure, sized and weighed from the data" (base_st: mut BaseState, fishing_st: mut FishingState, fishingtest_st: mut FishingtestState) {
|
||||
fresh(base_st, fishing_st, fishingtest_st)
|
||||
test "everyday fish only without a lure, sized and weighed from the data" {
|
||||
fresh()
|
||||
for i in 0 .. 40 {
|
||||
fishing_cast(base_st, fishing_st, 20.0, 0.0)
|
||||
hook(base_st, fishing_st)
|
||||
let s = fishing_species(fishing_st)
|
||||
fishing_cast(20.0, 0.0)
|
||||
hook()
|
||||
let s = fishing_species()
|
||||
expect(s != FISH_OLD_MAROON)
|
||||
let k = FishSpecies[s]
|
||||
expect(fishing_cm(fishing_st) >= k.cm_min and fishing_cm(fishing_st) <= k.cm_min + k.cm_spread)
|
||||
fishing_stop(fishing_st)
|
||||
expect(fishing_cm() >= k.cm_min and fishing_cm() <= k.cm_min + k.cm_spread)
|
||||
fishing_stop()
|
||||
}
|
||||
expect(fishing_weight_of(FISH_CUTTHROAT, 50) > fishing_weight_of(FISH_CUTTHROAT, 30))
|
||||
}
|
||||
|
||||
test "reeled in the green three times, it is landed and counted" (base_st: mut BaseState, fishing_st: mut FishingState, fishingtest_st: mut FishingtestState) {
|
||||
fresh(base_st, fishing_st, fishingtest_st)
|
||||
fishing_cast(base_st, fishing_st, 20.0, 0.0)
|
||||
hook(base_st, fishing_st)
|
||||
facts(base_st, fishing_st)
|
||||
play(base_st, fishing_st, 3)
|
||||
let fs = facts(base_st, fishing_st)
|
||||
test "reeled in the green three times, it is landed and counted" {
|
||||
fresh()
|
||||
fishing_cast(20.0, 0.0)
|
||||
hook()
|
||||
facts()
|
||||
play(3)
|
||||
let fs = facts()
|
||||
expect(saw(fs, FISHING_CAUGHT))
|
||||
expect_eq(fishing_caught(fishing_st), 1)
|
||||
expect(fishing_biggest(fishing_st) > 0)
|
||||
expect(not fishing_active(fishing_st))
|
||||
expect_eq(fishing_caught(), 1)
|
||||
expect(fishing_biggest() > 0)
|
||||
expect(not fishing_active())
|
||||
let last = fs[len(fs) - 1]
|
||||
expect(last.kg > 0.0)
|
||||
expect(last.x == 20.0)
|
||||
}
|
||||
|
||||
test "a press outside the green throws the hook" (base_st: mut BaseState, fishing_st: mut FishingState, fishingtest_st: mut FishingtestState) {
|
||||
fresh(base_st, fishing_st, fishingtest_st)
|
||||
fishing_cast(base_st, fishing_st, 20.0, 0.0)
|
||||
hook(base_st, fishing_st)
|
||||
while fishing_marker(fishing_st) < fishing_window_hi(fishing_st) + 0.01 { fishing_run(base_st, fishing_st, 0.005) }
|
||||
fishing_press(base_st, fishing_st)
|
||||
expect(saw(facts(base_st, fishing_st), FISHING_LINE_SNAPPED))
|
||||
expect(not fishing_active(fishing_st))
|
||||
test "a press outside the green throws the hook" {
|
||||
fresh()
|
||||
fishing_cast(20.0, 0.0)
|
||||
hook()
|
||||
while fishing_marker() < fishing_window_hi() + 0.01 { fishing_run(0.005) }
|
||||
fishing_press()
|
||||
expect(saw(facts(), FISHING_LINE_SNAPPED))
|
||||
expect(not fishing_active())
|
||||
}
|
||||
|
||||
test "a fight left alone goes slack" (base_st: mut BaseState, fishing_st: mut FishingState, fishingtest_st: mut FishingtestState) {
|
||||
fresh(base_st, fishing_st, fishingtest_st)
|
||||
fishing_cast(base_st, fishing_st, 20.0, 0.0)
|
||||
hook(base_st, fishing_st)
|
||||
for i in 0 .. 700 { fishing_run(base_st, fishing_st, 0.02) }
|
||||
expect(saw(facts(base_st, fishing_st), FISHING_SLACK))
|
||||
expect_eq(fishing_caught(fishing_st), 0)
|
||||
test "a fight left alone goes slack" {
|
||||
fresh()
|
||||
fishing_cast(20.0, 0.0)
|
||||
hook()
|
||||
for i in 0 .. 700 { fishing_run(0.02) }
|
||||
expect(saw(facts(), FISHING_SLACK))
|
||||
expect_eq(fishing_caught(), 0)
|
||||
}
|
||||
|
||||
test "a legend takes the lure, runs, turns, and is landed at five" (base_st: mut BaseState, fishing_st: mut FishingState, fishingtest_st: mut FishingtestState) {
|
||||
fresh(base_st, fishing_st, fishingtest_st)
|
||||
fishingtest_st.lure = true
|
||||
fishing_cast(base_st, fishing_st, 20.0, 0.0)
|
||||
hook(base_st, fishing_st)
|
||||
expect_eq(fishing_species(fishing_st), FISH_OLD_MAROON)
|
||||
expect_eq(fishing_need(fishing_st), 5)
|
||||
let w0 = fishing_window(fishing_st)
|
||||
play(base_st, fishing_st, 2)
|
||||
expect(fishing_window(fishing_st) < w0)
|
||||
test "a legend takes the lure, runs, turns, and is landed at five" {
|
||||
fresh()
|
||||
lure = true
|
||||
fishing_cast(20.0, 0.0)
|
||||
hook()
|
||||
expect_eq(fishing_species(), FISH_OLD_MAROON)
|
||||
expect_eq(fishing_need(), 5)
|
||||
let w0 = fishing_window()
|
||||
play(2)
|
||||
expect(fishing_window() < w0)
|
||||
for i in 0 .. 400 {
|
||||
if not fishing_running(fishing_st) { fishing_run(base_st, fishing_st, 0.02) }
|
||||
if not fishing_running() { fishing_run(0.02) }
|
||||
}
|
||||
let fs = facts(base_st, fishing_st)
|
||||
let fs = facts()
|
||||
expect(saw(fs, FISHING_RUNS))
|
||||
if fishing_running(fishing_st) {
|
||||
let before = fishing_hits(fishing_st)
|
||||
fishing_press(base_st, fishing_st)
|
||||
expect_eq(fishing_hits(fishing_st), before - 1)
|
||||
if fishing_running() {
|
||||
let before = fishing_hits()
|
||||
fishing_press()
|
||||
expect_eq(fishing_hits(), before - 1)
|
||||
}
|
||||
play(base_st, fishing_st, 40)
|
||||
expect(fishing_legend_caught(fishing_st))
|
||||
let last = facts(base_st, fishing_st)
|
||||
play(40)
|
||||
expect(fishing_legend_caught())
|
||||
let last = facts()
|
||||
expect(last[len(last) - 1].lure)
|
||||
}
|
||||
|
||||
test "gentle: one press inside the ring, and the ring closes" (base_st: mut BaseState, fishing_st: mut FishingState, fishingtest_st: mut FishingtestState) {
|
||||
fresh(base_st, fishing_st, fishingtest_st)
|
||||
fishingtest_st.level = FISHING_GENTLE
|
||||
fishing_cast(base_st, fishing_st, 20.0, 0.0)
|
||||
hook(base_st, fishing_st)
|
||||
expect(fishing_gentle(fishing_st))
|
||||
expect_eq(fishing_need(fishing_st), 1)
|
||||
fishing_press(base_st, fishing_st)
|
||||
expect_eq(fishing_caught(fishing_st), 1)
|
||||
fishing_cast(base_st, fishing_st, 20.0, 0.0)
|
||||
hook(base_st, fishing_st)
|
||||
fishing_run(base_st, fishing_st, 2.1)
|
||||
expect(saw(facts(base_st, fishing_st), FISHING_LINE_SNAPPED))
|
||||
test "gentle: one press inside the ring, and the ring closes" {
|
||||
fresh()
|
||||
level = FISHING_GENTLE
|
||||
fishing_cast(20.0, 0.0)
|
||||
hook()
|
||||
expect(fishing_gentle())
|
||||
expect_eq(fishing_need(), 1)
|
||||
fishing_press()
|
||||
expect_eq(fishing_caught(), 1)
|
||||
fishing_cast(20.0, 0.0)
|
||||
hook()
|
||||
fishing_run(2.1)
|
||||
expect(saw(facts(), FISHING_LINE_SNAPPED))
|
||||
}
|
||||
|
||||
test "a legend fights on gentle too" (base_st: mut BaseState, fishing_st: mut FishingState, fishingtest_st: mut FishingtestState) {
|
||||
fresh(base_st, fishing_st, fishingtest_st)
|
||||
fishingtest_st.level = FISHING_GENTLE
|
||||
fishingtest_st.lure = true
|
||||
fishing_cast(base_st, fishing_st, 20.0, 0.0)
|
||||
hook(base_st, fishing_st)
|
||||
expect(not fishing_gentle(fishing_st))
|
||||
expect_eq(fishing_need(fishing_st), 5)
|
||||
test "a legend fights on gentle too" {
|
||||
fresh()
|
||||
level = FISHING_GENTLE
|
||||
lure = true
|
||||
fishing_cast(20.0, 0.0)
|
||||
hook()
|
||||
expect(not fishing_gentle())
|
||||
expect_eq(fishing_need(), 5)
|
||||
}
|
||||
|
||||
test "hard closes the window for everyday fish, relaxed keeps it centred" (base_st: mut BaseState, fishing_st: mut FishingState, fishingtest_st: mut FishingtestState) {
|
||||
fresh(base_st, fishing_st, fishingtest_st)
|
||||
fishing_cast(base_st, fishing_st, 20.0, 0.0)
|
||||
hook(base_st, fishing_st)
|
||||
expect(fishing_window_lo(fishing_st) + fishing_window_hi(fishing_st) > 0.999 and fishing_window_lo(fishing_st) + fishing_window_hi(fishing_st) < 1.001)
|
||||
fishing_stop(fishing_st)
|
||||
fishingtest_st.level = FISHING_HARD
|
||||
fishing_cast(base_st, fishing_st, 20.0, 0.0)
|
||||
hook(base_st, fishing_st)
|
||||
let w0 = fishing_window(fishing_st)
|
||||
play(base_st, fishing_st, 1)
|
||||
expect(fishing_window(fishing_st) < w0)
|
||||
test "hard closes the window for everyday fish, relaxed keeps it centred" {
|
||||
fresh()
|
||||
fishing_cast(20.0, 0.0)
|
||||
hook()
|
||||
expect(fishing_window_lo() + fishing_window_hi() > 0.999 and fishing_window_lo() + fishing_window_hi() < 1.001)
|
||||
fishing_stop()
|
||||
level = FISHING_HARD
|
||||
fishing_cast(20.0, 0.0)
|
||||
hook()
|
||||
let w0 = fishing_window()
|
||||
play(1)
|
||||
expect(fishing_window() < w0)
|
||||
}
|
||||
|
||||
test "skill makes a fish bigger" (base_st: mut BaseState, fishing_st: mut FishingState, fishingtest_st: mut FishingtestState) {
|
||||
fresh(base_st, fishing_st, fishingtest_st)
|
||||
fishingtest_st.skill = 1.0
|
||||
fishing_cast(base_st, fishing_st, 20.0, 0.0)
|
||||
hook(base_st, fishing_st)
|
||||
let k = FishSpecies[fishing_species(fishing_st)]
|
||||
expect(fishing_cm(fishing_st) >= k.cm_min + 60)
|
||||
test "skill makes a fish bigger" {
|
||||
fresh()
|
||||
skill = 1.0
|
||||
fishing_cast(20.0, 0.0)
|
||||
hook()
|
||||
let k = FishSpecies[fishing_species()]
|
||||
expect(fishing_cm() >= k.cm_min + 60)
|
||||
}
|
||||
|
||||
test "the record is saved, and a line in the water is not" (base_st: mut BaseState, fishing_st: mut FishingState, fishingtest_st: mut FishingtestState) {
|
||||
fresh(base_st, fishing_st, fishingtest_st)
|
||||
fishing_record_set(fishing_st, 7, 52, true)
|
||||
fishing_cast(base_st, fishing_st, 20.0, 0.0)
|
||||
test "the record is saved, and a line in the water is not" {
|
||||
fresh()
|
||||
fishing_record_set(7, 52, true)
|
||||
fishing_cast(20.0, 0.0)
|
||||
let root = save_tree()
|
||||
save_section(root, "fishing", 1, fishing_save(fishing_st))
|
||||
save_section(root, "fishing", 1, fishing_save())
|
||||
let text = save_encode(root)
|
||||
fishing_reset(base_st, fishing_st)
|
||||
fishing_reset()
|
||||
let n = load_section(save_decode(text), "fishing")
|
||||
fishing_load(base_st, fishing_st, n.data, n.version)
|
||||
expect_eq(fishing_caught(fishing_st), 7)
|
||||
expect_eq(fishing_biggest(fishing_st), 52)
|
||||
expect(fishing_legend_caught(fishing_st))
|
||||
expect(not fishing_active(fishing_st))
|
||||
fishing_load(n.data, n.version)
|
||||
expect_eq(fishing_caught(), 7)
|
||||
expect_eq(fishing_biggest(), 52)
|
||||
expect(fishing_legend_caught())
|
||||
expect(not fishing_active())
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,102 +4,102 @@ export const FISHING_NOT_WATER: int = 1
|
|||
export const FISHING_BUSY: int = 2
|
||||
|
||||
# a line into (x, z): bait halves the wait (and is a fact, for the game to take from the pack)
|
||||
export function fishing_cast(base_st: mut BaseState, fishing_st: mut FishingState, x: float, z: float) -> int {
|
||||
if fishing_st.fishing_st != FISHING_OFF { return FISHING_BUSY }
|
||||
fishing_st.fishing_bx = x
|
||||
fishing_st.fishing_bz = z
|
||||
if not fishing_water_at(fishing_st, x, z) { return FISHING_NOT_WATER }
|
||||
fishing_st.fishing_st = FISHING_WAIT
|
||||
fishing_st.fishing_sp = -1
|
||||
fishing_st.fishing_len = 0
|
||||
fishing_st.fishing_lure_on = FishingWorld.has_lure()
|
||||
fishing_st.fishing_bait_on = FishingWorld.has_bait()
|
||||
var wait = 6.0 + fishing_rand(fishing_st) * 14.0
|
||||
if fishing_st.fishing_bait_on { wait = wait * 0.5 }
|
||||
fishing_st.fishing_t = wait * FishingWorld.bite_mult()
|
||||
if fishing_st.fishing_bait_on { fishing_say(base_st, fishing_st, FISHING_BAIT_USED) }
|
||||
fishing_say(base_st, fishing_st, FISHING_CAST)
|
||||
export function fishing_cast(x: float, z: float) -> int {
|
||||
if fishing_st != FISHING_OFF { return FISHING_BUSY }
|
||||
fishing_bx = x
|
||||
fishing_bz = z
|
||||
if not fishing_water_at(x, z) { return FISHING_NOT_WATER }
|
||||
fishing_st = FISHING_WAIT
|
||||
fishing_sp = -1
|
||||
fishing_len = 0
|
||||
fishing_lure_on = FishingWorld.has_lure()
|
||||
fishing_bait_on = FishingWorld.has_bait()
|
||||
var wait = 6.0 + fishing_rand() * 14.0
|
||||
if fishing_bait_on { wait = wait * 0.5 }
|
||||
fishing_t = wait * FishingWorld.bite_mult()
|
||||
if fishing_bait_on { fishing_say(FISHING_BAIT_USED) }
|
||||
fishing_say(FISHING_CAST)
|
||||
return FISHING_CAST_OK
|
||||
}
|
||||
|
||||
# the bite comes exactly `secs` after now (staging, footage)
|
||||
export function fishing_set_wait(fishing_st: mut FishingState, secs: float) -> void {
|
||||
if fishing_st.fishing_st == FISHING_WAIT { fishing_st.fishing_t = secs }
|
||||
export function fishing_set_wait(secs: float) -> void {
|
||||
if fishing_st == FISHING_WAIT { fishing_t = secs }
|
||||
}
|
||||
|
||||
export function fishing_stop(fishing_st: mut FishingState) -> void {
|
||||
fishing_st.fishing_st = FISHING_OFF
|
||||
fishing_st.fishing_run_t = 0.0
|
||||
export function fishing_stop() -> void {
|
||||
fishing_st = FISHING_OFF
|
||||
fishing_run_t = 0.0
|
||||
}
|
||||
|
||||
function fishing_strike(base_st: mut BaseState, fishing_st: mut FishingState) -> void {
|
||||
let k = FishSpecies[fishing_st.fishing_sp]
|
||||
fishing_st.fishing_st = FISHING_REEL
|
||||
fishing_st.fishing_won = 0
|
||||
fishing_st.fishing_mark = 0.0
|
||||
fishing_st.fishing_dir = 1.0
|
||||
fishing_st.fishing_t = k.fight
|
||||
fishing_st.fishing_need_n = k.need
|
||||
fishing_st.fishing_run_t = 0.0
|
||||
fishing_st.fishing_run_left = k.runs
|
||||
fishing_st.fishing_run_next = 3.0 + fishing_rand(fishing_st) * 3.0
|
||||
fishing_st.fishing_len = fishing_size(fishing_st, fishing_st.fishing_sp)
|
||||
fishing_st.fishing_gentle_on = FishingWorld.level() == FISHING_GENTLE and not k.legend
|
||||
fishing_st.fishing_ring_t = 0.0
|
||||
if fishing_st.fishing_gentle_on {
|
||||
fishing_st.fishing_need_n = 1
|
||||
fishing_st.fishing_ring_t = 2.0
|
||||
function fishing_strike() -> void {
|
||||
let k = FishSpecies[fishing_sp]
|
||||
fishing_st = FISHING_REEL
|
||||
fishing_won = 0
|
||||
fishing_mark = 0.0
|
||||
fishing_dir = 1.0
|
||||
fishing_t = k.fight
|
||||
fishing_need_n = k.need
|
||||
fishing_run_t = 0.0
|
||||
fishing_run_left = k.runs
|
||||
fishing_run_next = 3.0 + fishing_rand() * 3.0
|
||||
fishing_len = fishing_size(fishing_sp)
|
||||
fishing_gentle_on = FishingWorld.level() == FISHING_GENTLE and not k.legend
|
||||
fishing_ring_t = 0.0
|
||||
if fishing_gentle_on {
|
||||
fishing_need_n = 1
|
||||
fishing_ring_t = 2.0
|
||||
}
|
||||
fishing_new_window(fishing_st)
|
||||
fishing_say(base_st, fishing_st, FISHING_HOOKED)
|
||||
fishing_new_window()
|
||||
fishing_say(FISHING_HOOKED)
|
||||
}
|
||||
|
||||
function fishing_land(base_st: mut BaseState, fishing_st: mut FishingState) -> void {
|
||||
fishing_st.fishing_n += 1
|
||||
if fishing_st.fishing_len > fishing_st.fishing_big { fishing_st.fishing_big = fishing_st.fishing_len }
|
||||
if FishSpecies[fishing_st.fishing_sp].legend { fishing_st.fishing_leg = true }
|
||||
fishing_say(base_st, fishing_st, FISHING_CAUGHT)
|
||||
fishing_stop(fishing_st)
|
||||
function fishing_land() -> void {
|
||||
fishing_n += 1
|
||||
if fishing_len > fishing_big { fishing_big = fishing_len }
|
||||
if FishSpecies[fishing_sp].legend { fishing_leg = true }
|
||||
fishing_say(FISHING_CAUGHT)
|
||||
fishing_stop()
|
||||
}
|
||||
|
||||
function fishing_lost(base_st: mut BaseState, fishing_st: mut FishingState, what: int) -> void {
|
||||
fishing_say(base_st, fishing_st, what)
|
||||
fishing_stop(fishing_st)
|
||||
function fishing_lost(what: int) -> void {
|
||||
fishing_say(what)
|
||||
fishing_stop()
|
||||
}
|
||||
|
||||
function fishing_reel_press(base_st: mut BaseState, fishing_st: mut FishingState) -> void {
|
||||
if fishing_st.fishing_gentle_on {
|
||||
if fishing_st.fishing_ring_t > 0.0 { fishing_land(base_st, fishing_st) } else { fishing_lost(base_st, fishing_st, FISHING_LINE_SNAPPED) }
|
||||
function fishing_reel_press() -> void {
|
||||
if fishing_gentle_on {
|
||||
if fishing_ring_t > 0.0 { fishing_land() } else { fishing_lost(FISHING_LINE_SNAPPED) }
|
||||
return
|
||||
}
|
||||
if fishing_st.fishing_run_t > 0.0 {
|
||||
fishing_st.fishing_won = Math.max(fishing_st.fishing_won - 1, 0)
|
||||
fishing_say(base_st, fishing_st, FISHING_CHECKED)
|
||||
if fishing_run_t > 0.0 {
|
||||
fishing_won = Math.max(fishing_won - 1, 0)
|
||||
fishing_say(FISHING_CHECKED)
|
||||
return
|
||||
}
|
||||
if fishing_in_window(fishing_st) {
|
||||
fishing_st.fishing_won += 1
|
||||
fishing_new_window(fishing_st)
|
||||
if fishing_st.fishing_won >= fishing_st.fishing_need_n { fishing_land(base_st, fishing_st) } else { fishing_say(base_st, fishing_st, FISHING_GOOD) }
|
||||
if fishing_in_window() {
|
||||
fishing_won += 1
|
||||
fishing_new_window()
|
||||
if fishing_won >= fishing_need_n { fishing_land() } else { fishing_say(FISHING_GOOD) }
|
||||
return
|
||||
}
|
||||
if FishSpecies[fishing_st.fishing_sp].legend and fishing_st.fishing_won > 0 {
|
||||
fishing_st.fishing_won -= 1
|
||||
fishing_say(base_st, fishing_st, FISHING_TURNED)
|
||||
if FishSpecies[fishing_sp].legend and fishing_won > 0 {
|
||||
fishing_won -= 1
|
||||
fishing_say(FISHING_TURNED)
|
||||
return
|
||||
}
|
||||
fishing_lost(base_st, fishing_st, FISHING_LINE_SNAPPED)
|
||||
fishing_lost(FISHING_LINE_SNAPPED)
|
||||
}
|
||||
|
||||
# the button: waiting it reels in, on a bite it strikes, on a fish it reels
|
||||
export function fishing_press(base_st: mut BaseState, fishing_st: mut FishingState) -> void {
|
||||
if fishing_st.fishing_st == FISHING_WAIT {
|
||||
fishing_lost(base_st, fishing_st, FISHING_REELED_IN)
|
||||
export function fishing_press() -> void {
|
||||
if fishing_st == FISHING_WAIT {
|
||||
fishing_lost(FISHING_REELED_IN)
|
||||
return
|
||||
}
|
||||
if fishing_st.fishing_st == FISHING_BITE_ON {
|
||||
fishing_strike(base_st, fishing_st)
|
||||
if fishing_st == FISHING_BITE_ON {
|
||||
fishing_strike()
|
||||
return
|
||||
}
|
||||
if fishing_st.fishing_st == FISHING_REEL { fishing_reel_press(base_st, fishing_st) }
|
||||
if fishing_st == FISHING_REEL { fishing_reel_press() }
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue