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

precomputed shade algo, viewport basic render

Browse Source
This commit is contained in:
anton.gurov 2019-10-30 17:56:30 +03:00
parent 4a77323aab
commit 3958951cd5
15 changed files with 924 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
cmd/game/main.go
View File

@ -3,6 +3,8 @@ package main
import (
"github.com/rs/zerolog"
"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/ui"
"lab.zaar.be/thefish/alchemyst-go/ui/mainwindow"
"lab.zaar.be/thefish/alchemyst-go/util"
@ -94,13 +96,13 @@ Cursus in hac habitasse platea. Aliquet risus feugiat in ante metus dictum. Maec
Sed euismod nisi porta lorem mollis aliquam ut porttitor leo. Ut tellus elementum sagittis vitae et leo duis ut diam. Elementum curabitur vitae nunc sed velit dignissim. Auctor elit sed vulputate mi sit. Consectetur adipiscing elit ut aliquam purus. Feugiat vivamus at augue eget arcu. Duis ut diam quam nulla porttitor massa id neque. Pharetra magna ac placerat vestibulum lectus mauris ultrices. Non sodales neque sodales ut etiam. Massa ultricies mi quis hendrerit dolor. Est sit amet facilisis magna etiam. Ornare suspendisse sed nisi lacus sed viverra tellus in.
`)
menuLayer.WithColor("red").PutWithBackground(40,40,"Ы", "#aa1257d4")
menuLayer.WithColor("white").PutWithBackground(41,40,"Щ", "#cd31ed12")
menuLayer.WithColor("yellow").PutWithBackground(42,40,"Ц", "#efcccccc")
menuLayer.WithColor("red").PutWithBackground(20,40,"Ы", "#aa1257d4")
menuLayer.WithColor("white").PutWithBackground(21,40,"Щ", "#cd31ed12")
menuLayer.WithColor("yellow").PutWithBackground(22,40,"Ц", "#efcccccc")
menuLayer.WithColor("red").PutWithBackground(40,1,"Ы", "#aa1257d4")
menuLayer.WithColor("white").PutWithBackground(41,1,"Щ", "#cd31ed12")
menuLayer.WithColor("yellow").PutWithBackground(42,1,"Ц", "#efcccccc")
menuLayer.WithColor("red").PutWithBackground(39,1,"Ы", "#aa1257d4")
menuLayer.WithColor("white").PutWithBackground(40,1,"Щ", "#cd31ed12")
menuLayer.WithColor("yellow").PutWithBackground(41,1,"Ц", "#efcccccc")
bgLayer.WithColor("#77cfcfcf").NewWindow(45, 5, 40, 40).Splash()
@ -120,6 +122,11 @@ Sed euismod nisi porta lorem mollis aliquam ut porttitor leo. Ut tellus elementu
State.Do(initRender)
level := gamemap.NewLevel(ctx, "test", 1)
level = mapgens.DefaultGen(level)
vp := mainwindow.NewViewPort(40, 0, 60, 47, level, &baseLayer)
//main loop!
for {
//fresh inputs to chan
@ -158,6 +165,10 @@ Sed euismod nisi porta lorem mollis aliquam ut porttitor leo. Ut tellus elementu
baseLayer.Print(1, 5, key)
}
})
State.Do(func(){
vp.Render()
})
//update screen
State.Do(func() {
blt.Refresh()

2
engine/fov/fov.go → engine/fov/basic/basic_raycasting.go
View File

@ -1,4 +1,4 @@
package fov
package basic
import (
"github.com/jcerise/gogue/gamemap"

11
engine/fov/common.go Normal file
View File

@ -0,0 +1,11 @@
package fov
import (
"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
"lab.zaar.be/thefish/alchemyst-go/engine/types"
)
type Fov interface {
IsInFov(coords types.Coords) bool
ComputeFov(level *gamemap.Level, coords types.Coords, radius int)
}

257
engine/fov/milazzo/milazzo.go Normal file
View File

@ -0,0 +1,257 @@
package milazzo
/**
```cpp
sealed class MyVisibility : Visibility
{
/// <param name="blocksLight">A function that accepts the X and Y coordinates of a tile and determines whether the
/// given tile blocks the passage of light. The function must be able to accept coordinates that are out of bounds.
/// </param>
/// <param name="setVisible">A function that sets a tile to be visible, given its X and Y coordinates. The function
/// must ignore coordinates that are out of bounds.
/// </param>
/// <param name="getDistance">A function that takes the X and Y coordinate of a point where X >= 0,
/// Y >= 0, and X >= Y, and returns the distance from the point to the origin (0,0).
/// </param>
public MyVisibility(Func<int, int, bool> blocksLight, Action<int, int> setVisible, Func<int, int, int> getDistance)
{
_blocksLight = blocksLight;
GetDistance = getDistance;
_setVisible = setVisible;
}
public override void Compute(LevelPoint origin, int rangeLimit)
{
_setVisible(origin.X, origin.Y);
for(uint octant=0; octant<8; octant++) Compute(octant, origin, rangeLimit, 1, new Slope(1, 1), new Slope(0, 1));
}
struct Slope // represents the slope Y/X as a rational number
{
public Slope(uint y, uint x) { Y = y; X = x; }
public bool Greater(uint y, uint x) { return Y*x > X*y; } // this > y/x
public bool GreaterOrEqual(uint y, uint x) { return Y*x >= X*y; } // this >= y/x
public bool Less(uint y, uint x) { return Y*x < X*y; } // this < y/x
//public bool LessOrEqual(uint y, uint x) { return Y*x <= X*y; } // this <= y/x
public readonly uint X, Y;
}
void Compute(uint octant, LevelPoint origin, int rangeLimit, uint x, Slope top, Slope bottom)
{
// throughout this function there are references to various parts of tiles. a tile's coordinates refer to its
// center, and the following diagram shows the parts of the tile and the vectors from the origin that pass through
// those parts. given a part of a tile with vector u, a vector v passes above it if v > u and below it if v < u
// g center: y / x
// a------b a top left: (y*2+1) / (x*2-1) i inner top left: (y*4+1) / (x*4-1)
// | /\ | b top right: (y*2+1) / (x*2+1) j inner top right: (y*4+1) / (x*4+1)
// |i/__\j| c bottom left: (y*2-1) / (x*2-1) k inner bottom left: (y*4-1) / (x*4-1)
//e|/| |\|f d bottom right: (y*2-1) / (x*2+1) m inner bottom right: (y*4-1) / (x*4+1)
// |\|__|/| e middle left: (y*2) / (x*2-1)
// |k\ /m| f middle right: (y*2) / (x*2+1) a-d are the corners of the tile
// | \/ | g top center: (y*2+1) / (x*2) e-h are the corners of the inner (wall) diamond
// c------d h bottom center: (y*2-1) / (x*2) i-m are the corners of the inner square (1/2 tile width)
// h
for(; x <= (uint)rangeLimit; x++) // (x <= (uint)rangeLimit) == (rangeLimit < 0 || x <= rangeLimit)
{
// compute the Y coordinates of the top and bottom of the sector. we maintain that top > bottom
uint topY;
if(top.X == 1) // if top == ?/1 then it must be 1/1 because 0/1 < top <= 1/1. this is special-cased because top
{ // starts at 1/1 and remains 1/1 as long as it doesn't hit anything, so it's a common case
topY = x;
}
else // top < 1
{
// get the tile that the top vector enters from the left. since our coordinates refer to the center of the
// tile, this is (x-0.5)*top+0.5, which can be computed as (x-0.5)*top+0.5 = (2(x+0.5)*top+1)/2 =
// ((2x+1)*top+1)/2. since top == a/b, this is ((2x+1)*a+b)/2b. if it enters a tile at one of the left
// corners, it will round up, so it'll enter from the bottom-left and never the top-left
topY = ((x*2-1) * top.Y + top.X) / (top.X*2); // the Y coordinate of the tile entered from the left
// now it's possible that the vector passes from the left side of the tile up into the tile above before
// exiting from the right side of this column. so we may need to increment topY
if(BlocksLight(x, topY, octant, origin)) // if the tile blocks light (i.e. is a wall)...
{
// if the tile entered from the left blocks light, whether it passes into the tile above depends on the shape
// of the wall tile as well as the angle of the vector. if the tile has does not have a beveled top-left
// corner, then it is blocked. the corner is beveled if the tiles above and to the left are not walls. we can
// ignore the tile to the left because if it was a wall tile, the top vector must have entered this tile from
// the bottom-left corner, in which case it can't possibly enter the tile above.
//
// otherwise, with a beveled top-left corner, the slope of the vector must be greater than or equal to the
// slope of the vector to the top center of the tile (x*2, topY*2+1) in order for it to miss the wall and
// pass into the tile above
if(top.GreaterOrEqual(topY*2+1, x*2) && !BlocksLight(x, topY+1, octant, origin)) topY++;
}
else // the tile doesn't block light
{
// since this tile doesn't block light, there's nothing to stop it from passing into the tile above, and it
// does so if the vector is greater than the vector for the bottom-right corner of the tile above. however,
// there is one additional consideration. later code in this method assumes that if a tile blocks light then
// it must be visible, so if the tile above blocks light we have to make sure the light actually impacts the
// wall shape. now there are three cases: 1) the tile above is clear, in which case the vector must be above
// the bottom-right corner of the tile above, 2) the tile above blocks light and does not have a beveled
// bottom-right corner, in which case the vector must be above the bottom-right corner, and 3) the tile above
// blocks light and does have a beveled bottom-right corner, in which case the vector must be above the
// bottom center of the tile above (i.e. the corner of the beveled edge).
//
// now it's possible to merge 1 and 2 into a single check, and we get the following: if the tile above and to
// the right is a wall, then the vector must be above the bottom-right corner. otherwise, the vector must be
// above the bottom center. this works because if the tile above and to the right is a wall, then there are
// two cases: 1) the tile above is also a wall, in which case we must check against the bottom-right corner,
// or 2) the tile above is not a wall, in which case the vector passes into it if it's above the bottom-right
// corner. so either way we use the bottom-right corner in that case. now, if the tile above and to the right
// is not a wall, then we again have two cases: 1) the tile above is a wall with a beveled edge, in which
// case we must check against the bottom center, or 2) the tile above is not a wall, in which case it will
// only be visible if light passes through the inner square, and the inner square is guaranteed to be no
// larger than a wall diamond, so if it wouldn't pass through a wall diamond then it can't be visible, so
// there's no point in incrementing topY even if light passes through the corner of the tile above. so we
// might as well use the bottom center for both cases.
uint ax = x*2; // center
if(BlocksLight(x+1, topY+1, octant, origin)) ax++; // use bottom-right if the tile above and right is a wall
if(top.Greater(topY*2+1, ax)) topY++;
}
}
uint bottomY;
if(bottom.Y == 0) // if bottom == 0/?, then it's hitting the tile at Y=0 dead center. this is special-cased because
{ // bottom.Y starts at zero and remains zero as long as it doesn't hit anything, so it's common
bottomY = 0;
}
else // bottom > 0
{
bottomY = ((x*2-1) * bottom.Y + bottom.X) / (bottom.X*2); // the tile that the bottom vector enters from the left
// code below assumes that if a tile is a wall then it's visible, so if the tile contains a wall we have to
// ensure that the bottom vector actually hits the wall shape. it misses the wall shape if the top-left corner
// is beveled and bottom >= (bottomY*2+1)/(x*2). finally, the top-left corner is beveled if the tiles to the
// left and above are clear. we can assume the tile to the left is clear because otherwise the bottom vector
// would be greater, so we only have to check above
if(bottom.GreaterOrEqual(bottomY*2+1, x*2) && BlocksLight(x, bottomY, octant, origin) &&
!BlocksLight(x, bottomY+1, octant, origin))
{
bottomY++;
}
}
// go through the tiles in the column now that we know which ones could possibly be visible
int wasOpaque = -1; // 0:false, 1:true, -1:not applicable
for(uint y = topY; (int)y >= (int)bottomY; y--) // use a signed comparison because y can wrap around when decremented
{
if(rangeLimit < 0 || GetDistance((int)x, (int)y) <= rangeLimit) // skip the tile if it's out of visual range
{
bool isOpaque = BlocksLight(x, y, octant, origin);
// every tile where topY > y > bottomY is guaranteed to be visible. also, the code that initializes topY and
// bottomY guarantees that if the tile is opaque then it's visible. so we only have to do extra work for the
// case where the tile is clear and y == topY or y == bottomY. if y == topY then we have to make sure that
// the top vector is above the bottom-right corner of the inner square. if y == bottomY then we have to make
// sure that the bottom vector is below the top-left corner of the inner square
bool isVisible =
isOpaque || ((y != topY || top.Greater(y*4-1, x*4+1)) && (y != bottomY || bottom.Less(y*4+1, x*4-1)));
// NOTE: if you want the algorithm to be either fully or mostly symmetrical, replace the line above with the
// following line (and uncomment the Slope.LessOrEqual method). the line ensures that a clear tile is visible
// only if there's an unobstructed line to its center. if you want it to be fully symmetrical, also remove
// the "isOpaque ||" part and see NOTE comments further down
// bool isVisible = isOpaque || ((y != topY || top.GreaterOrEqual(y, x)) && (y != bottomY || bottom.LessOrEqual(y, x)));
if(isVisible) SetVisible(x, y, octant, origin);
// if we found a transition from clear to opaque or vice versa, adjust the top and bottom vectors
if(x != rangeLimit) // but don't bother adjusting them if this is the last column anyway
{
if(isOpaque)
{
if(wasOpaque == 0) // if we found a transition from clear to opaque, this sector is done in this column,
{ // so adjust the bottom vector upward and continue processing it in the next column
// if the opaque tile has a beveled top-left corner, move the bottom vector up to the top center.
// otherwise, move it up to the top left. the corner is beveled if the tiles above and to the left are
// clear. we can assume the tile to the left is clear because otherwise the vector would be higher, so
// we only have to check the tile above
uint nx = x*2, ny = y*2+1; // top center by default
// NOTE: if you're using full symmetry and want more expansive walls (recommended), comment out the next line
if(BlocksLight(x, y+1, octant, origin)) nx--; // top left if the corner is not beveled
if(top.Greater(ny, nx)) // we have to maintain the invariant that top > bottom, so the new sector
{ // created by adjusting the bottom is only valid if that's the case
// if we're at the bottom of the column, then just adjust the current sector rather than recursing
// since there's no chance that this sector can be split in two by a later transition back to clear
if(y == bottomY) { bottom = new Slope(ny, nx); break; } // don't recurse unless necessary
else Compute(octant, origin, rangeLimit, x+1, top, new Slope(ny, nx));
}
else // the new bottom is greater than or equal to the top, so the new sector is empty and we'll ignore
{ // it. if we're at the bottom of the column, we'd normally adjust the current sector rather than
if(y == bottomY) return; // recursing, so that invalidates the current sector and we're done
}
}
wasOpaque = 1;
}
else
{
if(wasOpaque > 0) // if we found a transition from opaque to clear, adjust the top vector downwards
{
// if the opaque tile has a beveled bottom-right corner, move the top vector down to the bottom center.
// otherwise, move it down to the bottom right. the corner is beveled if the tiles below and to the right
// are clear. we know the tile below is clear because that's the current tile, so just check to the right
uint nx = x*2, ny = y*2+1; // the bottom of the opaque tile (oy*2-1) equals the top of this tile (y*2+1)
// NOTE: if you're using full symmetry and want more expansive walls (recommended), comment out the next line
if(BlocksLight(x+1, y+1, octant, origin)) nx++; // check the right of the opaque tile (y+1), not this one
// we have to maintain the invariant that top > bottom. if not, the sector is empty and we're done
if(bottom.GreaterOrEqual(ny, nx)) return;
top = new Slope(ny, nx);
}
wasOpaque = 0;
}
}
}
}
// if the column didn't end in a clear tile, then there's no reason to continue processing the current sector
// because that means either 1) wasOpaque == -1, implying that the sector is empty or at its range limit, or 2)
// wasOpaque == 1, implying that we found a transition from clear to opaque and we recursed and we never found
// a transition back to clear, so there's nothing else for us to do that the recursive method hasn't already. (if
// we didn't recurse (because y == bottomY), it would have executed a break, leaving wasOpaque equal to 0.)
if(wasOpaque != 0) break;
}
}
// NOTE: the code duplication between BlocksLight and SetVisible is for performance. don't refactor the octant
// translation out unless you don't mind an 18% drop in speed
bool BlocksLight(uint x, uint y, uint octant, LevelPoint origin)
{
uint nx = origin.X, ny = origin.Y;
switch(octant)
{
case 0: nx += x; ny -= y; break;
case 1: nx += y; ny -= x; break;
case 2: nx -= y; ny -= x; break;
case 3: nx -= x; ny -= y; break;
case 4: nx -= x; ny += y; break;
case 5: nx -= y; ny += x; break;
case 6: nx += y; ny += x; break;
case 7: nx += x; ny += y; break;
}
return _blocksLight((int)nx, (int)ny);
}
void SetVisible(uint x, uint y, uint octant, LevelPoint origin)
{
uint nx = origin.X, ny = origin.Y;
switch(octant)
{
case 0: nx += x; ny -= y; break;
case 1: nx += y; ny -= x; break;
case 2: nx -= y; ny -= x; break;
case 3: nx -= x; ny -= y; break;
case 4: nx -= x; ny += y; break;
case 5: nx -= y; ny += x; break;
case 6: nx += y; ny += x; break;
case 7: nx += x; ny += y; break;
}
_setVisible((int)nx, (int)ny);
}
readonly Func<int, int, bool> _blocksLight;
readonly Func<int, int, int> GetDistance;
readonly Action<int, int> _setVisible;
}
```
*/

194
engine/fov/precomputed_permissive/precomputed_permissive.go Normal file
View File

@ -0,0 +1,194 @@
package precomputed_permissive
import (
"errors"
"fmt"
"lab.zaar.be/thefish/alchemyst-go/engine/fov/basic"
"lab.zaar.be/thefish/alchemyst-go/engine/types"
"math"
"sort"
)
/*
Why am I here? Well, I just don't know what to call it - I'm sure it's an established method, and I'm aware there are probably optimisations to be had. I thought if I roughed out the algorithm here, the r/roguelikedev community would surely be able to help! I haven't included optimisations here, but if anyone wants them I got 'em :)
Method
Beforehand
List the cells in your largest-possible FOV, storing X and Y values relative to the center.
Store the distance from the center for each cell, and sort the list by this in ascending order.
Store the range of angles occluded by each cell in this list, in clockwise order as absolute integers only.
Create a 360-char string of 0s called EmptyShade, and a 360-char string of 1s called FullShade
Runtime
Store two strings – CurrentShade and NextShade
Set CurrentShade to EmptyShade to start.
While CurrentShade =/= FullShade: step through the Cell List:
If the distance to the current cell is not equal to the previous distance checked then replace the contents of the CurrentShade variable with the contents of the NextShade variable.
If the tested cell is opaque – for each angle in the range occluded by the cell, place a 1 at the position determined by angle%360 in the NextShade string.
For each angle in the range occluded by the cell, add 1 to the shade value for that cell for each 0 encountered at the position determined by angle%360 in the CurrentShade string.
Notes
Benefits
No messing around with octants
Highly efficient - each cell is only visited once, and checks within that cell are rare. It performs as fast as any other LOS I've tried but with more options
Human-readable - code and output are highly legible, making it very easy to work with
Flexible - I'm using it for FOV, LOS, renderer, and lighting. Each process is calling the same function, within which flags control how much data is evaluated and output. It only uses the data it needs to in the context where its needed – so monsters that need a list of things they can see only check if a cell is visible or not, and don’t bother calculating how much visibility they have there. This cuts processing dramatically.
Other links
cfov by Konstantin Stupnik on RogueTemple
Pre-Computed Visiblity Trees on RogueBasin
/r/roguelikedev FAQ Friday on FOV which kicked off this train of thought
/u/pnjeffries on his FOV algorithm which inspired this one
Adam Milazzo's FOV Method Roundup where a similar method described as 'permissive' is detailed
*/
var NotFoundCell = errors.New("Cell not found")
type Cell struct {
types.Coords
distance float64
occluded []int //indexes of cells in CellList
}
type CellList []*Cell
type DistanceSorter CellList
func (a DistanceSorter) Len() int { return len(a) }
func (a DistanceSorter) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a DistanceSorter) Less(i, j int) bool { return a[i].distance < a[j].distance }
func (pp *precomputedPermissive) FindByCoords(c types.Coords) (int, *Cell, error) {
for i := range pp.CellList {
if pp.CellList[i].Coords == c {
// Found!
return i, pp.CellList[i], nil
}
}
return 0, &Cell{}, NotFoundCell
}
type precomputedPermissive struct {
MaxTorchRadius int
CellList CellList
cosTable map[int]float64
sinTable map[int]float64
}
func NewPrecomputedPermissive(maxTorchRadius int) *precomputedPermissive {
result := &precomputedPermissive{MaxTorchRadius: maxTorchRadius}
result.PrecomputeFovMap()
return result
}
func (pp *precomputedPermissive) IsInFov(coords types.Coords) bool {
return true
}
func (pp *precomputedPermissive) ComputeFov(coords types.Coords, radius int) {
}
func (pp *precomputedPermissive) PrecomputeFovMap() {
max := pp.MaxTorchRadius
minusMax := (-1) * max
zeroCoords := types.Coords{0, 0}
var x, y int
//fill list
for x = minusMax; x < max+1; x++ {
for y = minusMax; y < max+1; y++ {
if x == 0 && y == 0 {
continue;
}
iterCoords := types.Coords{x, y}
distance := zeroCoords.DistanceTo(iterCoords)
if distance <= float64(max) {
pp.CellList = append(pp.CellList, &Cell{iterCoords, distance, nil})
}
}
}
//Do not change cell order after this!
sort.Sort(DistanceSorter(pp.CellList))
//debug
//for _, cell := range pp.CellList {
// fmt.Printf("\n coords: %v, distance: %f, len_occl: %d", cell.Coords, cell.distance, len(cell.occluded))
//}
//Bresanham lines / Raycast
var lineX, lineY float64
for i := 0; i < 360; i++ {
dx := math.Sin(float64(i) / (float64(180) / math.Pi))
dy := math.Cos(float64(i) / (float64(180) / math.Pi))
occlusion := make([]int, max)
traversedCells := make([]*Cell, max)
lineX = 0
lineY = 0
for j := 0; j < max; j++ {
lineX -= dx
lineY -= dy
roundedX := int(basic.Round(lineX))
roundedY := int(basic.Round(lineY))
idx, cell, err := pp.FindByCoords(types.Coords{roundedX, roundedY})
if err != nil {
//inexistent coord found
break;
}
occlusion[j] = idx
traversedCells[j] = cell
}
// -2 because we do not want to cell occlude itself
for k := len(occlusion) - 2; k >= 0; k-- {
if traversedCells[k] == nil {
continue;
}
if traversedCells[k].occluded == nil {
traversedCells[k].occluded = occlusion[k + 1:]
}
//Remove duplicates
traversedCells[k].occluded = unique(append(traversedCells[k].occluded, occlusion[k + 1:]...))
}
fmt.Printf("\n next: %d", i)
}
fmt.Printf("before len: %d", len(pp.CellList))
fmt.Printf("after len: %d", len(pp.CellList))
for _, cell := range pp.CellList {
fmt.Printf("\n coords: %v, distance: %f, len_occl: %d", cell.Coords, cell.distance, len(cell.occluded))
}
}
func unique(intSlice []int) []int {
keys := make(map[int]bool)
list := []int{}
for _, entry := range intSlice {
if _, value := keys[entry]; !value {
keys[entry] = true
list = append(list, entry)
}
}
return list
}

22
engine/fov/precomputed_permissive/precomputed_permissive_test.go Normal file
View File

@ -0,0 +1,22 @@
package precomputed_permissive
import (
"fmt"
"lab.zaar.be/thefish/alchemyst-go/engine/fov/precomputed_shade"
"lab.zaar.be/thefish/alchemyst-go/engine/types"
"testing"
)
func TestDistance(t *testing.T) {
iterCoords := types.Coords{0,0}
fmt.Printf("\n dto: \t %v", iterCoords.DistanceTo(types.Coords{0,1}))
fmt.Printf("\n dto: \t %v", iterCoords.DistanceTo(types.Coords{0,5}))
fmt.Printf("\n dto: \t %v", iterCoords.DistanceTo(types.Coords{3,3}))
fmt.Printf("\n dto: \t %v", iterCoords.DistanceTo(types.Coords{100,0}))
}
func TestPrecomp(t *testing.T) {
ppFov := precomputed_shade.NewPrecomputedShade(20)
_ = ppFov
t.Log("ok")
}

281
engine/fov/precomputed_shade/precomputed_shade.go Normal file
View File

@ -0,0 +1,281 @@
package precomputed_shade
import (
"bytes"
"errors"
"lab.zaar.be/thefish/alchemyst-go/engine/fov/basic"
"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
"lab.zaar.be/thefish/alchemyst-go/engine/types"
"math"
"sort"
)
/*
Why am I here? Well, I just don't know what to call it - I'm sure it's an established method, and I'm aware there are probably optimisations to be had. I thought if I roughed out the algorithm here, the r/roguelikedev community would surely be able to help! I haven't included optimisations here, but if anyone wants them I got 'em :)
Method
Beforehand
List the cells in your largest-possible FOV, storing X and Y values relative to the center.
Store the distance from the center for each cell, and sort the list by this in ascending order.
Store the range of angles occludedAngles by each cell in this list, in clockwise order as absolute integers only.
Create a 360-char string of 0s called EmptyShade, and a 360-char string of 1s called FullShade
Runtime
Store two strings – CurrentShade and NextShade
Set CurrentShade to EmptyShade to start.
While CurrentShade =/= FullShade: step through the Cell List:
If the distance to the current cell is not equal to the previous distance checked then replace the contents of the
CurrentShade variable with the contents of the NextShade variable.
If the tested cell is opaque – for each angle in the range occludedAngles by the cell, place a 1 at the position
determined by angle%360 in the NextShade string.
For each angle in the range occludedAngles by the cell, add 1 to the shade value for that cell for each 0 encountered
at the position determined by angle%360 in the CurrentShade string.
Notes
Benefits
No messing around with octants
Highly efficient - each cell is only visited once, and checks within that cell are rare. It performs as fast as any
other LOS I've tried but with more options
Human-readable - code and output are highly legible, making it very easy to work with
Flexible - I'm using it for FOV, LOS, renderer, and lighting. Each process is calling the same function, within which
flags control how much data is evaluated and output. It only uses the data it needs to in the context where
its needed – so monsters that need a list of things they can see only check if a cell is visible or not, and don’t
bother calculating how much visibility they have there. This cuts processing dramatically.
Other links
cfov by Konstantin Stupnik on RogueTemple
Pre-Computed Visiblity Trees on RogueBasin
/r/roguelikedev FAQ Friday on FOV which kicked off this train of thought
/u/pnjeffries on his FOV algorithm which inspired this one
Adam Milazzo's FOV Method Roundup where a similar method described as 'permissive' is detailed
*/
var errNotFoundCell = errors.New("Cell not found")
var errOutOfBounds = errors.New("Cell out of bounds")
type Cell struct {
types.Coords
distance float64
occludedAngles []int //indexes of cells in CellList
shade int //shade value
}
type CellList []*Cell
type DistanceSorter CellList
func (a DistanceSorter) Len() int { return len(a) }
func (a DistanceSorter) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a DistanceSorter) Less(i, j int) bool { return a[i].distance < a[j].distance }
type precomputedShade struct {
initCoords types.Coords
MaxTorchRadius int
CellList CellList
FovMap [][]int
LightWalls bool
}
func NewPrecomputedShade(maxTorchRadius int) *precomputedShade {
result := &precomputedShade{MaxTorchRadius: maxTorchRadius, LightWalls: true}
result.PrecomputeFovMap()
return result
}
func (ps *precomputedShade) FindByCoords(c types.Coords) (int, *Cell, error) {
for i := range ps.CellList {
if ps.CellList[i].Coords == c {
// Found!
return i, ps.CellList[i], nil
}
}
return 0, &Cell{}, errNotFoundCell
}
func (ps *precomputedShade) IsInFov(coords types.Coords) bool {
rc := ps.fromLevelCoords(coords)
_, cell, err := ps.FindByCoords(rc)
if err != nil {
return false
}
return cell.shade > 0
}
func (ps *precomputedShade) SetLightWalls(value bool) {
ps.LightWalls = value
}
func (ps *precomputedShade) Init() {
ps.PrecomputeFovMap()
}
func (ps *precomputedShade) PrecomputeFovMap() {
max := ps.MaxTorchRadius
minusMax := (-1) * max
zeroCoords := types.Coords{0, 0}
var x, y int
//fill list
for x = minusMax; x < max+1; x++ {
for y = minusMax; y < max+1; y++ {
if x == 0 && y == 0 {
continue;
}
iterCoords := types.Coords{x, y}
distance := zeroCoords.DistanceTo(iterCoords)
if distance <= float64(max) {
ps.CellList = append(ps.CellList, &Cell{iterCoords, distance, nil, 0})
}
}
}
//Do not change cell order after this!
sort.Sort(DistanceSorter(ps.CellList))
//debug
//for _, cell := range ps.CellList {
// fmt.Printf("\n coords: %v, distance: %f, len_occl: %d", cell.Coords, cell.distance, len(cell.occludedAngles))
//}
//Bresanham lines / Raycast
var lineX, lineY float64
for i := 0; i < 360; i++ {
dx := math.Sin(float64(i) / (float64(180) / math.Pi))
dy := math.Cos(float64(i) / (float64(180) / math.Pi))
lineX = 0
lineY = 0
for j := 0; j < max; j++ {
lineX -= dx
lineY -= dy
roundedX := int(basic.Round(lineX))
roundedY := int(basic.Round(lineY))
_, cell, err := ps.FindByCoords(types.Coords{roundedX, roundedY})
if err != nil {
//inexistent coord found
break;
}
cell.occludedAngles = unique(append(cell.occludedAngles, i))
}
}
//for _, cell := range ps.CellList {
// fmt.Printf("\n coords: %v, distance: %f, len_occl: %d", cell.Coords, cell.distance, len(cell.occludedAngles))
//}
}
func (ps *precomputedShade) recalc(level *gamemap.Level, initCoords types.Coords, radius int) {
ps.initCoords = initCoords
if radius > ps.MaxTorchRadius {
radius = ps.MaxTorchRadius //fixme
}
level.Tiles[initCoords.X][initCoords.Y].Visible = true
var fullShade = make([]byte, 360)
for i := range fullShade {
fullShade[i] = 1
}
var emptyShade = make([]byte, 360)
currentShade := emptyShade
nextShade := emptyShade
i := 0
prevDistance := 0.0
for !bytes.Equal(currentShade, fullShade) {
if (i == len(ps.CellList)-1) {
break
}
cell := ps.CellList[i]
i++
if cell.distance != prevDistance {
currentShade = nextShade
}
if cell.distance > float64(radius) {
break
}
lc, err := ps.toLevelCoords(level, initCoords, cell.Coords)
if err != nil {
continue
}
//fmt.Printf("\n level coords: %v", lc)
if level.Tiles[lc.X][lc.Y].BlocksSight {
level.Tiles[lc.X][lc.Y].Visible = true
for _, angle := range cell.occludedAngles {
nextShade[angle] = 1
}
}
for _, angle := range cell.occludedAngles {
if currentShade[angle] == 0 {
cell.shade = cell.shade + 1
}
}
}
}
func (ps *precomputedShade) ComputeFov(level *gamemap.Level, initCoords types.Coords, radius int) {
ps.recalc(level, initCoords, radius)
for _, cell := range ps.CellList {
//fmt.Printf("\n coords: %v, distance: %f, shade: %d", cell.Coords, cell.distance, cell.shade)
if cell.shade > 0 {
cs, err := ps.toLevelCoords(level, initCoords, cell.Coords)
if err != nil {
continue
}
level.Tiles[cs.X][cs.Y].Visible = true
}
}
}
func (ps *precomputedShade) toLevelCoords(level *gamemap.Level, initCoords, relativeCoords types.Coords) (types.Coords, error) {
realCoords := types.Coords{initCoords.X + relativeCoords.X, initCoords.Y + relativeCoords.Y}
if !level.InBounds(realCoords) {
return types.Coords{}, errOutOfBounds
}
return realCoords, nil
}
func (ps *precomputedShade) fromLevelCoords(lc types.Coords) types.Coords {
relativeCoords := types.Coords{lc.X - ps.initCoords.X, lc.Y - ps.initCoords.Y}
return relativeCoords
}
func unique(intSlice []int) []int {
keys := make(map[int]bool)
list := []int{}
for _, entry := range intSlice {
if _, value := keys[entry]; !value {
keys[entry] = true
list = append(list, entry)
}
}
return list
}

85
engine/fov/precomputed_shade/precomputed_shade_test.go Normal file
View File

@ -0,0 +1,85 @@
package precomputed_shade
import (
"fmt"
"lab.zaar.be/thefish/alchemyst-go/engine/gamemap"
"lab.zaar.be/thefish/alchemyst-go/engine/types"
"testing"
)
func TestPsDistance(t *testing.T) {
iterCoords := types.Coords{0, 0}
fmt.Printf("\n dto: \t %v", iterCoords.DistanceTo(types.Coords{0, 1}))
fmt.Printf("\n dto: \t %v", iterCoords.DistanceTo(types.Coords{0, 5}))
fmt.Printf("\n dto: \t %v", iterCoords.DistanceTo(types.Coords{3, 3}))
fmt.Printf("\n dto: \t %v", iterCoords.DistanceTo(types.Coords{100, 0}))
}
func TestPrecompShade(t *testing.T) {
ppFov := NewPrecomputedShade(15)
_ = ppFov
t.Log("ok")
//level := gamemap.NewLevel(util.ClientCtx{}, "test", 1)
level := &gamemap.Level{
Name: "test1",
Depth: 1,
Rect: types.NewRect(0, 0, 20, 20),
}
level.Tiles = make([][]*gamemap.Tile, level.W)
for i := range level.Tiles {
level.Tiles[i] = make([]*gamemap.Tile, level.H)
}
var tile func() (*gamemap.Tile)
for x := 0; x < level.W; x++ {
for y := 0; y < level.H; y++ {
if x == 0 || y == 0 || x == (level.W-1) || y == (level.H-1) {
tile = gamemap.NewWall
} else {
tile = gamemap.NewFloor
}
level.Tiles[x][y] = tile()
}
}
playerCoords := types.Coords{10, 10}
level.Tiles[8][12] = gamemap.NewWall()
level.Tiles[10][8] = gamemap.NewWall()
level.Tiles[7][9] = gamemap.NewWall()
level.Tiles[7][11] = gamemap.NewWall()
level.Tiles[5][10] = gamemap.NewWall()
level.Tiles[10][11] = gamemap.NewWall()
level.Tiles[11][10] = gamemap.NewWall()
ppFov.ComputeFov(level, playerCoords, 15)
fmt.Printf("\n\n")
var render = func(x, y int) string {
if playerCoords.X == x && playerCoords.Y == y {
return "@"
}
result := level.Tiles[x][y].Char
if !level.Tiles[x][y].Visible {
result = "?"
}
return result
}
for y := 0; y < level.H; y++ {
for x := 0; x < level.W; x++ {
fmt.Printf("%s", render(x, y))
}
fmt.Printf("\n")
}
}

6
engine/gamemap/level.go
View File

@ -26,7 +26,9 @@ func (l *Level) Put (x, y int, tileFunc interface{}) {
if tf == nil {
l.ctx.Logger().Fatal().Msgf("Got non-tile type to put into level: %v", tf)
}
l.Tiles[x][y] = tf
if l.InBounds(types.Coords{x, y}) {
l.Tiles[x][y] = tf
}
}
func NewLevel(ctx util.ClientCtx, branch string, depth int) *Level {
@ -46,5 +48,5 @@ func NewLevel(ctx util.ClientCtx, branch string, depth int) *Level {
type Room struct {
*types.Rect
Center *types.Coords
Center types.Coords
}

5
engine/gamemap/mapgens/default.go
View File

@ -22,7 +22,7 @@ func DefaultGen(l *gamemap.Level) *gamemap.Level {
}
}
rooms := make([]*gamemap.Room, maxrooms)
rooms := make([]*gamemap.Room, 0)
for i := 0; i < maxrooms; i++ {
newRoom := &gamemap.Room{
@ -32,8 +32,7 @@ func DefaultGen(l *gamemap.Level) *gamemap.Level {
rng.Range(minRoomSize, maxRoomSize),
rng.Range(minRoomSize, maxRoomSize),
)}
newRoom.Center.X = newRoom.X + newRoom.W / 2
newRoom.Center.Y = newRoom.Y + newRoom.H / 2
newRoom.Center = types.Coords{newRoom.X + newRoom.W / 2, newRoom.Y + newRoom.H / 2}
failed := false
for _, otherRoom := range rooms {

1
engine/gamemap/tile.go
View File

@ -39,6 +39,7 @@ type Tile struct {
BlocksPass bool
BlocksSight bool
Explored bool
Visible bool
MustDraw bool
Colordance bool
}

2
engine/types/coords.go
View File

@ -10,7 +10,7 @@ func (c *Coords) Get() (int, int) {
return c.X, c.Y
}
func (c *Coords) DistanceTo(o *Coords) float64 {
func (c *Coords) DistanceTo(o Coords) float64 {
dx := c.X - o.X
dy := c.X - o.Y
return math.Sqrt(math.Pow(float64(dx), 2) + math.Pow(float64(dy), 2))

4
engine/types/rect.go
View File

@ -56,6 +56,6 @@ func (self *Rect) Intersects(other *Rect) bool {
return false
}
func (r *Rect) InBounds (x,y int) bool {
return x >= r.X && x <= (r.X + r.W) && y >= r.Y && y <= (r.Y + r.H)
func (r *Rect) InBounds (c Coords) bool {
return c.X >= r.X && c.X <= (r.X + r.W -1) && c.Y >= r.Y && c.Y <= (r.Y + r.H -1)
}

4
ui/mainwindow/layer.go
View File

@ -36,10 +36,14 @@ func (layer *Layer) WithColor(colorName string) *Layer {
func (layer *Layer) PutWithRawBackground(x,y int, symbol interface{}, bgColor uint32) {
layer.before()
prevColor := uint32(blt.State(blt.TK_COLOR))
prevCompMode := blt.State(blt.TK_COMPOSITION)
blt.Color(bgColor)
blt.Composition(1)
layer.Put(x,y,"█")
blt.Color(prevColor)
layer.Put(x,y, symbol)
blt.Composition(prevCompMode)
}
func (layer *Layer) PutWithBackground(x,y int, symbol interface{}, bgColorName string) {

53
ui/mainwindow/viewport.go
View File

@ -2,25 +2,40 @@ package mainwindow
import (
"errors"
"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/types"
)
var NotInViewError = errors.New("not in ViewPort")
const FPS_LIMIT = 60
type ViewPort struct {
*types.Rect
level *gamemap.Level
layer *Layer
Fov fov.Fov
playerCoords types.Coords
playerTorchRadius int
}
func NewViewPort(x, y, w, h int, level *gamemap.Level, layer *Layer) *ViewPort {
return &ViewPort{
//fixme
fov := precomputed_shade.NewPrecomputedShade(15)
fov.Init()
vp := ViewPort{
Rect: &types.Rect{x, y, w, h},
level: level,
layer: layer,
Fov: fov,
}
vp.playerCoords = types.Coords{10,10}
vp.playerTorchRadius = 10
return &vp
}
func (vp *ViewPort) Move(c *types.Coords) {
@ -52,34 +67,35 @@ func (vp *ViewPort) ToVPCoords(c *types.Coords) (newCoords *types.Coords, err er
return &types.Coords{x, y}, nil
}
//call only from main thread
////call only from main thread
//func (vp *ViewPort) Render() {
// //fixme get these from state chan(s)
// var fpsTicker int
// var fovRecompute bool
// var fovRecompute bool = true
// redraw := false
// //fixme get player instance
//
// vp.Move(player.Coords)
// vp.Move(&vp.playerCoords)
// //fixme detect fovRecompute
// if fovRecompute {
// vp.layer.Clear(vp.Rect)
// fovRecompute = false
// redraw = true
// //fixme
// vp.level.ComputeFov(FovMap, player.Coords, player.TorchRadius, FovLightWalls, FovAlgo)
//
// vp.Fov.ComputeFov(vp.level, vp.playerCoords, vp.playerTorchRadius)
// }
// //increase ticker
// fpsTicker++
//
// if redraw || fpsTicker % (FPS_LIMIT / 10) == 0 {
// fpsTicker := 0
// if redraw || fpsTicker%(FPS_LIMIT/10) == 0 {
// fpsTicker = 0
//
// for y:=0; y < vp.H; y++ {
// for x:=0; x<vp.W; x++ {
// 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.IsInFov(mapCoords)
// visible := vp.Fov.IsInFov(mapCoords)
// if !visible {
// if tile.MustDraw {
// //darkened version of landscape
@ -98,4 +114,19 @@ func (vp *ViewPort) ToVPCoords(c *types.Coords) (newCoords *types.Coords, err er
// }
//
// }
//}
//}
func (vp *ViewPort) Render() {
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]
fg := tile.ColorSet.Fg()
bg := tile.ColorSet.Bg()
vp.layer.WithRawColor(fg).
PutWithRawBackground(mapCoords.X, mapCoords.Y, tile.Char, bg)
}
}
}