deserialize.go

   1 package mtmap
   2
   3 import (
   4         "bytes"
   5         "compress/zlib"
   6         "encoding/binary"
   7         "errors"
   8         "github.com/anon55555/mt"
   9         "io"
  10 )
  11
  12 var (
  13         ErrInvalidSerializeVer = errors.New("invalid serialize version")
  14         ErrInvalidContentWidth = errors.New("invalid content width")
  15         ErrInvalidParamsWidth  = errors.New("invalid params width")
  16         ErrInvalidNodeMetaVer  = errors.New("invalid node meta version")
  17         ErrInvalidNameIdMapVer = errors.New("invalid name id mapping version")
  18         ErrInvalidStaticObjVer = errors.New("invalid static object version")
  19         ErrInvalidNode         = errors.New("invalid node")
  20 )
  21
  22 func Deserialize(data []byte, idNameMap map[string]mt.Content) (blk *MapBlk, err error) {
  23         r := bytes.NewReader(data)
  24         blk = &MapBlk{}
  25
  26         var ver uint8
  27         if err := binary.Read(r, binary.BigEndian, &ver); err != nil {
  28                 return nil, err
  29         }
  30
  31         if ver != SerializeVer {
  32                 return nil, ErrInvalidSerializeVer
  33         }
  34
  35         if err := binary.Read(r, binary.BigEndian, &blk.Flags); err != nil {
  36                 return nil, err
  37         }
  38
  39         if err := binary.Read(r, binary.BigEndian, &blk.LightingComplete); err != nil {
  40                 return nil, err
  41         }
  42
  43         var contentWidth uint8
  44         if err := binary.Read(r, binary.BigEndian, &contentWidth); err != nil {
  45                 return nil, err
  46         }
  47
  48         if contentWidth != ContentWidth {
  49                 return nil, ErrInvalidContentWidth
  50         }
  51
  52         var paramsWidth uint8
  53         if err := binary.Read(r, binary.BigEndian, &paramsWidth); err != nil {
  54                 return nil, err
  55         }
  56
  57         if paramsWidth != ParamsWidth {
  58                 return nil, ErrInvalidParamsWidth
  59         }
  60
  61         {
  62                 r, err := zlib.NewReader(r)
  63                 if err != nil {
  64                         return nil, err
  65                 }
  66
  67                 if err := binary.Read(r, binary.BigEndian, &blk.Param0); err != nil {
  68                         return nil, err
  69                 }
  70
  71                 if _, err := io.Copy(io.Discard, r); err != nil {
  72                         return nil, err
  73                 }
  74
  75                 if err := r.Close(); err != nil {
  76                         return nil, err
  77                 }
  78         }
  79
  80         blk.NodeMetas = make(map[uint16]*mt.NodeMeta)
  81         {
  82                 r, err := zlib.NewReader(r)
  83                 if err != nil {
  84                         return nil, err
  85                 }
  86
  87                 var version uint8
  88                 if err := binary.Read(r, binary.BigEndian, &version); err != nil {
  89                         return nil, err
  90                 }
  91
  92                 if version != NodeMetaVer {
  93                         return nil, ErrInvalidNodeMetaVer
  94                 }
  95
  96                 var count uint16
  97                 if err := binary.Read(r, binary.BigEndian, &count); err != nil {
  98                         return nil, err
  99                 }
 100
 101                 for i := uint16(0); i < count; i++ {
 102                         var pos uint16
 103                         if err := binary.Read(r, binary.BigEndian, &pos); err != nil {
 104                                 return nil, err
 105                         }
 106
 107                         var num uint32
 108                         if err := binary.Read(r, binary.BigEndian, &num); err != nil {
 109                                 return nil, err
 110                         }
 111
 112                         var data = &mt.NodeMeta{}
 113                         data.Fields = make([]mt.NodeMetaField, 0)
 114                         for j := uint32(0); j < num; j++ {
 115                                 var field mt.NodeMetaField
 116
 117                                 var lenName uint16
 118                                 if err := binary.Read(r, binary.BigEndian, &lenName); err != nil {
 119                                         return nil, err
 120                                 }
 121
 122                                 var name = make([]byte, lenName)
 123                                 if err := binary.Read(r, binary.BigEndian, &name); err != nil {
 124                                         return nil, err
 125                                 }
 126                                 field.Name = string(name)
 127
 128                                 var lenValue uint32
 129                                 if err := binary.Read(r, binary.BigEndian, &lenValue); err != nil {
 130                                         return nil, err
 131                                 }
 132
 133                                 var value = make([]byte, lenValue)
 134                                 if err := binary.Read(r, binary.BigEndian, &value); err != nil {
 135                                         return nil, err
 136                                 }
 137                                 field.Value = string(value)
 138
 139                                 if err := binary.Read(r, binary.BigEndian, &field.Private); err != nil {
 140                                         return nil, err
 141                                 }
 142
 143                                 data.Fields = append(data.Fields, field)
 144                         }
 145
 146                         if err := data.Inv.Deserialize(r); err != nil {
 147                                 return nil, err
 148                         }
 149
 150                         blk.NodeMetas[pos] = data
 151                 }
 152
 153                 if _, err := io.Copy(io.Discard, r); err != nil {
 154                         return nil, err
 155                 }
 156
 157                 if err := r.Close(); err != nil {
 158                         return nil, err
 159                 }
 160         }
 161
 162         var staticObjVer uint8
 163         if err := binary.Read(r, binary.BigEndian, &staticObjVer); err != nil {
 164                 return nil, err
 165         }
 166
 167         if staticObjVer != StaticObjVer {
 168                 return nil, ErrInvalidStaticObjVer
 169         }
 170
 171         var staticObjCount uint16
 172         if err := binary.Read(r, binary.BigEndian, &staticObjCount); err != nil {
 173                 return nil, err
 174         }
 175
 176         blk.StaticObjs = make([]StaticObj, 0)
 177         for i := uint16(0); i < staticObjCount; i++ {
 178                 var obj StaticObj
 179
 180                 if err := binary.Read(r, binary.BigEndian, &obj.Type); err != nil {
 181                         return nil, err
 182                 }
 183
 184                 var pos [3]int32
 185                 if err := binary.Read(r, binary.BigEndian, &pos); err != nil {
 186                         return nil, err
 187                 }
 188
 189                 obj.Pos = [3]float32{
 190                         float32(pos[0]) / 1000.0,
 191                         float32(pos[1]) / 1000.0,
 192                         float32(pos[2]) / 1000.0,
 193                 }
 194
 195                 var dataLen uint16
 196                 if err := binary.Read(r, binary.BigEndian, &dataLen); err != nil {
 197                         return nil, err
 198                 }
 199
 200                 var data = make([]byte, dataLen)
 201                 if err := binary.Read(r, binary.BigEndian, &data); err != nil {
 202                         return nil, err
 203                 }
 204
 205                 obj.Data = string(data)
 206
 207                 blk.StaticObjs = append(blk.StaticObjs, obj)
 208         }
 209
 210         if err := binary.Read(r, binary.BigEndian, &blk.Timestamp); err != nil {
 211                 return nil, err
 212         }
 213
 214         var nameIdMapVer uint8
 215         if err := binary.Read(r, binary.BigEndian, &nameIdMapVer); err != nil {
 216                 return nil, err
 217         }
 218
 219         if nameIdMapVer != NameIdMapVer {
 220                 return nil, ErrInvalidNameIdMapVer
 221         }
 222
 223         var nameIdMapCount uint16
 224         if err := binary.Read(r, binary.BigEndian, &nameIdMapCount); err != nil {
 225                 return nil, err
 226         }
 227
 228         nameIdMap := make(map[mt.Content]string)
 229
 230         for i := uint16(0); i < nameIdMapCount; i++ {
 231                 var id uint16
 232                 if err := binary.Read(r, binary.BigEndian, &id); err != nil {
 233                         return nil, err
 234                 }
 235
 236                 var nameLen uint16
 237                 if err := binary.Read(r, binary.BigEndian, &nameLen); err != nil {
 238                         return nil, err
 239                 }
 240
 241                 var name = make([]byte, nameLen)
 242                 if err := binary.Read(r, binary.BigEndian, &name); err != nil {
 243                         return nil, err
 244                 }
 245
 246                 nameIdMap[mt.Content(id)] = string(name)
 247         }
 248
 249         for i := 0; i < 4096; i++ {
 250                 name, ok := nameIdMap[blk.Param0[i]]
 251                 if !ok {
 252                         return nil, ErrInvalidNode
 253                 }
 254
 255                 id, ok := idNameMap[name]
 256                 if !ok {
 257                         return nil, ErrInvalidNode
 258                 }
 259
 260                 blk.Param0[i] = id
 261         }
 262
 263         return
 264 }