From e3813b1ea4f4bdde77d0d70bc92ef95ed1d4c6a7 Mon Sep 17 00:00:00 2001 From: Orkuncakilkaya Date: Sun, 27 Sep 2026 15:06:33 +0300 Subject: [PATCH] refactor(steps): 0.R5 - a seat's share is a question (steps__share): seat 0 read live, a teammate's column as sent for this chapter; only steps_share, the verb, clears a stale table - steps_met, steps_each, steps_lacking, steps_my_shares and steps_share_of read Co-Authored-By: Claude Opus 5.5 --- packages/ludic.steps/each.ludic | 10 ++++----- packages/ludic.steps/party.ludic | 38 +++++++++++++++++--------------- 2 files changed, 24 insertions(+), 24 deletions(-) diff --git a/packages/ludic.steps/each.ludic b/packages/ludic.steps/each.ludic index 98c58bc1..0385c280 100644 --- a/packages/ludic.steps/each.ludic +++ b/packages/ludic.steps/each.ludic @@ -7,21 +7,19 @@ export function steps_players(steps_st: StepsState) -> int { } # how many seats taken have step i's thing (seat 0 counted live) -export function steps_each(steps_st: mut StepsState, i: int) -> int { - steps__cols(steps_st) +export function steps_each(steps_st: StepsState, i: int) -> int { var n = 0 for p in 0 .. steps_st.steps__players { - if StepsWorld.present(p) and steps_st.steps__col[p * STEPS_PER_CHAPTER + i] != 0 { n += 1 } + if StepsWorld.present(p) and steps__share(steps_st, p, i) != 0 { n += 1 } } return n } # the seats that do not have it yet -export function steps_lacking(steps_st: mut StepsState, i: int) -> []int { - steps__cols(steps_st) +export function steps_lacking(steps_st: StepsState, i: int) -> []int { let out = new []int for p in 0 .. steps_st.steps__players { - if StepsWorld.present(p) and steps_st.steps__col[p * STEPS_PER_CHAPTER + i] == 0 { push(out, p) } + if StepsWorld.present(p) and steps__share(steps_st, p, i) == 0 { push(out, p) } } return out } diff --git a/packages/ludic.steps/party.ludic b/packages/ludic.steps/party.ludic index d5bb5371..d0a9812c 100644 --- a/packages/ludic.steps/party.ludic +++ b/packages/ludic.steps/party.ludic @@ -17,20 +17,25 @@ function steps__party_clear(steps_st: mut StepsState) -> void { # a party over (or a new one): every column forgotten export function steps_party_reset(steps_st: mut StepsState) -> void { steps_st.steps__col = null } -# the columns, emptied when the chapter they were about is not this one; seat 0 refilled -function steps__cols(steps_st: mut StepsState) -> void { - if steps_st.steps__col == null or steps_st.steps__col_ch != steps_st.steps__cur { steps__party_clear(steps_st) } - if steps_finished(steps_st) { return } - for i in 0 .. steps_in(steps_st, steps_st.steps__cur) { - steps_st.steps__col[i] = steps_mine(steps_st, steps_kind(steps_st, steps_st.steps__cur, i), steps_param(steps_st, steps_st.steps__cur, i), steps_need(steps_st, steps_st.steps__cur, i)) +# the columns, emptied when the chapter they were about is not this one (before a teammate's go in) +function steps__cols(steps_st: mut StepsState) -> void { if steps_st.steps__col == null or steps_st.steps__col_ch != steps_st.steps__cur { steps__party_clear(steps_st) } } + +# seat p's share of step i: seat 0 read live, a teammate's as they sent it for this chapter +function steps__share(steps_st: StepsState, p: int, i: int) -> int { + let ch = steps_st.steps__cur + if p == 0 { + if steps_finished(steps_st) or i >= steps_in(steps_st, ch) { return 0 } + return steps_mine(steps_st, steps_kind(steps_st, ch, i), steps_param(steps_st, ch, i), steps_need(steps_st, ch, i)) } + let k = p * STEPS_PER_CHAPTER + i + if steps_st.steps__col == null or steps_st.steps__col_ch != ch or k >= len(steps_st.steps__col) { return 0 } + return steps_st.steps__col[k] } # this machine's shares for the current chapter, to send to whoever owns the story -export function steps_my_shares(steps_st: mut StepsState) -> []int { - steps__cols(steps_st) +export function steps_my_shares(steps_st: StepsState) -> []int { let out = new []int - for i in 0 .. STEPS_PER_CHAPTER { push(out, steps_st.steps__col[i]) } + for i in 0 .. STEPS_PER_CHAPTER { push(out, steps__share(steps_st, 0, i)) } return out } @@ -41,9 +46,8 @@ export function steps_share(steps_st: mut StepsState, p: int, ch: int, shares: [ for i in 0 .. min(len(shares), STEPS_PER_CHAPTER) { steps_st.steps__col[p * STEPS_PER_CHAPTER + i] = shares[i] } } -export function steps_share_of(steps_st: mut StepsState, p: int, i: int) -> int { - steps__cols(steps_st) - return steps_st.steps__col[p * STEPS_PER_CHAPTER + i] +export function steps_share_of(steps_st: StepsState, p: int, i: int) -> int { + return steps__share(steps_st, p, i) } # a seat emptied: what it had goes with it @@ -54,10 +58,10 @@ export function steps_leave(steps_st: mut StepsState, p: int) -> void { # the shares of every seat taken, combined as the pool says (seat 0 is the start) function steps__combined(steps_st: StepsState, i: int, how: int) -> int { - var v = steps_st.steps__col[i] + var v = steps__share(steps_st, 0, i) for p in 1 .. steps_st.steps__players { if not StepsWorld.present(p) { continue } - let c = steps_st.steps__col[p * STEPS_PER_CHAPTER + i] + let c = steps__share(steps_st, p, i) if how == STEPS_POOL_ANY or how == STEPS_POOL_OR { v = v | c } else if how == STEPS_POOL_SUM { v += c } else if how == STEPS_POOL_MAX { if c > v { v = c } } @@ -66,24 +70,22 @@ function steps__combined(steps_st: StepsState, i: int, how: int) -> int { } # the answer to step i of the current chapter: solo this is steps_eval and nothing more -export function steps_met(steps_st: mut StepsState, i: int) -> bool { +export function steps_met(steps_st: StepsState, i: int) -> bool { let ch = steps_st.steps__cur let kind = steps_kind(steps_st, ch, i) if not StepsWorld.party() { return steps_eval(steps_st, kind, steps_param(steps_st, ch, i), steps_need(steps_st, ch, i)) } let how = steps_pool(steps_st, kind) if how == STEPS_POOL_WORLD { return steps_eval(steps_st, kind, steps_param(steps_st, ch, i), steps_need(steps_st, ch, i)) } - steps__cols(steps_st) return steps_from(steps_st, kind, steps_param(steps_st, ch, i), steps_need(steps_st, ch, i), steps__combined(steps_st, i, how), steps_players(steps_st), steps_each(steps_st, i)) } # the party's count for step i of the current chapter, -1 for one that is not a tally -export function steps_party_got(steps_st: mut StepsState, i: int) -> int { +export function steps_party_got(steps_st: StepsState, i: int) -> int { let ch = steps_st.steps__cur let kind = steps_kind(steps_st, ch, i) let param = steps_param(steps_st, ch, i) if steps_got(steps_st, kind, param) < 0 { return -1 } let how = steps_pool(steps_st, kind) if not StepsWorld.party() or how == STEPS_POOL_WORLD or how == STEPS_POOL_ANY or how == STEPS_POOL_EACH { return steps_got(steps_st, kind, param) } - steps__cols(steps_st) return steps_got_from(steps_st, kind, param, steps__combined(steps_st, i, how)) }