deserialize.go

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