sneak
5ba9fe8f66
.golangci.yml is the prompts-repo standard verbatim plus one approved
exception (paralleltest, sneak 2026-07-06). Roughly 1,500 findings
fixed:
- autofix sweep (wsl_v5/nlreturn/intrange/modernize formatting), with
the misspell autofix REVERTED where it rewrote authentic C game text
("missle vanishes" stays, with nolint and a comment)
- error handling: errcheck sites get real handling — saveFile now
closes explicitly and removes corrupt saves, scoreboard writes are
documented best-effort, err113 sentinel errors (ErrSaveOutOfDate,
ErrScreenTooSmall); panics allowed for unrecoverable states per
MEMORY.md policy
- gosec: real fixes (ParseInt for SEED, 0600 scorefile) and justified
per-line nolints for provably-bounded conversions (randomMonsterLetter
helper collapses eight rnd(26)+'A' sites)
- API tidying from linters: pointer receivers on flag types
(recvcheck), msg helpers renamed addmsgf/doaddf/Printwf/MvPrintwf
(goprintffuncname), myExit()/findFloor(monst)/mkGameInput(t) drop
always-constant params (unparam), gameEnd carries no status
- gocritic/staticcheck: if-else chains to switches, the pack.c
inventory filter untangled into matchesFilter, main.go split so
defers run before exit (exitAfterDefer, funlen)
- revive doc comments on all exported flag types/consts/methods
Remaining findings are confined to linters pending sneak's exception
decision (mnd, gochecknoglobals, cyclop, nestif, gocognit, exhaustive,
goconst, testpackage); TODO.md records the state. MEMORY.md added at
repo root as the project's agent working notes.
56 lines
1.3 KiB
Go
56 lines
1.3 KiB
Go
package game
|
|
|
|
// Rng is the original Rogue linear congruential generator. The C RN macro is
|
|
//
|
|
// #define RN (((seed = seed*11109+13849) >> 16) & 0xffff)
|
|
//
|
|
// with `seed` a C int; Seed is int32 so the multiplication wraps exactly the
|
|
// way 32-bit C arithmetic does. A given seed therefore produces the same
|
|
// dungeon as the C game.
|
|
type Rng struct {
|
|
Seed int32
|
|
}
|
|
|
|
// Rnd picks a very random number in [0, rng) (main.c rnd).
|
|
func (r *Rng) Rnd(rng int) int {
|
|
if rng == 0 {
|
|
return 0
|
|
}
|
|
|
|
v := r.next()
|
|
if v < 0 {
|
|
v = -v
|
|
}
|
|
|
|
return v % rng
|
|
}
|
|
|
|
// Roll rolls a number of dice (main.c roll).
|
|
func (r *Rng) Roll(number, sides int) int {
|
|
dtotal := 0
|
|
for ; number > 0; number-- {
|
|
dtotal += r.Rnd(sides) + 1
|
|
}
|
|
|
|
return dtotal
|
|
}
|
|
|
|
// next steps the generator and returns the next raw value (the RN macro).
|
|
func (r *Rng) next() int {
|
|
r.Seed = r.Seed*11109 + 13849
|
|
|
|
return int(r.Seed>>16) & 0xffff
|
|
}
|
|
|
|
// rnd is the ported code's spelling of C rnd(): every call site in the C
|
|
// sources reads rnd(x), and keeping that shape makes cross-checking easy.
|
|
func (g *RogueGame) rnd(rng int) int { return g.Rng.Rnd(rng) }
|
|
|
|
// roll is C roll().
|
|
func (g *RogueGame) roll(number, sides int) int { return g.Rng.Roll(number, sides) }
|
|
|
|
// spread gives a fuzzy number centered on nm (misc.c spread).
|
|
func (g *RogueGame) spread(nm int) int {
|
|
return nm - nm/20 + g.rnd(nm/10)
|
|
}
|