158 lines
3.2 KiB
Go
158 lines
3.2 KiB
Go
// Package path implements pathfinding.
|
|
package path
|
|
|
|
import (
|
|
"github.com/Tnze/go-mc/bot/world"
|
|
"github.com/Tnze/go-mc/data/block"
|
|
"github.com/beefsack/go-astar"
|
|
)
|
|
|
|
type V3 struct {
|
|
X, Y, Z int
|
|
}
|
|
|
|
func (v V3) Cost(other V3) float64 {
|
|
x, y, z := v.X-other.X, v.Y-other.Y, v.Z-other.Z
|
|
return float64(x*x+z*z) + 1.2*float64(y*y)
|
|
}
|
|
|
|
// Nav represents a navigation to a position.
|
|
type Nav struct {
|
|
World *world.World
|
|
Start, Dest V3
|
|
}
|
|
|
|
func (n *Nav) Path() (path []astar.Pather, distance float64, found bool) {
|
|
return astar.Path(
|
|
Tile{ // Start point
|
|
Nav: n,
|
|
Movement: Waypoint,
|
|
Pos: n.Start,
|
|
},
|
|
Tile{ // Destination point
|
|
Nav: n,
|
|
Movement: Waypoint,
|
|
Pos: n.Dest,
|
|
})
|
|
}
|
|
|
|
// Movement represents a single type of movement in a path.
|
|
type Movement uint8
|
|
|
|
var allMovements = []Movement{TraverseNorth, TraverseSouth, TraverseEast, TraverseWest}
|
|
|
|
// Valid movement values.
|
|
const (
|
|
Waypoint Movement = iota
|
|
TraverseNorth
|
|
TraverseSouth
|
|
TraverseEast
|
|
TraverseWest
|
|
)
|
|
|
|
// Tile represents a point in a path. All tiles in a path are adjaceent their
|
|
// preceeding tiles.
|
|
type Tile struct {
|
|
Nav *Nav
|
|
|
|
Movement Movement
|
|
Pos V3
|
|
}
|
|
|
|
func (t Tile) PathNeighborCost(to astar.Pather) float64 {
|
|
other := to.(Tile)
|
|
return 1 + other.Movement.BaseCost()
|
|
}
|
|
|
|
func (t Tile) PathEstimatedCost(to astar.Pather) float64 {
|
|
other := to.(Tile)
|
|
cost := t.Pos.Cost(other.Pos)
|
|
return cost + other.Movement.BaseCost()
|
|
}
|
|
|
|
func (t Tile) PathNeighbors() []astar.Pather {
|
|
possibles := make([]astar.Pather, 0, 8)
|
|
|
|
if t.Pos == t.Nav.Dest && t.Movement != Waypoint {
|
|
dupe := t
|
|
dupe.Movement = Waypoint
|
|
return []astar.Pather{dupe}
|
|
}
|
|
|
|
for _, m := range allMovements {
|
|
x, y, z := m.Offset()
|
|
pos := V3{X: t.Pos.X + x, Y: t.Pos.Y + y, Z: t.Pos.Z + z}
|
|
if m.Possible(t.Nav, pos.X, pos.Y, pos.Z) {
|
|
possibles = append(possibles, Tile{
|
|
Nav: t.Nav,
|
|
Movement: m,
|
|
Pos: pos,
|
|
})
|
|
}
|
|
}
|
|
|
|
// fmt.Printf("%v.Neighbours(): %+v\n", t.Pos, possibles)
|
|
return possibles
|
|
}
|
|
|
|
func (m Movement) Possible(nav *Nav, x, y, z int) bool {
|
|
// fmt.Printf("%s.Possible(%d,%d,%d)\n", m, x, y, z)
|
|
switch m {
|
|
case Waypoint, TraverseNorth, TraverseSouth, TraverseEast, TraverseWest:
|
|
b := nav.World.GetBlockStatus(x, y, z)
|
|
if _, safe := safeStepBlocks[b]; !safe {
|
|
return false
|
|
}
|
|
above1 := uint32(nav.World.GetBlockStatus(x, y+1, z))
|
|
above2 := uint32(nav.World.GetBlockStatus(x, y+2, z))
|
|
return above1 == block.Air.MinStateID && above2 == block.Air.MinStateID
|
|
default:
|
|
panic(m)
|
|
}
|
|
}
|
|
|
|
func (m Movement) Offset() (x, y, z int) {
|
|
switch m {
|
|
case Waypoint:
|
|
return 0, 0, 0
|
|
case TraverseNorth:
|
|
return 0, 0, -1
|
|
case TraverseSouth:
|
|
return 0, 0, 1
|
|
case TraverseEast:
|
|
return 1, 0, 0
|
|
case TraverseWest:
|
|
return -1, 0, 0
|
|
default:
|
|
panic(m)
|
|
}
|
|
}
|
|
|
|
func (m Movement) BaseCost() float64 {
|
|
switch m {
|
|
case Waypoint:
|
|
return 0
|
|
case TraverseNorth, TraverseSouth, TraverseEast, TraverseWest:
|
|
return 1
|
|
default:
|
|
panic(m)
|
|
}
|
|
}
|
|
|
|
func (m Movement) String() string {
|
|
switch m {
|
|
case Waypoint:
|
|
return "waypoint"
|
|
case TraverseNorth:
|
|
return "traverse-north"
|
|
case TraverseSouth:
|
|
return "traverse-south"
|
|
case TraverseEast:
|
|
return "traverse-east"
|
|
case TraverseWest:
|
|
return "traverse-west"
|
|
default:
|
|
panic(m)
|
|
}
|
|
}
|