phase 0.3
This commit is contained in:
commit
4a94bfc4e7
52 changed files with 11653 additions and 0 deletions
810
internal/ui/fleet.go
Normal file
810
internal/ui/fleet.go
Normal file
|
|
@ -0,0 +1,810 @@
|
|||
package ui
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
tea "github.com/charmbracelet/bubbletea"
|
||||
"github.com/charmbracelet/lipgloss"
|
||||
|
||||
"skyrama-tui/internal/model"
|
||||
"skyrama-tui/internal/service"
|
||||
"skyrama-tui/internal/style"
|
||||
)
|
||||
|
||||
// ─── Messages ─────────────────────────────────────────────────────────────────
|
||||
|
||||
type FleetLoadedMsg struct {
|
||||
Fleet []model.PlayerPlane
|
||||
Facilities []model.FacilityStatus
|
||||
Note string // surfaced dispatch failure (e.g. out of fuel), if any
|
||||
}
|
||||
type FleetErrMsg struct{ Err error }
|
||||
type FlightLaunchedMsg struct{ PlaneID uint32 }
|
||||
type FlightLandedMsg struct {
|
||||
Count int
|
||||
CashEarned int64
|
||||
}
|
||||
type ServiceProgressMsg struct{}
|
||||
type PlaneSoldMsg struct{ Refund int64 }
|
||||
type DestinationsLoadedMsg struct{ Dest []model.CentralAirport }
|
||||
type DispatchResultMsg struct{ Queued int }
|
||||
type DispatchCancelledMsg struct{ Count int }
|
||||
|
||||
// ─── Columns ──────────────────────────────────────────────────────────────────
|
||||
|
||||
// fleetColumns are the status lanes shown side-by-side, in lifecycle order.
|
||||
var fleetColumns = []struct{ status, title string }{
|
||||
{"idle", "Waiting"},
|
||||
{"boarding", "Boarding"},
|
||||
{"taxiing", "Refueling"},
|
||||
{"flying", "In-flight"},
|
||||
{"unloading", "Unloading"},
|
||||
}
|
||||
|
||||
// colEntry is one plane-template's planes within a single status column.
|
||||
// Identical templates (same plane_id) are interchangeable, so they collapse to
|
||||
// one row with a count.
|
||||
type colEntry struct {
|
||||
planeID uint32
|
||||
name string
|
||||
aircraft string
|
||||
size string
|
||||
opType string
|
||||
fuelCost uint32
|
||||
maxPax int32
|
||||
cash int32
|
||||
buyingCost uint32
|
||||
members []model.PlayerPlane // members in THIS status only
|
||||
}
|
||||
|
||||
// ─── FleetModel ───────────────────────────────────────────────────────────────
|
||||
|
||||
type FleetModel struct {
|
||||
client *service.GameService
|
||||
airportID uint32
|
||||
fleet []model.PlayerPlane
|
||||
facilities []model.FacilityStatus
|
||||
cols [][]colEntry
|
||||
queued []colEntry // RAM-queued dispatches (status "queued"), shown in Waiting
|
||||
activeCol int
|
||||
sel []int // cursor index per column
|
||||
|
||||
// attribute filters ("" = all)
|
||||
filterSize string
|
||||
filterType string
|
||||
filterOp string
|
||||
|
||||
// dispatch sub-mode
|
||||
dispatchMode bool
|
||||
dispatchEntry colEntry
|
||||
destinations []model.CentralAirport
|
||||
destIdx int
|
||||
dispatchCount int
|
||||
|
||||
statusMsg string
|
||||
sellArmed bool
|
||||
focused bool
|
||||
width int
|
||||
height int
|
||||
}
|
||||
|
||||
func NewFleetModel(client *service.GameService, airportID uint32) FleetModel {
|
||||
return FleetModel{
|
||||
client: client,
|
||||
airportID: airportID,
|
||||
sel: make([]int, len(fleetColumns)),
|
||||
}
|
||||
}
|
||||
|
||||
func (m FleetModel) Init() tea.Cmd {
|
||||
return tea.Batch(m.loadFleet(), m.loadDestinations())
|
||||
}
|
||||
|
||||
func (m FleetModel) Update(msg tea.Msg) (FleetModel, tea.Cmd) {
|
||||
switch msg := msg.(type) {
|
||||
case tea.WindowSizeMsg:
|
||||
m.width = msg.Width
|
||||
m.height = msg.Height
|
||||
|
||||
case FleetLoadedMsg:
|
||||
m.fleet = msg.Fleet
|
||||
m.facilities = msg.Facilities
|
||||
m.cols = m.buildColumns()
|
||||
m.queued = m.buildQueued()
|
||||
m.clampSel()
|
||||
if msg.Note != "" {
|
||||
m.statusMsg = style.Warning.String() + msg.Note
|
||||
}
|
||||
|
||||
case DestinationsLoadedMsg:
|
||||
m.destinations = msg.Dest
|
||||
|
||||
case ServiceProgressMsg:
|
||||
return m, m.loadFleet()
|
||||
|
||||
case FlightLaunchedMsg:
|
||||
m.statusMsg = style.Success.String() + fmt.Sprintf("Plane #%d launched!", msg.PlaneID)
|
||||
return m, m.loadFleet()
|
||||
|
||||
case FlightLandedMsg:
|
||||
m.statusMsg = style.Success.String() +
|
||||
fmt.Sprintf("%d plane(s) landed! +$%d", msg.Count, msg.CashEarned)
|
||||
return m, m.loadFleet()
|
||||
|
||||
case PlaneSoldMsg:
|
||||
m.statusMsg = style.Success.String() + fmt.Sprintf("Sold plane for $%d", msg.Refund)
|
||||
return m, m.loadFleet()
|
||||
|
||||
case DispatchResultMsg:
|
||||
m.statusMsg = style.Success.String() +
|
||||
fmt.Sprintf("Queued %d plane(s) for dispatch", msg.Queued)
|
||||
return m, m.loadFleet()
|
||||
|
||||
case DispatchCancelledMsg:
|
||||
m.statusMsg = style.Success.String() +
|
||||
fmt.Sprintf("Cancelled %d queued dispatch(es)", msg.Count)
|
||||
return m, m.loadFleet()
|
||||
|
||||
case FleetErrMsg:
|
||||
m.statusMsg = style.Error.String() + msg.Err.Error()
|
||||
|
||||
case tea.KeyMsg:
|
||||
if !m.focused {
|
||||
break
|
||||
}
|
||||
return m.handleKey(msg)
|
||||
}
|
||||
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// handleKey routes a keypress depending on the current sub-mode.
|
||||
func (m FleetModel) handleKey(msg tea.KeyMsg) (FleetModel, tea.Cmd) {
|
||||
// Dispatch modal has its own bindings.
|
||||
if m.dispatchMode {
|
||||
return m.handleDispatchKey(msg)
|
||||
}
|
||||
|
||||
// A sell confirmation is pending: y confirms, anything else cancels.
|
||||
if m.sellArmed {
|
||||
m.sellArmed = false
|
||||
if msg.String() == "y" || msg.String() == "Y" {
|
||||
if e := m.currentEntry(); e != nil && len(e.members) > 0 {
|
||||
return m, m.sellPlane(&e.members[0])
|
||||
}
|
||||
m.statusMsg = style.Muted.Render("Nothing to sell.")
|
||||
return m, nil
|
||||
}
|
||||
m.statusMsg = style.Muted.Render("Sale cancelled.")
|
||||
return m, nil
|
||||
}
|
||||
|
||||
switch msg.String() {
|
||||
case "r", "R":
|
||||
m.statusMsg = ""
|
||||
return m, m.loadFleet()
|
||||
case "left", "h":
|
||||
if m.activeCol > 0 {
|
||||
m.activeCol--
|
||||
}
|
||||
case "right", "l":
|
||||
if m.activeCol < len(fleetColumns)-1 {
|
||||
m.activeCol++
|
||||
}
|
||||
case "up", "k":
|
||||
if m.sel[m.activeCol] > 0 {
|
||||
m.sel[m.activeCol]--
|
||||
}
|
||||
case "down", "j":
|
||||
if m.sel[m.activeCol] < len(m.cols[m.activeCol])-1 {
|
||||
m.sel[m.activeCol]++
|
||||
}
|
||||
case "z":
|
||||
m.filterSize = cycle(m.filterSize, "small", "medium", "large", "huge")
|
||||
m.cols = m.buildColumns()
|
||||
m.clampSel()
|
||||
case "t":
|
||||
m.filterType = cycle(m.filterType, "plane", "helicopter", "seaplane", "spaceship")
|
||||
m.cols = m.buildColumns()
|
||||
m.clampSel()
|
||||
case "o":
|
||||
m.filterOp = cycle(m.filterOp, "passenger", "cargo")
|
||||
m.cols = m.buildColumns()
|
||||
m.clampSel()
|
||||
case "s", "S":
|
||||
// Sell only makes sense on a Waiting (idle) plane.
|
||||
if fleetColumns[m.activeCol].status != "idle" {
|
||||
m.statusMsg = style.Muted.Render("Select a Waiting plane to sell.")
|
||||
return m, nil
|
||||
}
|
||||
e := m.currentEntry()
|
||||
if e == nil || len(e.members) == 0 {
|
||||
break
|
||||
}
|
||||
m.sellArmed = true
|
||||
m.statusMsg = style.Warning.String() +
|
||||
fmt.Sprintf("Sell one %s for $%d? (y/n)", e.name, resaleValue(&e.members[0]))
|
||||
return m, nil
|
||||
case "x", "X":
|
||||
if len(m.queued) == 0 {
|
||||
m.statusMsg = style.Muted.Render("Nothing queued to cancel.")
|
||||
return m, nil
|
||||
}
|
||||
return m, m.cancelQueue()
|
||||
case " ", "enter":
|
||||
return m.onSelect()
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// onSelect handles enter/space on the focused column entry.
|
||||
func (m FleetModel) onSelect() (FleetModel, tea.Cmd) {
|
||||
e := m.currentEntry()
|
||||
if e == nil {
|
||||
return m, nil
|
||||
}
|
||||
switch fleetColumns[m.activeCol].status {
|
||||
case "idle":
|
||||
// Open the dispatch picker for this template.
|
||||
if len(m.destinations) == 0 {
|
||||
m.statusMsg = style.Muted.Render("No destinations available yet.")
|
||||
return m, nil
|
||||
}
|
||||
m.dispatchMode = true
|
||||
m.dispatchEntry = *e
|
||||
m.destIdx = 0
|
||||
m.dispatchCount = 1
|
||||
m.statusMsg = ""
|
||||
case "flying":
|
||||
// Try to land any ready members.
|
||||
return m, m.CheckLanding()
|
||||
default:
|
||||
m.statusMsg = style.Muted.Render("These planes are in service — wait for them to free up.")
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// handleDispatchKey drives the destination/count modal.
|
||||
func (m FleetModel) handleDispatchKey(msg tea.KeyMsg) (FleetModel, tea.Cmd) {
|
||||
idle := len(m.dispatchEntry.members)
|
||||
switch msg.String() {
|
||||
case "esc", "q":
|
||||
m.dispatchMode = false
|
||||
m.statusMsg = style.Muted.Render("Dispatch cancelled.")
|
||||
case "up", "k":
|
||||
if m.destIdx > 0 {
|
||||
m.destIdx--
|
||||
}
|
||||
case "down", "j":
|
||||
if m.destIdx < len(m.destinations)-1 {
|
||||
m.destIdx++
|
||||
}
|
||||
case "left", "h", "-":
|
||||
if m.dispatchCount > 1 {
|
||||
m.dispatchCount--
|
||||
}
|
||||
case "right", "l", "+", "=":
|
||||
if m.dispatchCount < idle {
|
||||
m.dispatchCount++
|
||||
}
|
||||
case "enter", " ":
|
||||
dest := m.destinations[m.destIdx].AirportID
|
||||
members := m.dispatchEntry.members
|
||||
count := m.dispatchCount
|
||||
m.dispatchMode = false
|
||||
return m, m.dispatchFlights(members, dest, count)
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
func (m FleetModel) View() string {
|
||||
if m.dispatchMode {
|
||||
return m.dispatchView()
|
||||
}
|
||||
if len(m.fleet) == 0 {
|
||||
return style.Muted.Render("No planes in your fleet. Buy some in the Shop tab (5).")
|
||||
}
|
||||
|
||||
header := style.PanelHeader.Render(fmt.Sprintf("🛩 Your Fleet (%d planes)", len(m.fleet)))
|
||||
|
||||
// Active filters + facilities (runway/service-bay free/total).
|
||||
filterLine := m.filterLine()
|
||||
facilitiesLine := m.facilitiesLine()
|
||||
|
||||
status := ""
|
||||
if m.statusMsg != "" {
|
||||
status = m.statusMsg
|
||||
}
|
||||
|
||||
cols := m.renderColumns()
|
||||
|
||||
help := style.HelpKey.Render("←→/hl") + style.HelpDesc.Render(" column ") +
|
||||
style.HelpKey.Render("↑↓/jk") + style.HelpDesc.Render(" select ") +
|
||||
style.HelpKey.Render("enter") + style.HelpDesc.Render(" dispatch/land ") +
|
||||
style.HelpKey.Render("s") + style.HelpDesc.Render(" sell ") +
|
||||
style.HelpKey.Render("x") + style.HelpDesc.Render(" cancel queue ") +
|
||||
style.HelpKey.Render("z/t/o") + style.HelpDesc.Render(" filter ") +
|
||||
style.HelpKey.Render("r") + style.HelpDesc.Render(" refresh")
|
||||
|
||||
return lipgloss.JoinVertical(lipgloss.Left,
|
||||
header,
|
||||
filterLine,
|
||||
facilitiesLine,
|
||||
status,
|
||||
cols,
|
||||
"",
|
||||
style.Muted.Render(help),
|
||||
)
|
||||
}
|
||||
|
||||
// ─── Rendering ──────────────────────────────────────────────────────────────
|
||||
|
||||
func (m FleetModel) renderColumns() string {
|
||||
n := len(fleetColumns)
|
||||
colW := 18
|
||||
if m.width > 4 {
|
||||
colW = (m.width - 4) / n
|
||||
}
|
||||
if colW < 12 {
|
||||
colW = 12
|
||||
}
|
||||
bodyH := m.height - 11
|
||||
if bodyH < 3 {
|
||||
bodyH = 3
|
||||
}
|
||||
|
||||
titleSel := lipgloss.NewStyle().Foreground(style.ColorSky).Bold(true)
|
||||
titleDim := lipgloss.NewStyle().Foreground(style.ColorPassenger)
|
||||
rowSel := lipgloss.NewStyle().Foreground(style.ColorSky).Bold(true)
|
||||
|
||||
rendered := make([]string, n)
|
||||
for ci := range fleetColumns {
|
||||
var b strings.Builder
|
||||
title := fmt.Sprintf("%s (%d)", fleetColumns[ci].title, columnPlaneCount(m.cols[ci]))
|
||||
// Show queued count alongside the Waiting lane.
|
||||
if ci == 0 && len(m.queued) > 0 {
|
||||
title += fmt.Sprintf(" +%d⏳", columnPlaneCount(m.queued))
|
||||
}
|
||||
if ci == m.activeCol {
|
||||
b.WriteString(titleSel.Render("▌" + title))
|
||||
} else {
|
||||
b.WriteString(titleDim.Render(" " + title))
|
||||
}
|
||||
b.WriteString("\n")
|
||||
|
||||
if len(m.cols[ci]) == 0 {
|
||||
b.WriteString(style.Muted.Render(" —"))
|
||||
}
|
||||
for ri, e := range m.cols[ci] {
|
||||
line := fmt.Sprintf("%s %s ×%d", planeIcon(e.aircraft), e.name, len(e.members))
|
||||
// In-flight / service columns show the soonest countdown.
|
||||
if r, ok := soonestRemaining(e.members); ok {
|
||||
if r == 0 {
|
||||
line += " ✓"
|
||||
} else {
|
||||
line += " " + fmtDuration(r)
|
||||
}
|
||||
}
|
||||
line = truncate(line, colW-2)
|
||||
if ci == m.activeCol && ri == m.sel[ci] {
|
||||
b.WriteString(rowSel.Render("›" + line))
|
||||
} else {
|
||||
b.WriteString(" " + line)
|
||||
}
|
||||
b.WriteString("\n")
|
||||
}
|
||||
// Queued (RAM-accepted, not yet launched) dispatches hang under Waiting,
|
||||
// dimmed and non-selectable, showing their destination.
|
||||
if ci == 0 && len(m.queued) > 0 {
|
||||
dim := lipgloss.NewStyle().Foreground(style.ColorMuted)
|
||||
for _, e := range m.queued {
|
||||
dest := ""
|
||||
if len(e.members) > 0 && e.members[0].DestinationName.Valid {
|
||||
dest = " → " + e.members[0].DestinationName.String
|
||||
}
|
||||
line := truncate(fmt.Sprintf("⏳ %s ×%d%s", e.name, len(e.members), dest), colW-2)
|
||||
b.WriteString(" " + dim.Render(line) + "\n")
|
||||
}
|
||||
}
|
||||
colStyle := lipgloss.NewStyle().Width(colW).MaxHeight(bodyH)
|
||||
rendered[ci] = colStyle.Render(b.String())
|
||||
}
|
||||
return lipgloss.JoinHorizontal(lipgloss.Top, rendered...)
|
||||
}
|
||||
|
||||
func (m FleetModel) dispatchView() string {
|
||||
e := m.dispatchEntry
|
||||
header := style.PanelHeader.Render(
|
||||
fmt.Sprintf("🛫 Dispatch %s %s", planeIcon(e.aircraft), e.name))
|
||||
|
||||
info := style.Muted.Render(fmt.Sprintf("%d idle · ⛽%d each", len(e.members), e.fuelCost))
|
||||
if e.maxPax > 0 {
|
||||
info += style.Muted.Render(fmt.Sprintf(" · 👤%d each", e.maxPax))
|
||||
}
|
||||
|
||||
var b strings.Builder
|
||||
b.WriteString(style.PanelHeader.Render("Destination") + "\n")
|
||||
for i, d := range m.destinations {
|
||||
label := d.Name
|
||||
if d.FactionName != "" {
|
||||
label += " — " + d.FactionName
|
||||
}
|
||||
if i == m.destIdx {
|
||||
b.WriteString(lipgloss.NewStyle().Foreground(style.ColorSky).Bold(true).Render("› "+label) + "\n")
|
||||
} else {
|
||||
b.WriteString(" " + style.Muted.Render(label) + "\n")
|
||||
}
|
||||
}
|
||||
|
||||
count := style.CashChip.Render(fmt.Sprintf(" Count: %d / %d ", m.dispatchCount, len(e.members)))
|
||||
|
||||
help := style.HelpKey.Render("↑↓") + style.HelpDesc.Render(" destination ") +
|
||||
style.HelpKey.Render("←→") + style.HelpDesc.Render(" count ") +
|
||||
style.HelpKey.Render("enter") + style.HelpDesc.Render(" confirm ") +
|
||||
style.HelpKey.Render("esc") + style.HelpDesc.Render(" cancel")
|
||||
|
||||
return lipgloss.JoinVertical(lipgloss.Left,
|
||||
header,
|
||||
info,
|
||||
"",
|
||||
b.String(),
|
||||
count,
|
||||
"",
|
||||
style.Muted.Render(help),
|
||||
)
|
||||
}
|
||||
|
||||
func (m FleetModel) filterLine() string {
|
||||
val := func(label, v string) string {
|
||||
if v == "" {
|
||||
v = "all"
|
||||
}
|
||||
return style.Muted.Render(label+":") + style.HelpKey.Render(v)
|
||||
}
|
||||
return style.Muted.Render("Filters ") +
|
||||
val("size", m.filterSize) + " " +
|
||||
val("type", m.filterType) + " " +
|
||||
val("op", m.filterOp)
|
||||
}
|
||||
|
||||
// facilitiesLine shows runway / service-bay availability (free/total) per size,
|
||||
// so the player can see why dispatched planes sit queued.
|
||||
func (m FleetModel) facilitiesLine() string {
|
||||
if len(m.facilities) == 0 {
|
||||
return style.Muted.Render("Facilities none — build runways & service bays in the Buildings tab")
|
||||
}
|
||||
byType := make(map[string][]string)
|
||||
var order []string
|
||||
for _, f := range m.facilities {
|
||||
if _, ok := byType[f.OperationType]; !ok {
|
||||
order = append(order, f.OperationType)
|
||||
}
|
||||
size := "?"
|
||||
if f.Size != "" {
|
||||
size = f.Size[:1]
|
||||
}
|
||||
byType[f.OperationType] = append(byType[f.OperationType],
|
||||
fmt.Sprintf("%s %d/%d", size, f.Total-f.Busy, f.Total))
|
||||
}
|
||||
var segs []string
|
||||
for _, t := range order {
|
||||
icon, label := "🅿", "Service"
|
||||
if t == "runway" {
|
||||
icon, label = "🛫", "Runway"
|
||||
}
|
||||
segs = append(segs, fmt.Sprintf("%s %s %s", icon, label, strings.Join(byType[t], " ")))
|
||||
}
|
||||
return style.Muted.Render("Facilities " + strings.Join(segs, " "))
|
||||
}
|
||||
|
||||
// ─── Column building / selection ───────────────────────────────────────────
|
||||
|
||||
func (m FleetModel) buildColumns() [][]colEntry {
|
||||
cols := make([][]colEntry, len(fleetColumns))
|
||||
for ci, col := range fleetColumns {
|
||||
idx := make(map[uint32]int)
|
||||
for i := range m.fleet {
|
||||
p := m.fleet[i]
|
||||
if p.Status != col.status || !m.passesFilter(p) {
|
||||
continue
|
||||
}
|
||||
j, ok := idx[p.PlaneID]
|
||||
if !ok {
|
||||
pax := int32(0)
|
||||
if p.MaxPassengers.Valid {
|
||||
pax = p.MaxPassengers.Int32
|
||||
}
|
||||
cash := int32(0)
|
||||
if p.CashReward.Valid {
|
||||
cash = p.CashReward.Int32
|
||||
}
|
||||
cols[ci] = append(cols[ci], colEntry{
|
||||
planeID: p.PlaneID,
|
||||
name: p.PlaneName,
|
||||
aircraft: p.AircraftType,
|
||||
size: p.AircraftSize,
|
||||
opType: p.OperationType,
|
||||
fuelCost: p.FuelCost,
|
||||
maxPax: pax,
|
||||
cash: cash,
|
||||
buyingCost: p.BuyingCost,
|
||||
})
|
||||
j = len(cols[ci]) - 1
|
||||
idx[p.PlaneID] = j
|
||||
}
|
||||
cols[ci][j].members = append(cols[ci][j].members, p)
|
||||
}
|
||||
}
|
||||
return cols
|
||||
}
|
||||
|
||||
// buildQueued groups RAM-queued planes (synthetic status "queued") by template,
|
||||
// for the dimmed rows under the Waiting column.
|
||||
func (m FleetModel) buildQueued() []colEntry {
|
||||
idx := make(map[uint32]int)
|
||||
var out []colEntry
|
||||
for i := range m.fleet {
|
||||
p := m.fleet[i]
|
||||
if p.Status != "queued" || !m.passesFilter(p) {
|
||||
continue
|
||||
}
|
||||
j, ok := idx[p.PlaneID]
|
||||
if !ok {
|
||||
out = append(out, colEntry{
|
||||
planeID: p.PlaneID,
|
||||
name: p.PlaneName,
|
||||
aircraft: p.AircraftType,
|
||||
size: p.AircraftSize,
|
||||
})
|
||||
j = len(out) - 1
|
||||
idx[p.PlaneID] = j
|
||||
}
|
||||
out[j].members = append(out[j].members, p)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func (m FleetModel) passesFilter(p model.PlayerPlane) bool {
|
||||
if m.filterSize != "" && p.AircraftSize != m.filterSize {
|
||||
return false
|
||||
}
|
||||
if m.filterType != "" && p.AircraftType != m.filterType {
|
||||
return false
|
||||
}
|
||||
if m.filterOp != "" && p.OperationType != m.filterOp {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func (m *FleetModel) clampSel() {
|
||||
if len(m.sel) != len(fleetColumns) {
|
||||
m.sel = make([]int, len(fleetColumns))
|
||||
}
|
||||
for ci := range m.cols {
|
||||
if m.sel[ci] >= len(m.cols[ci]) {
|
||||
m.sel[ci] = len(m.cols[ci]) - 1
|
||||
}
|
||||
if m.sel[ci] < 0 {
|
||||
m.sel[ci] = 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (m FleetModel) currentEntry() *colEntry {
|
||||
if m.activeCol < 0 || m.activeCol >= len(m.cols) {
|
||||
return nil
|
||||
}
|
||||
col := m.cols[m.activeCol]
|
||||
i := m.sel[m.activeCol]
|
||||
if i < 0 || i >= len(col) {
|
||||
return nil
|
||||
}
|
||||
return &col[i]
|
||||
}
|
||||
|
||||
// ─── Commands ────────────────────────────────────────────────────────────────
|
||||
|
||||
func (m FleetModel) loadFleet() tea.Cmd {
|
||||
client := m.client
|
||||
airportID := m.airportID
|
||||
return func() tea.Msg {
|
||||
fleet, err := client.GetFleet(airportID)
|
||||
if err != nil {
|
||||
return FleetErrMsg{Err: err}
|
||||
}
|
||||
facilities, err := client.Facilities(airportID)
|
||||
if err != nil {
|
||||
return FleetErrMsg{Err: err}
|
||||
}
|
||||
return FleetLoadedMsg{Fleet: fleet, Facilities: facilities, Note: client.DispatchNote(airportID)}
|
||||
}
|
||||
}
|
||||
|
||||
func (m FleetModel) loadDestinations() tea.Cmd {
|
||||
client := m.client
|
||||
return func() tea.Msg {
|
||||
dest, err := client.GetCentralAirports()
|
||||
if err != nil {
|
||||
return FleetErrMsg{Err: err}
|
||||
}
|
||||
return DestinationsLoadedMsg{Dest: dest}
|
||||
}
|
||||
}
|
||||
|
||||
// dispatchFlights queues up to count idle members for dispatch to destID. The
|
||||
// service accepts them into RAM instantly and its background worker launches
|
||||
// them to SQL as bays/runways free — so the UI never blocks on bay contention.
|
||||
func (m FleetModel) dispatchFlights(members []model.PlayerPlane, destID uint32, count int) tea.Cmd {
|
||||
client := m.client
|
||||
airportID := m.airportID
|
||||
var chosen []model.PlayerPlane
|
||||
for _, p := range members {
|
||||
if p.Status != "idle" {
|
||||
continue
|
||||
}
|
||||
chosen = append(chosen, p)
|
||||
if len(chosen) >= count {
|
||||
break
|
||||
}
|
||||
}
|
||||
return func() tea.Msg {
|
||||
queued := client.DispatchFlights(airportID, chosen, destID)
|
||||
return DispatchResultMsg{Queued: queued}
|
||||
}
|
||||
}
|
||||
|
||||
// cancelQueue clears all not-yet-launched dispatches for this airport.
|
||||
func (m FleetModel) cancelQueue() tea.Cmd {
|
||||
client := m.client
|
||||
airportID := m.airportID
|
||||
return func() tea.Msg {
|
||||
return DispatchCancelledMsg{Count: client.CancelQueue(airportID)}
|
||||
}
|
||||
}
|
||||
|
||||
func (m FleetModel) sellPlane(pp *model.PlayerPlane) tea.Cmd {
|
||||
client := m.client
|
||||
airportID := m.airportID
|
||||
id := pp.ID
|
||||
return func() tea.Msg {
|
||||
refund, err := client.SellPlane(airportID, id)
|
||||
if err != nil {
|
||||
return FleetErrMsg{Err: err}
|
||||
}
|
||||
return PlaneSoldMsg{Refund: refund}
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Exported for parent AppModel ─────────────────────────────────────────────
|
||||
|
||||
// LoadFleet fetches the current fleet from the DB.
|
||||
func (m FleetModel) LoadFleet() tea.Cmd { return m.loadFleet() }
|
||||
|
||||
// LoadDestinations fetches the central-port dispatch destinations (global, so
|
||||
// it does not depend on the airport id being resolved yet).
|
||||
func (m FleetModel) LoadDestinations() tea.Cmd { return m.loadDestinations() }
|
||||
|
||||
// CheckServiceProgress advances planes through service stages.
|
||||
func (m FleetModel) CheckServiceProgress() tea.Cmd {
|
||||
client := m.client
|
||||
airportID := m.airportID
|
||||
return func() tea.Msg {
|
||||
if err := client.AdvanceServiceStages(airportID); err != nil {
|
||||
return FleetErrMsg{Err: err}
|
||||
}
|
||||
return ServiceProgressMsg{}
|
||||
}
|
||||
}
|
||||
|
||||
// CheckLanding lands every plane whose flight has elapsed (the service does the
|
||||
// query + land loop). Returns nil when nothing was ready, so the tick is quiet.
|
||||
func (m FleetModel) CheckLanding() tea.Cmd {
|
||||
client := m.client
|
||||
airportID := m.airportID
|
||||
return func() tea.Msg {
|
||||
landed, cash, err := client.LandReadyPlanes(airportID)
|
||||
if err != nil {
|
||||
return FleetErrMsg{Err: err}
|
||||
}
|
||||
if landed == 0 {
|
||||
return nil
|
||||
}
|
||||
return FlightLandedMsg{Count: landed, CashEarned: cash}
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Misc helpers ─────────────────────────────────────────────────────────────
|
||||
|
||||
// resaleValue previews what a plane sells for: full buying cost within the 5-min
|
||||
// purchase window, otherwise half. (Authoritative value is computed in SQL by
|
||||
// SellPlane on MySQL's clock; this preview uses Go time and may be ~seconds off.)
|
||||
func resaleValue(pp *model.PlayerPlane) int64 {
|
||||
if !pp.PurchasedAt.IsZero() && time.Since(pp.PurchasedAt) <= 5*time.Minute {
|
||||
return int64(pp.BuyingCost)
|
||||
}
|
||||
return int64(pp.BuyingCost) / 2
|
||||
}
|
||||
|
||||
// soonestRemaining returns the smallest TimeRemainingSeconds among members that
|
||||
// are in a timed phase (flight/service). ok=false if none are timed.
|
||||
func soonestRemaining(members []model.PlayerPlane) (int, bool) {
|
||||
best := -1
|
||||
for i := range members {
|
||||
switch members[i].Status {
|
||||
case "boarding", "taxiing", "flying", "unloading":
|
||||
r := members[i].TimeRemainingSeconds()
|
||||
if best < 0 || r < best {
|
||||
best = r
|
||||
}
|
||||
}
|
||||
}
|
||||
return best, best >= 0
|
||||
}
|
||||
|
||||
func columnPlaneCount(entries []colEntry) int {
|
||||
n := 0
|
||||
for _, e := range entries {
|
||||
n += len(e.members)
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
// cycle advances v through "" → options[0] → … → "" (wraps back to all).
|
||||
func cycle(v string, options ...string) string {
|
||||
if v == "" {
|
||||
return options[0]
|
||||
}
|
||||
for i, o := range options {
|
||||
if o == v {
|
||||
if i+1 < len(options) {
|
||||
return options[i+1]
|
||||
}
|
||||
return ""
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func truncate(s string, max int) string {
|
||||
if max < 1 {
|
||||
max = 1
|
||||
}
|
||||
if len([]rune(s)) <= max {
|
||||
return s
|
||||
}
|
||||
r := []rune(s)
|
||||
if max <= 1 {
|
||||
return string(r[:max])
|
||||
}
|
||||
return string(r[:max-1]) + "…"
|
||||
}
|
||||
|
||||
func planeIcon(aircraft string) string {
|
||||
switch aircraft {
|
||||
case "helicopter":
|
||||
return "🚁"
|
||||
case "seaplane":
|
||||
return "🛥"
|
||||
case "spaceship":
|
||||
return "🚀"
|
||||
default:
|
||||
return "✈"
|
||||
}
|
||||
}
|
||||
|
||||
func fmtDuration(secs int) string {
|
||||
d := time.Duration(secs) * time.Second
|
||||
h := int(d.Hours())
|
||||
mn := int(d.Minutes()) % 60
|
||||
s := int(d.Seconds()) % 60
|
||||
if h > 0 {
|
||||
return fmt.Sprintf("%dh%dm", h, mn)
|
||||
}
|
||||
if mn > 0 {
|
||||
return fmt.Sprintf("%dm%ds", mn, s)
|
||||
}
|
||||
return fmt.Sprintf("%ds", s)
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue