LilGuy/internal/game/game.go

package game

import (
	"image/color"
	"time"

	"github.com/hajimehoshi/ebiten/v2"
	"github.com/hajimehoshi/ebiten/v2/inpututil"

	"github.com/atridad/BigFeelings/internal/hero"
	"github.com/atridad/BigFeelings/internal/status"
	"github.com/atridad/BigFeelings/internal/ui/hud"
	"github.com/atridad/BigFeelings/internal/ui/menu"
)

// ============================================================
// CONFIGURATION
// Tweak these values to change game settings
// ============================================================

const (
	ScreenWidth  = 960
	ScreenHeight = 540
	TargetTPS    = 60
	WindowTitle  = "Big Feelings"
)

var (
	backgroundColor = color.NRGBA{R: 0, G: 0, B: 0, A: 255}
)

// Hero configuration
const (
	heroStartX       = ScreenWidth / 2
	heroStartY       = ScreenHeight / 2
	heroRadius       = 28.0
	heroSpeed        = 180.0
	heroMaxStamina   = 100.0
	heroStaminaDrain = 50.0
	heroStaminaRegen = 30.0
)

var (
	heroColor = color.NRGBA{R: 210, G: 220, B: 255, A: 255}
)

// HUD configuration
const (
	hudX = ScreenWidth - 220
	hudY = 20
)

// Stamina bar colors
var (
	staminaNormalColor = color.NRGBA{R: 0, G: 255, B: 180, A: 255}
	staminaLowColor    = color.NRGBA{R: 255, G: 60, B: 60, A: 255}
)

const (
	staminaLowThreshold = 0.2
)

// ============================================================
// TYPES
// ============================================================

type gameState int

const (
	statePlaying gameState = iota
	statePaused
)

type controls struct {
	Left   bool
	Right  bool
	Up     bool
	Down   bool
	Sprint bool
}

type Game struct {
	state *state
}

type state struct {
	hero      *hero.Hero
	hud       hud.Overlay
	bounds    hero.Bounds
	lastTick  time.Time
	pauseMenu *menu.PauseMenu
	gameState gameState
}

// ============================================================
// INITIALIZATION
// ============================================================

func New() *Game {
	return &Game{state: newState()}
}

func newState() *state {
	now := time.Now()
	return &state{
		hero: hero.New(hero.Config{
			StartX:       heroStartX,
			StartY:       heroStartY,
			Radius:       heroRadius,
			Speed:        heroSpeed,
			Color:        heroColor,
			MaxStamina:   heroMaxStamina,
			StaminaDrain: heroStaminaDrain,
			StaminaRegen: heroStaminaRegen,
		}),
		hud: hud.Overlay{
			X:     hudX,
			Y:     hudY,
			Color: color.White,
		},
		bounds: hero.Bounds{
			Width:  ScreenWidth,
			Height: ScreenHeight,
		},
		lastTick:  now,
		pauseMenu: menu.NewPauseMenu(),
		gameState: statePlaying,
	}
}

// ============================================================
// INPUT
// ============================================================

func readControls() controls {
	return controls{
		Left:   ebiten.IsKeyPressed(ebiten.KeyArrowLeft) || ebiten.IsKeyPressed(ebiten.KeyA),
		Right:  ebiten.IsKeyPressed(ebiten.KeyArrowRight) || ebiten.IsKeyPressed(ebiten.KeyD),
		Up:     ebiten.IsKeyPressed(ebiten.KeyArrowUp) || ebiten.IsKeyPressed(ebiten.KeyW),
		Down:   ebiten.IsKeyPressed(ebiten.KeyArrowDown) || ebiten.IsKeyPressed(ebiten.KeyS),
		Sprint: ebiten.IsKeyPressed(ebiten.KeyShift),
	}
}

// ============================================================
// UPDATE
// ============================================================

func (g *Game) Update() error {
	if inpututil.IsKeyJustPressed(ebiten.KeyEscape) {
		if g.state.gameState == statePlaying {
			g.state.gameState = statePaused
			g.state.pauseMenu.Reset()
		} else if g.state.gameState == statePaused {
			g.state.gameState = statePlaying
			g.state.lastTick = time.Now()
		}
	}

	if g.state.gameState == statePlaying {
		g.state.update(readControls())
	} else if g.state.gameState == statePaused {
		if selectedOption := g.state.pauseMenu.Update(); selectedOption != nil {
			switch *selectedOption {
			case menu.OptionResume:
				g.state.gameState = statePlaying
				g.state.lastTick = time.Now()
			case menu.OptionQuit:
				return ebiten.Termination
			}
		}
	}

	return nil
}

func (s *state) update(input controls) {
	now := time.Now()
	dt := now.Sub(s.lastTick).Seconds()
	s.lastTick = now

	s.hero.Update(hero.Input{
		Left:   input.Left,
		Right:  input.Right,
		Up:     input.Up,
		Down:   input.Down,
		Sprint: input.Sprint,
	}, dt, s.bounds)
}

// ============================================================
// RENDERING
// ============================================================

func (g *Game) Draw(screen *ebiten.Image) {
	g.state.draw(screen)
}

func (s *state) draw(screen *ebiten.Image) {
	screen.Fill(backgroundColor)
	s.hero.Draw(screen)

	staminaColor := staminaNormalColor
	if s.hero.Stamina < s.hero.MaxStamina*staminaLowThreshold {
		staminaColor = staminaLowColor
	}

	staminaMeter := status.Meter{
		Label: "Stamina",
		Base:  s.hero.MaxStamina,
		Level: s.hero.Stamina,
		Color: staminaColor,
	}
	s.hud.Draw(screen, []status.Meter{staminaMeter})

	if s.gameState == statePaused {
		s.pauseMenu.Draw(screen, ScreenWidth, ScreenHeight)
	}
}

func (g *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
	return ScreenWidth, ScreenHeight
}