feat: add pause; add points for soft & hard drops

Author: Broderick-Westrope

README.md

@@ -26,8 +26,8 @@ Please feel free to open issues with suggestions, bugs, etc.
 - Game over conditions
     - Game over screen
 - ~~Drop one row immediately if nothing is blocking~~
-- Pause ('P' key?)
+- ~~Pause ('P' key?)~~
 - ~~Fix Tetrimino rotation axis~~
 - Implement SRS (Super Rotation System)
-- Score points from soft & hard drops
+- ~~Score points from soft & hard drops~~
 - T-Spins

internal/marathon/fall.go

@@ -21,15 +21,6 @@ func (f *fall) calculateFallSpeeds(level uint) {
 	f.softDropTime = time.Microsecond * time.Duration(speed/10)
 }
 
-func (f *fall) toggleSoftDrop() {
-	f.isSoftDrop = !f.isSoftDrop
-	if f.isSoftDrop {
-		f.stopwatch.Interval = f.softDropTime
-		return
-	}
-	f.stopwatch.Interval = f.defaultTime
-}
-
 func defaultFall(level uint) *fall {
 	f := fall{}
 	f.calculateFallSpeeds(level)

internal/marathon/keys.go

@@ -12,6 +12,7 @@ type keyMap struct {
 	SoftDrop         key.Binding
 	HardDrop         key.Binding
 	Hold             key.Binding
+	Pause            key.Binding
 }
 
 func defaultKeyMap() *keyMap {
@@ -25,6 +26,7 @@ func defaultKeyMap() *keyMap {
 		SoftDrop:         key.NewBinding(key.WithKeys("s", "k"), key.WithHelp("s, k", "toggle soft drop")),
 		HardDrop:         key.NewBinding(key.WithKeys("w", "i"), key.WithHelp("w, i", "hard drop")),
 		Hold:             key.NewBinding(key.WithKeys(" "), key.WithHelp("space", "hold")),
+		Pause:            key.NewBinding(key.WithKeys("p"), key.WithHelp("p", "pause")),
 	}
 }
 

internal/marathon/model.go

@@ -32,6 +32,8 @@ type Model struct {
 	timer      stopwatch.Model
 	cfg        *config.Config
 	fullscreen *FullscreenInfo
+	paused     bool
+	startLine  int
 }
 
 func InitialModel(level uint, fullscreen *FullscreenInfo) *Model {
@@ -50,6 +52,7 @@ func InitialModel(level uint, fullscreen *FullscreenInfo) *Model {
 		},
 		canHold: true,
 		timer:   stopwatch.NewWithInterval(time.Millisecond),
+		paused:  false,
 	}
 	m.bag = tetris.NewBag(len(m.matrix))
 	m.fall = defaultFall(level)
@@ -73,6 +76,8 @@ func InitialModel(level uint, fullscreen *FullscreenInfo) *Model {
 		m.styles.ProgramFullscreen.Width(fullscreen.Width).Height(fullscreen.Height)
 	}
 
+	m.startLine = len(m.matrix)
+
 	return m
 }
 
@@ -81,15 +86,40 @@ func (m Model) Init() tea.Cmd {
 }
 
 func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	var cmd tea.Cmd
 	var cmds []tea.Cmd
 
+	m.timer, cmd = m.timer.Update(msg)
+	cmds = append(cmds, cmd)
+
+	m.fall.stopwatch, cmd = m.fall.stopwatch.Update(msg)
+	cmds = append(cmds, cmd)
+
+	// Operations that can be performed all the time
 	switch msg := msg.(type) {
 	case tea.KeyMsg:
 		switch {
 		case key.Matches(msg, m.keys.Quit):
 			return m, tea.Quit
+		case key.Matches(msg, m.keys.Pause):
+			m.paused = !m.paused
+			cmds = append(cmds, m.timer.Toggle())
+			cmds = append(cmds, m.fall.stopwatch.Toggle())
 		case key.Matches(msg, m.keys.Help):
 			m.help.ShowAll = !m.help.ShowAll
+		}
+	case tea.WindowSizeMsg:
+		m.styles.ProgramFullscreen.Width(msg.Width).Height(msg.Height)
+	}
+
+	if m.paused {
+		return m, tea.Batch(cmds...)
+	}
+
+	// Operations that can be performed when the game is not paused
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		switch {
 		case key.Matches(msg, m.keys.Left):
 			err := m.currentTet.MoveLeft(&m.matrix)
 			if err != nil {
@@ -111,18 +141,10 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				panic(fmt.Errorf("failed to rotate tetrimino counter-clockwise: %w", err))
 			}
 		case key.Matches(msg, m.keys.HardDrop):
-			for {
-				finished, err := m.lowerTetrimino()
-				if err != nil {
-					panic(fmt.Errorf("failed to lower tetrimino (hard drop): %w", err))
-				}
-				if finished {
-					cmds = append(cmds, m.fall.stopwatch.Reset())
-					break
-				}
-			}
+			m.hardDrop()
+			cmds = append(cmds, m.fall.stopwatch.Reset())
 		case key.Matches(msg, m.keys.SoftDrop):
-			m.fall.toggleSoftDrop()
+			m.toggleSoftDrop()
 		case key.Matches(msg, m.keys.Hold):
 			err := m.holdTetrimino()
 			if err != nil {
@@ -133,21 +155,24 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		if m.fall.stopwatch.ID() != msg.ID {
 			break
 		}
-		_, err := m.lowerTetrimino()
+		finished, err := m.lowerTetrimino()
 		if err != nil {
 			panic(fmt.Errorf("failed to lower tetrimino (tick): %w", err))
 		}
-	case tea.WindowSizeMsg:
-		m.styles.ProgramFullscreen.Width(msg.Width).Height(msg.Height)
-	}
-
-	var cmd tea.Cmd
-
-	m.timer, cmd = m.timer.Update(msg)
-	cmds = append(cmds, cmd)
+		if finished {
+			if m.fall.isSoftDrop {
+				linesCleared := m.currentTet.Pos.Y - m.startLine
+				if linesCleared > 0 {
+					m.scoring.AddSoftDrop(uint(linesCleared))
+				}
+			}
 
-	m.fall.stopwatch, cmd = m.fall.stopwatch.Update(msg)
-	cmds = append(cmds, cmd)
+			err := m.nextTetrimino()
+			if err != nil {
+				panic(fmt.Errorf("failed to get next tetrimino (tick): %w", err))
+			}
+		}
+	}
 
 	return m, tea.Batch(cmds...)
 }
@@ -186,6 +211,11 @@ func (m *Model) matrixView() string {
 }
 
 func (m *Model) informationView() string {
+	header := ""
+	if m.paused {
+		header = lipgloss.NewStyle().Bold(true).Render("** PAUSED **")
+	}
+
 	var output string
 	output += fmt.Sprintln("Score: ", m.scoring.Total())
 	output += fmt.Sprintln("Level: ", m.scoring.Level())
@@ -202,7 +232,7 @@ func (m *Model) informationView() string {
 		output += fmt.Sprintf("%06.3f\n", elapsed)
 	}
 
-	return m.styles.Information.Render(output)
+	return m.styles.Information.Render(lipgloss.JoinVertical(lipgloss.Left, header, output))
 }
 
 func (m *Model) holdView() string {
@@ -298,14 +328,6 @@ func (m *Model) lowerTetrimino() (bool, error) {
 	if !m.currentTet.CanMoveDown(m.matrix) {
 		action := m.matrix.RemoveCompletedLines(m.currentTet)
 		m.scoring.ProcessAction(action, m.cfg.MaxLevel)
-		m.currentTet = m.bag.Next()
-		// TODO: Check if the game is over at the starting position
-		m.currentTet.Pos.Y++
-		err := m.matrix.AddTetrimino(m.currentTet)
-		if err != nil {
-			return false, fmt.Errorf("failed to add tetrimino to matrix: %w", err)
-		}
-		m.canHold = true
 		return true, nil
 	}
 
@@ -316,3 +338,58 @@ func (m *Model) lowerTetrimino() (bool, error) {
 
 	return false, nil
 }
+
+func (m *Model) nextTetrimino() error {
+	m.currentTet = m.bag.Next()
+	// TODO: Check if the game is over at the starting position
+	m.currentTet.Pos.Y++
+	err := m.matrix.AddTetrimino(m.currentTet)
+	if err != nil {
+		return fmt.Errorf("failed to add tetrimino to matrix: %w", err)
+	}
+	m.canHold = true
+
+	if m.fall.isSoftDrop {
+		m.startLine = m.currentTet.Pos.Y
+	}
+
+	return nil
+}
+
+func (m *Model) hardDrop() {
+	m.startLine = m.currentTet.Pos.Y
+	for {
+		finished, err := m.lowerTetrimino()
+		if err != nil {
+			panic(fmt.Errorf("failed to lower tetrimino (hard drop): %w", err))
+		}
+		if finished {
+			break
+		}
+	}
+	linesCleared := m.currentTet.Pos.Y - m.startLine
+	if linesCleared > 0 {
+		m.scoring.AddHardDrop(uint(m.currentTet.Pos.Y - m.startLine))
+	}
+	m.startLine = len(m.matrix)
+
+	err := m.nextTetrimino()
+	if err != nil {
+		panic(fmt.Errorf("failed to get next tetrimino (hard drop): %w", err))
+	}
+}
+
+func (m *Model) toggleSoftDrop() {
+	m.fall.isSoftDrop = !m.fall.isSoftDrop
+	if m.fall.isSoftDrop {
+		m.fall.stopwatch.Interval = m.fall.softDropTime
+		m.startLine = m.currentTet.Pos.Y
+		return
+	}
+	m.fall.stopwatch.Interval = m.fall.defaultTime
+	linesCleared := m.currentTet.Pos.Y - m.startLine
+	if linesCleared > 0 {
+		m.scoring.AddSoftDrop(uint(linesCleared))
+	}
+	m.startLine = len(m.matrix)
+}