updates

engine/ecs/entity.go

@@ -0,0 +1,5 @@
+package ecs
+
+type Entity struct {
+	ID int
+}

engine/fov/fov.go

@@ -0,0 +1,88 @@
+package fov
+
+import (
+	"github.com/jcerise/gogue/gamemap"
+	"math"
+)
+
+type FieldOfVision struct {
+	cosTable    map[int]float64
+	sinTable    map[int]float64
+	torchRadius int
+}
+
+func (f *FieldOfVision) Initialize() {
+
+	f.cosTable = make(map[int]float64)
+	f.sinTable = make(map[int]float64)
+
+	for i := 0; i < 360; i++ {
+		ax := math.Sin(float64(i) / (float64(180) / math.Pi))
+		ay := math.Cos(float64(i) / (float64(180) / math.Pi))
+
+		f.sinTable[i] = ax
+		f.cosTable[i] = ay
+	}
+}
+
+func (f *FieldOfVision) SetTorchRadius(radius int) {
+	if radius > 1 {
+		f.torchRadius = radius
+	}
+}
+
+func (f *FieldOfVision) SetAllInvisible(gameMap *gamemap.Map) {
+	for x := 0; x < gameMap.Width; x++ {
+		for y := 0; y < gameMap.Height; y++ {
+			gameMap.Tiles[x][y].Visible = false
+		}
+	}
+}
+
+func (f *FieldOfVision) RayCast(playerX, playerY int, gameMap *gamemap.Map) {
+	// Cast out rays each degree in a 360 circle from the player. If a ray passes over a floor (does not block sight)
+	// tile, keep going, up to the maximum torch radius (view radius) of the player. If the ray intersects a wall
+	// (blocks sight), stop, as the player will not be able to see past that. Every visible tile will get the Visible
+	// and Explored properties set to true.
+
+	for i := 0; i < 360; i++ {
+
+		ax := f.sinTable[i]
+		ay := f.cosTable[i]
+
+		x := float64(playerX)
+		y := float64(playerY)
+
+		// Mark the players current position as explored
+		tile := gameMap.Tiles[playerX][playerY]
+		tile.Explored = true
+		tile.Visible = true
+
+		for j := 0; j < f.torchRadius; j++ {
+			x -= ax
+			y -= ay
+
+			roundedX := int(Round(x))
+			roundedY := int(Round(y))
+
+			if x < 0 || x > float64(gameMap.Width-1) || y < 0 || y > float64(gameMap.Height-1) {
+				// If the ray is cast outside of the gamemap, stop
+				break
+			}
+
+			tile := gameMap.Tiles[roundedX][roundedY]
+
+			tile.Explored = true
+			tile.Visible = true
+
+			if gameMap.Tiles[roundedX][roundedY].BlocksSight == true {
+				// The ray hit a wall, go no further
+				break
+			}
+		}
+	}
+}
+
+func Round(f float64) float64 {
+	return math.Floor(f + .5)
+}

engine/gamemap/level.go

@@ -0,0 +1,14 @@
+package gamemap
+
+import "lab.zaar.be/thefish/alchemyst-go/engine/ecs"
+
+type Level struct {
+	Name string
+	Branch string
+	Depth int
+	MaxRooms int
+	Width int
+	Height int
+	Objects []ecs.Entity
+	Tiles [][]*Tile
+}

engine/gamemap/mapgen.go

@@ -0,0 +1,20 @@
+package gamemap
+
+type mapGen interface {
+	generate(l *Level) *Level
+}
+
+type defaultGen struct {}
+
+func (d defaultGen) generate(l *Level) *Level {
+
+	l.Tiles, rooms = addRooms(l)
+	l. Tiles = connectRooms(rooms)
+	l.Objects = populate(rooms)
+
+	return l
+}
+
+func addRooms(l *Level) {
+
+}

engine/gamemap/tile.go

@@ -0,0 +1,143 @@
+package gamemap
+
+import "lab.zaar.be/thefish/alchemyst-go/util"
+import blt "lab.zaar.be/thefish/bearlibterminal"
+
+type ColorHolder struct {
+	R uint8
+	G uint8
+	B uint8
+}
+
+type TileColorSet struct {
+	Fg     func() uint32
+	Bg     func() uint32
+	DarkFg func() uint32
+	DarkBg func() uint32
+	current *ColorHolder
+}
+
+type Appearance struct {
+	Char  string
+	ColorSet *TileColorSet
+}
+
+var crng = util.NewRNG()
+
+func colordance(colorValue uint8, minGlow, maxGlow, step int) uint8 {
+	color := crng.Range(0, step) + int(colorValue)
+	if color > maxGlow {
+		color = crng.Range(0, step) + minGlow
+	}
+	return uint8(color)
+}
+
+type Tile struct {
+	*Appearance
+	Name string
+	Description string
+	BlocksPass bool
+	BlocksSight bool
+	Explored bool
+	MustDraw bool
+}
+
+
+func NewWall() *Tile {
+	return &Tile{
+		Name: "Wall",
+		Description: "A dull rock wall",
+		BlocksPass: true,
+		BlocksSight: true,
+		Explored: false,
+		MustDraw: false,
+		Appearance: &Appearance{
+			Char: "#",
+			ColorSet: &TileColorSet{
+				Fg: func() uint32 {return blt.ColorFromARGB(255, 130,110,150)},
+				Bg: func() uint32 {return blt.ColorFromARGB(255, 172,170,173)},
+				DarkFg: func() uint32 {return blt.ColorFromARGB(255, 20,20,68)},
+				DarkBg: func() uint32 {return blt.ColorFromARGB(255, 7,7,30)},
+			},
+		},
+	}
+}
+
+func NewFloor() *Tile {
+	return &Tile{
+		Name: "Floor",
+		Description: "Dusty rock floor",
+		BlocksPass: false,
+		BlocksSight: false,
+		Explored: false,
+		MustDraw: false,
+		Appearance: &Appearance{
+			Char: ".",
+			ColorSet: &TileColorSet{
+				Fg: func() uint32 {return blt.ColorFromARGB(255, 220,220,250)},
+				Bg: func() uint32 {return blt.ColorFromARGB(255, 19,19,70)},
+				DarkFg: func() uint32 {return blt.ColorFromARGB(255, 30,20,50)},
+				DarkBg: func() uint32 {return blt.ColorFromARGB(255, 7,7,30)},
+			},
+		},
+	}
+}
+
+func NewWaterTile() *Tile {
+	ch := &ColorHolder{19,19,70}
+	return &Tile {
+		Name: "Water",
+		Description: "Murky water",
+		BlocksPass: false,
+		BlocksSight: false,
+		Explored: false,
+		MustDraw: true, //fixme debug
+		Appearance: &Appearance{
+			Char: ".",
+			ColorSet: &TileColorSet{
+				current: ch,
+				Fg: func() uint32 {return blt.ColorFromARGB(255, 220,220,250)},
+				Bg: func() uint32 {
+					return blt.ColorFromARGB(
+						255,
+						ch.R,
+						colordance(ch.G, 2, 42, 4 ),
+						colordance(ch.B, 180,229,12),
+					)
+				},
+				DarkFg: func() uint32 {return blt.ColorFromARGB(255, 30,20,50)},
+				DarkBg: func() uint32 {return blt.ColorFromARGB(255, 7,7,30)},
+			},
+		},
+	}
+}
+
+func NewDeepWaterTile() *Tile {
+	ch := &ColorHolder{5,2,154}
+	return &Tile {
+		Name: "Deep Water",
+		Description: "Deep water",
+		BlocksPass: false,
+		BlocksSight: false,
+		Explored: false,
+		MustDraw: true, //fixme debug
+		Appearance: &Appearance{
+			Char: " ",
+			ColorSet: &TileColorSet{
+				current: ch,
+				Fg: func() uint32 {return blt.ColorFromARGB(255, 220,220,250)},
+				Bg: func() uint32 {
+					return blt.ColorFromARGB(
+						255,
+						ch.R,
+						colordance(ch.G, 0, 15, 2 ),
+						colordance(ch.B, 120,180,5),
+					)
+				},
+				DarkFg: func() uint32 {return blt.ColorFromARGB(255, 30,20,50)},
+				DarkBg: func() uint32 {return blt.ColorFromARGB(255, 7,7,30)},
+			},
+		},
+	}
+}
+

engine/gamemap/types.go

@@ -0,0 +1,5 @@
+package gamemap
+
+type Coords struct {
+	x,y int
+}

main.go

@@ -59,7 +59,6 @@ func main() {
 
 	}
 	mainCtx.Logger().Info().Msg("pre-shutdown sequence")
-
 }
 
 // do runs f on the main thread.

ui/mainwindow/camera.go

@@ -0,0 +1,43 @@
+package mainwindow
+
+type GameCamera struct {
+	X      int
+	Y      int
+	Width  int
+	Height int
+}
+
+func (c *GameCamera) MoveCamera(targetX int, targetY int, mapWidth int, mapHeight int) {
+	// Update the camera coordinates to the target coordinates
+	x := targetX - c.Width/2
+	y := targetY - c.Height/2
+
+	if x < 0 {
+		x = 0
+	}
+
+	if y < 0 {
+		y = 0
+	}
+
+	if x > mapWidth - c.Width {
+		x = mapWidth - c.Width
+	}
+
+	if y > mapHeight - c.Height {
+		y = mapHeight - c.Height
+	}
+
+	c.X, c.Y = x, y
+}
+
+func (c *GameCamera) ToCameraCoordinates(mapX int, mapY int) (cameraX int, cameraY int) {
+	// Convert coordinates on the gamemap, to coordinates on the viewport
+	x, y := mapX-c.X, mapY-c.Y
+
+	if x < 0 || y < 0 || x >= c.Width || y >= c.Height {
+		return -1, -1
+	}
+
+	return x, y
+}

ui/mainwindow/console.go

@@ -1,12 +0,0 @@
-package mainwindow
-
-//Console is a pair of layers (BG and FG) used to render something
-// All because of lack of background colors in libbearterminal
-
-type Console struct {
-	x,y,w,h int
-	FgLayer *Layer
-	BgLayer *Layer
-}
-
-func NewConsole

ui/mainwindow/window.go

@@ -26,6 +26,7 @@ func (mw *MainWindow) Open() {
 		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'",
 			config.MainWindowSizeX,
 			config.MainWindowSizeY,
 			config.Title,

util/rng.go

@@ -0,0 +1,94 @@
+package util
+
+import (
+	"math"
+	"math/rand"
+	"time"
+)
+
+type RNG struct {
+	seed int64
+	rand *rand.Rand
+}
+
+func NewRNG() *RNG {
+	rng := RNG{}
+
+	// Set the seed to the current time. This can be updated later by the user.
+	rng.seed = time.Now().UTC().UnixNano()
+	rng.rand = rand.New(rand.NewSource(rng.seed))
+
+	return &rng
+}
+
+func (rng *RNG) GetSeed() int64 {
+	return rng.seed
+}
+
+func (rng *RNG) SetSeed(seed int64) {
+	rng.seed = seed
+}
+
+func (rng *RNG) Uniform() float64 {
+	return rng.rand.Float64()
+}
+
+func (rng *RNG) UniformRange(a, b float64) float64 {
+	return a + rng.Uniform() * (b - a)
+}
+
+func (rng *RNG) Normal(mean, stddev float64) float64 {
+
+	var r, x float64
+
+	for r >= 1 || r == 0 {
+		x = rng.UniformRange(-1.0, 1.0)
+		y := rng.UniformRange(-1.0, 1.0)
+		r = x*x + y*y
+	}
+
+	result := x * math.Sqrt(-2 * math.Log(r) / r)
+
+	return mean + stddev * result
+
+}
+
+func (rng *RNG) Percentage() int {
+	return rng.rand.Intn(100)
+}
+
+func (rng *RNG) Range(min, max int) int {
+	if min == max {
+		return min
+	} else {
+		return rng.rand.Intn(max - min) + min
+	}
+}
+
+func (rng *RNG) RangeNegative(min, max int) int {
+	if min == max {
+		return min
+	} else {
+		return rng.rand.Intn(max - min + 1) + min
+	}
+}
+
+func (rng *RNG) GetWeightedEntity(values map[int]int) int {
+	// First up, get the total weight value from the gamemap
+	totalWeight := 0
+	for weight := range values {
+		totalWeight += weight
+	}
+
+	// Next, get a random integer in the range of the total weight
+	r := rng.Range(0, totalWeight)
+
+	for weight, value := range values {
+		r -= value
+		if r <= 0 {
+			return weight
+		}
+	}
+
+	return -1
+}