oled

type Blockfall ¶

type Blockfall struct {
	Score int
	Lines int
	Over  bool
	// contains filtered or unexported fields
}

Blockfall is one round.

func NewBlockfall(seed uint64) *Blockfall

func (g *Blockfall) End()

func (g *Blockfall) Frame(buf []byte)

func (g *Blockfall) Key(key, state int)

func (g *Blockfall) State() (bool, int, int)

func (g *Blockfall) Step()

type GameDef ¶ added in v1.0.6

type GameDef struct {
	ID, Title string
	Code      []string // remote sequence, by the key names of the speaker's own trace
	Intro     Track
	Over      Track
	// Live: the round's music runs through the game too and follows it
	// (liveaudio.go). Only for games played without Previous/Skip, which are
	// also the firmware's own skip keys and stop the stream.
	Live bool
	// contains filtered or unexported fields
}

GameDef describes one game: how it is started and what it sounds like.

func Game(id string) (GameDef, bool)

type KeyPress ¶

type KeyPress struct {
	Key   int
	State int
}

KeyPress is one remote key state change: Key in BoseApp's KEY_VAL order, State as BoseApp logs it (0 press, 1 release, 2 repeat while held, 3 and 4 press-and-hold stages, 5 timeout).

type Kind ¶

type Kind int

Kind selects the splash text.

const (
	KindNone      Kind = iota
	KindBoot           // a real box boot
	KindInstalled      // first start of STR on this box
	KindUpdated        // first start of a new agent version
)

func DecideKind(stamp string, otaMarker, boxBoot bool) Kind

func (k Kind) String() string

type LiveAudio ¶ added in v1.0.6

type LiveAudio struct {
	// contains filtered or unexported fields
}

LiveAudio is the music of a round that changes with the game: one stream from the intro to the game-over jingle, switched inside the stream so the speaker never has to start a new one. The game sets the tempo and queues short cues; the synth reads them while it renders.

The speaker buffers a second or two of the stream, so everything here is chosen to sound right when it arrives late: a march whose tempo follows the aliens left, a warble while the saucer crosses, and fanfares for a cleared wave or a lost ship. Shot and explosion sounds would always lag the picture and are left out on purpose.

func NewLiveAudio() *LiveAudio

func (la *LiveAudio) Cue(notes []int)

func (la *LiveAudio) GameOver()

func (la *LiveAudio) SetSaucer(on bool)

func (la *LiveAudio) SetTempo(pct int)

func (la *LiveAudio) StartGame()

type Logo ¶

type Logo struct {
	Subtitle string
	Total    float64 // seconds; the zoom-out fills the last 1.6 s
	Hold     bool    // stay assembled with a running bar until Exit is called
	// contains filtered or unexported fields
}

Logo animates the STR mark: the dots of the big letters fly in from outside the panel and settle, the subtitle types in under it, a highlight band sweeps across, and the finale zooms the whole picture towards the viewer until it is gone. With Hold set it never zooms out and instead shows a running bar (for "UPDATING", which ends with the reboot).

func NewLogo(subtitle string, total float64, seed uint64) *Logo

func (l *Logo) Done(t float64) bool

func (l *Logo) Exit(t float64)

func (l *Logo) Frame(t float64, buf []byte)

type Notice ¶ added in v1.0.13

type Notice struct {
	Kind NoticeKind
	// Key is the preset key the notice is about (the count of keys for
	// NoticeRestored).
	Key int
	// Line1 is the big line, Line2 and Line3 the small ones; all already
	// sanitised to what the font can draw.
	Line1, Line2, Line3 string
	// Hold is how long the notice stays, fade-in included.
	Hold time.Duration
	// Bar, when above 0, draws a bar filled to that fraction (0..1).
	Bar float64
	// Bypass shows the notice even when notices are switched off.
	Bypass bool
	// contains filtered or unexported fields
}

Notice is one message for the panel. Build it with the constructors below.

func AlreadyOnKey(other int) Notice

func EmptyKey(key int) Notice

func Identify(name string) Notice

func KeyHeld(key int) Notice

func KeysRestored(n int) Notice

func NotSaved(key int) Notice

func SavedByKey(key int, name string) Notice

func SavedFromApp(key int) Notice

func Swapped(key, other int, otherName string) Notice

type NoticeKind ¶ added in v1.0.13

type NoticeKind string

NoticeKind names a notice in the log and in tests.

const (
	NoticeSavedByKey   NoticeKind = "saved-key"
	NoticeSavedFromApp NoticeKind = "saved-app"
	NoticeAlreadyOnKey NoticeKind = "already-on-key"
	NoticeSwapped      NoticeKind = "swapped"
	NoticeNotSaved     NoticeKind = "not-saved"
	NoticeEmptyKey     NoticeKind = "empty-key"
	NoticeRestored     NoticeKind = "keys-restored"
	NoticeIdentify     NoticeKind = "identify"
)

const NoticeKeyHeld NoticeKind = "key-held"

type Result ¶

type Result struct {
	Score, Lines int
	Reason       string // "game over", "idle", "time", "key", "stopped"
	Screen       []byte // last frame, grey levels 0..15
}

Result is how a round ended.

func PlayRound(id string, stop <-chan struct{}, hooks RoundHooks, logger *slog.Logger) (Result, error)

type RoundHooks ¶

type RoundHooks struct {
	// IntroReady reports whether the intro may end: the caller holds it
	// while the speaker wakes and the intro music starts (capped at introMax).
	IntroReady func() bool
	// GameStart runs when the intro ends and the game begins (music off).
	GameStart func()
	// GameOver runs when the game-over screen appears (jingle on).
	GameOver func()
	// OverHold keeps the game-over screen up past gameOverShown while it
	// reports true (the jingle is still playing), capped at gameOverMax.
	OverHold func() bool
	// Live is the round's live music, handed to a game that drives it.
	Live *LiveAudio
}

RoundHooks lets the caller run the music around a round. Every hook is called from the render loop and must not block. All are optional.

type Scores ¶

type Scores struct {
	Best     int       `json:"best"`
	BestAt   time.Time `json:"bestAt,omitzero"`
	Last     int       `json:"last"`
	LastRows int       `json:"lastRows"`
	LastAt   time.Time `json:"lastAt,omitzero"`
	Rounds   int       `json:"rounds"`
}

Scores is what the app reads back.

func LoadScores(id string) Scores

func SaveRound(id string, r Result, now time.Time) (Scores, error)

type Starguard ¶ added in v1.0.6

type Starguard struct {
	Score int
	// contains filtered or unexported fields
}

Starguard is one round.

func NewStarguard(seed uint64) *Starguard

func (g *Starguard) End()

func (g *Starguard) Frame(buf []byte)

func (g *Starguard) Key(key, state int)

func (g *Starguard) State() (bool, int, int)

func (g *Starguard) Step()

type Synth ¶

type Synth struct {
	Track Track
	// contains filtered or unexported fields
}

Synth renders a track sample by sample.

func (s *Synth) Render(buf []int16)

type Track ¶

type Track struct {
	Lead, Bass []int
	Loop       bool
	// Live, when set, makes this the music of one round that follows the
	// game (liveaudio.go); Lead and Bass are then unused.
	Live *LiveAudio
}

Track is one piece of music: a lead and a bass line in the formats above. A track that does not loop is followed by silence until the stream stops, so the speaker keeps the same stream and shows no state change.

func (tr Track) Length() time.Duration

type TrackText ¶ added in v1.0.13

type TrackText struct {
	Station, Artist, Title string
	Clock, Hour12          bool
}

TrackText is what the track screen shows. Station is the small top line; Title is the main text, Artist the line above it. Either of Artist and Title may be empty (the per-speaker mode shows only one of them). Clock adds the time: in the top line when there is a track, large on its own when Artist and Title are both empty. Hour12 draws it as "3:42 PM", as the speaker's own clock setting says.