deserialize.go

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