go
/
curse-you-go-rogue
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Using the new multi-file layout, which is going to be better.

Browse Source
master
Zed A. Shaw 3 days ago
parent a2075eea59
commit 00647a20e1
7 changed files with 272 additions and 191 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 38
      01_the_screen/data.go
  2. 14
      01_the_screen/debug.go
  3. 27
      01_the_screen/game.go
  4. 193
      01_the_screen/main.go
  5. 65
      01_the_screen/map.go
  6. 12
      01_the_screen/movement.go
  7. 114
      01_the_screen/ui.go

38
01_the_screen/data.go
Unescape View File

@ -0,0 +1,38 @@
package main
import (
"github.com/gdamore/tcell/v2"
)
const (
WALL = '#'
SPACE = '.'
PATH_LIMIT = 1000
RENDER = true
SHOW_RENDER = false
SHOW_PATHS = false
HEARING_DISTANCE = 6
)
type Map [][]rune
type Position struct {
X int
Y int
}
type Enemy struct {
HP int
Pos Position
Damage int
}
type Game struct {
Screen tcell.Screen
Level Map
Player Enemy
Status string
Width int
Height int
Enemies map[Position]*Enemy
}

14
01_the_screen/debug.go
Unescape View File

@ -0,0 +1,14 @@
package main
import (
"log"
"os"
)
var dbg *log.Logger
func DebugInit() {
out, err := os.Create("debug.log")
if err != nil { log.Fatal(err) }
dbg = log.New(out, "", log.LstdFlags)
}

27
01_the_screen/game.go
Unescape View File

@ -0,0 +1,27 @@
package main
import (
"os"
)
func NewGame(width int, height int) (*Game) {
var game Game
game.Width = width
game.Height = height
game.Enemies = make(map[Position]*Enemy)
game.Level = make(Map, height, height)
game.Player = Enemy{20, Position{1,1}, 4}
return &game
}
func (game *Game) Exit() {
if RENDER {
game.Screen.Fini()
}
os.Exit(0)
}

193
01_the_screen/main.go
Unescape View File

@ -1,199 +1,10 @@
package main
import (
"os"
"log"
"fmt"
"github.com/gdamore/tcell/v2"
"github.com/gdamore/tcell/v2/encoding"
)
var dbg *log.Logger
const (
WALL = '#'
SPACE = '.'
RENDER = true
)
type Map [][]rune
type Paths [][]int
type Position struct {
x int
y int
}
type Enemy struct {
hp int
pos Position
damage int
}
type Game struct {
screen tcell.Screen
level Map
player Enemy
status string
width int
height int
}
func (game *Game) DrawText(x int, y int, text string) {
for i, cell := range text {
game.screen.SetContent(x+i, y, cell, nil, tcell.StyleDefault)
}
}
func (game *Game) DrawStatus() {
game.DrawText(0, game.height, game.status)
hp := fmt.Sprintf("HP: %d", game.player.hp)
game.DrawText(game.width - len(hp), game.height, hp)
}
func (game *Game) Status(msg string) {
game.status = msg
}
func (game *Game) DrawEntity(symbol rune, pos Position, color tcell.Color) {
style := tcell.StyleDefault.Bold(true).Foreground(color)
game.screen.SetContent(pos.x, pos.y, symbol, nil, style)
}
func (game *Game) DrawMap() {
gray := tcell.StyleDefault.Foreground(tcell.ColorGray)
for y, line := range game.level {
for x, cell := range line {
if cell == SPACE {
game.screen.SetContent(x, y, cell, nil, gray)
} else {
game.screen.SetContent(x, y, cell, nil, tcell.StyleDefault)
}
}
}
}
func (game *Game) Render() {
if !RENDER { return }
game.screen.Clear()
game.DrawMap()
game.DrawEntity('@', game.player.pos, tcell.ColorYellow)
game.DrawStatus()
game.screen.Show()
}
func (game *Game) Exit() {
if RENDER {
game.screen.Fini()
}
os.Exit(0)
}
func (game *Game) Occupied(x int, y int) bool {
return game.level[y][x] != SPACE
}
func (game *Game) NewMap() {
game.level = Map{
[]rune("#################"),
[]rune("#.#...#.........#"),
[]rune("#.#.###.#.###.#.#"),
[]rune("#.#.....#...#.#.#"),
[]rune("#.#.#######.#.###"),
[]rune("#.#...#...#.#...#"),
[]rune("#.###.###...###.#"),
[]rune("#...#.......#...#"),
[]rune("#.#.#########...#"),
[]rune("#.#.............#"),
[]rune("#################"),
}
}
func (game *Game) MovePlayer(x_delta int, y_delta int) {
target := Position{
game.player.pos.x + x_delta,
game.player.pos.y + y_delta,
}
if !game.Occupied(target.x, target.y) {
game.player.pos = target
}
}
func (game *Game) HandleKeys(ev *tcell.EventKey) bool {
switch ev.Key() {
case tcell.KeyEscape:
return false
case tcell.KeyUp:
game.MovePlayer(0, -1)
case tcell.KeyDown:
game.MovePlayer(0, 1)
case tcell.KeyRight:
game.MovePlayer(1, 0)
case tcell.KeyLeft:
game.MovePlayer(-1, 0)
}
switch ev.Rune() {
case 'q':
return false
}
return true
}
func (game *Game) HandleEvents() bool {
if !RENDER { return false }
switch ev := game.screen.PollEvent().(type) {
case *tcell.EventResize:
game.screen.Sync()
case *tcell.EventKey:
return game.HandleKeys(ev)
}
return true
}
func (game *Game) InitScreen() {
encoding.Register()
var err error
game.screen, err = tcell.NewScreen()
if err != nil { log.Fatal(err) }
err = game.screen.Init()
if err != nil { log.Fatal(err) }
}
func NewGame(width int, height int) (*Game) {
var game Game
game.width = width
game.height = height
game.level = make(Map, height, height)
game.player = Enemy{20, Position{1,1}, 4}
return &game
}
func main() {
out, err := os.Create("debug.log")
if err != nil { log.Fatal(err) }
dbg = log.New(out, "", log.LstdFlags)
DebugInit()
game := NewGame(17, 11)
err := game.InitScreen()
game.InitScreen()
game.NewMap()
game.Render()

65
01_the_screen/map.go
Unescape View File

@ -0,0 +1,65 @@
package main
import (
"slices"
)
func compass(near Position, offset int) []Position {
return []Position{
Position{near.X, near.Y - offset},
Position{near.X, near.Y + offset},
Position{near.X + offset, near.Y},
Position{near.X - offset, near.Y},
}
}
func (game *Game) CloneMap() Map {
// this is a shallow copy though
new_map := slices.Clone(game.Level)
for i, row := range new_map {
// this makes sure the row is an actual copy
new_map[i] = slices.Clone(row)
}
return new_map
}
func (game *Game) Inbounds(pos Position, offset int) bool {
return pos.X >= offset &&
pos.X < game.Width - offset &&
pos.Y >= offset &&
pos.Y < game.Height - offset
}
func (game *Game) Occupied(pos Position) bool {
is_player := pos == game.Player.Pos
// Inbounds comes first to prevent accessing level with bad x,y
return !game.Inbounds(pos, 1) ||
game.Level[pos.Y][pos.X] == WALL ||
is_player
}
func (game *Game) FillMap(target Map, setting rune) {
for y := 0 ; y < game.Height; y++ {
target[y] = slices.Repeat([]rune{setting}, game.Width)
}
}
func (game *Game) NewMap() {
game.Level = Map{
[]rune("#################"),
[]rune("#.#...#.........#"),
[]rune("#.#.###.#.###.#.#"),
[]rune("#.#.....#...#.#.#"),
[]rune("#.#.#######.#.###"),
[]rune("#.#...#...#.#...#"),
[]rune("#.###.###...###.#"),
[]rune("#...#.......#...#"),
[]rune("#.#.#########...#"),
[]rune("#.#.............#"),
[]rune("#################"),
}
}

12
01_the_screen/movement.go
Unescape View File

@ -0,0 +1,12 @@
package main
func (game *Game) MovePlayer(x_delta int, y_delta int) {
target := Position{
game.Player.Pos.X + x_delta,
game.Player.Pos.Y + y_delta,
}
if !game.Occupied(target) {
game.Player.Pos = target
}
}

114
01_the_screen/ui.go
Unescape View File

@ -0,0 +1,114 @@
package main
import (
"log"
"fmt"
"github.com/gdamore/tcell/v2"
"github.com/gdamore/tcell/v2/encoding"
)
//// DRAWING
func (game *Game) DrawText(x int, y int, text string) {
for i, cell := range text {
game.Screen.SetContent(x+i, y, cell, nil, tcell.StyleDefault)
}
}
func (game *Game) DrawStatus() {
game.DrawText(0, game.Height, game.Status)
hp := fmt.Sprintf("HP: %d", game.Player.HP)
game.DrawText(game.Width - len(hp), game.Height, hp)
}
func (game *Game) SetStatus(msg string) {
game.Status = msg
}
func (game *Game) DrawEntity(symbol rune, pos Position, color tcell.Color) {
style := tcell.StyleDefault.Bold(true).Foreground(color)
game.Screen.SetContent(pos.X, pos.Y, symbol, nil, style)
}
func (game *Game) DrawMap() {
gray := tcell.StyleDefault.Foreground(tcell.ColorGray)
for y, line := range game.Level {
for x, cell := range line {
if cell == SPACE {
game.Screen.SetContent(x, y, cell, nil, gray)
} else {
game.Screen.SetContent(x, y, cell, nil, tcell.StyleDefault)
}
}
}
}
///// RENDERING
func (game *Game) InitScreen() {
var err error
encoding.Register()
game.Screen, err = tcell.NewScreen()
// using log.Fatal instead of dbg.Fatal
// because the screen isn't setup yet
if err != nil { log.Fatal(err) }
err = game.Screen.Init()
if err != nil { log.Fatal(err) }
}
func (game *Game) Render() {
if !RENDER { return }
game.Screen.Clear()
game.DrawMap()
game.DrawEntity('@', game.Player.Pos, tcell.ColorYellow)
game.DrawStatus()
game.Screen.Show()
}
//// EVENTS
func (game *Game) HandleKeys(ev *tcell.EventKey) bool {
switch ev.Key() {
case tcell.KeyEscape:
return false
case tcell.KeyUp:
game.MovePlayer(0, -1)
case tcell.KeyDown:
game.MovePlayer(0, 1)
case tcell.KeyRight:
game.MovePlayer(1, 0)
case tcell.KeyLeft:
game.MovePlayer(-1, 0)
}
switch ev.Rune() {
case 'q':
return false
}
return true
}
func (game *Game) HandleEvents() bool {
if !RENDER { return false }
switch ev := game.Screen.PollEvent().(type) {
case *tcell.EventResize:
game.Screen.Sync()
case *tcell.EventKey:
return game.HandleKeys(ev)
}
return true
}
Write Preview
Loading…
Cancel
Save