helper funcs

Author: setanarut

_examples/parser/main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"fmt"
 	"strconv"
 
 	"github.com/anthonynsimon/bild/imgio"
@@ -15,14 +16,22 @@ func main() {
 		panic(err)
 	}
 
-	ase.BuildTilemapImages()
+	fmt.Println(len(ase.Tags))
+
+	tag2 := ase.GetTagByName("tag2")
+	myImageLayer := ase.GetLayerByName("my image layer")
+	imgio.Save(
+		myImageLayer.Name+"_"+tag2.Name+"_start.png",
+		myImageLayer.Cel(tag2.Start).Image,
+		imgio.PNGEncoder(),
+	)
 
+	ase.BuildTilemapImages()
 	frame := 0
 	for i, layer := range ase.Layers {
-		if layer.IsCelEmpty(0) || layer.Type == aseprite.Group {
-			continue
+		if !layer.IsCelEmpty(frame) && layer.IsTilemapLayer() {
+			imgio.Save(strconv.Itoa(i)+"_"+layer.Name+".png", layer.Cel(frame).Image, imgio.PNGEncoder())
 		}
-		imgio.Save(strconv.Itoa(i)+"_"+layer.Name+".png", layer.Cel(frame).Image, imgio.PNGEncoder())
 	}
 
 }

ase.go

@@ -37,7 +37,7 @@ type Ase struct {
 	Slices []Slice
 
 	// Timeline animation tags
-	Tags []Tag
+	Tags []*Tag
 
 	// Tilesets used in Tilemap layers
 	Tilesets []*Tileset
@@ -63,6 +63,18 @@ func (a *Ase) GetLayerByName(name string) *Layer {
 	return a.Layers[idx]
 }
 
+// GetTagByName returns the first Tag with the given name.
+// Returns nil if no layer is found with that name.
+func (a *Ase) GetTagByName(tagName string) *Tag {
+	idx := slices.IndexFunc(a.Tags, func(t *Tag) bool {
+		return t.Name == tagName
+	})
+	if idx == -1 {
+		return nil
+	}
+	return a.Tags[idx]
+}
+
 // GetLayerByUUID returns the layer with the given UUID.
 // Returns nil if no layer is found with that UUID.
 func (a *Ase) GetLayerByUUID(id uuid.UUID) *Layer {
@@ -218,7 +230,7 @@ func (a *Ase) parse(r io.Reader, onlyVisible bool) (filesize int64, err error) {
 				startIdx := len(a.Tags)
 				a.Tags = append(a.Tags, newTags...)
 				for k := range newTags {
-					tagQueue = append(tagQueue, &a.Tags[startIdx+k])
+					tagQueue = append(tagQueue, a.Tags[startIdx+k])
 				}
 				lastUserDataTarget = nil
 			case 0x2022:
@@ -357,18 +369,21 @@ func (a *Ase) parseSlice(raw []byte, totalFrames int) Slice {
 }
 
 // Chunk0x2018
-func (a *Ase) parseTags(raw []byte) []Tag {
+func (a *Ase) parseTags(raw []byte) []*Tag {
 	ntags := int(binary.LittleEndian.Uint16(raw))
-	tags := make([]Tag, ntags)
+	tags := make([]*Tag, 0, ntags)
 	ptr := raw[10:]
-	for i := range ntags {
-		t := &tags[i]
+
+	for range ntags {
+		t := &Tag{}
 		t.Start = int(binary.LittleEndian.Uint16(ptr))
 		t.End = int(binary.LittleEndian.Uint16(ptr[2:]))
 		t.LoopDirection = LoopDirection(ptr[4])
 		t.Repeat = binary.LittleEndian.Uint16(ptr[5:])
 		nameLen := binary.LittleEndian.Uint16(ptr[17:])
 		t.Name = string(ptr[19 : 19+nameLen])
+
+		tags = append(tags, t)
 		ptr = ptr[19+nameLen:]
 	}
 

ase_test.go

@@ -151,6 +151,9 @@ func TestAseDataStructure(t *testing.T) {
 						Type:       2,
 						Opacity:    255,
 						Image:      &image.Paletted{},
+						UserData: UserData{
+							Text: "tag2_start",
+						},
 					},
 					{
 						LayerIndex: 2,
@@ -178,7 +181,7 @@ func TestAseDataStructure(t *testing.T) {
 				},
 			},
 		},
-		Tags: []Tag{
+		Tags: []*Tag{
 			{
 				Name: "tag1",
 				UserData: UserData{
@@ -252,14 +255,25 @@ func TestAseProp(t *testing.T) {
 
 func TestPalettedTilemapRender(t *testing.T) {
 
-	a, err := Read("test_files/test_paletted.ase", false)
+	ase, err := Read("test_files/test_paletted.ase", false)
 	if err != nil {
 		t.Fatalf("Failed to read file: %v", err)
 	}
 
-	a.BuildTilemapImages()
+	tag2 := ase.GetTagByName("tag2")
+	imlayer := ase.GetLayerByName("my image layer")
 
-	gotImage := a.GetLayerByName("test tilemap").Cel(0).Image
+	if imlayer.Cel(tag2.Start).UserData.Text != "tag2_start" {
+		t.Errorf("tag2 start userdata text is not tag2_start")
+	}
+
+	ase.BuildTilemapImages()
+
+	if !ase.GetLayerByName("test tilemap").IsTilemapLayer() {
+		t.Errorf("test tilemap layer is not tilemap layer")
+	}
+
+	gotImage := ase.GetLayerByName("test tilemap").Cel(0).Image
 
 	gotImageP, ok := gotImage.(*image.Paletted)
 
@@ -557,7 +571,7 @@ func compareAse(t *testing.T, exp, act *Ase) {
 		t.Errorf("Tags count: expected %d, got %d", len(exp.Tags), len(act.Tags))
 	} else {
 		for i := range exp.Tags {
-			compareTag(t, i, &exp.Tags[i], &act.Tags[i])
+			compareTag(t, i, exp.Tags[i], act.Tags[i])
 		}
 	}
 

test_files/test_paletted.ase

@@ -361,6 +361,13 @@ func (l *Layer) IsReferenceLayer() bool {
 	return l.Flags&64 != 0
 }
 
+func (l *Layer) IsTilemapLayer() bool {
+	return l.Type == Tilemap
+}
+func (l *Layer) IsGroupLayer() bool {
+	return l.Type == Group
+}
+
 // GetTileset returns the Tileset used by Tilemap layers.
 // It returns nil if layer is not a tilemap.
 func (l *Layer) GetTileset() *Tileset {