map.go

   1 package main
   2
   3 import (
   4         "github.com/anon55555/mt"
   5         "github.com/dragonfireclient/hydra-dragonfire/convert"
   6         "github.com/yuin/gopher-lua"
   7         "sync"
   8 )
   9
  10 type MapBlk struct {
  11         data  *mt.MapBlk
  12         edges [6]*PathfindEdge
  13 }
  14
  15 type Map struct {
  16         mu       sync.Mutex
  17         pathfind bool
  18         blocks   map[[3]int16]*MapBlk
  19         userdata *lua.LUserData
  20 }
  21
  22 var mapFuncs = map[string]lua.LGFunction{
  23         "block": l_map_block,
  24         "node":  l_map_node,
  25 }
  26
  27 func getMap(l *lua.LState, idx int) *Map {
  28         return l.CheckUserData(idx).Value.(*Map)
  29 }
  30
  31 func newMap(l *lua.LState) *Map {
  32         mp := &Map{}
  33         mp.blocks = map[[3]int16]*MapBlk{}
  34         mp.userdata = l.NewUserData()
  35         mp.userdata.Value = mp
  36         l.SetMetatable(mp.userdata, l.GetTypeMetatable("hydra.map"))
  37         return mp
  38 }
  39
  40 func (mp *Map) process(client *Client, pkt *mt.Pkt) {
  41         switch cmd := pkt.Cmd.(type) {
  42         case *mt.ToCltBlkData:
  43                 go func() {
  44                         mp.mu.Lock()
  45                         defer mp.mu.Unlock()
  46
  47                         blk := &MapBlk{}
  48                         blk.data = &cmd.Blk
  49                         if mp.pathfind {
  50                                 pfPreprocess(mp, cmd.Blkpos, blk)
  51                         }
  52
  53                         mp.blocks[cmd.Blkpos] = blk
  54                 }()
  55
  56                 client.conn.SendCmd(&mt.ToSrvGotBlks{Blks: [][3]int16{cmd.Blkpos}})
  57         }
  58 }
  59
  60 func l_map(l *lua.LState) int {
  61         mp := newMap(l)
  62         mp.pathfind = l.ToBool(1)
  63         l.Push(mp.userdata)
  64         return 1
  65 }
  66
  67 func l_map_block(l *lua.LState) int {
  68         mp := getMap(l, 1)
  69         var blkpos [3]int16
  70         convert.ReadVec3Int16(l, l.Get(2), &blkpos)
  71
  72         mp.mu.Lock()
  73         defer mp.mu.Unlock()
  74
  75         blk, ok := mp.blocks[blkpos]
  76         if ok {
  77                 l.Push(convert.PushMapBlk(l, *blk.data))
  78         } else {
  79                 l.Push(lua.LNil)
  80         }
  81
  82         return 1
  83 }
  84
  85 func l_map_node(l *lua.LState) int {
  86         mp := getMap(l, 1)
  87
  88         var pos [3]int16
  89         convert.ReadVec3Int16(l, l.Get(2), &pos)
  90         blkpos, i := mt.Pos2Blkpos(pos)
  91
  92         mp.mu.Lock()
  93         defer mp.mu.Unlock()
  94
  95         blk, blk_ok := mp.blocks[blkpos]
  96         if blk_ok {
  97                 meta, meta_ok := blk.data.NodeMetas[i]
  98                 if !meta_ok {
  99                         meta = &mt.NodeMeta{}
 100                 }
 101
 102                 lnode := l.NewTable()
 103                 l.SetField(lnode, "param0", lua.LNumber(blk.data.Param0[i]))
 104                 l.SetField(lnode, "param1", lua.LNumber(blk.data.Param1[i]))
 105                 l.SetField(lnode, "param2", lua.LNumber(blk.data.Param2[i]))
 106                 l.SetField(lnode, "meta", convert.PushNodeMeta(l, *meta))
 107                 l.Push(lnode)
 108         } else {
 109                 l.Push(lua.LNil)
 110         }
 111
 112         return 1
 113 }