gravestench/OpenDiablo2
1
1
Fork 0
mirror of https://github.com/OpenDiablo2/OpenDiablo2 synced 2024-06-28 10:05:23 +00:00
Code Issues Releases Wiki Activity

lint updates for /d2astar (#507)

Browse Source
This commit is contained in:
thetogi 2020-07-01 00:13:25 -04:00 committed by GitHub
parent 0f9e846834
commit 5b26624cb8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 31 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
d2common/d2astar/goreland_example.go
View File

@ -4,28 +4,29 @@ package d2astar
// the sake of testing. This functionality forms the back end for // the sake of testing. This functionality forms the back end for
// goreland_test.go, and serves as an example for how to use A* for a graph. // goreland_test.go, and serves as an example for how to use A* for a graph.
// The Magical World of Goreland, is where Ted Stevens and Al Gore are from. // The Magical World of Goreland, is where Ted Stevens and Al Gore are from.
// //
// It is composed of Big Trucks, and a Series of Tubes! // It is composed of Big Trucks, and a Series of Tubes!
// //
// Ok, it is basically just a Graph. // Ok, it is basically just a Graph.
// Nodes are called "Trucks" and they have X, Y coordinates // Nodes are called "Trucks" and they have X, Y coordinates
// Edges are called "Tubes", they connect Trucks, and they have a cost // Edges are called "Tubes", they connect Trucks, and they have a cost
// //
// The key differences between this example and the Tile world: // The key differences between this example and the Tile world:
// 1) There is no grid. Trucks have arbitrary coordinates. // 1) There is no grid. Trucks have arbitrary coordinates.
// 2) Edges are not implied by the grid positions. Instead edges are explicitly // 2) Edges are not implied by the grid positions. Instead edges are explicitly
// modelled as Tubes. // modelled as Tubes.
// //
// The key similarities between this example and the Tile world: // The key similarities between this example and the Tile world:
// 1) They both use Manhattan distance as their heuristic // 1) They both use Manhattan distance as their heuristic
// 2) Both implement Pather // 2) Both implement Pather
//Goreland represents a world of trucks and tubes.
type Goreland struct { type Goreland struct {
// trucks map[int]*Truck // not needed really // trucks map[int]*Truck // not needed really
} }
//Tube is an edge. They connect Trucks, and have a cost.
type Tube struct { type Tube struct {
from *Truck from *Truck
to *Truck to *Truck
@ -39,7 +40,7 @@ type Truck struct {
X, Y int X, Y int
// array of tubes going to other trucks // array of tubes going to other trucks
out_to []Tube outTo []Tube
label string label string
} }
@ -49,8 +50,8 @@ func (t *Truck) PathNeighbors() []Pather {
neighbors := []Pather{} neighbors := []Pather{}
for _, tube_element := range t.out_to { for _, tubeElement := range t.outTo {
neighbors = append(neighbors, Pather(tube_element.to)) neighbors = append(neighbors, Pather(tubeElement.to))
} }
return neighbors return neighbors
} }
@ -58,9 +59,9 @@ func (t *Truck) PathNeighbors() []Pather {
// PathNeighborCost returns the cost of the tube leading to Truck. // PathNeighborCost returns the cost of the tube leading to Truck.
func (t *Truck) PathNeighborCost(to Pather) float64 { func (t *Truck) PathNeighborCost(to Pather) float64 {
for _, tube_element := range (t).out_to { for _, tubeElement := range (t).outTo {
if Pather((tube_element.to)) == to { if Pather((tubeElement.to)) == to {
return tube_element.Cost return tubeElement.Cost
} }
} }
return 10000000 return 10000000

38
d2common/d2astar/goreland_test.go
View File

@ -19,51 +19,51 @@ func AddTube(t1, t2 *Truck, cost float64) *Tube {
tube1.from = t1 tube1.from = t1
tube1.to = t2 tube1.to = t2
t1.out_to = append(t1.out_to, *tube1) t1.outTo = append(t1.outTo, *tube1)
t2.out_to = append(t2.out_to, *tube1) t2.outTo = append(t2.outTo, *tube1)
return tube1 return tube1
} }
// Consider a world with Nodes (Trucks) and Edges (Tubes), Edges each having a cost // Consider a world with Nodes (Trucks) and Edges (Tubes), Edges each having a cost
// //
// E // E
// /| // /|
// / | // / |
// S--M // S--M
// //
// S=Start at (0,0) // S=Start at (0,0)
// E=End at (1,1) // E=End at (1,1)
// M=Middle at (0,1) // M=Middle at (0,1)
// //
// S-M and M-E are clean clear tubes. cost: 1 // S-M and M-E are clean clear tubes. cost: 1
// //
// S-E is either: // S-E is either:
// //
// 1) TestGraphPath_ShortDiagonal : diagonal is a nice clean clear Tube , cost: 1.9 // 1) TestGraphPath_ShortDiagonal : diagonal is a nice clean clear Tube , cost: 1.9
// Solver should traverse the bridge. // Solver should traverse the bridge.
// Expect solution: Start, End Total cost: 1.9 // Expect solution: Start, End Total cost: 1.9
// //
// 1) TestGraphPath_LongDiagonal : diagonal is a Tube plugged full of // 1) TestGraphPath_LongDiagonal : diagonal is a Tube plugged full of
// "enormous amounts of material"!, cost: 10000. // "enormous amounts of material"!, cost: 10000.
// Solver should avoid the plugged tube. // Solver should avoid the plugged tube.
// Expect solution Start,Middle,End Total cost: 2.0 // Expect solution Start,Middle,End Total cost: 2.0
func createGorelandGraphPath_Diagonal(t *testing.T, diagonal_cost float64, expectedDist float64) { func createGorelandGraphPathDiagonal(t *testing.T, diagonalCost float64, expectedDist float64) {
world := new(Goreland) world := new(Goreland)
tr_start := AddTruck(0, 0, "Start") trStart := AddTruck(0, 0, "Start")
tr_mid := AddTruck(0, 1, "Middle") trMid := AddTruck(0, 1, "Middle")
tr_end := AddTruck(1, 1, "End") trEnd := AddTruck(1, 1, "End")
AddTube(tr_start, tr_end, diagonal_cost) AddTube(trStart, trEnd, diagonalCost)
AddTube(tr_start, tr_mid, 1) AddTube(trStart, trMid, 1)
AddTube(tr_mid, tr_end, 1) AddTube(trMid, trEnd, 1)
t.Logf("Goreland. Diagonal cost: %v\n\n", diagonal_cost) t.Logf("Goreland. Diagonal cost: %v\n\n", diagonalCost)
p, dist, found := Path(tr_start, tr_end, math.MaxFloat64) p, dist, found := Path(trStart, trEnd, math.MaxFloat64)
if !found { if !found {
t.Log("Could not find a path") t.Log("Could not find a path")
@ -79,8 +79,8 @@ func createGorelandGraphPath_Diagonal(t *testing.T, diagonal_cost float64, expec
} }
func TestGraphPaths_ShortDiagonal(t *testing.T) { func TestGraphPaths_ShortDiagonal(t *testing.T) {
createGorelandGraphPath_Diagonal(t, 1.9, 1.9) createGorelandGraphPathDiagonal(t, 1.9, 1.9)
} }
func TestGraphPaths_LongDiagonal(t *testing.T) { func TestGraphPaths_LongDiagonal(t *testing.T) {
createGorelandGraphPath_Diagonal(t, 10000, 2.0) createGorelandGraphPathDiagonal(t, 10000, 2.0)
} }