thefish/alchemyst
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

diagnostic tool fixes

Browse Source
This commit is contained in:
thefish 2024-04-22 13:52:17 +03:00
parent 4f18b6db18
commit dc2e6ea2b5
20 changed files with 178 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.envrc Normal file
View File

@ -0,0 +1 @@
GOPROXY="direct"

4
cmd/game/main.go
View File

@ -192,9 +192,9 @@ func main() {
potion2 := controller.CreateEntity([]ecs.Component{}) potion2 := controller.CreateEntity([]ecs.Component{})
controller.AddComponent(potion2, types.Appearance{ controller.AddComponent(potion2, types.Appearance{
Glyph: types.PlainGlyphHolder{"!"}, Glyph: types.PlainGlyphHolder{Glyph: "!"},
ColorSet: types.TileColorSet{ ColorSet: types.TileColorSet{
Fg: types.PlainColorHolder{255, 222, 255, 55}, Fg: types.PlainColorHolder{A: 255, R: 222, G: 255, B: 55},
}, },
}) })
controller.AddComponent(potion2, rooms[1].Center) //implicit Coords controller.AddComponent(potion2, rooms[1].Center) //implicit Coords

2
config.json
View File

@ -1,5 +1,5 @@
{ {
"version": "v0.0.1.7-16-gbf13c9c", "version": "v0.0.1.7-29-g4f18b6d",
"title": "Alchemyst", "title": "Alchemyst",
"sizeX": 100, "sizeX": 100,
"sizeY": 47, "sizeY": 47,

6
engine/fov/precomputed_permissive/precomputed_permissive.go
View File

@ -62,7 +62,7 @@ func (pp *precomputedPermissive) ComputeFov(coords types.Coords, radius int) {
func (pp *precomputedPermissive) PrecomputeFovMap() { func (pp *precomputedPermissive) PrecomputeFovMap() {
max := pp.MaxTorchRadius max := pp.MaxTorchRadius
minusMax := (-1) * max minusMax := (-1) * max
zeroCoords := types.Coords{0, 0} zeroCoords := types.Coords{X: 0, Y: 0}
var x, y int var x, y int
//fill list //fill list
for x = minusMax; x < max+1; x++ { for x = minusMax; x < max+1; x++ {
@ -70,7 +70,7 @@ func (pp *precomputedPermissive) PrecomputeFovMap() {
if x == 0 && y == 0 { if x == 0 && y == 0 {
continue; continue;
} }
iterCoords := types.Coords{x, y} iterCoords := types.Coords{X: x, Y: y}
distance := zeroCoords.DistanceTo(iterCoords) distance := zeroCoords.DistanceTo(iterCoords)
if distance <= float64(max) { if distance <= float64(max) {
pp.CellList = append(pp.CellList, &Cell{iterCoords, distance, nil}) pp.CellList = append(pp.CellList, &Cell{iterCoords, distance, nil})
@ -101,7 +101,7 @@ func (pp *precomputedPermissive) PrecomputeFovMap() {
roundedX := int(basic.Round(lineX)) roundedX := int(basic.Round(lineX))
roundedY := int(basic.Round(lineY)) roundedY := int(basic.Round(lineY))
idx, cell, err := pp.FindByCoords(types.Coords{roundedX, roundedY}) idx, cell, err := pp.FindByCoords(types.Coords{X: roundedX, Y: roundedY})
if err != nil { if err != nil {
//inexistent coord found //inexistent coord found
break; break;

12
engine/fov/precomputed_shade/precomputed_shade_test.go
View File

@ -8,12 +8,12 @@ import (
) )
func TestPsDistance(t *testing.T) { func TestPsDistance(t *testing.T) {
iterCoords := types.Coords{0, 0} iterCoords := types.Coords{X: 0, Y: 0}
fmt.Printf("\n dto: \t %v", iterCoords.DistanceTo(types.Coords{0, 1})) fmt.Printf("\n dto: \t %v", iterCoords.DistanceTo(types.Coords{X: 0, Y: 1}))
fmt.Printf("\n dto: \t %v", iterCoords.DistanceTo(types.Coords{0, 5})) fmt.Printf("\n dto: \t %v", iterCoords.DistanceTo(types.Coords{X: 0, Y: 5}))
fmt.Printf("\n dto: \t %v", iterCoords.DistanceTo(types.Coords{3, 3})) fmt.Printf("\n dto: \t %v", iterCoords.DistanceTo(types.Coords{X: 3, Y: 3}))
fmt.Printf("\n dto: \t %v", iterCoords.DistanceTo(types.Coords{100, 0})) fmt.Printf("\n dto: \t %v", iterCoords.DistanceTo(types.Coords{X: 100, Y: 0}))
} }
func TestPrecompShade(t *testing.T) { func TestPrecompShade(t *testing.T) {
@ -44,7 +44,7 @@ func TestPrecompShade(t *testing.T) {
} }
} }
playerCoords := types.Coords{10, 10} playerCoords := types.Coords{X: 10, Y: 10}
level.SetTileByXY(8, 12, gamemap.NewWall()) level.SetTileByXY(8, 12, gamemap.NewWall())
level.SetTileByXY(10, 8, gamemap.NewWall()) level.SetTileByXY(10, 8, gamemap.NewWall())

12
engine/gamemap/level.go
View File

@ -1,6 +1,8 @@
package gamemap package gamemap
import ( import (
"fmt"
"lab.zaar.be/thefish/alchemyst-go/engine/ecs" "lab.zaar.be/thefish/alchemyst-go/engine/ecs"
"lab.zaar.be/thefish/alchemyst-go/engine/types" "lab.zaar.be/thefish/alchemyst-go/engine/types"
"lab.zaar.be/thefish/alchemyst-go/util/appctx" "lab.zaar.be/thefish/alchemyst-go/util/appctx"
@ -28,7 +30,7 @@ func (l *Level) GetTileNbs (coords types.Coords) []*Tile {
result := make([]*Tile,0) result := make([]*Tile,0)
for i := coords.X-1; i < coords.X+1; i++ { for i := coords.X-1; i < coords.X+1; i++ {
for j := coords.Y-1; j < coords.Y+1; j++ { for j := coords.Y-1; j < coords.Y+1; j++ {
nbc := types.Coords{i,j} nbc := types.Coords{X: i,Y: j}
if l.InBounds(nbc){ if l.InBounds(nbc){
if nbc == coords { if nbc == coords {
continue continue
@ -66,14 +68,14 @@ func (l *Level) Put (x, y int, tileFunc interface{}) {
if tile == nil { if tile == nil {
appctx.Logger().Fatal().Msgf("Got non-tile type to put into level: %v", tile) appctx.Logger().Fatal().Msgf("Got non-tile type to put into level: %v", tile)
} }
if l.InBounds(types.Coords{x, y}) { if l.InBounds(types.Coords{X: x, Y: y}) {
l.Tiles[y*l.W+x] = tile l.Tiles[y*l.W+x] = tile
} }
} }
func NewLevel(branch string, depth int) *Level { func NewLevel(branch string, depth int) *Level {
l := &Level{ l := &Level{
Name: branch + string(depth), Name: fmt.Sprintf(branch, depth),
Depth: depth, Depth: depth,
Rect: types.NewRect(0,0, mapWidth, mapHeight), Rect: types.NewRect(0,0, mapWidth, mapHeight),
} }
@ -84,13 +86,13 @@ func NewLevel(branch string, depth int) *Level {
} }
func (l *Level) SetAllInvisible() { func (l *Level) SetAllInvisible() {
for idx, _ := range l.Tiles { for idx := range l.Tiles {
l.Tiles[idx].Visible = false l.Tiles[idx].Visible = false
} }
} }
func (l *Level) SetAllVisible() { func (l *Level) SetAllVisible() {
for idx, _ := range l.Tiles { for idx := range l.Tiles {
l.Tiles[idx].Visible = true l.Tiles[idx].Visible = true
} }
} }

35
engine/gamemap/mapgens/common.go
View File

@ -13,7 +13,7 @@ var maxRoomSize = 22
var maxrooms = 100 var maxrooms = 100
var fges = map[int]types.RectFill{ var fges = map[int]types.RectFill{
1: types.RectFill{ 1: {
Top: gamemap.NewWall, Top: gamemap.NewWall,
Bottom: gamemap.NewWall, Bottom: gamemap.NewWall,
Left: gamemap.NewWall, Left: gamemap.NewWall,
@ -25,7 +25,7 @@ var fges = map[int]types.RectFill{
Body: gamemap.NewFloor, Body: gamemap.NewFloor,
}, },
2: types.RectFill{ 2: {
Top: gamemap.NewWaterTile, Top: gamemap.NewWaterTile,
Bottom: gamemap.NewWaterTile, Bottom: gamemap.NewWaterTile,
Left: gamemap.NewWaterTile, Left: gamemap.NewWaterTile,
@ -53,7 +53,14 @@ func GetRandomRoomList(rng *util.RNG, l *gamemap.Level, maxRooms, minRoomSize, m
var newRoom = gamemap.Room{} var newRoom = gamemap.Room{}
if !prefabUsed || rng.Range(0, 5) > 3 { if prefabUsed && rng.Range(0, 5) <= 3 {
newRoom = gamemap.NewRandomRectRoom(
rng,
rng.Range(minRoomSize, maxRoomSize),
rng.Range(minRoomSize, maxRoomSize),
fillage,
)
} else {
//if prefabUsed { //if prefabUsed {
//prefab //prefab
prefabUsed = true prefabUsed = true
@ -67,20 +74,14 @@ func GetRandomRoomList(rng *util.RNG, l *gamemap.Level, maxRooms, minRoomSize, m
Mobs: r.Mobs, Mobs: r.Mobs,
Connectors: make([]types.Coords,0), Connectors: make([]types.Coords,0),
} }
for _, coord := range r.Connectors { newRoom.Connectors = append(newRoom.Connectors, r.Connectors...)
newRoom.Connectors = append(newRoom.Connectors, coord) // for _, coord := range r.Connectors {
} // newRoom.Connectors = append(newRoom.Connectors, coord)
} else { // }
newRoom = gamemap.NewRandomRectRoom(
rng,
rng.Range(minRoomSize, maxRoomSize),
rng.Range(minRoomSize, maxRoomSize),
fillage,
)
} }
where := types.Coords{ where := types.Coords{
rng.Range(1, l.W-2-newRoom.W), X: rng.Range(1, l.W-2-newRoom.W),
rng.Range(1, l.H-2-newRoom.H), Y: rng.Range(1, l.H-2-newRoom.H),
} }
newRoom.MoveToCoords(where) newRoom.MoveToCoords(where)
@ -172,7 +173,7 @@ func DigHTunnel(l *gamemap.Level, x1, x2, y int) {
finish = x1 finish = x1
} }
for i := start; i <= finish; i++ { for i := start; i <= finish; i++ {
if l.InBounds(types.Coords{i, y}) { if l.InBounds(types.Coords{X: i, Y: y}) {
l.MakePassByXY(i, y, gamemap.NewFloor()) l.MakePassByXY(i, y, gamemap.NewFloor())
//l.Tiles[i][y] = gamemap.NewFloor() //l.Tiles[i][y] = gamemap.NewFloor()
} }
@ -189,7 +190,7 @@ func DigVTunnel(l *gamemap.Level, y1, y2, x int) {
finish = y1 finish = y1
} }
for i := start; i <= finish; i++ { for i := start; i <= finish; i++ {
if l.InBounds(types.Coords{x, i}) { if l.InBounds(types.Coords{X: x, Y: i}) {
l.MakePassByXY(x, i, gamemap.NewFloor()) l.MakePassByXY(x, i, gamemap.NewFloor())
} }
} }

13
engine/gamemap/prefab.go
View File

@ -2,7 +2,8 @@ package gamemap
import ( import (
"encoding/json" "encoding/json"
"io/ioutil" "os"
"lab.zaar.be/thefish/alchemyst-go/engine/items" "lab.zaar.be/thefish/alchemyst-go/engine/items"
"lab.zaar.be/thefish/alchemyst-go/engine/mob" "lab.zaar.be/thefish/alchemyst-go/engine/mob"
"lab.zaar.be/thefish/alchemyst-go/engine/types" "lab.zaar.be/thefish/alchemyst-go/engine/types"
@ -29,7 +30,7 @@ type PrefabRecord struct {
} }
func LoadPrefabFile(filename string) (*PrefabFile, error) { func LoadPrefabFile(filename string) (*PrefabFile, error) {
data, err := ioutil.ReadFile(filename) data, err := os.ReadFile(filename)
if err!= nil { if err!= nil {
return nil, err return nil, err
} }
@ -62,6 +63,8 @@ func (pfbl PrefabLoader) PrefabRoomsList() []Room {
for _, rawPrefab := range file.Prefabs { for _, rawPrefab := range file.Prefabs {
appctx.Logger().Debug().Msgf("adding %s", rawPrefab.name)
for k,v := range rawPrefab.TileLegend { for k,v := range rawPrefab.TileLegend {
currentTileLegend[k] = v currentTileLegend[k] = v
} }
@ -73,8 +76,8 @@ func (pfbl PrefabLoader) PrefabRoomsList() []Room {
} }
room := Room{ room := Room{
Rect:types.Rect{0, 0, rawPrefab.Size.X, rawPrefab.Size.Y}, Rect:types.Rect{X: 0, Y: 0, W: rawPrefab.Size.X, H: rawPrefab.Size.Y},
Center: types.Coords{rawPrefab.Size.X / 2, rawPrefab.Size.Y / 2}, //fixme Center: types.Coords{X: rawPrefab.Size.X / 2, Y: rawPrefab.Size.Y / 2}, //fixme
Geometry: make([]func()*Tile, rawPrefab.Size.X*rawPrefab.Size.Y), Geometry: make([]func()*Tile, rawPrefab.Size.X*rawPrefab.Size.Y),
Mobs: make([]mob.Mob, rawPrefab.Size.X*rawPrefab.Size.Y), Mobs: make([]mob.Mob, rawPrefab.Size.X*rawPrefab.Size.Y),
Items: make([]items.Carried, rawPrefab.Size.X*rawPrefab.Size.Y), Items: make([]items.Carried, rawPrefab.Size.X*rawPrefab.Size.Y),
@ -99,7 +102,7 @@ func (pfbl PrefabLoader) PrefabRoomsList() []Room {
} }
if shortName == "connector" { if shortName == "connector" {
f = NewWall f = NewWall
room.Connectors = append(room.Connectors, types.Coords{i,j}) room.Connectors = append(room.Connectors, types.Coords{X: i,Y: j})
} else { } else {
f, ok = TileTypeMap[shortName] f, ok = TileTypeMap[shortName]
if (!ok) { if (!ok) {

19
engine/gamemap/room.go
View File

@ -3,12 +3,13 @@ package gamemap
import ( import (
"errors" "errors"
"fmt" "fmt"
"strings"
"lab.zaar.be/thefish/alchemyst-go/engine/items" "lab.zaar.be/thefish/alchemyst-go/engine/items"
"lab.zaar.be/thefish/alchemyst-go/engine/mob" "lab.zaar.be/thefish/alchemyst-go/engine/mob"
"lab.zaar.be/thefish/alchemyst-go/engine/types" "lab.zaar.be/thefish/alchemyst-go/engine/types"
"lab.zaar.be/thefish/alchemyst-go/util" "lab.zaar.be/thefish/alchemyst-go/util"
"lab.zaar.be/thefish/alchemyst-go/util/appctx" "lab.zaar.be/thefish/alchemyst-go/util/appctx"
"strings"
) )
var invalidBlit = errors.New("trying to blit on existing good tile") var invalidBlit = errors.New("trying to blit on existing good tile")
@ -27,7 +28,7 @@ func (r *Room) Put (x, y int, tileFunc interface{}) {
if tf == nil { if tf == nil {
return //fixme error return //fixme error
} }
if r.InBounds(types.Coords{x, y}) { if r.InBounds(types.Coords{X: x, Y: y}) {
r.Geometry[x+y*r.W] = tf r.Geometry[x+y*r.W] = tf
} }
} }
@ -39,7 +40,7 @@ func (room *Room) BlitToLevel(l *Level) error {
for j := 0; j < room.H; j++ { for j := 0; j < room.H; j++ {
for i := 0; i < room.W; i++ { for i := 0; i < room.W; i++ {
mapCoords := types.Coords{room.X + i, room.Y + j} mapCoords := types.Coords{X: room.X + i, Y: room.Y + j}
underlyingTile := l.GetTile(mapCoords) underlyingTile := l.GetTile(mapCoords)
tileFunc := room.Geometry[i+j*room.W] tileFunc := room.Geometry[i+j*room.W]
@ -85,17 +86,17 @@ func NewRandomRectRoom(rng *util.RNG, w, h int, fillage types.RectFill) Room {
w, w,
h, h,
), ),
Center: types.Coords{w / 2, h /2 }, Center: types.Coords{X: w / 2, Y: h /2 },
Geometry: make([]func()*Tile, w*h), Geometry: make([]func()*Tile, w*h),
} }
newRoom.Blit(fillage, &newRoom) newRoom.Blit(fillage, &newRoom)
//add connectors //add connectors
newRoom.Connectors = append( newRoom.Connectors = append(
newRoom.Connectors, newRoom.Connectors,
types.Coords{rng.Range(1, w - 2), 1}, types.Coords{X: rng.Range(1, w - 2), Y: 1},
types.Coords{rng.Range(1, w - 2), h -2}, types.Coords{X: rng.Range(1, w - 2), Y: h -2},
types.Coords{1, rng.Range(1, h - 2)}, types.Coords{X: 1, Y: rng.Range(1, h - 2)},
types.Coords{w - 2, rng.Range(1, h - 2)}, types.Coords{X: w - 2, Y: rng.Range(1, h - 2)},
) )
return newRoom return newRoom
} }
@ -104,7 +105,7 @@ func (r *Room) String() string {
return strings.Join([]string{ return strings.Join([]string{
"room: ", "room: ",
"\t" + fmt.Sprintf(" rect: X: %d, Y: %d, maxX: %d, maxY: %d", r.Rect.X, r.Rect.Y, r.Rect.W + r.X - 1, r.Rect.H + r.Y - 1), "\t" + fmt.Sprintf(" rect: X: %d, Y: %d, maxX: %d, maxY: %d", r.Rect.X, r.Rect.Y, r.Rect.W + r.X - 1, r.Rect.H + r.Y - 1),
"\t" + fmt.Sprintf(" center:", r.Center.X, r.Center.Y), "\t" + fmt.Sprintf(" center: %d, %d", r.Center.X, r.Center.Y),
"\t" + fmt.Sprintf(" Connectors: %v", r.Connectors), "\t" + fmt.Sprintf(" Connectors: %v", r.Connectors),
},"\n") + "\n" },"\n") + "\n"
} }

89
engine/gamemap/tile.go
View File

@ -37,21 +37,22 @@ func (t *Tile) GetRawBgColor() uint32 {
func NewWall() *Tile { func NewWall() *Tile {
return &Tile{ return &Tile{
Appearance: &Appearance{
Glyph: &PlainGlyphHolder{Glyph: "#"},
ColorSet: TileColorSet{
Fg: &PlainColorHolder{A: 255, R: 130, G: 110, B: 150},
Bg: &PlainColorHolder{A: 255, R: 172, G: 170, B: 173},
DarkFg: &PlainColorHolder{A: 255, R: 20, G: 20, B: 68},
DarkBg: &PlainColorHolder{A: 255, R: 7, G: 7, B: 30},
},
},
Name: "Wall", Name: "Wall",
Description: "A dull rock wall", Description: "A dull rock wall",
BlocksPass: true, BlocksPass: true,
BlocksSight: true, BlocksSight: true,
Explored: false, Explored: false,
MustDraw: false, MustDraw: false,
Appearance: &Appearance{ Visible: false,
Glyph: &PlainGlyphHolder{"#"},
ColorSet: TileColorSet{
Fg: &PlainColorHolder{255, 130, 110, 150},
Bg: &PlainColorHolder{255, 172, 170, 173},
DarkFg: &PlainColorHolder{255, 20, 20, 68},
DarkBg: &PlainColorHolder{255, 7, 7, 30},
},
},
} }
} }
@ -64,18 +65,18 @@ func NewDecoratedWall() *Tile {
Explored: false, Explored: false,
MustDraw: false, MustDraw: false,
Appearance: &Appearance{ Appearance: &Appearance{
Glyph: &PlainGlyphHolder{"#"}, Glyph: &PlainGlyphHolder{Glyph: "#"},
ColorSet: TileColorSet{ ColorSet: TileColorSet{
Fg: &PlainColorHolder{255, 130, 110, 150}, Fg: &PlainColorHolder{A: 255, R: 130, G: 110, B: 150},
//Bg: &PlainColorHolder{255, 172, 170, 173}, //Bg: &PlainColorHolder{255, 172, 170, 173},
Bg: &DanceColorHolder{ Bg: &DanceColorHolder{
255, A: 255,
DeviatedColorRing(172, -15, 10), R: DeviatedColorRing(172, -15, 10),
DeviatedColorRing(170, -5, 15), G: DeviatedColorRing(170, -5, 15),
DeviatedColorRing(173, -10, 10), B: DeviatedColorRing(173, -10, 10),
}, },
DarkFg: &PlainColorHolder{255, 20, 20, 68}, DarkFg: &PlainColorHolder{A: 255, R: 20, G: 20, B: 68},
DarkBg: &PlainColorHolder{255, 7, 7, 30}, DarkBg: &PlainColorHolder{A: 255, R: 7, G: 7, B: 30},
}, },
}, },
} }
@ -90,12 +91,12 @@ func NewFloor() *Tile {
Explored: false, Explored: false,
MustDraw: false, MustDraw: false,
Appearance: &Appearance{ Appearance: &Appearance{
Glyph: &PlainGlyphHolder{"."}, Glyph: &PlainGlyphHolder{Glyph: "."},
ColorSet: TileColorSet{ ColorSet: TileColorSet{
Fg: &PlainColorHolder{255, 220, 220, 250}, Fg: &PlainColorHolder{A: 255, R: 220, G: 220, B: 250},
Bg: &PlainColorHolder{255, 19, 19, 70}, Bg: &PlainColorHolder{A: 255, R: 19, G: 19, B: 70},
DarkFg: &PlainColorHolder{255, 30, 20, 50}, DarkFg: &PlainColorHolder{A: 255, R: 30, G: 20, B: 50},
DarkBg: &PlainColorHolder{255, 7, 7, 30}, DarkBg: &PlainColorHolder{A: 255, R: 7, G: 7, B: 30},
}, },
}, },
} }
@ -111,17 +112,17 @@ func NewWaterTile() *Tile {
Explored: false, Explored: false,
MustDraw: true, //fixme debug MustDraw: true, //fixme debug
Appearance: &Appearance{ Appearance: &Appearance{
Glyph: &PlainGlyphHolder{" "}, Glyph: &PlainGlyphHolder{Glyph: " "},
ColorSet: TileColorSet{ ColorSet: TileColorSet{
Fg: &PlainColorHolder{255, 220, 220, 250}, Fg: &PlainColorHolder{A: 255, R: 220, G: 220, B: 250},
Bg: &DanceColorHolder{ Bg: &DanceColorHolder{
255, A: 255,
SingleColorRing(5), R: SingleColorRing(5),
FillColorRing(2, 2, 42, 4), G: FillColorRing(2, 2, 42, 4),
FillColorRing(154, 150, 229, 12), B: FillColorRing(154, 150, 229, 12),
}, },
DarkFg: &PlainColorHolder{255, 30, 20, 50}, DarkFg: &PlainColorHolder{A: 255, R: 30, G: 20, B: 50},
DarkBg: &PlainColorHolder{255, 7, 7, 30}, DarkBg: &PlainColorHolder{A: 255, R: 7, G: 7, B: 30},
}, },
}, },
@ -131,27 +132,21 @@ func NewWaterTile() *Tile {
func NewDeepWaterTile() *Tile { func NewDeepWaterTile() *Tile {
//ch := &ColorHolder{5, 2, 154} //ch := &ColorHolder{5, 2, 154}
return &Tile{ return &Tile{
Appearance: &Appearance{
Glyph: &PlainGlyphHolder{Glyph: " "},
ColorSet: TileColorSet{
Fg: &PlainColorHolder{A: 255, R: 220, G: 220, B: 250},
Bg: &DanceColorHolder{A: 255, R: SingleColorRing(19), G: FillColorRing(19, 0, 15, 2), B: FillColorRing(127, 120, 176, 12)},
DarkFg: &PlainColorHolder{A: 255, R: 30, G: 20, B: 50},
DarkBg: &PlainColorHolder{A: 255, R: 7, G: 7, B: 30},
},
},
Name: "Deep Water", Name: "Deep Water",
Description: "Deep water", Description: "Deep water",
BlocksPass: false, BlocksPass: false,
BlocksSight: false, BlocksSight: false,
Explored: false, Explored: false,
MustDraw: true, //fixme debug MustDraw: true,
Visible: false,
Appearance: &Appearance{
Glyph: &PlainGlyphHolder{" "},
ColorSet: TileColorSet{
Fg: &PlainColorHolder{255, 220, 220, 250},
Bg: &DanceColorHolder{
255,
SingleColorRing(19),
FillColorRing(19, 0, 15, 2),
FillColorRing(127, 120, 176, 12),
},
DarkFg: &PlainColorHolder{255, 30, 20, 50},
DarkBg: &PlainColorHolder{255, 7, 7, 30},
},
},
} }
} }

33
engine/items/itemprops/ip_test.go
View File

@ -1,14 +1,15 @@
package itemprops package itemprops
import ( import (
"encoding/json" "encoding/json"
"github.com/rs/zerolog" "os"
"github.com/rs/zerolog/log" "testing"
"github.com/shopspring/decimal" "time"
"github.com/stretchr/testify/suite"
"os" "github.com/rs/zerolog"
"testing" "github.com/rs/zerolog/log"
"time" "github.com/shopspring/decimal"
"github.com/stretchr/testify/suite"
) )
type IpTestSuite struct { type IpTestSuite struct {
@ -67,8 +68,8 @@ func (suite *IpTestSuite) TestMaterialWeightAndVolume() {
Flags: metalMaterialFlags, Flags: metalMaterialFlags,
Density: DimensionItemDensity{decimal.NewFromInt(7800)}, Density: DimensionItemDensity{decimal.NewFromInt(7800)},
FractureToughness: DimensionFractureToughness{decimal.NewFromInt(30)}, FractureToughness: DimensionFractureToughness{decimal.NewFromInt(30)},
MeltingPoint: DimensionItemNullTemperature{decimal.NullDecimal{decimal.NewFromInt(1400), true}}, MeltingPoint: DimensionItemNullTemperature{decimal.NullDecimal{Decimal: decimal.NewFromInt(1400), Valid: true}},
BoilingPoint: DimensionItemNullTemperature{decimal.NullDecimal{decimal.NewFromInt(3200), true}}, BoilingPoint: DimensionItemNullTemperature{decimal.NullDecimal{Decimal: decimal.NewFromInt(3200), Valid: true}},
} }
testOakWood := Material{ testOakWood := Material{
@ -77,7 +78,7 @@ func (suite *IpTestSuite) TestMaterialWeightAndVolume() {
Flags: woodMaterialFlags, Flags: woodMaterialFlags,
Density: DimensionItemDensity{decimal.NewFromInt(700)}, Density: DimensionItemDensity{decimal.NewFromInt(700)},
FractureToughness: DimensionFractureToughness{decimal.NewFromFloat(4.5)}, FractureToughness: DimensionFractureToughness{decimal.NewFromFloat(4.5)},
MeltingPoint: DimensionItemNullTemperature{decimal.NullDecimal{decimal.NewFromInt(600), true}}, //загорается при 600 град Цельсия MeltingPoint: DimensionItemNullTemperature{decimal.NullDecimal{Decimal: decimal.NewFromInt(600), Valid: true}}, //загорается при 600 град Цельсия
} }
testCube := ItemPhysics{ testCube := ItemPhysics{
@ -156,8 +157,8 @@ func (suite *IpTestSuite) TestMaterialSerialization() {
Flags: metalMaterialFlags, Flags: metalMaterialFlags,
Density: DimensionItemDensity{decimal.NewFromInt(7800)}, Density: DimensionItemDensity{decimal.NewFromInt(7800)},
FractureToughness: DimensionFractureToughness{decimal.NewFromInt(30)}, FractureToughness: DimensionFractureToughness{decimal.NewFromInt(30)},
MeltingPoint: DimensionItemNullTemperature{decimal.NullDecimal{decimal.NewFromInt(1400), true}}, MeltingPoint: DimensionItemNullTemperature{decimal.NullDecimal{Decimal: decimal.NewFromInt(1400), Valid: true}},
BoilingPoint: DimensionItemNullTemperature{decimal.NullDecimal{decimal.NewFromInt(3200), true}}, BoilingPoint: DimensionItemNullTemperature{decimal.NullDecimal{Decimal: decimal.NewFromInt(3200), Valid: true}},
} }
testOakWood := Material{ testOakWood := Material{
@ -166,7 +167,7 @@ func (suite *IpTestSuite) TestMaterialSerialization() {
Flags: woodMaterialFlags, Flags: woodMaterialFlags,
Density: DimensionItemDensity{decimal.NewFromInt(700)}, Density: DimensionItemDensity{decimal.NewFromInt(700)},
FractureToughness: DimensionFractureToughness{decimal.NewFromFloat(4.5)}, FractureToughness: DimensionFractureToughness{decimal.NewFromFloat(4.5)},
MeltingPoint: DimensionItemNullTemperature{decimal.NullDecimal{decimal.NewFromInt(600), true}}, //загорается при 600 град Цельсия MeltingPoint: DimensionItemNullTemperature{decimal.NullDecimal{Decimal: decimal.NewFromInt(600), Valid: true}}, //загорается при 600 град Цельсия
} }
bytes, err := json.Marshal(teststeel) bytes, err := json.Marshal(teststeel)
suite.NoError(err) suite.NoError(err)
@ -204,8 +205,8 @@ func (suite *IpTestSuite) TestMaterialDeserialization() {
Flags: metalMaterialFlags, Flags: metalMaterialFlags,
Density: DimensionItemDensity{decimal.NewFromInt(7800)}, Density: DimensionItemDensity{decimal.NewFromInt(7800)},
FractureToughness: DimensionFractureToughness{decimal.NewFromInt(30)}, FractureToughness: DimensionFractureToughness{decimal.NewFromInt(30)},
MeltingPoint: DimensionItemNullTemperature{decimal.NullDecimal{decimal.NewFromInt(1400), true}}, MeltingPoint: DimensionItemNullTemperature{decimal.NullDecimal{Decimal: decimal.NewFromInt(1400), Valid: true}},
BoilingPoint: DimensionItemNullTemperature{decimal.NullDecimal{decimal.NewFromInt(3200), true}}, BoilingPoint: DimensionItemNullTemperature{decimal.NullDecimal{Decimal: decimal.NewFromInt(3200), Valid: true}},
} }
loadedsteel := mm["steel"] loadedsteel := mm["steel"]

18
engine/items/itemprops/material.go
View File

@ -1,13 +1,13 @@
package itemprops package itemprops
import ( import (
"encoding/json" "encoding/json"
"fmt" "fmt"
"github.com/rs/zerolog" "os"
"io/ioutil" "path/filepath"
"os" "strings"
"path/filepath"
"strings" "github.com/rs/zerolog"
) )
type Material struct { type Material struct {
@ -50,7 +50,7 @@ func NewMaterialMap(path string, logger zerolog.Logger) (MaterialMap, error) {
if strings.HasSuffix(path, ".json") { if strings.HasSuffix(path, ".json") {
splt := strings.Split(path, "/") splt := strings.Split(path, "/")
logger.Info().Msgf("loading %s %d", splt[len(splt)-1], info.Size()) logger.Info().Msgf("loading %s %d", splt[len(splt)-1], info.Size())
bytes, err := ioutil.ReadFile(path) bytes, err := os.ReadFile(path)
if err != nil { if err != nil {
return err return err
} }
@ -60,7 +60,7 @@ func NewMaterialMap(path string, logger zerolog.Logger) (MaterialMap, error) {
if err != nil { if err != nil {
return err return err
} }
for idx, _ := range ttmp { for idx := range ttmp {
tmp[idx] = append(tmp[idx], ttmp[idx]...) tmp[idx] = append(tmp[idx], ttmp[idx]...)
} }
} }

2
engine/matertals/properties.go
View File

@ -50,7 +50,7 @@ func (ms MatterState) Change(from MatterState, to MatterState) bool {
return false return false
}(transitions[from], to) }(transitions[from], to)
if !newStateFound { if !newStateFound {
log.Warn().Msgf("Transition %s -> %s is impossible", from, to) log.Warn().Msgf(`Transition %d -> %d is impossible`, from, to)
return false return false
} }
// check temperatures/conditions, see template // check temperatures/conditions, see template

6
engine/mob/movement/movement.go
View File

@ -23,11 +23,11 @@ func (mov Moveable) Walk() {
//fixme change it to WhatsOnTile //fixme change it to WhatsOnTile
func (mov Moveable) IsBlocked(c types.Coords) bool { func (mov Moveable) IsBlocked(c types.Coords) bool {
if mov.Level.GetTile(c).BlocksPass == true { if mov.Level.GetTile(c).BlocksPass {
return true return true
} }
list := mov.Controller.GetEntitiesWithComponent(ecs.MobComponent) list := mov.Controller.GetEntitiesWithComponent(ecs.MobComponent)
for idx, _ := range list { for idx := range list {
coords := mov.Controller.GetComponent(list[idx], ecs.CoordsComponent) coords := mov.Controller.GetComponent(list[idx], ecs.CoordsComponent)
if coords == nil { if coords == nil {
continue continue
@ -50,7 +50,7 @@ func (mov Moveable) IsBlocked(c types.Coords) bool {
func Walk(entity ecs.Entity, state *gamestate.GameState, dx, dy int) { func Walk(entity ecs.Entity, state *gamestate.GameState, dx, dy int) {
controller := state.Controller controller := state.Controller
coords := controller.GetComponent(state.Player, ecs.CoordsComponent).(types.Coords) coords := controller.GetComponent(state.Player, ecs.CoordsComponent).(types.Coords)
newCoords := types.Coords{coords.X + dx, coords.Y + dy} newCoords := types.Coords{X: coords.X + dx, Y: coords.Y + dy}
if !state.Level.InBounds(newCoords) { if !state.Level.InBounds(newCoords) {
return return
} }

19
engine/screens/devmenu.go
View File

@ -1,15 +1,16 @@
package screens package screens
import ( import (
"context" "context"
"fmt" "fmt"
"lab.zaar.be/thefish/alchemyst-go/effects" "strings"
"lab.zaar.be/thefish/alchemyst-go/engine/ecs"
"lab.zaar.be/thefish/alchemyst-go/engine/gamestate" "lab.zaar.be/thefish/alchemyst-go/effects"
"lab.zaar.be/thefish/alchemyst-go/engine/types" "lab.zaar.be/thefish/alchemyst-go/engine/ecs"
"lab.zaar.be/thefish/alchemyst-go/ui/mainwindow" "lab.zaar.be/thefish/alchemyst-go/engine/gamestate"
"lab.zaar.be/thefish/alchemyst-go/util/appctx" "lab.zaar.be/thefish/alchemyst-go/engine/types"
"strings" "lab.zaar.be/thefish/alchemyst-go/ui/mainwindow"
"lab.zaar.be/thefish/alchemyst-go/util/appctx"
) )
type DevmenuScreen struct { type DevmenuScreen struct {

7
engine/screens/inventory.go
View File

@ -146,7 +146,12 @@ func (is *InventoryScreen) InventoryRender() {
footerHeight = footerHeight + 2 footerHeight = footerHeight + 2
} }
_, headerHeight := menuLayer.PrintInside(is.Rect, is.header, blt.TK_ALIGN_LEFT) _, headerHeight := menuLayer.PrintInside(is.Rect, is.header, blt.TK_ALIGN_LEFT)
itemField := types.Rect{is.X, is.Y + headerHeight + 1, is.W, is.H - headerHeight - footerHeight} itemField := types.Rect{
X: is.X,
Y: is.Y + headerHeight + 1,
W: is.W,
H: is.H - headerHeight - footerHeight,
}
_ = itemField _ = itemField
is.pageSize = itemField.H - 2 is.pageSize = itemField.H - 2

6
ui/mainwindow/viewport.go
View File

@ -13,7 +13,7 @@ type ViewPort struct {
func NewViewPort(x, y, w, h int) *ViewPort { func NewViewPort(x, y, w, h int) *ViewPort {
vp := ViewPort{ vp := ViewPort{
Rect: types.Rect{x, y, w, h}, Rect: types.Rect{X: x, Y: y, W: w, H: h},
} }
return &vp return &vp
} }
@ -47,8 +47,8 @@ func (vp *ViewPort) ToVPCoords(c types.Coords) (newCoords types.Coords, err erro
//coords on map to coords on vp //coords on map to coords on vp
x, y := c.X-vp.CameraCoords.X, c.Y-vp.CameraCoords.Y x, y := c.X-vp.CameraCoords.X, c.Y-vp.CameraCoords.Y
if x < 0 || y < 0 || x > vp.W || y > vp.H { if x < 0 || y < 0 || x > vp.W || y > vp.H {
return types.Coords{-1, -1}, fmt.Errorf("Not in viewport: {%d, %d}", x, y) return types.Coords{X: -1, Y: -1}, fmt.Errorf("Not in viewport: {%d, %d}", x, y)
} }
return types.Coords{x, y}, nil return types.Coords{X: x, Y: y}, nil
} }

38
util/delaunay/delaunay.go
View File

@ -6,6 +6,7 @@ import "lab.zaar.be/thefish/alchemyst-go/engine/types"
var nodeId = 0 var nodeId = 0
var nodeList = make(map[types.Coords]Node, 0) var nodeList = make(map[types.Coords]Node, 0)
// Node defines a struct having as components the node X and Y coordinate position. // Node defines a struct having as components the node X and Y coordinate position.
type Node struct { type Node struct {
Id int Id int
@ -129,17 +130,27 @@ func (d *Delaunay) Init(width, height int) *Delaunay {
} }
var supertriangle1, supertriangle2 Triangle var supertriangle1, supertriangle2 Triangle
// clear method clears the delaunay triangles slice. // clear method clears the delaunay triangles slice.
func (d *Delaunay) clear() { func (d *Delaunay) clear() {
p0 := newNode(types.Coords{0,0}) p0 := newNode(types.Coords{X: 0, Y: 0})
p1 := newNode(types.Coords{d.width, 0}) p1 := newNode(types.Coords{X: d.width, Y: 0})
p2 := newNode(types.Coords{d.width, d.height}) p2 := func() Node {
p3 := newNode(types.Coords{0, d.height}) var coords types.Coords = types.Coords{X: d.width, Y: d.height}
if n, ok := nodeList[coords]; ok {
return n
}
neue := Node{Id: nodeId, Coords: coords}
nodeList[coords] = neue
nodeId++
return neue
}()
p3 := newNode(types.Coords{X: 0, Y: d.height})
// Create the supertriangle, an artificial triangle which encompasses all the points. // Create the supertriangle, an artificial triangle which encompasses all the points.
// At the end of the triangulation process any triangles which share Edges with the supertriangle are deleted from the triangle list. // At the end of the triangulation process any triangles which share Edges with the supertriangle are deleted from the triangle list.
supertriangle1 = t.newTriangle(p0,p1,p2) supertriangle1 = t.newTriangle(p0, p1, p2)
supertriangle2 = t.newTriangle(p0,p2,p3) supertriangle2 = t.newTriangle(p0, p2, p3)
d.triangles = []Triangle{supertriangle1, supertriangle2} d.triangles = []Triangle{supertriangle1, supertriangle2}
} }
@ -199,7 +210,7 @@ func (d *Delaunay) Insert(points []types.Coords) *Delaunay {
} }
for i = 0; i < len(polygon); i++ { for i = 0; i < len(polygon); i++ {
edge := polygon[i] edge := polygon[i]
temps = append(temps, t.newTriangle(edge.Nodes[0], edge.Nodes[1], newNode(types.Coords{x, y}))) temps = append(temps, t.newTriangle(edge.Nodes[0], edge.Nodes[1], newNode(types.Coords{X: x, Y: y})))
} }
d.triangles = temps d.triangles = temps
} }
@ -245,12 +256,9 @@ func (d *Delaunay) GetTriangles() []Triangle {
} }
func (d *Delaunay) GetEdges() []Edge { func (d *Delaunay) GetEdges() []Edge {
edges := make([]Edge, 0) edges := make([]Edge, 0)
for _, trs := range d.triangles { for _, trs := range d.triangles {
for _, e := range trs.Edges { edges = append(edges, trs.Edges...)
edges = append(edges, e) }
} return edges
}
return edges
} }

10
util/delaunay/mst.go
View File

@ -11,7 +11,7 @@ func GetTriangles(coords []types.Coords, w, h int) []types.Edge {
edges := d.Init(100, 100).Insert(coords).GetEdges() edges := d.Init(100, 100).Insert(coords).GetEdges()
output := make([]types.Edge, 0) output := make([]types.Edge, 0)
for _, e := range edges{ for _, e := range edges{
output = append(output, types.Edge{e.Nodes[0].Coords, e.Nodes[1].Coords}) output = append(output, types.Edge{From: e.Nodes[0].Coords, To: e.Nodes[1].Coords})
} }
return output return output
} }
@ -46,16 +46,16 @@ func GetMst(coords []types.Coords, w, h, negativeWeight int) []types.Edge {
graph = append( graph = append(
graph, graph,
kruskals.SimpleWeightedEdge{ kruskals.SimpleWeightedEdge{
nodeMap[e.Nodes[0].Id], F: nodeMap[e.Nodes[0].Id],
nodeMap[e.Nodes[1].Id], T: nodeMap[e.Nodes[1].Id],
negativeWeight - int(e.Nodes[0].Coords.DistanceTo(e.Nodes[1].Coords))}, W: negativeWeight - int(e.Nodes[0].Coords.DistanceTo(e.Nodes[1].Coords))},
) )
} }
result := kruskals.MinimumSpanningTree(graph) result := kruskals.MinimumSpanningTree(graph)
output := make([]types.Edge, 0) output := make([]types.Edge, 0)
for _, we := range result{ for _, we := range result{
output = append(output, types.Edge{nodeList[we.From()].Coords, nodeList[we.To()].Coords}) output = append(output, types.Edge{From: nodeList[we.From()].Coords, To: nodeList[we.To()].Coords})
} }
return output return output
} }