Noah Petherbridge
9e4f34864d
* Clean up unused msgpack code for levels and doodads * Fix the cosmetic bug where actors in your level would display wrongly when scrolling off the top/left edges of the screen: they used to anchor at their own 0,0 coordinate and crop their width/height leading to a 'scrolling' effect that didn't happen on the right/bottom edges.
130 lines
2.9 KiB
Go
130 lines
2.9 KiB
Go
package level
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
|
|
"git.kirsle.net/go/render"
|
|
)
|
|
|
|
// MapAccessor implements a chunk accessor by using a map of points to their
|
|
// palette indexes. This is the simplest accessor and is best for sparse chunks.
|
|
type MapAccessor map[render.Point]*Swatch
|
|
|
|
// NewMapAccessor initializes a MapAccessor.
|
|
func NewMapAccessor() MapAccessor {
|
|
return MapAccessor{}
|
|
}
|
|
|
|
// Inflate the sparse swatches from their palette indexes.
|
|
func (a MapAccessor) Inflate(pal *Palette) error {
|
|
for point, swatch := range a {
|
|
if swatch.IsSparse() {
|
|
// Replace this with the correct swatch from the palette.
|
|
if swatch.paletteIndex >= len(pal.Swatches) {
|
|
return fmt.Errorf("MapAccessor.Inflate: swatch for point %s has paletteIndex %d but palette has only %d colors",
|
|
point,
|
|
swatch.paletteIndex,
|
|
len(pal.Swatches),
|
|
)
|
|
}
|
|
a[point] = pal.Swatches[swatch.paletteIndex]
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Len returns the current size of the map, or number of pixels registered.
|
|
func (a MapAccessor) Len() int {
|
|
return len(a)
|
|
}
|
|
|
|
// IterViewport returns a channel to loop over pixels in the viewport.
|
|
func (a MapAccessor) IterViewport(viewport render.Rect) <-chan Pixel {
|
|
pipe := make(chan Pixel)
|
|
go func() {
|
|
for px := range a.Iter() {
|
|
if px.Point().Inside(viewport) {
|
|
pipe <- px
|
|
}
|
|
}
|
|
close(pipe)
|
|
}()
|
|
return pipe
|
|
}
|
|
|
|
// Iter returns a channel to loop over all points in this chunk.
|
|
func (a MapAccessor) Iter() <-chan Pixel {
|
|
pipe := make(chan Pixel)
|
|
go func() {
|
|
for point, swatch := range a {
|
|
pipe <- Pixel{
|
|
X: point.X,
|
|
Y: point.Y,
|
|
Swatch: swatch,
|
|
}
|
|
}
|
|
close(pipe)
|
|
}()
|
|
return pipe
|
|
}
|
|
|
|
// Get a pixel from the map.
|
|
func (a MapAccessor) Get(p render.Point) (*Swatch, error) {
|
|
pixel, ok := a[p]
|
|
if !ok {
|
|
return nil, errors.New("no pixel")
|
|
}
|
|
return pixel, nil
|
|
}
|
|
|
|
// Set a pixel on the map.
|
|
func (a MapAccessor) Set(p render.Point, sw *Swatch) error {
|
|
a[p] = sw
|
|
return nil
|
|
}
|
|
|
|
// Delete a pixel from the map.
|
|
func (a MapAccessor) Delete(p render.Point) error {
|
|
if _, ok := a[p]; ok {
|
|
delete(a, p)
|
|
return nil
|
|
}
|
|
return errors.New("pixel was not there")
|
|
}
|
|
|
|
// MarshalJSON to convert the chunk map to JSON.
|
|
//
|
|
// When serialized, the key is the "X,Y" coordinate and the value is the
|
|
// swatch index of the Palette, rather than redundantly serializing out the
|
|
// Swatch object for every pixel.
|
|
func (a MapAccessor) MarshalJSON() ([]byte, error) {
|
|
dict := map[string]int{}
|
|
for point, sw := range a {
|
|
dict[point.String()] = sw.Index()
|
|
}
|
|
|
|
out, err := json.Marshal(dict)
|
|
return out, err
|
|
}
|
|
|
|
// UnmarshalJSON to convert the chunk map back from JSON.
|
|
func (a MapAccessor) UnmarshalJSON(b []byte) error {
|
|
var dict map[string]int
|
|
err := json.Unmarshal(b, &dict)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for coord, index := range dict {
|
|
point, err := render.ParsePoint(coord)
|
|
if err != nil {
|
|
return fmt.Errorf("MapAccessor.UnmarshalJSON: %s", err)
|
|
}
|
|
a[point] = NewSparseSwatch(index)
|
|
}
|
|
|
|
return nil
|
|
}
|