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

precomputed shade wall lighting

Browse Source
This commit is contained in:
anton.gurov 2019-10-31 16:30:12 +03:00
parent 1c44dd0885
commit cddc5fa70f
3 changed files with 58 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -9,56 +9,7 @@ import (
"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
*/
//Incomplete implementation of permissive algo with precomputation
var NotFoundCell = errors.New("Cell not found")

85
engine/fov/precomputed_shade/precomputed_shade.go
View File

@ -10,35 +10,47 @@ import (
"sort"
)
//Реализация алгоритма от chilly_durango
//https://www.reddit.com/r/roguelikedev/comments/5n1tx3/fov_algorithm_sharencompare/
//Пока не побеждена засветка стен (или это у меня руки кривые) - сложность почти O(N^2)
//Не только у меня:
//chilly_durango:
//I turned down the Radio 4 in my car to think about this on the way home - that's how much this question has been
// bugging me. The two best from all the awful compromises I could consider were:
// - Only lighting walls with light from the player (cheap trick, dutch)
// - Match light value for walls with the highest light value in adjacent floor cell visible to player (seems costly)
/*
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 :)
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
- 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
- Store two strings – CurrentShade and NextShade
- Set CurrentShade to EmptyShade to start.
- While CurrentShade =/= FullShade: step through the Cell List:
Set CurrentShade to EmptyShade to start.
- 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.
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
- 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 lit value for that cell for each 0 encountered
at the position determined by angle%360 in the CurrentShade string.
- For each angle in the range occludedAngles by the cell, add 1 to the lit value for that cell for each 0
encountered at the position determined by angle%360 in the CurrentShade string.
Notes
Benefits
@ -74,9 +86,8 @@ var errOutOfBounds = errors.New("Cell out of bounds")
type Cell struct {
types.Coords
distance float64
occludedAngles []int //indexes of cells in CellList
lit int //lit value
wasOccluded bool
occludedAngles []int //angles occluded by this cell
lit int //light "amount"
}
type CellList []*Cell
@ -88,10 +99,9 @@ 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
originCoords types.Coords
MaxTorchRadius int
CellList CellList
FovMap [][]int
LightWalls bool
}
@ -142,7 +152,7 @@ func (ps *precomputedShade) PrecomputeFovMap() {
iterCoords := types.Coords{x, y}
distance := zeroCoords.DistanceTo(iterCoords)
if distance <= float64(max) {
ps.CellList = append(ps.CellList, &Cell{iterCoords, distance, nil, 0, false})
ps.CellList = append(ps.CellList, &Cell{iterCoords, distance, nil, 0})
}
}
}
@ -186,7 +196,7 @@ func (ps *precomputedShade) PrecomputeFovMap() {
func (ps *precomputedShade) recalc(level *gamemap.Level, initCoords types.Coords, radius int) {
ps.initCoords = initCoords
ps.originCoords = initCoords
if radius > ps.MaxTorchRadius {
radius = ps.MaxTorchRadius //fixme
@ -235,11 +245,6 @@ func (ps *precomputedShade) recalc(level *gamemap.Level, initCoords types.Coords
}
}
if level.GetTile(lc).BlocksSight {
level.GetTile(lc).Visible = true
}
}
}
@ -249,13 +254,29 @@ func (ps *precomputedShade) ComputeFov(level *gamemap.Level, initCoords types.Co
for _, cell := range ps.CellList {
//fmt.Printf("\n coords: %v, distance: %f, lit: %d", cell.Coords, cell.distance, cell.lit)
if cell.lit > 0 {
cs, err := ps.toLevelCoords(level, initCoords, cell.Coords)
if cell.lit > 0 {
if err != nil {
continue
}
level.GetTile(cs).Visible = true
}
//light walls, crutch
if level.GetTile(cs).BlocksSight && ps.LightWalls {
if cell.IsAdjacentTo(&types.Coords{0,0}) {
level.GetTile(cs).Visible = true
} else {
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.lit > 0 { //magic constant!
level.GetTile(cs).Visible = true
}
}
}
}
}
}
@ -268,7 +289,7 @@ func (ps *precomputedShade) toLevelCoords(level *gamemap.Level, initCoords, rela
}
func (ps *precomputedShade) fromLevelCoords(lc types.Coords) types.Coords {
relativeCoords := types.Coords{lc.X - ps.initCoords.X, lc.Y - ps.initCoords.Y}
relativeCoords := types.Coords{lc.X - ps.originCoords.X, lc.Y - ps.originCoords.Y}
return relativeCoords
}

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

@ -54,6 +54,9 @@ func TestPrecompShade(t *testing.T) {
level.SetTileByXY(5, 10, gamemap.NewWall())
level.SetTileByXY(10, 11, gamemap.NewWall())
level.SetTileByXY(10, 12, gamemap.NewWall())
level.SetTileByXY(10, 13, gamemap.NewWall())
level.SetTileByXY(11, 10, gamemap.NewWall())
ppFov.ComputeFov(level, playerCoords, 12)