Add serialization

diff --git a/deserialize.go b/deserialize.go
index a6bc96563d4c65889e84212049d7fe75461bdcd5..7e52effcf1495ff505f4889d4e6e7ac7fd4fecc2 100644 (file)
--- a/deserialize.go
+++ b/deserialize.go
@@ -9,39 +9,16 @@ import (
        "io"
 )
 
-type MapBlk struct {
-       mt.MapBlk
-       Flags            MapBlkFlags
-       LightingComplete uint16
-       StaticObjs       []StaticObj
-       Timestamp        uint32
-}
-
-type MapBlkFlags uint8
-
-const (
-       IsUnderground MapBlkFlags = 1 << iota
-       DayNightDiffers
-       NotGenerated = 1 << 4
-)
-
-var SerializeVer uint8 = 28
-
 var (
        ErrInvalidSerializeVer = errors.New("invalid serialize version")
        ErrInvalidContentWidth = errors.New("invalid content width")
        ErrInvalidParamsWidth  = errors.New("invalid params width")
        ErrInvalidNodeMetaVer  = errors.New("invalid node meta version")
        ErrInvalidNameIdMapVer = errors.New("invalid name id mapping version")
+       ErrInvalidStaticObjVer = errors.New("invalid static object version")
        ErrInvalidNode         = errors.New("invalid node")
 )
 
-type StaticObj struct {
-       Type uint8
-       Pos  [3]float32
-       Data string
-}
-
 func Deserialize(data []byte, idNameMap map[string]mt.Content) (blk *MapBlk, err error) {
        r := bytes.NewReader(data)
        blk = &MapBlk{}
@@ -68,7 +45,7 @@ func Deserialize(data []byte, idNameMap map[string]mt.Content) (blk *MapBlk, err
                return nil, err
        }
 
-       if contentWidth != 2 {
+       if contentWidth != ContentWidth {
                return nil, ErrInvalidContentWidth
        }
 
@@ -77,7 +54,7 @@ func Deserialize(data []byte, idNameMap map[string]mt.Content) (blk *MapBlk, err
                return nil, err
        }
 
-       if paramsWidth != 2 {
+       if paramsWidth != ParamsWidth {
                return nil, ErrInvalidParamsWidth
        }
 
@@ -112,7 +89,7 @@ func Deserialize(data []byte, idNameMap map[string]mt.Content) (blk *MapBlk, err
                        return nil, err
                }
 
-               if version != 2 {
+               if version != NodeMetaVer {
                        return nil, ErrInvalidNodeMetaVer
                }
 
@@ -187,6 +164,10 @@ func Deserialize(data []byte, idNameMap map[string]mt.Content) (blk *MapBlk, err
                return nil, err
        }
 
+       if staticObjVer != StaticObjVer {
+               return nil, ErrInvalidStaticObjVer
+       }
+
        var staticObjCount uint16
        if err := binary.Read(r, binary.BigEndian, &staticObjCount); err != nil {
                return nil, err
@@ -235,7 +216,7 @@ func Deserialize(data []byte, idNameMap map[string]mt.Content) (blk *MapBlk, err
                return nil, err
        }
 
-       if nameIdMapVer != 0 {
+       if nameIdMapVer != NameIdMapVer {
                return nil, ErrInvalidNameIdMapVer
        }
 
@@ -252,7 +233,7 @@ func Deserialize(data []byte, idNameMap map[string]mt.Content) (blk *MapBlk, err
                        return nil, err
                }
 
-               var nameLen mt.Content
+               var nameLen uint16
                if err := binary.Read(r, binary.BigEndian, &nameLen); err != nil {
                        return nil, err
                }

diff --git a/serialize.go b/serialize.go
new file mode 100644 (file)
index 0000000..6fdf68d
--- /dev/null
+++ b/serialize.go
@@ -0,0 +1,176 @@
+package mtmap
+
+import (
+       "bytes"
+       "compress/zlib"
+       "encoding/binary"
+       "github.com/anon55555/mt"
+       "io"
+)
+
+func Serialize(blk *MapBlk, w io.Writer, idNameMap map[string]mt.Content) error {
+       if err := binary.Write(w, binary.BigEndian, &SerializeVer); err != nil {
+               return err
+       }
+
+       if err := binary.Write(w, binary.BigEndian, &blk.Flags); err != nil {
+               return err
+       }
+
+       if err := binary.Write(w, binary.BigEndian, &blk.LightingComplete); err != nil {
+               return err
+       }
+
+       if err := binary.Write(w, binary.BigEndian, &ContentWidth); err != nil {
+               return err
+       }
+
+       if err := binary.Write(w, binary.BigEndian, &ParamsWidth); err != nil {
+               return err
+       }
+
+       {
+               var buf bytes.Buffer
+               zw := zlib.NewWriter(&buf)
+
+               if err := binary.Write(zw, binary.BigEndian, &blk.Param0); err != nil {
+                       return err
+               }
+
+               if err := zw.Close(); err != nil {
+                       return err
+               }
+
+               if _, err := buf.WriteTo(w); err != nil {
+                       return err
+               }
+       }
+
+       {
+               var buf bytes.Buffer
+               zw := zlib.NewWriter(&buf)
+
+               if err := binary.Write(zw, binary.BigEndian, &NodeMetaVer); err != nil {
+                       return err
+               }
+
+               var count = uint16(len(blk.NodeMetas))
+               if err := binary.Write(zw, binary.BigEndian, &count); err != nil {
+                       return err
+               }
+
+               for pos, data := range blk.NodeMetas {
+                       if err := binary.Write(zw, binary.BigEndian, &pos); err != nil {
+                               return err
+                       }
+
+                       var num = uint32(len(data.Fields))
+                       if err := binary.Write(zw, binary.BigEndian, &num); err != nil {
+                               return err
+                       }
+
+                       for _, field := range data.Fields {
+                               var lenName = uint16(len(field.Name))
+                               if err := binary.Write(zw, binary.BigEndian, &lenName); err != nil {
+                                       return err
+                               }
+
+                               var name = []byte(field.Name)
+                               if err := binary.Write(zw, binary.BigEndian, &name); err != nil {
+                                       return err
+                               }
+
+                               var lenValue = uint32(len(field.Value))
+                               if err := binary.Write(zw, binary.BigEndian, &lenValue); err != nil {
+                                       return err
+                               }
+
+                               var value = []byte(field.Value)
+                               if err := binary.Write(zw, binary.BigEndian, &value); err != nil {
+                                       return err
+                               }
+
+                               if err := binary.Write(zw, binary.BigEndian, &field.Private); err != nil {
+                                       return err
+                               }
+                       }
+
+                       if err := data.Inv.Serialize(zw); err != nil {
+                               return err
+                       }
+               }
+
+               if err := zw.Close(); err != nil {
+                       return err
+               }
+
+               if _, err := buf.WriteTo(w); err != nil {
+                       return err
+               }
+       }
+
+       if err := binary.Write(w, binary.BigEndian, &StaticObjVer); err != nil {
+               return err
+       }
+
+       var staticObjCount = uint16(len(blk.StaticObjs))
+       if err := binary.Write(w, binary.BigEndian, &staticObjCount); err != nil {
+               return err
+       }
+
+       for _, obj := range blk.StaticObjs {
+               if err := binary.Write(w, binary.BigEndian, &obj.Type); err != nil {
+                       return err
+               }
+
+               var pos = [3]int32{
+                       int32(obj.Pos[0] * 1000.0),
+                       int32(obj.Pos[1] * 1000.0),
+                       int32(obj.Pos[2] * 1000.0),
+               }
+               if err := binary.Write(w, binary.BigEndian, &pos); err != nil {
+                       return err
+               }
+
+               var dataLen = uint16(len(obj.Data))
+               if err := binary.Write(w, binary.BigEndian, &dataLen); err != nil {
+                       return err
+               }
+
+               var data = []byte(obj.Data)
+               if err := binary.Write(w, binary.BigEndian, &data); err != nil {
+                       return err
+               }
+       }
+
+       if err := binary.Write(w, binary.BigEndian, &blk.Timestamp); err != nil {
+               return err
+       }
+
+       if err := binary.Write(w, binary.BigEndian, &NameIdMapVer); err != nil {
+               return err
+       }
+
+       var nameIdMapCount = uint16(len(idNameMap))
+       if err := binary.Write(w, binary.BigEndian, &nameIdMapCount); err != nil {
+               return err
+       }
+
+       for name, id := range idNameMap {
+               if err := binary.Write(w, binary.BigEndian, &id); err != nil {
+                       return err
+               }
+
+               var nameLen = uint16(len(name))
+               if err := binary.Write(w, binary.BigEndian, &nameLen); err != nil {
+                       return err
+               }
+
+               var name = []byte(name)
+               if err := binary.Write(w, binary.BigEndian, &name); err != nil {
+                       return err
+               }
+       }
+
+       return nil
+}

diff --git a/types.go b/types.go
new file mode 100644 (file)
index 0000000..abb02e2
--- /dev/null
+++ b/types.go
@@ -0,0 +1,36 @@
+package mtmap
+
+import (
+       "github.com/anon55555/mt"
+)
+
+type MapBlk struct {
+       mt.MapBlk
+       Flags            MapBlkFlags
+       LightingComplete uint16
+       StaticObjs       []StaticObj
+       Timestamp        uint32
+}
+
+type MapBlkFlags uint8
+
+const (
+       IsUnderground MapBlkFlags = 1 << iota
+       DayNightDiffers
+       NotGenerated = 1 << 4
+)
+
+var (
+       SerializeVer uint8 = 28
+       ContentWidth uint8 = 2
+       ParamsWidth  uint8 = 2
+       NodeMetaVer  uint8 = 2
+       StaticObjVer uint8 = 0
+       NameIdMapVer uint8 = 0
+)
+
+type StaticObj struct {
+       Type uint8
+       Pos  [3]float32
+       Data string
+}