input.go

package main

import (
	"github.com/hajimehoshi/ebiten/v2"
	"github.com/hajimehoshi/ebiten/v2/inpututil"
)

// eventMsg is a transient announcement drawn at the top of the screen
// (war declarations, conquests, surrenders...).
type eventMsg struct {
	text string
	ttl  float64
}

// banner queues a world event announcement.
func (g *Game) banner(text string) {
	g.banners = append(g.banners, eventMsg{text: text, ttl: 6})
	if len(g.banners) > 6 {
		g.banners = g.banners[1:]
	}
}

func (g *Game) updateBanners(dt float64) {
	kept := g.banners[:0]
	for _, b := range g.banners {
		b.ttl -= dt
		if b.ttl > 0 {
			kept = append(kept, b)
		}
	}
	g.banners = kept
}

// handleInput processes selection and orders:
//
//	Left click           — select the unit under the cursor (Shift adds)
//	Left drag (empty)    — rubber-band select player units in the box
//	Left drag (on unit)  — ONE-TIME move order for the selection
//	Right drag / click   — PERSISTENT order for the selection (stays until C)
//	Left+Right drag      — DEFENCE LINE: the selection lines up along the
//	                       line you draw (hold both buttons, drag, release)
//	C                    — cancel orders (selection, or all of yours)
//	X                    — declare war on the country under the cursor
func (g *Game) handleInput() {
	mx, my := ebiten.CursorPosition()

	if inpututil.IsKeyJustPressed(ebiten.KeyC) {
		g.cancelSelectedOrders()
		return
	}
	if inpututil.IsKeyJustPressed(ebiten.KeyX) {
		g.declareWarOnHovered()
		return
	}

	leftDown := ebiten.IsMouseButtonPressed(ebiten.MouseButtonLeft)
	rightDown := ebiten.IsMouseButtonPressed(ebiten.MouseButtonRight)

	// Defence-line order: with units selected, hold left+right and drag to
	// draw a line; the selection deploys evenly along it once both buttons
	// are released. The preview keeps following the cursor while one button
	// is still held, and the gesture ends without committing if it was never
	// completed (both buttons pressed together first).
	if g.dragMode == dragLine {
		if !leftDown && !rightDown {
			g.finishLineOrder(mx, my)
			g.dragMode = dragNone
		}
		return
	}
	if leftDown && rightDown && len(g.selected) > 0 {
		g.dragMode = dragLine
		g.dragStartX, g.dragStartY = mx, my
		return
	}

	if inpututil.IsMouseButtonJustPressed(ebiten.MouseButtonLeft) {
		g.dragStartX, g.dragStartY = mx, my
		if u := g.playerUnitAt(mx, my); u != nil {
			if ebiten.IsKeyPressed(ebiten.KeyShift) {
				g.addSelected(u)
			} else {
				g.selected = []*Unit{u}
			}
			g.dragMode = dragMove
		} else {
			g.dragMode = dragSelect
		}
	}
	if inpututil.IsMouseButtonJustReleased(ebiten.MouseButtonLeft) {
		dx, dy := mx-g.dragStartX, my-g.dragStartY
		if g.dragMode == dragSelect {
			if dx*dx+dy*dy < 36 { // plain click: select under cursor or clear
				if u := g.playerUnitAt(mx, my); u != nil {
					if ebiten.IsKeyPressed(ebiten.KeyShift) {
						g.addSelected(u)
					} else {
						g.selected = []*Unit{u}
					}
				} else {
					g.selected = nil
				}
			} else {
				g.selectBox(g.dragStartX, g.dragStartY, mx, my)
			}
		} else if g.dragMode == dragMove && dx*dx+dy*dy >= 36 {
			wx, wy := g.camera.ScreenToWorld(float64(mx), float64(my))
			g.issueOrders(g.selected, wx, wy, false)
		}
		g.dragMode = dragNone
	}

	// right button: persistent orders (right-click also selects the unit
	// under the cursor if nothing is selected yet)
	if inpututil.IsMouseButtonJustPressed(ebiten.MouseButtonRight) {
		g.dragStartX, g.dragStartY = mx, my
		if len(g.selected) == 0 {
			if u := g.playerUnitAt(mx, my); u != nil {
				g.selected = []*Unit{u}
			}
		}
	}
	if inpututil.IsMouseButtonJustReleased(ebiten.MouseButtonRight) {
		if len(g.selected) > 0 {
			wx, wy := g.camera.ScreenToWorld(float64(mx), float64(my))
			g.issueOrders(g.selected, wx, wy, true)
		}
	}
}

// addSelected adds u to the selection if it isn't already there.
func (g *Game) addSelected(u *Unit) {
	for _, s := range g.selected {
		if s == u {
			return
		}
	}
	g.selected = append(g.selected, u)
}

// playerUnitAt returns the player's unit under screen coordinates, or nil.
func (g *Game) playerUnitAt(sx, sy int) *Unit {
	m := g.gameMap
	if m == nil || len(g.units) == 0 {
		return nil
	}
	wx, wy := g.camera.ScreenToWorld(float64(sx), float64(sy))
	tol := 14.0 / g.camera.Zoom // screen px tolerance scaled to world
	tol2 := tol * tol
	var best *Unit
	bestD := tol2
	for _, u := range g.units {
		if u.Owner != m.PlayerCountry || u.HP <= 0 {
			continue
		}
		dx, dy := u.X-wx, u.Y-wy
		if d := dx*dx + dy*dy; d <= bestD {
			bestD, best = d, u
		}
	}
	return best
}

// selectBox selects every player unit inside the screen rectangle.
func (g *Game) selectBox(x0, y0, x1, y1 int) {
	m := g.gameMap
	if m == nil {
		return
	}
	if x0 > x1 {
		x0, x1 = x1, x0
	}
	if y0 > y1 {
		y0, y1 = y1, y0
	}
	wx0, wy0 := g.camera.ScreenToWorld(float64(x0), float64(y0))
	wx1, wy1 := g.camera.ScreenToWorld(float64(x1), float64(y1))
	g.selected = nil
	for _, u := range g.units {
		if u.Owner != m.PlayerCountry || u.HP <= 0 {
			continue
		}
		if u.X >= wx0 && u.X <= wx1 && u.Y >= wy0 && u.Y <= wy1 {
			g.selected = append(g.selected, u)
		}
	}
}

// issueOrders gives every selected unit a move order. One-time orders target
// the exact point; persistent orders scatter each unit around it.
func (g *Game) issueOrders(units []*Unit, wx, wy float64, persistent bool) {
	for _, u := range units {
		if u.HP <= 0 {
			continue
		}
		g.orderUnit(u, wx, wy, persistent)
	}
}

// finishLineOrder commits the defence line the player is drawing: the line
// runs from where the gesture started (screen coords) to the current cursor,
// converted to world space for issueLineOrder.
func (g *Game) finishLineOrder(mx, my int) {
	if len(g.selected) == 0 {
		return
	}
	wx0, wy0 := g.camera.ScreenToWorld(float64(g.dragStartX), float64(g.dragStartY))
	wx1, wy1 := g.camera.ScreenToWorld(float64(mx), float64(my))
	g.issueLineOrder(g.selected, wx0, wy0, wx1, wy1)
}

// cancelSelectedOrders clears orders of the selection (or of every player
// unit when nothing is selected).
func (g *Game) cancelSelectedOrders() {
	m := g.gameMap
	if m == nil {
		return
	}
	if len(g.selected) == 0 {
		for _, u := range g.units {
			if u.Owner == m.PlayerCountry {
				u.Order = nil
			}
		}
		return
	}
	for _, u := range g.selected {
		u.Order = nil
	}
}

// declareWarOnHovered declares war on the country under the cursor (X key).
func (g *Game) declareWarOnHovered() {
	m := g.gameMap
	if m == nil {
		return
	}
	mx, my := ebiten.CursorPosition()
	wx, wy := g.camera.ScreenToWorld(float64(mx), float64(my))
	tx, ty := int(wx)/tileSize, int(wy)/tileSize
	if tx < 0 || tx >= m.Width || ty < 0 || ty >= m.Height {
		return
	}
	oc := m.Owner[ty][tx]
	if oc < 0 || oc == m.PlayerCountry {
		g.banner("No valid target to declare war on.")
		return
	}
	if g.eliminated[oc] {
		g.banner("That nation no longer exists.")
		return
	}
	if g.atWarBetween(m.PlayerCountry, oc) {
		g.banner("You are already at war with " + g.name(oc) + ".")
		return
	}
	if g.pendingOutgoing(m.PlayerCountry) {
		g.banner("You already have a war declaration pending.")
		return
	}
	g.declareWar(m.PlayerCountry, oc)
}

// pendingOutgoing reports whether country i has its own declaration pending
// (incoming declarations from others don't block counter-declarations, which
// take effect immediately as a mutual war).
func (g *Game) pendingOutgoing(i int) bool {
	for _, d := range g.decls {
		if d.a == i {
			return true
		}
	}
	return false
}

// hoveredForeignCountry returns the non-player, non-eliminated country index
// under the cursor, or -1 (used for the HUD declare-war hint).
func (g *Game) hoveredForeignCountry() int {
	m := g.gameMap
	if m == nil {
		return -1
	}
	mx, my := ebiten.CursorPosition()
	wx, wy := g.camera.ScreenToWorld(float64(mx), float64(my))
	tx, ty := int(wx)/tileSize, int(wy)/tileSize
	if tx < 0 || tx >= m.Width || ty < 0 || ty >= m.Height {
		return -1
	}
	oc := m.Owner[ty][tx]
	if oc < 0 || oc == m.PlayerCountry || g.eliminated[oc] {
		return -1
	}
	return oc
}

// selectionCentroid returns the average position of the selected units.
func (g *Game) selectionCentroid() (float64, float64, bool) {
	if len(g.selected) == 0 {
		return 0, 0, false
	}
	var sx, sy float64
	for _, u := range g.selected {
		sx += u.X
		sy += u.Y
	}
	return sx / float64(len(g.selected)), sy / float64(len(g.selected)), true
}

// isSelected reports whether u is currently selected.
func (g *Game) isSelected(u *Unit) bool {
	for _, s := range g.selected {
		if s == u {
			return true
		}
	}
	return false
}