113 lines
3.5 KiB
Text
113 lines
3.5 KiB
Text
# prefs.ludic — `Prefs.*`: named integer preferences persisted as plain text.
|
|
#
|
|
# Prefs.load("save/prefs.txt") read the file if it exists (missing = empty)
|
|
# Prefs.get("best_floor", 0) an int by name, with a default
|
|
# Prefs.set("best_floor", 3) set (and remember) a value
|
|
# Prefs.save() write every key back as `key=value` lines
|
|
#
|
|
# Deterministic and dependency-free: one file, up to PREFS_MAX entries.
|
|
|
|
const PREFS_MAX: int = 64
|
|
|
|
state PrefsState {
|
|
prefs_path: pointer = null
|
|
prefs_names: pointers = pointers(PREFS_MAX)
|
|
prefs_vals: words = words(PREFS_MAX)
|
|
prefs_n: int = 0
|
|
}
|
|
|
|
namespace Prefs {
|
|
|
|
internal function find(prefs_st: PrefsState, key: pointer) -> int {
|
|
var i = 0
|
|
while i < prefs_st.prefs_n { if prefs_st.prefs_names[i] == key { return i }; i += 1 }
|
|
return -1
|
|
}
|
|
|
|
export function get(prefs_st: mut PrefsState, key: pointer, fallback: int) -> int {
|
|
let i = find(prefs_st, key)
|
|
if i < 0 { return fallback }
|
|
return prefs_st.prefs_vals[i]
|
|
}
|
|
|
|
# keep the larger of the stored value and `value`; true when `value` is a new record
|
|
export function max(prefs_st: mut PrefsState, key: pointer, value: int) -> bool {
|
|
if value <= get(prefs_st, key, 0) { return false }
|
|
set(prefs_st, key, value)
|
|
return true
|
|
}
|
|
|
|
export function set(prefs_st: mut PrefsState, key: pointer, value: int) -> void {
|
|
var i = find(prefs_st, key)
|
|
if i < 0 {
|
|
if prefs_st.prefs_n >= PREFS_MAX { return }
|
|
i = prefs_st.prefs_n
|
|
prefs_st.prefs_names[i] = key
|
|
prefs_st.prefs_n += 1
|
|
}
|
|
prefs_st.prefs_vals[i] = value
|
|
}
|
|
|
|
# the text of a whole file, or null when it does not exist
|
|
internal function read_all(path: pointer) -> pointer {
|
|
let f = file_open(path, "rb")
|
|
if f == null { return null }
|
|
file_seek(f, 0, 2)
|
|
let size = file_tell(f)
|
|
file_seek(f, 0, 0)
|
|
let buf = bytes(size + 1)
|
|
file_read(f, buf, size)
|
|
file_close(f)
|
|
buf[size] = 0
|
|
return buf
|
|
}
|
|
|
|
# digits after `=` on one line -> an int (a leading '-' negates)
|
|
internal function parse_line(prefs_st: mut PrefsState, buf: pointer, from: int, to: int) -> void {
|
|
var eq = from
|
|
while (eq < to) and (buf[eq] != '=') { eq += 1 } # '='
|
|
if eq >= to { return }
|
|
let key = bytes(eq - from + 1)
|
|
var k = 0
|
|
while k < eq - from { key[k] = buf[from + k]; k += 1 }
|
|
key[eq - from] = 0
|
|
var v = 0
|
|
var neg = false
|
|
var p = eq + 1
|
|
if (p < to) and (buf[p] == '-') { neg = true; p += 1 } # '-'
|
|
while (p < to) and (buf[p] >= '0') and (buf[p] <= '9') { v = v * 10 + (buf[p] - 48); p += 1 }
|
|
if neg { v = -v }
|
|
set(prefs_st, key, v)
|
|
}
|
|
|
|
export function load(prefs_st: mut PrefsState, path: pointer) -> void {
|
|
prefs_st.prefs_path = path
|
|
let buf = read_all(path)
|
|
if buf == null { return }
|
|
var start = 0
|
|
var i = 0
|
|
while buf[i] != 0 {
|
|
if buf[i] == '\n' { parse_line(prefs_st, buf, start, i); start = i + 1 } # newline
|
|
i += 1
|
|
}
|
|
if i > start { parse_line(prefs_st, buf, start, i) }
|
|
}
|
|
|
|
internal function write_text(f: pointer, s: pointer) -> void {
|
|
var n = 0
|
|
while s[n] != 0 { n += 1 }
|
|
file_write(f, s, n)
|
|
}
|
|
|
|
export function save(prefs_st: mut PrefsState) -> void {
|
|
if prefs_st.prefs_path == null { return }
|
|
let f = file_open(prefs_st.prefs_path, "wb")
|
|
if f == null { return }
|
|
var i = 0
|
|
while i < prefs_st.prefs_n {
|
|
write_text(f, `{prefs_st.prefs_names[i]}={string(prefs_st.prefs_vals[i])}\n`)
|
|
i += 1
|
|
}
|
|
file_close(f)
|
|
}
|
|
}
|