rgoue/term/tcell.go

// Package term provides the tcell-backed Terminal for the Rogue port. It
// replaces curses and the 900-line escape-sequence decoder in mdport.c:
// tcell delivers decoded key events, which are translated here to the
// single-byte command codes the game understands.
package term

import (
	"fmt"
	"os"
	"os/exec"

	"github.com/gdamore/tcell/v2"

	"git.eeqj.de/sneak/rgoue/game"
)

// Tcell renders game Windows on a tcell screen and turns key events into
// Rogue input bytes.
type Tcell struct {
	screen tcell.Screen
	last   *game.Window // last rendered window, for resize redraws
}

// New initializes the terminal. The screen must be at least 80x24, as the
// C game required.
func New() (*Tcell, error) {
	s, err := tcell.NewScreen()
	if err != nil {
		return nil, err
	}
	if err := s.Init(); err != nil {
		return nil, err
	}
	w, h := s.Size()
	if h < game.NumLines || w < game.NumCols {
		s.Fini()
		return nil, fmt.Errorf("sorry, the screen must be at least %dx%d",
			game.NumLines, game.NumCols)
	}
	s.HideCursor()
	return &Tcell{screen: s}, nil
}

// Fini restores the terminal.
func (t *Tcell) Fini() {
	t.screen.Fini()
}

// Render blits a game window to the terminal (curses refresh).
func (t *Tcell) Render(w *game.Window) {
	t.last = w
	rows, cols := w.Size()
	for y := 0; y < rows; y++ {
		for x := 0; x < cols; x++ {
			ch, standout := w.CellAt(y, x)
			style := tcell.StyleDefault
			if standout {
				style = style.Reverse(true)
			}
			t.screen.SetContent(x, y, rune(ch), nil, style)
		}
	}
	t.screen.Show()
}

// ReadChar blocks for the next key, translated to the byte codes the C
// game reads: arrows become hjkl, control keys their C0 codes.
func (t *Tcell) ReadChar() byte {
	for {
		ev := t.screen.PollEvent()
		switch ev := ev.(type) {
		case *tcell.EventResize:
			if t.last != nil {
				t.Render(t.last)
			}
		case *tcell.EventKey:
			switch ev.Key() {
			case tcell.KeyUp:
				return 'k'
			case tcell.KeyDown:
				return 'j'
			case tcell.KeyLeft:
				return 'h'
			case tcell.KeyRight:
				return 'l'
			case tcell.KeyHome:
				return 'y'
			case tcell.KeyPgUp:
				return 'u'
			case tcell.KeyEnd:
				return 'b'
			case tcell.KeyPgDn:
				return 'n'
			case tcell.KeyEnter:
				return '\n'
			case tcell.KeyEscape:
				return game.Escape
			case tcell.KeyBackspace, tcell.KeyBackspace2:
				return 8
			case tcell.KeyDelete:
				return 0x7f
			case tcell.KeyTab:
				return '\t'
			case tcell.KeyCtrlC:
				return 3
			default:
				if ev.Key() >= tcell.KeyCtrlA && ev.Key() <= tcell.KeyCtrlZ {
					return byte(ev.Key())
				}
				if r := ev.Rune(); r > 0 && r < 0x80 {
					return byte(r)
				}
			}
		}
	}
}

// ShellEscape suspends the screen and runs the user's shell (main.c
// shell + md_shellescape).
func (t *Tcell) ShellEscape() {
	if err := t.screen.Suspend(); err != nil {
		return
	}
	shell := os.Getenv("SHELL")
	if shell == "" {
		shell = "/bin/sh"
	}
	fmt.Println("[Entering shell; exit to return to the game]")
	cmd := exec.Command(shell)
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	cmd.Run()
	t.screen.Resume()
}