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 := binary.Write(zw, binary.BigEndian, &blk.Param1); err != nil {
  41                         panic(err)
  42                 }
  43
  44                 if err := binary.Write(zw, binary.BigEndian, &blk.Param2); err != nil {
  45                         panic(err)
  46                 }
  47
  48                 if err := zw.Close(); err != nil {
  49                         panic(err)
  50                 }
  51
  52                 if _, err := buf.WriteTo(w); err != nil {
  53                         panic(err)
  54                 }
  55         }
  56
  57         {
  58                 var buf bytes.Buffer
  59                 zw := zlib.NewWriter(&buf)
  60
  61                 var version = NodeMetaVer
  62                 if len(blk.NodeMetas) == 0 {
  63                         version = 0
  64                 }
  65
  66                 if err := binary.Write(zw, binary.BigEndian, &version); err != nil {
  67                         panic(err)
  68                 }
  69
  70                 if version != 0 {
  71                         var count = uint16(len(blk.NodeMetas))
  72                         if err := binary.Write(zw, binary.BigEndian, &count); err != nil {
  73                                 panic(err)
  74                         }
  75
  76                         for pos, data := range blk.NodeMetas {
  77                                 if err := binary.Write(zw, binary.BigEndian, &pos); err != nil {
  78                                         panic(err)
  79                                 }
  80
  81                                 var num = uint32(len(data.Fields))
  82                                 if err := binary.Write(zw, binary.BigEndian, &num); err != nil {
  83                                         panic(err)
  84                                 }
  85
  86                                 for _, field := range data.Fields {
  87                                         var lenName = uint16(len(field.Name))
  88                                         if err := binary.Write(zw, binary.BigEndian, &lenName); err != nil {
  89                                                 panic(err)
  90                                         }
  91
  92                                         var name = []byte(field.Name)
  93                                         if err := binary.Write(zw, binary.BigEndian, &name); err != nil {
  94                                                 panic(err)
  95                                         }
  96
  97                                         var lenValue = uint32(len(field.Value))
  98                                         if err := binary.Write(zw, binary.BigEndian, &lenValue); err != nil {
  99                                                 panic(err)
 100                                         }
 101
 102                                         var value = []byte(field.Value)
 103                                         if err := binary.Write(zw, binary.BigEndian, &value); err != nil {
 104                                                 panic(err)
 105                                         }
 106
 107                                         if err := binary.Write(zw, binary.BigEndian, &field.Private); err != nil {
 108                                                 panic(err)
 109                                         }
 110                                 }
 111
 112                                 if err := data.Inv.Serialize(zw); err != nil {
 113                                         panic(err)
 114                                 }
 115                         }
 116                 }
 117
 118                 if err := zw.Close(); err != nil {
 119                         panic(err)
 120                 }
 121
 122                 if _, err := buf.WriteTo(w); err != nil {
 123                         panic(err)
 124                 }
 125         }
 126
 127         if err := binary.Write(w, binary.BigEndian, &StaticObjVer); err != nil {
 128                 panic(err)
 129         }
 130
 131         var staticObjCount = uint16(len(blk.StaticObjs))
 132         if err := binary.Write(w, binary.BigEndian, &staticObjCount); err != nil {
 133                 panic(err)
 134         }
 135
 136         for _, obj := range blk.StaticObjs {
 137                 if err := binary.Write(w, binary.BigEndian, &obj.Type); err != nil {
 138                         panic(err)
 139                 }
 140
 141                 var pos = [3]int32{
 142                         int32(obj.Pos[0] * 1000.0),
 143                         int32(obj.Pos[1] * 1000.0),
 144                         int32(obj.Pos[2] * 1000.0),
 145                 }
 146                 if err := binary.Write(w, binary.BigEndian, &pos); err != nil {
 147                         panic(err)
 148                 }
 149
 150                 var dataLen = uint16(len(obj.Data))
 151                 if err := binary.Write(w, binary.BigEndian, &dataLen); err != nil {
 152                         panic(err)
 153                 }
 154
 155                 var data = []byte(obj.Data)
 156                 if err := binary.Write(w, binary.BigEndian, &data); err != nil {
 157                         panic(err)
 158                 }
 159         }
 160
 161         if err := binary.Write(w, binary.BigEndian, &blk.Timestamp); err != nil {
 162                 panic(err)
 163         }
 164
 165         if err := binary.Write(w, binary.BigEndian, &NameIdMapVer); err != nil {
 166                 panic(err)
 167         }
 168
 169         var localNameIdMap = make(map[mt.Content]string)
 170
 171         for i := 0; i < 4096; i++ {
 172                 id := blk.Param0[i]
 173                 if _, ok := localNameIdMap[id]; ok {
 174                         continue
 175                 }
 176
 177                 var name string
 178                 var ok bool
 179
 180                 switch id {
 181                 case mt.Unknown:
 182                         name = "unknown"
 183                 case mt.Air:
 184                         name = "air"
 185                 case mt.Ignore:
 186                         name = "ignore"
 187                 default:
 188                         name, ok = nameIdMap[id]
 189                         if !ok {
 190                                 id = mt.Unknown
 191                                 name = "unknown"
 192                         }
 193                 }
 194
 195                 localNameIdMap[id] = name
 196         }
 197
 198         var nameIdMapCount = uint16(len(localNameIdMap))
 199         if err := binary.Write(w, binary.BigEndian, &nameIdMapCount); err != nil {
 200                 panic(err)
 201         }
 202
 203         for id, name := range localNameIdMap {
 204                 if err := binary.Write(w, binary.BigEndian, &id); err != nil {
 205                         panic(err)
 206                 }
 207
 208                 var nameLen = uint16(len(name))
 209                 if err := binary.Write(w, binary.BigEndian, &nameLen); err != nil {
 210                         panic(err)
 211                 }
 212
 213                 var name = []byte(name)
 214                 if err := binary.Write(w, binary.BigEndian, &name); err != nil {
 215                         panic(err)
 216                 }
 217         }
 218 }