Forbid z index 7

This cuts memory use significantly, since many sprites in an object are
never used. We can get savings over time by evicting sprites when they
go out of scope, but that's, well, out of scope.

To achieve this, I introduce an assetstore package that is in charge of
loading things from the filesystem. This also allows some lingering
case-sensitivity issues to be handled cleanly.

I'd hoped that creating fewer ebiten.Image instances would help CPU
usage, but that doesn't seem to be the case.

cmd/view-map/main.go

@@ -2,32 +2,26 @@ package main
 
 import (
 	"flag"
-	"fmt"
 	"image"
 	"log"
 	"math"
 	"os"
-	"path/filepath"
+	"sort"
 
 	"github.com/hajimehoshi/ebiten"
 
-	"code.ur.gs/lupine/ordoor/internal/conv"
+	"code.ur.gs/lupine/ordoor/internal/assetstore"
-	"code.ur.gs/lupine/ordoor/internal/data"
-	"code.ur.gs/lupine/ordoor/internal/maps"
-	"code.ur.gs/lupine/ordoor/internal/sets"
 	"code.ur.gs/lupine/ordoor/internal/ui"
 )
 
 var (
 	gamePath = flag.String("game-path", "./orig", "Path to a WH40K: Chaos Gate installation")
-	mapFile  = flag.String("map", "", "Prefix path to a .map file, e.g. ./orig/Maps/Chapter01.MAP")
+	gameMap  = flag.String("map", "", "Name of a map, e.g., Chapter01")
-	txtFile  = flag.String("txt", "", "Prefix path to a .txt file, e.g. ./orig/Maps/Chapter01.txt")
 )
 
 type env struct {
-	gameMap *maps.GameMap
+	assets *assetstore.AssetStore
-	set     *sets.MapSet
+	area   *assetstore.Map
-	objects map[string]*conv.Object
 
 	step      int
 	state     state
@@ -43,54 +37,34 @@ type state struct {
 func main() {
 	flag.Parse()
 
-	if *gamePath == "" || *mapFile == "" || *txtFile == "" {
+	if *gamePath == "" || *gameMap == "" {
 		flag.Usage()
 		os.Exit(1)
 	}
 
-	gameMap, err := maps.LoadGameMapByFiles(*mapFile, *txtFile)
+	assets, err := assetstore.New(*gamePath)
 	if err != nil {
-		log.Fatalf("Couldn't load map file: %v", err)
+		log.Fatalf("Failed to scan root directory %v: %v", *gamePath, err)
 	}
 
-	setFile := filepath.Join(*gamePath, "Sets", gameMap.MapSetFilename())
+	area, err := assets.Map(*gameMap)
-	log.Println(setFile)
-	mapSet, err := sets.LoadSet(setFile)
 	if err != nil {
-		log.Fatalf("Couldn't load set file %s: %v", setFile, err)
+		log.Fatalf("Failed to load map %v: %v", *gameMap, err)
-	}
-
-	objects := make([]*conv.Object, 0, len(mapSet.Palette))
-	for _, name := range mapSet.Palette {
-		objFile := filepath.Join(*gamePath, "Obj", name+".obj")
-		rawObj, err := data.LoadObject(objFile)
-		if err != nil {
-			log.Fatalf("Failed to load %s: %v", name, err)
-		}
-
-		rawObj.Name = name
-
-		obj, err := conv.ConvertObject(rawObj, name)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		objects = append(objects, obj)
 	}
 
 	state := state{
 		zoom:   1.0,
 		origin: image.Point{0, 3000}, // FIXME: haxxx
+		zIdx:   1,
 	}
 	env := &env{
-		gameMap:   gameMap,
+		area:      area,
-		set:       mapSet,
+		assets:    assets,
-		objects:   conv.MapByName(objects),
 		state:     state,
 		lastState: state,
 	}
 
-	win, err := ui.NewWindow("View Map " + *mapFile)
+	win, err := ui.NewWindow("View Map " + *gameMap)
 	if err != nil {
 		log.Fatal("Couldn't create window: %v", err)
 	}
@@ -103,8 +77,8 @@ func main() {
 	win.OnKeyUp(ebiten.KeyDown, env.changeOrigin(+0, +64))
 	win.OnMouseWheel(env.changeZoom)
 
-	for i := 0; i <= 6; i++ {
+	for i := 0; i < 6; i++ {
-		win.OnKeyUp(ebiten.Key1+ebiten.Key(i), env.setZIdx(i))
+		win.OnKeyUp(ebiten.Key1+ebiten.Key(i), env.setZIdx(i+1))
 	}
 
 	if err := win.Run(env.Update, env.Draw); err != nil {
@@ -123,30 +97,6 @@ func (e *env) Update() error {
 	return nil
 }
 
-func (e *env) getSprite(palette []string, ref maps.ObjRef) (*conv.Sprite, error) {
-	// There seems to be an active bit that hides many sins
-	if !ref.IsActive() {
-		return nil, nil
-	}
-
-	if ref.Index() >= len(palette) {
-		return nil, fmt.Errorf("Palette too small: %v requested", ref.Index())
-	}
-
-	name := palette[ref.Index()]
-
-	obj := e.objects[name]
-	if obj == nil {
-		return nil, fmt.Errorf("Failed to find surface sprite %#v -> %q", ref, name)
-	}
-
-	if ref.Sprite() >= len(obj.Sprites) {
-		return nil, fmt.Errorf("Out-of-index sprite %v requested for %v", ref.Sprite(), name)
-	}
-
-	return obj.Sprites[ref.Sprite()], nil
-}
-
 func (e *env) Draw(screen *ebiten.Image) error {
 	// Bounds clipping
 	// http://www.java-gaming.org/index.php?topic=24922.0
@@ -155,35 +105,49 @@ func (e *env) Draw(screen *ebiten.Image) error {
 
 	sw, sh := screen.Size()
 
-	topLeftX, topLeftY := pixToCell(
+	topLeft := pixToCell(e.state.origin)
-		float64(e.state.origin.X),
+	topLeft.X -= 1 // Otherwise we miss half a cell on alternate rows on the left
-		float64(e.state.origin.Y),
-	)
-	topLeftX -= 1 // Otherwise we miss half a cell on alternate rows on the left
 
-	bottomRightX, bottomRightY := pixToCell(
+	bottomRight := pixToCell(image.Pt(e.state.origin.X+sw, e.state.origin.Y+sh))
-		float64(e.state.origin.X+sw),
-		float64(e.state.origin.Y+sh),
-	)
 
 	// X+Y is constant for all tiles in a column
 	// X-Y is constant for all tiles in a row
-	for a := int(topLeftX + topLeftY); a <= int(bottomRightX+bottomRightY); a++ {
+	// However, the drawing order is odd unless we reorder explicitly.
-		for b := int(topLeftX - topLeftY); b <= int(bottomRightX-bottomRightY); b++ {
+	toDraw := []image.Point{}
+	for a := topLeft.X + topLeft.Y; a <= bottomRight.X+bottomRight.Y; a++ {
+		for b := topLeft.X - topLeft.Y; b <= bottomRight.X-bottomRight.Y; b++ {
 			if b&1 != a&1 {
 				continue
 			}
 
-			x := (a + b) / 2
+			pt := image.Pt((a+b)/2, (a-b)/2)
-			y := (a - b) / 2
 
-			if x < int(e.gameMap.MinWidth) || x >= int(e.gameMap.MaxWidth) ||
+			if !pt.In(e.area.Rect) {
-				y < int(e.gameMap.MinLength) || y >= int(e.gameMap.MaxLength) {
 				continue
 			}
+			toDraw = append(toDraw, pt)
+		}
+	}
 
-			for z := 0; z <= e.state.zIdx; z++ {
+	sort.Slice(toDraw, func(i, j int) bool {
-				e.renderCell(x, y, z, screen)
+		iPix := cellToPix(toDraw[i])
+		jPix := cellToPix(toDraw[j])
+
+		if iPix.Y < jPix.Y {
+			return true
+		}
+
+		if iPix.Y == jPix.Y {
+			return iPix.X < jPix.X
+		}
+
+		return false
+	})
+
+	for _, pt := range toDraw {
+		for z := 0; z <= e.state.zIdx; z++ {
+			if err := e.renderCell(pt.X, pt.Y, z, screen); err != nil {
+				return err
 			}
 		}
 	}
@@ -192,38 +156,20 @@ func (e *env) Draw(screen *ebiten.Image) error {
 }
 
 func (e *env) renderCell(x, y, z int, screen *ebiten.Image) error {
-	var sprites []*conv.Sprite
+	images, err := e.area.ImagesForCell(x, y, z)
-	cell := e.gameMap.Cells.At(x, y, z)
+	if err != nil {
-
+		return err
-	if spr, err := e.getSprite(e.set.Palette, cell.Surface); err != nil {
-		log.Printf("%v %v %v surface: %v", x, y, z, err)
-	} else if spr != nil {
-		sprites = append(sprites, spr)
-	}
-
-	if spr, err := e.getSprite(e.set.Palette, cell.Center); err != nil {
-		log.Printf("%v %v %v center: %v", x, y, z, err)
-	} else if spr != nil {
-		sprites = append(sprites, spr)
-	}
-
-	if spr, err := e.getSprite(e.set.Palette, cell.Left); err != nil {
-		log.Printf("%v %v %v left: %v", x, y, z, err)
-	} else if spr != nil {
-		sprites = append(sprites, spr)
-	}
-
-	if spr, err := e.getSprite(e.set.Palette, cell.Right); err != nil {
-		log.Printf("%v %v %v right: %v", x, y, z, err)
-	} else if spr != nil {
-		sprites = append(sprites, spr)
 	}
 
 	iso := ebiten.GeoM{}
 	iso.Translate(-float64(e.state.origin.X), -float64(e.state.origin.Y))
 
-	fx, fy := cellToPix(float64(x), float64(y))
+	pix := cellToPix(image.Pt(x, y))
-	iso.Translate(fx, fy)
+	iso.Translate(float64(pix.X), float64(pix.Y))
+
+	if e.step%30 == 0 {
+		//	log.Printf("x=%v y=%v z=%v", pix.X-e.state.origin.X, pix.Y-e.state.origin.Y, z)
+	}
 
 	// Taking the Z index away *seems* to draw the object in the correct place.
 	// FIXME: There are some artifacts, investigate more
@@ -231,8 +177,8 @@ func (e *env) renderCell(x, y, z int, screen *ebiten.Image) error {
 
 	// TODO: iso.Scale(e.state.zoom, e.state.zoom) // apply current zoom factor
 
-	for _, sprite := range sprites {
+	for _, img := range images {
-		if err := screen.DrawImage(sprite.Image, &ebiten.DrawImageOptions{GeoM: iso}); err != nil {
+		if err := screen.DrawImage(img, &ebiten.DrawImageOptions{GeoM: iso}); err != nil {
 			return err
 		}
 	}
@@ -264,11 +210,17 @@ const (
 )
 
 // Doesn't take the camera or Z level into account
-func cellToPix(x, y float64) (float64, float64) {
+func cellToPix(pt image.Point) image.Point {
-	return (x - y) * cellWidth, (x + y) * cellHeight / 2.0
+	return image.Pt(
+		(pt.X-pt.Y)*cellWidth,
+		(pt.X+pt.Y)*cellHeight/2,
+	)
 }
 
 // Doesn't take the camera or Z level into account
-func pixToCell(x, y float64) (float64, float64) {
+func pixToCell(pt image.Point) image.Point {
-	return y/cellHeight + x/(cellWidth*2.0), y/cellHeight - x/(cellWidth*2.0)
+	return image.Pt(
+		pt.Y/cellHeight+pt.X/(cellWidth*2),
+		pt.Y/cellHeight-pt.X/(cellWidth*2),
+	)
 }

internal/assetstore/assetstore.go

@@ -0,0 +1,125 @@
+package assetstore
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+const (
+	RootDir = "" // Used in the entryMap for entries pertaining to the root dir
+)
+
+type entryMap map[string]map[string]string
+
+// type AssetStore is responsible for lazily loading game data when it is
+// required. Applications shouldn't need to do anything except set one of these
+// up, pointing at the game dir root, to access all assets.
+//
+// Assets should be loaded on-demand to keep memory costs as low as possible.
+// Cross-platform differences such as filename case sensitivity are also dealt
+// with here.
+//
+// We assume the directory is read-only. You can run Refresh() if you make a
+// change.
+type AssetStore struct {
+	RootDir string
+
+	// Case-insensitive file lookup.
+	// {"":{"anim":"Anim", "obj":"Obj", ...}, "anim":{ "warhammer.ani":"WarHammer.ani" }, ...}
+	entries entryMap
+
+	// These members are used to store things we've already loaded
+	maps map[string]*Map
+	objs map[string]*Object
+	sets map[string]*Set
+}
+
+// New returns a new AssetStore
+func New(dir string) (*AssetStore, error) {
+	store := &AssetStore{
+		RootDir: dir,
+	}
+
+	// fill entryMap
+	if err := store.Refresh(); err != nil {
+		return nil, err
+	}
+
+	return store, nil
+}
+
+func (a *AssetStore) Refresh() error {
+	rootEntries, err := processDir(a.RootDir)
+	if err != nil {
+		return fmt.Errorf("failed to process %v: %v", a.RootDir, err)
+	}
+
+	newEntryMap := make(entryMap, len(rootEntries))
+	newEntryMap[RootDir] = rootEntries
+
+	for lower, natural := range rootEntries {
+		path := filepath.Join(a.RootDir, natural)
+		fi, err := os.Stat(path)
+		if err != nil {
+			return fmt.Errorf("Failed to stat %v: %v", path, err)
+		}
+
+		if fi.IsDir() {
+			entries, err := processDir(path)
+			if err != nil {
+				return fmt.Errorf("Failed to process %v: %v", path, err)
+			}
+
+			newEntryMap[lower] = entries
+		}
+	}
+
+	// Refresh
+	a.entries = newEntryMap
+	a.maps = make(map[string]*Map)
+	a.objs = make(map[string]*Object)
+	a.sets = make(map[string]*Set)
+
+	return nil
+}
+
+func (a *AssetStore) lookup(name, ext string, dirs ...string) (string, error) {
+	filename := canonical(name + "." + ext)
+
+	for _, dir := range dirs {
+		dir = canonical(dir)
+		if base, ok := a.entries[dir]; ok {
+			if file, ok := base[filename]; ok {
+				actualDir := a.entries[RootDir][dir]
+				return filepath.Join(a.RootDir, actualDir, file), nil
+			}
+		}
+	}
+
+	return "", os.ErrNotExist
+}
+
+func canonical(s string) string {
+	return strings.ToLower(s)
+}
+
+func processDir(dir string) (map[string]string, error) {
+	entries, err := ioutil.ReadDir(dir)
+	if err != nil {
+		return nil, err
+	}
+
+	out := make(map[string]string, len(entries))
+	for _, entry := range entries {
+		if entry.Name() == "." || entry.Name() == ".." {
+			continue
+		}
+
+		out[canonical(entry.Name())] = entry.Name()
+	}
+
+	return out, nil
+}

internal/assetstore/map.go

@@ -0,0 +1,92 @@
+package assetstore
+
+import (
+	"image"
+	"log"
+
+	"github.com/hajimehoshi/ebiten"
+
+	"code.ur.gs/lupine/ordoor/internal/maps"
+)
+
+type Map struct {
+	assets *AssetStore
+	set    *Set
+	Rect   image.Rectangle
+
+	raw *maps.GameMap
+}
+
+// Map loads a game map with the given name (e.g. "Chapter01")
+func (a *AssetStore) Map(name string) (*Map, error) {
+	name = canonical(name)
+
+	if m, ok := a.maps[name]; ok {
+		return m, nil
+	}
+	log.Printf("Loading map %v", name)
+
+	mapFile, err := a.lookup(name, "map", "Maps", "MultiMaps")
+	if err != nil {
+		return nil, err
+	}
+
+	txtFile, err := a.lookup(name, "txt", "Maps", "MultiMaps")
+	if err != nil {
+		return nil, err
+	}
+
+	raw, err := maps.LoadGameMapByFiles(mapFile, txtFile)
+	if err != nil {
+		return nil, err
+	}
+
+	// The set for a map is small and frequently referenced, so load it here
+	set, err := a.Set(raw.MapSetName())
+	if err != nil {
+		return nil, err
+	}
+
+	m := &Map{
+		Rect: image.Rect(
+			int(raw.MinWidth),
+			int(raw.MinLength),
+			int(raw.MaxWidth),
+			int(raw.MaxLength),
+		),
+		assets: a,
+		raw:    raw,
+		set:    set,
+	}
+
+	a.maps[canonical(name)] = m
+
+	return m, nil
+}
+
+// ImagesForCell returns the sprites needed to correctly render this cell.
+// They should be rendered from first to last to get the correct ordering
+func (m *Map) ImagesForCell(x, y, z int) ([]*ebiten.Image, error) {
+	cell := m.raw.At(x, y, z)
+	images := make([]*ebiten.Image, 0, 4)
+
+	for _, ref := range []maps.ObjRef{cell.Surface, cell.Right, cell.Left, cell.Center} {
+		if !ref.IsActive() {
+			continue
+		}
+
+		obj, err := m.set.Object(ref.Index())
+		if err != nil {
+			return nil, err
+		}
+
+		img, err := obj.Image(ref.Sprite())
+		if err != nil {
+			return nil, err
+		}
+
+		images = append(images, img)
+	}
+
+	return images, nil
+}

internal/assetstore/object.go

@@ -0,0 +1,69 @@
+package assetstore
+
+import (
+	"log"
+
+	"github.com/hajimehoshi/ebiten"
+
+	"code.ur.gs/lupine/ordoor/internal/data"
+)
+
+type Object struct {
+	assets *AssetStore
+	images []*ebiten.Image
+
+	raw *data.Object
+}
+
+func (a *AssetStore) Object(name string) (*Object, error) {
+	name = canonical(name)
+
+	if obj, ok := a.objs[name]; ok {
+		return obj, nil
+	}
+	log.Printf("Loading object %v", name)
+
+	filename, err := a.lookup(name, "obj", "Obj")
+	if err != nil {
+		return nil, err
+	}
+
+	raw, err := data.LoadObjectLazily(filename)
+	if err != nil {
+		return nil, err
+	}
+	raw.Name = name
+
+	obj := &Object{
+		assets: a,
+		images: make([]*ebiten.Image, int(raw.NumSprites)),
+		raw:    raw,
+	}
+	a.objs[name] = obj
+
+	return obj, nil
+}
+
+// Filled lazily
+func (o *Object) Image(idx int) (*ebiten.Image, error) {
+	if img := o.images[idx]; img != nil {
+		return img, nil
+	}
+	log.Printf("Loading sprite %v %v", o.raw.Name, idx)
+
+	if o.raw.Sprites[idx] == nil {
+		if err := o.raw.LoadSprite(idx); err != nil {
+			return nil, err
+		}
+	}
+
+	stdImg := o.raw.Sprites[idx].ToImage()
+	img, err := ebiten.NewImageFromImage(stdImg, ebiten.FilterDefault)
+	if err != nil {
+		return nil, err
+	}
+
+	o.images[idx] = img
+
+	return img, nil
+}

internal/assetstore/set.go

@@ -0,0 +1,52 @@
+package assetstore
+
+import (
+	"errors"
+	"log"
+
+	"code.ur.gs/lupine/ordoor/internal/sets"
+)
+
+var (
+	ErrOutOfBounds = errors.New("Out of bounds")
+)
+
+type Set struct {
+	assets *AssetStore
+
+	raw *sets.MapSet
+}
+
+func (s *Set) Object(idx int) (*Object, error) {
+	if idx < 0 || idx >= len(s.raw.Palette) {
+		return nil, ErrOutOfBounds
+	}
+
+	return s.assets.Object(s.raw.Palette[idx])
+}
+
+func (a *AssetStore) Set(name string) (*Set, error) {
+	name = canonical(name)
+	if set, ok := a.sets[name]; ok {
+		return set, nil
+	}
+	log.Printf("Loading set %v", name)
+
+	filename, err := a.lookup(name, "set", "Sets")
+	if err != nil {
+		return nil, err
+	}
+
+	raw, err := sets.LoadSet(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	set := &Set{
+		assets: a,
+		raw:    raw,
+	}
+	a.sets[name] = set
+
+	return set, nil
+}

internal/conv/object.go

@@ -41,29 +41,13 @@ func ConvertObject(rawObj *data.Object, name string) (*Object, error) {
 	for i, rawSpr := range rawObj.Sprites {
 		w := int(rawSpr.Width)
 		h := int(rawSpr.Height)
-		data := spriteToData(name, i, rawSpr)
+		ebitenImage, err := ebiten.NewImageFromImage(rawSpr.ToImage(), ebiten.FilterDefault)
-
-		image, err := ebiten.NewImage(w, h, ebiten.FilterDefault)
 		if err != nil {
 			return nil, err
 		}
-		_ = image.ReplacePixels(data)
 
-		out.Sprites[i] = &Sprite{Width: w, Height: h, Image: image}
+		out.Sprites[i] = &Sprite{Width: w, Height: h, Image: ebitenImage}
 	}
 
 	return out, nil
 }
-
-func spriteToData(name string, idx int, sprite *data.Sprite) []byte {
-	width := int(sprite.Width)
-	height := int(sprite.Height)
-	out := make([]byte, 0, 4*width*height)
-
-	for _, palette := range sprite.Data {
-		color := data.ColorPalette[int(palette)]
-		out = append(out, color.R, color.G, color.B, color.A)
-	}
-
-	return out
-}

internal/data/object.go

@@ -3,6 +3,7 @@ package data
 import (
 	"encoding/binary"
 	"fmt"
+	"image"
 	"io"
 	"io/ioutil"
 	"os"
@@ -40,6 +41,16 @@ type Sprite struct {
 	Data []byte
 }
 
+func (s *Sprite) ToImage() *image.Paletted {
+	return &image.Paletted{
+		Pix:     s.Data,
+		Stride:  int(s.Width),
+		Rect:    image.Rect(0, 0, int(s.Width), int(s.Height)),
+		Palette: ColorPalette,
+	}
+}
+
+// dirEntry totals 8 bytes on disk
 type dirEntry struct {
 	Offset uint32 // Offset of the sprite relative to the data block
 	Size   uint32 // Size of the sprite in bytes, including any header
@@ -84,7 +95,7 @@ type Object struct {
 	Sprites  []*Sprite
 }
 
-func LoadObject(filename string) (*Object, error) {
+func LoadObjectLazily(filename string) (*Object, error) {
 	f, err := os.Open(filename)
 	if err != nil {
 		return nil, err
@@ -101,53 +112,85 @@ func LoadObject(filename string) (*Object, error) {
 		return nil, err
 	}
 
-	// Now load all sprites into memory
+	out.Sprites = make([]*Sprite, int(out.NumSprites))
-	dir := make([]dirEntry, out.NumSprites)
-	if _, err := f.Seek(int64(out.DirOffset), io.SeekStart); err != nil {
-		return nil, fmt.Errorf("Seeking to sprite directory: %v", err)
-	}
-
-	if err := binary.Read(f, binary.LittleEndian, &dir); err != nil {
-		return nil, fmt.Errorf("Reading sprite directory: %v", err)
-	}
-
-	if _, err := f.Seek(int64(out.DataOffset), io.SeekStart); err != nil {
-		return nil, fmt.Errorf("Seeking to sprites: %v", err)
-	}
-
-	for i, dirEntry := range dir {
-		if err := dirEntry.Check(); err != nil {
-			return nil, err
-		}
-
-		if _, err := f.Seek(int64(out.DataOffset+dirEntry.Offset), io.SeekStart); err != nil {
-			return nil, fmt.Errorf("Seeking to sprite %v: %v", i, err)
-		}
-
-		sprite := &Sprite{}
-
-		if err := binary.Read(f, binary.LittleEndian, &sprite.SpriteHeader); err != nil {
-			return nil, fmt.Errorf("Reading sprite %v header: %v", i, err)
-		}
-
-		if err := sprite.Check(dirEntry.Size); err != nil {
-			return nil, err
-		}
-
-		buf := io.LimitReader(f, int64(sprite.PixelSize))
-		sprite.Data = make([]byte, int(sprite.Height)*int(sprite.Width))
-
-		// The pixel data is RLE-compressed. Uncompress it here.
-		if err := rle.Expand(buf, sprite.Data); err != nil {
-			return nil, err
-		}
-
-		out.Sprites = append(out.Sprites, sprite)
-	}
 
 	return out, nil
 }
 
+func LoadObject(filename string) (*Object, error) {
+	obj, err := LoadObjectLazily(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := obj.LoadAllSprites(); err != nil {
+		return nil, err
+	}
+
+	return obj, nil
+}
+
+func (o *Object) LoadAllSprites() error {
+	for i := 0; i < int(o.NumSprites); i++ {
+		if err := o.LoadSprite(i); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (o *Object) LoadSprite(idx int) error {
+	if idx < 0 || idx >= int(o.NumSprites) {
+		return fmt.Errorf("Asked for idx %v of %v", idx, o.NumSprites)
+	}
+
+	f, err := os.Open(o.Filename)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	var entry dirEntry
+
+	if _, err := f.Seek(int64(o.DirOffset)+int64(idx*8), io.SeekStart); err != nil {
+		return fmt.Errorf("Seeking to sprite directory entry %v: %v", idx, err)
+	}
+
+	if err := binary.Read(f, binary.LittleEndian, &entry); err != nil {
+		return fmt.Errorf("Reading sprite directory entry %v: %v", idx, err)
+	}
+
+	if err := entry.Check(); err != nil {
+		return err
+	}
+
+	if _, err := f.Seek(int64(o.DataOffset+entry.Offset), io.SeekStart); err != nil {
+		return fmt.Errorf("Seeking to sprite %v: %v", idx, err)
+	}
+
+	sprite := &Sprite{}
+
+	if err := binary.Read(f, binary.LittleEndian, &sprite.SpriteHeader); err != nil {
+		return fmt.Errorf("Reading sprite %v header: %v", idx, err)
+	}
+
+	if err := sprite.Check(entry.Size); err != nil {
+		return err
+	}
+
+	buf := io.LimitReader(f, int64(sprite.PixelSize))
+	sprite.Data = make([]byte, int(sprite.Height)*int(sprite.Width))
+
+	// The pixel data is RLE-compressed. Uncompress it here.
+	if err := rle.Expand(buf, sprite.Data); err != nil {
+		return err
+	}
+
+	o.Sprites[idx] = sprite
+	return nil
+}
+
 func LoadObjects(dir string) (map[string]*Object, error) {
 	fis, err := ioutil.ReadDir(dir)
 	if err != nil {

internal/data/palette.go

@@ -5,7 +5,7 @@ import "image/color"
 var (
 	Transparent = color.RGBA{R: 0, G: 0, B: 0, A: 0}
 
-	ColorPalette = []color.RGBA{
+	ColorPalette = color.Palette{
 		Transparent,
 		color.RGBA{R: 128, G: 0, B: 0, A: 255},
 		color.RGBA{R: 0, G: 128, B: 0, A: 255},

internal/maps/maps.go

@@ -59,13 +59,17 @@ func (h Header) Height() int {
 	return MaxHeight
 }
 
-func (h Header) MapSetFilename() string {
+func (h Header) MapSetName() string {
 	idx := bytes.IndexByte(h.SetName[:], 0)
 	if idx < 0 {
 		idx = 8 // all 8 bytes are used
 	}
 
-	return string(h.SetName[0:idx:idx]) + ".set"
+	return string(h.SetName[0:idx:idx])
+}
+
+func (h Header) MapSetFilename() string {
+	return h.MapSetName() + ".set"
 }
 
 type ObjRef struct {

internal/ui/window.go

@@ -3,6 +3,9 @@ package ui
 import (
 	"flag"
 	"fmt"
+	"log"
+	"os"
+	"runtime/pprof"
 
 	"github.com/hajimehoshi/ebiten"
 	"github.com/hajimehoshi/ebiten/ebitenutil"
@@ -10,8 +13,9 @@ import (
 )
 
 var (
-	winX = flag.Int("win-x", 1280, "width of the view-map window")
+	screenScale = flag.Float64("screen-scale", 1.0, "Scale the window by this factor")
-	winY = flag.Int("win-y", 1024, "height of the view-map window")
+
+	cpuprofile = flag.String("cpuprofile", "", "write cpu profile to `file`")
 )
 
 type Window struct {
@@ -24,6 +28,7 @@ type Window struct {
 	drawFn   func(*ebiten.Image) error
 
 	debug bool
+	firstRun bool
 }
 
 // 0,0 is the *top left* of the window
@@ -36,6 +41,7 @@ func NewWindow(title string) (*Window, error) {
 		Title:         title,
 		KeyUpHandlers: make(map[ebiten.Key]func()),
 		debug:         true,
+		firstRun:      true,
 	}, nil
 }
 
@@ -49,6 +55,11 @@ func (w *Window) OnMouseWheel(f func(x, y float64)) {
 }
 
 func (w *Window) run(screen *ebiten.Image) error {
+	if w.firstRun {
+		ebiten.SetScreenScale(*screenScale)
+		w.firstRun = false
+	}
+
 	if err := w.updateFn(); err != nil {
 		return err
 	}
@@ -91,5 +102,17 @@ func (w *Window) Run(updateFn func() error, drawFn func(*ebiten.Image) error) er
 	w.updateFn = updateFn
 	w.drawFn = drawFn
 
-	return ebiten.Run(w.run, *winX, *winY, 1, w.Title)
+	if *cpuprofile != "" {
+        f, err := os.Create(*cpuprofile)
+        if err != nil {
+            log.Fatal("could not create CPU profile: ", err)
+        }
+        defer f.Close() // error handling omitted for example
+        if err := pprof.StartCPUProfile(f); err != nil {
+            log.Fatal("could not start CPU profile: ", err)
+        }
+        defer pprof.StopCPUProfile()
+    }
+
+	return ebiten.Run(w.run, 640, 480, 1, w.Title) // Native game resolution: 640x480
 }