Add path finding

[hydra-dragonfire.git] / map.go

diff --git a/map.go b/map.go
index 1ffae233dc6940a63cf58c1ca343261bc845c464..f877dcaa14347ed66bf8283c1dcbf1beeee7b7b7 100644 (file)
--- a/map.go
+++ b/map.go
@@ -7,15 +7,22 @@ import (
        "sync"
 )
 
+type MapBlk struct {
+       data      *mt.MapBlk
+       pathNodes map[[3]int16]*PathNode
+}
+
 type Map struct {
        mu       sync.Mutex
-       blocks   map[[3]int16]*mt.MapBlk
+       pathfind bool
+       blocks   map[[3]int16]*MapBlk
        userdata *lua.LUserData
 }
 
 var mapFuncs = map[string]lua.LGFunction{
        "block": l_map_block,
        "node":  l_map_node,
+       "path":  l_map_path,
 }
 
 func getMap(l *lua.LState, idx int) *Map {
@@ -24,7 +31,7 @@ func getMap(l *lua.LState, idx int) *Map {
 
 func newMap(l *lua.LState) *Map {
        mp := &Map{}
-       mp.blocks = map[[3]int16]*mt.MapBlk{}
+       mp.blocks = map[[3]int16]*MapBlk{}
        mp.userdata = l.NewUserData()
        mp.userdata.Value = mp
        l.SetMetatable(mp.userdata, l.GetTypeMetatable("hydra.map"))
@@ -34,15 +41,31 @@ func newMap(l *lua.LState) *Map {
 func (mp *Map) process(client *Client, pkt *mt.Pkt) {
        switch cmd := pkt.Cmd.(type) {
        case *mt.ToCltBlkData:
-               mp.mu.Lock()
-               mp.blocks[cmd.Blkpos] = &cmd.Blk
-               mp.mu.Unlock()
+               go func() {
+                       mp.mu.Lock()
+                       defer mp.mu.Unlock()
+
+                       blk := &MapBlk{}
+                       blk.data = &cmd.Blk
+
+                       if mp.pathfind {
+                               if oldblk, ok := mp.blocks[cmd.Blkpos]; ok {
+                                       pathRemoveBlock(oldblk)
+                               }
+
+                               pathAddBlock(mp, blk, cmd.Blkpos)
+                       }
+
+                       mp.blocks[cmd.Blkpos] = blk
+               }()
+
                client.conn.SendCmd(&mt.ToSrvGotBlks{Blks: [][3]int16{cmd.Blkpos}})
        }
 }
 
 func l_map(l *lua.LState) int {
        mp := newMap(l)
+       mp.pathfind = l.ToBool(1)
        l.Push(mp.userdata)
        return 1
 }
@@ -55,9 +78,9 @@ func l_map_block(l *lua.LState) int {
        mp.mu.Lock()
        defer mp.mu.Unlock()
 
-       block, ok := mp.blocks[blkpos]
+       blk, ok := mp.blocks[blkpos]
        if ok {
-               l.Push(convert.PushMapBlk(l, *block))
+               l.Push(convert.PushMapBlk(l, *blk.data))
        } else {
                l.Push(lua.LNil)
        }
@@ -75,17 +98,17 @@ func l_map_node(l *lua.LState) int {
        mp.mu.Lock()
        defer mp.mu.Unlock()
 
-       block, block_exists := mp.blocks[blkpos]
-       if block_exists {
-               meta, meta_exists := block.NodeMetas[i]
-               if !meta_exists {
+       blk, blk_ok := mp.blocks[blkpos]
+       if blk_ok {
+               meta, meta_ok := blk.data.NodeMetas[i]
+               if !meta_ok {
                        meta = &mt.NodeMeta{}
                }
 
                lnode := l.NewTable()
-               l.SetField(lnode, "param0", lua.LNumber(block.Param0[i]))
-               l.SetField(lnode, "param1", lua.LNumber(block.Param1[i]))
-               l.SetField(lnode, "param2", lua.LNumber(block.Param2[i]))
+               l.SetField(lnode, "param0", lua.LNumber(blk.data.Param0[i]))
+               l.SetField(lnode, "param1", lua.LNumber(blk.data.Param1[i]))
+               l.SetField(lnode, "param2", lua.LNumber(blk.data.Param2[i]))
                l.SetField(lnode, "meta", convert.PushNodeMeta(l, *meta))
                l.Push(lnode)
        } else {
@@ -94,3 +117,20 @@ func l_map_node(l *lua.LState) int {
 
        return 1
 }
+
+func l_map_path(l *lua.LState) int {
+       mp := getMap(l, 1)
+       if !mp.pathfind {
+               panic("map not configured to support path finding")
+       }
+
+       var src, dst [3]int16
+       convert.ReadVec3Int16(l, l.Get(2), &src)
+       convert.ReadVec3Int16(l, l.Get(3), &dst)
+
+       mp.mu.Lock()
+       defer mp.mu.Unlock()
+
+       l.Push(pathFind(mp, [2][3]int16{src, dst}, l))
+       return 1
+}