You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

282 lines
6.3 KiB
Go

package app
import (
"fmt"
"github.com/gdamore/tcell/v2"
"github.com/jordanorelli/astro-domu/internal/math"
"github.com/jordanorelli/astro-domu/internal/sim"
"github.com/jordanorelli/astro-domu/internal/wire"
"github.com/jordanorelli/blammo"
)
type gameView struct {
*blammo.Log
inFocus bool
keyHandler func(*tcell.EventKey) change
statusLine string
}
func (v *gameView) handleEvent(e tcell.Event) change {
if v.keyHandler == nil {
v.keyHandler = v.walkHandler
v.statusLine = "(walk)"
}
switch t := e.(type) {
case *tcell.EventKey:
return v.keyHandler(t)
default:
// ui.Debug("screen saw unhandled event of type %T", e)
}
return nil
}
func (v *gameView) walkHandler(e *tcell.EventKey) change {
if e.Key() == tcell.KeyRune {
switch e.Rune() {
case 'w':
return move(math.Up)
case 'a':
return move(math.Left)
case 's':
return move(math.Down)
case 'd':
return move(math.Right)
case 'i':
return openInventory{}
case 'l':
v.keyHandler = v.lookHandler
v.statusLine = "(look)"
case 'p':
v.keyHandler = v.pickupHandler
v.statusLine = "(pickup)"
case 'P':
v.keyHandler = v.putdownHandler
v.statusLine = "(put down)"
}
}
return nil
}
func (v *gameView) lookHandler(e *tcell.EventKey) change {
if e.Key() == tcell.KeyESC {
v.keyHandler = v.walkHandler
v.statusLine = "(walk)"
return nil
}
if e.Key() == tcell.KeyRune {
switch e.Rune() {
case 'w':
v.keyHandler = v.walkHandler
v.statusLine = "(walk)"
return &lookAt{x: 0, y: -1}
case 'a':
v.keyHandler = v.walkHandler
v.statusLine = "(walk)"
return &lookAt{x: -1, y: 0}
case 's':
v.keyHandler = v.walkHandler
v.statusLine = "(walk)"
return &lookAt{x: 0, y: 1}
case 'd':
v.keyHandler = v.walkHandler
v.statusLine = "(walk)"
return &lookAt{x: 1, y: 0}
}
}
return nil
}
func (v *gameView) pickupHandler(e *tcell.EventKey) change {
if e.Key() == tcell.KeyESC {
v.keyHandler = v.walkHandler
v.statusLine = "(walk)"
return nil
}
if e.Key() == tcell.KeyRune {
switch e.Rune() {
case 'w':
v.keyHandler = v.walkHandler
v.statusLine = "(walk)"
return &pickup{x: 0, y: -1}
case 'a':
v.keyHandler = v.walkHandler
v.statusLine = "(walk)"
return &pickup{x: -1, y: 0}
case 's':
v.keyHandler = v.walkHandler
v.statusLine = "(walk)"
return &pickup{x: 0, y: 1}
case 'd':
v.keyHandler = v.walkHandler
v.statusLine = "(walk)"
return &pickup{x: 1, y: 0}
}
}
return nil
}
func (v *gameView) putdownHandler(e *tcell.EventKey) change {
v.keyHandler = v.walkHandler
v.statusLine = "(walk)"
return nil
}
func (v *gameView) draw(img canvas, st *state) {
4 years ago
fill(img, tcell.StyleDefault.Background(tcell.NewRGBColor(0, 0, 12)))
v.drawHeader(img, st)
// fill in background dots first
dim := tcell.StyleDefault.Foreground(tcell.NewRGBColor(76, 72, 83))
for x := 0; x < st.room.Width; x++ {
for y := 0; y < st.room.Height; y++ {
img.setTile(x+1, y+2, tile{r: '·', style: dim})
}
}
img.setTile(0, 1, tile{r: '┌'})
img.setTile(st.room.Width+1, 1, tile{r: '┐'})
img.setTile(0, st.room.Height+2, tile{r: '└'})
img.setTile(st.room.Width+1, st.room.Height+2, tile{r: '┘'})
for x := 0; x < st.room.Width; x++ {
img.setTile(x+1, 1, tile{r: '─'})
img.setTile(x+1, st.room.Height+2, tile{r: '─'})
}
for y := 0; y < st.room.Height; y++ {
img.setTile(0, y+2, tile{r: '│'})
img.setTile(st.room.Width+1, y+2, tile{r: '│'})
}
for _, e := range st.room.Entities {
pos := e.Position
img.setTile(pos.X+1, pos.Y+2, tile{r: e.Glyph, style: tcell.StyleDefault})
}
writeString(img, v.statusLine, math.Vec{0, img.bounds().Height - 1}, tcell.StyleDefault)
}
func (v *gameView) drawHeader(img canvas, st *state) {
// the first row is the name of the room that we're currently in
var style tcell.Style
style = style.Background(tcell.NewRGBColor(64, 64, 128))
style = style.Foreground(tcell.NewRGBColor(0, 0, 0))
runes := []rune(st.room.Name)
bounds := img.bounds()
for i := 0; i < bounds.Width; i++ {
if i < len(runes) {
img.setTile(i, 0, tile{r: runes[i], style: style})
} else {
img.setTile(i, 0, tile{r: ' ', style: style})
}
}
}
func (v *gameView) setFocus(yes bool) { v.inFocus = yes }
type move math.Vec
func (m move) exec(ui *UI) {
go ui.client.Send(sim.Move(m))
}
type lookAt struct {
x int
y int
results *sim.Look
}
func (l *lookAt) exec(ui *UI) {
go func() {
res, err := ui.client.Send(sim.LookAt{l.x, l.y})
if err != nil {
ui.Error("look error: %v", err)
return
}
look, ok := res.Body.(*sim.Look)
if !ok {
ui.Error("look response is not look: %v", res.Body)
return
}
l.results = look
ui.misc <- func(ui *UI) {
ui.Info("setting detail view to %T", l)
ui.state.detail = l
}
}()
}
func (l *lookAt) handleEvent(e tcell.Event) change {
return nil
}
func (l *lookAt) draw(img canvas, st *state) {
if len(l.results.Here) == 0 {
writeString(img, "there's nothing here...", math.Vec{0, 0}, tcell.StyleDefault)
return
}
for i, item := range l.results.Here {
writeString(img, item.Name, math.Vec{0, i}, tcell.StyleDefault)
}
}
type pickup struct {
x, y int
}
func (p pickup) exec(ui *UI) {
go func() {
res, err := ui.client.Send(sim.Pickup{p.x, p.y})
if err != nil {
ui.state.detail = textView(err.Error())
return
}
switch v := res.Body.(type) {
case *sim.Pickedup:
ui.misc <- func(ui *UI) {
ui.state.detail = textView(fmt.Sprintf("you picked up: %s", v.Name))
ui.state.inventory.items = append(ui.state.inventory.items, item{ID: v.ID, name: v.Name})
}
case wire.Error:
ui.misc <- func(ui *UI) {
ui.state.detail = textView(v.Error())
}
default:
ui.misc <- func(ui *UI) {
ui.state.detail = textView(fmt.Sprintf("unexpected pickup response type: %T", res.Body))
}
}
}()
}
type putdown sim.Putdown
func (p putdown) exec(ui *UI) {
go func() {
res, err := ui.client.Send(sim.Putdown(p))
if err != nil {
ui.state.detail = textView(err.Error())
return
}
switch v := res.Body.(type) {
case *wire.OK:
ui.state.inventory.removeItem(p.ID)
case wire.Error:
ui.misc <- func(ui *UI) {
ui.state.detail = textView(v.Error())
}
default:
ui.misc <- func(ui *UI) {
ui.state.detail = textView(fmt.Sprintf("unexpected putdown response type: %T", res.Body))
}
}
}()
}