1111

level/rrrr.go

@@ -16,8 +16,17 @@ var BpeNotAvailableErr = errors.New("bpe not available")
 var OutOfBoundsErr = errors.New("out of bounds")
 var AvailableBpeMustBeLenOneErr = errors.New("available bpe must be 1")
 var NoAvailableBpeErr = errors.New("no available bpe")
+var Bpe0PalletMustBeLenOneErr = errors.New("bpe 0 pallet must be 1")
+var RealInvalidPaletteIndexErr = errors.New("invalid palette index")
+var AvailableBpeMustBeSortedErr = errors.New("available bpe must be sorted")
+var DirectModeCantResizeErr = errors.New("direct mode cannot resize")
 
 func (r RealStorageFormat) Import(data []uint64, bpe uint8, palette []int32) (s *RealStorage, err error) {
+	if !slices.IsSorted(r.AvailableBpes) {
+		err = AvailableBpeMustBeSortedErr
+		return
+	}
+
 	if !slices.Contains(r.AvailableBpes, bpe) {
 		err = BpeNotAvailableErr
 		return
@@ -25,7 +34,13 @@ func (r RealStorageFormat) Import(data []uint64, bpe uint8, palette []int32) (s
 	s = new(RealStorage)
 	s.format = r
 	s.resize(bpe)
-	s.data = data
+	if bpe == 0 && len(palette) != 1 {
+		err = Bpe0PalletMustBeLenOneErr
+		return
+	}
+	if data != nil {
+		s.data = data
+	}
 	s.palette = palette
 	return
 }
@@ -66,15 +81,15 @@ func (r *RealStorage) resize(bpe uint8) {
 		r.maxAtCurrentBpe = 1
 		return
 	}
-	elementsPerLong := int32(64 / int(bpe))
-	numberOfLongs := int(math.Ceil(float64(r.format.Len) / float64(elementsPerLong)))
+	numberOfElements := int32(64 / int(bpe))
+	numberOfLongs := int(math.Ceil(float64(r.format.Len) / float64(numberOfElements)))
 	newData := make([]uint64, numberOfLongs)
 	mask := (uint64(1) << uint32(bpe)) - 1
 	maxAtCurrentBpe := int32(1 << bpe)
 	if r.bpe == 0 {
-		r.data = newData
 		r.bpe = bpe
-		r.elementsPerLong = elementsPerLong
+		r.elementsPerLong = numberOfElements
+		r.data = newData
 		r.mask = mask
 		r.maxAtCurrentBpe = maxAtCurrentBpe
 		return
@@ -87,15 +102,17 @@ func (r *RealStorage) resize(bpe uint8) {
 		} else {
 			v = int32((r.data[i/r.elementsPerLong] >> ((i % r.elementsPerLong) * int32(r.bpe))) & r.mask)
 		}
-		newData[i/elementsPerLong] |= uint64(v) << ((i % elementsPerLong) * int32(bpe))
+		r.data[i/r.elementsPerLong] |= uint64(v) << ((i % r.elementsPerLong) * int32(bpe))
 	}
+	if resizeDirect {
+		r.palette = nil
+	}
+	r.elementsPerLong = numberOfElements
 	r.data = newData
-	r.bpe = bpe
-	r.elementsPerLong = elementsPerLong
 	r.mask = mask
 	r.maxAtCurrentBpe = maxAtCurrentBpe
-	return
 
+	return
 }
 
 func (r *RealStorage) Get(i int32) (s int32, err error) {
@@ -103,12 +120,26 @@ func (r *RealStorage) Get(i int32) (s int32, err error) {
 		err = OutOfBoundsErr
 		return
 	}
+	if r.bpe == 0 { // single mode
+		if len(r.palette) != 1 {
+			err = Bpe0PalletMustBeLenOneErr
+			return
+		}
+		s = r.palette[0]
+		return
+	}
+
 	v := int32((r.data[i/r.elementsPerLong] >> ((i % r.elementsPerLong) * int32(r.bpe))) & r.mask)
 	if r.palette == nil { // direct
 		s = v
 		return
 	}
-	s = r.palette[v] // should allways be true cause data checking
+	if v < 0 || v >= int32(len(r.palette)) {
+		err = RealInvalidPaletteIndexErr
+		return
+	}
+
+	s = r.palette[v]
 	return
 }
 
@@ -127,13 +158,19 @@ func (r *RealStorage) Set(i int32, v int32) (err error) {
 		if iv == -1 {
 			iv, err = r.appendPalette(v)
 		}
+		v = int32(iv)
 	}
+	r.set(i, v)
 	return
 }
 
 func (r *RealStorage) appendPalette(v int32) (i int, err error) {
-	i = len(r.palette) + 1
-	if i <= int(r.maxAtCurrentBpe) {
+	i = len(r.palette)
+	if r.palette == nil {
+		err = DirectModeCantResizeErr
+		return
+	}
+	if i < int(r.maxAtCurrentBpe) {
 		r.palette = append(r.palette, v)
 		return
 	}
@@ -144,10 +181,17 @@ func (r *RealStorage) appendPalette(v int32) (i int, err error) {
 
 	bpei := slices.Index(r.format.AvailableBpes, r.bpe)
 	if bpei == len(r.format.AvailableBpes)-1 {
-		err = CannotGrowPalletErr
+		err = NoAvailableBpeErr
 		return
 	}
 	newBpe := r.format.AvailableBpes[bpei+1]
 	r.resize(newBpe)
+	if r.palette == nil {
+		i = int(v) // direct mode
+		return
+	}
+
+	r.palette = append(r.palette, v)
+	i = len(r.palette) - 1
 	return
 }