Orkuncakilkaya
71735b10a2
ludic.base's Queue<T> carries a QueueTag (its name and pending count): queue_new(name), q_push(q, v), q_drain(q), q_clear(q) take no BaseState, and core_undrained(tags) names the given queues still holding facts. A reducer on a package's state can now call that package's verbs (wallet_earn(wallet_st, n)). ludic migrate state --prune (ludicc --migrate-prune) takes out each state parameter a function no longer uses, nor anything it calls, and the argument that fills it - including an argument for a parameter the callee has dropped, which is taken out before the call is checked, so a generic's T is told by the argument that says it. A reducer keeps its state. --dry-run now counts the edits it would make. Every package was moved with it: 608 base_st parameters and their arguments, 1889 edits. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
81 lines
2.5 KiB
Text
81 lines
2.5 KiB
Text
# verbs.ludic - can it be made, taking and giving back its makings, and making it
|
|
export state CraftingState {
|
|
craft_hold_i: int = -1
|
|
craft_hold_t: float = 0.0
|
|
craft_fact_q: Queue<Crafted> = null
|
|
}
|
|
|
|
export function craft_facts(crafting_st: mut CraftingState) -> Queue<Crafted> {
|
|
if crafting_st.craft_fact_q == null { crafting_st.craft_fact_q = queue_new("crafting.crafted") }
|
|
return crafting_st.craft_fact_q
|
|
}
|
|
|
|
# every making is in the pack
|
|
export function craft_has(i: int) -> bool {
|
|
if not craft_ok(i) { return false }
|
|
for k in 0 .. craft_inputs(i) {
|
|
if CraftPack.count(craft_input(i, k)) < craft_input_n(i, k) { return false }
|
|
}
|
|
return true
|
|
}
|
|
|
|
# learned, the makings in the pack, its station ready, and room for what it makes
|
|
export function craft_can(i: int) -> bool {
|
|
if not craft_ok(i) { return false }
|
|
let r = CraftRecipes[i]
|
|
if not r.learned or not craft_has(i) { return false }
|
|
if not CraftStations.ready(r.station) { return false }
|
|
return CraftPack.room(r.out) >= r.n
|
|
}
|
|
|
|
# the makings out of the pack, and what they leave behind into it
|
|
export function craft_take(i: int) -> void {
|
|
for k in 0 .. craft_inputs(i) {
|
|
let it = craft_input(i, k)
|
|
let n = craft_input_n(i, k)
|
|
CraftPack.take(it, n)
|
|
let left = CraftPack.leaves(it)
|
|
if left >= 0 { CraftPack.add(left, n) }
|
|
}
|
|
}
|
|
|
|
# the makings back, and what they left behind out again (a station said no after all)
|
|
export function craft_refund(i: int) -> void {
|
|
for k in 0 .. craft_inputs(i) {
|
|
let it = craft_input(i, k)
|
|
let n = craft_input_n(i, k)
|
|
CraftPack.add(it, n)
|
|
let left = CraftPack.leaves(it)
|
|
if left >= 0 { CraftPack.take(left, n) }
|
|
}
|
|
}
|
|
|
|
function craft_fact_push(crafting_st: mut CraftingState, i: int, queued: bool) -> void {
|
|
let r = CraftRecipes[i]
|
|
let c = new Crafted
|
|
c.recipe = i
|
|
c.item = r.out
|
|
c.n = r.n
|
|
c.station = r.station
|
|
c.queued = queued
|
|
q_push(craft_facts(crafting_st), c)
|
|
}
|
|
|
|
# make it: a timed recipe at a station goes into the station (given back if it will not take it),
|
|
# anything else is handed over at once. False, and the pack untouched, when it cannot be made.
|
|
export function craft_make(crafting_st: mut CraftingState, i: int) -> bool {
|
|
if not craft_can(i) { return false }
|
|
let r = CraftRecipes[i]
|
|
craft_take(i)
|
|
if r.minutes > 0 and r.station != CRAFT_HANDS {
|
|
if not CraftStations.start(r.station, i) {
|
|
craft_refund(i)
|
|
return false
|
|
}
|
|
craft_fact_push(crafting_st, i, true)
|
|
return true
|
|
}
|
|
CraftPack.add(r.out, r.n)
|
|
craft_fact_push(crafting_st, i, false)
|
|
return true
|
|
}
|