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 := binary.Read(r, binary.BigEndian, &blk.Param1); err != nil {
  69                         panic(err)
  70                 }
  71
  72                 if err := binary.Read(r, binary.BigEndian, &blk.Param2); err != nil {
  73                         panic(err)
  74                 }
  75
  76                 if err := r.Close(); err != nil {
  77                         panic(err)
  78                 }
  79         }
  80
  81         blk.NodeMetas = make(map[uint16]*mt.NodeMeta)
  82         {
  83                 r, err := zlib.NewReader(r)
  84                 if err != nil {
  85                         panic(err)
  86                 }
  87
  88                 var version uint8
  89                 if err := binary.Read(r, binary.BigEndian, &version); err != nil {
  90                         panic(err)
  91                 }
  92
  93                 if version != 0 {
  94                         if version != NodeMetaVer {
  95                                 panic(ErrInvalidNodeMetaVer)
  96                         }
  97
  98                         var count uint16
  99                         if err := binary.Read(r, binary.BigEndian, &count); err != nil {
 100                                 panic(err)
 101                         }
 102
 103                         for i := uint16(0); i < count; i++ {
 104                                 var pos uint16
 105                                 if err := binary.Read(r, binary.BigEndian, &pos); err != nil {
 106                                         panic(err)
 107                                 }
 108
 109                                 var num uint32
 110                                 if err := binary.Read(r, binary.BigEndian, &num); err != nil {
 111                                         panic(err)
 112                                 }
 113
 114                                 var data = &mt.NodeMeta{}
 115                                 data.Fields = make([]mt.NodeMetaField, 0)
 116                                 for j := uint32(0); j < num; j++ {
 117                                         var field mt.NodeMetaField
 118
 119                                         var lenName uint16
 120                                         if err := binary.Read(r, binary.BigEndian, &lenName); err != nil {
 121                                                 panic(err)
 122                                         }
 123
 124                                         var name = make([]byte, lenName)
 125                                         if err := binary.Read(r, binary.BigEndian, &name); err != nil {
 126                                                 panic(err)
 127                                         }
 128                                         field.Name = string(name)
 129
 130                                         var lenValue uint32
 131                                         if err := binary.Read(r, binary.BigEndian, &lenValue); err != nil {
 132                                                 panic(err)
 133                                         }
 134
 135                                         var value = make([]byte, lenValue)
 136                                         if err := binary.Read(r, binary.BigEndian, &value); err != nil {
 137                                                 panic(err)
 138                                         }
 139                                         field.Value = string(value)
 140
 141                                         if err := binary.Read(r, binary.BigEndian, &field.Private); err != nil {
 142                                                 panic(err)
 143                                         }
 144
 145                                         data.Fields = append(data.Fields, field)
 146                                 }
 147
 148                                 if err := data.Inv.Deserialize(r); err != nil {
 149                                         panic(err)
 150                                 }
 151
 152                                 blk.NodeMetas[pos] = data
 153                         }
 154                 }
 155
 156                 if err := r.Close(); err != nil {
 157                         panic(err)
 158                 }
 159         }
 160
 161         var staticObjVer uint8
 162         if err := binary.Read(r, binary.BigEndian, &staticObjVer); err != nil {
 163                 panic(err)
 164         }
 165
 166         if staticObjVer != StaticObjVer {
 167                 panic(ErrInvalidStaticObjVer)
 168         }
 169
 170         var staticObjCount uint16
 171         if err := binary.Read(r, binary.BigEndian, &staticObjCount); err != nil {
 172                 panic(err)
 173         }
 174
 175         blk.StaticObjs = make([]StaticObj, 0)
 176         for i := uint16(0); i < staticObjCount; i++ {
 177                 var obj StaticObj
 178
 179                 if err := binary.Read(r, binary.BigEndian, &obj.Type); err != nil {
 180                         panic(err)
 181                 }
 182
 183                 var pos [3]int32
 184                 if err := binary.Read(r, binary.BigEndian, &pos); err != nil {
 185                         panic(err)
 186                 }
 187
 188                 obj.Pos = [3]float32{
 189                         float32(pos[0]) / 1000.0,
 190                         float32(pos[1]) / 1000.0,
 191                         float32(pos[2]) / 1000.0,
 192                 }
 193
 194                 var dataLen uint16
 195                 if err := binary.Read(r, binary.BigEndian, &dataLen); err != nil {
 196                         panic(err)
 197                 }
 198
 199                 var data = make([]byte, dataLen)
 200                 if err := binary.Read(r, binary.BigEndian, &data); err != nil {
 201                         panic(err)
 202                 }
 203
 204                 obj.Data = string(data)
 205
 206                 blk.StaticObjs = append(blk.StaticObjs, obj)
 207         }
 208
 209         if err := binary.Read(r, binary.BigEndian, &blk.Timestamp); err != nil {
 210                 panic(err)
 211         }
 212
 213         var nameIdMapVer uint8
 214         if err := binary.Read(r, binary.BigEndian, &nameIdMapVer); err != nil {
 215                 panic(err)
 216         }
 217
 218         if nameIdMapVer != NameIdMapVer {
 219                 panic(ErrInvalidNameIdMapVer)
 220         }
 221
 222         var nameIdMapCount uint16
 223         if err := binary.Read(r, binary.BigEndian, &nameIdMapCount); err != nil {
 224                 panic(err)
 225         }
 226
 227         var nameIdMap = make(map[mt.Content]string)
 228
 229         for i := uint16(0); i < nameIdMapCount; i++ {
 230                 var id mt.Content
 231                 if err := binary.Read(r, binary.BigEndian, &id); err != nil {
 232                         panic(err)
 233                 }
 234
 235                 var nameLen uint16
 236                 if err := binary.Read(r, binary.BigEndian, &nameLen); err != nil {
 237                         panic(err)
 238                 }
 239
 240                 var name = make([]byte, nameLen)
 241                 if err := binary.Read(r, binary.BigEndian, &name); err != nil {
 242                         panic(err)
 243                 }
 244
 245                 nameIdMap[id] = string(name)
 246         }
 247
 248         for i := 0; i < 4096; i++ {
 249                 id := blk.Param0[i]
 250
 251                 name, ok := nameIdMap[id]
 252                 if !ok {
 253                         name = "unknown"
 254                 }
 255
 256                 switch name {
 257                 case "unknown":
 258                         id = mt.Unknown
 259                 case "air":
 260                         id = mt.Air
 261                 case "ignore":
 262                         id = mt.Ignore
 263                 default:
 264                         id, ok = idNameMap[name]
 265                         if !ok {
 266                                 id = mt.Unknown
 267                         }
 268                 }
 269
 270                 blk.Param0[i] = id
 271         }
 272
 273         return blk
 274 }