latest
This commit is contained in:
382
flappy/main.go
Normal file
382
flappy/main.go
Normal file
@@ -0,0 +1,382 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math/rand"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
tea "github.com/charmbracelet/bubbletea"
|
||||
"github.com/charmbracelet/lipgloss"
|
||||
)
|
||||
|
||||
// Physics tuned so per-frame displacement stays around one row, which keeps
|
||||
// motion smooth and the 7-row gap threadable at 30fps.
|
||||
const (
|
||||
fps = 30
|
||||
gravity = 0.09 // rows/frame^2
|
||||
jumpVel = -0.95 // rows/frame; peak rise ≈ v²/2g ≈ 5 rows over ~0.35s
|
||||
maxFall = 1.15 // terminal velocity, rows/frame — never skip >1 row
|
||||
pipeSpeed = 0.5 // cells/frame → 15 cells/s
|
||||
pipeGap = 7
|
||||
pipeSpacing = 28 // cells between pipes → one pipe ≈ every 1.9s
|
||||
pipeWidth = 3
|
||||
groundH = 2
|
||||
)
|
||||
|
||||
// tickMsg advances the simulation. gen guards against stale tick chains:
|
||||
// without it, restarting can leave an old chain in flight and the game
|
||||
// silently runs at double speed.
|
||||
type tickMsg struct{ gen int }
|
||||
|
||||
func tick(gen int) tea.Cmd {
|
||||
return tea.Tick(time.Second/fps, func(time.Time) tea.Msg {
|
||||
return tickMsg{gen: gen}
|
||||
})
|
||||
}
|
||||
|
||||
type pipe struct {
|
||||
x float64
|
||||
gapY int
|
||||
scored bool
|
||||
}
|
||||
|
||||
type star struct{ x, y int }
|
||||
|
||||
type model struct {
|
||||
termW, termH int
|
||||
width int // field width in cells
|
||||
height int // field height in cells (terminal minus header+footer)
|
||||
birdX int
|
||||
birdY float64
|
||||
birdVel float64
|
||||
pipes []pipe
|
||||
stars []star
|
||||
score int
|
||||
best int
|
||||
gen int // tick generation
|
||||
gameOver bool
|
||||
started bool
|
||||
resized bool
|
||||
}
|
||||
|
||||
func newGame(best, gen int, termW, termH int) model {
|
||||
m := model{best: best, gen: gen}
|
||||
if termW > 0 && termH > 0 {
|
||||
m.applySize(termW, termH)
|
||||
}
|
||||
return m
|
||||
}
|
||||
|
||||
// applySize records the terminal size, sizes the field, and rebuilds the
|
||||
// static starfield. The starfield must be stable between frames — rolling
|
||||
// new random speckles every render is what caused full-screen flicker.
|
||||
func (m *model) applySize(w, h int) {
|
||||
m.termW, m.termH = w, h
|
||||
m.width = w
|
||||
fieldH := h - 2 // one row header, one row footer
|
||||
if fieldH < 8 {
|
||||
fieldH = 8
|
||||
}
|
||||
m.height = fieldH
|
||||
m.birdX = w / 4
|
||||
if m.birdX < 4 {
|
||||
m.birdX = 4
|
||||
}
|
||||
if !m.resized {
|
||||
m.birdY = float64(m.height-groundH) / 2
|
||||
m.resized = true
|
||||
}
|
||||
// keep the bird inside the new bounds after a resize
|
||||
floor := float64(m.height - groundH - 1)
|
||||
if m.birdY > floor {
|
||||
m.birdY = floor
|
||||
}
|
||||
// static starfield, ~1 speckle per 40 sky cells
|
||||
skyH := m.height - groundH
|
||||
m.stars = m.stars[:0]
|
||||
n := m.width * skyH / 40
|
||||
for i := 0; i < n; i++ {
|
||||
m.stars = append(m.stars, star{x: rand.Intn(m.width), y: rand.Intn(skyH)})
|
||||
}
|
||||
}
|
||||
|
||||
func (m model) Init() tea.Cmd { return nil }
|
||||
|
||||
func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
||||
switch msg := msg.(type) {
|
||||
case tea.WindowSizeMsg:
|
||||
m.applySize(msg.Width, msg.Height)
|
||||
return m, nil
|
||||
|
||||
case tea.KeyMsg:
|
||||
switch msg.String() {
|
||||
case " ", "space", "enter", "up", "k":
|
||||
if m.gameOver {
|
||||
// restart: bump generation so any in-flight tick is ignored
|
||||
nm := newGame(m.best, m.gen+1, m.termW, m.termH)
|
||||
nm.started = true
|
||||
nm.birdVel = jumpVel // start with a flap, like the original
|
||||
return nm, tick(nm.gen)
|
||||
}
|
||||
if !m.started {
|
||||
m.started = true
|
||||
m.birdVel = jumpVel
|
||||
return m, tick(m.gen)
|
||||
}
|
||||
m.birdVel = jumpVel
|
||||
case "q", "esc", "ctrl+c":
|
||||
return m, tea.Quit
|
||||
}
|
||||
|
||||
case tickMsg:
|
||||
if msg.gen != m.gen {
|
||||
return m, nil // stale chain — drop it
|
||||
}
|
||||
if !m.started || m.gameOver {
|
||||
return m, nil // stop the loop; nothing animates on end screens
|
||||
}
|
||||
if m.resized {
|
||||
m.step()
|
||||
}
|
||||
return m, tick(m.gen)
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
func (m *model) step() {
|
||||
m.birdVel += gravity
|
||||
if m.birdVel > maxFall {
|
||||
m.birdVel = maxFall
|
||||
}
|
||||
m.birdY += m.birdVel
|
||||
|
||||
// ceiling clamp
|
||||
if m.birdY < 0 {
|
||||
m.birdY = 0
|
||||
m.birdVel = 0
|
||||
}
|
||||
// ground collision
|
||||
floor := float64(m.height - groundH - 1)
|
||||
if m.birdY >= floor {
|
||||
m.birdY = floor
|
||||
m.gameOver = true
|
||||
}
|
||||
|
||||
// advance pipes
|
||||
for i := range m.pipes {
|
||||
m.pipes[i].x -= pipeSpeed
|
||||
}
|
||||
for len(m.pipes) > 0 && m.pipes[0].x+pipeWidth < 0 {
|
||||
m.pipes = m.pipes[1:]
|
||||
}
|
||||
// spawn pipes
|
||||
usableH := m.height - groundH - pipeGap - 4
|
||||
if usableH < 1 {
|
||||
usableH = 1
|
||||
}
|
||||
if len(m.pipes) == 0 || m.pipes[len(m.pipes)-1].x < float64(m.width-pipeSpacing) {
|
||||
gapY := rand.Intn(usableH) + 2
|
||||
m.pipes = append(m.pipes, pipe{x: float64(m.width), gapY: gapY})
|
||||
}
|
||||
|
||||
by := int(m.birdY)
|
||||
for i := range m.pipes {
|
||||
p := &m.pipes[i]
|
||||
px := int(p.x)
|
||||
// score once the pipe's trailing edge passes the bird
|
||||
if !p.scored && px+pipeWidth <= m.birdX {
|
||||
p.scored = true
|
||||
m.score++
|
||||
if m.score > m.best {
|
||||
m.best = m.score
|
||||
}
|
||||
}
|
||||
// collision with pipe body
|
||||
if m.birdX >= px && m.birdX < px+pipeWidth {
|
||||
if by < p.gapY || by > p.gapY+pipeGap {
|
||||
m.gameOver = true
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// styles ----------------------------------------------------------------------
|
||||
|
||||
var (
|
||||
birdStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("220")).Bold(true)
|
||||
birdUpStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("226")).Bold(true)
|
||||
birdDnStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("214")).Bold(true)
|
||||
pipeStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("34"))
|
||||
pipeHi = lipgloss.NewStyle().Foreground(lipgloss.Color("46"))
|
||||
capStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("36"))
|
||||
skyStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("33"))
|
||||
groundStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("142"))
|
||||
dirtStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("130"))
|
||||
scoreStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("15")).Bold(true)
|
||||
bestStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("214")).Bold(true)
|
||||
overStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("196")).Bold(true)
|
||||
hintStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("245"))
|
||||
titleStyle = lipgloss.NewStyle().
|
||||
Foreground(lipgloss.Color("220")).
|
||||
Background(lipgloss.Color("23")).
|
||||
Bold(true)
|
||||
)
|
||||
|
||||
func birdGlyph(vel float64) (string, lipgloss.Style) {
|
||||
switch {
|
||||
case vel < -0.3:
|
||||
return "➚", birdUpStyle
|
||||
case vel > 0.5:
|
||||
return "➘", birdDnStyle
|
||||
default:
|
||||
return "➙", birdStyle
|
||||
}
|
||||
}
|
||||
|
||||
func (m model) View() string {
|
||||
if !m.resized {
|
||||
return hintStyle.Render(" sizing terminal… ")
|
||||
}
|
||||
width, height := m.width, m.height
|
||||
grid := make([][]string, height)
|
||||
for i := range grid {
|
||||
grid[i] = make([]string, width)
|
||||
for j := range grid[i] {
|
||||
grid[i][j] = " "
|
||||
}
|
||||
}
|
||||
|
||||
// static sky speckles (precomputed — stable between frames)
|
||||
for _, s := range m.stars {
|
||||
if s.y < height-groundH && s.x < width {
|
||||
grid[s.y][s.x] = skyStyle.Render("·")
|
||||
}
|
||||
}
|
||||
|
||||
// pipes
|
||||
for _, p := range m.pipes {
|
||||
px := int(p.x)
|
||||
topCap := p.gapY - 1
|
||||
botCap := p.gapY + pipeGap + 1
|
||||
for x := px; x < px+pipeWidth && x < width; x++ {
|
||||
if x < 0 {
|
||||
continue
|
||||
}
|
||||
for y := 0; y < height-groundH; y++ {
|
||||
if y < p.gapY || y > p.gapY+pipeGap {
|
||||
if y == topCap || y == botCap {
|
||||
grid[y][x] = capStyle.Render("▓")
|
||||
} else if x == px {
|
||||
grid[y][x] = pipeHi.Render("█")
|
||||
} else {
|
||||
grid[y][x] = pipeStyle.Render("█")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ground
|
||||
for y := height - groundH; y < height; y++ {
|
||||
for x := 0; x < width; x++ {
|
||||
if y == height-groundH {
|
||||
grid[y][x] = groundStyle.Render("▔")
|
||||
} else {
|
||||
grid[y][x] = dirtStyle.Render("▓")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// bird
|
||||
by := int(m.birdY)
|
||||
if by >= 0 && by < height && m.birdX >= 0 && m.birdX < width {
|
||||
glyph, style := birdGlyph(m.birdVel)
|
||||
grid[by][m.birdX] = style.Render(glyph)
|
||||
}
|
||||
|
||||
// overlays are written directly into the grid, cell by cell, so styled
|
||||
// field content underneath can never be corrupted by string splicing.
|
||||
if !m.started && !m.gameOver {
|
||||
m.overlayGrid(grid, []overline{
|
||||
{" FLAPPY BIRD ", titleStyle},
|
||||
{},
|
||||
{"press SPACE to flap", hintStyle},
|
||||
})
|
||||
} else if m.gameOver {
|
||||
m.overlayGrid(grid, []overline{
|
||||
{"✖ GAME OVER ✖", overStyle},
|
||||
{},
|
||||
{fmt.Sprintf("score %d • SPACE to retry", m.score), hintStyle},
|
||||
})
|
||||
}
|
||||
|
||||
// compose field
|
||||
var b strings.Builder
|
||||
for _, row := range grid {
|
||||
for _, c := range row {
|
||||
b.WriteString(c)
|
||||
}
|
||||
b.WriteString("\n")
|
||||
}
|
||||
field := b.String()
|
||||
|
||||
header := scoreStyle.Render(fmt.Sprintf(" SCORE %d ", m.score)) +
|
||||
" " +
|
||||
bestStyle.Render(fmt.Sprintf("BEST %d ", m.best))
|
||||
footer := hintStyle.Render(" SPACE: flap • Q: quit ")
|
||||
|
||||
return header + "\n" + field + footer
|
||||
}
|
||||
|
||||
// overline is one centred line of overlay text with its style.
|
||||
type overline struct {
|
||||
text string
|
||||
style lipgloss.Style
|
||||
}
|
||||
|
||||
// overlayGrid writes overlay lines into the middle of the grid, one styled
|
||||
// cell per rune. Empty lines clear a centred band for readability.
|
||||
func (m model) overlayGrid(grid [][]string, lines []overline) {
|
||||
startY := (len(grid) - len(lines)) / 2
|
||||
if startY < 0 {
|
||||
startY = 0
|
||||
}
|
||||
// widest line determines the cleared band
|
||||
maxW := 0
|
||||
for _, ol := range lines {
|
||||
if n := len([]rune(ol.text)); n > maxW {
|
||||
maxW = n
|
||||
}
|
||||
}
|
||||
for i, ol := range lines {
|
||||
y := startY + i
|
||||
if y < 0 || y >= len(grid) {
|
||||
continue
|
||||
}
|
||||
// clear a band as wide as the widest line so text sits on a clean row
|
||||
bandX := (m.width - maxW - 2) / 2
|
||||
for j := 0; j < maxW+2; j++ {
|
||||
x := bandX + j
|
||||
if x >= 0 && x < m.width {
|
||||
grid[y][x] = " "
|
||||
}
|
||||
}
|
||||
runes := []rune(ol.text)
|
||||
startX := (m.width - len(runes)) / 2
|
||||
for j, r := range runes {
|
||||
x := startX + j
|
||||
if x < 0 || x >= m.width {
|
||||
continue
|
||||
}
|
||||
grid[y][x] = ol.style.Render(string(r))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func main() {
|
||||
p := tea.NewProgram(newGame(0, 0, 0, 0), tea.WithAltScreen())
|
||||
if _, err := p.Run(); err != nil {
|
||||
fmt.Println("error running game:", err)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user