doodle/pkg/doodads/fmt_zipfile.go

124 lines
2.6 KiB
Go

package doodads
import (
"archive/zip"
"bytes"
"encoding/json"
"fmt"
"git.kirsle.net/SketchyMaze/doodle/pkg/balance"
"git.kirsle.net/SketchyMaze/doodle/pkg/log"
)
// ToZipfile serializes the doodad into zipfile format.
func (d *Doodad) ToZipfile() ([]byte, error) {
fh := bytes.NewBuffer([]byte{})
zipper := zip.NewWriter(fh)
defer zipper.Close()
// Migrate the Chunker caches into the zipfile.
for _, layer := range d.Layers {
if err := layer.Chunker.MigrateZipfile(zipper); err != nil {
return nil, fmt.Errorf("MigrateZipfile: %s", err)
}
}
// Migrate attached files to ZIP.
if d.Files != nil {
if err := d.Files.MigrateZipfile(zipper); err != nil {
return nil, fmt.Errorf("FileSystem.MigrateZipfile: %s", err)
}
}
// Write the header json.
{
header, err := d.AsJSON()
if err != nil {
return nil, err
}
writer, err := zipper.Create("doodad.json")
if err != nil {
return nil, err
}
if n, err := writer.Write(header); err != nil {
return nil, err
} else {
log.Debug("Written doodad.json to zipfile: %d bytes", n)
}
}
zipper.Close()
// Refresh our Zipfile reader from the zipper we just wrote.
bin := fh.Bytes()
if err := d.ReloadZipfile(bin); err != nil {
log.Error("ReloadZipfile: %s", err)
}
return fh.Bytes(), nil
}
// FromZipfile reads a doodad from zipfile format.
func FromZipfile(data []byte) (*Doodad, error) {
var (
doodad = New(balance.DoodadSize)
err = doodad.populateFromZipfile(data)
)
return doodad, err
}
// ReloadZipfile re-reads the level's zipfile after a write.
func (d *Doodad) ReloadZipfile(data []byte) error {
return d.populateFromZipfile(data)
}
// Common function between FromZipfile and ReloadZipFile.
func (d *Doodad) populateFromZipfile(data []byte) error {
var (
buf = bytes.NewReader(data)
zf *zip.Reader
decoder *json.Decoder
)
zf, err := zip.NewReader(buf, buf.Size())
if err != nil {
return err
}
// Read the doodad.json.
file, err := zf.Open("doodad.json")
if err != nil {
return err
}
decoder = json.NewDecoder(file)
err = decoder.Decode(d)
// Keep the zipfile reader handy.
d.Zipfile = zf
if d.Files != nil {
d.Files.Zipfile = zf
}
for i, layer := range d.Layers {
layer.Chunker.Layer = i
layer.Chunker.Zipfile = zf
}
// Re-inflate data after saving a new zipfile.
d.Inflate()
return err
}
// Loop may be called each loop to allow the level to maintain its
// memory usage, e.g., for chunks not requested recently from a zipfile
// level to free those from RAM.
func (d *Doodad) Loop() error {
for _, layer := range d.Layers {
layer.Chunker.FreeCaches()
}
return nil
}