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 != 0 {
  90                         if version != NodeMetaVer {
  91                                 panic(ErrInvalidNodeMetaVer)
  92                         }
  93
  94                         var count uint16
  95                         if err := binary.Read(r, binary.BigEndian, &count); err != nil {
  96                                 panic(err)
  97                         }
  98
  99                         for i := uint16(0); i < count; i++ {
 100                                 var pos uint16
 101                                 if err := binary.Read(r, binary.BigEndian, &pos); err != nil {
 102                                         panic(err)
 103                                 }
 104
 105                                 var num uint32
 106                                 if err := binary.Read(r, binary.BigEndian, &num); err != nil {
 107                                         panic(err)
 108                                 }
 109
 110                                 var data = &mt.NodeMeta{}
 111                                 data.Fields = make([]mt.NodeMetaField, 0)
 112                                 for j := uint32(0); j < num; j++ {
 113                                         var field mt.NodeMetaField
 114
 115                                         var lenName uint16
 116                                         if err := binary.Read(r, binary.BigEndian, &lenName); err != nil {
 117                                                 panic(err)
 118                                         }
 119
 120                                         var name = make([]byte, lenName)
 121                                         if err := binary.Read(r, binary.BigEndian, &name); err != nil {
 122                                                 panic(err)
 123                                         }
 124                                         field.Name = string(name)
 125
 126                                         var lenValue uint32
 127                                         if err := binary.Read(r, binary.BigEndian, &lenValue); err != nil {
 128                                                 panic(err)
 129                                         }
 130
 131                                         var value = make([]byte, lenValue)
 132                                         if err := binary.Read(r, binary.BigEndian, &value); err != nil {
 133                                                 panic(err)
 134                                         }
 135                                         field.Value = string(value)
 136
 137                                         if err := binary.Read(r, binary.BigEndian, &field.Private); err != nil {
 138                                                 panic(err)
 139                                         }
 140
 141                                         data.Fields = append(data.Fields, field)
 142                                 }
 143
 144                                 if err := data.Inv.Deserialize(r); err != nil {
 145                                         panic(err)
 146                                 }
 147
 148                                 blk.NodeMetas[pos] = data
 149                         }
 150                 }
 151
 152                 if _, err := io.Copy(io.Discard, r); err != nil {
 153                         panic(err)
 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                         panic(ErrInvalidNodeId{id})
 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                                 panic(ErrInvalidNodeName{name})
 267                         }
 268                 }
 269
 270                 blk.Param0[i] = id
 271         }
 272
 273         return blk
 274 }