Orkuncakilkaya
3ac1179440
ludic.update: whether this copy can update itself is worked out once, when the updater is configured (the panel asked every frame, building the path to the executable each time); the notes are a list the state keeps, filled by update_notes_for when the version or the language changes, which the game calls from its update tick. The feed's address is declared (once, when a check starts). ludic.steps, ludic.effects, ludic.telemetry: what is left is made on an event and declared with its bound - an arc's tables, a chapter's columns, a step's fact, an effect's start, end and clear, the fact pool's growth, the player id, a props record's nesting stack - and two pushes into a caller's kept list, at most a chapter's steps and the ring's size. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
60 lines
2 KiB
Text
60 lines
2 KiB
Text
# 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
|
|
}
|