X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=deserialize.go;h=78b9ea2573699faac004e947a6e2f2270161ad2c;hb=2f0d89c5cfb101bccf7bbe8be1b070ce2a4fee4c;hp=a6bc96563d4c65889e84212049d7fe75461bdcd5;hpb=29baaa00789ea4b01040f7fe54bc0ed5c560137d;p=mtmap.git

diff --git a/deserialize.go b/deserialize.go
index a6bc965..78b9ea2 100644
--- a/deserialize.go
+++ b/deserialize.go
@@ -1,7 +1,6 @@
 package mtmap
 
 import (
-	"bytes"
 	"compress/zlib"
 	"encoding/binary"
 	"errors"
@@ -9,94 +8,69 @@ import (
 	"io"
 )
 
-type MapBlk struct {
-	mt.MapBlk
-	Flags            MapBlkFlags
-	LightingComplete uint16
-	StaticObjs       []StaticObj
-	Timestamp        uint32
-}
-
-type MapBlkFlags uint8
-
-const (
-	IsUnderground MapBlkFlags = 1 << iota
-	DayNightDiffers
-	NotGenerated = 1 << 4
-)
-
-var SerializeVer uint8 = 28
-
 var (
 	ErrInvalidSerializeVer = errors.New("invalid serialize version")
 	ErrInvalidContentWidth = errors.New("invalid content width")
 	ErrInvalidParamsWidth  = errors.New("invalid params width")
 	ErrInvalidNodeMetaVer  = errors.New("invalid node meta version")
 	ErrInvalidNameIdMapVer = errors.New("invalid name id mapping version")
-	ErrInvalidNode         = errors.New("invalid node")
+	ErrInvalidStaticObjVer = errors.New("invalid static object version")
 )
 
-type StaticObj struct {
-	Type uint8
-	Pos  [3]float32
-	Data string
-}
-
-func Deserialize(data []byte, idNameMap map[string]mt.Content) (blk *MapBlk, err error) {
-	r := bytes.NewReader(data)
-	blk = &MapBlk{}
+func Deserialize(r io.Reader, idNameMap map[string]mt.Content) *MapBlk {
+	var blk = &MapBlk{}
 
 	var ver uint8
 	if err := binary.Read(r, binary.BigEndian, &ver); err != nil {
-		return nil, err
+		panic(err)
 	}
 
 	if ver != SerializeVer {
-		return nil, ErrInvalidSerializeVer
+		panic(ErrInvalidSerializeVer)
 	}
 
 	if err := binary.Read(r, binary.BigEndian, &blk.Flags); err != nil {
-		return nil, err
+		panic(err)
 	}
 
 	if err := binary.Read(r, binary.BigEndian, &blk.LightingComplete); err != nil {
-		return nil, err
+		panic(err)
 	}
 
 	var contentWidth uint8
 	if err := binary.Read(r, binary.BigEndian, &contentWidth); err != nil {
-		return nil, err
+		panic(err)
 	}
 
-	if contentWidth != 2 {
-		return nil, ErrInvalidContentWidth
+	if contentWidth != ContentWidth {
+		panic(ErrInvalidContentWidth)
 	}
 
 	var paramsWidth uint8
 	if err := binary.Read(r, binary.BigEndian, &paramsWidth); err != nil {
-		return nil, err
+		panic(err)
 	}
 
-	if paramsWidth != 2 {
-		return nil, ErrInvalidParamsWidth
+	if paramsWidth != ParamsWidth {
+		panic(ErrInvalidParamsWidth)
 	}
 
 	{
 		r, err := zlib.NewReader(r)
 		if err != nil {
-			return nil, err
+			panic(err)
 		}
 
 		if err := binary.Read(r, binary.BigEndian, &blk.Param0); err != nil {
-			return nil, err
+			panic(err)
 		}
 
 		if _, err := io.Copy(io.Discard, r); err != nil {
-			return nil, err
+			panic(err)
 		}
 
 		if err := r.Close(); err != nil {
-			return nil, err
+			panic(err)
 		}
 	}
 
@@ -104,92 +78,98 @@ func Deserialize(data []byte, idNameMap map[string]mt.Content) (blk *MapBlk, err
 	{
 		r, err := zlib.NewReader(r)
 		if err != nil {
-			return nil, err
+			panic(err)
 		}
 
 		var version uint8
 		if err := binary.Read(r, binary.BigEndian, &version); err != nil {
-			return nil, err
-		}
-
-		if version != 2 {
-			return nil, ErrInvalidNodeMetaVer
-		}
-
-		var count uint16
-		if err := binary.Read(r, binary.BigEndian, &count); err != nil {
-			return nil, err
+			panic(err)
 		}
 
-		for i := uint16(0); i < count; i++ {
-			var pos uint16
-			if err := binary.Read(r, binary.BigEndian, &pos); err != nil {
-				return nil, err
+		if version != 0 {
+			if version != NodeMetaVer {
+				panic(ErrInvalidNodeMetaVer)
 			}
 
-			var num uint32
-			if err := binary.Read(r, binary.BigEndian, &num); err != nil {
-				return nil, err
+			var count uint16
+			if err := binary.Read(r, binary.BigEndian, &count); err != nil {
+				panic(err)
 			}
 
-			var data = &mt.NodeMeta{}
-			data.Fields = make([]mt.NodeMetaField, 0)
-			for j := uint32(0); j < num; j++ {
-				var field mt.NodeMetaField
-
-				var lenName uint16
-				if err := binary.Read(r, binary.BigEndian, &lenName); err != nil {
-					return nil, err
-				}
-
-				var name = make([]byte, lenName)
-				if err := binary.Read(r, binary.BigEndian, &name); err != nil {
-					return nil, err
+			for i := uint16(0); i < count; i++ {
+				var pos uint16
+				if err := binary.Read(r, binary.BigEndian, &pos); err != nil {
+					panic(err)
 				}
-				field.Name = string(name)
 
-				var lenValue uint32
-				if err := binary.Read(r, binary.BigEndian, &lenValue); err != nil {
-					return nil, err
+				var num uint32
+				if err := binary.Read(r, binary.BigEndian, &num); err != nil {
+					panic(err)
 				}
 
-				var value = make([]byte, lenValue)
-				if err := binary.Read(r, binary.BigEndian, &value); err != nil {
-					return nil, err
+				var data = &mt.NodeMeta{}
+				data.Fields = make([]mt.NodeMetaField, 0)
+				for j := uint32(0); j < num; j++ {
+					var field mt.NodeMetaField
+
+					var lenName uint16
+					if err := binary.Read(r, binary.BigEndian, &lenName); err != nil {
+						panic(err)
+					}
+
+					var name = make([]byte, lenName)
+					if err := binary.Read(r, binary.BigEndian, &name); err != nil {
+						panic(err)
+					}
+					field.Name = string(name)
+
+					var lenValue uint32
+					if err := binary.Read(r, binary.BigEndian, &lenValue); err != nil {
+						panic(err)
+					}
+
+					var value = make([]byte, lenValue)
+					if err := binary.Read(r, binary.BigEndian, &value); err != nil {
+						panic(err)
+					}
+					field.Value = string(value)
+
+					if err := binary.Read(r, binary.BigEndian, &field.Private); err != nil {
+						panic(err)
+					}
+
+					data.Fields = append(data.Fields, field)
 				}
-				field.Value = string(value)
 
-				if err := binary.Read(r, binary.BigEndian, &field.Private); err != nil {
-					return nil, err
+				if err := data.Inv.Deserialize(r); err != nil {
+					panic(err)
 				}
 
-				data.Fields = append(data.Fields, field)
+				blk.NodeMetas[pos] = data
 			}
-
-			if err := data.Inv.Deserialize(r); err != nil {
-				return nil, err
-			}
-
-			blk.NodeMetas[pos] = data
 		}
 
 		if _, err := io.Copy(io.Discard, r); err != nil {
-			return nil, err
+			panic(err)
 		}
 
 		if err := r.Close(); err != nil {
-			return nil, err
+			panic(err)
 		}
 	}
 
 	var staticObjVer uint8
 	if err := binary.Read(r, binary.BigEndian, &staticObjVer); err != nil {
-		return nil, err
+		panic(err)
+	}
+
+	if staticObjVer != StaticObjVer {
+		panic(ErrInvalidStaticObjVer)
 	}
 
 	var staticObjCount uint16
 	if err := binary.Read(r, binary.BigEndian, &staticObjCount); err != nil {
-		return nil, err
+		panic(err)
 	}
 
 	blk.StaticObjs = make([]StaticObj, 0)
@@ -197,12 +177,12 @@ func Deserialize(data []byte, idNameMap map[string]mt.Content) (blk *MapBlk, err
 		var obj StaticObj
 
 		if err := binary.Read(r, binary.BigEndian, &obj.Type); err != nil {
-			return nil, err
+			panic(err)
 		}
 
 		var pos [3]int32
 		if err := binary.Read(r, binary.BigEndian, &pos); err != nil {
-			return nil, err
+			panic(err)
 		}
 
 		obj.Pos = [3]float32{
@@ -213,12 +193,12 @@ func Deserialize(data []byte, idNameMap map[string]mt.Content) (blk *MapBlk, err
 
 		var dataLen uint16
 		if err := binary.Read(r, binary.BigEndian, &dataLen); err != nil {
-			return nil, err
+			panic(err)
 		}
 
 		var data = make([]byte, dataLen)
 		if err := binary.Read(r, binary.BigEndian, &data); err != nil {
-			return nil, err
+			panic(err)
 		}
 
 		obj.Data = string(data)
@@ -227,57 +207,68 @@ func Deserialize(data []byte, idNameMap map[string]mt.Content) (blk *MapBlk, err
 	}
 
 	if err := binary.Read(r, binary.BigEndian, &blk.Timestamp); err != nil {
-		return nil, err
+		panic(err)
 	}
 
 	var nameIdMapVer uint8
 	if err := binary.Read(r, binary.BigEndian, &nameIdMapVer); err != nil {
-		return nil, err
+		panic(err)
 	}
 
-	if nameIdMapVer != 0 {
-		return nil, ErrInvalidNameIdMapVer
+	if nameIdMapVer != NameIdMapVer {
+		panic(ErrInvalidNameIdMapVer)
 	}
 
 	var nameIdMapCount uint16
 	if err := binary.Read(r, binary.BigEndian, &nameIdMapCount); err != nil {
-		return nil, err
+		panic(err)
 	}
 
-	nameIdMap := make(map[mt.Content]string)
+	var nameIdMap = make(map[mt.Content]string)
 
 	for i := uint16(0); i < nameIdMapCount; i++ {
-		var id uint16
+		var id mt.Content
 		if err := binary.Read(r, binary.BigEndian, &id); err != nil {
-			return nil, err
+			panic(err)
 		}
 
-		var nameLen mt.Content
+		var nameLen uint16
 		if err := binary.Read(r, binary.BigEndian, &nameLen); err != nil {
-			return nil, err
+			panic(err)
 		}
 
 		var name = make([]byte, nameLen)
 		if err := binary.Read(r, binary.BigEndian, &name); err != nil {
-			return nil, err
+			panic(err)
 		}
 
-		nameIdMap[mt.Content(id)] = string(name)
+		nameIdMap[id] = string(name)
 	}
 
 	for i := 0; i < 4096; i++ {
-		name, ok := nameIdMap[blk.Param0[i]]
+		id := blk.Param0[i]
+
+		name, ok := nameIdMap[id]
 		if !ok {
-			return nil, ErrInvalidNode
+			panic(ErrInvalidNodeId{id})
 		}
 
-		id, ok := idNameMap[name]
-		if !ok {
-			return nil, ErrInvalidNode
+		switch name {
+		case "unknown":
+			id = mt.Unknown
+		case "air":
+			id = mt.Air
+		case "ignore":
+			id = mt.Ignore
+		default:
+			id, ok = idNameMap[name]
+			if !ok {
+				panic(ErrInvalidNodeName{name})
+			}
 		}
 
 		blk.Param0[i] = id
 	}
 
-	return
+	return blk
 }