Move loading fonts to a new font package

This is not a core functionality. Game developer does not have to load fonts manually, because system and custom fonts are loaded automatically.

Author: elgopher

internal/font/font.go renamed to font/font.go

@@ -4,18 +4,40 @@
 package font
 
 import (
+	"bytes"
 	"fmt"
 
 	"github.com/elgopher/pi/image"
 )
 
-// Load gets non-zero pixels from the font sheet and converts them to font data understood by π.
-// The result is inserted into fontData slice.
+// Load loads font-sheet (png image) and converts
+// it to font data. Image must be 128x128. Each char is 8x8.
+// Char 0 is in the top-left corner. Char 1 to the right.
 //
-// Img must be 128x128. Each char is 8x8. Char 0 is in the top-left corner. Char 1 to the right.
+// This function can be used if you want to use 3rd font:
 //
-// fontData must have length of 2048.
-func Load(img image.Image, fontData []byte) error {
+// myFont := pi.Font{Width:4, WidthSpecial:8, Height: 8}
+// pi.Load(png, myFont.Data[:])
+//
+// Color with index 0 is treated as background. Any other color
+// as foreground.
+//
+// The result is inserted into fontData slice. The size of slice must
+// be 2048.
+func Load(png []byte, fontData []byte) error {
+	img, err := image.DecodePNG(bytes.NewReader(png))
+	if err != nil {
+		return fmt.Errorf("decoding font failed: %w", err)
+	}
+
+	if err = load(img, fontData[:]); err != nil {
+		return fmt.Errorf("error system font: %w", err)
+	}
+
+	return nil
+}
+
+func load(img image.Image, fontData []byte) error {
 	const (
 		charWidth, charHeight  = 8, 8   // in pixels
 		rows, cells            = 16, 16 // number of rows and cells in font sheet

internal/font/font_test.go renamed to font/font_test.go

@@ -4,25 +4,40 @@
 package font_test
 
 import (
-	"bytes"
 	_ "embed"
 	"testing"
 
-	"github.com/elgopher/pi/image"
-	"github.com/elgopher/pi/internal/font"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
+	"github.com/elgopher/pi/font"
 )
 
-//go:embed font_test.png
-var testFont []byte
+var (
+	//go:embed internal/invalid-width.png
+	invalidWidthImage []byte
+
+	//go:embed internal/invalid-height.png
+	invalidHeightImage []byte
+
+	//go:embed internal/valid.png
+	validImage []byte
+
+	//go:embed internal/empty.png
+	emptyImage []byte
+)
 
 func TestLoadImageInto(t *testing.T) {
-	t.Run("should return error for invalid image", func(t *testing.T) {
-		tests := map[string]image.Image{
-			"width not 128":            {Width: 1, Height: 128, Pixels: make([]byte, 128)},
-			"height not 128":           {Width: 128, Height: 1, Pixels: make([]byte, 128)},
-			"invalid number of pixels": {Width: 128, Height: 128, Pixels: make([]byte, 128)},
+	t.Run("should return error when font png is invalid", func(t *testing.T) {
+		var out [2048]byte
+		err := font.Load(make([]byte, 0), out[:])
+		require.Error(t, err)
+	})
+
+	t.Run("should return error for invalid image size", func(t *testing.T) {
+		tests := map[string][]byte{
+			"width not 128":  invalidWidthImage,
+			"height not 128": invalidHeightImage,
 		}
 		for name, img := range tests {
 			t.Run(name, func(t *testing.T) {
@@ -34,15 +49,13 @@ func TestLoadImageInto(t *testing.T) {
 	})
 
 	t.Run("should return error for invalid fontData", func(t *testing.T) {
-		img := image.Image{Width: 128, Height: 128, Pixels: make([]byte, 128*128)}
 		var out [1]byte
-		err := font.Load(img, out[:])
+		err := font.Load(validImage, out[:])
 		assert.Error(t, err)
 	})
 
 	t.Run("should override existing data", func(t *testing.T) {
 		out := makeNotZeroSlice(2048, 1)
-		emptyImage := image.Image{Width: 128, Height: 128, Pixels: make([]byte, 128*128)}
 		// when
 		err := font.Load(emptyImage, out)
 		require.NoError(t, err)
@@ -51,10 +64,8 @@ func TestLoadImageInto(t *testing.T) {
 
 	t.Run("should load pixels", func(t *testing.T) {
 		out := make([]byte, 2048)
-		img, err := image.DecodePNG(bytes.NewReader(testFont))
-		require.NoError(t, err)
 		// when
-		err = font.Load(img, out)
+		err := font.Load(validImage, out)
 		// then
 		require.NoError(t, err)
 		expectedChar0 := []byte{1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80}

font/internal/empty.png

@@ -14,6 +14,7 @@ import (
 	"fmt"
 	"io/fs"
 
+	"github.com/elgopher/pi/font"
 	"github.com/elgopher/pi/vm"
 )
 
@@ -108,15 +109,15 @@ func Boot() error {
 		return err
 	}
 
-	if err := LoadFontData(systemFontPNG, vm.SystemFont.Data[:]); err != nil {
+	if err := font.Load(systemFontPNG, vm.SystemFont.Data[:]); err != nil {
 		return err
 	}
 
 	if Resources == nil {
 		Resources = embed.FS{}
 	}
 
-	if err := loadResources(Resources); err != nil {
+	if err := loadGameResources(Resources); err != nil {
 		return err
 	}
 
@@ -162,7 +163,7 @@ func validateUserParameters() error {
 	return nil
 }
 
-func loadResources(resources fs.ReadFileFS) error {
+func loadGameResources(resources fs.ReadFileFS) error {
 	if err := loadSpriteSheet(resources); err != nil {
 		return err
 	}

font/internal/invalid-height.png

@@ -4,6 +4,7 @@
 package pi_test
 
 import (
+	_ "embed"
 	"strconv"
 	"testing"
 	"testing/fstest"
@@ -15,6 +16,9 @@ import (
 	"github.com/elgopher/pi/vm"
 )
 
+//go:embed internal/testimage/custom-font.png
+var customFont []byte
+
 func TestBoot(t *testing.T) {
 	const color = 7
 
@@ -113,7 +117,7 @@ func TestBoot(t *testing.T) {
 	t.Run("should load custom-font.png", func(t *testing.T) {
 		pi.Reset()
 		pi.Resources = fstest.MapFS{
-			"custom-font.png": &fstest.MapFile{Data: customFontPng},
+			"custom-font.png": &fstest.MapFile{Data: customFont},
 		}
 		// when
 		err := pi.Boot()

font/internal/invalid-width.png

@@ -4,14 +4,12 @@
 package pi
 
 import (
-	"bytes"
 	_ "embed"
 	"errors"
 	"fmt"
 	"io/fs"
 
-	"github.com/elgopher/pi/image"
-	"github.com/elgopher/pi/internal/font"
+	"github.com/elgopher/pi/font"
 	"github.com/elgopher/pi/vm"
 )
 
@@ -100,27 +98,6 @@ func (f Font) printRune(r rune, sx, sy int, color byte) int {
 	}
 }
 
-// LoadFontData loads font-sheet (png image) and converts
-// it to font data. Image must be 128x128. Each char is 8x8.
-// Char 0 is in the top-left corner. Char 1 to the right.
-//
-// This function can be used if you want to use 3rd font:
-//
-// myFont := pi.Font{Width:4, WidthSpecial:8,Height: 8}
-// pi.LoadFontData(png, myFont.Data[:])
-func LoadFontData(png []byte, out []byte) error {
-	img, err := image.DecodePNG(bytes.NewReader(png))
-	if err != nil {
-		return fmt.Errorf("decoding font failed: %w", err)
-	}
-
-	if err = font.Load(img, out[:]); err != nil {
-		return fmt.Errorf("error system font: %w", err)
-	}
-
-	return nil
-}
-
 func loadCustomFont(resources fs.ReadFileFS) error {
 	fileContents, err := resources.ReadFile("custom-font.png")
 	if errors.Is(err, fs.ErrNotExist) {
@@ -131,5 +108,5 @@ func loadCustomFont(resources fs.ReadFileFS) error {
 		return fmt.Errorf("error loading custom-font.png file: %w", err)
 	}
 
-	return LoadFontData(fileContents, vm.CustomFont.Data[:])
+	return font.Load(fileContents, vm.CustomFont.Data[:])
 }

internal/font/font_test.png renamed to font/internal/valid.png

@@ -147,30 +147,3 @@ func assertScreenEqual(t *testing.T, file string) {
 		fmt.Println("Screenshot taken", screenshot)
 	}
 }
-
-//go:embed internal/testimage/print/custom-font.png
-var customFontPng []byte
-
-//go:embed internal/testimage/print/custom-font-too-small.png
-var customFontTooSmall []byte
-
-func TestLoadFontData(t *testing.T) {
-	t.Run("should return error when font png is invalid", func(t *testing.T) {
-		font := pi.Font{}
-		err := pi.LoadFontData(make([]byte, 0), font.Data[:])
-		require.Error(t, err)
-	})
-
-	t.Run("should return error when png is valid but too small", func(t *testing.T) {
-		font := pi.Font{}
-		err := pi.LoadFontData(customFontTooSmall, font.Data[:])
-		require.Error(t, err)
-	})
-
-	t.Run("should decode png file into font data", func(t *testing.T) {
-		font := pi.Font{}
-		err := pi.LoadFontData(customFontPng, font.Data[:])
-		require.NoError(t, err)
-		assert.Equal(t, byte(0b00001111), font.Data[0])
-	})
-}