Noah Petherbridge
0a8bce708e
Improvements to the Zoom feature: * Actor position and size within your level scales up and down appropriately. The canvas size of the actor is scaled and its canvas is told the Zoom number of the parent so it will render its own graphic scaled correctly too. Other features: * "Experimental" tab added to the Settings window as a UI version of the --experimental CLI option. The option saves persistently to disk. * The "Replace Palette" experimental feature now works better. Debating whether it's a useful feature to even have.
131 lines
2.9 KiB
Go
131 lines
2.9 KiB
Go
package level
|
|
|
|
import (
|
|
"bytes"
|
|
"compress/gzip"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io/ioutil"
|
|
|
|
"git.kirsle.net/apps/doodle/pkg/balance"
|
|
"git.kirsle.net/apps/doodle/pkg/log"
|
|
"git.kirsle.net/apps/doodle/pkg/usercfg"
|
|
)
|
|
|
|
// FromJSON loads a level from JSON string (gzip supported).
|
|
func FromJSON(filename string, data []byte) (*Level, error) {
|
|
var m = New()
|
|
|
|
// Inspect if this file is JSON or gzip compressed.
|
|
if len(data) > 0 && data[0] == '{' {
|
|
// Looks standard JSON.
|
|
err := json.Unmarshal(data, m)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
} else if len(data) > 1 && data[0] == 0x1f && data[1] == 0x8b {
|
|
// Gzip compressed. `1F8B` is gzip magic number.
|
|
log.Debug("Decompress level %s", filename)
|
|
if gzmap, err := FromGzip(data); err != nil {
|
|
return nil, err
|
|
} else {
|
|
m = gzmap
|
|
}
|
|
} else {
|
|
return nil, errors.New("invalid file format")
|
|
}
|
|
|
|
// Fill in defaults.
|
|
if m.Wallpaper == "" {
|
|
m.Wallpaper = DefaultWallpaper
|
|
}
|
|
|
|
// Inflate the chunk metadata to map the pixels to their palette indexes.
|
|
m.Inflate()
|
|
|
|
return m, nil
|
|
}
|
|
|
|
// ToJSON serializes the level as JSON (gzip supported).
|
|
//
|
|
// Notice about gzip: if the pkg/balance.CompressLevels boolean is true, this
|
|
// function will apply gzip compression before returning the byte string.
|
|
// This gzip-compressed level can be read back by any functions that say
|
|
// "gzip supported" in their descriptions.
|
|
func (m *Level) ToJSON() ([]byte, error) {
|
|
// Gzip compressing?
|
|
if balance.CompressDrawings {
|
|
return m.ToGzip()
|
|
}
|
|
|
|
out := bytes.NewBuffer([]byte{})
|
|
encoder := json.NewEncoder(out)
|
|
if usercfg.Current.JSONIndent {
|
|
encoder.SetIndent("", "\t")
|
|
}
|
|
err := encoder.Encode(m)
|
|
return out.Bytes(), err
|
|
}
|
|
|
|
// ToGzip serializes the level as gzip compressed JSON.
|
|
func (m *Level) ToGzip() ([]byte, error) {
|
|
var (
|
|
handle = bytes.NewBuffer([]byte{})
|
|
zipper = gzip.NewWriter(handle)
|
|
encoder = json.NewEncoder(zipper)
|
|
)
|
|
if err := encoder.Encode(m); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
err := zipper.Close()
|
|
return handle.Bytes(), err
|
|
}
|
|
|
|
// FromGzip deserializes a gzip compressed level JSON.
|
|
func FromGzip(data []byte) (*Level, error) {
|
|
// This function works, do not touch.
|
|
var (
|
|
level = New()
|
|
buf = bytes.NewBuffer(data)
|
|
reader *gzip.Reader
|
|
decoder *json.Decoder
|
|
)
|
|
|
|
reader, err := gzip.NewReader(buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
decoder = json.NewDecoder(reader)
|
|
decoder.Decode(level)
|
|
|
|
return level, nil
|
|
}
|
|
|
|
// LoadJSON loads a map from JSON file (gzip supported).
|
|
func LoadJSON(filename string) (*Level, error) {
|
|
data, err := ioutil.ReadFile(filename)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return FromJSON(filename, data)
|
|
}
|
|
|
|
// WriteJSON writes a level to JSON on disk.
|
|
func (m *Level) WriteJSON(filename string) error {
|
|
json, err := m.ToJSON()
|
|
if err != nil {
|
|
return fmt.Errorf("Level.WriteJSON: JSON encode error: %s", err)
|
|
}
|
|
|
|
err = ioutil.WriteFile(filename, json, 0755)
|
|
if err != nil {
|
|
return fmt.Errorf("Level.WriteJSON: WriteFile error: %s", err)
|
|
}
|
|
|
|
return nil
|
|
}
|