From a91351d3dcc670299f92103f2ab31a6e31415aa4 Mon Sep 17 00:00:00 2001
From: thefish <thefish@zaar.be>
Date: Thu, 31 Oct 2019 22:47:36 +0300
Subject: [PATCH 1/8] makefile

---
 .gitignore                |  1 +
 Makefile                  | 21 +++++++-------
 cmd/game/main.go          |  8 ++++++
 dist/.gitkeep             |  0
 link.sh                   |  2 +-
 ui/mainwindow/viewport.go | 60 +++++++--------------------------------
 6 files changed, 31 insertions(+), 61 deletions(-)
 create mode 100644 dist/.gitkeep

diff --git a/.gitignore b/.gitignore
index b7c4c01..d70e461 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 .idea/*
 tmp/*
 logs/*
+dist/*
 *.swp
diff --git a/Makefile b/Makefile
index 406bbfd..663a14b 100644
--- a/Makefile
+++ b/Makefile
@@ -2,26 +2,27 @@ PROJECT_NAME := "alchemyst-go"
 PKG := "lab.zaar.be/thefish/$(PROJECT_NAME)"
 GO=$(shell which go)
 CWD=$(shell pwd)
+DISTFOLDER=$(CWD)/dist
+CP=$(shell cp)
 GLIDE=$(shell which glide)
 
 LDFLAGS="-X \"main.versionInfo=${PKG_VER}-${CI_PIPELINE_ID} built at $(shell date) on $(shell hostname) with $(shell go version)\""
 
-.PHONY: all build test get-dep
+.PHONY: all build test
 
 all: build test
 
 #build: build.spec build.server
-build: build.server
+build: build.game
 
-#build.spec:
-#	$(CWD)/bin/oapi-codegen --generate types,spec -o $(CWD)/api/inner/inner.gen.go $(CWD)/public/schema/api.yaml
+build.deps:
+	GIT_SSL_NO_VERIFY=true $(GO) mod vendor
 
-build.server:
-	$(GO) build -ldflags $(LDFLAGS) -o $(CWD)/bin/game $(CWD)/cmd/game/main.go
+build.game:
+	cp $(CWD)/vendor/lab.zaar.be/thefish/bearlibterminal/libBearLibTerminal.so $(DISTFOLDER)
+	cp $(CWD)/config.json $(DISTFOLDER)
+	cp -r $(CWD)/resources $(DISTFOLDER)
+	$(GO) build -ldflags $(LDFLAGS) -o $(DISTFOLDER)/game $(CWD)/cmd/game/main.go
 
 test:
 	$(GO) test -v $(go list ./... | grep -v /vendor/)
-
-get-dep:
-	GIT_SSL_NO_VERIFY=true go mod vendor
-
diff --git a/cmd/game/main.go b/cmd/game/main.go
index ee09d44..a908b48 100644
--- a/cmd/game/main.go
+++ b/cmd/game/main.go
@@ -116,12 +116,19 @@ func setupLayers(mainwindow *mainwindow.MainWindow) {
 
 func decodeInput(ctx util.ClientCtx, baseLayer *mainwindow.Layer) {
 	var exit = false
+	var waitForWCspam = true
 	for !exit{
 		select {
 		case keycode := <-State.rawInput:
 			if keycode == blt.TK_NONE {
 				continue
 			}
+			if keycode == blt.TK_CLOSE && !waitForWCspam {
+				ctx.Logger().Warn().Msg("exiting on window close...")
+				State.exit <- struct{}{}
+				ctx.Logger().Warn().Msg("...done")
+				return
+			}
 			var pressed= ""
 			var isModifier, _= util.InArray(keycode, modifiers)
 			if !isModifier {
@@ -153,6 +160,7 @@ func decodeInput(ctx util.ClientCtx, baseLayer *mainwindow.Layer) {
 					exit = true
 					return
 				default:
+					waitForWCspam = false;
 					State.input <- pressed
 				}
 			}
diff --git a/dist/.gitkeep b/dist/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/link.sh b/link.sh
index f988a49..81240a5 100755
--- a/link.sh
+++ b/link.sh
@@ -1,2 +1,2 @@
 #!/bin/bash
-ln -s src/bearlibterminal/libBearLibTerminal.so .
+ln -s vendor/lab.zaar.be/thefish/bearlibterminal/libBearLibTerminal.so .
diff --git a/ui/mainwindow/viewport.go b/ui/mainwindow/viewport.go
index 447c3ea..749d24d 100644
--- a/ui/mainwindow/viewport.go
+++ b/ui/mainwindow/viewport.go
@@ -125,61 +125,21 @@ func (vp *ViewPort) Render() {
 		vp.layer.Clear(vp.Rect)
 		fovRecompute = false
 		redraw = true
-		//fixme
-
 		vp.Fov.ComputeFov(vp.level, vp.playerCoords, vp.playerTorchRadius)
 	}
 
-	//for y := 0; y < vp.H; y++ {
-	//	for x := 0; x < vp.W; x++ {
-	//		mapCoords := types.Coords{vp.X + x, vp.Y + y}
-	//		tile := vp.level.Tiles[mapCoords.X][mapCoords.Y]
-	//
-	//		if tile.Visible {
-	//			if tile.MustDraw {
-	//				//darkened version of landscape
-	//				vp.layer.WithRawColor(tile.ColorSet.DarkFg()).
-	//					PutWithRawBackground(mapCoords.X, mapCoords.Y, tile.Char, tile.ColorSet.DarkBg())
-	//			}
-	//		} else {
-	//			if redraw == true || tile.Colordance {
-	//				vp.layer.WithRawColor(tile.ColorSet.Fg()).
-	//					PutWithRawBackground(mapCoords.X, mapCoords.Y, tile.Char, tile.ColorSet.Bg())
-	//				tile.Explored = true
-	//				tile.MustDraw = true
-	//			}
-	//		}
-	//	}
-	//}
+	if redraw {
+		for y := 0; y < vp.H; y++ {
+			for x := 0; x < vp.W; x++ {
+				mapCoords := types.Coords{vp.X + x, vp.Y + y}
 
-	for y := 0; y < vp.H; y++ {
-		for x := 0; x < vp.W; x++ {
-			mapCoords := types.Coords{vp.X + x, vp.Y + y}
-			//vp.level.GetTile(mapCoords).Render()
-
-			tile := vp.level.GetTile(mapCoords)
-
-			//vp.layer.
-			//	WithRawColor(tile.GetRawColor()).
-			//	PutWithBackground(mapCoords.X, mapCoords.Y, tile.GetChar(), "grey")
-
-			vp.layer.PutToBase(mapCoords.X,mapCoords.Y,tile.GetChar(), tile.GetRawColor(), tile.GetRawBgColor())
-
-			//if tile.Visible {
-			//	if tile.MustDraw {
-			//		//darkened version of landscape
-			//		vp.layer.WithColor("green").
-			//			Put(mapCoords.X, mapCoords.Y, tile.Char)
-			//	}
-			//} else {
-			//	if redraw == true || tile.Colordance {
-			//		vp.layer.WithColor("grey").
-			//			Put(mapCoords.X, mapCoords.Y, tile.Char)
-			//		tile.Explored = true
-			//		tile.MustDraw = true
-			//	}
-			//}
+				tile := vp.level.GetTile(mapCoords)
+				if tile.Explored || tile.MustDraw || tile.Visible {
+					vp.layer.PutToBase(mapCoords.X, mapCoords.Y, tile.GetChar(), tile.GetRawColor(), tile.GetRawBgColor())
+				}
+			}
 		}
+		//redraw = false
 	}
 
 }

From c6c6b6254d14b326fa10d8cd841c0e89d8adf8d5 Mon Sep 17 00:00:00 2001
From: thefish <thefish@zaar.be>
Date: Fri, 1 Nov 2019 15:03:52 +0300
Subject: [PATCH 2/8] fixes to viewport, config tuning

---
 cmd/game/main.go                  |  73 +++++++++-----------
 config.json                       |   3 +-
 engine/gamemap/level.go           |   4 +-
 engine/gamemap/mapgens/default.go |   7 +-
 engine/gamemap/tile.go            | 110 +++---------------------------
 engine/types/appearance.go        |  94 +++++++++++++++++++++++++
 engine/types/gamestate.go         |  20 ++++++
 ui/mainwindow/layer.go            |   2 +-
 ui/mainwindow/mainwindow.go       |   3 +-
 ui/mainwindow/viewport.go         |  84 ++++++++++++++++-------
 util/config.go                    |   1 +
 11 files changed, 228 insertions(+), 173 deletions(-)
 create mode 100644 engine/types/appearance.go
 create mode 100644 engine/types/gamestate.go

diff --git a/cmd/game/main.go b/cmd/game/main.go
index a908b48..500b934 100644
--- a/cmd/game/main.go
+++ b/cmd/game/main.go
@@ -5,6 +5,7 @@ import (
 	"github.com/rs/zerolog/log"
 	"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
 	"lab.zaar.be/thefish/alchemyst-go/engine/gamemap/mapgens"
+	"lab.zaar.be/thefish/alchemyst-go/engine/types"
 	"lab.zaar.be/thefish/alchemyst-go/ui"
 	"lab.zaar.be/thefish/alchemyst-go/ui/mainwindow"
 	"lab.zaar.be/thefish/alchemyst-go/util"
@@ -22,23 +23,6 @@ func init() {
 	runtime.LockOSThread()
 }
 
-type GameState struct {
-	mainfunc chan func()
-	exit     chan struct{}
-	input    chan string
-	rawInput chan int
-}
-
-// do runs f on the main thread.
-func (*GameState) Do(f func()) {
-	done := make(chan struct{}, 1)
-	State.mainfunc <- func() {
-		f()
-		done <- struct{}{}
-	}
-	<-done
-}
-
 //we can run logic in separate goroutines
 //
 //    go doSometing(State,...)
@@ -52,11 +36,13 @@ func (*GameState) Do(f func()) {
 // 		...
 // }
 
-var State = GameState{
-	mainfunc: make(chan func()),
-	exit:     make(chan struct{}, 1),
-	input:    make(chan string, 1),
-	rawInput: make(chan int, 1),
+var State = types.GameState{
+	Mainfunc:     make(chan func()),
+	Exit:         make(chan struct{}, 1),
+	Input:        make(chan string, 1),
+	RawInput:     make(chan int, 1),
+	FovRecompute: make(chan struct{},1),
+	Redraw: 	  make(chan struct{},1),
 }
 
 func main() {
@@ -72,35 +58,37 @@ func main() {
 
 	setupLayers(mw)
 
-	level := gamemap.NewLevel(mainCtx, "test", 1)
-	level = mapgens.DefaultGen(level)
+	level, rooms := mapgens.DefaultGen(gamemap.NewLevel(mainCtx, "test", 1))
+
 	vp := mainwindow.NewViewPort(40, 0, 60, 47, level, mw.GetLayer("base"))
-	vp.Render()
+	vp.PlayerCoords = rooms[0].Center
+	vp.Render(State)
 
 	go decodeInput(mainCtx, mw.GetLayer("base"))
+	go vp.Listen(State)
 
 	//but every call to bearlibterminal must be wrapped to closure and passed to mainfunc
 	var exit = false
 	for !exit {
 
 		select {
-		case State.rawInput <- ui.ReadKeyCode():
+		case State.RawInput <- ui.ReadKeyCode():
 			break
-		case pressed := <-State.input:
+		case pressed := <-State.Input:
 			mw.GetLayer("base").ClearArea(0, 3, 40, 1)
 			mw.GetLayer("base").Print(1, 3, "Key: "+pressed)
 			mw.GetLayer("base").Print(1, 6, "█")
 			break
-		//case f := <-State.mainfunc:
-		//	f()
-		//	break
-		case <-State.exit:
+			//case f := <-State.mainfunc:
+			//	f()
+			//	break
+		case <-State.Exit:
 			mainCtx.Logger().Warn().Msg("quitting NOW")
 			exit = true
 			break
-		// не оставляйте default в бесконесчном select {} - сожрет всё CPU
+			// не оставляйте default в бесконесчном select {} - сожрет всё CPU
 		default:
-			vp.Render()
+			vp.Render(State)
 			blt.Refresh()
 		}
 
@@ -117,20 +105,20 @@ func setupLayers(mainwindow *mainwindow.MainWindow) {
 func decodeInput(ctx util.ClientCtx, baseLayer *mainwindow.Layer) {
 	var exit = false
 	var waitForWCspam = true
-	for !exit{
+	for !exit {
 		select {
-		case keycode := <-State.rawInput:
+		case keycode := <-State.RawInput:
 			if keycode == blt.TK_NONE {
 				continue
 			}
 			if keycode == blt.TK_CLOSE && !waitForWCspam {
 				ctx.Logger().Warn().Msg("exiting on window close...")
-				State.exit <- struct{}{}
+				State.Exit <- struct{}{}
 				ctx.Logger().Warn().Msg("...done")
 				return
 			}
-			var pressed= ""
-			var isModifier, _= util.InArray(keycode, modifiers)
+			var pressed = ""
+			var isModifier, _ = util.InArray(keycode, modifiers)
 			if !isModifier {
 
 				pressed = ui.Scancodemap[keycode]
@@ -147,6 +135,7 @@ func decodeInput(ctx util.ClientCtx, baseLayer *mainwindow.Layer) {
 
 				//global hotkeys
 				switch pressed {
+				//fixme testing only
 				case "F10":
 					State.Do(func() {
 						blt.Set("window: size=100x47; font: ./resources/fonts-ttf/UbuntuMono-R.ttf, size=11;")
@@ -155,13 +144,15 @@ func decodeInput(ctx util.ClientCtx, baseLayer *mainwindow.Layer) {
 					fallthrough
 				case "Escape":
 					ctx.Logger().Info().Msg("exiting on quit command...")
-					State.exit <- struct{}{}
+					State.Exit <- struct{}{}
 					ctx.Logger().Info().Msg("...done")
 					exit = true
 					return
 				default:
-					waitForWCspam = false;
-					State.input <- pressed
+					if pressed != "" {
+						waitForWCspam = false;
+						State.Input <- pressed
+					}
 				}
 			}
 		}
diff --git a/config.json b/config.json
index a7d5be7..9ae5595 100644
--- a/config.json
+++ b/config.json
@@ -4,6 +4,7 @@
   "sizeX": 100,
   "sizeY": 47,
   "fpsLimit" : 60,
-  "font": "./resources/fonts-ttf/LiberationMono-Bold.ttf",
+  "font": "./resources/fonts-ttf/UbuntuMono-R.ttf",
+  "fontSize": "12x16",
   "verbosity": "debug"
 }
\ No newline at end of file
diff --git a/engine/gamemap/level.go b/engine/gamemap/level.go
index 34b8c16..bb749c3 100644
--- a/engine/gamemap/level.go
+++ b/engine/gamemap/level.go
@@ -7,8 +7,8 @@ import (
 )
 
 //fixme move to config
-var mapWidth = 150
-var mapHeight = 100
+var mapWidth = 70
+var mapHeight = 50
 
 
 type Level struct {
diff --git a/engine/gamemap/mapgens/default.go b/engine/gamemap/mapgens/default.go
index 67fd62e..2a6bc3f 100644
--- a/engine/gamemap/mapgens/default.go
+++ b/engine/gamemap/mapgens/default.go
@@ -11,7 +11,7 @@ var maxRoomSize = 22
 var maxrooms = 30
 
 //fixme make closure to stack them
-func DefaultGen(l *gamemap.Level) *gamemap.Level {
+func DefaultGen(l *gamemap.Level) (*gamemap.Level, []*gamemap.Room) {
 
 	rng := util.NewRNG()
 
@@ -56,6 +56,9 @@ func DefaultGen(l *gamemap.Level) *gamemap.Level {
 		if !failed {
 			rooms = append(rooms, newRoom)
 		}
+
+		//addStairs(rooms)
+		//itemize(rooms)
 	}
 
 	//fillage := types.RectFill{
@@ -89,7 +92,7 @@ func DefaultGen(l *gamemap.Level) *gamemap.Level {
 		}
 	}
 
-	return l
+	return l, rooms
 }
 
 func connectRooms (l *gamemap.Level, room, otherRoom *gamemap.Room, fillage types.RectFill, toss int) {
diff --git a/engine/gamemap/tile.go b/engine/gamemap/tile.go
index 4294dc6..ae60388 100644
--- a/engine/gamemap/tile.go
+++ b/engine/gamemap/tile.go
@@ -1,69 +1,8 @@
 package gamemap
 
 import (
-	"github.com/gammazero/deque"
-	"lab.zaar.be/thefish/alchemyst-go/util"
+	. "lab.zaar.be/thefish/alchemyst-go/engine/types"
 )
-import blt "lab.zaar.be/thefish/bearlibterminal"
-
-type ColorHolder interface {
-	GetColor() uint32
-}
-
-type cdeque struct {
-	deque.Deque
-}
-
-func (c *cdeque) Next() uint8 {
-	c.Rotate(1)
-	return c.Front().(uint8)
-}
-
-type DanceColorHolder struct {
-	A uint8
-	R *cdeque
-	G *cdeque
-	B *cdeque
-}
-
-func (chd *DanceColorHolder) GetColor() uint32 {
-	return blt.ColorFromARGB(
-		chd.A,
-		chd.R.Next(),
-		chd.G.Next(),
-		chd.B.Next(),
-	)
-}
-
-type PlainColorHolder struct {
-	A uint8
-	R uint8
-	G uint8
-	B uint8
-}
-
-func (chb *PlainColorHolder) GetColor() uint32 {
-	return blt.ColorFromARGB(
-		chb.A,
-		chb.R,
-		chb.G,
-		chb.B,
-	)
-}
-
-type TileColorSet struct {
-	Fg     ColorHolder
-	Bg     ColorHolder
-	DarkFg ColorHolder
-	DarkBg ColorHolder
-}
-
-type Appearance struct {
-	Char     string        `json:"char"`
-	ColorSet *TileColorSet `json:"colorSet"`
-}
-
-var crng = util.NewRNG()
 
 type Tile struct {
 	*Appearance `json:"app"`
@@ -97,33 +36,6 @@ func (t *Tile) GetRawBgColor() uint32 {
 	}
 }
 
-func singleColorRing(colorValue uint8) *cdeque {
-	c := &cdeque{}
-	c.PushBack(colorValue)
-	return c
-}
-
-func fillColorRing(colorValue uint8, minGlow, maxGlow, step int) *cdeque {
-	q := make([]uint8, 0)
-	color := int(colorValue)
-	for color < maxGlow {
-		q = append(q, uint8(color))
-		color = crng.Range(1, step) + color
-	}
-	color = crng.Range(0, step+minGlow)
-	q = append(q, uint8(color))
-	//for uint8(color) < uint8(colorValue) {
-	//	q = append(q, uint8(color))
-	//	color = crng.Range(1, step+minGlow)
-	//}
-
-	c := &cdeque{}
-	for _, v := range q {
-		c.PushBack(uint8(v))
-	}
-	return c
-}
-
 func NewWall() *Tile {
 	return &Tile{
 		Name:        "Wall",
@@ -178,14 +90,14 @@ func NewWaterTile() *Tile {
 		Appearance: &Appearance{
 			Char: " ",
 			ColorSet: &TileColorSet{
-				Fg:      &PlainColorHolder{255, 220, 220, 250},
+				Fg: &PlainColorHolder{255, 220, 220, 250},
 				Bg: &DanceColorHolder{
 					255,
-					singleColorRing(19),
-					fillColorRing(19, 0, 15, 2),
-					fillColorRing(70, 120, 220, 12),
+					SingleColorRing(19),
+					FillColorRing(19, 0, 15, 2),
+					FillColorRing(70, 120, 220, 12),
 				},
-				DarkFg: &PlainColorHolder{255, 30, 20, 50 },
+				DarkFg: &PlainColorHolder{255, 30, 20, 50},
 				DarkBg: &PlainColorHolder{255, 7, 7, 30},
 			},
 		},
@@ -205,16 +117,16 @@ func NewDeepWaterTile() *Tile {
 		Appearance: &Appearance{
 			Char: " ",
 			ColorSet: &TileColorSet{
-				Fg:      &PlainColorHolder{255, 220, 220, 250},
+				Fg: &PlainColorHolder{255, 220, 220, 250},
 				Bg: &DanceColorHolder{
 					255,
-					singleColorRing(5),
-					fillColorRing(2,2,42,4),
-					fillColorRing(154, 150, 229, 12),
+					SingleColorRing(5),
+					FillColorRing(2, 2, 42, 4),
+					FillColorRing(154, 150, 229, 12),
 				},
 				DarkFg: &PlainColorHolder{255, 30, 20, 50},
 				DarkBg: &PlainColorHolder{255, 7, 7, 30},
 			},
 		},
 	}
-}
\ No newline at end of file
+}
diff --git a/engine/types/appearance.go b/engine/types/appearance.go
new file mode 100644
index 0000000..d09ded5
--- /dev/null
+++ b/engine/types/appearance.go
@@ -0,0 +1,94 @@
+package types
+
+import (
+	"github.com/gammazero/deque"
+	"lab.zaar.be/thefish/alchemyst-go/util"
+)
+import blt "lab.zaar.be/thefish/bearlibterminal"
+
+var crng = util.NewRNG()
+
+type ColorHolder interface {
+	GetColor() uint32
+}
+
+type cdeque struct {
+	deque.Deque
+}
+
+func (c *cdeque) Next() uint8 {
+	c.Rotate(1)
+	return c.Front().(uint8)
+}
+
+type DanceColorHolder struct {
+	A uint8
+	R *cdeque
+	G *cdeque
+	B *cdeque
+}
+
+func (chd *DanceColorHolder) GetColor() uint32 {
+	return blt.ColorFromARGB(
+		chd.A,
+		chd.R.Next(),
+		chd.G.Next(),
+		chd.B.Next(),
+	)
+}
+
+type PlainColorHolder struct {
+	A uint8
+	R uint8
+	G uint8
+	B uint8
+}
+
+func (chb *PlainColorHolder) GetColor() uint32 {
+	return blt.ColorFromARGB(
+		chb.A,
+		chb.R,
+		chb.G,
+		chb.B,
+	)
+}
+
+type TileColorSet struct {
+	Fg     ColorHolder
+	Bg     ColorHolder
+	DarkFg ColorHolder
+	DarkBg ColorHolder
+}
+
+type Appearance struct {
+	Char     string        `json:"char"`
+	ColorSet *TileColorSet `json:"colorSet"`
+}
+
+
+func SingleColorRing(colorValue uint8) *cdeque {
+	c := &cdeque{}
+	c.PushBack(colorValue)
+	return c
+}
+
+func FillColorRing(colorValue uint8, minGlow, maxGlow, step int) *cdeque {
+	q := make([]uint8, 0)
+	color := int(colorValue)
+	for color < maxGlow {
+		q = append(q, uint8(color))
+		color = crng.Range(1, step) + color
+	}
+	color = crng.Range(0, step+minGlow)
+	q = append(q, uint8(color))
+	//for uint8(color) < uint8(colorValue) {
+	//	q = append(q, uint8(color))
+	//	color = crng.Range(1, step+minGlow)
+	//}
+
+	c := &cdeque{}
+	for _, v := range q {
+		c.PushBack(uint8(v))
+	}
+	return c
+}
\ No newline at end of file
diff --git a/engine/types/gamestate.go b/engine/types/gamestate.go
new file mode 100644
index 0000000..8ae529e
--- /dev/null
+++ b/engine/types/gamestate.go
@@ -0,0 +1,20 @@
+package types
+
+type GameState struct {
+	Mainfunc     chan func()
+	Exit         chan struct{}
+	Input        chan string
+	RawInput     chan int
+	FovRecompute chan struct{}
+	Redraw		 chan struct{}
+}
+
+// do runs f on the main thread.
+func (g *GameState) Do(f func()) {
+	done := make(chan struct{}, 1)
+	g.Mainfunc <- func() {
+		f()
+		done <- struct{}{}
+	}
+	<-done
+}
diff --git a/ui/mainwindow/layer.go b/ui/mainwindow/layer.go
index 8d5af19..f7f131e 100644
--- a/ui/mainwindow/layer.go
+++ b/ui/mainwindow/layer.go
@@ -98,7 +98,7 @@ func (layer *Layer) Decorate(f func(args ...interface{})) func(args ...interface
 	}
 }
 
-func (layer *Layer) Clear(r *types.Rect) {
+func (layer *Layer) ClearRect(r *types.Rect) {
 	blt.ClearArea(r.X, r.Y, r.W, r.H)
 }
 
diff --git a/ui/mainwindow/mainwindow.go b/ui/mainwindow/mainwindow.go
index 3ca1f1b..1d7147a 100644
--- a/ui/mainwindow/mainwindow.go
+++ b/ui/mainwindow/mainwindow.go
@@ -42,13 +42,14 @@ func (mw *MainWindow) Open() {
 	blt.Set(
 		fmt.Sprintf(
 			//"window: size=%dx%d, title='%s v%s'; font: ./resources/fonts-bitmap/ibmnew8x12.png, size=8x12;",
-			"window: size=%dx%d, title='%s v%s'; font: %s, size=8x16;",
+			"window: size=%dx%d, title='%s v%s'; font: %s, size=%s;",
 			//"window: size=%dx%d, title='%s v%s'",
 			config.MainWindowSizeX,
 			config.MainWindowSizeY,
 			config.Title,
 			config.Version,
 			config.Font,
+			config.FontSize,
 		),
 	)
 }
diff --git a/ui/mainwindow/viewport.go b/ui/mainwindow/viewport.go
index 749d24d..96404c8 100644
--- a/ui/mainwindow/viewport.go
+++ b/ui/mainwindow/viewport.go
@@ -2,6 +2,7 @@ package mainwindow
 
 import (
 	"errors"
+	"fmt"
 	"lab.zaar.be/thefish/alchemyst-go/engine/fov"
 	"lab.zaar.be/thefish/alchemyst-go/engine/fov/precomputed_shade"
 	"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
@@ -10,15 +11,14 @@ import (
 
 var NotInViewError = errors.New("not in ViewPort")
 
-const FPS_LIMIT = 60
-
 type ViewPort struct {
 	*types.Rect
+	cameraCoords      types.Coords
 	level             *gamemap.Level
 	layer             *Layer
 	Fov               fov.Fov
-	playerCoords      types.Coords
-	playerTorchRadius int
+	PlayerCoords      types.Coords
+	PlayerTorchRadius int
 }
 
 func NewViewPort(x, y, w, h int, level *gamemap.Level, layer *Layer) *ViewPort {
@@ -32,13 +32,13 @@ func NewViewPort(x, y, w, h int, level *gamemap.Level, layer *Layer) *ViewPort {
 		Fov:   fov,
 	}
 
-	vp.playerCoords = types.Coords{10, 10}
-	vp.playerTorchRadius = 10
+	vp.PlayerCoords = types.Coords{10, 10}
+	vp.PlayerTorchRadius = 10
 
 	return &vp
 }
 
-func (vp *ViewPort) Move(c *types.Coords) {
+func (vp *ViewPort) Move(c *types.Coords, state types.GameState) {
 	x := c.X - vp.Rect.W/2
 	y := c.Y - vp.Rect.H/2
 
@@ -49,22 +49,26 @@ func (vp *ViewPort) Move(c *types.Coords) {
 		y = 0
 	}
 	if x > vp.level.W-vp.W {
-		x = vp.level.W - vp.W
+		x = vp.level.W - vp.W - 1
 	}
 	if y > vp.level.H-vp.H {
-		x = vp.level.H - vp.H
+		x = vp.level.H - vp.H - 1
 	}
-	//if x != vp.X || y != vp.Y { State.FovRecompute <- struct{}{}}
-	vp.X, vp.Y = x, y
+	if x != vp.cameraCoords.X || y != vp.cameraCoords.Y {
+		state.FovRecompute <- struct{}{}
+	}
+	vp.cameraCoords.X = x
+	vp.cameraCoords.Y = y
+
 }
 
-func (vp *ViewPort) ToVPCoords(c *types.Coords) (newCoords *types.Coords, err error) {
+func (vp *ViewPort) ToVPCoords(c types.Coords) (newCoords types.Coords, err error) {
 	//coords on map to coords on vp
-	x, y := c.X-vp.X, c.Y-vp.Y
-	if x < 0 || y < 0 || x >= vp.W || y >= vp.H {
-		return &types.Coords{-1, -1}, NotInViewError
+	x, y := c.X-vp.cameraCoords.X, c.Y-vp.cameraCoords.Y
+	if x < 0 || y < 0 || x > vp.W || y > vp.H {
+		return types.Coords{-1, -1}, NotInViewError
 	}
-	return &types.Coords{x, y}, nil
+	return types.Coords{x, y}, nil
 }
 
 ////call only from main thread
@@ -75,15 +79,15 @@ func (vp *ViewPort) ToVPCoords(c *types.Coords) (newCoords *types.Coords, err er
 //	redraw := false
 //	//fixme get player instance
 //
-//	vp.Move(&vp.playerCoords)
+//	vp.Move(&vp.PlayerCoords)
 //	//fixme detect fovRecompute
 //	if fovRecompute {
-//		vp.layer.Clear(vp.Rect)
+//		vp.layer.ClearRect(vp.Rect)
 //		fovRecompute = false
 //		redraw = true
 //		//fixme
 //
-//		vp.Fov.ComputeFov(vp.level, vp.playerCoords, vp.playerTorchRadius)
+//		vp.Fov.ComputeFov(vp.level, vp.PlayerCoords, vp.PlayerTorchRadius)
 //	}
 //	//increase ticker
 //	fpsTicker++
@@ -119,26 +123,54 @@ func (vp *ViewPort) ToVPCoords(c *types.Coords) (newCoords *types.Coords, err er
 var redraw = true
 var fovRecompute = true
 
-func (vp *ViewPort) Render() {
+func (vp *ViewPort) Listen(state types.GameState) {
+	for {
+		select {
+		case <-state.FovRecompute:
+			fovRecompute = true
+		case <-state.Redraw:
+			redraw = true
+		}
+	}
+}
+
+func (vp *ViewPort) Render(state types.GameState) {
+
+	vp.Move(&vp.PlayerCoords, state)
 
 	if fovRecompute {
-		vp.layer.Clear(vp.Rect)
+		vp.layer.ClearRect(vp.Rect)
 		fovRecompute = false
 		redraw = true
-		vp.Fov.ComputeFov(vp.level, vp.playerCoords, vp.playerTorchRadius)
+		vp.Fov.ComputeFov(vp.level, vp.PlayerCoords, vp.PlayerTorchRadius)
 	}
 
 	if redraw {
+		//terrain
 		for y := 0; y < vp.H; y++ {
 			for x := 0; x < vp.W; x++ {
-				mapCoords := types.Coords{vp.X + x, vp.Y + y}
+				mapCoords := types.Coords{vp.cameraCoords.X + x, vp.cameraCoords.Y + y}
 
-				tile := vp.level.GetTile(mapCoords)
-				if tile.Explored || tile.MustDraw || tile.Visible {
-					vp.layer.PutToBase(mapCoords.X, mapCoords.Y, tile.GetChar(), tile.GetRawColor(), tile.GetRawBgColor())
+				if vp.level.InBounds(mapCoords) {
+					tile := vp.level.GetTile(mapCoords)
+					if tile.Explored || tile.MustDraw || tile.Visible {
+						vp.layer.PutToBase(x + vp.X, y + vp.Y, tile.GetChar(), tile.GetRawColor(), tile.GetRawBgColor())
+					}
 				}
 			}
 		}
+		//mobs
+		pc,err := vp.ToVPCoords(vp.PlayerCoords)
+		_ = pc
+		if err != nil {
+			fmt.Println("error on getting player position")
+		} else {
+			vp.layer.WithColor("white").Put(pc.X + vp.X, pc.Y + vp.Y, "@")
+			//mw.GetLayer("base").WithColor("white").Put(42, 10, "B")
+			//mw.GetLayer("overlay").WithColor("white").Put(59, 10, "O")
+		}
+
+		redraw = true
 		//redraw = false
 	}
 
diff --git a/util/config.go b/util/config.go
index 4d6afd9..a50cb53 100644
--- a/util/config.go
+++ b/util/config.go
@@ -14,6 +14,7 @@ type Config struct {
 	MainWindowSizeX int    `json:"sizeX"`
 	MainWindowSizeY int    `json:"sizeY"`
 	Font            string `json:"font"`
+	FontSize            string `json:"fontSize"` //format is "8x12"
 	Verbosity       string `json:"verbosity"`
 }
 

From 1ac6ae46655d048490e2abe07b38265015e78e33 Mon Sep 17 00:00:00 2001
From: thefish <thefish@zaar.be>
Date: Fri, 1 Nov 2019 17:51:55 +0300
Subject: [PATCH 3/8] animation handling, screens, vp changes

---
 cmd/game/main.go                              | 39 ++++++--
 config.json                                   |  6 +-
 .../precomputed_shade_test.go                 |  2 +-
 engine/gamemap/tile.go                        | 12 +--
 engine/mob/mob.go                             | 25 ------
 engine/screens/character.go                   | 11 +++
 engine/screens/game.go                        | 60 +++++++++++++
 engine/screens/inventory.go                   | 11 +++
 engine/screens/target.go                      | 11 +++
 engine/screens/title.go                       | 11 +++
 engine/types/appearance.go                    | 17 +++-
 engine/types/gamestate.go                     |  1 +
 engine/types/mob.go                           | 19 ++++
 engine/{mob => types}/player.go               |  4 +-
 engine/types/screen.go                        | 88 ++++++++++++++++++
 ui/mainwindow/viewport.go                     | 90 ++++++-------------
 16 files changed, 297 insertions(+), 110 deletions(-)
 delete mode 100644 engine/mob/mob.go
 create mode 100644 engine/screens/character.go
 create mode 100644 engine/screens/game.go
 create mode 100644 engine/screens/inventory.go
 create mode 100644 engine/screens/target.go
 create mode 100644 engine/screens/title.go
 create mode 100644 engine/types/mob.go
 rename engine/{mob => types}/player.go (55%)
 create mode 100644 engine/types/screen.go

diff --git a/cmd/game/main.go b/cmd/game/main.go
index 500b934..4169c63 100644
--- a/cmd/game/main.go
+++ b/cmd/game/main.go
@@ -5,6 +5,7 @@ import (
 	"github.com/rs/zerolog/log"
 	"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
 	"lab.zaar.be/thefish/alchemyst-go/engine/gamemap/mapgens"
+	"lab.zaar.be/thefish/alchemyst-go/engine/screens"
 	"lab.zaar.be/thefish/alchemyst-go/engine/types"
 	"lab.zaar.be/thefish/alchemyst-go/ui"
 	"lab.zaar.be/thefish/alchemyst-go/ui/mainwindow"
@@ -58,11 +59,35 @@ func main() {
 
 	setupLayers(mw)
 
+	//fixme
 	level, rooms := mapgens.DefaultGen(gamemap.NewLevel(mainCtx, "test", 1))
-
 	vp := mainwindow.NewViewPort(40, 0, 60, 47, level, mw.GetLayer("base"))
-	vp.PlayerCoords = rooms[0].Center
-	vp.Render(State)
+
+
+	screenMgr := types.NewScreenManager(mainCtx)
+	screenMgr.AddScreen("title", &screens.TitleScreen{})
+	screenMgr.AddScreen("game", screens.NewGameScreen(mw, &State, vp))
+
+	screenMgr.SetScreenByName("game")
+
+
+	//fixme
+	player := &types.Player{
+		Mob: types.Mob{
+			Appearance: &types.Appearance{
+				Glyph: &types.PlainGlyphHolder{"@"},
+				ColorSet: &types.TileColorSet{
+					Fg:     &types.PlainColorHolder{255, 255, 255, 255},
+				},
+			},
+			Coords: rooms[0].Center,
+			BlocksPass: true,
+		},
+	}
+	State.Player = player
+
+	vp.PlayerCoords = player.Coords
+	vp.Render(&State)
 
 	go decodeInput(mainCtx, mw.GetLayer("base"))
 	go vp.Listen(State)
@@ -75,9 +100,7 @@ func main() {
 		case State.RawInput <- ui.ReadKeyCode():
 			break
 		case pressed := <-State.Input:
-			mw.GetLayer("base").ClearArea(0, 3, 40, 1)
-			mw.GetLayer("base").Print(1, 3, "Key: "+pressed)
-			mw.GetLayer("base").Print(1, 6, "█")
+			screenMgr.CurrentScreen.HandleInput(pressed)
 			break
 			//case f := <-State.mainfunc:
 			//	f()
@@ -86,9 +109,9 @@ func main() {
 			mainCtx.Logger().Warn().Msg("quitting NOW")
 			exit = true
 			break
-			// не оставляйте default в бесконесчном select {} - сожрет всё CPU
+		// не оставляйте default в бесконесчном select {} - сожрет всё CPU
 		default:
-			vp.Render(State)
+			screenMgr.CurrentScreen.Render()
 			blt.Refresh()
 		}
 
diff --git a/config.json b/config.json
index 9ae5595..7680f2a 100644
--- a/config.json
+++ b/config.json
@@ -1,10 +1,10 @@
 {
   "version": "0.0.0.1",
-  "title" : "Test Go+BLT App",
+  "title" : "Alchemyst",
   "sizeX": 100,
   "sizeY": 47,
   "fpsLimit" : 60,
-  "font": "./resources/fonts-ttf/UbuntuMono-R.ttf",
-  "fontSize": "12x16",
+  "font": "./resources/fonts-ttf/LiberationMono-Bold.ttf",
+  "fontSize": "8x12",
   "verbosity": "debug"
 }
\ No newline at end of file
diff --git a/engine/fov/precomputed_shade/precomputed_shade_test.go b/engine/fov/precomputed_shade/precomputed_shade_test.go
index f703e01..298d7e0 100644
--- a/engine/fov/precomputed_shade/precomputed_shade_test.go
+++ b/engine/fov/precomputed_shade/precomputed_shade_test.go
@@ -67,7 +67,7 @@ func TestPrecompShade(t *testing.T) {
 		if playerCoords.X == x && playerCoords.Y == y {
 			return "@"
 		}
-		result := level.GetTileByXY(x, y).Char
+		result := level.GetTileByXY(x, y).Glyph.GetGlyph()
 		if !level.GetTileByXY(x, y).Visible {
 			result = "?"
 		}
diff --git a/engine/gamemap/tile.go b/engine/gamemap/tile.go
index ae60388..3a5aae2 100644
--- a/engine/gamemap/tile.go
+++ b/engine/gamemap/tile.go
@@ -17,7 +17,7 @@ type Tile struct {
 }
 
 func (t *Tile) GetChar() string {
-	return t.Char
+	return t.Glyph.GetGlyph()
 }
 
 func (t *Tile) GetRawColor() uint32 {
@@ -45,7 +45,7 @@ func NewWall() *Tile {
 		Explored:    false,
 		MustDraw:    false,
 		Appearance: &Appearance{
-			Char: "#",
+			Glyph: &PlainGlyphHolder{"#"},
 			ColorSet: &TileColorSet{
 				Fg:     &PlainColorHolder{255, 130, 110, 150},
 				Bg:     &PlainColorHolder{255, 172, 170, 173},
@@ -65,7 +65,7 @@ func NewFloor() *Tile {
 		Explored:    false,
 		MustDraw:    false,
 		Appearance: &Appearance{
-			Char: ".",
+			Glyph: &PlainGlyphHolder{"."},
 			ColorSet: &TileColorSet{
 				Fg:     &PlainColorHolder{255, 220, 220, 250},
 				Bg:     &PlainColorHolder{255, 19, 19, 70},
@@ -88,14 +88,14 @@ func NewWaterTile() *Tile {
 		Colordance:  true,
 
 		Appearance: &Appearance{
-			Char: " ",
+			Glyph: &PlainGlyphHolder{" "},
 			ColorSet: &TileColorSet{
 				Fg: &PlainColorHolder{255, 220, 220, 250},
 				Bg: &DanceColorHolder{
 					255,
 					SingleColorRing(19),
 					FillColorRing(19, 0, 15, 2),
-					FillColorRing(70, 120, 220, 12),
+					FillColorRing(127, 120, 176, 12),
 				},
 				DarkFg: &PlainColorHolder{255, 30, 20, 50},
 				DarkBg: &PlainColorHolder{255, 7, 7, 30},
@@ -115,7 +115,7 @@ func NewDeepWaterTile() *Tile {
 		MustDraw:    true, //fixme debug
 		Colordance:  true,
 		Appearance: &Appearance{
-			Char: " ",
+			Glyph: &PlainGlyphHolder{" "},
 			ColorSet: &TileColorSet{
 				Fg: &PlainColorHolder{255, 220, 220, 250},
 				Bg: &DanceColorHolder{
diff --git a/engine/mob/mob.go b/engine/mob/mob.go
deleted file mode 100644
index 1f70c59..0000000
--- a/engine/mob/mob.go
+++ /dev/null
@@ -1,25 +0,0 @@
-package mob
-
-import (
-	"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
-	"lab.zaar.be/thefish/alchemyst-go/engine/types"
-)
-
-type Mob struct {
-	*gamemap.Appearance
-	*types.Coords
-	BlocksPass bool
-}
-
-
-func (m *Mob) Walk(dx, dy int) {
-
-}
-
-func (m *Mob) Render() {
-
-}
-
-func (m *Mob) MoveToCoords(c types.Coords) {
-
-}
\ No newline at end of file
diff --git a/engine/screens/character.go b/engine/screens/character.go
new file mode 100644
index 0000000..4805e88
--- /dev/null
+++ b/engine/screens/character.go
@@ -0,0 +1,11 @@
+package screens
+
+type CharacterScreen struct {
+
+}
+
+func (ts *CharacterScreen) UseEcs() bool {return false}
+func (ts *CharacterScreen) Enter() {}
+func (ts *CharacterScreen) HandleInput(input string) {}
+func (ts *CharacterScreen) Exit() {}
+func (ts *CharacterScreen) Render() {}
diff --git a/engine/screens/game.go b/engine/screens/game.go
new file mode 100644
index 0000000..2740ff9
--- /dev/null
+++ b/engine/screens/game.go
@@ -0,0 +1,60 @@
+package screens
+
+import (
+	"lab.zaar.be/thefish/alchemyst-go/engine/types"
+	"lab.zaar.be/thefish/alchemyst-go/ui/mainwindow"
+)
+
+type GameScreen struct {
+	mw    *mainwindow.MainWindow
+	state *types.GameState
+	vp    *mainwindow.ViewPort
+}
+
+func NewGameScreen(mw *mainwindow.MainWindow, state *types.GameState, viewPort *mainwindow.ViewPort) *GameScreen {
+	return &GameScreen{mw: mw, state: state, vp: viewPort}
+}
+
+func (ts *GameScreen) UseEcs() bool { return true }
+func (ts *GameScreen) Enter()       {}
+func (ts *GameScreen) HandleInput(input string) {
+	//ts.state.Do(func(){
+	switch input {
+	case "Up", "k", "8":
+		ts.state.Player.Walk(0, -1)
+		break
+	case "Down", "j", "2":
+		ts.state.Player.Walk(0, 1)
+		break
+	case "Left", "h", "4":
+		ts.state.Player.Walk(-1, 0)
+		break
+	case "Right", "l", "6":
+		ts.state.Player.Walk(1, 0)
+		break
+	case "y", "7":
+		ts.state.Player.Walk(-1, -1)
+		break
+	case "u", "9":
+		ts.state.Player.Walk(1, -1)
+		break
+	case "b", "1":
+		ts.state.Player.Walk(-1, 1)
+		break
+	case "n", "3":
+		ts.state.Player.Walk(-1, 3)
+		break
+
+
+	default:
+		ts.mw.GetLayer("base").ClearArea(0, 3, 40, 1)
+		ts.mw.GetLayer("base").Print(1, 3, "Key: "+input)
+		ts.mw.GetLayer("base").Print(1, 6, "█")
+
+	}
+	//})
+}
+func (ts *GameScreen) Exit()   {}
+func (ts *GameScreen) Render() {
+	ts.vp.Render(ts.state)
+}
diff --git a/engine/screens/inventory.go b/engine/screens/inventory.go
new file mode 100644
index 0000000..6b19c5a
--- /dev/null
+++ b/engine/screens/inventory.go
@@ -0,0 +1,11 @@
+package screens
+
+type InventoryScreen struct {
+
+}
+
+func (ts *InventoryScreen) UseEcs() bool {return true}
+func (ts *InventoryScreen) Enter() {}
+func (ts *InventoryScreen) HandleInput(input string) {}
+func (ts *InventoryScreen) Exit() {}
+func (ts *InventoryScreen) Render() {}
diff --git a/engine/screens/target.go b/engine/screens/target.go
new file mode 100644
index 0000000..839efda
--- /dev/null
+++ b/engine/screens/target.go
@@ -0,0 +1,11 @@
+package screens
+
+type TargetScreen struct {
+
+}
+
+func (ts *TargetScreen) UseEcs() bool {return true}
+func (ts *TargetScreen) Enter() {}
+func (ts *TargetScreen) HandleInput(input string) {}
+func (ts *TargetScreen) Exit() {}
+func (ts *TargetScreen) Render() {}
diff --git a/engine/screens/title.go b/engine/screens/title.go
new file mode 100644
index 0000000..1390985
--- /dev/null
+++ b/engine/screens/title.go
@@ -0,0 +1,11 @@
+package screens
+
+type TitleScreen struct {
+
+}
+
+func (ts *TitleScreen) UseEcs() bool {return false}
+func (ts *TitleScreen) Enter() {}
+func (ts *TitleScreen) HandleInput(input string) {}
+func (ts *TitleScreen) Exit() {}
+func (ts *TitleScreen) Render() {}
diff --git a/engine/types/appearance.go b/engine/types/appearance.go
index d09ded5..d61e397 100644
--- a/engine/types/appearance.go
+++ b/engine/types/appearance.go
@@ -60,8 +60,21 @@ type TileColorSet struct {
 	DarkBg ColorHolder
 }
 
+
+type GlyphHolder interface {
+	GetGlyph() string
+}
+
+type PlainGlyphHolder struct {
+	Glyph string
+}
+
+func (pch *PlainGlyphHolder) GetGlyph() string {
+	return pch.Glyph
+}
+
 type Appearance struct {
-	Char     string        `json:"char"`
+	Glyph    GlyphHolder   `json:"char"`
 	ColorSet *TileColorSet `json:"colorSet"`
 }
 
@@ -80,7 +93,7 @@ func FillColorRing(colorValue uint8, minGlow, maxGlow, step int) *cdeque {
 		color = crng.Range(1, step) + color
 	}
 	color = crng.Range(0, step+minGlow)
-	q = append(q, uint8(color))
+	q = append(q, colorValue)
 	//for uint8(color) < uint8(colorValue) {
 	//	q = append(q, uint8(color))
 	//	color = crng.Range(1, step+minGlow)
diff --git a/engine/types/gamestate.go b/engine/types/gamestate.go
index 8ae529e..5478b65 100644
--- a/engine/types/gamestate.go
+++ b/engine/types/gamestate.go
@@ -7,6 +7,7 @@ type GameState struct {
 	RawInput     chan int
 	FovRecompute chan struct{}
 	Redraw		 chan struct{}
+	Player 		 *Player
 }
 
 // do runs f on the main thread.
diff --git a/engine/types/mob.go b/engine/types/mob.go
new file mode 100644
index 0000000..67b7fd5
--- /dev/null
+++ b/engine/types/mob.go
@@ -0,0 +1,19 @@
+package types
+
+type Mob struct {
+	*Appearance
+	Coords
+	BlocksPass bool
+}
+
+func (m *Mob) Walk(dx, dy int) {
+
+}
+
+func (m *Mob) Render() {
+
+}
+
+func (m *Mob) MoveToCoords(c Coords) {
+
+}
\ No newline at end of file
diff --git a/engine/mob/player.go b/engine/types/player.go
similarity index 55%
rename from engine/mob/player.go
rename to engine/types/player.go
index 1a7d145..052ec2a 100644
--- a/engine/mob/player.go
+++ b/engine/types/player.go
@@ -1,5 +1,5 @@
-package mob
+package types
 
 type Player struct {
-	*Mob
+	Mob
 }
diff --git a/engine/types/screen.go b/engine/types/screen.go
new file mode 100644
index 0000000..8d1dc43
--- /dev/null
+++ b/engine/types/screen.go
@@ -0,0 +1,88 @@
+package types
+
+import (
+	"lab.zaar.be/thefish/alchemyst-go/util"
+)
+
+type Screen interface {
+	Enter()
+	Exit()
+	Render()
+	HandleInput(input string)
+	UseEcs() bool
+}
+
+type ScreenManager struct {
+	ctx util.ClientCtx
+	Screens map[string]Screen
+	CurrentScreen Screen
+	PreviousScreen Screen
+}
+
+// NewScreenManager is a convenience/constructor method to properly initialize a new ScreenManager
+func NewScreenManager(ctx util.ClientCtx) *ScreenManager {
+	manager := ScreenManager{
+		ctx:ctx,
+		Screens: make(map[string]Screen),
+		CurrentScreen: nil,
+	}
+	return &manager
+}
+
+func (sm *ScreenManager) AddScreen(screenName string, screen Screen) {
+	// Check to see if a screen with the given screenName has already been added
+	if _, ok := sm.Screens[screenName]; !ok {
+		// A screen with the given name does not yet exist on the ScreenManager, go ahead and add it
+		sm.Screens[screenName] = screen
+	} else {
+		sm.ctx.Logger().Warn().Msgf("A screen with name %v was already added to the ScreenManager %v!", screenName, sm)
+	}
+}
+
+// RemoveScreen will remove a screen from the ScreenManager. This can be useful when a temporary screen needs to be
+// created, as it can be quickly added (rather than registering at game creation), and then removed when it is no
+// longer needed
+func (sm *ScreenManager) RemoveScreen(screenName string, screen Screen) {
+	// Check if the given screenName exists in the ScreenManager
+	if _, ok := sm.Screens[screenName]; ok {
+		delete(sm.Screens, screenName)
+	} else {
+		// A screen with the given name does not exist
+		sm.ctx.Logger().Warn().Msgf("A screen with name %v was not found on ScreenManager %v!", screenName, sm)
+	}
+}
+
+// SetScreen will set the current screen property of the screen manager to the provided screen
+func (sm *ScreenManager) SetScreen(screen Screen) {
+	// Call the exit function of the currentScreen, and set the currentScreen as the previousScreen
+	// Only do this if there is a currentScreen
+	if sm.CurrentScreen != nil {
+		sm.CurrentScreen.Exit()
+		sm.PreviousScreen = sm.CurrentScreen
+	}
+
+	// Set the provided screen as the currentScreen, and call the enter() function of the new currentScreen
+	sm.CurrentScreen = screen
+	sm.CurrentScreen.Enter()
+}
+
+// SetScreenByName takes a string representing the screen desired to navigate to. It will then transition the
+// ScreenManager to the specified screen, if one is found.
+func (sm *ScreenManager) SetScreenByName(screenName string) {
+	// Check if the given screenName exists in the ScreenManager
+	if _, ok := sm.Screens[screenName]; ok {
+		// Call the exit function of the currentScreen, and set the currentScreen as the previousScreen
+		// Only do this if there is a currentScreen
+		if sm.CurrentScreen != nil {
+			sm.CurrentScreen.Exit()
+			sm.PreviousScreen = sm.CurrentScreen
+		}
+
+		// Set the provided screen as the currentScreen, and call the enter() function of the new currentScreen
+		sm.CurrentScreen = sm.Screens[screenName]
+		sm.CurrentScreen.Enter()
+	} else {
+		// A screen with the given name does not exist
+		sm.ctx.Logger().Warn().Msgf("A screen with name %v was not found on ScreenManager %v!", screenName, sm)
+	}
+}
\ No newline at end of file
diff --git a/ui/mainwindow/viewport.go b/ui/mainwindow/viewport.go
index 96404c8..585ab04 100644
--- a/ui/mainwindow/viewport.go
+++ b/ui/mainwindow/viewport.go
@@ -7,6 +7,7 @@ import (
 	"lab.zaar.be/thefish/alchemyst-go/engine/fov/precomputed_shade"
 	"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
 	"lab.zaar.be/thefish/alchemyst-go/engine/types"
+	"time"
 )
 
 var NotInViewError = errors.New("not in ViewPort")
@@ -19,26 +20,35 @@ type ViewPort struct {
 	Fov               fov.Fov
 	PlayerCoords      types.Coords
 	PlayerTorchRadius int
+	animateTiles      *time.Ticker
 }
 
 func NewViewPort(x, y, w, h int, level *gamemap.Level, layer *Layer) *ViewPort {
 	//fixme
-	fov := precomputed_shade.NewPrecomputedShade(15)
-	fov.Init()
+	computedFov := precomputed_shade.NewPrecomputedShade(15)
+	computedFov.Init()
 	vp := ViewPort{
 		Rect:  &types.Rect{x, y, w, h},
 		level: level,
 		layer: layer,
-		Fov:   fov,
+		Fov:   computedFov,
 	}
 
-	vp.PlayerCoords = types.Coords{10, 10}
-	vp.PlayerTorchRadius = 10
+	vp.PlayerTorchRadius = 14
+	vp.animateTiles = time.NewTicker(time.Second / 10)
 
 	return &vp
 }
 
-func (vp *ViewPort) Move(c *types.Coords, state types.GameState) {
+func (vp *ViewPort) Close() {
+	vp.animateTiles.Stop()
+	vp.animateTiles = nil //free pointer to ticker
+}
+
+func (vp *ViewPort) Move(state *types.GameState) {
+
+	c := &state.Player.Coords
+	
 	x := c.X - vp.Rect.W/2
 	y := c.Y - vp.Rect.H/2
 
@@ -71,55 +81,6 @@ func (vp *ViewPort) ToVPCoords(c types.Coords) (newCoords types.Coords, err erro
 	return types.Coords{x, y}, nil
 }
 
-////call only from main thread
-//func (vp *ViewPort) Render() {
-//	//fixme get these from state chan(s)
-//	var fpsTicker int
-//	var fovRecompute bool = true
-//	redraw := false
-//	//fixme get player instance
-//
-//	vp.Move(&vp.PlayerCoords)
-//	//fixme detect fovRecompute
-//	if fovRecompute {
-//		vp.layer.ClearRect(vp.Rect)
-//		fovRecompute = false
-//		redraw = true
-//		//fixme
-//
-//		vp.Fov.ComputeFov(vp.level, vp.PlayerCoords, vp.PlayerTorchRadius)
-//	}
-//	//increase ticker
-//	fpsTicker++
-//
-//	if redraw || fpsTicker%(FPS_LIMIT/10) == 0 {
-//		fpsTicker = 0
-//
-//		for y := 0; y < vp.H; y++ {
-//			for x := 0; x < vp.W; x++ {
-//				mapCoords := types.Coords{vp.X + x, vp.Y + y}
-//				tile := vp.level.Tiles[mapCoords.X][mapCoords.Y]
-//				visible := vp.Fov.IsInFov(mapCoords)
-//				if !visible {
-//					if tile.MustDraw {
-//						//darkened version of landscape
-//						vp.layer.WithRawColor(tile.ColorSet.DarkFg()).
-//							PutWithRawBackground(mapCoords.X, mapCoords.Y, tile.Char, tile.ColorSet.DarkBg())
-//					}
-//				} else {
-//					if redraw == true || tile.Colordance {
-//						vp.layer.WithRawColor(tile.ColorSet.Fg()).
-//							PutWithRawBackground(mapCoords.X, mapCoords.Y, tile.Char, tile.ColorSet.Bg())
-//						tile.Explored = true
-//						tile.MustDraw = true
-//					}
-//				}
-//			}
-//		}
-//
-//	}
-//}
-
 var redraw = true
 var fovRecompute = true
 
@@ -130,19 +91,21 @@ func (vp *ViewPort) Listen(state types.GameState) {
 			fovRecompute = true
 		case <-state.Redraw:
 			redraw = true
+		case <-vp.animateTiles.C:
+			redraw = true
 		}
 	}
 }
 
-func (vp *ViewPort) Render(state types.GameState) {
+func (vp *ViewPort) Render(state *types.GameState) {
 
-	vp.Move(&vp.PlayerCoords, state)
+	vp.Move(state)
 
 	if fovRecompute {
 		vp.layer.ClearRect(vp.Rect)
 		fovRecompute = false
 		redraw = true
-		vp.Fov.ComputeFov(vp.level, vp.PlayerCoords, vp.PlayerTorchRadius)
+		vp.Fov.ComputeFov(vp.level, state.Player.Coords, vp.PlayerTorchRadius)
 	}
 
 	if redraw {
@@ -154,24 +117,25 @@ func (vp *ViewPort) Render(state types.GameState) {
 				if vp.level.InBounds(mapCoords) {
 					tile := vp.level.GetTile(mapCoords)
 					if tile.Explored || tile.MustDraw || tile.Visible {
-						vp.layer.PutToBase(x + vp.X, y + vp.Y, tile.GetChar(), tile.GetRawColor(), tile.GetRawBgColor())
+						vp.layer.PutToBase(x+vp.X, y+vp.Y, tile.GetChar(), tile.GetRawColor(), tile.GetRawBgColor())
 					}
 				}
 			}
 		}
 		//mobs
-		pc,err := vp.ToVPCoords(vp.PlayerCoords)
+		pc, err := vp.ToVPCoords(vp.PlayerCoords)
 		_ = pc
 		if err != nil {
 			fmt.Println("error on getting player position")
 		} else {
-			vp.layer.WithColor("white").Put(pc.X + vp.X, pc.Y + vp.Y, "@")
+			vp.layer.WithColor("white").Put(pc.X+vp.X, pc.Y+vp.Y, "@")
 			//mw.GetLayer("base").WithColor("white").Put(42, 10, "B")
 			//mw.GetLayer("overlay").WithColor("white").Put(59, 10, "O")
 		}
 
-		redraw = true
-		//redraw = false
+		//redraw = true
+		redraw = false
+
 	}
 
 }

From 529f5a57492eb9c9250edc6d4913bcfbb95a996f Mon Sep 17 00:00:00 2001
From: thefish <thefish@zaar.be>
Date: Fri, 1 Nov 2019 18:21:27 +0300
Subject: [PATCH 4/8] reorganize

---
 cmd/game/main.go                         | 11 +++++---
 engine/{types => gamestate}/gamestate.go | 10 +++++--
 engine/mob/mob.go                        | 21 +++++++++++++++
 engine/{types => mob}/player.go          |  2 +-
 engine/screens/game.go                   |  8 +++---
 engine/types/mob.go                      | 19 -------------
 ui/mainwindow/viewport.go                | 34 +++++++++++-------------
 7 files changed, 56 insertions(+), 49 deletions(-)
 rename engine/{types => gamestate}/gamestate.go (65%)
 create mode 100644 engine/mob/mob.go
 rename engine/{types => mob}/player.go (67%)
 delete mode 100644 engine/types/mob.go

diff --git a/cmd/game/main.go b/cmd/game/main.go
index 4169c63..d9d32b9 100644
--- a/cmd/game/main.go
+++ b/cmd/game/main.go
@@ -5,6 +5,8 @@ import (
 	"github.com/rs/zerolog/log"
 	"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
 	"lab.zaar.be/thefish/alchemyst-go/engine/gamemap/mapgens"
+	"lab.zaar.be/thefish/alchemyst-go/engine/gamestate"
+	"lab.zaar.be/thefish/alchemyst-go/engine/mob"
 	"lab.zaar.be/thefish/alchemyst-go/engine/screens"
 	"lab.zaar.be/thefish/alchemyst-go/engine/types"
 	"lab.zaar.be/thefish/alchemyst-go/ui"
@@ -37,7 +39,7 @@ func init() {
 // 		...
 // }
 
-var State = types.GameState{
+var State = gamestate.GameState{
 	Mainfunc:     make(chan func()),
 	Exit:         make(chan struct{}, 1),
 	Input:        make(chan string, 1),
@@ -61,7 +63,8 @@ func main() {
 
 	//fixme
 	level, rooms := mapgens.DefaultGen(gamemap.NewLevel(mainCtx, "test", 1))
-	vp := mainwindow.NewViewPort(40, 0, 60, 47, level, mw.GetLayer("base"))
+	State.Level = level
+	vp := mainwindow.NewViewPort(40, 0, 60, 47, mw.GetLayer("base"))
 
 
 	screenMgr := types.NewScreenManager(mainCtx)
@@ -72,8 +75,8 @@ func main() {
 
 
 	//fixme
-	player := &types.Player{
-		Mob: types.Mob{
+	player := &mob.Player{
+		Mob: mob.Mob{
 			Appearance: &types.Appearance{
 				Glyph: &types.PlainGlyphHolder{"@"},
 				ColorSet: &types.TileColorSet{
diff --git a/engine/types/gamestate.go b/engine/gamestate/gamestate.go
similarity index 65%
rename from engine/types/gamestate.go
rename to engine/gamestate/gamestate.go
index 5478b65..d20b9ae 100644
--- a/engine/types/gamestate.go
+++ b/engine/gamestate/gamestate.go
@@ -1,4 +1,9 @@
-package types
+package gamestate
+
+import (
+	"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
+	"lab.zaar.be/thefish/alchemyst-go/engine/mob"
+)
 
 type GameState struct {
 	Mainfunc     chan func()
@@ -7,7 +12,8 @@ type GameState struct {
 	RawInput     chan int
 	FovRecompute chan struct{}
 	Redraw		 chan struct{}
-	Player 		 *Player
+	Level        *gamemap.Level
+	Player 		 *mob.Player
 }
 
 // do runs f on the main thread.
diff --git a/engine/mob/mob.go b/engine/mob/mob.go
new file mode 100644
index 0000000..21eef57
--- /dev/null
+++ b/engine/mob/mob.go
@@ -0,0 +1,21 @@
+package mob
+
+import "lab.zaar.be/thefish/alchemyst-go/engine/types"
+
+type Mob struct {
+	*types.Appearance
+	types.Coords
+	BlocksPass bool
+}
+
+func (m *Mob) Walk(dx, dy int) {
+
+}
+
+func (m *Mob) Render() {
+
+}
+
+func (m *Mob) MoveToCoords(c types.Coords) {
+
+}
\ No newline at end of file
diff --git a/engine/types/player.go b/engine/mob/player.go
similarity index 67%
rename from engine/types/player.go
rename to engine/mob/player.go
index 052ec2a..c1b8920 100644
--- a/engine/types/player.go
+++ b/engine/mob/player.go
@@ -1,4 +1,4 @@
-package types
+package mob
 
 type Player struct {
 	Mob
diff --git a/engine/screens/game.go b/engine/screens/game.go
index 2740ff9..9a32e80 100644
--- a/engine/screens/game.go
+++ b/engine/screens/game.go
@@ -1,17 +1,17 @@
 package screens
 
 import (
-	"lab.zaar.be/thefish/alchemyst-go/engine/types"
+	"lab.zaar.be/thefish/alchemyst-go/engine/gamestate"
 	"lab.zaar.be/thefish/alchemyst-go/ui/mainwindow"
 )
 
 type GameScreen struct {
 	mw    *mainwindow.MainWindow
-	state *types.GameState
+	state *gamestate.GameState
 	vp    *mainwindow.ViewPort
 }
 
-func NewGameScreen(mw *mainwindow.MainWindow, state *types.GameState, viewPort *mainwindow.ViewPort) *GameScreen {
+func NewGameScreen(mw *mainwindow.MainWindow, state *gamestate.GameState, viewPort *mainwindow.ViewPort) *GameScreen {
 	return &GameScreen{mw: mw, state: state, vp: viewPort}
 }
 
@@ -44,8 +44,6 @@ func (ts *GameScreen) HandleInput(input string) {
 	case "n", "3":
 		ts.state.Player.Walk(-1, 3)
 		break
-
-
 	default:
 		ts.mw.GetLayer("base").ClearArea(0, 3, 40, 1)
 		ts.mw.GetLayer("base").Print(1, 3, "Key: "+input)
diff --git a/engine/types/mob.go b/engine/types/mob.go
deleted file mode 100644
index 67b7fd5..0000000
--- a/engine/types/mob.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package types
-
-type Mob struct {
-	*Appearance
-	Coords
-	BlocksPass bool
-}
-
-func (m *Mob) Walk(dx, dy int) {
-
-}
-
-func (m *Mob) Render() {
-
-}
-
-func (m *Mob) MoveToCoords(c Coords) {
-
-}
\ No newline at end of file
diff --git a/ui/mainwindow/viewport.go b/ui/mainwindow/viewport.go
index 585ab04..ec15208 100644
--- a/ui/mainwindow/viewport.go
+++ b/ui/mainwindow/viewport.go
@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"lab.zaar.be/thefish/alchemyst-go/engine/fov"
 	"lab.zaar.be/thefish/alchemyst-go/engine/fov/precomputed_shade"
-	"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
+	"lab.zaar.be/thefish/alchemyst-go/engine/gamestate"
 	"lab.zaar.be/thefish/alchemyst-go/engine/types"
 	"time"
 )
@@ -15,7 +15,6 @@ var NotInViewError = errors.New("not in ViewPort")
 type ViewPort struct {
 	*types.Rect
 	cameraCoords      types.Coords
-	level             *gamemap.Level
 	layer             *Layer
 	Fov               fov.Fov
 	PlayerCoords      types.Coords
@@ -23,19 +22,18 @@ type ViewPort struct {
 	animateTiles      *time.Ticker
 }
 
-func NewViewPort(x, y, w, h int, level *gamemap.Level, layer *Layer) *ViewPort {
-	//fixme
+func NewViewPort(x, y, w, h int, layer *Layer) *ViewPort {
+
 	computedFov := precomputed_shade.NewPrecomputedShade(15)
 	computedFov.Init()
 	vp := ViewPort{
 		Rect:  &types.Rect{x, y, w, h},
-		level: level,
 		layer: layer,
 		Fov:   computedFov,
 	}
 
-	vp.PlayerTorchRadius = 14
-	vp.animateTiles = time.NewTicker(time.Second / 10)
+	vp.PlayerTorchRadius = 9
+	vp.animateTiles = time.NewTicker(time.Second / 12)
 
 	return &vp
 }
@@ -45,10 +43,10 @@ func (vp *ViewPort) Close() {
 	vp.animateTiles = nil //free pointer to ticker
 }
 
-func (vp *ViewPort) Move(state *types.GameState) {
+func (vp *ViewPort) Move(state *gamestate.GameState) {
 
 	c := &state.Player.Coords
-	
+
 	x := c.X - vp.Rect.W/2
 	y := c.Y - vp.Rect.H/2
 
@@ -58,11 +56,11 @@ func (vp *ViewPort) Move(state *types.GameState) {
 	if y < 0 {
 		y = 0
 	}
-	if x > vp.level.W-vp.W {
-		x = vp.level.W - vp.W - 1
+	if x > state.Level.W-vp.W {
+		x = state.Level.W - vp.W - 1
 	}
-	if y > vp.level.H-vp.H {
-		x = vp.level.H - vp.H - 1
+	if y > state.Level.H-vp.H {
+		x = state.Level.H - vp.H - 1
 	}
 	if x != vp.cameraCoords.X || y != vp.cameraCoords.Y {
 		state.FovRecompute <- struct{}{}
@@ -84,7 +82,7 @@ func (vp *ViewPort) ToVPCoords(c types.Coords) (newCoords types.Coords, err erro
 var redraw = true
 var fovRecompute = true
 
-func (vp *ViewPort) Listen(state types.GameState) {
+func (vp *ViewPort) Listen(state gamestate.GameState) {
 	for {
 		select {
 		case <-state.FovRecompute:
@@ -97,7 +95,7 @@ func (vp *ViewPort) Listen(state types.GameState) {
 	}
 }
 
-func (vp *ViewPort) Render(state *types.GameState) {
+func (vp *ViewPort) Render(state *gamestate.GameState) {
 
 	vp.Move(state)
 
@@ -105,7 +103,7 @@ func (vp *ViewPort) Render(state *types.GameState) {
 		vp.layer.ClearRect(vp.Rect)
 		fovRecompute = false
 		redraw = true
-		vp.Fov.ComputeFov(vp.level, state.Player.Coords, vp.PlayerTorchRadius)
+		vp.Fov.ComputeFov(state.Level, state.Player.Coords, vp.PlayerTorchRadius)
 	}
 
 	if redraw {
@@ -114,8 +112,8 @@ func (vp *ViewPort) Render(state *types.GameState) {
 			for x := 0; x < vp.W; x++ {
 				mapCoords := types.Coords{vp.cameraCoords.X + x, vp.cameraCoords.Y + y}
 
-				if vp.level.InBounds(mapCoords) {
-					tile := vp.level.GetTile(mapCoords)
+				if state.Level.InBounds(mapCoords) {
+					tile := state.Level.GetTile(mapCoords)
 					if tile.Explored || tile.MustDraw || tile.Visible {
 						vp.layer.PutToBase(x+vp.X, y+vp.Y, tile.GetChar(), tile.GetRawColor(), tile.GetRawBgColor())
 					}

From 17ef52a5cf210b809911d0ee116f212bc5f0eda5 Mon Sep 17 00:00:00 2001
From: thefish <thefish@zaar.be>
Date: Fri, 1 Nov 2019 19:59:12 +0300
Subject: [PATCH 5/8] fix supid viewport bug

---
 .../precomputed_shade/precomputed_shade.go    |  7 ++++++-
 engine/gamemap/level.go                       |  6 ++++++
 engine/mob/mob.go                             |  8 ++++++--
 engine/screens/game.go                        |  2 +-
 ui/mainwindow/viewport.go                     | 20 +++++++++----------
 5 files changed, 29 insertions(+), 14 deletions(-)

diff --git a/engine/fov/precomputed_shade/precomputed_shade.go b/engine/fov/precomputed_shade/precomputed_shade.go
index e1a4dbf..eca682e 100644
--- a/engine/fov/precomputed_shade/precomputed_shade.go
+++ b/engine/fov/precomputed_shade/precomputed_shade.go
@@ -195,7 +195,9 @@ func (ps *precomputedShade) PrecomputeFovMap() {
 }
 
 func (ps *precomputedShade) recalc(level *gamemap.Level, initCoords types.Coords, radius int) {
-
+	for i, _ := range ps.CellList {
+		ps.CellList[i].lit = 0
+	}
 	ps.originCoords = initCoords
 
 	if radius > ps.MaxTorchRadius {
@@ -250,6 +252,7 @@ func (ps *precomputedShade) recalc(level *gamemap.Level, initCoords types.Coords
 
 func (ps *precomputedShade) ComputeFov(level *gamemap.Level, initCoords types.Coords, radius int) {
 
+	level.SetAllInvisible()
 	ps.recalc(level, initCoords, radius)
 
 	for _, cell := range ps.CellList {
@@ -260,6 +263,7 @@ func (ps *precomputedShade) ComputeFov(level *gamemap.Level, initCoords types.Co
 				continue
 			}
 			level.GetTile(cs).Visible = true
+			level.GetTile(cs).Explored = true
 		}
 
 		//light walls, crutch
@@ -273,6 +277,7 @@ func (ps *precomputedShade) ComputeFov(level *gamemap.Level, initCoords types.Co
 						(maybeNb.X == cell.X || maybeNb.Y == cell.Y) &&
 						maybeNb.lit > 0 { //magic constant!
 						level.GetTile(cs).Visible = true
+						level.GetTile(cs).Explored = true
 					}
 				}
 			}
diff --git a/engine/gamemap/level.go b/engine/gamemap/level.go
index bb749c3..fd38d60 100644
--- a/engine/gamemap/level.go
+++ b/engine/gamemap/level.go
@@ -58,6 +58,12 @@ func NewLevel(ctx util.ClientCtx, branch string, depth int) *Level {
 	return l
 }
 
+func (l *Level) SetAllInvisible() {
+	for idx, _ := range l.Tiles {
+		l.Tiles[idx].Visible = false
+	}
+}
+
 type Room struct {
 	*types.Rect
 	Center types.Coords
diff --git a/engine/mob/mob.go b/engine/mob/mob.go
index 21eef57..309ffbb 100644
--- a/engine/mob/mob.go
+++ b/engine/mob/mob.go
@@ -1,6 +1,9 @@
 package mob
 
-import "lab.zaar.be/thefish/alchemyst-go/engine/types"
+import (
+	"fmt"
+	"lab.zaar.be/thefish/alchemyst-go/engine/types"
+)
 
 type Mob struct {
 	*types.Appearance
@@ -9,7 +12,8 @@ type Mob struct {
 }
 
 func (m *Mob) Walk(dx, dy int) {
-
+	m.Coords = types.Coords{m.X + dx, m.Y + dy}
+	fmt.Printf("new coords: %d, %d\n", m.Coords.X, m.Coords.Y)
 }
 
 func (m *Mob) Render() {
diff --git a/engine/screens/game.go b/engine/screens/game.go
index 9a32e80..a91f5e0 100644
--- a/engine/screens/game.go
+++ b/engine/screens/game.go
@@ -42,7 +42,7 @@ func (ts *GameScreen) HandleInput(input string) {
 		ts.state.Player.Walk(-1, 1)
 		break
 	case "n", "3":
-		ts.state.Player.Walk(-1, 3)
+		ts.state.Player.Walk(1, 1)
 		break
 	default:
 		ts.mw.GetLayer("base").ClearArea(0, 3, 40, 1)
diff --git a/ui/mainwindow/viewport.go b/ui/mainwindow/viewport.go
index ec15208..4d97eac 100644
--- a/ui/mainwindow/viewport.go
+++ b/ui/mainwindow/viewport.go
@@ -32,7 +32,7 @@ func NewViewPort(x, y, w, h int, layer *Layer) *ViewPort {
 		Fov:   computedFov,
 	}
 
-	vp.PlayerTorchRadius = 9
+	vp.PlayerTorchRadius = 11
 	vp.animateTiles = time.NewTicker(time.Second / 12)
 
 	return &vp
@@ -56,11 +56,11 @@ func (vp *ViewPort) Move(state *gamestate.GameState) {
 	if y < 0 {
 		y = 0
 	}
-	if x > state.Level.W-vp.W {
+	if x > state.Level.W-vp.W - 1 {
 		x = state.Level.W - vp.W - 1
 	}
-	if y > state.Level.H-vp.H {
-		x = state.Level.H - vp.H - 1
+	if y > state.Level.H-vp.H - 1 {
+		y = state.Level.H - vp.H - 1
 	}
 	if x != vp.cameraCoords.X || y != vp.cameraCoords.Y {
 		state.FovRecompute <- struct{}{}
@@ -101,12 +101,12 @@ func (vp *ViewPort) Render(state *gamestate.GameState) {
 
 	if fovRecompute {
 		vp.layer.ClearRect(vp.Rect)
-		fovRecompute = false
+		fovRecompute = true
 		redraw = true
 		vp.Fov.ComputeFov(state.Level, state.Player.Coords, vp.PlayerTorchRadius)
 	}
 
-	if redraw {
+	//if redraw {
 		//terrain
 		for y := 0; y < vp.H; y++ {
 			for x := 0; x < vp.W; x++ {
@@ -114,14 +114,14 @@ func (vp *ViewPort) Render(state *gamestate.GameState) {
 
 				if state.Level.InBounds(mapCoords) {
 					tile := state.Level.GetTile(mapCoords)
-					if tile.Explored || tile.MustDraw || tile.Visible {
+					if tile.Explored || tile.Visible {
 						vp.layer.PutToBase(x+vp.X, y+vp.Y, tile.GetChar(), tile.GetRawColor(), tile.GetRawBgColor())
 					}
 				}
 			}
 		}
 		//mobs
-		pc, err := vp.ToVPCoords(vp.PlayerCoords)
+		pc, err := vp.ToVPCoords(state.Player.Coords)
 		_ = pc
 		if err != nil {
 			fmt.Println("error on getting player position")
@@ -132,8 +132,8 @@ func (vp *ViewPort) Render(state *gamestate.GameState) {
 		}
 
 		//redraw = true
-		redraw = false
+		//redraw = false
 
-	}
+	//}
 
 }

From 8c428838d6510b265758ecbf917d52f830dbfa3a Mon Sep 17 00:00:00 2001
From: thefish <thefish@zaar.be>
Date: Fri, 1 Nov 2019 22:01:23 +0300
Subject: [PATCH 6/8] slight fixes

---
 cmd/game/main.go                              |  2 +-
 .../precomputed_shade/precomputed_shade.go    |  2 +-
 engine/gamemap/level.go                       |  4 +-
 engine/gamemap/mapgens/default.go             | 50 +++++++++++--------
 ui/mainwindow/viewport.go                     |  6 +--
 5 files changed, 35 insertions(+), 29 deletions(-)

diff --git a/cmd/game/main.go b/cmd/game/main.go
index d9d32b9..40d2a08 100644
--- a/cmd/game/main.go
+++ b/cmd/game/main.go
@@ -64,7 +64,7 @@ func main() {
 	//fixme
 	level, rooms := mapgens.DefaultGen(gamemap.NewLevel(mainCtx, "test", 1))
 	State.Level = level
-	vp := mainwindow.NewViewPort(40, 0, 60, 47, mw.GetLayer("base"))
+	vp := mainwindow.NewViewPort(30, 0, 70, 47, mw.GetLayer("base"))
 
 
 	screenMgr := types.NewScreenManager(mainCtx)
diff --git a/engine/fov/precomputed_shade/precomputed_shade.go b/engine/fov/precomputed_shade/precomputed_shade.go
index eca682e..4013009 100644
--- a/engine/fov/precomputed_shade/precomputed_shade.go
+++ b/engine/fov/precomputed_shade/precomputed_shade.go
@@ -274,7 +274,7 @@ func (ps *precomputedShade) ComputeFov(level *gamemap.Level, initCoords types.Co
 				for _, maybeNb := range ps.CellList {
 					if  //int(maybeNb.distance) == int(cell.distance-1) &&
 						maybeNb.IsAdjacentTo(&cell.Coords) &&
-						(maybeNb.X == cell.X || maybeNb.Y == cell.Y) &&
+						//(maybeNb.X == cell.X || maybeNb.Y == cell.Y) &&
 						maybeNb.lit > 0 { //magic constant!
 						level.GetTile(cs).Visible = true
 						level.GetTile(cs).Explored = true
diff --git a/engine/gamemap/level.go b/engine/gamemap/level.go
index fd38d60..eebff22 100644
--- a/engine/gamemap/level.go
+++ b/engine/gamemap/level.go
@@ -7,8 +7,8 @@ import (
 )
 
 //fixme move to config
-var mapWidth = 70
-var mapHeight = 50
+var mapWidth = 150
+var mapHeight = 90
 
 
 type Level struct {
diff --git a/engine/gamemap/mapgens/default.go b/engine/gamemap/mapgens/default.go
index 2a6bc3f..38da59e 100644
--- a/engine/gamemap/mapgens/default.go
+++ b/engine/gamemap/mapgens/default.go
@@ -60,33 +60,39 @@ func DefaultGen(l *gamemap.Level) (*gamemap.Level, []*gamemap.Room) {
 		//addStairs(rooms)
 		//itemize(rooms)
 	}
+	fges := map[int]types.RectFill{
+		1: types.RectFill{
+			Top:         func() *gamemap.Tile { return gamemap.NewWall() },
+			Bottom:      func() *gamemap.Tile { return gamemap.NewWall() },
+			Left:        func() *gamemap.Tile { return gamemap.NewWall() },
+			Right:       func() *gamemap.Tile { return gamemap.NewWall() },
+			BottomLeft:  func() *gamemap.Tile { return gamemap.NewWall() },
+			BottomRight: func() *gamemap.Tile { return gamemap.NewWall() },
+			TopLeft:     func() *gamemap.Tile { return gamemap.NewWall() },
+			TopRight:    func() *gamemap.Tile { return gamemap.NewWall() },
+			Body:        func() *gamemap.Tile { return gamemap.NewFloor() },
+		},
 
-	//fillage := types.RectFill{
-	//	Top: func() *gamemap.Tile {return gamemap.NewWall()},
-	//	Bottom: func() *gamemap.Tile {return gamemap.NewWall()},
-	//	Left: func() *gamemap.Tile {return gamemap.NewWall()},
-	//	Right: func() *gamemap.Tile {return gamemap.NewWall()},
-	//	BottomLeft: func() *gamemap.Tile {return gamemap.NewWall()},
-	//	BottomRight: func() *gamemap.Tile {return gamemap.NewWall()},
-	//	TopLeft: func() *gamemap.Tile {return gamemap.NewWall()},
-	//	TopRight: func() *gamemap.Tile {return gamemap.NewWall()},
-	//	Body: func() *gamemap.Tile {return gamemap.NewFloor()},
-	//}
+		2: types.RectFill{
+			Top:         func() *gamemap.Tile { return gamemap.NewWaterTile() },
+			Bottom:      func() *gamemap.Tile { return gamemap.NewWaterTile() },
+			Left:        func() *gamemap.Tile { return gamemap.NewWaterTile() },
+			Right:       func() *gamemap.Tile { return gamemap.NewWaterTile() },
+			BottomLeft:  func() *gamemap.Tile { return gamemap.NewWaterTile() },
+			BottomRight: func() *gamemap.Tile { return gamemap.NewWaterTile() },
+			TopLeft:     func() *gamemap.Tile { return gamemap.NewWaterTile() },
+			TopRight:    func() *gamemap.Tile { return gamemap.NewWaterTile() },
+			Body:        func() *gamemap.Tile { return gamemap.NewDeepWaterTile() },
+		},
+	}
 
-	fillage := types.RectFill{
-		Top: func() *gamemap.Tile {return gamemap.NewWaterTile()},
-		Bottom: func() *gamemap.Tile {return gamemap.NewWaterTile()},
-		Left: func() *gamemap.Tile {return gamemap.NewWaterTile()},
-		Right: func() *gamemap.Tile {return gamemap.NewWaterTile()},
-		BottomLeft: func() *gamemap.Tile {return gamemap.NewWaterTile()},
-		BottomRight: func() *gamemap.Tile {return gamemap.NewWaterTile()},
-		TopLeft: func() *gamemap.Tile {return gamemap.NewWaterTile()},
-		TopRight: func() *gamemap.Tile {return gamemap.NewWaterTile()},
-		Body: func() *gamemap.Tile {return gamemap.NewDeepWaterTile()},
+	var fillage types.RectFill
+	for _, room := range rooms {
+		fillage = fges[rng.GetWeightedEntity(map[int]int{1:10, 2:1})]
+		room.Blit(fillage, l)
 	}
 
 	for idx, room := range rooms {
-		room.Blit(fillage, l)
 		if idx > 0 {
 			connectRooms(l, room, rooms[idx-1], fillage, rng.Range(0,1))
 		}
diff --git a/ui/mainwindow/viewport.go b/ui/mainwindow/viewport.go
index 4d97eac..0c77ca3 100644
--- a/ui/mainwindow/viewport.go
+++ b/ui/mainwindow/viewport.go
@@ -56,11 +56,11 @@ func (vp *ViewPort) Move(state *gamestate.GameState) {
 	if y < 0 {
 		y = 0
 	}
-	if x > state.Level.W-vp.W - 1 {
-		x = state.Level.W - vp.W - 1
+	if x > state.Level.W - vp.W - 1 {
+		x = state.Level.W - vp.W
 	}
 	if y > state.Level.H-vp.H - 1 {
-		y = state.Level.H - vp.H - 1
+		y = state.Level.H - vp.H
 	}
 	if x != vp.cameraCoords.X || y != vp.cameraCoords.Y {
 		state.FovRecompute <- struct{}{}

From fd27dfd636b2730d5f8ddb9dd91a0868cab67d71 Mon Sep 17 00:00:00 2001
From: thefish <thefish@zaar.be>
Date: Mon, 4 Nov 2019 16:30:06 +0300
Subject: [PATCH 7/8] memleak fix

---
 engine/gamemap/level.go       | 1 +
 engine/gamestate/gamestate.go | 1 +
 2 files changed, 2 insertions(+)

diff --git a/engine/gamemap/level.go b/engine/gamemap/level.go
index eebff22..373c09b 100644
--- a/engine/gamemap/level.go
+++ b/engine/gamemap/level.go
@@ -49,6 +49,7 @@ func (l *Level) Put (x, y int, tileFunc interface{}) {
 
 func NewLevel(ctx util.ClientCtx, branch string, depth int) *Level {
 	l := &Level{
+		ctx: ctx,
 		Name:     branch + string(depth),
 		Depth:    depth,
 		Rect: types.NewRect(0,0, mapWidth, mapHeight),
diff --git a/engine/gamestate/gamestate.go b/engine/gamestate/gamestate.go
index d20b9ae..6fe2dc4 100644
--- a/engine/gamestate/gamestate.go
+++ b/engine/gamestate/gamestate.go
@@ -21,6 +21,7 @@ func (g *GameState) Do(f func()) {
 	done := make(chan struct{}, 1)
 	g.Mainfunc <- func() {
 		f()
+		f = nil //zero pointer for closure function
 		done <- struct{}{}
 	}
 	<-done

From f9ebcefc86615491b457a416421dd953696845da Mon Sep 17 00:00:00 2001
From: thefish <thefish@zaar.be>
Date: Mon, 4 Nov 2019 19:07:16 +0300
Subject: [PATCH 8/8] use gogues ecs, not working, needs rethinking

---
 cmd/game/main.go                |  64 ++++++---
 engine/ecs/component.go         |   9 ++
 engine/ecs/controller.go        | 247 ++++++++++++++++++++++++++++++++
 engine/ecs/entity.go            |   6 +
 engine/ecs/system.go            |   7 +
 engine/ecs/systemMessages.go    |  87 +++++++++++
 engine/ecs/util.go              |  25 ++++
 engine/gamemap/level.go         |   2 +-
 engine/mob/mob.go               |  16 ++-
 engine/mob/mob_render_system.go |  29 ++++
 engine/screens/game.go          |  16 +--
 engine/types/appearance.go      |   6 +-
 engine/types/coords.go          |   9 +-
 13 files changed, 490 insertions(+), 33 deletions(-)
 create mode 100644 engine/ecs/component.go
 create mode 100644 engine/ecs/controller.go
 create mode 100644 engine/ecs/system.go
 create mode 100644 engine/ecs/systemMessages.go
 create mode 100644 engine/ecs/util.go
 create mode 100644 engine/mob/mob_render_system.go

diff --git a/cmd/game/main.go b/cmd/game/main.go
index 40d2a08..4f1435a 100644
--- a/cmd/game/main.go
+++ b/cmd/game/main.go
@@ -3,6 +3,7 @@ package main
 import (
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
+	"lab.zaar.be/thefish/alchemyst-go/engine/ecs"
 	"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
 	"lab.zaar.be/thefish/alchemyst-go/engine/gamemap/mapgens"
 	"lab.zaar.be/thefish/alchemyst-go/engine/gamestate"
@@ -44,8 +45,8 @@ var State = gamestate.GameState{
 	Exit:         make(chan struct{}, 1),
 	Input:        make(chan string, 1),
 	RawInput:     make(chan int, 1),
-	FovRecompute: make(chan struct{},1),
-	Redraw: 	  make(chan struct{},1),
+	FovRecompute: make(chan struct{}, 1),
+	Redraw:       make(chan struct{}, 1),
 }
 
 func main() {
@@ -66,35 +67,58 @@ func main() {
 	State.Level = level
 	vp := mainwindow.NewViewPort(30, 0, 70, 47, mw.GetLayer("base"))
 
-
 	screenMgr := types.NewScreenManager(mainCtx)
 	screenMgr.AddScreen("title", &screens.TitleScreen{})
 	screenMgr.AddScreen("game", screens.NewGameScreen(mw, &State, vp))
 
 	screenMgr.SetScreenByName("game")
 
-
 	//fixme
-	player := &mob.Player{
-		Mob: mob.Mob{
-			Appearance: &types.Appearance{
-				Glyph: &types.PlainGlyphHolder{"@"},
-				ColorSet: &types.TileColorSet{
-					Fg:     &types.PlainColorHolder{255, 255, 255, 255},
-				},
-			},
-			Coords: rooms[0].Center,
-			BlocksPass: true,
-		},
-	}
-	State.Player = player
+	//player := &mob.Player{
+	//	Mob: mob.Mob{
+	//		Appearance: &types.Appearance{
+	//			Glyph: &types.PlainGlyphHolder{"@"},
+	//			ColorSet: &types.TileColorSet{
+	//				Fg:     &types.PlainColorHolder{255, 255, 255, 255},
+	//			},
+	//		},
+	//		Coords: rooms[0].Center,
+	//		BlocksPass: true,
+	//	},
+	//}
+	//State.Player = player
 
-	vp.PlayerCoords = player.Coords
-	vp.Render(&State)
+	//vp.PlayerCoords = player.Coords
+	//vp.Render(&State)
 
 	go decodeInput(mainCtx, mw.GetLayer("base"))
 	go vp.Listen(State)
 
+	controller := ecs.NewController()
+
+	controller.MapComponentClass("coords", types.Coords{})
+	controller.MapComponentClass("appearance", types.Appearance{})
+	controller.MapComponentClass("mob", mob.Mob{})
+
+	player := controller.CreateEntity([]ecs.Component{})
+
+	controller.AddComponent(player, &types.Appearance{
+		Glyph: &types.PlainGlyphHolder{"@"},
+		ColorSet: &types.TileColorSet{
+			Fg: &types.PlainColorHolder{255, 255, 255, 255},
+		},
+	})
+
+	controller.AddComponent(player, rooms[0].Center) //implicit Coords
+
+
+	render := mob.MobRenderSystem{EntityController: controller}
+
+	controller.AddSystem(render, 1)
+
+
+
+
 	//but every call to bearlibterminal must be wrapped to closure and passed to mainfunc
 	var exit = false
 	for !exit {
@@ -112,7 +136,7 @@ func main() {
 			mainCtx.Logger().Warn().Msg("quitting NOW")
 			exit = true
 			break
-		// не оставляйте default в бесконесчном select {} - сожрет всё CPU
+			// не оставляйте default в бесконесчном select {} - сожрет всё CPU
 		default:
 			screenMgr.CurrentScreen.Render()
 			blt.Refresh()
diff --git a/engine/ecs/component.go b/engine/ecs/component.go
new file mode 100644
index 0000000..8ffdaaf
--- /dev/null
+++ b/engine/ecs/component.go
@@ -0,0 +1,9 @@
+package ecs
+
+// ECS system by jcerise, github.com/jcerise/gogue
+
+import "reflect"
+
+type Component interface {
+	TypeOf() reflect.Type
+}
\ No newline at end of file
diff --git a/engine/ecs/controller.go b/engine/ecs/controller.go
new file mode 100644
index 0000000..1f9c8dd
--- /dev/null
+++ b/engine/ecs/controller.go
@@ -0,0 +1,247 @@
+package ecs
+
+// ECS system by jcerise, github.com/jcerise/gogue
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+)
+
+type Controller struct {
+	systems map[reflect.Type]System
+	sortedSystems map[int][]System
+	priorityKeys []int
+	nextEntityID int
+	components map[reflect.Type][]int
+	entities map[int]map[reflect.Type]Component
+	deadEntities []int
+
+	// The component map will keep track of what components are available
+	componentMap map[string]Component
+}
+
+// NewController is a convenience/constructor method to properly initialize a new processor
+func NewController() *Controller {
+	controller := Controller{}
+	controller.systems = make(map[reflect.Type]System)
+	controller.sortedSystems = make(map[int][]System)
+	controller.priorityKeys = []int{}
+	controller.nextEntityID = 0
+	controller.components = make(map[reflect.Type][]int)
+	controller.entities = make(map[int]map[reflect.Type]Component)
+	controller.deadEntities = []int{}
+	controller.componentMap = make(map[string]Component)
+
+	return &controller
+}
+
+// Create a new entity in the world. An entity is simply a unique integer.
+// If any components are provided, they will be associated with the created entity
+func (c *Controller) CreateEntity(components []Component) int {
+	c.nextEntityID += 1
+
+	if len(components) > 0 {
+		for _, v := range components {
+			c.AddComponent(c.nextEntityID, v)
+		}
+	}
+
+	c.entities[c.nextEntityID] = make(map[reflect.Type]Component)
+
+	return c.nextEntityID
+}
+
+// DeleteEntity removes an entity, all component instances attached to that entity, and any components associations with
+// that entity
+func (c *Controller) DeleteEntity(entity int) {
+	// First, delete all the component associations for the entity to be removed
+	for k, _ := range c.entities[entity] {
+		c.RemoveComponent(entity, k)
+	}
+
+	// Then, delete the entity itself. The components have already been removed and disassociated with it, so a simple
+	// delete will do here
+	delete(c.entities, entity)
+}
+
+// MapComponent registers a component with the controller. This map of components gives the controller access to the
+// valid components for a game system, and allows for dynamic loading of components from the data loader.
+func (c *Controller) MapComponentClass(componentName string, component Component) {
+	// TODO: Possible to overwrite existing components with old name...
+	c.componentMap[componentName] = component
+}
+
+// GetMappedComponentClass returns a component class based on the name it was registered under. This allows for dyanamic
+// mapping of components to entities, for example, from the data loader.
+func (c *Controller) GetMappedComponentClass(componentName string) Component {
+	if _, ok := c.componentMap[componentName]; ok {
+		return c.componentMap[componentName]
+	} else {
+		// TODO: Add better (read: actual) error handling here
+		fmt.Printf("Component[%s] not registered on Controller.\n", componentName)
+		return nil
+	}
+}
+
+// AddComponent adds a component to an entity. The component is added to the global list of components for the
+// processor, and also directly associated with the entity itself. This allows for flexible checking of components,
+// as you can check which entites are associated with a component, and vice versa.
+func (c *Controller) AddComponent(entity int, component Component) {
+	// First, get the type of the component
+	componentType := reflect.TypeOf(component)
+
+	// Record that the component type is associated with the entity.
+	c.components[componentType] = append(c.components[componentType], entity)
+
+	// Now, check to see if the entity is already tracked in the controller entity list. If it is not, add it, and
+	// associate the component with it
+	if _, ok := c.entities[entity]; !ok {
+		c.entities[entity] = make(map[reflect.Type]Component)
+	}
+
+	c.entities[entity][componentType] = component
+}
+
+// HasComponent checks a given entity to see if it has a given component associated with it
+func (c *Controller) HasComponent(entity int, componentType reflect.Type) bool {
+	if _, ok := c.entities[entity][componentType]; ok {
+		return true
+	} else {
+		return false
+	}
+}
+
+// GetComponent returns the component instance for a component type, if one exists for the provided entity
+func (c *Controller) GetComponent(entity int, componentType reflect.Type) Component {
+	// Check the given entity has the provided component
+	if c.HasComponent(entity, componentType) {
+		return c.entities[entity][componentType]
+	}
+
+	return nil
+}
+
+// GetEntity gets a specific entity, and all of its component instances
+func (c *Controller) GetEntity(entity int) map[reflect.Type]Component {
+	for i, _ := range c.entities {
+		if i == entity {
+			return c.entities[entity]
+		}
+	}
+
+	return nil
+}
+
+// GetEntities returns a map of all entities and their component instances
+func (c *Controller) GetEntities() map[int]map[reflect.Type]Component {
+	return c.entities
+}
+
+// GetEntitiesWithComponent returns a list of all entities with a given component attached
+// TODO: Allow for passing a list of components
+func (c *Controller) GetEntitiesWithComponent(componentType reflect.Type) []int {
+	entitiesWithComponent := make([]int, 0)
+	for entity := range c.entities {
+		if c.HasComponent(entity, componentType) {
+			entitiesWithComponent = append(entitiesWithComponent, entity)
+		}
+	}
+
+	return entitiesWithComponent
+}
+
+// UpdateComponent updates a component on an entity with a new version of the same component
+func (c *Controller) UpdateComponent(entity int, componentType reflect.Type, newComponent Component) int {
+	// First, remove the component in question (Don't actually update things, but rather remove and replace)
+	c.RemoveComponent(entity, componentType)
+
+	// Next, replace the removed component with the updated one
+	c.AddComponent(entity, newComponent)
+
+	return entity
+}
+
+// DeleteComponent will delete a component instance from an entity, based on component type. It will also remove the
+// association between the component and the entity, and remove the component from the processor completely if no
+// other entities are using it.
+func (c *Controller) RemoveComponent(entity int, componentType reflect.Type) int {
+	// Find the index of the entity to operate on in the components slice
+	index := -1
+	for i, v := range c.components[componentType] {
+		if (v == entity) {
+			index = i
+		}
+	}
+
+	// If the component was found on the entity, remove the association between the component and the entity
+	if index != -1 {
+		c.components[componentType] = append(c.components[componentType][:index], c.components[componentType][index+1:]...)
+		// If this was the last entity associated with the component, remove the component entry as well
+		if len(c.components[componentType]) == 0 {
+			delete(c.components, componentType)
+		}
+	}
+
+	// Now, remove the component instance from the entity
+	delete(c.entities[entity], componentType)
+
+	return entity
+}
+
+
+// AddSystem registers a system to the controller. A priority can be provided, and systems will be processed in
+// numeric order, low to high. If multiple systems are registered as the same priority, they will be randomly run within
+// that priority group.
+func (c *Controller) AddSystem(system System, priority int) {
+	systemType := reflect.TypeOf(system)
+
+	if _, ok := c.systems[systemType]; !ok {
+		// A system of this type has not been added yet, so add it to the systems list
+		c.systems[systemType] = system
+
+		// Now, append the system to a special list that will be used for sorting by priority
+		if !IntInSlice(priority, c.priorityKeys) {
+			c.priorityKeys = append(c.priorityKeys, priority)
+		}
+		c.sortedSystems[priority] = append(c.sortedSystems[priority], system)
+		sort.Ints(c.priorityKeys)
+	} else {
+		fmt.Printf("A system of type %v was already added to the controller %v!", systemType, c)
+	}
+}
+
+// Process kicks off system processing for all systems attached to the controller. Systems will be processed in the
+// order they are found, or if they have a priority, in priority order. If there is a mix of systems with priority and
+// without, systems with priority will be processed first (in order).
+func (c *Controller) Process(excludedSystems []reflect.Type) {
+	for _, key := range c.priorityKeys {
+		for _, system := range c.sortedSystems[key] {
+			systemType := reflect.TypeOf(system)
+
+			// Check if the current system type was marked as excluded on this call. If it was, not process it.
+			if !TypeInSlice(systemType, excludedSystems) {
+				system.Process()
+			}
+		}
+	}
+}
+
+// HasSystem checks the controller to see if it has a given system associated with it
+func (c *Controller) HasSystem(systemType reflect.Type) bool {
+	if _, ok := c.systems[systemType]; ok {
+		return true
+	} else {
+		return false
+	}
+}
+
+// ProcessSystem allows for on demand processing of individual systems, rather than processing all at once via Process
+func (c *Controller) ProcessSystem(systemType reflect.Type) {
+	if c.HasSystem(systemType) {
+		system := c.systems[systemType]
+		system.Process()
+	}
+}
+
+
diff --git a/engine/ecs/entity.go b/engine/ecs/entity.go
index 636470c..34baf22 100644
--- a/engine/ecs/entity.go
+++ b/engine/ecs/entity.go
@@ -1,3 +1,9 @@
 package ecs
 
+// ECS system by jcerise, github.com/jcerise/gogue
+
 type Entity int
+
+func (e *Entity) HasComponent(c Component) bool {
+	return true
+}
\ No newline at end of file
diff --git a/engine/ecs/system.go b/engine/ecs/system.go
new file mode 100644
index 0000000..3e8d48d
--- /dev/null
+++ b/engine/ecs/system.go
@@ -0,0 +1,7 @@
+package ecs
+
+// ECS system by jcerise, github.com/jcerise/gogue
+
+type System interface {
+	Process()
+}
diff --git a/engine/ecs/systemMessages.go b/engine/ecs/systemMessages.go
new file mode 100644
index 0000000..580321d
--- /dev/null
+++ b/engine/ecs/systemMessages.go
@@ -0,0 +1,87 @@
+package ecs
+
+type SystemMessageType struct {
+	Name string
+}
+
+type SystemMessage struct {
+	MessageType SystemMessageType
+	Originator System
+	MessageContent map[string]string
+}
+
+// SystemMessageQueue is a super simple way of messaging between systems. Essentially, it is nothing more than a list of
+// messages. Each message has a type, and an originator. Each system can "subscribe" to a type of message, which
+// basically just means that it will check the queue for any messages of that type before it does anything else.
+// Messages can contain a map of information, which each system that creates messages of that type, and those that
+// subscribe to it should know how to handle any information contained in the message. Ideally, the message queue will
+// be cleared out occasionally, either by the subscribing systems, or the game loop. Pretty simple for now, but should
+// solve a subset of problems nicely.
+type SystemMessageQueue struct {
+	Messages map[System][]SystemMessage
+	Subscriptions map[System][]SystemMessageType
+}
+
+func InitializeSystemMessageQueue() *SystemMessageQueue {
+	smq := SystemMessageQueue{}
+	smq.Messages = make(map[System][]SystemMessage)
+	smq.Subscriptions = make(map[System][]SystemMessageType)
+	return &smq
+}
+
+// BroadcastMessage appends a system message onto the games SystemMessageQueue, allowing it to consumed by a service
+// subscribes to the MessageType.
+func (smq *SystemMessageQueue) BroadcastMessage(messageType SystemMessageType, messageContent map[string]string, originator System) {
+	newMessage := SystemMessage{MessageType: messageType, MessageContent: messageContent, Originator: originator}
+
+	// Find all subscriptions to this message type, and add this message to the subscribers message queue
+	for subscribedSystem, typeList := range smq.Subscriptions {
+		if MessageTypeInSlice(messageType, typeList) {
+			smq.Messages[subscribedSystem] = append(smq.Messages[subscribedSystem], newMessage)
+		}
+	}
+}
+
+// GetSubscribedMessages returns a list of SystemMessages that have messageType. Can return an empty list
+func (smq *SystemMessageQueue) GetSubscribedMessages(system System) []SystemMessage {
+	messages := []SystemMessage{}
+
+	for _, message := range smq.Messages[system] {
+		messages = append(messages, message)
+	}
+
+	return messages
+}
+
+// DeleteMessages deletes a processed message from the queue (for example, if the event has been processed)
+func (smq *SystemMessageQueue) DeleteMessages(messageName string, system System) {
+	modifiedQueue := smq.Messages[system]
+	for index, message := range smq.Messages[system] {
+		if message.MessageType.Name == messageName {
+			modifiedQueue[index] = modifiedQueue[len(modifiedQueue)-1]
+			modifiedQueue = modifiedQueue[:len(modifiedQueue)-1]
+		}
+	}
+
+	smq.Messages[system] = modifiedQueue
+}
+
+//MessageTypeInSlice will return true if the MessageType provided is present in the slice provided, false otherwise
+func MessageTypeInSlice(a SystemMessageType, list []SystemMessageType) bool {
+	for _, b := range list {
+		if b == a {
+			return true
+		}
+	}
+	return false
+}
+
+//MessageTypeInSliceOfMessages will return true if the MessageType provided is present in the slice provided, false otherwise
+func MessageTypeInSliceOfMessages(a SystemMessageType, list []SystemMessage) bool {
+	for _, b := range list {
+		if b.MessageType == a {
+			return true
+		}
+	}
+	return false
+}
diff --git a/engine/ecs/util.go b/engine/ecs/util.go
new file mode 100644
index 0000000..8b077a9
--- /dev/null
+++ b/engine/ecs/util.go
@@ -0,0 +1,25 @@
+package ecs
+
+// ECS system by jcerise, github.com/jcerise/gogue
+
+import "reflect"
+
+// IntInSlice will return true if the integer value provided is present in the slice provided, false otherwise.
+func IntInSlice(a int, list []int) bool {
+	for _, b := range list {
+		if b == a {
+			return true
+		}
+	}
+	return false
+}
+
+// TypeInSlice will return true if the reflect.Type provided is present in the slice provided, false otherwise.
+func TypeInSlice(a reflect.Type, list []reflect.Type) bool {
+	for _, b := range list {
+		if b == a {
+			return true
+		}
+	}
+	return false
+}
diff --git a/engine/gamemap/level.go b/engine/gamemap/level.go
index 373c09b..c05f10d 100644
--- a/engine/gamemap/level.go
+++ b/engine/gamemap/level.go
@@ -17,7 +17,7 @@ type Level struct {
 	Name     string
 	Branch   string
 	Depth    int
-	Objects  []ecs.Entity
+	Objects  *[]ecs.Entity
 	Tiles    []*Tile
 }
 
diff --git a/engine/mob/mob.go b/engine/mob/mob.go
index 309ffbb..8a93082 100644
--- a/engine/mob/mob.go
+++ b/engine/mob/mob.go
@@ -2,7 +2,9 @@ package mob
 
 import (
 	"fmt"
+	"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
 	"lab.zaar.be/thefish/alchemyst-go/engine/types"
+	"reflect"
 )
 
 type Mob struct {
@@ -11,8 +13,14 @@ type Mob struct {
 	BlocksPass bool
 }
 
-func (m *Mob) Walk(dx, dy int) {
-	m.Coords = types.Coords{m.X + dx, m.Y + dy}
+func (m *Mob) Walk(level *gamemap.Level, dx, dy int) {
+	newCoords := types.Coords{m.X + dx, m.Y + dy}
+	if level.GetTile(newCoords).BlocksPass {
+		return
+	}
+	if level.Objects.At(newCoords).HasComponent("block_pass") {
+
+	}
 	fmt.Printf("new coords: %d, %d\n", m.Coords.X, m.Coords.Y)
 }
 
@@ -22,4 +30,8 @@ func (m *Mob) Render() {
 
 func (m *Mob) MoveToCoords(c types.Coords) {
 
+}
+
+func (mob Mob) TypeOf() reflect.Type {
+	return reflect.TypeOf(mob)
 }
\ No newline at end of file
diff --git a/engine/mob/mob_render_system.go b/engine/mob/mob_render_system.go
new file mode 100644
index 0000000..47a4918
--- /dev/null
+++ b/engine/mob/mob_render_system.go
@@ -0,0 +1,29 @@
+package mob
+
+import (
+	"lab.zaar.be/thefish/alchemyst-go/engine/ecs"
+	"lab.zaar.be/thefish/alchemyst-go/engine/types"
+)
+
+type MobRenderSystem struct {
+	EntityController *ecs.Controller
+}
+
+func (mrs MobRenderSystem) Process(){
+	for e := range mrs.EntityController.GetEntities() {
+		if mrs.EntityController.HasComponent(e, types.Coords{}.TypeOf()) &&
+			mrs.EntityController.HasComponent(e, types.Appearance{}.TypeOf()) {
+
+			pos := mrs.EntityController.GetComponent(e, types.Coords{}.TypeOf()).(types.Coords)
+			appearance := mrs.EntityController.GetComponent(e, types.Appearance{}.TypeOf()).(types.Appearance)
+
+			// Clear the cell this entity occupies, so it is the only glyph drawn there
+			for i := 0; i <= 2; i++ {
+				//fixme
+				gogue.ClearArea(pos.X, pos.Y, 1, 1, i)
+			}
+			//fixme
+			gogue.PrintGlyph(pos.X, pos.Y, appearance.Glyph, "", appearance.Layer)
+		}
+	}
+}
\ No newline at end of file
diff --git a/engine/screens/game.go b/engine/screens/game.go
index a91f5e0..b8c6886 100644
--- a/engine/screens/game.go
+++ b/engine/screens/game.go
@@ -21,28 +21,28 @@ func (ts *GameScreen) HandleInput(input string) {
 	//ts.state.Do(func(){
 	switch input {
 	case "Up", "k", "8":
-		ts.state.Player.Walk(0, -1)
+		ts.state.Player.Walk(ts.state.Level, 0, -1)
 		break
 	case "Down", "j", "2":
-		ts.state.Player.Walk(0, 1)
+		ts.state.Player.Walk(ts.state.Level,0, 1)
 		break
 	case "Left", "h", "4":
-		ts.state.Player.Walk(-1, 0)
+		ts.state.Player.Walk(ts.state.Level,-1, 0)
 		break
 	case "Right", "l", "6":
-		ts.state.Player.Walk(1, 0)
+		ts.state.Player.Walk(ts.state.Level,1, 0)
 		break
 	case "y", "7":
-		ts.state.Player.Walk(-1, -1)
+		ts.state.Player.Walk(ts.state.Level,-1, -1)
 		break
 	case "u", "9":
-		ts.state.Player.Walk(1, -1)
+		ts.state.Player.Walk(ts.state.Level,1, -1)
 		break
 	case "b", "1":
-		ts.state.Player.Walk(-1, 1)
+		ts.state.Player.Walk(ts.state.Level,-1, 1)
 		break
 	case "n", "3":
-		ts.state.Player.Walk(1, 1)
+		ts.state.Player.Walk(ts.state.Level,1, 1)
 		break
 	default:
 		ts.mw.GetLayer("base").ClearArea(0, 3, 40, 1)
diff --git a/engine/types/appearance.go b/engine/types/appearance.go
index d61e397..f3d921a 100644
--- a/engine/types/appearance.go
+++ b/engine/types/appearance.go
@@ -3,6 +3,7 @@ package types
 import (
 	"github.com/gammazero/deque"
 	"lab.zaar.be/thefish/alchemyst-go/util"
+	"reflect"
 )
 import blt "lab.zaar.be/thefish/bearlibterminal"
 
@@ -78,7 +79,6 @@ type Appearance struct {
 	ColorSet *TileColorSet `json:"colorSet"`
 }
 
-
 func SingleColorRing(colorValue uint8) *cdeque {
 	c := &cdeque{}
 	c.PushBack(colorValue)
@@ -104,4 +104,8 @@ func FillColorRing(colorValue uint8, minGlow, maxGlow, step int) *cdeque {
 		c.PushBack(uint8(v))
 	}
 	return c
+}
+
+func (app Appearance) TypeOf() reflect.Type {
+	return reflect.TypeOf(app)
 }
\ No newline at end of file
diff --git a/engine/types/coords.go b/engine/types/coords.go
index 74e943e..d7d5923 100644
--- a/engine/types/coords.go
+++ b/engine/types/coords.go
@@ -1,11 +1,18 @@
 package types
 
-import "math"
+import (
+	"math"
+	"reflect"
+)
 
 type Coords struct {
 	X, Y int
 }
 
+func (сс Coords) TypeOf() reflect.Type {
+	return reflect.TypeOf(сс)
+}
+
 func (c *Coords) Get() (int, int) {
 	return c.X, c.Y
 }