init

Author: xonvanetta

.gitignore

@@ -0,0 +1,2 @@
+*.exe
+*-linux

Makefile

@@ -0,0 +1,10 @@
+
+build: rotten-blood-boss-timer ebb-and-flow-timer
+
+rotten-blood-boss-timer:
+GOARCH=amd64 GOOS=linux go build -o rotten-blood-boss-timer-linux -ldflags="-X 'main.WindowTitle=Rotten Blood Boss Timer' -X main.FirstAlarm=5s -X main.SecondAlarm=78s -X main.Interval=90s" ./cmd/tibia-timer
+GOARCH=amd64 GOOS=windows go build -o rotten-blood-boss-timer.exe -ldflags="-X 'main.WindowTitle=Rotten Blood Boss Timer' -X main.FirstAlarm=5s -X main.SecondAlarm=78s -X main.Interval=90s" ./cmd/tibia-timer
+
+ebb-and-flow-timer:
+GOARCH=amd64 GOOS=linux go build -o ebb-and-flow-timer-linux -ldflags="-X 'main.WindowTitle=Ebb and Flow Timer' -X main.FirstAlarm=15s -X main.SecondAlarm=0 -X main.Interval=120s" ./cmd/tibia-timer
+GOARCH=amd64 GOOS=windows go build -o ebb-and-flow-timer.exe -ldflags="-X 'main.WindowTitle=Ebb and Flow Timer' -X main.FirstAlarm=15s -X main.SecondAlarm=0 -X main.Interval=120s" ./cmd/tibia-timer

README.md

@@ -0,0 +1,3 @@
+# Tibia-timer
+
+All sound files should be free of use, create an issue and I will update to some other effect.

cmd/tibia-timer/alert.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+"fmt"
+"time"
+
+"github.com/hajimehoshi/ebiten/v2/audio"
+"github.com/hajimehoshi/ebiten/v2/audio/mp3"
+)
+
+var (
+audioContext = audio.NewContext(32000)
+)
+
+type Alert struct {
+when time.Duration
+
+mute bool
+
+audioPlayer *audio.Player
+}
+
+func (a *Alert) SetVolume(vol float64) {
+a.audioPlayer.SetVolume(vol)
+}
+
+func (a *Alert) SetMute(m bool) {
+a.mute = m
+}
+
+func (a *Alert) Update(duration time.Duration) {
+if a.when == 0 {
+return
+}
+
+if a.mute {
+return
+}
+
+if duration == a.when && !a.audioPlayer.IsPlaying() {
+a.audioPlayer.Play()
+a.audioPlayer.Rewind()
+}
+}
+
+func NewAlert(when time.Duration, file string) (*Alert, error) {
+audioPlayer, err := loadAudioPlayer(file)
+if err != nil {
+return nil, err
+}
+
+return &Alert{
+when: when,
+audioPlayer: audioPlayer,
+}, nil
+}
+
+func loadAudioPlayer(file string) (*audio.Player, error) {
+audioFile, err := fs.Open(file)
+if err != nil {
+return nil, fmt.Errorf("failed to open file: %w", err)
+}
+stream, err := mp3.DecodeWithoutResampling(audioFile)
+if err != nil {
+return nil, fmt.Errorf("failed to decode audio file: %w", err)
+}
+
+audioPlayer, err := audioContext.NewPlayer(stream)
+if err != nil {
+return nil, fmt.Errorf("failed to create audio player: %w", err)
+}
+return audioPlayer, nil
+}

cmd/tibia-timer/config.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+"fmt"
+"time"
+)
+
+var (
+FirstAlarm = ""
+SecondAlarm = ""
+Interval = ""
+WindowTitle = ""
+)
+
+type Config struct {
+FirstAlarm time.Duration
+SecondAlarm time.Duration
+Interval time.Duration
+Volume float64
+}
+
+func (c *Config) Validate() error {
+if c.FirstAlarm == 0 {
+return fmt.Errorf("missing first alarm")
+}
+
+if c.Interval == 0 {
+return fmt.Errorf("missing interval")
+}
+
+return nil
+}
+
+func MustParseDuration(s string) time.Duration {
+d, err := time.ParseDuration(s)
+if err != nil {
+panic(fmt.Errorf("must parse duration: %w", err))
+}
+return d
+}

cmd/tibia-timer/files/goat.mp3

@@ -0,0 +1,181 @@
+package main
+
+import (
+"embed"
+"fmt"
+"image/color"
+"log"
+"time"
+
+"github.com/hajimehoshi/ebiten/v2"
+"github.com/hajimehoshi/ebiten/v2/audio"
+"github.com/hajimehoshi/ebiten/v2/ebitenutil"
+"github.com/hajimehoshi/ebiten/v2/inpututil"
+"github.com/hajimehoshi/ebiten/v2/text"
+"golang.org/x/image/font"
+"golang.org/x/image/font/opentype"
+)
+
+// Controller or System
+type Controller interface {
+Update(duration time.Duration)
+Draw(screen *ebiten.Image)
+}
+
+type Component interface {
+Update(duration time.Duration)
+}
+
+type Screen struct {
+time time.Time
+startTime time.Time
+
+controllers []Controller
+
+config *Config
+
+audioPlayer *audio.Player
+font font.Face
+}
+
+var (
+//go:embed files
+fs embed.FS
+)
+
+func (s *Screen) Update() error {
+if time.Now().After(s.time) {
+s.time = s.time.Add(s.config.Interval)
+}
+
+duration := time.Now().Sub(s.time).Round(time.Second).Abs()
+for _, controller := range s.controllers {
+controller.Update(duration)
+}
+
+if inpututil.IsKeyJustPressed(ebiten.KeyBackspace) {
+s.time = time.Now()
+s.startTime = s.time
+}
+
+if isPressed(ebiten.KeyLeft) {
+s.time = s.time.Add(-time.Second)
+}
+if isPressed(ebiten.KeyRight) {
+s.time = s.time.Add(time.Second)
+}
+return nil
+}
+
+func isPressed(key ebiten.Key) bool {
+if ebiten.IsKeyPressed(ebiten.KeyShift) {
+return ebiten.IsKeyPressed(key)
+}
+return inpututil.IsKeyJustPressed(key)
+}
+
+func (s *Screen) Draw(screen *ebiten.Image) {
+text.Draw(screen, fmt.Sprintf("Time left: %s", FormatTime(s.time)), s.font, 5, 25, color.White)
+ebitenutil.DebugPrintAt(screen, "Backspace: Reset time", 5, 45)
+ebitenutil.DebugPrintAt(screen, "<-: Remove one second", 5, 60)
+ebitenutil.DebugPrintAt(screen, "->: Add one second", 5, 75)
+ebitenutil.DebugPrintAt(screen, "^: Increase volume", 5, 90)
+ebitenutil.DebugPrintAt(screen, "v: Lower volume", 5, 105)
+ebitenutil.DebugPrintAt(screen, "M: Mute", 5, 120)
+ebitenutil.DebugPrintAt(screen, "Shift: Increase action", 5, 135)
+ebitenutil.DebugPrintAt(screen, fmt.Sprintf("Total Time: %s", FormatTime(s.startTime)), 5, 150)
+
+for _, controller := range s.controllers {
+controller.Draw(screen)
+}
+
+}
+
+func FormatTime(t time.Time) string {
+seconds := time.Now().Sub(t).Round(time.Second).Abs()
+
+minute := seconds / time.Minute
+seconds -= minute * time.Minute
+seconds = seconds / time.Second
+
+return fmt.Sprintf("%02d:%02d", minute, seconds)
+}
+
+func (s *Screen) Layout(outsideWidth, outsideHeight int) (screenWidth, screenHeight int) {
+return outsideWidth, outsideHeight
+}
+
+func main() {
+config := &Config{
+FirstAlarm: MustParseDuration(FirstAlarm),
+SecondAlarm: MustParseDuration(SecondAlarm),
+Interval: MustParseDuration(Interval),
+Volume: 0.1,
+}
+
+err := config.Validate()
+if err != nil {
+log.Fatalf("failed to validate config: %s", err)
+}
+
+font, err := loadTextFont()
+if err != nil {
+log.Fatalf("failed to load font: %s", err)
+}
+
+firstAlert, err := NewAlert(config.FirstAlarm, "files/quack.mp3")
+if err != nil {
+log.Fatalf("failed to load alert: %s", err)
+}
+
+secondAlert, err := NewAlert(config.SecondAlarm, "files/goat.mp3")
+if err != nil {
+log.Fatalf("failed to load alert: %s", err)
+}
+
+sounds := NewSoundController(config.Volume)
+sounds.Add(firstAlert)
+sounds.Add(secondAlert)
+
+s := &Screen{
+config: config,
+time: time.Now().Add(config.Interval),
+startTime: time.Now(),
+
+controllers: []Controller{sounds},
+font: font,
+}
+
+ebiten.SetWindowSize(200, 180)
+ebiten.SetWindowTitle(WindowTitle)
+ebiten.SetWindowFloating(true)
+
+if err := ebiten.RunGame(s); err != nil {
+log.Fatal(err)
+}
+
+}
+
+func loadTextFont() (font.Face, error) {
+ttfFile, err := fs.ReadFile("files/tahoma.ttf")
+if err != nil {
+return nil, fmt.Errorf("failed to open file: %w", err)
+}
+tt, err := opentype.Parse(ttfFile)
+if err != nil {
+return nil, fmt.Errorf("failed to parse font: %w", err)
+}
+
+tahoma, err := opentype.NewFace(tt, &opentype.FaceOptions{
+Size: 26,
+DPI: 72,
+Hinting: font.HintingVertical,
+})
+if err != nil {
+return nil, fmt.Errorf("failed to create new font face: %w", err)
+}
+// Adjust the line height.
+//mplusBigFont = text.FaceWithLineHeight(mplusBigFont, 54)
+
+return tahoma, nil
+}

cmd/tibia-timer/files/quack.mp3

@@ -0,0 +1,74 @@
+package main
+
+import (
+"fmt"
+"time"
+
+"github.com/hajimehoshi/ebiten/v2"
+"github.com/hajimehoshi/ebiten/v2/ebitenutil"
+)
+
+type Sound interface {
+Component
+SetVolume(vol float64)
+}
+
+type sound struct {
+volumeChanged bool
+mute bool
+volume float64
+
+sounds []Sound
+}
+
+func NewSoundController(volume float64) *sound {
+return &sound{
+volume: volume,
+volumeChanged: true,
+}
+}
+
+func (s *sound) Add(sound Sound) {
+s.sounds = append(s.sounds, sound)
+}
+
+func (s *sound) Update(duration time.Duration) {
+if s.volumeChanged {
+for _, sound := range s.sounds {
+sound.SetVolume(s.volume)
+}
+s.volumeChanged = false
+}
+
+if isPressed(ebiten.KeyUp) && s.volume <= 1 {
+s.volume += .01
+s.volumeChanged = true
+}
+if isPressed(ebiten.KeyDown) && s.volume > 0.01 {
+s.volume -= .01
+s.volumeChanged = true
+}
+
+if isPressed(ebiten.KeyM) {
+s.mute = !s.mute
+}
+
+if s.mute {
+return
+}
+
+for _, sound := range s.sounds {
+sound.Update(duration)
+}
+}
+
+func (s *sound) Draw(screen *ebiten.Image) {
+ebitenutil.DebugPrintAt(screen, fmt.Sprintf("Volume: %s", s.FormatVolume()), 5, 30)
+}
+
+func (s *sound) FormatVolume() string {
+if s.mute {
+return "mute"
+}
+return fmt.Sprintf("%.0f%%", s.volume*100)
+}