serialize.go

   1 package mtmap
   2
   3 import (
   4         "bytes"
   5         "compress/zlib"
   6         "encoding/binary"
   7         "github.com/anon55555/mt"
   8         "io"
   9 )
  10
  11 func Serialize(blk *MapBlk, w io.Writer, nameIdMap map[mt.Content]string) {
  12         if err := binary.Write(w, binary.BigEndian, &SerializeVer); err != nil {
  13                 panic(err)
  14         }
  15
  16         if err := binary.Write(w, binary.BigEndian, &blk.Flags); err != nil {
  17                 panic(err)
  18         }
  19
  20         if err := binary.Write(w, binary.BigEndian, &blk.LightingComplete); err != nil {
  21                 panic(err)
  22         }
  23
  24         if err := binary.Write(w, binary.BigEndian, &ContentWidth); err != nil {
  25                 panic(err)
  26         }
  27
  28         if err := binary.Write(w, binary.BigEndian, &ParamsWidth); err != nil {
  29                 panic(err)
  30         }
  31
  32         {
  33                 var buf bytes.Buffer
  34                 zw := zlib.NewWriter(&buf)
  35
  36                 if err := binary.Write(zw, binary.BigEndian, &blk.Param0); err != nil {
  37                         panic(err)
  38                 }
  39
  40                 if err := zw.Close(); err != nil {
  41                         panic(err)
  42                 }
  43
  44                 if _, err := buf.WriteTo(w); err != nil {
  45                         panic(err)
  46                 }
  47         }
  48
  49         {
  50                 var buf bytes.Buffer
  51                 zw := zlib.NewWriter(&buf)
  52
  53                 var version = NodeMetaVer
  54                 if len(blk.NodeMetas) == 0 {
  55                         version = 0
  56                 }
  57
  58                 if err := binary.Write(zw, binary.BigEndian, &version); err != nil {
  59                         panic(err)
  60                 }
  61
  62                 if version != 0 {
  63                         var count = uint16(len(blk.NodeMetas))
  64                         if err := binary.Write(zw, binary.BigEndian, &count); err != nil {
  65                                 panic(err)
  66                         }
  67
  68                         for pos, data := range blk.NodeMetas {
  69                                 if err := binary.Write(zw, binary.BigEndian, &pos); err != nil {
  70                                         panic(err)
  71                                 }
  72
  73                                 var num = uint32(len(data.Fields))
  74                                 if err := binary.Write(zw, binary.BigEndian, &num); err != nil {
  75                                         panic(err)
  76                                 }
  77
  78                                 for _, field := range data.Fields {
  79                                         var lenName = uint16(len(field.Name))
  80                                         if err := binary.Write(zw, binary.BigEndian, &lenName); err != nil {
  81                                                 panic(err)
  82                                         }
  83
  84                                         var name = []byte(field.Name)
  85                                         if err := binary.Write(zw, binary.BigEndian, &name); err != nil {
  86                                                 panic(err)
  87                                         }
  88
  89                                         var lenValue = uint32(len(field.Value))
  90                                         if err := binary.Write(zw, binary.BigEndian, &lenValue); err != nil {
  91                                                 panic(err)
  92                                         }
  93
  94                                         var value = []byte(field.Value)
  95                                         if err := binary.Write(zw, binary.BigEndian, &value); err != nil {
  96                                                 panic(err)
  97                                         }
  98
  99                                         if err := binary.Write(zw, binary.BigEndian, &field.Private); err != nil {
 100                                                 panic(err)
 101                                         }
 102                                 }
 103
 104                                 if err := data.Inv.Serialize(zw); err != nil {
 105                                         panic(err)
 106                                 }
 107                         }
 108                 }
 109
 110                 if err := zw.Close(); err != nil {
 111                         panic(err)
 112                 }
 113
 114                 if _, err := buf.WriteTo(w); err != nil {
 115                         panic(err)
 116                 }
 117         }
 118
 119         if err := binary.Write(w, binary.BigEndian, &StaticObjVer); err != nil {
 120                 panic(err)
 121         }
 122
 123         var staticObjCount = uint16(len(blk.StaticObjs))
 124         if err := binary.Write(w, binary.BigEndian, &staticObjCount); err != nil {
 125                 panic(err)
 126         }
 127
 128         for _, obj := range blk.StaticObjs {
 129                 if err := binary.Write(w, binary.BigEndian, &obj.Type); err != nil {
 130                         panic(err)
 131                 }
 132
 133                 var pos = [3]int32{
 134                         int32(obj.Pos[0] * 1000.0),
 135                         int32(obj.Pos[1] * 1000.0),
 136                         int32(obj.Pos[2] * 1000.0),
 137                 }
 138                 if err := binary.Write(w, binary.BigEndian, &pos); err != nil {
 139                         panic(err)
 140                 }
 141
 142                 var dataLen = uint16(len(obj.Data))
 143                 if err := binary.Write(w, binary.BigEndian, &dataLen); err != nil {
 144                         panic(err)
 145                 }
 146
 147                 var data = []byte(obj.Data)
 148                 if err := binary.Write(w, binary.BigEndian, &data); err != nil {
 149                         panic(err)
 150                 }
 151         }
 152
 153         if err := binary.Write(w, binary.BigEndian, &blk.Timestamp); err != nil {
 154                 panic(err)
 155         }
 156
 157         if err := binary.Write(w, binary.BigEndian, &NameIdMapVer); err != nil {
 158                 panic(err)
 159         }
 160
 161         var localNameIdMap = map[mt.Content]string{
 162                 mt.Unknown: "unknown",
 163                 mt.Air:     "air",
 164                 mt.Ignore:  "ignore",
 165         }
 166
 167         for i := 0; i < 4096; i++ {
 168                 id := blk.Param0[i]
 169                 if _, ok := localNameIdMap[id]; ok {
 170                         continue
 171                 }
 172
 173                 name, ok := nameIdMap[id]
 174                 if !ok {
 175                         panic(ErrInvalidNodeId{id})
 176                 }
 177
 178                 localNameIdMap[id] = name
 179         }
 180
 181         var nameIdMapCount = uint16(len(localNameIdMap))
 182         if err := binary.Write(w, binary.BigEndian, &nameIdMapCount); err != nil {
 183                 panic(err)
 184         }
 185
 186         for id, name := range localNameIdMap {
 187                 if err := binary.Write(w, binary.BigEndian, &id); err != nil {
 188                         panic(err)
 189                 }
 190
 191                 var nameLen = uint16(len(name))
 192                 if err := binary.Write(w, binary.BigEndian, &nameLen); err != nil {
 193                         panic(err)
 194                 }
 195
 196                 var name = []byte(name)
 197                 if err := binary.Write(w, binary.BigEndian, &name); err != nil {
 198                         panic(err)
 199                 }
 200         }
 201 }