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         ErrInvalidNode         = errors.New("invalid node")
  19 )
  20
  21 func Deserialize(r io.Reader, idNameMap map[string]mt.Content) *MapBlk {
  22         var blk = &MapBlk{}
  23
  24         var ver uint8
  25         if err := binary.Read(r, binary.BigEndian, &ver); err != nil {
  26                 panic(err)
  27         }
  28
  29         if ver != SerializeVer {
  30                 panic(ErrInvalidSerializeVer)
  31         }
  32
  33         if err := binary.Read(r, binary.BigEndian, &blk.Flags); err != nil {
  34                 panic(err)
  35         }
  36
  37         if err := binary.Read(r, binary.BigEndian, &blk.LightingComplete); err != nil {
  38                 panic(err)
  39         }
  40
  41         var contentWidth uint8
  42         if err := binary.Read(r, binary.BigEndian, &contentWidth); err != nil {
  43                 panic(err)
  44         }
  45
  46         if contentWidth != ContentWidth {
  47                 panic(ErrInvalidContentWidth)
  48         }
  49
  50         var paramsWidth uint8
  51         if err := binary.Read(r, binary.BigEndian, &paramsWidth); err != nil {
  52                 panic(err)
  53         }
  54
  55         if paramsWidth != ParamsWidth {
  56                 panic(ErrInvalidParamsWidth)
  57         }
  58
  59         {
  60                 r, err := zlib.NewReader(r)
  61                 if err != nil {
  62                         panic(err)
  63                 }
  64
  65                 if err := binary.Read(r, binary.BigEndian, &blk.Param0); err != nil {
  66                         panic(err)
  67                 }
  68
  69                 if _, err := io.Copy(io.Discard, r); err != nil {
  70                         panic(err)
  71                 }
  72
  73                 if err := r.Close(); err != nil {
  74                         panic(err)
  75                 }
  76         }
  77
  78         blk.NodeMetas = make(map[uint16]*mt.NodeMeta)
  79         {
  80                 r, err := zlib.NewReader(r)
  81                 if err != nil {
  82                         panic(err)
  83                 }
  84
  85                 var version uint8
  86                 if err := binary.Read(r, binary.BigEndian, &version); err != nil {
  87                         panic(err)
  88                 }
  89
  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                 if _, err := io.Copy(io.Discard, r); err != nil {
 152                         panic(err)
 153                 }
 154
 155                 if err := r.Close(); err != nil {
 156                         panic(err)
 157                 }
 158         }
 159
 160         var staticObjVer uint8
 161         if err := binary.Read(r, binary.BigEndian, &staticObjVer); err != nil {
 162                 panic(err)
 163         }
 164
 165         if staticObjVer != StaticObjVer {
 166                 panic(ErrInvalidStaticObjVer)
 167         }
 168
 169         var staticObjCount uint16
 170         if err := binary.Read(r, binary.BigEndian, &staticObjCount); err != nil {
 171                 panic(err)
 172         }
 173
 174         blk.StaticObjs = make([]StaticObj, 0)
 175         for i := uint16(0); i < staticObjCount; i++ {
 176                 var obj StaticObj
 177
 178                 if err := binary.Read(r, binary.BigEndian, &obj.Type); err != nil {
 179                         panic(err)
 180                 }
 181
 182                 var pos [3]int32
 183                 if err := binary.Read(r, binary.BigEndian, &pos); err != nil {
 184                         panic(err)
 185                 }
 186
 187                 obj.Pos = [3]float32{
 188                         float32(pos[0]) / 1000.0,
 189                         float32(pos[1]) / 1000.0,
 190                         float32(pos[2]) / 1000.0,
 191                 }
 192
 193                 var dataLen uint16
 194                 if err := binary.Read(r, binary.BigEndian, &dataLen); err != nil {
 195                         panic(err)
 196                 }
 197
 198                 var data = make([]byte, dataLen)
 199                 if err := binary.Read(r, binary.BigEndian, &data); err != nil {
 200                         panic(err)
 201                 }
 202
 203                 obj.Data = string(data)
 204
 205                 blk.StaticObjs = append(blk.StaticObjs, obj)
 206         }
 207
 208         if err := binary.Read(r, binary.BigEndian, &blk.Timestamp); err != nil {
 209                 panic(err)
 210         }
 211
 212         var nameIdMapVer uint8
 213         if err := binary.Read(r, binary.BigEndian, &nameIdMapVer); err != nil {
 214                 panic(err)
 215         }
 216
 217         if nameIdMapVer != NameIdMapVer {
 218                 panic(ErrInvalidNameIdMapVer)
 219         }
 220
 221         var nameIdMapCount uint16
 222         if err := binary.Read(r, binary.BigEndian, &nameIdMapCount); err != nil {
 223                 panic(err)
 224         }
 225
 226         nameIdMap := make(map[mt.Content]string)
 227
 228         for i := uint16(0); i < nameIdMapCount; i++ {
 229                 var id mt.Content
 230                 if err := binary.Read(r, binary.BigEndian, &id); err != nil {
 231                         panic(err)
 232                 }
 233
 234                 var nameLen uint16
 235                 if err := binary.Read(r, binary.BigEndian, &nameLen); err != nil {
 236                         panic(err)
 237                 }
 238
 239                 var name = make([]byte, nameLen)
 240                 if err := binary.Read(r, binary.BigEndian, &name); err != nil {
 241                         panic(err)
 242                 }
 243
 244                 nameIdMap[id] = string(name)
 245         }
 246
 247         for i := 0; i < 4096; i++ {
 248                 name, ok := nameIdMap[blk.Param0[i]]
 249                 if !ok {
 250                         panic(ErrInvalidNode)
 251                 }
 252
 253                 id, ok := idNameMap[name]
 254                 if !ok {
 255                         panic(ErrInvalidNode)
 256                 }
 257
 258                 blk.Param0[i] = id
 259         }
 260
 261         return blk
 262 }